Systems Design and Management
Windows Server 2003 to 2012 Migration
Documented, managed, and personally spearheaded an effort to replace more than a dozen active Windows 2003 servers with 2012 versions while running against Microsoft’s end-of-life deadline. The affected servers included web servers, application servers, and database servers. During the migration process we were able to remove many redundancies, increase performance by taking advantage of new features, and replace our physical server farm with mostly virtual machines.
Shared Object Caching Service
I reviewed the existing system of local server caches for application data then researched, documented, prototyped, and implemented a customized shared caching solution using NCache technologies. Implemented many performance improvements in various applications and services to take advantage of the shared caching. In some cases, we saw a 6-times increase in performance over querying the database server.
Continuous Integration Services
First, I spec’d, built, documented, and maintained a continuous integration service using CruiseControl.Net that interfaced with: a source code repository (reads and writes), networked file system (through PowerShell and Batch scripts), and an IIS installation. Services it could provide included: compiling DLL libraries, deploying Web Applications, automatically migrating updated files from the source code repository, and running NUnit tests. Later, after promoting and demoing Team Foundation Server I converted the tools to that system along with converting the project management database from Axosoft.
I’ve set up and used the following monitoring or analysis tools:
- Microsoft System Center Operations Manager – including custom monitoring such as for Windows Services.
- Web Metrics
- Google Analytics
Planning & Writing
I was asked to evaluate and adapt an existing RFP proposal for an enterprise level medical records management. The original proposal was based on Java and a LAMP stack, but needed to be adjusted to Wintel due to client requirements. I helped convert it to .Net and included integration points with SharePoint, BizTalk, Forefront Identity Manager, SSIS, OpenFax, and Avaya. My proposal included diagrams of the data connections, infrastructure requirements, and high-level user models.
Documenting a Solution
One particular documentation task involved the transfer of IP for a large web application and database project. The new team that would take ownership of the project needed documentation both for end users and the development / support team. In this case, while I was the project manager for the application’s development I did not actually develop the application. I wrote over a dozen documents detailing such aspects as:
- Database Schema
- Shared Classes
- User Interface Standards
- Naming and coding conventions
- Processes such as setting up development stations and deployment scripts
I’ve written over a dozen whitepapers for the DATArrive application detailing specific application modules, shared features, and configuration options. Each whitepaper consisted of both technical and layman text.
Functional Specifications and process Documentation
The majority of my technical writing has involved functional specifications, responding to RFPs, or documenting processes. Some highlights:
- A point-by-point disaster recovery plan
- A deployment process document describing point-by-point code and database deployment steps
- Multiple other standards and procedures documents
- Original RFP responses including estimates, timeline, screenshots, and custom Visio process diagrams
- Functional specifications for new, contracted client development including use cases, Visio workflow diagrams, and report mockups
- Statements of work describing a proposed new application including business rules in Visio diagrams, UI mockups, and data schema definitions.
DATArrive is a massive, software-as-a-service, line of business application. It includes web and mobile front ends, a SQL server backend, and numerous standard and custom integration points. Modules include time and labor management, inventory control, inspection systems, delivery services, and more. I was the system architect as well as the lead developer and database administrator.
Some of the features implemented by me include:
- Third party UI tools, such as interactive grids, calendar controls, and combo boxes
- AJAX and the MS AJAX toolkit implementations
- Numerous web service implementations and interfaces
- Microsoft Reporting (local RDLC reports)
- LINQ to SQL
- Custom database abstraction layer
- AJAX-enabled mapping tools using Mapstraction, OpenLayers, Open Street Maps, and various geo-location web service APIs
- CSV-based data importing and exporting tools
ADAM Web Management
The business used an Active Directory Application Mode (ADAM) repository for managing a subset of their entire user base. They discovered a need to easily search for users, run reports against the user store, assign and remove groups, and otherwise manage the users in the store. The resulting web application provided all of those functions using an AJAX-enabled web form. One interesting challenge was the requirement to handle 50,000 users within a specific OU with a single command.
SLATE is a web-based lesson management system that was initially built in 2004. The unique thing about this application is that it was custom built for a not for profit organization supporting the blind and visually impaired. As such, the application needed to apply tremendous care to include necessary tags and titles to allow for text-to-speech screen readers as well as a flexible CSS style sheet that would allow users to significant magnify the text size without disrupting the overall design.
I needed to implement a more secure and streamlined web service application. This involved:
- Mandating SSL transport
- Implementing custom basic authentication
Forcing SSL was a very simple process, but custom basic authentication took more effort. The basic authentication that comes with WCF is automatically tied to Windows accounts. Since this was a software-as-a-service implementation providing users with Active Directory accounts would not work. The solution involved extending the UserNamePasswordValidator class.
XML over WCF
I’ve found that many web service providers that come from a Java environment often prefer to send XML over web services rather than use parameters. Since the XML data type is not available as a WCF method parameter this meant I’ve had to expand the WCF service by creating custom service contracts that take the entire message body as an IO.Stream then convert the stream to XML before processing.
Web service client with certificate signing
I always try to give myself extra time when working on projects that involve communicating with another organization’s APIs and web services. In one case, I was particularly glad I had the extra time because at the last minute the service provider threw in the mandate that the message body of the request needed to be signed using an SSL certificate. This threw the project into a twist because by default WCF does not sign a message body, just the message header and the pre-built options that do allow message body signing not only also encrypt the data (which was not allowed in this implementation) but would not work over SSL. Another problem occurred because the WCF output generated a mustUnderstand=true attribute to the results that errored on the server endpoint. The final solution I came up with had three key parts:
- Implement a custom binding using MutualCertificateDuplex as the authentication type
- Modify the service declaration with the appropriate Net.Security.ProtectionLevel values
- Create and apply a custom text message encoder as part of the bindingElementExtensions
Infinite self-referencing hierarchies
The application allowed some data objects to be defined in a self-referencing hierarchy. Many times, the service needed to know information not only about the immediate parent record of a row, but also about the top-most parent. This can be tricky to implement so that queries perform quickly. In the end I:
- Created user defined functions with Common Table Expressions (CTE) to navigate through the hierarchy and output the primary key of the top level parent
- Added a calculated field using the function to tables and views as appropriate so the data could easily be joined
Massive Logic Procedures
The implementation allowed individual companies to define very complex business rules revolving around overtime calculations. For example, a set of rules might include many, many logic points such as: over 40 hours in a week should be overtime, over 12 hours in a day should be double-time, during holidays treat regular time as overtime and overtime as double-time, apply different rules based on the shift worked, exclude certain employees or tasks from overtime, if the worker has worked seven straight days in the week all time should be overtime or better, and so on. Evaluating and processing these rules occurred at many points in the application that may not have involved specific user actions including triggered actions from inserts into a database table. Using SQL alone the process was slow and inefficient to the point that processes could not keep up. As a solution, I:
- Moved the logic to a Common Language Runtime (CLR) custom stored procedure. CLR objects perform much better against logical operations than SQL
- Implemented a Service Broker solution that accepted the data into a queue for offline processing. This not only allowed data to come at maximum speed with the processing occurring in another thread, but it allowed multiple threads to operate simultaneously against the same queued list rather than the original sequential processing
Database Redundancy and High Availability
I’ve set up SQL Server maintenance plans including:
- Running full, transactional, and differential backups
- Clearing out old backup and log files
- Calling PowerShell scripts to sync folders with Amazon S3 buckets for offline backup
- Reporting available disk space and other system values
I’ve also established SQL Database Mirroring and built and maintained replication schemes:
- High availability
- Witness server
- Monitoring mirroring and alerting
- SLQ Agent Jobs activated automatically as a result of a failover
I’ve also customized Transactional replication, including
- Merge replication
- Snapshot replication
Calling Web Services from SQL Server
As part of a client-requested feature I needed to pull data from a web service periodically in order to populate and update “almost” real-time data. Web service implementation using SQL Server was possible using CLR objects. The biggest challenge was that such an implementation required a manual installation of the web service binding DLL each time the application was deployed. To make this simpler I built into the deployment process scripts that would transfer the appropriate DLL after building and then re-create the appropriate assembly reference.
- iPhone / iPod Touch Mobile Payment System – For this credit card terminal plus inventory management application I wrote the initial code for the technical proofs before managing the development team who wrote the bulk of the application. After deployment I acted as the maintenance developer
- Mono (Xamarin) for Android Labor Tracking Application – This application communicated via secure web services to the backend application. Once again, I built the technical proof before managing the development team who continued the application
- Windows Mobile 6.5 Proof of Concept – I build a proof of concept application for Windows Mobile 6.5 that would allow users to activate their installed application via a license key, log into the application using a user name and password, and see their assigned projects for the day
- Web Formatted ASP.Net Pages – I’ve build numerous web application interfaces for mobile devices. This includes the old-style System.Web.UI.MobileControls based ASP.Net mobile tags
- Email linked list using an SMTP endpoint
- Custom workflows using MS SharePoint Designer
- Extended the application to Internet users using custom authentication
- Implemented User Profile and Search features
- Integrated Reporting Services and TFS
Credit-Card Based Subscription management
- Through an HTTPS enabled web application Using Authorize.Net
- Subscription management for adding and cancelling monthly subscriptions