Monday, December 17, 2012

What's cooking in the EDT kitchen? - December 17

EDT version 0.8.2 is nearly finished.  We're running extensive tests and fixing bugs.  Progress has slowed down a bit since many of us are taking time off for the holidays, but everything should be finished by the end of January.

Matt

Tuesday, December 4, 2012

What's cooking in the EDT kitchen? - December 4

We're working on the fourth milestone of the EDT 0.8.2 release.  Here's what we accomplished in the last week: 

Language

  • Work continued on the bytes type.
  • More work was done to support classes.
  • We made a language design change to solve a problem related to assigning an array to a variable of a different type. When you write array as SomeType[], we'll create a copy of the array.  The as expression may be implicit, which happens when you assign one kind of array to another.
This is a fairly short list, but we also fixed many bugs.

 Matt

Tuesday, November 27, 2012

What's cooking in the EDT kitchen? - November 27

We're working on the fourth milestone of the EDT 0.8.2 release.  Here's what we accomplished in the last week:

Extensibility
  • Content assist, which needed repairs after the extensibility work we did in Milestone 3, is working again. It's driven by the types known to the compiler, with no more hard-coded information.  This was the last piece of Extensibility work for the release.
Language
  • We added ten functions to the string type. They make it much easier to manipulate text in EGL.
  • We added functions that return the day, month, and year parts of a date.
  • Work continued on the bytes type, specifically conversion of bytes data to/from XML.
  • More work was done to support classes, with the addition of abstract and static keywords.
Matt

Tuesday, November 20, 2012

What's cooking in the EDT kitchen? - November 20

We made great progress towards EDT 0.8.2 M4 last week.  In many cases, we've done more planning than coding in the first week after a milestone, but not this time.  Unfortunately I expect things to slow down this week, since most of the team is taking two or three days off for Thanksgiving.

Extensibility
  • We're making content assist work again. It's the only major feature that was broken by the extensibility features introduced in M3.
Language
  • Any expression can now be used to specify the size of a new array. Previously you had to use a literal number.
  • We finished the ternary if-then-else operator.  Its syntax is (condition) ?? true_value : false_value.  (Yes there are two question marks, not one.  They keep our parser from being confused.)
  • We started work on new functions that make it easier to work with dates and strings.
  • We have a type called AnyStruct whose value can be any "structured" type: record, handler, class, external type, or any.
Matt

Tuesday, November 13, 2012

What's cooking in the EDT kitchen? - November 13

The big news from EDT-land is that 0.8.2 Milestone 3 is finished. There's one more milestone in this release, and we'll be done with it early next year.

Our New and Noteworthy page will tell you what's in M3. It doesn't mention classes or the bytes type, which I've written about in my weekly posts, because those features weren't finished in time.  They'll be included in Milestone 4, and I doubt they'll be the only language enhancements we add.  (The official list of M4 contents hasn't been made yet.)


Matt

Version 0.8.2 Milestone 3 is available

The new milestone build is waiting for you:
Matt

Wednesday, November 7, 2012

What's cooking in the EDT kitchen? - November 7

It's testing time!  We're testing EDT 0.8.2 Milestone 3, and we'll make it available as soon as we can.

Tuesday, October 30, 2012

What's cooking in the EDT kitchen? - October 30

EDT 0.8.2 Milestone 3 is nearly finished!  We're in the final week of development now.

In the past week we've been merging our extensibility changes into the main development branch.  We've updated our tests and samples.  Work continues on language enhancements like classes.

Matt

Tuesday, October 23, 2012

What's cooking in the EDT kitchen? - October 23

As I wrote in last week's post, we continue making good progress towards 0.8.2 Milestone 3.  The milestone will be finished in two weeks.

Extensibility
  • Our system types can now be compiled under the extensible framework.  No more "magic" or patching things up by hand!  Once this is done we'll start merging the extensibility changes into the main code stream (and our nightly builds).
Language
  • Continued working to implementing classes.
  • We're working on a new rule to decide when two arrays are compatible.  The current rule is complicated and maybe inconsistent.  The simplest rule (both arrays must be exactly the same type, unless one is an array of Anys) is more strict than we've been in the past.
  • We decided that only eglx.lang.* will be implicitly imported in an egl file.  Importing eglx.lang.* gives you basic things like int, string, etc.
Other
 Matt

Monday, October 15, 2012

What's cooking in the EDT kitchen? - October 15

We continue making good progress towards our next milestone.

Extensibility
  • We're close to getting our system types compiled under the new extensible framework.  Once this is done we'll start merging the extensibility changes into the main code stream (and our nightly builds).
Language
  • Started implementing classes.
  • We decided that "abstract" functions will be allowed in a class. An abstract function contains no statements and is terminated by a semicolon instead of the end keyword. In order for our parser to understand this new syntax, we will remove support for the do-nothing statement that consists of only a semicolon.
  • We revised the rules for comparisons involving the bytes type. Our old rule was that both bytes value must have a length, and the lengths must be the same. So you couldn't compare a bytes(3) to a bytes(4), or a bytes(3) to a bytes with no length. These comparisons are now valid. Comparing bytes(n) and bytes will be like comparing string(n) and string.
Other
Matt

Monday, October 8, 2012

What's cooking in the EDT kitchen? - October 8

Hello. Here I am again, letting you know what we've been up to in the EDT kitchen. You can read my previous post to learn what we did last week.

Extensibility
  • We're close to getting our system types compiled under the new extensible framework.  Once this is done we'll start merging the extensibility changes into the main code stream (and our nightly builds).
Language
  • Finished parser and compiler work for the "if-then-else" ternary operator. It hasn't yet been implemented in the generators.
  • Wrote many tests for the new bytes type.  The next step is to run the tests and fix all the problems we find.
Other
Matt

Tuesday, October 2, 2012

What's cooking in the EDT kitchen? - October 2

We finished EDT 0.8.2 Milestone 2 last week. You can read about it on our new and noteworthy page.

Here's a link to last week's "What's Cooking?" post.

This week is the first week of Milestone 3, which will include the extensibility features we've been working on for so long, as well as improvements to the language.

Extensibility
  • Modifying the validation code to use the new extensibility features.
Language
  • Began work on the "if-then-else" ternary operator.  Example: x = y > 0 ? y : -1;
Other
Matt

Version 0.8.2 Milestone 2 is available

The new milestone build is waiting for you:


-- Ben

Tuesday, September 25, 2012

What's cooking in the EDT kitchen? - September 25

We just spent another week of EDT 0.8.2 development focused mainly on extensibility.  But we also (finally!) did some work on language enhancements too.

Here's a link to last week's "What's Cooking?" post.

Extensibility
  • Modifying the validation code to use the new extensibility features.
  • Rich UI has been separated into a compiler extension.
  • Continued work to make content assist aware of extensions.
Language
  • Made the const keyword applicable to any variable declaration.
  • We removed many unsupported language features from the parser and code formatter. They were features from RBD that we aren't going to include in EDT 1.0.
Other
Matt

Tuesday, September 18, 2012

2012 IBM Rational China EGL Contest Ends Successfully

This is a guest post by Fa Hua Jin (known as Rocky) of the IBM China Development Lab.

An awards ceremony for 2012 IBM Rational EGL contest was held on August 24, 2012, at the IBM Software Technical Summit in Beijing, China. After half a year’s hard work, six teams were awarded prizes. There was strong competition from 104 registered teams at Chinese universities and academies.

IBM Fellow Kevin Stoodley issued the 1st prize award at the ceremony

EGL is a business programming language provided by IBM. Many enterprises and organizations around the world choose EGL as the programming language to develop their most important core applications. To promote the EGL language, and also to attract more developers from communities, IBM started the EGL open strategy in 2008. In December 2011, the open version of EGL, EDT 0.7 (EGL Development Tools), was released. EDT is  open source, based on Eclipse.  Anybody can use EDT for free, and engage in EDT’s development and testing under the Eclipse open source license.

To promote EGL in China, and make the Chinese development community more aware of it, IBM China Development Lab launched the EGL contest in March, 2012. Its target audience was students in universities and academies in mainland China. After the contest started, lots of students from all over China actively joined the event. By the end of May, 104 teams from 35 universities and academies in China had registered for the contest. The various and innovative topics chosen by students covered interesting topics and issues. This demonstrates the wide vision and interests of the students, and it also shows the many strong capabilities of EGL.

The submitted works mostly covered the following themes.
  • Extend the language by leveraging the extensibility of EGL.
  • Interesting applications for smart hand-held devices. For example, a campus management system, network collaboration drawing, computer remote control, meal-ordering system, etc.
  • Web 2.0-based applications, for things such as social networking, a food safety information release platform, etc.

The committee awarded prizes to the following six works.

First Prize

Name: Extend EGL to Support Google Application Engine Datastore
Author: Ying Zhong Xu
From: Institute of Computing Technology, Chinese Academy of Sciences, Beijing, North China
Description: Extend the abstract I/O statements of EGL to support the BigTable implementation of Google App Engine. The work perfectly demonstrated EGL‘s extensibility – if a 3rd party writes a new I/O implementation in EGL, existing EGL applications can be seamlessly migrated to the new system. In this sample, an EGL program which accesses a database could be deployed to Google App engine without making too many changes.

 The schematic diagram

Second Prizes

Work 1

Name: I Love Playing
Author: Mao De Shi, Gui Ju Zhang
From: Hunan University, Changsha, Central China
Description: This SNS-based application developed in EGL uses web 2.0 technologies. Users can use this application to organize and join activities. The application covers the major functions of SNS applications. It also leverages various 3rd party services. For example, the MSN account service, the location service provided by Sohu.com, and weather service provided by Google. Authors also took advantage of EGL extensibility and encapsulated the JQuery widgets. The application’s UI is clean and beautiful; it’s also easy to use.

 Login

Propose activity

Work 2

Name: Click
Author: Dao Shu Wang, Xiao Lin Hou, Tie Xin Gao
From: Peking University, Beijing, North China
Description: An EGL mobile application. The application can be used for controlling a remote computer with a smart phone. The authors fully took advantage of EGL’s capabilities, extending EGL to support interaction with local native OS functionalities. This is an innovative idea, with clean, beautiful user interfaces.

 Use mobile to control computer

Third Prizes

Work 1

Name: Food Safety Information Release System
Author: Xiaobin He, Zhen Ming Shen, Chao Wang
From: Sun Yat-sen University, Guangdong, South China
Description: The food safety release and management system is based on EGL web 2.0 technologies. The authors hope to establish a communication platform between government and public consumers, which would help to resolve food safety problems. Food safety authorities would publish food safety news and random-sampling inspection results, and the public could file complaints against certain brands. Authorities would handle the complaints and then reply to consumers in the system. The application UI is simplified with full functionality. The authors are proficient with EGL web 2.0 development technologies. They also provided a professional development process and detailed documentation. The judges were very impressed with their use of software lifecycle management tools.

 Food safety information release and management system

Work 2

Name: What Should I Eat?
Author: Li Zhang, Lin Lu
From: Xiamen University, Xiamen, Southeast China
Description: An EGL mobile application, helping to solve the problem of deciding what to eat. The user can specify the price range and other preferences, and then the system will automatically propose food and restaurants. The authors fully leveraged the EGL mobile functionalities, and gave the EGL development team some suggestions.

What Should I Eat?

Work 3

Name: Who Am I?
Author: Jun Yu Chen
From: Sichuan University, Chengdu, Southwest China
Description: EGL Web 2.0-based application for self test. The system provides several tests to help people better understand themselves; also it provides the ability to dynamically add new tests. The UI layout is clean, with full functionality, and it is easy to use.

Who Am I?

Monday, September 17, 2012

What's cooking in the EDT kitchen? - September 17

Last week, we continued working mainly on extensibility, as we've been doing for many weeks now.  We're still on track to finish the 0.8.2 release on time.

Extensibility
  • Modifying the IDE code to use the new extensibility features.
  • Content assist and quick fix actions are now driven by the type system.
Other
  • Updated the rules for assignments with delegates.  Two delegates are compatible if they are the same type, or their parameters and return types match.  Previously, a delegate was only compatible with other delegates of the same type.
  • You can contribute samples of EGL code to Rosetta Code at http://rosettacode.org/wiki/EGL and the EDT wiki's Code Snippets page at http://wiki.eclipse.org/EDT:Code_snippets
Matt

Monday, September 10, 2012

Accessing services

You can access services in ways that match your need:

  • You can write an EGL service type and deploy it as a "dedicated service," along with your Rich UI application. In this case, you don't need to know the service location, and the logic for accessing the service is a simple call statement, a callback function, and an exception handler.
  • You can deploy the same EGL service type as an EGL REST-RPC service. In this case, your call statement has an additional clause, and you'll use that clause to reference a resource-binding entry in the deployment descriptor.

    The resource-binding entry stores the access details outside of your logic. As a result, you can reference a different service location without re-generating your code.

  • If your EGL REST-RPC service is referenced from one or more handlers, you might write a simple, declarative proxy function in a library -- no logic needed there -- and then reference that function from your requesting code. In this case, you also write a resource-binding entry.

    The mechanism just described also works when you access a dedicated service or a third-party REST service.

  • You might invoke several services to combine their data in a mash-up, which is an application that provides a single presentation from multiple sources. A mash-up might be lighthearted, or worthy of enterprise-level computing, or both. EGL allows for creativity and depth.

How do you start to learn about service access?

  • Do you want to be "hands on" from the start? Try out the code snippets for accessing a service.
  • Do you want to see a more detailed overview of the options? Consider service bindings.
  • Do you want some background information? Read service-oriented architecture (SOA) for EGL developers.
  • Do you want to learn more detail that is specific to EGL? Go to the Help system, search for and select "EGL support for SOA," and gain access to the subtopics by clicking the ToC icon at the bottom left. The language reference also has topics of interest; in particular, "REST annotation."

We were most concerned about ease of use when we designed service access. We also ensured that the use of proxy functions is similar to the use of proxy functions for accessing a program on IBM i.

We're pleased with the design and the outcome, but let us know what you think.

-- Ben

What's cooking in the EDT kitchen? - September 10

Stop me if you've heard this one before...we spent the last week working mainly on the extensibility enhancements for EDT 0.8.2.

Extensibility

  • Made a plan for how and when to merge these changes into the main development branch.
  • Making validation of EGL source code extensible.
  • Updated our JUnit tests for the new validation code.
  • Making it possible to add new types and annotations.
  • Modifying the IDE code to use the extensibility features. 
  • Updating source files of built-in types so they can be compiled by the new extensible code
Other
  • Examining a possible contribution to EDT from someone outside of the development team. (I'll give more details in the future if we decide to accept it.)
  • We selected the winners of the EGL programming contest in China. We'll describe them in a blog post, soon.
  • Fighting with Git, missing the simplicity of CVS.
Matt

Tuesday, September 4, 2012

What's cooking in the EDT kitchen? - September 4

Another week has gone by in which we mainly worked to make EDT extensible. The extensibility project is one of our two main themes as we develop EDT 0.8.2. (The other theme is Language, but we haven't started on it yet.)

Extensibility
  • Making validation of EGL source code extensible.
  • Making it possible to add new types and annotations.
  • Modifying the SQL, IBM i, and services code to use the extensibility features.
Other
Also, be sure to read this post by Dan Darnell on the EDT Forum. Dan used EDT to write a browser-based maze-solving game.

Matt

Monday, August 27, 2012

What's cooking in the EDT kitchen? - August 27

Last week we continued on the path towards a fully-extensible EDT. In particular, we worked on:
  • Making validation of EGL source code extensible.
  • Making it possible to add new types and annotations.
  • Modifying the SQL, IBM i, and services code to use the extensibility features.
This is the same list of features that I wrote in my previous post.

Matt

Tuesday, August 21, 2012

What's cooking in the EDT kitchen? - August 21

This week's "what's cooking?" post looks a lot like the one from last week.  We kept our focus on Extensibility, as you can see below.

Extensibility
  • Making validation of EGL source code extensible.
  • Making it possible to add new types and annotations.
  • Modifying the SQL, IBM i, and services code to use the extensibility features.
The schedule for this release calls for us to finish Milestone 1 at the end of the week.  We've decided not to make a special Milestone 1 build, because there's nothing interesting to give you.  The extensibility work is being done outside of the main development branch, and we won't finish it for quite some time.

Matt

Tuesday, August 14, 2012

Developing Mobile Applications with EGL

As you may have read in the What's New content for EDT version .8.1, EGL now supports the development of mobile applications using the Dojo Mobile Widget set.

Images from the EGL Dojo Mobile Samples

If you are interested in developing mobile applications, the following links contain some recommended reading:

* Supported Dojo Mobile Widgets
* Configuring an EDT workspace for mobile development
* Supported Browsers and Rendering Engines
* Mobile Samples

Also, at this time, it is not recommended that an application use both the Dojo Mobile widget set and the Dojo Desktop widget set, as it may cause runtime and performance issues.

We look forward to seeing the types of mobile applications being developed with these new widgets.  Any questions or comments related to the mobile widgets, or EDT in general, should be posted in the EDT forum.  If you find a bug in any of the widgets, you can open a defect in Bugzilla using the  Widgets component.

-Brian

What's cooking in the EDT kitchen? - August 14

Last week we continued down the path I described in my previous post.  We're in the early days of developing EDT 0.8.2.  The two main themes of the release are Extensibility and Language (we'll get to the Language part later).

Here are last week's main accomplishments:

Extensibility
  • Making validation of EGL source code extensible.
  • Making it possible to add new types and annotations.
  • Modifying the SQL, IBM i, and services code to use the extensibility features.
Other
  • Added a new sample project, the EGL Dojo Mobile Sample. It's available in the Samples section of the EDT web site.
  • Evaluating the entries to the EGL programming contest in China.
Matt

Tuesday, August 7, 2012

What's cooking in the EDT kitchen? - August 7

I'm happy to say that EDT 0.8.1 was released a few days after my last post.

The schedule and content for EDT 0.8.2 have been posted on the EDT wiki. The two main themes for the release are Extensibility and Language. The Extensibility effort's aim is to make a pluggable framework for compilers and generators, which our code will then use. The goal for the Language theme is to implement the core elements of EGL that we haven't implemented yet.

During the last two weeks we changed version control systems, from CVS to Git. This has slowed us down a little, but we're getting used to Git. (By the way, if you're interested in contributing to EDT, read our Developer's Guide to Getting Started on EDT.)

Here are the other things we've been doing:

Extensibility
  • Making validation of EGL source code extensible.
  • Making it possible to add new types.
Other Matt

IBM i Updates in EDT 0.8.1

For those of you using EDT to develop applications that access IBM i programs, EDT 0.8.1 has a few changes you'll want to know about:

 

Annotation name changes

Based on feedback from you, our users, we have changed the names of the annotations used to control data conversion. Annotations that were previously prefixed with AS400 in the eglx.jtopen.annotations package now specify a prefix of Struct. As an example, the AS400Text annotation is now StructText. When you open existing EGL source code in EDT 0.8.1, you will see validation errors and you will need to change the annotation names.

 

New datatypes

EDT 0.8.1 adds Time and limited String to the types that can be used with IBMi programs.

The use of limited strings provides some advantages in coding for IBMi programs. EDT 0.8.0 required that all string fields used in accessing IBM i programs specify AS400Text{length=xx}. If you use a limited string, you no longer need to use a StructText annotation.

For example:

  firstName string{@StructText{length=10}};

can now also be written:

  firstName string(10);

Specifying an IBMiConnection on the proxy function

In EDT 0.8.0 you used connectionResourceBindingURI on the IBMiProgram annotation to define a default connection on the proxy function. In version 0.8.1 we have normalized connection definitions, and you can now use an @Resource annotation on the proxy function to specify the default connection.

EDT 0.8.0
  function testProc2(IPARM int inout, 
                      RETDATA int inout)returns(int){
     @ExternalName {value = "TESTPROC"},
     @IBMiProgram {
         isServiceProgram=true,
         programName="TSTSRVMME",
         libraryName = "/QSYS.LIB/TSTSRVPGM.LIB",
         connectionResourceBindingURI =         
                  "binding:file:thirdparty_programs#conn1"
     }
  }
EDT 0.8.1
  function testProc2(IPARM int inout, 
                      RETDATA int inout)returns(int){
     @ExternalName {value = "TESTPROC"},
     @Resource{uri = 
                "binding:file:thirdparty_programs#conn1"},
     @IBMiProgram {
         isServiceProgram=true,
         programName="TSTSRVMME",
         libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
     }
  }


Thank you for using EDT,
Joe

Thursday, August 2, 2012

Browser rendering engines

In release 0.8.1 we made a change to the visual editor's rendering engine preferences (to see what I'm talking about navigate to Window > Preferences > EGL > Rich UI > Appearance, section at the bottom). There's no longer a 'default' option, as that was leading to confusion as it differs from system to system. The new preferences are more explicit about which engine to use, and we only display options that are supported on your operating system and architecture. Linux users will also see a 'User configured' option which will use the default engine as configured per the SWT FAQ, since many such systems aren't set up to "work out of the box".

For more information on what's supported, see the "Rendering Engines" section at http://wiki.eclipse.org/EDT:Supported_Platforms.

Is this more complicated than it should be? YES. But we're limited by what SWT supports and the manual configurations, if any, SWT requires.

Also worth noting is a new button in the visual editor's toolbar:


Clicking on this question mark will display the user agent of the rendering engine being used by the visual editor - especially useful when using the 'User Configured' option. It would also be useful to include the user agent information when opening bug reports related to Rich UI runtime errors.

-Justin

Wednesday, August 1, 2012

Version 0.8.1 is ready

We finished testing and are pleased with the new version, which shows the two main benefits of EGL: ease of coding and ease of thought.

For the first time, you can use the Rich UI feature to develop mobile applications. The new version also offers a consistent way to access enterprise logic from your mobile applications and from other web applications.

Now... what do you say?

No, I'm not asking you to say "thank you"; I'm asking, "What do you think?"


-- Ben

Monday, July 30, 2012

What's cooking in the EDT kitchen? - July 30


In my previous post I told you that EDT 0.8.1 would be released last week.  Unfortunately we missed that deadline.  The code is fine (it was built ten days ago), but the intellectual property review will take two or three more days.

Meanwhile, we have been working on new features for EDT 0.8.2.  They include a fully-extensible compiler.  You may recall that this was prototyped during 0.8.1.

We're also adding classes.  That's right, EDT will allow you to write object-oriented code!  We're doing Java-style O.O.: single inheritance for classes, with interfaces providing abstraction.

Matt

Monday, July 23, 2012

What's cooking in the EDT kitchen? - July 23

EDT 0.8.1 is almost ready to enjoy!  Everything is finished except a few administrative tasks.  They should be completed by the end of the week.

As I reported in my last post, we're already working on our next release, EDT 0.8.2.  I'll have more to say about that next week.

Matt

Monday, July 16, 2012

What's cooking in the EDT kitchen? - July 16

Once again I can't report many new developments in the world of EDT 0.8.1.  As I wrote last week, we continue to thoroughly test our code and fix bugs.  We're still on target to finish the 0.8.1 release by the end of the month.

A few of us have started work on EDT 0.8.2.  New features under development include EGLDoc (a tool to create documentation from .egl source files), and the removal of hard-coded information in the EDT compiler (which will allow users to completely customize it).

Matt

Monday, July 9, 2012

What's cooking in the EDT kitchen? - July 9

This week's EDT progress report is the same as last week's (which you can read here).  We're testing our code and fixing bugs, but we're not adding any more enhancements to this release.  EDT 0.8.1 should be finished by the end of this month.

Monday, July 2, 2012

What's cooking in the EDT kitchen? - July 2

Last week, the EDT team reached the third milestone of the 0.8.1 release.  The 0.8.1 M3 build is available now from our Milestones update site http://download.eclipse.org/edt/milestones/1.0/ if you'd like to give it a try.  We'll add an entry about M3 to our EDT 1.0 - New & Noteworthy page soon.

As I wrote in my previous post, we plan to spend a few more weeks writing documentation, testing, and fixing the bugs we find.  The release should be finished by the end of the month.

Monday, June 25, 2012

What's cooking in the EDT kitchen? - June 25

This is the latest weekly blog post designed to let you know what's coming in EDT 0.8.1.  You can read the previous week's post here.

We finished writing new code for 0.8.1 Milestone 3 last week.  We're about halfway done testing it, so we expect to have a Milestone 3 build for you by the end of this week.  Several more weeks of testing will follow Milestone 3, and then we'll be done with the 0.8.1 release.

We spent a lot of time last week on tests: writing them, reviewing them, and running them.  Many tests are written with our EUnit framework.  We also worked on our documentation.  Here are a few other significant things we accomplished.

IDE Usability 
  • Continued to work on a code formatter
  • Update the wizards for the data types added in this release
Language
  • Updated our sample projects with the new service invocation syntax
Other
  • Supported the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese). We're excited to have 104 teams from 35 universities and academies involved in the contest! Awards will be presented at the Beijing Innovate conference in August. 
  • Developers continue investigation on integration with new mobile technologies
Matt

Tuesday, June 19, 2012

What's cooking in the EDT kitchen? - June 18

I'm posting once again to let you know what the EDT development team worked on last week.  You can read the previous week's post here.

Last week we served you 0.8.1 Milestone 2.  It took longer to cook than we expected, but we think it was worth the wait.  While some of us were finishing Milestone 2, the rest we already working on the enhancements and fixes for Milestone 3.  We have now reached the end of the development period for M3.  It's the final milestone of the release, and we've just begun testing it.

Here are the significant items we worked on last week (some of them won't officially appear until version 0.8.2).

IDE Usability 
  • Enhanced the EGL editor with a vertical ruler, and support for "Link With Editor" on files from EGLARs
  • Began work on a code formatter
  • Continued work on debugging with files in EGLARs, including our system types
  • Made the Variables view in the debugger recognize new types
Extensibility
  • Worked on a prototype for the extensible type system
Language
  • Adding support for our newest datatypes to wizards, IBM i support, and SQL
  • Changed service invocations to make them more generic
  • Ensured that operators work properly with null operands
  • Refined and extended the APIs of several types: bytes, time, timestamp
  • Added the 'xor' operator for boolean operands
  • Supported constructors and the 'super' keyword
  • Improved the way Java programs detect NullValueExceptions
Other
  • We held a stakeholder feedback meeting to review what's in M2 and what's coming in M3. 
  • Updated many testcases in our test framework, making it easier to connect known failures with their defects
  • Supported the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese). We're excited to have 104 teams from 35 universities and academies involved in the contest! Awards will be presented at the Beijing Innovate conference in August. 
  • Developers continue investigation on integration with new mobile technologies
Matt

Tuesday, June 12, 2012

Version 0.8.1 Milestone 2 is available

... with new features and a promise of more to come:
  • When you are working on an EGL project, you can review the EGL type definitions that are provided for you. You have immediate access to the details of the technology.

    The type definitions are stored in EGL archive (EGLAR) files.  In the future, you'll be able to protect your proprietary logic by distributing code in those kind of files, just as you distribute Java code in JAR files.

  • New EGL language improvements are in place:
    • You can use the forEach statement to iterate through a list of any type.
    • You can define the type of a numeric literal to control memory usage.
    • You can use bitwise operators to set flags and to do other tasks efficiently.
    • You can declare variables of type STRING(n) and TIME. Use STRING(n) to integrate with IBM i programs; and TIME to write simple code when a timestamp is either too complex or interferes with IBM i or SQL integration.
In the near term, you can look forward to ease of coding on a new front: you'll be able to write widgets for mobile applications. You can also look forward to greater ease of thought: you'll be able to access different kinds of back-end logic in the same way, whether the logic is a host program or a service.

The technology is gaining consistency and power.  Why not take a closer look?
Ben

Monday, June 11, 2012

What's cooking in the EDT kitchen? - June 11

This is the latest weekly blog post designed to let you know what's being cooked up for the next version of EDT.  In case you missed it, read last week's post.

Much of last week was spent polishing the code for 0.8.1 Milestone 2. We tested, fixed bugs, and verified the fixes. We wrote, reviewed, and revised documentation. We did the following other stuff too (though most of it won't appear in our builds until M2 is done):

IDE Usability
  • Continued work on debugging with files in EGLARs
Language
  • Started adding support for our newest datatypes in IBM i
  • Ensured that operators work properly with null operands
  • Fixed problems with the implementation of the bytes type
Other
  • EDT was mentioned in several sessions relating to EGL at Innovate 2012, the Rational Software Conference.  
  • EDT stakeholder meeting will be this week - Wed, June 13th at 10am Eastern US. Anyone interested in EDT is welcome to attend to learn more about what is in EDT 0.8.1 Milestone 2 and what's coming in M3. This is your chance to talk directly to the developers and provide your input on what 
  • Supported the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese). We're excited to have 87 teams with 160 people from 28 universities involved in the contest! Awards will be presented at the Beijing Innovate conference in August. 
  • Developers continue investigation on integration with new mobile technologies
Matt

Monday, June 4, 2012

What's cooking in the EDT kitchen? - June 4

This is the latest weekly blog post designed to let you know what's coming in EDT 0.8.1.  In case you missed it, read last week's post.

In the past week, we mostly worked towards reaching the second milestone of the release.  We wrote tests, ran them, and fixed bugs.  Here are the other important things we did:

IDE Usability
  • Continued work on "open declaration" (F3) in the editor for files in EGLARs
Extensibility
  • Worked on a prototype for the extensible type system
Language
  • Made all of the type conversion code able to accept and return null
Other
  • Investigated integration with new mobile technologies
  • Supported the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese). We're excited to have 87 teams with 160 people from 28 universities involved in the contest! Awards will be presented at the Beijing Innovate conference in August. 
Matt

Tuesday, May 29, 2012

What's cooking in the EDT kitchen? - May 29

Once again, here is my weekly blog post letting you know what we're working on for the next version of EDT. Normally I post these on Mondays, but yesterday was the Memorial Day holiday in the US. In case you missed it, read last week's post.

As a reminder, I don't mention the things we do routinely, like fixing defects, answering questions on the forum, writing documentation, etc.

Here are last week's accomplishments:

IDE Usability
  • Continued work on "open declaration" (F3) in the editor for files in EGLARs
  • Improved the way a native type is displayed in the debugger's Variables view
Extensibility
  • The prototype for extensible validation is nearly complete
Language
  • Updated time, timestamp, and date formatting to match our specification
  • Added support for more datatypes in XML coming from JavaScript
  • Implemented the string(n) and bytes(n) types in JavaScript (this was already done in Java)
Other
  • Prepared for the test phase of 0.8.1 Milestone 2 by writing test scenarios and testcases
  • Investigated integration with new mobile technologies
  • Supported the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese). We're excited to have 87 teams with 160 people from 28 universities involved in the contest! Awards will be presented at the Beijing Innovate conference in August. 
Matt

Tuesday, May 22, 2012

What's cooking in the EDT kitchen? - May 22

This is the latest weekly blog post designed to let you know what's being cooked up for the next version of EDT. Normally I post these on Mondays, but I was out sick yesterday (no, it wasn't the cheese-like substance in fridge). In case you missed it, read last week's post.

Last week we continued making progress toward our goals for EDT 0.8.1.  Here are the details:

IDE Usability
  • Add search capability to the Open Part dialog
  • Make a "library" entry in the EGL Path of an EGLAR for the built-in types
  • Implement "open declaration" (F3) in the editor for files in EGLARs
Extensibility
  • Prototype extensible validation
  • Refactored annotation generation
Language
  • Add support for more datatypes in XML coming from JavaScript
Other
  • Finished the test phase of 0.8.1 Milestone 1 with a success rate of 95%. We won't be posting a milestone driver for M1 since much of the work has been to refactor for extensibility and less new functions.We do plan to post a milestone driver for M2. If you really want the latest, you can get the nightly builds though they are often not as stable as milestone or release builds. 
  • Investigate integrating with new mobile technologies. 
  • Support the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese). We're excited to have 87 teams with 160 people from 28 universities involved in the contest! Awards will be presented at the Beijing Innovate conference in August. 
Matt

Monday, May 14, 2012

What's cooking in the EDT kitchen? - May 14

This is the latest weekly blog post designed to let you know what's being cooked up for the next version of EDT.  In case you missed it, read last week's post.

Last week the EDT chefs served a few new dishes along with some old favorites.  (Also, I found a really old onion in the back of the refrigerator, and something that might be a new kind of cheese.)

Here's what's been happening:

IDE Usability
  • Update searching and indexing for EGLARs
  • Make a "library" entry in the EGL Path of an EGLAR for the built-in types
  • Implement a read-only editor for files in EGLARs
Extensibility
  • Prototype extensible validation
Language
  • Support for foreach loop on arrays
  • Add new bit-manipulation operators
Other
  • Wrote new tests, with hundreds of new variations, for the test phase of 0.8.1 Milestone 1, and began running the tests
  • Investigate integrating with new mobile technologies
  • Support the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese)
Matt

Monday, May 7, 2012

What's cooking in the EDT kitchen? - May 7

This is the latest weekly blog post designed to let you know what's coming in the next version of EDT.  In case you missed it, read last week's post.

Here's what's been happening:


IDE Usability
  • Update searching and indexing for EGLARs
  • Implement a read-only editor for files in EGLARs
Extensibility
  • Prototype extensible validation
Language
  • Support for foreach loop on arrays
  • Support for 'super' (to access an overridden function or field, or a super-type's constructor)
  • Add syntax for new kinds of literals
  • Add new bit-manipulation operators
  • Update testcases after the latest language changes
Other
  • Investigate integrating with new mobile technologies
  • Support the 2012 IBM Rational EGL Programming contest, open to university students in China http://www.ibm.com/software/cn/rational/eglcontest/ (the page is in Chinese)
  • Prepare for the test phase of 0.8.1 Milestone 1
Matt

Saturday, May 5, 2012

Sharing data among services

Services often need to share data. There are many examples: like storing an IBMiConnection using the HttpSession to create a persistent host Job, or a login service that stores configuration information on the session so data services have access to the information without directly obtaining it from the Rich UI application. It may be obvious, but it's worth stating, for invocations to share the same session they must use the same session cookie and the services must be deployed to the same server cluster.

First let's look at how to access the HttpSession in a service:

Setting or getting a session value is pretty easy. First get the HttpSession then use setAttribute or getAttribute. The service is run in a servlet. The servlet's doPost function saves the HttpServletRequest in a thread local variable, this makes it accessible as the service context, ServletContext.getHttpServletRequest().

Here's some sample example service function that returns the HttpSession which is used by the put/get functions:

    function getSession()returns(HttpSession?)
        session HttpSession?;
        request javax.servlet.http.HttpServletRequest? = ServletContext.getHttpServletRequest();
        if(request != null)
            session = request.getSession();
        end
        if(session == null)
            exp InvocationException;
            exp.message = "there is no session";
            throw exp;
        end
        return(session);
    end

    function putSessionValue(key string in, value Object in)
        session HttpSession? = getSession();
        session.setAttribute(key, value);
    end
    function getSessionValue(key string in)returns(Object)
        session HttpSession? = getSession();
        return(session.getAttribute(key));
    end

 

Now for a look at the client side:

With dedicated service invocations the session is managed by the browser, with REST service invocations the Rich UI application must manage the sessions.

Using a dedicated service invocation:

If you are accessing the service in a dedicated fashion (your using clause has an HttpProxy), using the same session is easy because the session is managed by the browser that the application is running in. All services invoked in a dedicated fashion are running on the same EGL Rich UI proxy; so session sharing just happens.

Using a REST service invocation:

If you want to access the session in a REST service, it's a bit more complicated because the Rich UI application must manage the session used for the service invocations. I've tried to make it a little easier by encapsulating much of the functionality to work with the session into the CookieSession library. There's information below on where to find this library.

Here are the points you need to design your application to manage the service sessions.

When a Rich UI application makes a REST service invocation the using clause is HTTPRest. The browser still does an HTTPRequest to the EGL Proxy like it did for the dedicated invocation, but it passes information to tell the the EGL Proxy to create a new HTTPRequest to the service.

Sounds complicated but it's a few simple implementation concepts: the service invocation 'returning to' function looks for and extracts a set-cookie:JSESSIONID from the response header, if it is found the JSESSIONID is copied to the request header Cookie value on the variable used for the service invocation.

For each service invocation that wants to use the same session, you must use the same 'using' clause variable, in this case I'm using httpSession1. So each call statement that has using httpSession1 will use the same session. Since we are storing data on the variable it can't be defined in a function, it must be defined in a more global location like a handler or library. If you had four services, two on server A and two on server B you would have two HttpRest variables - one for each server. If all four services are on the same server one variable will do.

    function invokeService()
 
      call GETREC.getCustomers() using httpSession1 returning to handleCustomersResponse onException handleException;
    end   

The 'returning to' function calls processResponseHeadersSession passing the response and the 'using' clause variable.
    function handleCustomersResponse(retResult CUST[] in, http IHttp)
        //process the response headers to handle the Session ID
        CookieSession.processResponseHeadersSession(http.getResponse(), httpSession1);

        .....

In the CookieSession library processResponseHeadersSession in the CookieSession library calls extractJSessionId to extracts the set-cookie from the header, if it's found setRequestSessionId puts the JSESSIONID cookie in the request headers of httpSession1. Once the request headers contain the cookie, the same session will be used with each invocation. Each service response should check for a set-cookie meaning there has been a change in session.

    function processResponseHeadersSession(http Response in, httpVar IHttp in)
            // This function gets the jsessionid and puts the key's value in the http.request
            //by putting the key in the http.request each service invocation using that request will use the same session
            //IMPORTANT NOTE:
            //be very careful with http variables and multiple service invocations
            //service can only use the same request if the services are deployed to the same server cluster
            jsessionId string? = extractJSessionId(http);
            if(jsessionId != null)
               setRequestSessionId(jsessionId, httpVar);
            end
    end   



The code above is part of an IBMi persistent program example. You can load it from dev.eclipse.org//cvsroot/tools org.eclipse.edt/ibmi/org.eclipse.edt.ibmi.examples.

In closing

You've made it through the concepts and examples and now you want to try this. Well there a small problem in the 0.8.0 release which prevents the set-cookie from working in the development environment. You will need to either deploy the application or get a 0.8.1 build.

I hope you'll look for my next blog where I'll use the concepts above to create persistent IBMi jobs.

-Joe

Monday, April 30, 2012

What's cooking in the EDT kitchen? - April 30

This is the second weekly blog post designed to let you know what's coming in the next version of EDT.  In case you missed it, read last week's post.

Here's what's been happening:


IDE Usability
  • Refine the EGL ARchive (EGLAR) spec 
  • Update searching and indexing for EGLARs
  • Implement a read-only editor for files in EGLARs
  • EGLARs containing built-in types now include source code
Extensibility
  • Modularize the generators and runtimes
  • Prototype extensible validation
Language
  • Compiler support for foreach loop on arrays
  • Compiler support for 'super' (to access an overridden function or field, or a super-type's constructor)
Other
Matt

Thursday, April 26, 2012

Accessing your database with JNDI

For those not familiar with Java Naming and Directory Interface (JNDI), it's a mechanism in Java for looking up named "things", which can be anything you want. How it works is you define something on the server (for this blog entry, it's a data source for accessing a database), give it a name, and then you can retrieve this object in your application to perform some task with it (such as, use the data source to connect to a database). Not all runtime environments have a JNDI environment defined; batch Java typically doesn't, but application servers do (so use JNDI with your service but not with your program).

When developing a SQL application, there are two main benefits to this design:
  • The application doesn't need to know how to get to the database.
  • Most data sources support connection pooling, which has significant performance improvements over always obtaining a new connection in your application.
There are two types of authentication for JNDI:
  • Container-based: the credentials are stored in the JNDI definition on the server and applications do not provide any credentials. This is the most common choice, and thus the default setting.
  • Application-based: the application must provide the credentials.
    Note: Not all data sources support application-based authentication! Apache Tomcat's default data source implementation, for example, will throw an error if you try to use it.
So, how do you use JNDI in your EDT application? The best way is to use a resource binding. By default, we will enable JNDI for the SQL resource binding:


The JDNI settings are visible when you select an SQL resource binding in the Deployment Descriptor editor. You can change the name of the data source of the type of authentication that will be used.

The code that you write does not care how the connection is being obtained, those details are left to the deployment descriptor. A quick snippet for connecting to a database and adding a new row:

ds SQLDataSource = SysLib.getResource("binding:DerbyConnection");
add newRecord to ds;

Normally the JNDI configuration in your deployment descriptor is only used by the client application for obtaining the data source from the server, however if you are deploying to Apache Tomcat then we will also define the data source for you. If you are deploying to any other server type, you will need to define the data source on the server yourself (refer to the server's documentation for how this should be done). The reason we cannot do this for any type of server is that there is no standard for how to define the data source, the standard only covers how to access defined objects; every server does it differently.

I'll leave you with a tip: the IDE test server does support JNDI, but if you want to add connection pooling support to it then all you need to do is define an Apache Tomcat runtime at Window > Preferences > Server > Runtime Environments to take advantage of Tomcat's connection pooling support.

-Justin

Monday, April 23, 2012

What's cooking in the EDT kitchen?

As we're incubating the EGL Development Tools (EDT) project, we want to keep everyone informed of our progress. We just finished EDT 0.8.0 (see our earlier post), and have started work on EDT 0.8.1.

We're trying to make it easier for more people and companies to use and contribute to the EDT community. You can find high-level plans on our wiki, or query Bugzilla for a low-level view which shows all of the enhancements currently planned for 0.8.1, though the list will grow during the lifetime of the release. (You can add the Target Milestone to the results using the Change Columns link below the list.)  We realize reading through Bugzilla query results isn't everyone's cup of tea, so we'll also post a weekly progress report (like this post) on the blog to help answer to the question "What are they working on?"

At the moment, we're working on the first of three milestones for the 0.8.1 release. The three main themes of this release are:
  • IDE usability - EGLAR support, source code analysis
  • Extensibility - improved extensibility of the compiler, generators, runtimes, and the deployment process
  • Language - implement more of the language in our generators and runtimes
Here's the list of what we worked on last week. It's meant to be short and sweet, so I don't mention the names of the developers, provide links to Bugzilla, or include estimates of when unfinished work will be done. Also, every week we're fixing defects, answering questions on the forum, writing documentation, etc. so I'm not going to mention those things here.

IDE Usability
  • Design and review the specification for EGLAR support
  • Read RBD's code for EGLARs
  • Investigate EGLAR project explorer
Extensibility
  • Prototype validation extensibility
  • Investigate runtime modularization: split runtimes into functional segments, generators add what is required during generation or deployment
Language
  • Added compiler support for bitwise operators and new types (bytes, time, limited string)
  • Update to content assist for the new types
  • Compiler support for foreach loop on arrays
  • Added bitwise operators, time and limited string types in Java
  • Added a validation check about passing nullable values
  • Work on JavaScript debug's label support
  • Wrote a design for EGLDoc (like Javadoc for EGL)
  • Investigate changing the compiler to keep comments (necessary for EGLDoc)
Other
  • Investigate integrating with new mobile technologies
We hope these weekly reports will help you stay informed about what's cooking in the EDT kitchen and spark your interest to join the other EDT chefs, or at least try out the resulting dish, I mean downloads.

As always, we look forward to hearing from you on the EDT forum.

Matt

Thursday, April 19, 2012

Updating to EDT 0.8 plus some tips

If you have an earlier version of EGL Development tools, either EDT 0.7 or a 0.8 milestone or nightly build, or if you don't have EDT at all yet, then we recommend you get the official EDT 0.8 build. So how do you do that? Well, there's a few ways.

One way is to download the EDT 0.8 all-in-one build from the download page. The all-in-one builds include the Java EE edition of Eclipse 3.7 and the EDT plugins. All you do is unzip and start Eclipse.

If you want to update an existing Eclipse or EDT, another way to get EDT 0.8 is to use the update site url: http://download.eclipse.org/edt/updates/1.0. Be sure this site is checked in the Available Site list under the Help>Install New Software menu. If you added the nightly or milestone sites, uncheck those. When you select the site, EGL Development Tools (EDT) 0.8.0 should appear in the list.

EDT update

And now the tips:

To use the 0.8 level of the Rich UI widgets and Dojo (based on Dojo toolkit version 1.7.2), create a new EGL Web 2.0 project and those projects should be automatically brought into your workspace. You can then retarget the EGL build path for any of your projects to the use these updated dependency projects.

As mentioned in the last blog announcing EDT, there's a few syntax changes that may require you to update your project code, including service definition and binding.

The samples have also been updated to version 0.8. You can get the samples from EDT's Documentation page, http://eclipse.org/edt/#doc. The samples are a good way to learn how to use the various widgets and overall functionality of EGL.

We hope you'll try out EDT 0.8.

Stay tuned for what's coming in EDT 0.8.1.

Theresa, EDT User Experience and Design

Friday, April 13, 2012

EGL Web Developer Tools version 0.8 is available...

... and with it, a proposed motto: "Ease of coding, ease of thought."

Here are some highlights of what's newly available:
  • The service-access mechanism is more uniform. When you develop a Rich UI application, you invoke an EGL dedicated service by fulfilling a two-step process that is characteristic of the language:

    1. Define a binding variable; for example:
         myBindingVar HttpProxy;
    2. Embed the variable in an action statement; for example:
         call MyServiceType.myFunction("abc")
              using myBindingVar
              returning to myResponseHandler
              onException myExceptionHandler;

    The two-step process is in effect not only for service access, but for database access, too. 
  • When you run the EGL deployer to prepare a service for Apache Tomcat, EGL configures the database JNDI detail for you, hiding the complexity.  
  • The IDE has more function:
    • You can use a wizard to write back-end logic for maintaining a database. Your investment? A few keystrokes, a few clicks.
    • You can use a wizard to create an external type. In this way, you can more easily reuse Java code in your application. And you can still use a manual process to create an external type from Java or JavaScript code.
  • You can configure the call statement to invoke code synchronously. Here's an example:
   result int;
   myString String = "abc";
   conn IBMiConnection? = 
         SysLib.getResource("binding:someEntry");
      try
         call MyHostProcedure(myString) 
            using conn
            returns (result);
      onException(exception AnyException)
         //handle exception
      end  

For now, the synchronous call statement is available only to invoke an IBM i program from EGL code that is generated to Java.
  • Did I mention support for IBM i?  We even provide a way to access an IBM i program from a Rich UI application.
  • Rich UI itself is improving:
    • To provide better download performance, we've reduced the size of the downloaded code and are switching to Asynchronous Module Definition, which is a standard technology for loading code on the web.
    • Support for Dojo is based on Dojo toolkit version 1.7.
    • Arbitrary data of any type can be stored and accessed by a Rich UI widget, for a more logical pattern of data assignment and use.
The technology is gaining value, whether you need to write spiffy web apps, access enterprise data, or do both. Why not take a closer look?

    Monday, April 9, 2012

    EDT @ EclipseCon 2012


    Last week I attended EclipseCon 2012 in Reston, Virginia, to present the EDT project as part of the Eclipse Hot New Product Showcase. While the EDT project did not win the award for Hot New Product, I did get a chance to talk to a lot of people about EDT, EGL, EDT Web Developer Tools, and Eclipse. If you have not had a chance to attend an EclipseCon, I would highly recommend making the trip.

    To prepare for my trip to EclipseCon, I worked with the team to create a handout that provides an overview of the EDT project. We felt that it was important for the handout to highlight two specific areas of the project; 1) an overview of EGL as a language and the goal of the EDT project to provide an extensible IDE for EGL, and 2) an overview of our first extension, which we have been calling EDT Web Developer Tools.  It was not easy to try and condense all of the information related to these topics onto two pages, but in the end I think we managed to make everything fit.

    In addition to providing the best information in the limited space available, we also felt that the handout should use the same graphical theme as the EDT project web site. We enlisted Rebecca, a graphics designer at ClearBlade, who helped us get the handout just right. Thanks, Rebecca!

    If you get a chance to look at the EDT Overview handout, let us know what you think! Is there anything that you would add or remove? There's a lot of content in EDT now and lots of ideas for the future, so we hope to get people as excited about it as we are.

    I enjoyed the sessions and talking to people EclipseCon. Thanks to the folks who stopped by the EDT table to hear what the EDT project is all about. As always, we would love to hear what you think about the project, so feel free to post a comment to this blog, or on the EDT Forum.

    -Brian

    Tuesday, March 27, 2012

    IDE test server overview

    One of the goals of EDT is to let you test your applications without having to configure and deploy to your target environment. However, we must also use care not to alter the behavior of the application when in test mode.

    The IDE test server (based on Jetty) is a major player in this regard, allowing you to invoke services from a Rich UI client without deploying them. Not only will the test server run the service right out of the EGL source project, it'll also automatically manages itself by updating configurations when files such as your deployment descriptors change. You don't even start the server yourself - it's started up when needed, and runs in the background. By the way, the server runs in debug mode, so you can set breakpoints in the service and step through the code.

    Now, there are some situations where the server needs to be restarted for changes to take effect. You'll be prompted if this happens, and given the choice to terminate the server now or let it keep running. The most typical case is when the Java debugger's hot code replace fails (e.g. you modified a part but the generated Java code contains a type of change that the Java debugger does not support "swapping in", such as a new global field).

    I mentioned previously that the server is started automatically, and an important addendum is that the server instance has a "base project", which dictates the classpath, the list of available deployment descriptors, etc. When invoking a service, one of the following rules is used to determine the "base project":
    • When invoking a dedicated service, the project of the main Rich UI handler is the base project.
    • When invoking a REST service, the project containing the service is the base project.
    This allows us to best match the deployed environment. If you open the Debug perspective, the Debug view will list all the test server processes. The process name will indicate the "base project" of that particular server, and there is only one server process per base project. You can use this information to terminate a specific project test server. (Once killed it'll get started back up automatically the next time it's needed.)

    Before I go, a couple tips:
    • When invoking a dedicated service, make sure the project containing the service is on the Java Build Path of the Rich UI project.
    • To invoke a service in a RESTful way, the service must be listed as a REST service in the deployment descriptor, otherwise it will not be exposed as a REST service (this is to match the deployed application's behavior). Then to use the test server instead of trying to invoke the deployed service, use the following workspace URI format for your REST binding: workspace://myServiceProject/myPackage.myService. If you use the 'http://' URI format then the test server will not be used.
    • If you're using JNDI database access in your services, you can benefit from connection pooling (which provides a significant performance boost) simply by defining an Apache Tomcat runtime at Window > Preferences > Server > Runtime Environments. Otherwise it'll still work, but will run slower.
    And if you're a developer looking to extend EDT, the test server can also be extended to support new concepts (information on this can be found on the wiki).

    -Justin