Milan Nosál

Leveraging Program Comprehension with Concern-oriented Source Code Projections

In this paper we briefly introduce our concern-oriented source code projections that enable looking at same source code in multiple different ways. The objective of this paper is to discuss projection creation process in detail and to explain benefits of using projections to aid program comprehension. We achieve this objective by showing a case study that illustrates using projections on examples. Presented case study was done using our prototypical tool that is implemented as a plugin for NetBeans IDE. We briefly introduce the tool and present an experiment that we have conducted with a group of students at our university. The results of the experiment indicate that projections have positive effect on program comprehension.

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.

Reusable software documentation with phrase annotations

ProblemReoccurring software documentation fragments called documentation phrases crosscut documentation body and introduce undesired redundancy. The redundancy imposes problems with software documentation development and evolution.ObjectiveWe want to reduce the negative effect caused by documentation phrases redundancy by centralizing the documentation phrases sources. This way a documentation phrase will have a single source that can be used for maintenance and evolution.MethodWe discuss the nature of documentation phrases and argue for the support of their parametrization. We present a new documentation phrase instantiation method based on source code annotations. The provides free IDE support for writing documentation and is aided by our tool prototype.Results and contributionsOur contributions of this paper include identification of documentation phrase parametrization and the annotation-based documentation phrase instantiation. The annotation-based documentation phrase instantiation method enables to reduce the effort needed for documentation development and evolution.

Program comprehension with four-layered mental model

Program comprehension deals with an important problem of recreating mental model of the software system from the source code. This process is needed every time a new programmer joins the development team, or the old one forgets about the code. We designed the four-layered model of the developers mental model that provides a deeper understanding of the mental model and of the program comprehension in general. The described model was verified by an observatory study with 3 subjects. This paper concludes with our findings and conclusions.

XML to Annotations Mapping Patterns.

Configuration languages based on XML and source code annotations are very popular in the industry. There are situations in which there are reasons to move configuration languages from one format to the other, or to support multiple configuration languages. In such cases mappings between languages based on these formats have to be defined. Mapping can be used to support multiple configuration languages or to seamlessly move configurations from annotations to XML or vice versa. In this paper, we present XML to annotations mapping patterns that can be used to map languages from one format to the other.

Towards developer-friendly annotation-based code generation

This paper discusses a generative programming technique based on attribute-oriented programming (source code annotations) and aspect-oriented programming. We propose an annotation-based generator framework that combines these two techniques to provide a rapid and easy-to-use implementation options for annotation-based generators. The framework is inspired by internals of the industrial rapid application development tool Spring Roo. We discuss how the technique used in Spring Roo can be enhanced using Convention over Configuration principle. The paper briefly presents the generator framework prototype - AnBaG. We conclude with a discussion that compares the Spring Roo generation with AnBaG.

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.

Practical experience with task-driven case studies

The problem of effective teaching of programming is still open. Students still face problems with learning and especially understanding of even basic programming principles. In this paper we present our experiences with our modern teaching method for programming that is basically a combination of the task-driven methodology and case study approach. This new method is called task-driven case study approach. In the paper we share our own experiences from the viewpoint of teachers, but we also present results of a survey done with 112 of our students. Presented results show positive experience both from viewpoint of students and teachers.

Performing experiments in 3rd party premises using cloud-based virtual machine as remote laboratory: Case study of controlled experiment with high school students in their school

In this paper we use a case study of a controlled experiment to present a flexible laboratory architectural solution to controlled experiment environments. In our case we used a virtual machine as a remote laboratory to enable a convenient experimentation. Thanks to our architecture we were able to automate and centralize the environment administration, and data collection. In this paper we discuss the advantages and disadvantages of the approach.

Unified compile-time and runtime java annotation processing

Java provides two different options for processing source code annotations. One of them is the annotation processing API used in compile time, and the other is the Reflection API used in runtime. Both options provide different API for accessing program metamodel. In this paper, we examine the differences between those representations and we discuss options on how to unify these models along with advantages and disadvantages of this approach. Based on this proposal, we design a unified Java language model and present a prototype tool which can populate a unified model during both compilation and runtime. The paper includes the designed API of this unified language model. To verify our approach, we have performed experiments to show the usability of the unified metamodel.