I like puzzles.  I didn't know that I would like my job when I started, but I consider myself lucky that I really enjoy what I do.

Last year I was working a team at a local commodities trading company that had fallen into mostly production support.  They had several new development projects that they wanted me to do, but they also inherited a large number of old legacy processes that were starting to break, about 1000 of them.  They just didn’t have enough staff to handle both and of course, fixing legacy apps always comes first.

I went to work for a small marketing agency.  They mostly did print and media ads, but had a small development team for their growing digital marketing campaigns.  They asked me to bring them up to speed on MVC and so I started by learning MVC myself and delivering a medium sized web in my first few months there.   While I was there I delivered a few medium web apps, and a few small web apps, as well as an in-house wiki (Foswiki/Perl) for knowledge sharing and automated deployments (Jenkins/java).

I fell in love with MVC, and was able to get up to speed quickly based on my previous two years working with the MVVM pattern in WPF.  I actually found MVC Model binding simpler that WPF and page actions easier to use than WPF Commands. 

I designed one of the medium sized and all of the small web apps from beginning to end, from requirements gathering and database design through to testing and maintenance.  The largest of them had three phases of delivery over nine months using prototypes and waterfall design methodology. 

Before that I had five years of project work in the commodities group of that local company.  I was a contractor and worked on four different teams while I was there, getting my six month contract extended for the entire five years.  One team was of a dozen developers, and others with only a few. 

The first team I was with was the largest one.  We had over  a dozen devs at one time, and a large enterprise web application and database application to support and enhance.  I was tasked with delivering an issue tracking system of any sort that would be better than emails and spreadsheets.  After some research on all kinds of options from writing my own to implementing and customizing an existing free app, I settled on Eventum, which was a mature, open sourced PHP webapp written by the MySql team.  This went over extremely well, and I extended and customized it over the next couple of years as it expanded to several other teams besides ours.

In addition to that, and writing the legacy enhancements and bugfixes for my two years on this team, I had another cool project that I wrote mostly on the side.  We had TV screens on the walls, and my boss wanted to see metrics of all of our systems on one of them.  I used a single .net web page and used some Dundas charts and gauges for the front end, but the back end was a bunch of multi threaded calls to over twenty different data stores, each with different caching schemes and data interfaces.

My last couple of years there were spent doing double duty leading two small teams of two to four developers.  I rewrote a medium sized enterprise database application of 20k lines and delivered a WPF application to move all maintenance from IT to the business users.  Basically, I let them update their own data, with authorization, and auditing.  Updating their own data had been a complicated, manual, multi step process that took a few days  and required a coordinated effort with a business user and an IT resource.  I automated this process, and gave the business users the tool to do it themselves.  Although the database wasn’t a rewrite from the start, after two years of constant refactoring I had trimmed the original stored procedure codebase in size to a third of what it was and converted a mess of duplicated spaghetti code to an extensible, documented, and easily maintained set of procedures.

The other team I led supported the process that extracted data for a vendor data warehouse.   It was a small data store, in the realm of 250k rows, but it involved again a series of manual, complicated steps for an IT resource to follow perfectly every time it was requested by the business user.  I automated the extraction process, and delivered again a WPF application for the user to control the extraction, with logging, and even history, so that they could go back to previous extractions.

One time I inherited a system of sorts that supported a single user, with her third party data warehouse application.  We didn’t support the warehouse, but we were supposed to get the data extracts that she imported into the warehouse at monthly intervals.  The existing IT process was very manual, and very time intensive.  As well as involving data from 4 different sources and the queries or processes to get them, it involved a dozen files per run, sometimes up to three people from different departments, with several runs per month, taking four to eight hours each run, and no history or state tracking except to keep the files in folders forever. 

The initial attempt to automate this also left behind a number of files and processes to maintain, and it had been running for over a year with 60 monthly man hours of IT dedicated to it and now several hundred files, folders, and processes in assorted locations.

This is one of my favorite jobs.  People put a mess in front of me and I turn it into something easy to use that saves time.  One of the things that bugged me about the existing process was that there was no history and it took too long.  I expanded our small database to include tables for each of our entities, and started automating the extracts in a nightly process.  This had the effect of making the user’s request time drop from several hours for the complicated queries to almost instant since we were now caching the data ourselves, as well as provided an easy way for IT to hook into historic runs. 

Another thing that I wanted to change was to streamline the steps.  The existing process exported from data sources, inserted into databases, extracted into files, joined with other datasources, imported into databases again.  So I built an SSIS package that did the data transformations on our Oracle database and inserted the data directly into the warehouse MSSQL server.  This removed the need for the files and a whole staging process, and made the whole process easier to maintain from an IT perspective.

Another thing that I wanted to change was to remove the IT resource component.  I don’t believe IT needs to be involved for day to day business operation requests, unless something breaks.  So I built a simple WPF click-once intranet application with a handful of features, enabling the user to run the whole extract/import instantly for any date they choose, and even view the data by Excel export if they want.  I like that it not only provided so much convenience for the user, but that it dropped the IT cost to maintain from an average of 60 monthly man hours to almost zero.

One of my least favorite projects where I had control over the outcome was my first WPF project. I had been doing aspnet web apps and winform apps for a few years. I hadn’t really learned a lot about patterns or architecture, but I was exposed to a senior consultant who had a particular effect on me. Under his influence, I started to open my eyes to new technology. I realized that I needed to accelerate my learning or my career was not going to go anywhere.

So among other things, I tried WPF for my next project instead of Winforms. The problem was, that I applied the event driven, static design of Winforms to WPF and it was not built for that.

Once I had invested enough time in the initial design and started to hit my first roadblocks, I realized that WPF was built to work against a pattern called MVVM, and I didn’t want to learn a new pattern on top of a new framework. I kept hitting roadblocks in UI development and each time I found solutions were always in MVVM and so they were not available to me. I ended up writing lots of hacks and disorganized code instead of learning about MVVM.

I delivered in nine months but it was a long nine months. My immediate next opportunity was a small deliverable, and I did that in WPF while learning MVVM, and realized my mistake. I was amazed at how easy it was if I used the correct pattern.  New technologies are as much, if not more, about patterns as they are about the nuts and bolts.