Eclipse Finance Day 2012/Session Abstracts
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.