Ciprian-Bogdan Chirila

A logic based approach to locate composite refactoring opportunities in object-oriented code

In todays software engineering, more and more emphasis is put on the quality of object-oriented software design. It is commonly accepted that building a software system with maintainability and reusability issues in mind is far more important than just getting all the requirements fulfilled in one way or another. Design patterns are powerful means to obtain this goal. Tools have been built that automatically detect design patterns in object-oriented code and help in understanding the code. Other tools help in refactoring object-oriented code towards introducing design patterns, but human intelligence is needed to detect where these design patterns should be inserted. This paper proposes a logic approach to the automatic detection of places within object-oriented code where the Composite design pattern could have been used. Suspects identified by such a tool could very well be served as input data for other tools that automatically refactor the code as to introduce the missing design pattern.

Generating logic-based representations for programs

Modern software engineering has come to a point where it deals with quite large and complex software artifacts. Labor-intensive activities such as code analysis and code transformation are becoming less and less tractable on such enormous software systems unless a certain level of automatization is provided. Since automatic approaches of code analysis and code transformation strongly rely on software models instead of actual software systems, the software modeling process is of vital interest to a great deal of researchers in the software engineering community. However, the main drawback of most of the software modeling tools available is the fact that they are aimed at software systems written in a certain programming language. This article introduces ProGen, a software tool capable of modeling software systems written in any language for which a plain JAVACC grammar is available, also describing its advantages and limitations.

A dialog based game component for a competencies based e-learning framework

Traditional education systems are highly theoretical and almost entirely based on student knowledge memorization. Nowadays european society development is focused on practical skills, globalization and competitiveness. Existing romanian e-learning systems tend to present and explain knowledge in a spectacular way using multimedia but none of them are based on the concept of competence. The solution in this sense is a new educational system which is based on competencies achieved in real life scenarios.

A suite of java specific metrics for software quality assessment based on statical code analyzers

Software quality assessment can cut costs significantly from early development stages. On the other hand quality assessment helps in taking development decisions, checking the effect of fault corrections, estimating maintenance effort. Fault density based quality assessment relying on statical source code analyzers need language specific metrics in order to quantify quality as a number. Thus, we identified and defined informally a suite of Java metrics in order to accomplish our quality assessment goal.

Towards a software quality assessment model based on open-source statical code analyzers

In the context of software engineering, quality assessment is not straightforward. Generally, quality assessment is important since it can cut costs in the product life-cycle. A software quality assessment model based on open-source analyzers and quality factors facilitates quality measurement. Our quality assessment model is based on three principles: mapping rules to quality factors, computing scores based on the percentage of rule violating entities (classes, methods, instructions), assessing quality as a weighted mean of the rule attached scores.

Towards a generic gamification of sorting algorithms

Computer science disciplines are very important in the context of an emerging IT industry especially in the Eastern Europe countries where lots of companies invested in research and development sites. The need for highly qualified specialists is very acute and is expressed in several occasions as a request addressed to universities to double the number of bachelor graduates. In this sense universities try to adapt and they provide distance learning programs. In this context all the advantages of software must be used: generative learning objects, gamifications etc. A gamification model for sorting algorithms is proposed in this sense in order to exercise the logic steps of programming and algorithms thus triggering a way of thinking that is needed in the creation of new software. To motivate the student in performing the exercise we used some elements of game mechanics like score and difficulty levels. All the newly created e-learning models are provided to the student through an online Web application.

Generative Learning Object Assessment Items for a Set of Computer Science Disciplines

Learning objects with static content are good for learning and practice, but not much recommended for assessment. The main problem is with content repetition which enables mechanical answer memorization by the student and replication of answers from class neighbors which is considered as an examination fraud. The generative learning object (GLO) is an evolved concept of learning objects (LO) based on reusing the learning patterns. Enhancing GLOs with dynamic content could increase their reusability even more.

Towards programs logic based representation driven by grammar and conforming to a metamodel

Logic representation of programs gives an expressive way to perform analysis and transformation. Logic representation conforming to a specified metamodel enables analysis and transformation at both meta and concrete representation levels. Logic representation mapping rules express how programs can be automatically translated into metamodel conforming logic representation. The designed formalisms are suitable to any programming language.

Generic rules for logic representation transformations

Programs expressed using logic representations can be more easily analysed and transformed. Transformations will depend on the target language semantics. A field encapsulation refactorization will be different for a Java program and an Eiffel program. Logic based representations of programs and its metamodel allows writing generic rules capable of performing some language independent transformations like: syntactical and semantical checking, searching specific nodes, cloning node structures, replacing references, generating fact visualizations. An example is given in this sense related to the implementation of feature body exheritance mechanism of reverse inheritance class relationship in the context of Eiffel language.

Towards logic based representation of XML models

Both code analysis and code transformation are processes that rely on software models instead of actual software systems. In the context of software modeling, we have done so far some efforts to attach logic representation to programs written in any language by using an automatic and grammar-driven approach. However, XML proved to be a difficult candidate for such an approach, because we discovered the XML format is already close to the logic format that we desired, and running our generic grammar-driven approach on XML files would add unnecessary complications. Therefore, we imagined a different technique for transforming XML files into logic models, a technique that preserves useful information already present in XML files. As a benefit of the approach we will show how UML models (also described in XML) can be transformed into logic models and analyzed or transformed further at a logical level.