Design Patterns released November 2006. Here is the synopsis:Adaptive Object Modeling is a relatively new concept in object oriented design
that has found some roots in advanced development processes. It allows that
applications are in continual flux (or their requirements are) from adjustments
to business rules, environments and user requirements. It's precepts are that
using metadata for business objects, rules and process flows, instead
of hard coded, static method code, makes the application more flexible to user/client
needs. The AOM design model also requires that certain domain 'facts'
are maintained, i.e. that there are controlled interpretations of the effects
of the 'immediate' changes from user-generated metadata.
Adaptive solutions offer us a way to make applications more configurable (regarding
workflow) to the end users. It is not a 99% solution and, to my knowledge there
is no end-to-end solution that meets all needs, simply because those needs are
more directly defined by the business requirements. However, since business
requirements change frequently, writing immutable code flow logic leaves very
short lives for code. Even the online industry is feeling the need to configure
dynamically: if you are a subscriber to most web portals like Yahoo or MSN you
have a user configurable home page where you can decide which items of interest
you would like to display on your page. Most portal technologies are indirectly
pointing us to a more adaptive model, simply because they are configurable by
end-users or power-users.
I see adaptive technologies like Adaptive Object Modeling in the same light
as a web portal: some functionality is needed to be coded by developers, like
database and business logic, but where and when this logic is implemented should
be (following business trends) decided upon by business experts, not developers.
Some adaptive models incorporate the non meta-data into their models tightly
coupled with their meta-data, which is one way to do it, but I prefer to let
the EUD (end user developer) have the hand in how business data is handled,
and simply allow the AOM framework to give the actual implementation of when
and where back to business experts (which most developers don't have the bandwidth
to be).
As I see different business models for IT and how each company deals
with the 'brand new' OO world of .NET, I see there is still a very poor
understanding of the lessons learned from older OO languages like, say,
Java and C++. Many of the current developers in the industry are ASP scripting
programmers, without even the basic ideas common to OO environments. There
is also a large gap in 'management awareness' of these issues. Usually
those groups that do use modern project management techniques, (such as
having a Quality Control team, team code reviews and architecture reviews)
are still sorely in need of someone who is a true 'architect' to bring
their existing teams up to speed. Usually the 'team lead' is the senior
contractor on the job, and he is also a scripting programmer. This leaves
many projects even in the largest corporations in severe need of rearchitecting
and these projects seem to develop many more problems as their scope grows.
As enough time goes by, 'code death' eventually occurs. There is only
one way to prevent this ongoing. Certain professional OO standards and
techniques must be adopted by the project team, and encouraged and propagated
by the project management and upper level management.
One such technique I find of great use is refactoring. Martin Fowler,
the OO design industries foremost proponent of refactoring has this to
say:
'Refactoring is a controlled technique for improving the design of an
existing code base. Its essence is applying a series of small behavior-preserving
transformations, each of which "too small to be worth doing". However
the cumulative effect of each of these transformations is quite significant.
By doing them in small steps you reduce the risk of introducing errors.
You also avoid having the system broken while you are carrying out the
restructuring - which allows you to gradually refactor a system over an
extended period of time.'
| Make
a Donation to Help Build/Maintain our site! |©2006 Christopher G. Lasater
