Levels of Development

About 7 years ago I wrote piece for Software Development Magazine saying that components and objects would not be succesful until they were aggregated into larger re-usable chunks. I was wrong. It had to go both ways – smaller chunks as well as larger – so that programmers had several levels of development and could move up and down those levels with ease. This means not just moving up or down but also horizontally out to new devices and platforms but with the same development tools

Circa 2004 and development environs are starting to provide just such depth and reach. And aready the move to smaller chunks has been accomplished with the rise of object languages. They make three smaller chunks readily available:
1)through vast object libraries; there are vast well defined object variations such as lists, maps, arrays and stuctures as themes available to developers – this is the small substitution path;
2)through object extension and derivation one can have not just polygons – but rectangles, and triangles, pentagons and each with it own area and circumference function/method; but common edge and fill variables/attributes – this is the inheritance path;
3)one can have multiple constructors including defering to the super or default definition allowing for multiple lines/levels of entry.
This richness of options at the language level has now been reflected with the emergence of 3 system levels: i)components then ii)design patterns and frameworks followed by iii) Web Service driven macro system calls and usage. Lets look at how well these 3 expanding levels of systems are utilized in our 3 most popular development environs:

  Java C/C++ .Net Framework
Major System      
reliability/availability ++ + +?
scalability + ++ =?
performance = ++ =?
portability ++ +/-
interoperability + +/-
manageability + + +
security + = +?
usability + = +
portability + +/- -?
interoperability = -?
usability = + ++
portability ++`
security + = -?
usability + ++

Now before describing the table, it is worthwhile delineating the major development environs. Java includes J2ME, J2SE, and J2EE frameworks; C/C++ systems considered are from major independent and some cross platform suppliers like Borland, Metroworks, Trolltech, and Watcom; and the .NET Framework includes all the major languages like VC++, VB, JScript, and C# that are portable across Web, Windows, and now .NET Compact Framework applications. It is also very important to note that reuse is being fostered actively by all three development environs at the language and/or framework level with now huge libraries of common base classes and functions. I can remember just 7-8 years ago when the C++ Common Standard Libraries were Jolt-awarded and yet Java was soon to be doubling and redoubling that standard with its J2SE libraries alone. Now almost all of the development environs offer large base class libraries as drivers and constituents of their frameworks.

We have also tried to gauge the depth of a development environ with such measures as usability, availability/reliability, security, performance and scalability. For reach of a development environ we have used measures such as portability, interoperability, and manageability. Note portability measures the ability to transparently move an application from one OS/hardware platform to another; while interoperability measure the ability to readily interface with other development environs and frameworks primarily within but also across platforms and devices.

Also note that major systems may be made up in whole or in part by one or more major framework and accompanying components. Finally, note that specialized development environs and systems for such tasks as embedded processing, agenting and artificial intelligence may confound our categories as they tend to move development boundaries themselves.


What immediately stands out is the remarkable job Sun and its partners have done with Java. This is not seen just in the outstanding reach of Java systems but also their excellent depth. Thus sticking with the sandlot model, memory management with code referencing checks plus tough try/catch/finally and exception escalation handling has paid dividends on the depth scale with good to superior marks in security, reliability, and availability. However, Java is splintering in the frameworks space with Swing, AWT, and now SWT along with several dataobjects libraries such as SDO, JDO, and JDBC based frameworks. This causes its reach and depth to falter in the frameworks/pattern space with lower interoperability and usability ratings. But in the components space JavaBeans continue to slowly but surely mature and achieve greater interoperability and use in generation systems for servlets through applets to applications. So it should be no surprise that Java is one of the most popular development environs for applications on a diverse set of devices and platforms.

In contrast, C/C++ has a much more mixed assessment. The problem is that each vendor has its own framework for presentation, database transactions and middleware. Standards for XML and distributed messaging plus Web Services certainly help but clearly the lack of a consistent GUI and other components then proceeds to damage the reach story – and this is particularly damaging in the embedded world where heretofore C/C++ with its realtime performance has been a stand out. It will be interesting to see whether consolidation and/or standardization will be able to bring out the performance advantage of C/C++ development systems.

The .NET Framework almost across the board cedes reach measures at every development level desite the Mono project (proof perfect that .NET will always run best in Windows) and the .NET Compact Framework for mobiles and handhelds. But even more troubling for large IT shops are the many depth question marks remaining on .NET Framework. This is primarily due to the slow uptake of .NET at Microsoft itself. .NET, almost 4 years later, is getting its big coming out party for being used in Microsofts own applications with Visual Studio 2005, SQL Server 2005 and some of the other 2004/2005 Servers. But VC++ .NET 2.0 is newly minted with close CLI coupling still to go through full shakedown -> SQL Server 2005 may be 2006 bound. This is one of the consequences of the transformation from “Just Good Enough” development of the roaring 90s to the “Trustworthy & Secure” computing mandates of 2001 and 2003. Thus,until 2001 and .NET, major Microsoft development tools such as VB, Foxpro, VC++(it had actually competing try/catch/finally security mechanisms) and others lacked try/catch/finally, exception escalation, and runtime checks while Java was 3-5 years into perfecting the same. In addition, security nd reliability concerns were trumped by ease of use and operational facility mandates. The .NET result is that there are so many question marks where the environ will finally fall in the inevitable performance versus security/reliability versus usability trade-offs. The important bellwether system to watch is SQL Server 2005.


But the most important point to note is that at least three levels of development and reuse are now viable for designers and developers. Through Web Services, CORBA and other RPC mechnisms plus XML and other database mechanisms – reuse of major systems is highly practicable. Likewise at the pattern and framework level, refactoring or tranformational design allow developers either to move within a framework or completely moveout with API-safe displacement or complete replacement. Ditto for the components level – where moving between components in a library is often feasible. Also there is a much broader set of make or buy options – see components.org for examples. In short, reuse and substitution are available across the board – and at level of detail that makes refining/fixing systems on at least 3 levels a practical reality. Let me say it again: RIP to Rip and Replace.