Component-Oriented Thinking (Page 4)

<< Page 3 (Data Binding)

<< Back to the start

Domain Oriented Software

Earlier the idea was introduced that component oriented types could be defined using meta data to reduce the effort needed to develop applications. This has the same goals as the old 4GL languages, but is crucially different because the meta data is open. The concept of specifying domain level meta data helps to understand how efficient your development effort it is. Often hand coding is between 20 and 70 times less efficient than defining an application using meta data and then code generating it.

Using meta data to drive component oriented software opens up an important avenue for software, called Domain Oriented software.

Domain Oriented software is the idea that the module and types can be defined in an abstract meta-language, and then the implementation is rendered using a code generator.

Domain oriented software is more than generative software because many code generators only generate code to solve a specific problem, (e.g. EJB) whereas domain oriented software can generate code for different implementations. Domain oriented software is more than component oriented software because component oriented software is about exposing software interfaces, whereas domain oriented software can generate different implementations for the same interface.

Conclusion

The previous articles have looked at language evolution and concluded that the bloom of API's and code generators is part of a maturation phase. It's now time to take stock and look at the successes and failures of Java and decide where it's going next. It clearly can't stand still.

It is clear from looking at the success stories in the community that designers have stumbled into component oriented thinking, and Sun should extend the Java Beans API's to make a clear separation between data and architecture.

Part Four: Domain Oriented Architecture
The series continues with a more detailed look at Domain Oriented software and architecture.

References

JBeans http://www.javelinsoft.com/jbeans

JGenerator http://www.javelinsoft.com/jgenerator

Pattern Oriented Software Architecture: A System of Patterns [Buschmann et.al. 1996].

Carnegie Mellon University, Domain Engineering, Jan 2001
http://www.sei.cmu.edu/domain-engineering/domain_eng.html

Kai Kosimies, Towards Architecture Oriented Programming Environments, Aug 2001,
http://www.cs.ualberta.ca/~kenw/conf/awsa2001/papers/koskimies.pdf

Mike, A Formal Approach to Domain-Oriented Software Design Environments, September 1995
http://ase.arc.nasa.gov/papers/KBSE94/KBSE94-abstract.html

Jan Klunder, Domain Modeling, Jan 2000
http://www.xs4all.nl/~jklunder/elisa/part04/doc000.html

About the author

Robin Sharp is the Managing Director of Javelin Software (http://www.javelinsoft.com).
He can be reached at

<< Back to Programming

<< Back to Software Reality