Short commentaries of tech issues
- Components vs. Building it
- Everyone will be a programmer
- Code Bloat - an issue for ever
- C++ is dead...
- ..And so may be Java
- OO development will be supplanted
- Components with faces
This is a series of commentaries. I reserve the right to make U-turns at any time.
We will continue down a road of component building by component suppliers. This will have the effect of removing systems oriented programming work from most corporations and centering the development teams on integration work. Application groups will become much more user driven in this mode. Frequently these developers will not even be 'computer programmers,' more likely business knowledgeable users that have taken up programming in Office tools (Word, Excel).
It is my conjecture that everyone, one day, will be a programmer. Just as everyone can write (well, the majority of us [myself excluded it seems]) when once it was only Monks that had this skill, one day everyone will cook up their own applications. These applications may just be utilities in the word processors macro language, but the effect will be that users will, for instance create all their own reports, or their own summaries. The tools to get there are appearing.
Code Bloat - an issue for ever
We will never cure code bloat, it's with us forever. The reason is simple. We all want everything, however what I want is different to the next worker individual. The use of components to supply the core features of programs, to allow this vast range of features will also exacerbate the issue. Components have code that makes it possible to do many things, the programs that use these components only use a limited number of the available features, the unused features cannot be removed. As more components with more features get loaded into applications the application footprint increases, and continues to increase.
...it just doesn't know it yet. Too long in the making, and too confused in its execution, C++ is going to go the way of ADA. As more components are needed, each with more complex features and required more quickly, other languages will appear to supplant the 90's icon. Java may not be the best solution, but derivatives of Perl or Modula-3 could fill a niche.
If Sun is not careful, Java will be viewed in the same way as Ancient Greek, interesting, but ultimately of no relevance to everyday life. Real applications in Java are just too slow. Yes, you can run the JIT, but it takes a good deal of power to execute on any substancial application, time best spent going other places. Unless Sun lightens up and figures out that cross platform is an entertaining but mostly useless goal and that versions specific to hardware platforms would offer better integration, features and performance, there can be no future for Java.
O-O development will be supplanted
Object oriented development will be supplanted by a mix of Structured methodologies, O-O methodologies, Patterns and Mega-Patterns. Mega-Patterns will take the low level pattern concept to a higher level, allowing for the architecting of application spaces. Want an accounting package? Here is the high level Mega-Pattern, do your analysis based on the mega-pattern, select the features needed, then create the system from the patterns thrown up.
Components will evolve to provide computer readable faces. These faces will define the methods, attributes and events of the components, but in a machine readable and validatable form. This will allow a programming CAD tool to be used to throw components together to allow applications to be created without significant programmer overhead in writing the component glue.
[page index]