Pedro Rangel Henriques

Comparing general-purpose and domain-specific languages: An empirical study

Many domain-specific languages, that try to bring feasible alternatives for existing solutions while simplifying programming work, have come up in recent years. Although, these little languages seem to be easy to use, there is an open issue whether they bring advantages in comparison to the application libraries, which are the most commonly used implementation approach. In this work, we present an experiment, which was carried out to compare such a domain-specific language with a comparable application library. The experiment was conducted with 36 programmers, who have answered a questionnaire on both implementation approaches. The questionnaire is more than 100 pages long. For a domain-specific language and the application library, the same problem domain has been used - construction of graphical user interfaces. In terms of a domain-specific language, XAML has been used and C# Forms for the application library. A cognitive dimension framework has been used for a comparison between XAML and C# Forms.

Automatic generation of language-based tools using the LISA system

Many tools have been constructed using different formal methods to process various parts of a language specification (e.g. scanner generators, parser generators and compiler generators). The automatic generation of a complete compiler was the primary goal of such systems, but researchers recognised the possibility that many other language-based tools could be generated from formal language specifications. Such tools can be generated automatically whenever they can be described by a generic fixed part that traverses the appropriate data structures generated by a specific variable part, which can be systematically derivable from the language specifications. The paper identifies generic and specific parts for various language-based tools. Several language-based tools are presented in the paper, which are automatically generated using an attribute grammar-based compiler generator called LISA. The generated tools that are described in the paper include editors, inspectors, debuggers and visualisers/animators. Because of their complexity of construction, special emphasis is given to visualisers/animators, and the unique contribution of our approach toward generating such tools.

Program comprehension for domain-specific languages

In the past, we have been looking for program comprehension tools that are able to interconnect operational and behavioral views, aiming at aiding the software analyst to relate problem and program domains in order to reach a full understanding of software systems. In this paper we are concerned with Program Comprehension issues applied to Domain Specific Languages (DSLs). We are now willing to understand how techniques and tools for the comprehension of traditional programming languages fit in the understanding of DSLs. Being the language tailored for the description of problems in a specific domain, we believe that specific visualizations (at a higher abstraction level, closer to the problem level) could and should be defined to enhance the comprehension of the descriptions in that particular domain.

Automatic Generation of Language-based Tools

Many tools can be automatically derived from formal language definitions, such as compilers/interpreters, editors, analyzers, visualizers/animators, etc. Some examples of language-based tools generated automatically by the LISA system are described in the paper. In addition the specification of an algorithm animator and program visualizer, Alma, generated from an extended LISA input-grammar is discussed; LISA principles and code are reused in Alma implementation.

Plagiarism Detection: A Tool Survey and Comparison

We illustrate the state of the art in software plagiarism detection tools by comparing their features and testing them against a wide range of source codes. The source codes were edited according to several types of plagiarism to show the tools accuracy at detecting each type. The decision to focus our research on plagiarism of programming languages is two fold: on one hand, it is a challenging case-study since programming languages impose a structured writing style; on the other hand, we are looking for the integration of such a tool in an Automatic-Grading System (AGS) developed to support teachers in the context of Programming courses. Besides the systematic characterisation of the underlying problem domain, the tools were surveyed with the objective of identifying the most successful approach in order to design the aimed plugin for our AGS.

AspectLISA: an aspect-oriented compiler construction system based on attribute grammars

The use of object-oriented techniques and concepts, like encapsulation and inheritance, greatly improves language specifications towards better modularity, reusability and extensibility. Additional improvements can be achieved with aspect-oriented techniques since semantic aspects also crosscut many language constructs. Indeed, aspect-oriented constructs have been already added to some language specifications. The LISA compiler construction system follows an object-oriented approach and has already implemented mechanisms for inheritance, modularity and extensibility. Adding aspects to LISA will lead to more reusable language specifications. In the paper, aspect-oriented attribute grammars are introduced, and the underlying ideas are incorporated into AspectLISA, an aspect-oriented compiler generator based on attribute grammars.

Assertion-based Slicing and Slice Graphs

This paper revisits the idea of slicing programs based on their axiomatic semantics, rather than using criteria based on control/data dependencies. We show how the forward propagation of preconditions and the backward propagation of post conditions can be combined in a new slicing algorithm that is more precise than the existing specification-based algorithms. The algorithm is based on (i) a precise test for removable statements, and (ii) the construction of a slice graph, a program control flow graph extended with semantic labels. It improves on previous approaches in two aspects: it does not fail to identify removable commands; and it produces the smallest possible slice that can be obtained (in a sense that will be made precise). The paper also reviews in detail, through examples, the ideas behind the use of preconditions and post conditions for slicing programs.

TM-Builder: An Ontology Builder based on XML Topic Maps

Everyday a huge number of new information resources are linked to the web. This way the web is growing very fast, making search tasks more and more difficult with worse results. To solve the problem several initiatives were undertaken and a new area of research and development emerged: the one called Semantic Web. When we refer to the semantic web we are thinking about a network of concepts. Each concept has a group of related resources and can be related to other concepts; we can then use this concept network to navigate among web resources or simply among information resources. From the undertaken initiatives one became an ISO standard: Topic Maps ISO 13250. The aim of this paper is to introduce a Topic Map (TM) Builder , that is a processor that extracts topics and relations from instances of a family of XML documents. A TM-Builder is strongly dependent on the resources structure. So, to extract a topic map for different collections of information resources (sets of documents with different structures) we have to implement several TM-Builders, one for each collection. This is not very easy! To overcome this inconvenient we have created an XML abstraction layer for TM-Buildersthat enables us to specify the topic map we want to build from a concrete family of resources, in order to generate automatically the intended extractor. To describe that process, i.e. the extraction of knowledge from XML documents to produce a TM, we present a language to specify topic maps for a class of XML documents, that we call XSTM (XML Specification for Topic Maps). We also discuss a XSL processor that automatically generates the Extractor from its formal specification written in XSTM, the XSTM-P.

Topic maps constraint languages: understanding and comparing

Topic map constraint language (TMCL) provides a means to express constraints on topic maps conforming to ISO/IEC 13250. In this article, we will use a test suite and show, step-by-step, the way we handled several kinds of topic maps constraints in many different instances in order to answer questions like: Do they do the same job? Are there some kinds of topic maps constraints that are easier to specify with one of them? Do you need different background to use the tools? Is it possible to use them in similar situations (the same topic maps instances)? May we use them to produce an equal result? How do AsTMa!, OSL, Toma and XTche relate to TMCL? What kind of constraints each one of these three cannot specify? We will conclude this paper with a summary of the comparisons accomplished between those topic maps constraint languages over the use case proposed.

GamaSlicer: an online laboratory for program verification and analysis

In this paper we present the GamaSlicer tool, which is primarily a semantics-based program slicer that also offers formal verification (generation of verification conditions) and program visualization functionality. The tool allows users to obtain slices using a number of different families of slicing algorithms (precondition-based, postcondition-based, and specification-based), from a correct software component annotated with pre and postconditions (contracts written in JML-annotated Java). Each family in turn contains algorithms of different precision (with more precise algorithms being asymptotically slower). A novelty of our work at the theoretical level is the inclusion of a new, much more effective algorithm for specification-based slicing, and in fact other current work at this level is being progressively incorporated in the tool. The tool also generates (in a step-by-step fashion) a set of verification conditions (as formulas written in the SMT-lib language, which enables the use of different automatic SMT provers). This allows to establish the initial correctness of the code with respect to their contracts.