Internal tool to enforce proper code rolling between year-specific code bases in C# and Oracle.
- An internal tool created to add a validation process for handling code rolling between different yearspecific codebases. Prototyped and developed to initial version in a week as an intern. Personally maintained the tool as part of role responsibilities and later mentored an intern as they made major upgrades to the custom analysis library of the tool, enhanced the UI, and added additional features requested by the design team.
- Tool is ran as part of each check-in build in each branch to verify that all code is rolled correctly and that the checked-in code is always in a good state.
- Usage of the tool has reduced missed code rolling that would have previously had to be caught during a code review. This has been increasingly successful in the turn-around time on hotfix tasks in particular by finding errors sooner and mitigating risk by reducing human error.
Mapping data married with CIMS data in a smart data-entry UI.
- Due to government regulation changes regarding reporting acres on policies, this project was created to implement a new entry UI and modify existing entry UIs to allow for reporting location information more easily.
- The new entry UI uses CIMS and in-house mapping data to provide a look-up for each entry as well as input validation. It was designed to work with existing agent needs and workflow for acreage entry.
- Beyond the new UI was major restructuring of existing mapping services to integrate the new UI, the new match making for policies to GIS data, and improve performance where possible.
- My role on the project was to handle everything related to CIMS (data queries, validation, lookups), the entry UI (custom controls, presentation enhancements), and code review for the architect on the project. Most of the UI enhancements could be reused elsewhere with minimal changes.
CIMS data warehouse with dynamic request/import.
- Conversion from a process using two separate tasks that had deadlock and other performance issues to adding CIMS build procesing to an existing multi-threaded WCF service.
- Service was designed to handle iterative processing and requesting, importing associated CIMS data with transactional integrity, sudden service shutdown, and then restarting the build in the proper place.
- Consolidated existing data from multiple Oracle database schemas into a single consistent schema, converting all relevant data into the new format. All year-based data was stored in the same tables with proper indices for improved data retention and query performance.
- Singular data warehouse reduced complexity and improved data consistency/retain-ability.
Ineligible tracking system with improved data request/import processing.
- Restructuring request and data import process due to government regulatory changes over the course of a five month timeline.
- Worked with government contractors, program managers, and company staff to improve the data request and import process used for all AIPs.
- Improved service performance to match the same structure as the CIMS rewrite. Improved processing performance and reliability of the service.
- Recommended and implemented approved enhancements to processes using the ITS data to improve user experience and productivity.
Document Generation Framework
C# on-client and on-server request-based document generation framework.
- Single-threaded client-side and multi-threaded server-side implementation of a document generation framework that outputs the final results in a PDF format using specific libraries based on platform due to licensing restrictions.
- As an intern, assisted in the transition away from a PDF-template driven system into a code-only solution that allowed for more reliability between documents and removing an unneeded middlelayer that added complexity in development and process management. My efforts and feedback to the architect in charge of the project shaped the initial version of the new framework as well as influence design decisions on future iterations.
- One of the highly-used Agency facing documents was having an execution timeout and out-of-memory issue. After two other developers with more senior positions spent fifteen hours each on attempting to determine the issue, I was given the task and delivered a working solution in six hours with a final solution implemented by ten hours. This required debugging skills and thoughtfulness of the entire framework to determine the core issue, resolve it, and not introduce issues in any of the other eighty documents.