Why Model When You Can Just Program?

Ed Merks, Eclipse Modeling PMC Lead and itemis

As a software developer, programming is as natural as speaking and listening. Java code rolls from your fingertips accelerated by Eclipse's excellent tools. In contrast, modeling is an arcane art focused on strange rituals: rendering diagrams that never scale no matter the monitor size or navigating a maze of menus and dialogs that never yield a comprehensible overview. It's not surprising that there is a strong aversion to modeling: it simply goes against the grain. In this presentation we'll learn that nothing could be further from the truth. Programming and modeling are one and the same.

What makes an application a “good” application

Christian Campo, compeople AG

There are many aspects of software quality a developer applies when creating “good” software. Examples are maintainability, security, and reliability. However, it is not immediately clear to everyone using the software that these aspects are paramount to “good” software design. Especially end-users tend to judge software by intangible qualities, such as whether they “feel comfortable” using the software.

In this talk we will present the "other side" of software development - usability. What are the aspects that make your software more usable? What should I consider when designing my software? When done right, and considered early on in the software development lifecycle, usability can make your software even better.
I will be discussing software usability and its relevance to software engineering. Touching on different topics, answering such questions as: how to structure information, how to visually communicate effectively, how to best support a user’s workflow, and how to make design decisions. This talk should give you a basic understanding of the skills involved in creating more usable software. By doing this, it should supplement your skill-set or at least broaden your horizon.

Gaining traceability in the world of fragmented Agile ALM stacks

Benjamin Muskalla, Tasktop

Over the past decade, many ALM stacks have shifted from vertically integrated silos to tangled and disconnected systems reminiscent of the London tube map. Layer upon layer of legacy, piecemeal Agile deployments and new open source tools have brought traceability to a halt, forcing us into overloaded email inboxes and manual process for tracking delivery in large-scale and regulated environments. The path forward is to either standardize the entire ALM stack, or to embrace heterogeneity. Either way, the ALM architecture must be untangled and the legacy connected for the modernization to happen.

For inspiration, we can look to how ALM strategies have formed bottom-up in the very heterogeneous jungle of open source projects. Open source ALM combines distributed teams, heterogeneous stacks, resource constraints, massive amounts of stakeholder input, and an overload of cross-project dependencies. Despite these challenges, the velocity of many popular open source projects is measurably higher than that of their enterprise counterparts, and what’s even more interesting is that some of the most successful projects provide end-to-end traceability for their constituents.
In this talk, we will examine the key lessons learned from the latest developments in open source ALM, and examine how to apply the practices, ALM architecture patterns and strategies for embracing heterogeneity in order to help pave a path for your Agile and ALM modernization efforts.

Usage of ECore+OCL for business modeling in the connection with Excel-based model representation and validation in the Life Insurance business domain

Ilia Louganski, Credit Suisse Trust

In 2012, Credit Suisse Trust (CST) faced significant challenges as it
wanted to adapt its life insurance platform to rapidly changing business
needs. A backlog of change requests was piling up; turn-around times were
increasing and time-to-market for new products had become unacceptable. It
became clear that the platform had reached a point of complexity where it
could no longer be managed using the IT processes and methodologies in
place.

CST management quickly realized what was happening and saw the lack of
consistency and clarity of the business requirements as the main root cause
of the situation. The tooling put in place to capture and track the
requirements used Excel® as deployment vehicle, a tool that was commonly
used by the team members. However, the structure of the Excel sheet was
designed and managed with Business Object Models developed with the open
source XOCL framework, which integrates mainstream ECore and OCL. Such
models were also validated by using automatically generated tabular editors.

The presentation will show how the approach helped to systematically work
through a large number of requirements and how the business gained control
over the situation, thanks to an ECore+OCL based approach in combination
with an Excel based methodology for representation and validation.

Experiences from Using EJBs in an Eclipse RCP Application

Three-layer architectures using EJBs are fairly common in applications
in the financial sector. However there does not yet exist a standard
for accessing remote EJBs from OSGi applications (RFP 152 has just been
published). We have been using remote EJBs in an Eclipse RCP application for
several years. We'd like to present our approach, its pros and cons
and how it rates on an "OSGi-cleanness" scale. We believe it
is generic enough to be applicable to any application server.
In addition we will show how we have set up the developers' Eclipse
workbenches to increase productivity.

Interface Management in a Large Enterprise

Robert Blust, UBS

Enterprise Architecture decomposes IT systems into subsystems and defines rules and principles for
their communication. To keep the realization conformant to these rules and principles can be a
challenge. To handle this challenge, UBS launched the Integration Architecture initiative. It aims to
provide a usable, end-to-end process and tooling along with the necessary standards and methods to
identify, specify, design, and govern interfaces between parts of the IT System.

A first, already realized step was to visualize the current state bycapturing the actual communication
patterns of subsystems by analyzing their static source code and producing EMF-based graphs. This
allows identifying, for instance, non conformant interaction patterns.

The current step is to realize anappropriate tool chain for the specification, implementation and
management of interfaces, which supports
- Platform independent definition of data types and interfaces in local project scope
- Complete specification of interfaces, their operations, Policy (SLA), visibility etc
- Conformance to the architectural rules and principles
- Automatic generation ofartifacts like XML-Schema and WSDL files
- Built time Repository of Interface Portfolio Management (e.g. usage of interfaces)
- merging the interface models from the local project back into the central repository
- The governance process with corresponding ownership model and role based reviews

Modularization of large projects using Eclipse and OSGi

Marc Hoffman, Swiss Railway

Many productive applications have been built with a large and monolithic code base - and this is not an issue of the past. When such applications need to be extended or application variants should created we often wish for a modular structure in retrospect. This leads to the question commonly asked in this situation: Is it at all feasible to modularize a large productive application with acceptable costs and risk?

The Swiss railway (SBB) chose to do just that with its Rail Control System (RCS) project. The goal was to ensure its long term maintainability and - at the same time - keep the capability to incorporate future. This talk presents a practicable way to modularize large monolithic projects step-by-step and describes some of the benefits realized in the RCS project.

Model Driven Tool Chain for a Large Swiss Bank

To manage a complex multi-tier service architecture, Credit Suisse implemented a framework and a model-driven, domain-specific solution.

In the first part of the presentation we will show the concept of a service architecture called «Multi Channel Platform – MCP». This architecture provides a framework to implement and reuse business logic in a SOA infrastructure.

The second part of the presentation shows how we realized a model-driven tool chain based on Eclipse Xtext and Xtend 2, called «Model Driven Generator – MDGEN». The tooling allows to model service layers with a domain specific language (DSL) and to generate most of the artifacts needed for the implementation.

Lessons learned by replace a bank-wide core application with an Eclipse RCP Client and a JEE backend

Nikolaos Kaintantzis, Zuhlke Engineering

Starting in 2008 we created a repository / data warehouse storing statistical data and meta data. An Eclipse RCP client is being used to provide an interface for expert users such as data administrators and programmers to manage and explore data, meta data and structure definitions, authorizations, and to develop and run scripts based on a Groovy DSL to automate processes. After a successful roll-out in 2010, we are working on the 3rd release.

Creating and maintaining this application taught us many lessons we want to share. You will see the benefits of and the challenges in using Eclipse RCP when building a big and important application.

Topics covered by this session:
- The businesses first impression after the first sprints
- Finding suitable perspectives
- Limits of trees and tables
- Integrating Groovy
- Continuous integration with Eclipse and Maven
- UX considerations and Eclipse RCP
- Help system and documentation

Business Capability Modeling and EMF Recapitulation and Developments on Business and Tooling side

At Eclipse Banking Day 2008 in NYC the speakers presented how they used ECore to elaborate a metamodel for the Business Capability Modeling activities at UBS.

A summary is given. The evolution of the capability modeling in the financial services business and the new possibilities offered by the evolution of the Eclipse technologies are shown as well.

On the business side, the BIAN SOA initiative has managed to create a common understanding of the atomic capabilities and some specific value chains, while the grouping in to more abstract capabilities remains with the single organization. The metamodel of capability modeling is adapted correspondingly, allowing recording groupings, orderings and prioritization of existing capabilities coming from BIAN, rather than inventing new ones. Interestingly the BIAN approach is based on a metamodel for services, which is based itself on the ISO20022 metamodel for messages and common process understanding in the respective businesses, which as well has been reused in XBRL, the standard for financial reporting. This allowed reusing metamodel created by one of the speaker as expert in the TC68/WG4/5 groups defining modeling methodology for ISO20022.

On the tooling side, a number of used frameworks have made progress. Most notably, the new version 3.0 of GMF now makes it easy to generate a graphical value chain editor, while back in 2008, this was considered a no-go.

Managing Eclipse Workplaces in the Enterprise

Dietmar Stoll, itemis Schweiz

Starting enterprise projects with Eclipse usually involves defining an Eclipse distribution to be used by the developers. It typically includes a set of project specific features, update sites, target platform definitions, preferences and more. Developers are supposed to follow set-up procedures, for instance connecting to a specific source code repository and importing project sets and preferences. This manual kind of Eclipse workplace provisioning is known to be inconsistent and error-prone, and is especially hard to implement when teams are large and distributed. Automated and centrally managed provisioning of Eclipse distributions (including Eclipse workspace provisioning) can help to make sure that all developers get equipped with the same workplace setup and that updates or changes get rolled out simultaneously and consistently over all workplaces which significantly speeds up project setup time, reduces support overhead, and decreases maintenance effort. This talk presents an Eclipse workplace provisioning solution that has been successfully implemented for an automotive customer with internationally distributed development teams and sites.

Model-driven development in the context of technical SOA

Michael Rauch & Christoph Gutmann, Swiss Mobiliar

Experience report about how Eclipse Modeling technology is successfully applied to establish forward engineering in the domain of technical SOA. Modeling and code generation help us to drive standardization, increase quality and portability, reduce development effort and gain insight into dependencies. Besides giving an overview of the current solution and the underlying technologies, also lessons learned concerning process and organization are shared. Datatypes, Services, Components and Wirings are modeled in a DSL (Xtext). This model spans project boundaries and contains all technical SOA participants of the company. The model is stored in a central repository. Multiple artifacts are generated based on the model, among them are WSDL, Service Endpoint- and Client-Implementations for multiple target platforms, a service catalog and multiple reports. Finally generated artifacts are pushed to their respective repositories (SOA repository, Maven repository).

As in 2008 for at the Eclipse Banking Day in Frankfurt PostFinance has already presented an overview and outlook of the in house developed Eclipse RCP based Applications.

Four years and a lot of interesting (and important) learning later the Eclipse based applications are up and running and have reached a quite impressive maturity level.

Modernizing a large Counter Application during ongoing operation

Marco Weber (Swiss Post) & Paolo Bazzi (BSI) Talk in German

Outdated applications are a risk. How can we replace a large existing application without endangering the ongoing operation? As for any application handling over 150 million customer interactions each year, a proper approach to this challenge is obviously a top priority.

In this two part talk we presents the incremental approach chosen by Swiss Post to migrate its Centura based SCHAPO cashier application to the Eclipse RCP technology involving BSI as a technology partner. The incremental setup delivered two decisive advantages: minimization of risk and optimal cost control. Furthermore, the step-by-step migration of existing components allowed the parallel implementation of new business requirements. Depending on the volume of the new requirements more or less legacy code was refactored and replaced in each delivery.

In the second part of the talk we explain the target architecture and the Eclipse technology involved. We also elaborate on the move towards an open service-oriented architecture that enables the integration of external service providers into the cashier application such as Ticket Corner, prepaid cards or insurance companies.

Finally, we offer some of the lessons learn in this multi-year migration project.

Generating Web Serices with Xtext based DSL

Frank Baier & Matthias Cullman, Basler Versicherung AG Talk in German

Are you WSDL-First or Java-First? We are Baloise-Service-Model-first!

Xtext provides a powerful framework to create DSLs. We used these capabilities to create the Baloise Service Modelling Language, which allows us to describe services in a concise and truely platform independent manner. The Java-Like DSL has a smooth learning curve for developers and generation of many custom web service artifacts ensures productivity and quality.

We are amazed by the power of Xtext and DSL - since the introduction in our development community more projects have been initiated. We will present background on the decisions that lead us to Xtext and of course the Baloise Service Modelling Language.

Requirements Engineering, Management and Traceability with Eclipse

Jens Trompeter, itemis

Within the scope of requirements engineering, key quality advantages emerge when formal models are created with suitable software tools , e.g. in terms of accuracy, consistency, search options and the traceability of changes. This tool does not necessarily have to be a heavyweight, complicated and expensive standard tool.

With the Eclipse tool YAKINDU Requirements, you describe your requirements with the help of formal models. For this purpose, different specification languages, including an editor, are at one’s disposal for the various elements of your requirements specification. From the consistent modeling information, YAKINDU Requirements generates requirement specifications and other documents at the touch of a button.

Thereby, the specification language for requirements, use cases, business objects, etc. are based on the Eclipse technology Xtext - a framework for the development of domain-specific languages (DSLs).

With Xtext, one’s own DSLs can be created in a short space of time: On the basis of the simple EBNF-grammar of the framework, components such as parsers, meta-models and even mature and fully functional Eclipse-editors are derived automatically. For example, it is possible to complement one’s own DSLs for the modeling of finance products, business rules, etc.

This talk will show how you describe your requirements with the Eclipse tool YAKINDU Requirements and the help of formal models based on Eclipse Xtext.

Model-based UI Transformation to Eclipse Scout

Volkert Barr (Raiffeisen), Peter Nudlin (IBM) & Stephan Leicht (BSI)

For the context of modernizing Raiffeisen's DIALBA system, a large core banking application, we present the approach selected to re-architecture and transform this historically grown system into a modern target architecture involving Java/Eclipse technology.

In a first step using IBM's ACT4 transformation engine the legacy application is parsed from the complete source artifacts into ACT4's model inventory. Definition of layers and system components follow after a dependency analysis on the ACT4 model inventory. All elements of the system are then assigned to their location within the technical and functional target architecture. Finally, the source code for the transformed application is generated per layer and component according to this target architecture.

For the specific case of the Client/UI Layer a formal declarative definition for each module will first be generated by ACT4. A purpose built generator will then produce a modularized Client/UI Application based on the Eclipse Scout framework. The resulting application is then to be executed by an Eclipse Virgo Server.
In addition to presenting an overview of the chosen migration path, the presentation will highlight additional aspects of the transformation process and the target architecture that might be of interest to the audience.