Eclipse Finance Day 2012/Session Abstracts
- 1 Why Model When You Can Just Program?
- 2 What makes an application a “good” application
- 3 Gaining traceability in the world of fragmented Agile ALM stacks
- 4 Usage of ECore+OCL for business modeling in the connection with Excel-based model representation and validation in the Life Insurance business domain
- 5 Experiences from Using EJBs in an Eclipse RCP Application
- 6 Interface Management in a Large Enterprise
- 7 Modularization of large projects using Eclipse and OSGi
- 8 Model Drive Tool Chain for a large Swiss Bank
- 9 Business Capability Modeling and EMF Recapitulation and Developments on Business and Tooling side
- 10 Managing Eclipse Workplaces in the Enterprise
- 11 Model-driven development in the context of technical SOA
- 12 One Vision – One Platform; Eclipse als Plattform für die GUI Integration
- 13 Modernizing a large Counter Application during ongoing operation
- 14 Generating Web Serices with Xtext based DSL
- 15 Requirements Engineering, Management and Traceability with Eclipse
- 16 Model-based UI Transformation to Eclipse Scout
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
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
Markus Hediger (SIX Payment Services) & Philippe Marschall (Netcetera)
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 decomposesIT 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 Drive Tool Chain for a large Swiss Bank
Mario Lovisi (Credit Suisse) and Serano Colameo (itemis) Talk in German
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.
Business Capability Modeling and EMF Recapitulation and Developments on Business and Tooling side
Christian Meier (UBS), Peter Brunner (NTT Data) & Philipp Kutter (Montages)
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 Stol, itemis
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).
One Vision – One Platform; Eclipse als Plattform für die GUI Integration
Remo Lotscher & Christin Spicher, Swiss PostFinance Talk in German
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
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, our service eco system including development as well as cofiguration management and operation 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.