- Profit from over 100 example languages
- Reading and writing data formats in a comprehensible way
- Automate arbitrary refactorings
- Perform flexible visualisation and analysis of Java-based software
- Manage variants and keep the overview
- Keep code and documentation maintainable despite of many versions
- Realise reuse in a new dimension
- Import instead of duplicate
- Reduce costs and effort in DSL development
- Reuse proven concepts in multiple projects
- Replace time-consuming manual specification by code generation
- Identify more errors at development time
- Recognise problems instantly when they are caused
- Leave testing to tools and use your time for development
Big software systems are composed of a great number of artefacts. Although it often appears as if the code is the only source of information, there are a lot of other sources that define a system: XML files, databases, Excel spreadsheets. These different formats are often insufficiently connected. As a result, issues are recognised too late - sometimes only after the software was deployed. Consequently, an improved linkage between all information during system development time is essential to improve efficiency and quality.
The well-known Eclipse-based open source tool EMFText, developed by DevBoost and TU Dresden, provides the technical foundation to aggregate information from different sources into an integrated model. The strength of EMFText lies in the ability to connect existing formats in no time. For this, we leverage widespread standards (MOF and XMI of the Object Management Group) and the corresponding implementations (EMF and Ecore). With this, we are able to process different kinds of artefacts with a large number of tools. In addition, EMFText generates Eclipse editors to edit the different formats more efficiently.
Many widespread formats are already integrated with EMFText. This includes, among others, Java code, XML files, database schemas, configuration files and CSV files. Furthermore, there are a number of new formats and languages available for the compact specification of selected aspects of a software system. Examples are HEDL, for the specification of Hibernate entities, Functions, for system analysis, and QuickUML for a compact textual specification of UML models. A complete list of all freely available languages is available from the EMFText Zoo.
We are happy to discuss with you how you can profit from EMFText. We develop high-quality tools for you with EMFText or train you and your team in the handling of EMFText. Feel free to contact us.
Today, Java code makes up a large part of most enterprise systems. To keep these systems maintainable, extendable and flexible in the long run, constant checking of the consistency of code and other artefacts is necessary. Coding guidelines need to be followed, anti-patterns need to be avoided and interfaces need to be used correctly. To save costs and to prevent mistakes during theses tasks, a high degree of automation is desirable.
JaMoPP, one of our open source tools, addresses theses challenges. JaMoPP automatically converts your Java code base into an EMF-conformant model. This model can be processed by a large number of tools. Additionally, the model can be linked with other files, such as property or CSV files. Linkages to data from an SQL database are also supported. On the base of this integrated model, individual guidlines for your software can be defined. This way, structural problems are recognised instantly and, if required, repaired automatically.
We are happy to analyse if and how individual guidelines can support the quality control in your application. Feel free to contact us.
Variability in modelling and implementation.
If a software product is sold to different customers, a product line is emerging. In this situation, it is particularly important to reuse common parts of the software for all customers. At the same time, the adjustment of customer-specific parts needs to stay practical. To assure efficient and consistent reuse as well as variant creation, specialised tools are required.
The software product line tool FeatureMapper, developed in cooperation between DevBoost and TU Dresden, addresses exactly this problem. It offers a universal approach to describe mappings between features and arbitrary software parts. With these mappings, customer-specific products can be automatically generated. Thanks to its integration with the Eclipse Modelling Framework (EMF), FeatureMapper can be utilised in combination with arbitrary textual and graphical languages. Combined with JaMoPP, FeatureMapper can process Java source code.
DevBoost can support you in introducing software product lines in your company. We offer coaching for using FeatureMapper in the context of your company or adjust FeatureMapper to the application on the modelling and programming languages used by your company. Feel free to contact us.
Architecture lives of components.
Good software architecture requires a separation of the software system into components. How a system is broken down into components depends on many factors. Should the components be exchangeable at runtime? Do the components have to realise certain non-functional properties? Are the components developed by multiple teams? Do different customers need different implementations of a component? Which components are actually supported by the used programming languages, modelling languages and frameworks?
DevBoost and TU Dresden develop Reuseware as an open source tool that supports the development of customised components. With Reuseware, arbitrary artefacts can be decomposed, parameterised and automatically recomposed. Additionally, different kinds of artefact fragments (e.g., Java code snippets or XML fragments), which are conceptually connected, can be encapsulated into one component.
If you plan to improve the structure, reusability and variability of your application by using components, we might be able to help. Feel free to contact us.
Modelling languages made to measure.
The rising interest in Domain Specific Languages (DSLs) and Model-Driven Software Development increases the need for methods and technologies for the efficient development of modelling languages. However, the requirements for modelling languages differ from company to company. Only if one succeeds to adjust languages to specific needs, that is to build so called language families, the necessary efficiency in language development can be reached.
The language development tool LanGems, which is developed by DevBoost and TU Dresden, offers a solution in this problem area. LanGems transfers methods of software product line development to language development. Furthermore, it leverages innovative techniques for the modular development of syntax and semantics of modelling languages.
LanGems is applied in multiple companies to customise language families - for example for languages to model domain knowledge in ontologies (OWL) and for defining constraints in object-oriented systems (OCL). The application area of language families, however, is much broader. It is applicable in all areas in which structural modelling is a concern and in which the need to adjust modelling languages is constantly present.
We are happy to analyse your development process for the potential of language families and support you in introducing customised and efficient modelling languages. Feel free to contact us.
Hibernate is probably the most popular framework for object-relational mapping. It implements the Java Persistence API (JPA) and is productively used in a great deal of projects. We at DevBoost also use Hibernate and value this way of accessing relational databases. However, our experiences with the framework showed us that there is potential for improvement.
HEDL (Hibernate Entity Definition Language), a Domain Specific Language (DSL) for Hibernate, allows a compact specification of entities. A large amount of methods and annotations, which usually need to be coded manually, are generated by HEDL automatically. For instance, each entity is automatically equipped with a unique ID as well as getters and setters for all its properties. HEDL supports the definition of uniqueness constraints over one or multiple properties, contains pre-defined data types and makes the definition of 1-to-n and n-to-m references a breeze. HEDL generates, for each entity, Java code with Hibernate annotations and, in addition, Data Access Objects (DAOs), which contain convenient methods to create or find entities. With this, the effort to create these Java classes is reduced to a minimum.
HEDL is an open source project that is freely available under the Eclipse Public License (EPL). Try it out yourself. Install HEDL in your Eclipse environment and profit from Hibernate more than ever.
JUnit is the foundation of Test-Driven Development (TDD) in the Java world. Although, every Java developer should know JUnit and use it, the full potential of TDD is seldom exploited. On the one hand, too few tests are written in the first place. On the other hand, existing tests are not maintained. One reason for this is insufficient tool support which leads to unnecessary efforts concerning the creation, adjustment and execution of tests.
JUnitLopp extends existing JUnit tools to address this problem. It runs tests automatically, when the code that is covered by the test was changes. This relieves the developer from the task of running tests manually. They only need to act when necessary; when a test fails. With JUnitLoop, such a failure is recognised immediately when changes are made. Thus, the problem is recognised much faster and can be fixed more efficiently. Testing and fixing is therefore seamlessly integrated in the standard development process.
JUnitLoop is an open source project that is freely available under the Eclipse Public License (EPL). Try it out yourself. Install JUnitLoop in your Eclipse environment and profit from efficient Test-Driven Development.