Create new citation styles for MS Word

Have you ever written your thesis or a large scientific paper in MS Word? If yes, you might have used the new citation and bibliography feature of Word that is available from the 2007 version on. Although it simplifies work a lot compared to manual citation, its usability is poor and there are some hidden features and bugs you should be aware of. In this post I will explain them and introduce a template for creating citations and a bibliography that are similiar to the LNI style (Lecture Notes in Informatics) which is required for publications of the GI (Gesellschaft für Informatik).

The template will create entries in the following form:
Bibliography:

[Ger11a] Gerlach S. (2011): Improving efficiency when deriving numerous products from software product lines simultaneously. In: Schäfer I.; John I. und Schmid K. (Hg.): Proceedings of the 15th International Software Product Line Conference. New York, NY, USA: ACM. ISBN 978-1-450-30789-5. S. 9:1‐9:4.

Citation: [Ger11a]

Continue reading

Semantic typing in domain-specific languages

In domain-specific languages (DSL) concepts of the targeted problem-domain are introduced as language constructs. This is done in order to model using these concepts and abstract from specific technical solutions. However, a static typing of the DSL is useful, especially when it is used to calculate values. In DSLs the typesystem can be designed individually just as all the provided language constructs. For this reason, the data types shouldn’t be introduced because of technical differences but because of their semantics in the problem domain. Such semantic type systems and a static typing of a DSLs can prevent semantic errors during modeling by checking for type incompatibilities. This article discusses the idea of semantic typing and shows a concrete implementation in a DSL for creating user interfaces.

Continue reading

Designing Scalable Code Generators for very large Java Projects

Model-driven development is increasingly applied in large industrial projects. When java is used as the target language, some language details have to be considered that do not make any difference in conventional implementation. It is also necessary to take them into account when deciding between code generation and runtime interpretation. In order to make the generators scalable it is important to keep their execution times low. Furthermore, they need to be designed in such a way that changes to the source models result in localized and traceable effects in the generated code. This can be achieved by respecting some basic design rules during development of the code generators.

Continue reading

Improving Efficiency when Deriving Numerous Products from Software Product Lines Simultaneously

In-car infotainment systems must allow for product differentiation and the adaption to the needs of different markets. Product line approaches are applied because large numbers of different product variants need to be developed simultaneously. During development, updated versions of each projected product variant need to be derived from the product line assets repeatedly. Current build tools create each of the numerous product variants one after another. Accordingly, the creation process can take much time. This paper presents an approach to abbreviate this creation process based on the fact that multiple product variants created at once can have parts in common. To benefit from this optimization potential the workflow that creates an individual product variant is subdivided into multiple fragments. Whenever a set of such product variants needs to be created, an optimization algorithm then calculates an individual execution order of the fragments for this set. This order minimizes the total execution time by a systematic reuse of workflow fragment’s results for the creation of multiple different product variants.
Continue reading

Create Event Handlers for WPF frontends in Java

In one of the previous posts I showed how a WPF frontend can be controlled by a Java application. Furthermore, I demonstrated how proxies can be generated automatically that allows for more convenient way of programming the Java part. However, there is no way so far, to handle interaction of the user with the WPF frontend in the Java backend. This posts demonstrates the basics for such an implementation.

It uses the existing socket communication to send an event to the Java program whenever a relevant user interaction with the WPF frontend occurs. The java program interprets the received event and calls the corresponding handler that is selected depending on the type of event. Thus, to determine which event handler is to be called the type of event need to be set during modeling the user interface in XAML. To enable this, we will introduce a new attached property available to all controls.
Continue reading

Generate graphical Visualizations for textual DSLs

The advantage of using a textual notation for models is that no special editors are required to create and edit these models. Furthermore, the models can also be diffed and merged using standard tools. Such textual notations are particularly suitable for expert tools. Graphical notation, on the other hand, illustrate complex relations and are often easier to understand. The combination of both notations makes optimum use of their particular benefits.

In this post I will demonstrate how we can achieve this goal by enhancing the textual Xtext editors with graphical visualizations. The visualization will be shown in a view within the Eclipse IDE. Thus, we will use the SWT-based Zest toolkit for rendering.

Continue reading

Examples of Visual Effects in WPF/XAML

In this post we will create a WPF application that shows an color changing logo reflected on a polished surface. We will use nothing but XAML to create visual effects such as mirroring, a horizon, a spotlight and dynamic colorization of a grayscale image.

Continue reading