Stefan Werner is building an interactive audiospace which will become part of the mediaspace interactive room at RWTH Aachen, Germany. Jan Borchers from the ETH Zürich and myself are supervising the thesis work. We are eager to see the performance of the new MAC G5 machines. Thanks to the Unix platform the MAC has turned into a computing platform equally interesting for those working in the media areas as well as people as myself which come from a Unix background and which have traditionally shied away from Apple products.

Building frameworks with generative components is quite popular with my students right now. Maurice Tauscher extended the TREND framework with a servlet/template mechanism that allowed the generation of web GUIs from meta-data. The existing framework uses together to generate meta-classes and data and the runtime framework generated Java Swing components. To support lightweight clients the servlet based extension was developed with a specialized template mechanism and last but not least a SOAP command interface following the composite message pattern.

Michael Taege developed an eclipse plug-in to generate complete EJB components (entity beans, facades etc.) from xml meta-data. A powerful solution which we will see next term in our new lecture on generative computing. He had to solve problems like round-tripping from model to source and back. A very interesting aspect turned out to be lifecycle support of the generated and modified code: some clients already had a first version and when the generation templates changed he had to find a way to switch over to the new templates without losing code place by individual developers between the generated parts.

Eclipse seems to be used in just about EVERY project that has some tooling needs. The plug-in based extension mechanism has been accepted by the industry. Another topic for our generative computing lecture next term.

Tilman Hansen uses Struts to develop an enterprise portal. Struts 1.1 comes with the new tiles mechanism for tempate inheritance, a new plug-in interface for extensions and other things. Following good J2EE best practices and design patterns a separate Data Access layer has been developed. Most content comes from XML files. For security JAAS is uses (only the authentication part). Authorization is handled through an action base class which implements template/hook mechanisms. The project uses the eclipse IDE with easy-struts and solar-eclipse plug-ins. The result is a very clean design and a good performning enterprise portal. BTW: there is an open position for a diploma thesis with Struts.

Gerrit Quast just finished his thesis at DaimlerChrysler. He used WebServices technology to integrate a .NET base client-side framework with J2EE based server side services. His execellent thesis proves that WebServices can be successfully used in heterogeneous environments - if you play by the rules - e.g. with respect to types etc. It covers Architecture, Tooling And Security.

Ever wondered how SSO works, especially in a web environment? Three of my students are currently programming a web based SSO system in the style of the liberty alliance architecture . What could be a better way to learn SSO? They are using Secure Markup Language (SAML) to describe assertions about users and use the http redirection feature to bounce requests from service providers to identity providers. Message sequence diagrams are extremely helpful here.

I will use this example in my internet security lecture because it not only explains SSO nicely but also shows the privacy issues behind an almighty identity provider. Other interesting questions are how to protect clients from identity theft through providers, how to implement global logout reliably etc.

Following a pointer from Lisa Rein I ran across the work that is done by Mark Stiegler and others on a language and system for secure distributed computing. The new language is called "E" (see www.erights.org and has some very exciting features like "promises" - references that will contain something at a later time but can be uses right now. This allows us to deal with asynchrony in a way much easier compared to creating threads permanently. Another exciting feature is the use of capabilities - cryptographically secured keys which allow access to resources without the need for access control lists or the concept of principal. Looks like we might get rid of viruses and trojans one day because on a capability based systems programs need not run with a principals authority. Instead, they can get a number of keys (capabilities) to specific resources that constrain what a progam can do. And this again constrains malicious programs from causing any harm.

Two students of mine are currently working with "E" and I am looking forward to their presentation.

When I started working with EJB in 97 (actually it was the BOSS/component broker framework from IBM) we had a modelling department with advanced OO-analysts and designers. We were supposed to build the new infrastructure of a large bank using distributed objects technology. Unfortunately we had to learn that a distributed object system places so many restrictions on an OO-model that it is best if designers create their model with distribution in mind. This is nowadays well known through the seminal paper by Jim Waldo . EJB suffered from the same mistakes in the early versions and so called "best practices" needed to be found to deal with those weaknesses. The new EJB release have a lot of new functionality that can help here, e.g. local interfaces, relationship handling etc. How did those improvements affect our ability to create sound OO models? We won't be able to remove the distributed computing restrictions mentioned by Waldo but how do we handle composite objects now? A group of my students started to create an object model during the lecture on Advanced OO modelling by my friend Edmund Ihler and now they are trying to implement this model with EJB - by keeping the "spirit" of the model.

They can get a little help from J2EE patterns and EJB best practices . This will be quite interesting because the use inheritance and the composite object pattern which is not easy to map because of its recursive nature already.

(Plug starts)It is also a nice example of how we work across different lectures here at the HDM (end of plug)

For my distributed systems lecture two of my students are developing a load-balancing infrastructure using the Java Groups framework . This framework supports group communication (virtual synchrony etc.) and could be used to build distributed caches as well.

Two of my students are using a generative toolkit built here at HDM that allows entity beans to be described with XML (using a XSD schema) and automatically generated. They want to use it to convert an existing JDBC based application to EJB and also measure the performance impact of this conversion on various application servers. I believe they use JBOSS and Websphere .

Mark Ulrich is working on a very interesting thesis for a software development group which is part of a mid-size printing company. His has to establish the requirements for a project management software, run an evaluation and decide whether to buy a package or to develop something internally. The workflow and planning parts of such a software is both critical for goal tracking, budgeting etc. but also reaches deep into the working environment of team members and managers. This makes the whole task very delicate. What level of detail is needed for planning? When do you start to anger and demoralize your employees? How overhead is acceptable? Is there a lightweigth package available? These are the questions that need to be answered, besides the usual criteria of functional and non-functional requirements.

BTW: I've just read a book by Gunter Dueck and he talks a bit about some characters that always need to measure things. He also shows some optimization techniques, be it functions or table driven approaches - or the belly approach I use mostly (:-). Anyway, at least to me all requirements tables seem to contain incomparable items which preclude a quantitative approach. Taking the social acceptability of workflow software into account in many cases prevents a purely technological driven decision.

Another group of my students started grid computing. They use the Grid toolkit on linux. They are having a hard time setting it all up but they are at the same time learning a lot about certificates (how does NAT affect certificates? How does delegation work with certificates?). This topic is actually too big for the kind of exploratory projects we do within a lecture but they can continue working on grids in a software project next term. If you are interested in grid computing you might want to read a new redpaper from IBM from Viktor Berstis, "Fundamentals of Grid Computing".

Another interesting site is gridbus which offers the simulation package gridsim and has a link to a discret event simulation and visualization package called simjava .

Grid technology is currently a hot topic because some people see a mixture of different technologies like peer-to-peer, webservices etc. all being used within computing grids.

A fallout of last terms distributed systems lecture turned into a nice project with the goal to build a file sharing service with the Peer-To-Peer framework JXTA from SUN. Other important sources for p2p information is the portal on p2p from O'Reilly. Their emerging conferences site is also worth visiting freqently.

One of the problems we had here was to find a nice pattern for GUI integration. It is not nice to couple your business logic tightly with a specific gui (e.g. swing). But how do you handle cases where the business logic needs a result that usually is provides through GUI routines? You don't want to and you also cannot call "against" the GUI event handling which is usually top down. This problem is similiar to the problem that JAAS faces when a certain login module needs to get userid and password but it does not have direct access to a GUI. One possible solution is to create "callback" objects that return a result to non-GUI components. Internally those callback objects use certain delayed processing methods within Swing to notify the running GUI.