Abstract-Recently, there has been an important progress in applying search-based optimization techniques to the problem of software re-modularization. Yet, a major part of the existing body of work addresses the problem of modularizing software systems from scratch, regardless of the existing packages structure. This paper presents a novel multi-objective optimization approach for improving existing packages structure. The optimization approach aims at increasing the cohesion and reducing the coupling and cyclic connectivity of packages, by modifying as less as possible the existing packages organization. Moreover, maintainers can specify several constraints to guide the optimization process with regard to extra design factors. To this contribution, we use the Non-Dominated Sorting Genetic Algorithm (NSGA-II). We evaluate the optimization approach through an experiment covering four real-world software systems. The results promise the effectiveness of our optimization approach for improving existing packages structure by doing very small modifications.

Abstract-Interfaces are widely used in Java applications as central design elements for modular programming to increase program reusability and to ease maintainability of software systems. Despite the importance of interfaces and a considerable research effort that has investigated code quality and concrete classes' design, few works have investigated interfaces' design. In this paper, we empirically study interfaces' design and its impact on the design quality of implementing classes (i.e., class cohesion) analyzing twelve Java object-oriented applications. In this study we propose the "Interface-Implementations Model" that we use to adapt class cohesion metrics to assess the cohesion of interfaces based on their implementations. Moreover, we use other metrics that evaluate the conformance of interfaces to the well-known design principles "Program to an Interface, not an implementation" and "Interface Segregation Principle". The results show that software developers abide well by the interface design principles cited above, but they neglect the cohesion property. The results also show that such design practices of interfaces lead to a degraded cohesion of implementing classes, where these latter would be characterized by a worse cohesion than other classes.

Software Interfaces are meant to describe contracts governing interactions between logic modules.Interfaces, if well designed, significantly reduce software complexity and ease maintainability. However, as software evolves, the organization and the quality of software interfaces gradually deteriorate. As a consequence, this often leads to increased development cost, lower code quality and reduced reusability. Code clones are one of the most known bad smells in source code. This design defect may occur in interfaces by duplicating method/API declarations in several interfaces. Such interfaces are similar from the point of view of public services/APIs they specify, thus they indicate a bad organization of application services. In this paper, we characterize the interface clone design defect and illustrate it via examples taken from real-world open source software applications. We conduct an empirical study covering nine real-world open source software applications to quantify the presence of interface clones and evaluate their impact on interface design quality. The results of the empirical study show that interface clones are widely present in software interfaces. They also show that the presence of interface clones may cause a degradation of interface cohesion and indicate a considerable presence of code clones at implementations level.

Software Engineering is a pivot course in the Computer Science and Computer Engineering curriculums. This paper briefly presents traditional content which is usually being taught in many Software Engineering courses, and highlights some problems encountered during teaching this content. Then it builds on those problems to suggest a more appropriate content for the course. The suggested content is applied in nature to make the course interesting to students, pushes programming to the very beginning of the course so that students may have hands-on practice for a longer time, removes many topics which are usually found in traditional Software Engineering courses such as the structured approach, cuts on the number of diagrams that can be replaced by others to reduce confusion. The paper will consider the trade of between the material which was cut and the benefits gained from providing the students with a focused curriculum that may limit the difficulty and the confusion usually result from teaching a traditional curriculum, this includes limitations and implications of our approach and the expected gains.Index Terms-Software engineering, curriculum design, object-oriented, structured approach, JAVA.