It was roughly a year later after my first IT related article for the Visual Basic’s Programmer Journal that I decided to bring my real time debugging design to the ‘hard core’ world of C/C++. I wrote a new design and had it published in another major magazine of the times: Microsoft Systems Journal (now known as the MSDN Magazine). Even in this world, the core principles, in all their complexity, those foundations essential to debugging issues, were being ignored by a vast majority in the application industry, so I set out to help with that and try to make thing’s easier for everyone.
Spiritually, it was also the time I began to formulate myself into the ‘matrix’ if you will, the time when I could start visualizing the world through code, that how, what I was developing, the applications themselves, where nothing more then individuals; little virtual beings to our biological forms. Very crude forms, but I could see the continued patterns of design that related between the real world and the virtual. I remember the first few times trying to explain what I saw to those around me, how thing’s should be developed, but my visions were way too far ahead of its time and I lacked the tools to effectively deliver what I was trying to say.
During this time of my life, COM (Component Object Model) and N-Tier development was resonating deep within me. I understood the need for using much simpler, singular runtime objects in application designs. That the code written, the applications and all its parts needed to be broken down into much smaller pieces. Those pieces needed to do a ‘something’ instead of ‘everything’. The complexity that was (and still is today), needed to become smaller and more manageable. Even more adventurous was the advocating I did around trying to harness the power of scripting techniques; used to speed up development time and invoke dynamic runtime performance variables that could be changed without recompiling the application. Application developers, managers, other stake holders, even today this is a chore to try and get them to understand the long term benefits, let alone back then.
I was first introduced to these design techniques during my study of game engines and the industry as a whole. I always found those in the game industry pushed the boundaries in software and hardware development faster then anyone in the application field ever could (this still holds true today). The reasons for this are obvious, the breadth of technologies, knowledge and patterns that one needs to understand, the types of people that need to come together for a game creation is incredible. Anytime something simpler, more efficient or just outright common sense catches my mind, I’m off to the races. Back in those times, the number of books I amassed and poured through from the gaming industry amounted to a small fortune. I was always looking for better ways to develop and debug applications and the gaming field gave me what I wanted.
So much that could be done, but time wasn’t on our side, the industry wasn’t ready. Remember, this was a time in our history when the dot-com bubble was in full swing (although, when the article was released, it was fairly close to bursting). It, along with all of us in the magical bubble, had all been riding high on the hopes of many; the many that should never have been in the game to begin with. But the allure of instant money and celebrity status conjured up smoke and mirrors that drew every kind of person into this field of commerce. It was happening at such incredible rates of speed that proper architecture, the right types of educational training and the more simpler-advanced infrastructures never had the chance to be achieved correctly. The demand for coders, designers, anything IT related ran high and the money flowing to Consultants and companies was a river of endless wine. Everyone was drunk and with that, all the signs of imminent failure were ignored.
Application after application was designed, thrown over a wall and the next was started. With no sense of runtime monitoring for these applications as a first class citizen in their design, you had a better chance at surviving in a straw house during a hurricane. Debugging was done at development time and any problems that occurred were dealt with in a reactionary manner. If we were lucky, old school log files existed with some type of print outs that hopefully identified the location of code.
This style of design has continued right up until present day; only in the last few years has the area of DevOps and DataOps been starting to get the recognition it needs in the overall development of any application. The good note is, the industry is starting to realize this and now it’s just a matter of each developer sharing the knowledge to another. Once that happens, proper attention will be given to it’s need and the benefits one can reap from mining runtime data will finally been seen throughout all levels of management as a first class citizen and be required in all existing and future designs.
Feel free to send e-mails for general discussion or other topics of interest.