Burning Bird has posted The Parable of the Languages. It tells the tale of a group of programming languages, each with similar gripes and complains, banning together to defeat the eternal thorn in their collective sides. Well worth the read.
October 9th, 2002:
When I posted an entry regarding my upgrade to MovableType 2.5 I neglected to realize that one of the changes in the upgrade was that TrackBack pings are now sent via POST and not GET. My LiveJournal syndication script works via the TrackBack protocol, but was set up only to accept GET data. This is why the empty entry was made into LiveJournal. If it isn’t obvious by that, my LiveJournal syndication script is merely a quick hack, and doesn’t have even basic levels of error checking. It has been corrected, however, and this post should syndicate just fine.
Ben and Mena certainly deserve praise for their hard work. Regardless of what anyone says, good or bad about it, it certainly has swept the blogging world off its feet. But in my opinion, it seems that perhaps 2.5 was rushed out the door in order to release something on MT’s 1st birthday, as opposed to waiting until the release was worthy.
MT 2.5 includes default template changes that incorporate Mark Pilgrim‘s website recommendations from his online book, Dive Into Accessibility. This is a good thing as new users will most likely tweak the default templates and therefore slowly make the web more accessible as a whole. But, for those of us who are upgrading, this means nothing, as, those of us who are willing to follow Mark’s guidelines in their site design will do so, and those who aren’t certainly aren’t going to throw away their MT templates to use the new defaults.
MT 2.5 includes the code from the MT-Search plugin that many MT users installed. This seems like a good change. Search capability is a good thing, and having this embedded in the code only makes MT more featureful. MT-Search before now, was merely a hack. The templates didn’t integrate into the MT User Interface, the configuration settings were in a separate file. It really wasn’t a plugin at all, but merely a whole new script that used the MT API. I was excited when I heard it would be included in the next version of MovableType because I wanted it to be tied into MT better. However, it seems Ben and Mena just threw it in there at the last second. The templates do NOT live inside the MT User Interface. The search capability is not tightly integrated. The only real difference is that the configuration is now done in the main MT configuration file, and not in its own. Big deal.
Trackback auto-discovery has been implemented. This is a good thing. And it seems to be done correctly. I haven’t had a chance to use it yet, as many MT installs, like mine, don’t enable Trackback.
The ability to ping blo.gs, as well as any other weblogs.com compatible XML-RPC ping accepting server. This is a good change, and one that I had hacked into my old version of MT.
The keywords/metadata field was added. This is a nice addition for making a users MT install more searchable, but not really something to jump up and down about. If the keywords aren’t found somewhere in the entry text, they probably aren’t valid keywords anyway. Search engines started realizing this a few years ago and began ignoring keywords all together. I doubt many users are going to get tons of extra functionality out of this.
Localization is good. But it means close to nothing to the existing userbase.
The release isn’t spectacular, but it does have some good points. Maybe I’m just really pissed off about the Search templates not being embedded in the UI like everything else is. Maybe I was just really hoping for comment reply notification and threaded comment views.
All in all, if you’re using MT already and you have MT-Search installed, the upgrade isn’t worth the effort. If you’re a new user, there certainly isn’t anything wrong with it that should cause you to scour the Internet looking for an older version.
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.