revjim.net

Sometimes it amazes me how the mind works. It's amazing how, people in completely different circumstance, with completely different influences, can come to the same conclusion over time. It's also amazing how, even with formal training, those conclusions are not mandated.

First, some background. I've had no formal computer programming training. Everything I know I taught myself through trial and error. I've had some influence from others but, even then, the most influential were also not formally trained. I worked various jobs: Amateur Programmer, Macintosh Programmer/Network Admin/T-Shirt Printer (yes, believe it or not, that was my job function, and I got paid $4.50/hr to do it), Technical Support Rep, Access Database Programmer, Web Site designer, Web Programmer, Web Application Developer. Through this time-line of about 7 years I've learned several languages, several operating systems, and I've changed my design philosophy many, many times. I'm sure, before this life is over, I'll change it again.

Over the past 2 years or so, I've begun to adopt a design philosophy of my own design. It involves three parts: Input, Processing, and Output. Each portion of these parts, can, in most cases, be redivided into the same three parts. Input is the act of gathering data. It defines what is being acted on, what the parameters for that action are, and what should perform that action. Processing is the act of performing that action. This involves database queries, XML-RPC method calls, executing system commands, and any other task to perform the requested action. Output is what the user sees. This is the final stage in presentation that formats the data that resulted from the requested action, and displays it to the user. This is a philosophy that, while I'm sure has been influenced slightly by other software packages, and code that has crossed my desk, I have come up with on my own, through trial and error, based on what seems to be the most efficient (not in terms of the computers resources, but in the use of my time and energy).

Here comes the part that amazes me. This philosophy, this set of unwritten guidelines and rules that I've made for myself through trial and error is the same set of guidelines and rules that many people are taught in programming theory classes. It works best with Object Oriented programming, and therefore, is often used by Java developers. It is called the MVC method of object oriented programming. MVC stands for Model-View-Controller and just uses different words to describe the same method I have devised.

For some reason it never once crossed my mind that, someone else might employ the same practices that I do and that they might be being taught all over the world in every OO Theory class available to mankind. It makes me start to wonder, however, if it would have done me any good to attend an OO Theory class. I have an employee who has a Masters degree in Computer Science. He knows Java very well, has programmed many applications (not for me) in it, and, I'm sure, has sat through many OO Theory and Design classes. Yet, for some reason, these design principles are not evident in his work. In fact, his work tends to be of the brute force variety: do whatever gets it done the fastest, and fix the bugs when the occur. Therefore, even those who have had this philosophy suggested directly to them, or even forced upon them in a learning environment, don't always adopt its practices. Does that mean there is a better way, and these formally trained individuals are taught something better, or arrive at something better in their training, or is it merely a matter of having the right mode of thought? If I had had formal training that suggested this method, would I have adopted it, or would I have continued on my own path eventually arriving here anyway? And if I had adopted it, would I have discovered something even better by now?

It really is amazing how the human mind works. All of this leaves me wondering how many other people are out there sharing the same philosophies that I do on many things, both of us having arrived at the same conclusion, and yet neither of us knows it. It also makes me wonder if there isn't an even better method toward programming easily modifiable and extensible applications.