What is the JeeWiz Engine????

Jeewiz consists of a transformation engine and a set of transforms capable of turning specification into applications, web services, documentation sets, etc. The community edition provides you with the full engine, but only a subset of the transforms. For example, we give the transforms to let you generate a Spring/Hibernate back end, but only a reduced JSF front end.

It is possible to enhance the out-of-the-box transforms. JeeWiz transforms are fully extensible both by adding to and overriding the templates provided. By structuring your code, you needn't edit the templates directly, so you can make sure that you only affect the parts of the generated system you need to.

Because code patterns written into the transforms can be used time and again, they are in effect 100% reusable code. One reason why long term maintenance is so much easier and cheaper that with conventionally produced systems.

As well as using the transforms we give you, you can write your own. JeeWiz is faster and more flexible than XSLT for even moderately complex transformations and is extensible to allow multi-pass embellishments that achieve a complexity that XSLT can't. JeeWiz supports Model Driven Development and the highly complex architectures that can generate.

Why should I use JeeWiz?

JeeWiz is designed to appeal to programmers and architects involved in delivering reasonably complicated applications, particularly those using Java. The following features are why we prefer to use the JeeWiz generator rather than MDA tools to do system generation:

  • The JeeWiz engine is based on standard technologies - XML, Ant, Java, Velocity - and then adds a wide range of features to make complex system generation possible and practical. This means that the learning curve for most developers will be quick wherease a full MDA platform, when it exists, will not be easy to learn because of its focus on declarative programming (e.g. like OCL and the MOF2Text language).
  • Using an existing set of technologies also means that the long-term cost is minimised: JeeWiz can piggy-back on the investment in the related technologies. In contrast, to build a complete MDA platform will be a huge investment for the industry. As a small example, JeeWiz itself provides over 200 utility methods in the Velocity language and Java adds thousands more classes and their methods; the run-time library of the MOF2Text language at last count had less than 20 methods.
  • The pure MDA approach mandates UML as the modelling language, whereas JeeWiz is equally applicable to code-generation from any type of DSL. Furthermore, JeeWiz can be used in an ad-hoc way on any XML document - there is no need to create an explicit meta-model or parser. In effect, any dialect of XML can be transformed using JeeWiz.
  • Finally, JeeWiz has many structural features to create technology plugins and coordinate the actions of a range of other processors that extend the power of code generation. These features are essential to be able to achieve 90-95% code generation in complete web applications including the GUI.

How does JeeWiz compare to 'Pure' MDA?

In particular, we are referring to the 'pure' MDA as defined by the OMG. Lots of people talk about doing MDA in a pragmatic way, but without following all the specifications.

The MDA specifications have 5 important components, which are listed here alongside a description of the JeeWiz equivalent feature:

  • MOF - the meta-modelling language. JeeWiz uses a simplified XML as its meta-modelling language, in which the main elements are:
    • <meta-model> - Serves as the root for the XML document and gives some simple properties about a meta-model.
    • <meta-class> - Defines a type of class element that can be used in modelling (e.g. this would end up as a UML stereotype).
    • <property> - Defines a property/attribute on a meta-class.
    • <list> - Defines the hierarchical structure of the meta-model - which class elements can be included inside which other class elements.
    • <validator> - Defines constraints on the validity of a given class element.

    It is possible to write JeeWiz meta-models using a text editor; an XML editor can also be used.

    The meta-model is used to generate the Java classes that serve as the backing objects when reading in a model. This generation can generate indexes, check for uniqueness and construct named lists across independently-built meta-models.

  • UML - the model. In JeeWiz, the model's native format is XML too. UML class definitions map to XML elements and UML properties to XML attributes. Most UML editors end up with completely different serialisations of their model to XMI. JeeWiz supports Rational System Modeler out of the box. Historically we have supported a wide range of other formats, so we can normally support specific modelling regimes quite quickly
    • UML profiles - stereotypes and tagged values. In UML, a profile is used to create specialisations for the modelling elements - stereotypes and related tagged values for classes, attributes and relationships. In JeeWiz, the name of the XML element tags is derived from the stereotype - e.g. '<entity>' is the XML element for the <<entity>> stereotype. For a supported UML modelling tool, JeeWiz generates the UML profile from the meta-model; this normally has to be installed as a plugin to the modelling tool.
  • OCL - in JeeWiz models and meta-models, constraint are mostly Java expressions. There are also some specialised constraints that are expressed as tagged values - required, min-/max-length, min-/max-value and regular-expressions for string values.
  • MOF2Text - describes how to translate a model to text. JeeWiz uses Velocity as the scripting language, but has added many additional features to the language and execution environment. As the JeeWiz engine is open source, these new features can be used by the Apache Velocity project if they are interested.
  • QVT - describes how to transform model into other models. JeeWiz uses specially named Velocity programs that write XML which is then read in as XML to enhance the model. In other words, there is no special language for model-to-model transforms in JeeWiz.

JeeWiz offers features as part of its system generation environment that have no corresponding feature in MDA. These are based on the practical experience of building large-scale generation systems; they have been introduced to make the template developer's life easier.

  • Built-in features for easily changing conventions for variable or file names, or generated directory structures.
  • Technology plugins allow us to change part of the generated architecture with minimal changes to other parts of the architecture
  • Aspects, to easily change the small detail of the generated system. This approach is used for the programming language, physical and logical datatypes, the logging system, ORM systems, and user interface meta-components.
  • Links to underlying language (i.e Java in our case) during generation. In JeeWiz, these are supplied by Velocity. (In our view, this is the main reason why Velocity became a common choice in model-driven generators.)
  • Integrated build using Ant - because there needs to be a way of defining and implementing multi-level builds. JeeWiz allows Ant to use model values for conditional tests and substitutions into file paths, so the structure and content of the build can be driven directly by the model.
  • Integration of build with model-to-model transforms.

    This means that when we create a new model object using a model-model transform, it will get built automatically - there is no need to also specify that the object needs to be built. This reduces the amount of coordination required to build complete systems.

    This also gives architectural patterns a degree of language independence. Although JeeWiz no longer supports C#, in past versions we have had architectural patterns that we language independent, and then generated classes in C# or Java as appropriate.

Where's the Action Language?

We don't have one. An action language (sometimes dubiously called an action semantic) is a "language neutral" way of creating code in the model to explain what the application is to do when an event occurs. The transform converts that code into the target application code, and this way you can generate 100% of the application from your model. However no two generators use the same action language (for all they are open source) and so it just means learning a new language to convert into the one actually wanted, which is probably something like c# or java, that lots of people already know. So this is only going to be useful if you want to convert your model into multiple languages right at the beginning. Our commercial customers aren't into that.

Secondly, writing this stuff isn't really modelling. It uses a different skill set. Why force business-oriented modellers to code when you can employ a specialist? The JeeWiz paradigm is to generate action method stubs that a programmer can fill in directly in the target language. Now we don't want to have "protected areas" and "fill in areas", so these stubs are abstracted out into a superclass, which is placed in a separate area for coders to access and fill in. When we generate the application anew, we completely regenerate the base areas, but merge any changes to the signature of the model with any programmer code already written.

However the JeeWiz engine can happily convert action semantic if you really need it to, and there's nothing to stop you adding it into a field and doing your thing. This is an Open Source website and we aren't going to send the boys round!

How do I Download JeeWiz?

Downloads are available from this site. If you are new to model driven development and if you want access to our transforms, just download the latest release, which includes the engine, basic transforms, documentation, examples and so on. We expect this to be the preferred route for most users. If you just want to write your own transforms and have some experience, you'll be able to just download the latest release of the engine.

As well as being able to download JeeWizCE from this website, it will be available as part of the Eclipse SOA project, Swordfish, where it is used to generate Web Service infrastructure.

JeeWizCE is available on an Eclipse Open Source public licence. So feel free to download it and see what you think.

What's the Relationship between the Community Edition and Commercial JeeWiz?

The JeeWiz package comprises the engine, the transforms and services.

The engine is entirely licenced as Open Source. New Technology / enterprise (NT/e), the developers of JeeWiz, expect to continue to bring the latest stable releases of the engine to the Open Source arena.

Some of the transforms, available from this site, are also fully Open Source, and you may use the code accordingly. We hope that if you develop a general purpose transform you will make it available from this site, so the amount of freely available code will grow continually.

Other transforms are completely commercial and we expect that to remain the case. Some of these are available with the commercial release and are offered in such a way that developers can use the code without charge, companies only paying when the application moves into commercial use. For the time being if you want access to commercial transforms you should contact us from www.jeewiz.com. Variations on the open source transforms are also be available this way (struts, EJB, Web Services, datagrids etc).

Services will continue to be provided commercially, including tailored development of web applications (if you want to see how much better generating systems can be), writing transforms, support, training and consultancy.