A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Towards correct-by-construction product variants of a software product line: GFML, a formal language for feature modules

Software Product Line Engineering (SPLE) is a software engineering paradigm that focuses on reuse and variability. Although feature-oriented programming (FOP) can implement software product line efficiently, we still need a method to generate and prove correctness of all product variants more efficiently and automatically. In this context, we propose to manipulate feature modules which contain three kinds of artifacts: specification, code and correctness proof. We depict a methodology and a platform that help the user to automatically produce correct-by-construction product variants from the related feature modules. As a first step of this project, we begin by proposing a language, GFML, allowing the developer to write such feature modules. This language is designed so that the artifacts can be easily reused and composed. GFML files contain the different artifacts mentioned above.The idea is to compile them into FoCaLiZe, a language for specification, implementation and formal proof with some object-oriented flavor. In this paper, we define and illustrate this language. We also introduce a way to compose the feature modules on some examples.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301

Development of a process simulator using object oriented programming: Information modeling and program structure

Object Oriented Programming Languages (OOPL) offer the flexibility of language extension to the specific application of interest. The development effort required for process simulators can be greatly reduced if we extend OOPL with process simulator specific objects and use them for simulation. Design of objects is the most important aspect of development in using OOPL. But OOPL do not provide a methodology to aid in object design. The objects to be designed should reflect the nature of the application at hand.;The objective of this work is to develop an object oriented process simulator to illustrate the benefit of using OOPL in process simulation. An object design criteria is established, an analysis of the object model is performed, and a steady state process simulator using sequential and simultaneous approaches is developed using C++ as the underlying implementation language.;It is found that the object model has to be extended with operational behavior to effectively represent the process simulation information, the development effort is greatly reduced by using the object oriented approach for the process simulator, OOPL can act as common platforms for integrating process engineering activities, and C++ can be effectively used as an implementation language for object oriented process simulation.;Further work is necessary to extend the simulator with dynamic simulation capabilities and to make the simulator interactive and user friendly by developing a graphic interface

Assessing Students’ Object-Oriented Programming Skills with Java: The “Department-Employee” Project

Java is arguably today’s most popular and widely used object-oriented programming language. Learning Java is a daunting task for students, and teaching it is a challenging undertaking for instructors. To assess students’ object-oriented programming skills with Java, we developed the “Department-Employee” project. In this article, we review the history of object-oriented programming and provide an overview of object-oriented programming with Java. We also provide the project specification as well as the course background, grading rubric, and score reports. Survey data are presented on students’ backgrounds, as well as students’ perceptions regarding the project. Results from the instructor score reports and student perceptions show that the “Department-Employee” project was effective in assessing students’ object-oriented programming skills with Java

Study of fault-tolerant software technology

Presented is an overview of the current state of the art of fault-tolerant software and an analysis of quantitative techniques and models developed to assess its impact. It examines research efforts as well as experience gained from commercial application of these techniques. The paper also addresses the computer architecture and design implications on hardware, operating systems and programming languages (including Ada) of using fault-tolerant software in real-time aerospace applications. It concludes that fault-tolerant software has progressed beyond the pure research state. The paper also finds that, although not perfectly matched, newer architectural and language capabilities provide many of the notations and functions needed to effectively and efficiently implement software fault-tolerance

Improving Reuse of Distributed Transaction Software with Transaction-Aware Aspects

Implementing crosscutting concerns for transactions is difficult, even using Aspect-Oriented Programming Languages (AOPLs) such as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern consists of loosely-coupled abstractions like dynamically-generated identifiers, timestamps, and tentative value sets of distributed resources. Current AOPLs do not provide joinpoints and pointcuts for weaving advice into high-level abstractions or contexts, like transaction contexts. Other challenges stem from the essential complexity in the nature of the data, operations on the data, or the volume of data, and accidental complexity comes from the way that the problem is being solved, even using common transaction frameworks. This dissertation describes an extension to AspectJ, called TransJ, with which developers can implement transaction-related crosscutting concerns in cohesive and loosely-coupled aspects. It also presents a preliminary experiment that provides evidence of improvement in reusability without sacrificing the performance of applications requiring essential transactions. This empirical study is conducted using the extended-quality model for transactional application to define measurements on the transaction software systems. This quality model defines three goals: the first relates to code quality (in terms of its reusability); the second to software performance; and the third concerns software development efficiency. Results from this study show that TransJ can improve the reusability while maintaining performance of TransJ applications requiring transaction for all eight areas addressed by the hypotheses: better encapsulation and separation of concern; loose Coupling, higher-cohesion and less tangling; improving obliviousness; preserving the software efficiency; improving extensibility; and hasten the development process

EASY-SIM: A Visual Simulation System Software Architecture with an ADA 9X Application Framework

Software architectures increase productivity when used as the basis for developing applications in a problem domain. This thesis describes the creation of Easy-Sim, an object-oriented software architecture for visual simulation systems, and its corresponding implementation as an application framework in Ada 9X. The research built upon ObjectSim, an existing object-oriented simulation architecture implemented as a application framework. Both ObjectSim and Easy-Sim operate on Silicon Graphics platforms and use the IRIS Performer graphics programming library. Easy-Sim is implemented using version 1.83 of the GNAT compiler. The investigation for this thesis involved honing ObjectSim\u27s design, implementing the improved result in both C++ and Ada 9X, and developing applications to compare the two versions. The study achieved two main objectives: producing Easy-Sim as an improved visual simulation system architecture by building on ObjectSim\u27s experience, and producing a visual simulation system application from Easy-Sim in Ada 9X that performs at a level comparable to the same application built in C++

Tools and Models for High Level Parallel and Grid Programming

When algorithmic skeletons were first introduced by Cole in late 1980 the idea had an almost immediate success. The skeletal approach has been proved to be effective when application algorithms can be expressed in terms of skeletons composition. However, despite both their effectiveness and the progress made in skeletal systems design and implementation, algorithmic skeletons remain absent from mainstream practice. Cole and other researchers, focused the problem. They recognized the issues affecting skeletal systems and stated a set of principles that have to be tackled in order to make them more effective and to take skeletal programming into the parallel mainstream. In this thesis we propose tools and models for addressing some among the skeletal programming environments issues. We describe three novel approaches aimed at enhancing skeletons based systems from different angles. First, we present a model we conceived that allows algorithmic skeletons customization exploiting the macro data-flow abstraction. Then we present two results about the exploitation of meta-programming techniques for the run-time generation and optimization of macro data-flow graphs. In particular, we show how to generate and how to optimize macro data-flow graphs accordingly both to programmers provided non-functional requirements and to execution platform features. The last result we present are the Behavioural Skeletons, an approach aimed at addressing the limitations of skeletal programming environments when used for the development of component-based Grid applications. We validated all the approaches conducting several test, performed exploiting a set of tools we developed.Comment: PhD Thesis, 2008, IMT Institute for Advanced Studies, Lucca. arXiv admin note: text overlap with arXiv:1002.2722 by other author