« Glossary of OO/MDA terms | Main | 1.0 Basics of Class Modeling »

November 09, 2004

Introduction to the weblog

This weblog contains my (H. S. Lahman) ruminations on a variety of topics related to Object-Oriented (OO) software construction in general and Model Driven Architecture (MDA) in particular.  In particular the blog deals with translation where code is fully generated automatically from Object-Oriented Analysis (OOA) models (aka MDA Platform Independent Model or PIM).  Though the focus is on translation, much of the OO material is applicable in some fashion to OOD and OOP as well.  My primary goal is to describe why good OO practices exist and should be used.  There are a gazillion good books that describe how to express one's software solution in bubbles & arrows or 3GL code -- the purpose of this blog is to describe how one arrives at the solution one needs to express in some notation.

Though I am in the process of writing a book on the subject matter, progress there has been rather glacial and Pathfinder Solutions saw value in getting previews of that material for their customer base.  The source of the blog material is actually primarily from my participation on various online newsgroup and mail list forums rather than the book itself.  The subject matter is much the same as the book but the blog represents more of a Joycean stream of consciousness approach.  It is also easier for me to cut & paste the posts with minimal context editing.

The blog was only started in June of '04 and the content is added sporadically, so the content is somewhat limited at present.  Since it is triggered by essentially random eMail discussions it is also rather disorganized.  Sorry about that.  To help alleviate that I have provided categories and some ordering of posts.  These categories appear in the left margin of this display.  The best way to navigate the blog is through the categories that are on the left margin of the main blog.  These are usually pretty self-contained and require only a vague familiarity with OO development.  So the ordering of categories is not terribly critical.

Within those categories, though, it is usually a good idea to proceed in an orderly fashion.  The weblog's default ordering is chronological but that doesn't work well when posting is sporadic and based on online forums.  So I have employed a numerical scheme in the post titles that can be used to traverse them in proper order (lowest to highest).  Perhaps more useful, I have placed a hyperlink to the next/previous posts at the top and bottom of the posts themselves.

The principle categories so far are (with links to the first post in the category):

Application partitioning.  This is probably the most important single activity in developing large applications.  The posts in this category describe the basics of doing this properly.

Books.  I am often asked for recommendations on books and these are my thoughts on the matter.

Glossary.  This is just the definitions of the terms that I use frequently within the blog.  Most of the definitions are pretty standard but some are unique.

Invariants and parametric polymorphism.  Invariants are crucial to large scale reuse, simplifying code, and, consequently, improving reliability.  Parametric polymorphism is probably the most powerful tool in the OO developer's arsenal for solving customer problems and abstracting invariants -- despite the fact that inclusion polymorphism tends to get most of the press.

Legacy software replacement.  This category discusses issues related to replacing legacy software in an OO context.  It provides an approach to doing so that reduces risk and allows proper project management.

MDA in general.  These posts provide a brief overview of MDA and how it relates to translation.

Object state machines.  A basic discussion of the use of state to describe behavior responsibilities in OO software.

Persistence.  This category discusses how one deals with persistence in applications that are more than CRUD/USER pipeline applications.  It also discusses some fundamental differences between the OO and Relational programming paradigms.

Processes.  Too often programs are developed without enough attention to the processes that surround the intellectual exercises.  The category contains a pot pourri of techniques like object blitzes.

Relationships.  This is a discussion of the basics of OO relationships between classes with some tips about how to abstract them properly.

Testing and Defect Prevention.  Some posts about why I think software quality will be the next major competitive advantage and why software shops can't afford to play catch-up.

What is OO development all about?  These posts are intended to provide a basic understanding of what OO development is all about, why we do it, and when we shouldn't do it.

Technorati Profile

Posted by HS in Introduction to/root of the weblog | Permalink