is now

We are pleased to announce that Project Ace, invented at Sun Labs, is now available from Sun Professional Services. The Ace team and its technology, renamed DASL (pronounced dazzle), is officially a part of Sun Professional Services. This DASL technology is now offered and fully supported by Sun as a technology which accompanies a Sun Service customer engagement but *is not* available as an unaided standalone product.

The DASL technology fundamentally simplifies the creation of Java/J2EE/Web services applications. This unique "model to deploy" DASL application modeling language not only encapsulates best practices, but provides a solution to one of your biggest challenges - modeling and developing quality software systems much faster and more efficiently. We are also interested in applying DASL to any areas of interest to you, such as Auto-ID, grid computing, N1 and others.

During the next month, we will accept our first engagements with a few select customers. These could be in the form of a DASL proof of concept engagement where we implement 3-5 use cases in DASL to produce a running application prototype. If you are anxious to get your hands on DASL, all of our new enhancements, and be supported as a Sun customer, please do contact us at DASL@sun.com

The Ace Project at Sun Labs has developed a way to fundamentally simplify the process of creating modern, web-enabled business applications.

• Applications are specified in the Ace language, DASL^§, which is a higher level architectural programming language. This language is the gem at the heart of Ace. 

• DASL is based on published specifications and therefore can be considered open. 
• Ace is not a tool, it is a language which has a reference implementation that includes an ease-of-use tool. 
• Although the DASL language is compiled in the reference implementation, it can also be interpreted.
• The generators which come with Ace can be customized.
• The next version of the reference implementation will have a pluggable Ace generator API.
• DASL can call Java code.
• Ace doesn't compete with Java, it works at a higher level and generates pure Java code.
• The distribution details are implemented automatically at the time the application is compiled and deployed, based on the well defined semantics of the DASL language.
• There is no Ace runtime.
• The Ace approach results in tremendous cost and time savings when creating a J2EE Application.  
• As new architectures beyond J2EE evolve, new code generators can be written to support them without modifying the DASL language, and without rewriting applications written in it.

The preliminary results of this new way of building business applications have been remarkable.  We have found that in typical web applications as they are written today, roughly 5 to 10% of the code has to do with domain logic, and roughly 90 to 95% has to do with distribution.  Using our approach, there is a huge reduction in the number of lines of code required to specify these applications, and a corresponding huge reduction in the time it takes to write and debug the applications.  

For example, the Java J2EE Pet Store application can be specified using about 1000 lines of Ace code, as compared to 14,000 lines of code in the native J2EE implementation.  In fact, of those 1000 lines of Ace code, 750 of them can be created graphically via UML diagrams that are part of our GUI development tool, so the entire Pet Store is actually specified in Ace by writing only 250 lines of traditional "code".

The Ace project team believes that application programming languages must evolve to handle the distribution automatically.  Just as early programmers who wrote in assembly language had to worry about register allocation, stack protocols for invoking library functions, and other details of the machine on which the applications were run, today's programmers worry about passing data and objects back and forth between various computers, services, languages, and data sources.  We have defined DASL as the first of a new breed of higher level languages that abstract out the distribution details and handle them efficiently by capturing the global semantics of the application.

Benefits

The benefits of our approach to application writing include:

• Huge reduction in the time it takes to write and debug applications (many fewer lines of code).
• Ability to retarget existing applications to new deployment architectures without having to change the application specification.  Retargeting is crucial for several reasons:
• Applications initially written on a small scale (smaller number of simultaneous users) often must be redeployed with additional tiers if they become popular, e.g., the customer base grows.
• As hardware and technology advance, existing applications must often be rewritten for the new technology.  
  
• Automatic verification of correctness of application-level transaction semantics.
• Global optimization of communication between the browser, web server, proxy server, application server, and database server tiers.  While such optimization is possible today, it is so tedious and time-consuming that it is often not done.

Relevant Applications

At this time, we have developed the technology so that it is suitable for the following kinds of applications:

• Enterprise applications, deployed on the web.
• Dynamic web pages that involve form-based entry and query capabilities.
• Departmental applications within a business.
• Group and personal applications that require persistent data.
• Applications that run on wireless, hand-held devices.
• Web site design and validation
• Web service applications that run as independent servers.

We are investigating extending our approach to cover these kinds of applications:

• Roaming applications on wireless computers that synchronize with the "mother ship" database automatically when at home.
• Highly interactive "rich client" implementations, generated from the same specification that generates a JSP/HTML application today.

Completeness

While the Ace approach provides graphics as an aid to application design, Ace does not attempt to capture all of application programming using only graphics with a few computational expressions tacked on. Rather, it defines a powerful high-level language in which business logic can be expressed algorithmically.  The key difference between DASL and the Java(tm) programming language is that the distribution details are not expressed, while important application semantics such as persistence and transactions are expressed declaratively.

Ace provides access to legacy systems by allowing calls to any Java(tm) method from a DASL method.  Thus, any method or service that can be accessed from Java can be accessed by an Ace application.

An object-relational mapping facility is under construction, to allow the application writer precise control over the mapping between the business objects (expressed using the BOS sublanguage) and the relational DBMS schema used to store the objects.

Status of Project

Although the Ace project is not a committed Sun product, we have conducted a developer trial of our research development tools, which includes our compiler, graphic tools, deployment and testing tools, etc. One of our trial developers, Expert Systems of Monterrey, Mexico, has created an Ace application consisting of 13,000 lines of Ace code.  It compiles into 300,000 lines of deployed code (a combination of Java, JSP, HTML, XML, etc.).

To Find Out More

The sidebar at the top left contains more information about Ace.   To see examples of the Ace language, look at some of the sample applications.  A complete language guide for the DASL language can be obtained by navigating the "Request Documents" link, and requesting the "Practical Guide".  

^§The DASL language (Distributed Application Specification Language, pronounced dazzle) contains several sublanguages for expressing the application semantics.  The BOS sublanguage specifies the semantics of business objects, rules, relationships, and constraints.  The AUS sublanguage specifies the application task and interaction model, i.e., the application's usage of the business object layer.  Also incorporated into DASL is a query language, based on OMG's OQL standard, used to query the persistent store of business objects.