Great Myths of Software Development

We will look at 3 Great Myths in this post.

1. Objects cannot be expressed with tag based markup.
2. Design Patterns are patterns
3. High Level Languages are not pragmatic

Myth 1: Objects cannot be expressed with tag based markup.

Objects exist after a compliler has translated class based text code into compiled classes that are created as instances in running software. ColdFusion in version 6 introduced it's development community to standard objects based on the common code of that version. Historically we see that most languages create objects with script based code but this is not always the case. There are many types of objects out there. One of the most common type of ojbects is known as DOM these are the objects created with HTML markup. Language libraries like EXTJS seem to have found sweet spot solutions for letting JS developers create DOM with script. Both seem to work well and it is mostly a matter of style.

Now with that said, the JS vs HTML dom objects are equal. As time has passed and we have learned there are ways to design objects that interface together effectively. In electronics technology there are messaging packet standards that allow these physical entities to communicate with each other via messaging standards. They still need common interfaces but the messaging packets are essential. In software we tend to focus more on interface and the developer has to know more about the unique message packets they send in and take out. Because of this we find that one thing that makes integration more reliable is Unit Testing. Over time we have learned that Unit Testing is a two point test. We must test input and output. In reality Unit Testing doesn't care what goes on inside an object as long as it accepts the input and when appropriate returns the proper output. When we look at tags vs script again there is not change here in which is better.

Myth 2 : Design Patterns are patterns

Design Patterns are better thought of as generic principles that solve generic problems. There is a great deal of confusion that comes from the belief that design patterns are like a mold used to cut out holiday cookies. Principles don't change but the implementation of the principles does from one use to the next. If we add red to a white cookie we get something on the scale of pink to red. If we add it to a blue cookie we move to purple. That is just a principled illustration and like design patterns it only illustrates the difference between the cookie and the color. Design patterns are great things to understand and there is even a pattern called Anti-Pattern. This is not a specific pattern but the principle of learning where design patterns work wrong and make things worse. Therefore we can see that the study of design patterns is not meant to be rigid but a relaxed use of principles to improve software through good understanding of ways object oriented code can be created.

Myth 3 : High Level Languages are not pragmatic

Funny is the chant of a Java developer who would chide a high level language like ColdFusion. Then he turns around and promotes Spring or Hibernate. Often low level languages are so daunting that they create high level libraries to encapsulate common processes. A high level language is just a language that has these type of features packaged not only as a library but integrated into the commands built into a platform. If the language remains extensible and allows continued encapsulation like the lower level languages then it is actually out of the box the most pragmatic solution to be acquired.