Transformation

Just before writing this, I described JeeWiz to a young developer, who'd just built an automated testing system for voice recognition. He said

I can see how you can do most of it ... but how do you turn a small amount of "intent" into a large system?

Exactly the right question! In Java Web applications, we expand the original specification by a factor of 30-50 in generating a detailed specification for the build.

Many times when we're programming, we have to repeat ourselves. The maddening thing is that many systems have many similarities ... but until now it hasn't been possible to encode all the different aspects - the know-how, the architecture, the details and the customer's specials - to regenerate a wide range of multi-tier systems.

Compare this with seven years ago, before we started on JeeWiz. We analysed a real application for a UK telecom provider to see if we could automate its production ... and we didn't have a clue how to separate the intent from the technology requirements, let alone thing about generating the whole application.

Now we have reached the point where we are confident that we can generate any system from a small amount of intent if it has repetitive patterns.

How do we go about encoding a large-scale generation system? First of all, we buy the books. We recently collected the books in the office relevant to our two "big" enterprise generations - from straight cookbooks to "Bitter EJB" and Martin Fowler's "Patterns of Enterprise Application Architecture", for architecture and best practice. 20 books, average 750 pages each. That's 15,000 pages.

And do you know the funny thing? The books don't tell you everything you need to know to build real systems ... as anyone who has used an open-source Java framework will know. You end up banging your head against some nasty little problem the books don't cover, often with do diagnostics to tell you what's going wrong.

This is no different from what millions of architects and programmers around the world have to do. The difference is that we then encode this know-how into the generation systems. This is possible because JeeWiz has unique features for building powerful generation systems:

• Break it down. Use the JeeWiz framework to construct large generation systems in layers, so you can re-use a lot of other people's efforts.
• The devil in the details. JeeWiz provides "controls" to generate technology-specific details.
• Generate the architecture. Use 'executable patterns' to generate simple XML to expand intent.
• Say less, do more. Automatic builds, Velocity extensions and 250 library methods reduces the meta-programming effort - based on seven years' experience and hundreds of transforms.

You can use JeeWiz to automate generation of any new domain:

• A 'meta-architect' will need to break it down into layers.
• Master technologists (domain gurus) will produce the layer encoding their expertise. Tool or framework providers can provide plugins for their own technology to get it adopted.
• Architects can stop writing architecture guides that no-one reads and instead define a customisation layer for a standard generation system, to generate the company specials - like operational interfaces, look and feel, naming and deployment conventions etc.

More...

• JeeWiz framework's layer feature:   Reference   Tutorial
• JeeWiz controls:   Reference   Tutorial
• 'Executable patterns': Model-to-model transforms using Simple XML:   Reference   Tutorial
• The JeeWiz framework's automatic build feature
• Velocity Extensions:   Reference   Tutorial