What's new in EGL Development Tools (EDT)

Enhancements and fixes in EDT 0.8.2.

Milestone 4 features 50 fixes and enhancements. See the full list.

The following language changes are in place:

• Support has been added to Java generation for the new Class type. This new type adds the concept of abstract functions and inheritance capabilities to the EGL language. Support for static fields and functions is not yet complete, however. For more information refer to the enhancement.


• Support for the new bytes type was added for Java and JavaScript


• New functions have been added to the types date, bytes, string and all numeric types.


• Support for ternary expression has been added for java and javascript. The syntax of the expression is: booleanExpression ?? trueExpression : falseExpression
Here is an example use:

   t time;
   Syslib.writeStdOut((t.hourOf() < 12) ?? "It is before noon" : "It is after noon");

Generation time validation was added so that the generators can provide error messages on parts and stereotypes that are not supported by a given generator. For example, the JavaScript generator does not support generation of programs. Likewise, the Java generator does not support the generation of a handler with the type RuiHandler. These examples will now result in an error being placed on the parts during generation. Previously, the generators ignored these parts and no notification was given. Generator extensions can add parts and stereotypes that are supported.

Content assist is once again available.

Milestone 3 features 12 fixes and enhancements. See the full list.

Please note that recent changes might require that you migrate your EGL applications. For details, see the differences between EDT 0.8.2 and EDT 0.8.1.

The following language changes are in place:

• You can use the const keyword when you declare a value of any type. For additional flexibility, you can assign an arbitrary expression to a constant rather than just a literal.


• You can indicate the end of a Delegate definition by accepting the end keyword or by typing the ";" character.

The EGL Extensible Compiler is implemented:

• Details about packages and types are no longer hard coded, but are driven by definitions that are external to the core. As a result, you can extend EGL with new types, and the compile-time processing is the same as for the provided types.


• The team handled the following details:
  • Removed from the system scope all types that were not in the eglx.lang package.
  
  
  • Refactored the EGL code and validation logic for Rich UI, placing the content in an EDT extension.
  
  
  • Refactored the runtime Java code for SQL and IBM i, placing the content in an EDT extension.
  
  
  • Ported code to the IR object model that is used by all the EDT generators. The code was previously in an internal object model.

As a result of the extension changes, content assist is unavailable in the M3 release. The capability will return.

Milestones 1 and 2 feature 9 fixes and enhancements. See the full list.

This delivery is the first that is based on work stored in the Git version-control system. In addition, the const keyword is now applicable to any variable declaration.

Enhancements and fixes in EDT 0.8.1.

Milestone 3 features 110 fixes and enhancements. See the full list.

EGL now supports mobile computing. For details on getting started, see Preparing to develop a mobile application.

You can now access different kinds of back-end logic in a similar way, whether the logic is a host program or a service. For details on the new approach to service access, see the following overview: Service bindings

Two changes improve the existing support for IBM i:

• The names of the data conversion annotations are now generic. For example, "AS400Text" became "StructText." The change facilitates the possible future access of programs on System z.

• To indicate where an IBM i program resides, you now declare a Resource annotation in the proxy function, rather than coding a connectionResourceBindingURI annotation field. The change adds consistency and clarity.

For updated details on how to access an IBM i program, see the following overview: Support for IBM i

You can quickly access the EGL system definitions that were made available in Milestone 2:

• You can display an EGL system definition in the editor while you are coding. For example, if you declare a widget of type DojoMobileButton, you gain read-only access to the definition by placing the cursor on "DojoMobileButton" and pressing F3.

• You can use the EGL search mechanism to find the definition in your workspace. Here's an example that works as soon as you create a project for Rich UI:
  1. At the topmost menu, click Search > Search.
  2. Click the EGL Search tab.
  3. At that tab, type IHttp, which is the name of an EGL system definition.
  4. Click All Occurences.
  5. Click Search.

  The definition is available at the bottom right; and you gain access by double-clicking the file icon there:

  

94 fixes and enhancements were made in milestones 1 and 2. See the full list.

After you have created or imported an EGL project, you can review the provided type definitions by expanding EDT System Libraries:
 

You can now use the forEach statement to process each element of a list in turn. For example, assume that the following Record type is available:

				
Record MyRecordType 
  myString String;
  myInt Int;
end

The following code iterates through a list of that type:

myList MyRecordType[];
myList.appendElement(new MyRecordType{myString = "01", myInt = 1});
myList.appendElement(new MyRecordType{myString = "02", myInt = 2});
myList.appendElement(new MyRecordType{myString = "03", myInt = 3});        
        
forEach (myElement MyRecordType from myList)
   SysLib.writeStdOut(myElement.myString + " " + myElement.myInt);
end

The output is as follows:

01 1
02 2
03 3

As was already true, you can use the forEach statement to process an SQL result set.

Several bitwise operators are now available:

• ~ is a new unary negation operator, which changes 1s to 0s and the reverse. You typically assign the result, as in the following logic:

  				
     myvar int = ~10;     // bit pattern (4 bytes)
                          // previous:  0000 ... 00001010 
                          // new:       1111 ... 11110101
     Syslib.writeStdOut(myVar);
  

  The code displays the number -11.

• The binary operators are as follows:
  • & (intersection)
  • | (union)
  • xor (exclusive or)
  • <<n (a new left shift, with zero fill)
  • >>n (a new arithmetic right shift, with a fill that reproduces the leftmost bit value)
  • >>>n (a new logical right shift, with zero fill)

  Here is an example use:

     myvar = 10 << 2;     // bit pattern (4 bytes)
                          // previous: 0000 ... 00001010 
                          // new:      0000 ... 00101000
     Syslib.writeStdOut(myVar);
  

  The code displays the number 40.

You can now specify the type of a numeric literal by appending a character to the literal.

The next table shows the EGL type system for numeric literals.

// without scientific notation	
myDecimal decimal = 2.34;

// with scientific notation 
myFloat float = 2.539e7;

myFloat float = 12.34F;

mySmallFloat smallFloat = 12.34f;

myInt Int = 123;

mySmallInt smallInt = 123i;

myBigInt bigInt = 123I;

EGL now includes TIME and limited STRING:

• TIME is a value type, and the stored value corresponds to the HHmmss pattern: two digits for hour, two for minute, and two for second.
• STRING(n) is a reference type, like STRING. However, STRING(n) is similar to the SQL VARCHAR type, with n representing a limit on number of characters.

Enhancements and fixes in EDT 0.80.

140 fixes and enhancements were made in this milestone. See the full list.

The way you invoke a dedicated service is now consistent with the way you invoke a REST or EGL REST-RPC service. Specifically, you define a binding variable of type HttpProxy and do not declare a DedicatedService annotation.

For details on service access, see the following web page:
http://wiki.eclipse.org/EDT:Resource_Binding_Services

String is now a reference type rather than value type. In existing applications, the change has no effect on the following values:

• Strings that are processed inside a single EGL function.
• Strings that are passed to a function parameter that has an explicitly stated modifier, whether the modifier is IN, OUT, or INOUT.

As before, the GeneratedValue annotation identifies a record or handler field for which the corresponding table column receives a value from the database management system. The assignment to the table column occurs when an add statement runs.

The change is as follows: the add statement now places the DBMS-generated value into the field of the record or handler, making the value available to your code.

The team began to define Eclipse extension points for creating new generators and for contributing to existing generators.

60+ fixes and enhancements were made in this milestone. See the full list.

• You now specify a URI when you reference an EGL deployment descriptor entry. The change affects your use of the Resource annotation and the SysLib.getResource function. See Resource Binding Introduction for more information.
• When you want to access a REST service or IBM i program, you can do as follows: declare a connection variable, customize the variable, and configure a call statement to use the variable. The code is consistent with how you configure EGL add and get statements to access a database. The older process for accessing a service involved the following two steps: create a service-access variable based on a Service or Interface type; and use that variable in a call statement. The older process is still supported in the M2 release but is now deprecated. See Resource Bindings Services for more information.
• The M2 release introduces a call statement for synchronous access. At this time, the synchronous version of the call statement is used only for the following purpose: to call an IBM i called or service program from EGL code that is outside of Rich UI.

JNDI allows for a data source configuration to be managed separately from the application (typically by the application server). JNDI also allows for fast database access across multiple users. Starting with the M2 release, you can configure a resource binding to use a logical JNDI name. For details on several changes related to setting up an SQL database binding, see the Resource Binding Databases page.

As an EGL developer, you can access IBM i called programs, as well as procedures in IBM service programs. For more information, see the Support for IBM i page.

Other changes affect your interaction with the IDE:

• You can use a wizard to create an external type, much as you use a wizard to create a Handler or Service type. Note: this wizard only creates a basic external type. Future milestones/releases will extend this wizard with support for specific external types (e.g. Java, JavaScript).
• The outline view now displays a different icon for public and private functions, as shown here:
   
  
• You can now specify whether the Console view displays tracing messages from the EGL Test Server. By default, these messages are not displayed, but a preference page is provided to change this behavior (Window > Preferences > EGL > Test Server).

Arbitrary user data of any type (primitive, record, array, Dictionary, etc.) can now be stored and accessed on a RUI widget. This allows for storing a value and accessing it later in an event handling function (for example). The new APIs are RUIWidget.setUserData(any) and RUIWidget.getUserData().

60+ fixes and enhancements were made in this milestone. See the full list.

EGL content assist has been enhanced to show variables, fields, functions, and types with related details and icons that illustrate the kind of information being presented:
 

EGL Rich UI now supports the following capabilities:

• For better performance at startup, deployed applications are served up in zip format from the application server.
• In the 0.7 release, you could define displayable text in an external properties file. You can now use that text to overwrite the default messages for MVC-based validation. For details, see the following help topic: "Using properties files for displayable text in Rich UI."
• The deployed output is better organized. Specifically, the deployed HTML file is smaller and is accompanied by a new runtime file named edt_core.js.

Hundreds of fixes and enhancements were made since M3. See the full list.

• Nullability and Instantiation
• Reference types and Value Types
• SQL (Entities) specification
• Date specification and Timestamp specification

• Quick Fix support is now provided to create a callback function
  
  
• Quick Assist support is now provided for creating SQL related statements
• Content assist
  
  
• Code formatting
• Organize imports
  
  

Hundreds of fixes and architecture/infrastructure enhancements were made in this milestone. See the full list.

A serializable model, created during compilation, which represents an EGL part. Java APIs are provided for creating, reading, and manipulating instances of the model. Serializable to XML or as binary objects is currently available, with infrastructure to support serialization to other formats.

An extensible code transformation framework is in place for building and creating generators that act on objects created during compilation or programmatically.

• A 'core' generator is one that implements a transformation to a target runtime technology that adheres to the semantics of the 'core' EGL Language
• EGL Core will be the EGL specification containing:
  • Syntax and semantics for declaring EGL definitions
  • Execution semantics for statements and expressions
  • Semantic descriptions for extensible IO statements
    • GET, ADD, etc. with no description for specifics like SQL access
• EGL Core will not specify any metadata specifications except for those necessary to define other metadata
  • Annotation and Stereotype are types themselves known to the compiler

Supports the transformation of EGL into Java. Not fully implemented, but basic functions in place.

Simple example of Java created from EGL:

Supports the transformation of EGL core into JavaScript. Not fully implemented.

The EGL perspective provides quick access to common EGL actions (new project, new source file, etc), quick access to related perspectives (web, Java, etc), and shows a set of views commonly used during development of EGL applications (Project Explorer, Outline, etc).

Projects configured with EGL support (either new projects or projects with EGL support added) appear in the Project Explorer view. EGL source files are organized by package and commonly used actions are available on the context menu.

The EGL New Project wizard (File > New > EGL > New Project) creates a project configured with EGL support. By default, new projects use the default compiler and generator specified in the workspace-level preferences.

EGL support can be added to any existing project via the Configure > Convert to EGL Project action on the context menu of the Project Explorer view.

EGL compiler and generator preferences can be set in the workspace-level preferences page (Window > Preferences > EDT > Compiler)

Compilers and generators can be contributed to the IDE via extension points. A generator gets associated with a compiler, for example the base Java generator belongs to the EDT compiler and can be enabled for any projects using the EDT compiler. Currently generators are provided for Java and JavaScript.

Text editor for EGL source files. Provides the basics of content assist and color highlighting. Common, global actions (Undo, Save, etc) are available on the context menu as well as actions to format the EGL source, add/organize import statements, and jump to the declaration for a part (Open on Selection).

Breakpoints can be added via the EGL source editor. Breakpoints encountered during execution of the EGL part will result in the developer being directed to the Eclipse Debug perspective. Breakpoints can be set on any EGL statement.

The Variables view allows a developer to see variables currently in scope, their values, and their types. Variables are organized based on whether they are global or local.

EGL programs generated as Java can be debugged using the debug tools described above.

Note: the EGL debugger is an implementation of JSR-045. Any EGL extensions mapped to a Java runtime can take advantage of this support.

EGL batch-style programs generated as Java can be launched in debug mode (enabling use of breakpoints, etc) via the Debug As > EGL Java Application.