Sergej Chodarev

Pragmatic model-driven software development from the viewpoint of a programmer: Teaching experience

Model-driven software development is surrounded by numerous myths and misunderstandings that hamper its adoption. We have designed our course of model-driven development approach with the goal to introduce it from the viewpoint of a programmer as a pragmatic tool for solving concrete problems in development process. The course covers several techniques and principles of model-driven development instead of concentrating on a single tool. To explain these techniques we use a case-study that is iteratively developed by the students during the course. In the paper we explain the structure of our case study, contents of individual iterations, and our overall experience with this approach.

Abstract syntax driven approach for language composition

Popularity of domain-specific languages brings the problem of language components reuse. It should be possible to use parts of different languages in development of new one to lower costs and also allow incremental development. This problem could be solved using the composition of languages. In this paper we discuss the view of language composition from the perspective of concepts composition, where the role of concrete syntax is lowered. We present examples of language composition based on the principles of object composition implemented using YAJCo parser generator, that allows to specify the language based on its abstract syntax.

Towards Automated Program Abstraction and Language Enrichment

This paper focuses on the presentation of a method for automated raise of programming language abstraction level. The base concept for the approach is a code pattern -- recurring structure in program code. In contrast to design patterns it has a specific representation at a code level and thus can be parameterized and replaced by a new language element. In the article two algorithms for automated recognition of patterns in samples of programs are described and examined. The paper also presents an approach for language extension based on the found patterns. It is based on an interactive communication with the programming environment, where recognized patterns are suggested to a programmer and can be injected into the language in a form of new elements. Conducted experiments are evaluated in regard to the future perspective and contributions.

Model-aware language specification with Java

Tools that support development of parsers often concentrate on concrete syntax, leaving abstract syntax defined only implicitly. On the other hand there are projectional language workbenches that give central role to language model (abstract syntax) at the cost of locking a language to the concrete tool. In this paper we present YAJCo parser generator that uses model-centered approach to language definition while preserving textual representation. Abstract syntax of a language is expressed using object-oriented model in a general-purpose language with additional information and concrete syntax provided in form of annotations. In the paper we describe how abstract syntax, concrete syntax and semantics of the language are defined using YAJCo. We also describe how this method supports language composition and iterative development.

Development of human-friendly notation for XML-based languages

XML is a popular choice for development of domain-specific languages. In spite of its popularity, XML is a poor user interface and a lot of languages can be improved by introducing custom notation. This paper presents an approach for development of custom human-friendly notation for existing XML-based language together with a translator between the new notation and XML. This approach is based on explicit representation of language abstract syntax that can be decorated with mappings to both XML and the custom notation. The approach supports iterative design and development of the language concrete syntax, allowing its modification based on users feedback. Development process is demonstrated on a case study of language for definition of graphical user interface layout.

Haskell clone detection using pattern comparing algorithm

Detection of clones - repeating fragments in source code - is an important task for ensuring maintainability of software systems. This paper presents an algorithm for clone detection based on comparing parts of abstract syntax tree of programs and finding repeating patterns. The algorithm is implemented in the prototype tool that allows to detect clones in programs written in Haskell programming language. The main contribution is believed to be proposal and experimental verification of the new technique for identifying exact and syntactical clones in Haskell code.

Profile-driven source code exploration

The following study deals with static analysis of Java source codes and it is dedicated to those readers who are interested in techniques aiming at evaluation of programming abilities of job candidates or students. In our case, the goal of the static analysis is to assemble the most significant and interesting data about source code author (programmer). If properly visualized, such assembled data may form programmers profile which, to impartial observer, may further determine authors real programming abilities and his/her habits, both good and the bad ones. The present study represents first experiments attempting to form programmers profile by static analysis of language element frequency. Conclusion offers a broader view, combining also other techniques as a future plan to generate knowledge profiles more precisely.

Bootstrapping DSLs from user interfaces

Implementation of domain-specific languages (DSLs) is supported by powerful tools that can automatically generate various artifacts from the language specification. Domain analysis and design of a language, however, are usually done manually. Automatic extraction of domain information can be used to generate preliminary version of the language specification and therefore bootstrap the development process. One of the most suitable sources of domain information are graphical user interfaces (GUIs). In this paper we present the experiment validating this approach. Several existing applications were automatically analyzed to extract their domain models and generate a DSL processor based on them.

Visual augmentation of source code editors:A systematic mapping study

Source code written in textual programming languages is typically edited in integrated development environments or specialized code editors. These tools often display various visual items, such as icons, color highlights or more advanced graphical overlays directly in the main editable source code view. We call such visualizations source code editor augmentation. In this paper, we present a first systematic mapping study of source code editor augmentation tools and approaches. We manually reviewed the metadata of 5,553 articles published during the last twenty years in two phases -- keyword search and references search. The result is a list of 103 relevant articles and a taxonomy of source code editor augmentation tools with seven dimensions, which we used to categorize the resulting list of the surveyed articles. We also provide the definition of the term source code editor augmentation, along with a brief overview of historical development and augmentations available in current industrial IDEs.