Technical Benefits

Generate Your Business Components from a Business Definition File

JGenerator can be used to generate you business components from a business definition file. The business definition file uses our business definition language. The business definition language contains all the component definitions, type definitions, validation rules, finding patterns, supplementary files and information and name mappings as well as telling JGenerator which component implementations to generate.

Give JGenerator a business definition file and it will create, compile and deploy all the business components for you. For example, the Microsoft-Northwind database can be specified in an 11K business definition file and will generate a 2750K EJB and JSP code base! Looking at the code to business ratio of 200:1 it is clear that application development is "breath-takingly" inefficient. Improvements in languages cannot significantly help this problem. The only solution is to step out of the box and use code generators. JGenerator is the new direction for application development.

Using JGenerator will typically break the back of a project and make huge savings. www.JobsHive.com made a 90% saving in development time. In one man-month a free recruitment web site was developed.

Deliver and Integrate Your Vision Quickly Across the Enterprise

JGenerator is a true Enterprise tool. Don't get JGenerator confused with simple developer tools, such EJB Wizards. Other tools allow you to generate simple vanilla components. JGenerator allows developers to automate the creation of complex components with rich application functionality.

Unlike vendor specific tools JGenerator can generate code across multiple databases, from multiple vendors with different tiered architectures. For example with our dictionary Vendor class you can modify the SQL that is generated for Sybase, SQL Server, Oracle, Kdb, Interbase or DB2, simply by stating the name of the vendor in the properties file.

JGenerator can produce a web-based application administration system, called JSight that allows users to manage their components and data.

A team in a department can be supplied with a read only view of another departments data and integrate the other departments components into their application code.

Migrate Your Software Up, Down or Across Technologies

JGenerator can be used to write 1-tier (Memory), 2-tier (Jdbc/LocalEJB) or 3-tier (EJB/WebService) applications completely transparently. This is done by generating all the code to a standard design pattern, called JBeans. JBeans is a set of design patterns based on EJB and Java Beans, that provides a rich set of application components. Under this JBeans layer specific implementations are generated. This means developers only have to write their code once for any type of client and redeploy using different underlying technologies. We've taken complex applications such as Northwind and Fpml (Financial Product Markup language) and swapped between in-memory, Jdbc and EJB implementations simply by changing one line of code in the properties file.

As new technologies arrive (such as Web-Services) new JGenerator writer modules can be produced. Projects will not get stuck in the old-world, new-world divisions. Because JGenerator comes with the source, if an architect wants a different technical strategy the code can be changed easily. Projects can migrate from one technology to another by regenerating the code. The clients don't even have to recompile their code.

Give Developers the Flexibility and Power to Improve your Architecture

Until now architects tools simply haven't existed. JGenerator allows Architects to transparently redeploy their code using a different design patterns or technologies. Typically senior developers come up Architectures which then get fossilized because the cost to redevelop then is so expensive. As better solutions become obvious over time, architects either make irrational defenses of their original design or leave to try out their better design on another project.

JGenerator gives your Architects a flexibility and control they have never had. JGenerator produces interfaces for all of its components, so Architects have a free hand to swap custom architectures under the covers.

Serious developers find vendors tools and wizards restrictive and revert to hand crafting their components to get the desired functionality. JGenerators code modules are open, this allows you to adapt the code that is generated, so that you are given fine grained control over all the code that is produced.

 

 

Give your Application Developers a Natural and Intuitive Programming Style

JGenerator generates code to the JBeans standard. JBeans incorporates the simplicity of the Java Beans design patterns with the power of EJB design patterns. JBeans offers further benefits because it hides your programmers from all the nasty technical implementation details of Beans, Jdbc, EJB, JNDI and WebServices.

JBeans has evolved over the last six years as an intuitive, standard, but powerful set of interfaces for 1-tier, 2-tier and 3-tier architectures. The design and been stable and well received, showing we've got it right.

We have used the JBeans interfaces on projects with Java novices who have managed to pick up and use the JBeans components in a few minutes. Once your developers have understood the business data model then code completion makes implementation easy.

The code fragment below shows how easy it is to use the JBeans interfaces: -

CustomerSession session = CustomerContext.getCustomerSession();

Customer customer = session.findByCustomerCode( "AA125AA" );
customer.setCustomerType( CustomerType.FILTHY_RICH );

Address address = customer.getAddress();
address.setLine1( "28 The Avenue" );
address.setLine2( "Surbiton" );

session.save( customer );