JUnit error when testing an Xtext DSL

DSL, Xtext

As part of a research idea, I’m now creating a language to write Use Cases, using Xtext. It is also a good opportunity to analyze more deeply this framework for building textual DSLs in Eclipse.

But this is not why I’m writing this post. After I wrote the language specification, I wanted to create some tests. I followed the very brief tutorial and wrote a simple test. However, It didn’t work. The failure trace in JUnit always presented an error:

org.eclipse.xtext.parser.ParseException: java.lang.IllegalStateException: Unresolved proxy http://wwww.levysiqueira.com.br/MyLanguage.ecore#//Element.Make sure the EPackage has been registered.

at org.eclipse.xtext.parser.antlr.AbstractAntlrParser.doParse(AbstractAntlrParser.java:105)
... Continue reading →

Crítica – Livro "VHDL – Descrição e Síntese de Circuitos Digitais"

Book review, Português, VHDL

Decidi escrever, em português, algumas críticas de livros que estou lendo e, a primeira delas é sobre o livro “VHDL – Descrição e Síntese de Circuitos Digitais” de Roberto d’Amore (2ª Edição, LTC, 2012). Gostaria de deixar claro que não tenho nenhuma relação com o autor ou com a editora e, portanto, a crítica representa simplesmente a minha opinião sobre o livro. Esse livro apresenta a linguagem de descrição VHDL, enfatizando o seu uso para a síntese de circuitos digitais.
Continue reading →

Inheritance in QVTo

QVT, QVTo

An interesting feature in QVT Operational Mapping language (QVTo) is mapping reuse. Differently from QVT Relations (QVTr), the QVTo language has some concepts that allow reusing mappings easily, and, more importantly, in an organized way. One of these concepts is mapping inheritance.

When I first saw this concept, I expected (or hoped) it would allow specializing an existing mapping similar to what happens in a object-oriented language – maybe because I am an OO programmer/designer. To my frustration, it does not… Moreover, I think it has a strange semantics that is more similar to an “include”. Yet, a truly “inheritance” can be an interesting and useful concept to allow mapping reuse in QVTo.

Before discussing what I think would be a more interesting semantics, let me explain how it works in QVTo. Continue reading →

Using black box implementations in Eclipse QVTo

QVTo, Tutorial

In QVT, it is possible to execute external code in a transformation. According to the standard, it has some benefits (QVT, 2009, p.10):

  • It allows complex algorithms to be coded in any programming language with a MOF binding (or that can be executed from a language with a MOF binding).
  • It allows the use of domain specific libraries to calculate model property values. For example, mathematical, engineering, bioscience and many other domains have large libraries that encode domain-specific algorithms which will difficult, if not impossible to express using OCL.
  • It allows implementations of some parts of a transformation to be opaque.

The external code is called a “black box implementation”.

Using this concept, in Eclipse QVTo it is possible to execute an external Java code. In this post I will describe how you can easily create a black box implementation to execute a math sine operation. Continue reading →

PhD Thesis

Thesis

Here it is, finally, my PhD thesis in Computer Engineering. It is in Portuguese and its original title is “Transformação de um Modelo de Empresa em um Modelo de Casos de Uso seguindo os Conceitos de Engenharia Dirigida por Modelos” – which can be translated to “Transforming an Enterprise Model into a Use Case Model using Model-Driven Engineering Concepts”. Continue reading →

Essential Use Case Meta-model

Use Case

There are several meta-models and templates for use case textual description. These representations have different goals and viewpoints, thus proposing different concepts, or different relationship between concepts, or even different semantics for a concept.

Because some MDE works need to use a basic use case meta-model as part of the transformation, in this paper in WER 2011; I proposed an essential use case meta-model. This meta-model was based on a survey on existing meta-models and templates (the analysis of these concepts is available in this post).

Due to space limitations, the paper only presents part of the meta-model abstract syntax and semantics (textually). In this post I will make available the full abstract syntax and concrete syntax using XML (for the semantics, please refer to the original paper).

The meta-model’s abstract syntax is presented next, using a MOF class diagram. The Ecore file is available here. The original meta-model was adapted to include three meta-classes: UseCaseModel, Agent and Subject. Agent and Subject were included to represent who executes a Step – if a Subject (the System) or an Actor – an Agent is simply a generalization of Subject and Actor.

Essential Use Case Meta-model Continue reading →

Common Elements in a Use Case

Use Case

I’ve published a paper in WER 2011 that analyzes the most common elements of a use case textual representation and proposes a meta-model considering them. Due to lack of space, it wasn’t possible to include the original tables used in the analysis. During the workshop I’ve promised that I would make it available somewhere… and I’m finally fulfilling this promise. Here it is the first table, analyzing the main concepts proposed by some templates and meta-models.

Continue reading →

Transformation localization in QVTo

QVT, QVTo

Last week I’ve decided to translate my QVTo transformation to Portuguese. I’m preparing an experiment that uses this transformation, and my subjects are Brazilian students. So it wouldn’t be appropriate to have English texts in the obtained transformation. It would be a silly independent variable to consider…

So, how can I make my transformation outputs a Portuguese text? A simple solution would be to copy my existent code and just translate it. Easy… But an horrible solution. If I ever change my transformation code, due to this solution I would have to change in 2 places instead of just one. It’s the common “copy-paste in maintenance” problem.

So, how can I create an elegant localization solution? Using the Dictionary type defined in the QVTo Standard Library (defined in the QVT standard), I decided to use the following solution:

  • Create 2 dictionaries: one for English text and one for Portuguese text.
  • Create a “configuration property” so the user can select the language without touching the transformation code.
  • Create a query that returns the message asked, considering the selected dictionary.
  • Create a library for this localization query, separating it to my original code.

Continue reading →