it systemloesungen OG, Andreas-Hofer-Strasse 22, 6067 Absam
working for 3 years on our libraries to write desktop business applications,
have to download and install our libraries to get an impression of its
series "goodbye expensive software development" will be available in
problem areas of modern software development for custom applications,
Here a link to the issue: https://jaxenter.de/magazines/Java-Magazin-314-170797
going productive with some of our generated user-interfaces in java FX, we set
proposed workaround is not a single measure, but a whole series of steps to
ensure the cleanup.
(Pic 1: Cleanup code used)
applying this workaround in our TableForm component, we recognize a total heap
size of aprox.
Forms3 is our DSL to model user-interfaces for typical business applications on a logical level. Up to now, models were translated
by code generators to java-code using apache pivot as UI-library. With some help from our friends from bestsolution.at we recently
switched to the javaFX stack.
Since our DSL specifies user-interfaces in a pure logical form, i.e. without any dependencies on the underlying UI-library, we could
simply regenerate existing business-applications and run them in the javaFX environment.
JavaFX will allow us to take advantage of e(fx)clipse and the whole osgi-environment as future runtime for business-applications.
Furthermore, this was a first "prove of concept" that underlying technology stacks can be exchanged quite easily.
In Summer 2012 we used the mbeddr toolkit to generate C code out of modelled tests. mbeddr
supports embedded software development based on an extensible version of the C programming
language and an IDE. We recently wrote a case study, where we summarized our experiences made and
some lessons learned. Feel free to contact us for further information.
After almost two years of research we summarized the „status quo“ in a couple of slides (german only).
As described in the slides, we propose to develop enterprise applications around a few but very central concepts, i.e.
(1) Processes and Conditions
(2) commands and
Some explanations of the concepts and the supporting engineering-process can be found in the slides.
Our goal for Spring 2012 is to further develop the codegenerators to reach an initial release,
generating OSGi-packages and javaFX userinterface for fat-client usage.
We recently wrote a paper describing our two DSLs to model business applications. I attached a pdf version of the paper to this post. Hope there are some interesting thoughts for you. Feel free to contact me in case of questions.
Here is the paper! mps_showcase.pdf
Instead of discussing language modularization, -composition or -extension in theory, i am going to give you a brief
glimpse from a practical perspective by pointing out some major aspects of our business-application DSL´s: objectflow and
forms. Both DSL´s were built with jetbrains Meta Programming System. In this blog entry i will focus on objectflow since
we issued the first release of the DSL this week.
Objectflow builds on the ideas of Eric Evans´ paradigm of domain-driven design (DDD). Any data (entities or value objects
in DDD terms) can be modelled as objectflow business objects with various attributes and references. For example, an
invoice with invoice positions is modelled as a business object invoice containing a collection of invoice position business
objects. The invoice becomes a so called “root aggregate”, when functionality or operations are added in a dedicated invoice
service. Basically, all necessary functionality has to be put into a service and in turn, the service has to be related to a
business object. Thus, although Objectflow services can be written in plain java, the structure and building blocks of
services are standardized. Particularly this standardization results in more transparency and higher code quality by also incorporating
the flexibility of the java language itself.
Objectflow also takes advantage of a very strong collection language from MPS, which can be applied in services. Building
unions of invoices or summing up a collection of invoices are central operations in business and should therefore be
supported with a very clear and handy syntax. The collection language employed with objectflow provides the means to build
expressive queries using closures - in a way similar to Microsoft´s LINQ.
The very same high level collection language is also used in objectflow to handle database queries. Objectflow allows the
developer to create a so called “repository” containing various queries for business objects. Instead of generating java code,
SQL queries as well as their mappings to related database table fields with business object properties are generated automatically.
Thus the developer is no longer challenged by technical implementation details like mapping or database querying.
Of course, objectflow actively supports test driven development. Developers can create a new executable testsuit - tailored
to test business logic- with just one click. The testsuit contains pretest-data and posttest-data, both described in simple
json-notation. Pretest-data contains necessary data saved in business objects, which gets built and initialized before running a test.
Posttest-data contains expected outcomes which are compared with actual data from the test by posttest-checker methods.
To get a service tested, just shovel some pretest-data into a service and check it after execution with expected results.
In our initial case of invoices, one can test a booking services with a pretest invoice and posttest booking lines.
Feel free to contact me for further explanations. In the forthcomming blog entry, i am going to present some code examples
and screenshots from the forms DSL. See you soon...
Starting in October 2010, modellwerkstatt developed three domain specific languages (DSL) in order to model the requirments of business applications. The DSL´s are programming languages pretty close to java, but with unique features to easy and accelerate the development of business applications. Major features common to standard business applications are implemented in code generators. This is not only improving time to market, but also increasing standardization and code quality. Please refer to Martin Fowler to get a more in detail explanation of the theory behind DSLs (http://martinfowler.com/bliki/DomainSpecificLanguage.html).
The three languages were developed in Jetbrains MPS:
We have created two sceencasts to point out the power of DSL modelling. A simple BusinessObject “customer” should be handled. The whole business application is built from scratch. In screencast 1 we are creating the application with a view, in screencast 2 we add editing features to the application. Hope you enjoy the videos … although we have German versions only right now...
The next screencasts will be available in english. We will demonstrate input validation, wizzards, advanced queries and how a service can be implemented with a powerful collection language and preconditions. Stay tuned!