Last year I was presented with a problem. A problem that could, in my mind, only be effectively solved using an application. Software designed to accept input from a reporting system’s output in different formats. The goal, was to take all of that information, calculate the specific data that wasn’t generated by the reporting system and provided the line of business’ key performance indicators (KPIs).
The tool that I developed went through a number of iterations because it had been at least 10 years since I had programmed in Visual Basic 6 (it may have been Visual Basic 5, admittedly my memory isn’t that good on it since the software environment was boring) for Computer Science class in high school.
On that subject, I need to apologize to my CS teacher, Mr. Stromberg, for not paying more attention in his class, but admittedly the course materials were very dry and not very interesting. It also didn’t help that we were programming applications that I couldn’t sink my teeth into and felt like there wasn’t a truly useful purpose.
This project gave me a purpose.
The initial version only calculated one KPI as it used data from a single report provided by the chat service provider, but quickly it was made a priority to integrate an additional report to gather 3 additional KPIs. Then another KPI was tacked on which included another report.
The application was evolving slowly, with an initial push while adding functionality to try and add some ‘safety’ features to reduce user error issues. We often had end-users trying to use the wrong source report or settings when generating it.
I was asked to add additional features over time, but it was quickly becoming apparent that I was pushing the envelope too far and Excel was pushing back, at least, due to the overall application structure.
The software was ‘monolithic’ in design with some modular capabilities, but it was missing the boat since a lot of it was a cludge. My coding was already looking like a disaster to me since I had been steadily learning more. Meanwhile, I was being asked to add in more features and the program was crashing more and more often.
July came around and I started developing a new design with a concept focused on modularity and ease of use. It also began the separation of application functionality and user interface. Work on the UI ran into a brick wall with my inability to figure out how to use the multipage control. I kept working on the modular design and did some testing with other interfaces, but I knew that it was critical to provide those who use the application with a wizard-like UI.
As someone who has used a variety of software from the simple and easy to the complex and difficult, my application was shaping up to be straight-forward, but without any additional instructions for the end-user to make things easy to understand, they’d most likely continue to encounter problems with the report generation phase which required them to use someone else’s web interface to request the chat system to generate the data.
August came around and I got fed up with the current iteration of the application, so I made another push and got the interface working with the multipage control and the basic functionality (enough to match the current tool on it’s basic operations).
When October rolled around, I had managed to add instructions to the tool finally and began integrating a report format for another line of business. November came and I had to write a report for yet another line of business, based off of the tool I had wrote. This resulted in three days of hardcore programming, which included some fixing and code structure changes to make the application overall a more efficient design.
Just to give you an idea, I was using Do loops with boolean statements triggered by counters in the original design and continued into the new UI. With the overhaul for the new line of business, I switched to For loops that would simply roll through a range and generally were used in specific sub routines. A number of other changes were integrated under the hood to make things operate more efficiently.
A later revision gave me the opportunity to integrate security measures that also doubled to make the application as a whole function in a much more streamlined fashion. I started removing global variables, utilizing encapsulation, shifted procedures out of class modules that really shouldn’t have been there in the first place and included additional documentation to allow others to easily pick up the application and work with it from a code perspective.
In any case, I hope to follow up this post with a bit more detail on my code and what the end results of my learning were.
