Search

Two proposals intended to reduce flaws in software use two very different approaches for software security.

In this paper we present an approach to automate the architecture recovery process of software systems. The approach is built on information retrieval and clustering techniques, and, in particular, uses Latent Semantic Indexing (LSI) to get similarities among software entities (e.g., programs or classes) and the k-means clustering algorithm to form groups of software entities that implement similar functionality. In order to improve computational time in the context of the software evolution and then reduce energy waste, the architecture recovery process can be also applied by using fold-in and fold-out mechanisms that, respectively, add and remove software entities to the LSI representation of the understudy software system. The approach has been implemented in a prototype of a supporting software system as an Eclipse plug-in. Finally, to assess the approach and the plug-in, we have conducted an empirical investigation on five open source software systems implemented using the programming languages Java and C/C++. In the investigation special emphasis has been also given to the effect of using the fold-in and fold-out mechanisms.

The architecture of a software-intensive system can be defined as the set of relevant design decisions that affect the qualities of the overall system functionality; therefore, architectural decisions are eventually crucial to the success of a software project. The software engineering literature describes several techniques to choose among architectural alternatives, but it gives no clear guidance on which technique is more suitable than another, and in which circumstances. As such, there is no systematic way for software engineers to choose among decision-making techniques for resolving tradeoffs in architecture design. In this article, we provide a comparison of existing decision-making techniques, aimed to guide architects in their selection. The results show that there is no “best” decision-making technique; however, some techniques are more susceptible to specific difficulties. Hence architects should choose a decision-making technique based on the difficulties that they wish to avoid. This article represents a first attempt to reason on meta-decision-making, that is, the issue of deciding how to decide.

Software developers are increasingly using Unified Modeling Language (UML) tools to automate source code generation. Therefore, nowadays calculating software metrics from UML diagrams to evaluate software quality is an important trend in the software industry. However, acquisition of software metrics from Extensible Markup Language (XML) export of UML tools has been predominantly tool dependent. Moreover, each new tool may have different specifications in XML. Despite the overall need for a process to automate XML unification, no current solution has yet been proposed. Creating a framework to automate this assessment would streamline development and increase efficiency in software industry. With the aim to overcome this deficiency, we developed a parser-based framework, named UXSOM, to calculate software metrics independently from the UML tool. Particularly UXSOM is able to generate software metrics from the XML-based outputs of the tools, ArgoUML, UMLET, MagicDraw, Sparx Systems, and ESS Model. We showed a very general case of UML class diagram, in which we extracted and compared software metrics from these five different tool.

Software maintenance is a vital component that every company has to face when their product is delivered to the stakeholders. This task may span for more than ten years at the customer site.The cost of maintenance or keeping software operational consumes 60-70% of its entire life cycle cost. Definingmaintainability at the design stage of the software development life cycle (SDLC) will result in a cost effective product. In this paper, we proposed a design time relationship model between design properties and the maintainability of the software. This analysis is performed based on the influence of object oriented design metrics on software maintainability

Software Design Notation Storage and Inference Mechanism (DNSIM) is capable of storing software designs by using Design Markup Language (DGML) tags and reusing existing design elements to produce new software designs. This mechanism performs search operations on stored designs. The accuracy of the search results depends upon the correctness of the keywords provided to the search process. The challenge is to input the Software Requirement Specification (SRS) document as a search input to DNSIM and to produce the best possible design from existing design elements. This paper proposes a method to produce requirement specification keywords from the formal representation of the SRS. The DNSIM system uses the keywords produced by our method and shows significant improvements and accuracy in the design search results

The field of software architecture which is considered as a subfield of software engineering is now about two decades old. During this period a number of software Architecture Description Languages (ADLs) emerged and vanished. But none of the ADLs became much popular amongst the practitioners except a few, that too only in a specific domain. On the other hand Unified Modeling Language (UML) which some times is not even accepted as an ADL or accepted with a some hesitation has become an industry de facto standard notation for documenting software architectures. This paper makes an attempt to find an answer to this question as to what went wrong with the ADLs that they did not become much popular beyond their place of origin. Is UML really an Architecture Description Language.

Introduction Academic computer science has an odd relationship with software: Publishing papers about software is considered a distinctly stronger contribution than publishing the software. The historical reasons for this paradox no longer apply, but their legacy remains. This limits researchers who see the open-source software movement as an opportunity to make a scholarly contribution. Expanded definitions of scholarship acknowledge both application and discovery as important components. 1 One obstacle remains: evaluation. To raise software to the status of a first-class contribution, we propose "best practices" for the evaluation of the scholarly contribution of open-source software. Typically, scholars who develop software do not include it as a primary contribution for performance reviews. Instead, they write articles about the software and present the articles as contributions. This conflation of articles and software serves neither medium well. An article describes an original intellectual contribution consisting of an idea, the argument for its importance and correctness, and supporting data. In contrast, software is more often an implementation of prior ideas in a usable form. It bridges the often considerable gap between an idea and the practical application of that idea. The original idea and its implementation represent distinct kinds of contribution. The critical gap is the perceived incomparability of these two contributions. Lacking a concise description adapted to the traditional practices of performance review committees, software is difficult to evaluate as a scholarly contribution and is often relegated to second-class status. We propose a framework for common assessment based on widely accepted definitions of scholarship. Within this general framework, we consider the material and procedures that a performance review committee uses to evaluate a publication. We then describe how software can be summarized in a compatible form of bibliographic citation and supplementary material.

In this paper, we report on our experience in designing and deliv-ering two new software design courses in the Informatics major at UC Irvine. When the major was created in 2004, it explicitly con-tained slots for two software design courses to be created from the ground up. The authors led this effort, focusing one course on the topic of system design and one course on the topic of implementation design . We discuss the philosophy and pedagogy behind the courses, present key class activities, and reflect on having offered each course twice over the past two years.

Design of a software product largely influences its quality. Good design is one of the pre-requisites of a high quality product. Me-trics are usually used to assess the quality of software designs. The metrics for object oriented design focus on design characteristics, such as abstraction, coupling, cohesion, inheritance, polymorphism and encapsulation and are applied at attribute, method, class, pack-age, file and systems levels. Design metrics help the software de-signers to understand the problem areas in a design and to develop prediction models. A number of studies have modeled relation-ships between object oriented metrics and reusability, defects and faults, maintainability, and effort, and cost savings. So design me-trics can give an early indication of goodness of design and thus of the software product developed using that design. If designers know symptoms of bad design then it is helpful for them to avoid the bad design. In this paper, we have explored some of the symp-toms of bad design and studied metric relationships which high-light these symptoms.

This paper includes a causal-based modelling of software meas-urement processes in order to clarify the real situations in the em-pirical software engineering field. A first overview about existing causal network approaches shows the problems and possible bene-fits using these formal techniques in the software engineering area. The definition and extension of the causal modelling using causal networks helps to understand the relationships between the differ-ent software process artefacts and their causalities. The causal net-work based process model (CNPM) concept is based on the causal network idea of Pearl. The description of first applications of the CNPM approach for CMMI demonstrates the empirical reasoning of the software improvement processes in an explicit manner.

Software specifications are often lacking, incomplete and outdated in the industry. Lack and incomplete specifications cause various software engineering problems. Studies have shown that program comprehension takes up to 45% of software development costs. One of the root causes of the high cost is the lack-of documented specification. Also, outdated and incomplete specification might potentially cause bugs and compatibility issues. In this paper, we describe novel data mining techniques to mine or reverse engineer these specifications from the pool of software engineering data. A large amount of software data is available for analysis. One form of software data is program execution traces. A program trace can be viewed as a sequence of events collected when a program is run. A set of program traces in turn can be viewed as a sequence database. In this paper, we present some novel work in mining software specifications by employing novel pattern mining and rule mining techniques. Performance studies show the scalability of our technique. Case studies on traces of a real industrial application show the utility of our technique in recovering program specifications from execution traces.

Open-source project artifacts can be used to inject realism into software engineering courses or lessons on open-source software development. However, the use of open-source projects presents challenges for both educators and for students. Educators must search for projects that meet the constraints of their classes, and often must negotiate the scope and terms of the project with project managers. For students, many available open-source projects have a steep learning curve that inhibits them from making significant contributions to the project and benefiting from a "realistic" experience. To alleviate these problems and to encourage cross-institution collaboration, we have created the Repository for Open Software Education (ROSE) and have contributed three open-source projects intended for an undergraduate computer science or software engineering course. The projects in ROSE are education-friendly in terms of a manageable size and scope, and are intended to be evolved over many semesters. All projects have a set of artifacts covering all aspects of the development process, from requirements, design, code, and test. We invite other educators to contribute to ROSE and to use projects found on ROSE in their own courses.

This article presents an automated technique for visualizing large software architectures using multiple graphical representations, including multi-dimensional scaling, 2-D grid, and spiral layouts. We describe how our software visualization methods were applied to the Network Appliance operating system known as Data ONTAP 7G (ONTAP). We show how each method can be applied to comprehend a specific aspect of ONTAP. This approach can be used by software engineers, architects, and developers to better understand the architecture of their code.

Software needs to grow up and become responsible for itself and its own future by participating in its own installation and customization, maintaining its own health, and adapting itself to new circumstances, new users, and new uses. To create such software will require us to change some of our underlying assumptions about how we write programs. A promising approach seems to be to separate software that does the work (allopoietic)from software that keeps the system alive (autopoietic).

The ability to retrieve software in an easy and efficient way confers competitive advantage on computer users in general and, even more especially, on users of wireless devices (like some laptops, PDAs, etc.). In this article, we present a software retrieval service that allows users to select and retrieve software in an easy and efficient way, anywhere and anytime. Two relevant components of this service are: 1) a software ontology (software catalog) which provides users with a semantic description of software elements, hiding the location and access method of various software repositories, and 2) a set of specialist agents that allow browsing of the software catalog (automatically customized for each user), and an efficient retrieval method for the selected software. These agents automatically adapt their behavior to different users and situations by considering the profile and preferences of the users and the network status.In summary, our software-obtaining process based on an ontology and autonomous and adaptive agents presents a qualitative advance with respect to existing solutions: our approach adapts to the features of users, relieving them from knowing the technical features of their devices and the location and access method of various remote software repositories.

Should software developers be required to include infringement-inhibitingcomponents such as filters in their technologies?

This article describes the design and development of a design repository software system. This system is a prototype implementation intended to demonstrate the role of design repositories as part of a vision for the next generation of product development software systems. This research involves not only the creation of a prototype software system, but is part of a broader effort that also includes the development of a core product knowledge representation and that seeks to address terminological and semantic issues associated with computer-aided product development. This article focuses on the interfaces that have been developed to support authoring and navigation of the product models stored in design repositories as well as the software architecture and associated rationale that provide the framework on which the system is built.

Although virtual conferencing tools have been successfully used in executive meetings, current tools appear inadequate for the needs of software designers. As a result, while distributed code writing is becoming widespread, almost all software design meetings are still carried out face-to-face incurring costs that undermine the potential of distributed software development.Our research strives to build successful tools for supporting distributed software design meetings. To do so, we must first identify the unique activities of software design which must be mimicked in the virtual world. This paper does so with a detailed study of two colocated design meetings. We discuss issues that must be tackled in the transition to virtual settings, outline requirements for such tools, and propose strategies for meeting these requirements. In doing so, we also identify problems in existing colocated meetings which could be alleviated with these tools.

Recently, there is a growing interest in the research community to employ tamper-resistant processors for software protection. Many of these proposed systems rely on a specially tailored secure processor to prevent 1) illegal software duplication, 2) unauthorized software modification, and 3) unauthorized software reverse engineering. Most of these works primarily focus on the feasibility demonstration and design details rather than trying to elucidate many fundamental issues that are either "elusive" or "confusing" to the architecture researchers. Furthermore, many proposed systems have been built on assumptions whose security implications have not been well studied or understood. Instead of proposing yet another new secure architecture model, in this paper, we will try to answer some of these fundamental questions with respect to using hardware-based cryptography for protecting software execution. Those issues include, 1) Is hardware cryptography necessary? 2) Is per-process single cryptography key enough to provide the flexibility, inter-operability, and compatibility required by today's complex software system? 3) Is OTP (one-time-pad) in combination with "lazy" authentication secure enough to protect software confidentiality? 4) Is there way to protect software integrity using less hardware resource? Finally, the paper defines the difference between off-line and on-line attacks and presents a very low overhead security enhancement technique that can improve protection on software integrity over on-line attacks by several magnitudes.

Professional software developers use version control systems to coordinate their work, and to provide an unwindable history of their project's evolution. In contrast, students in most programming courses use a homegrown electronic submission program to submit their work, and email to coordinate with partners when doing team projects. In May 2003, we began using CVS, a popular open source version control system, as an assignment submission system. Students receive starter code by checking out the assignment, use the version control system to manage their work, and submit their assignment by committing it to CVS. Teaching assistants grade assignments by checking out each student's repository, and committing the marks. Our experience to date shows that this is both a simpler and a more flexible way to manage student assignments, and also an excellent way to teach them how to use a fundamental software development tool.

A key goal of educators teaching software engineering is to provide students with useful experience that will benefit them after graduation. A key component of this experience is usually a class project that is meant to expose students to the issues associated with real software development efforts. Unfortunately, educators rarely have the time required to manage software projects in addition to their normal pedagogical duties. As a result, many software engineering courses compromise the project experience by reducing the team sizes, project scope, and risk. In this paper, we present an approach to teaching a one-semester software engineering course in which approximately 30 students work together to construct a moderately sized (22 KLOC) software system. This approach provides a more realistic project experience for the students, without incurring significant managerial overhead for the instructor. We present our experiences using the approach for the spring 2004 software engineering course at The College of William and Mary.

The subject matter of a typical undergraduate software engineering course, while providing necessary background, can be quite dry. Team-based programming projects often complement the more theoretical textbook and lecture content by giving students valuable hands-on practice, albeit on a small scale and within a traditional classroom setting. This paper describes a company-based framework used in two semesters of a software engineering course. This approach incorporates a novel, collaborative framework to simulate the real-world experience of working for a medium-sized software design company or research laboratory, while giving students a vested interest in the overall outcome.

A key aspect of the design of any software system is its architecture. An architecture description, from a runtime perspective, should provide a formal specification of the architecture in terms of components and connectors and how they are composed together. Further, a dynamic or mobile architecture description must provide a specification of how the architecture of the software system can change at runtime. Enabling specification of dynamic and mobile architectures is a large challenge for an Architecture Description Language (ADL). This article describes π-ADL, a novel ADL that has been designed in the ArchWare European Project to address specification of dynamic and mobile architectures. It is a formal, well-founded theoretically language based on the higher-order typed π-calculus. While most ADLs focus on describing software architectures from a structural viewpoint, π-ADL focuses on formally describing architectures encompassing both the structural and behavioural viewpoints. The π-ADL design principles, concepts and notation are presented. How π-ADL can be used for specifying static, dynamic and mobile architectures is illustrated through case studies. The π-ADL toolset is outlined.

Software development projects face numerous challenges that threaten their successful completion. Whether it is not enough money, too little time, or a case of "requirements creep" that turns into a full sprint, projects must meet these challenges or face possible disastrous consequences. The funds needed to purchase supporting software tools or computing hardware may not be available, or they may be available for so short a period that informed purchase decisions become infeasible. Personnel resources are often limited, and it is difficult to adjust to personnel fluctuations during the project. The composition of the team personnel also offers potential challenges. A new software development team may begin with some members unfamiliar with the software development environment and project tools, and their learning curve can affect early productivity.

Biological design principles can potentially change the way we study, engineer, maintain, and develop large dynamic software systems. For example, computer programmers like to think of software as the product of intelligent design, carefully crafted to meet well-specified goals. In reality, large software systems evolve inadvertently through the actions of many individual programmers, often leading to unanticipated consequences. Because software is subject to constraints similar to those faced by evolving biological systems, we have much to gain by viewing software through the lens of biology. The talk will highlight how abstractions of biological processes can lead to new computational algorithms and engineering principles using examples from my own research. Specifically, it will show how the biological concepts of Darwinian evolution and immunology can be applied to problems such as repairing software bugs and cybersecurity.

Variability in software-intensive systems is usually understood as the ability of a software artifact to be changed in order to fit different contexts, environments, or purposes. Software architecture on the other hand determines the structure of a software system, and is described in an architecture description. This description includes the major stakeholders of a software system and their concerns. Variability is reflected in and facilitated through the software architecture. The First International Workshop on Variability in Software Architecture (VARSA) was held jointly with WICSA 2011 in Boulder, Colorado. The goal of the workshop was to explore and advance the state-of-the art in variability in software architecture. It featured four research paper presentations, two invited talks, and three working groups that discussed specific topics. This report summarizes the themes of the workshop, presents the results of the working group discussions, and suggests topics for further research.

of the key tasks. Premature termination can be observed throughout the development, deployment, and postdeployment improvement of software products. The problem is also present when experts advocate and describe a software development process. In this column, I will describe some of the disease’s manifestations in requirements documentation, diagrammatic description of software, interface documentation, and quality control. Requirements elicitation and documentation Nowhere is premature termination more evident than in the field sometimes called

The concept of information hiding modularity is a cornerstone of modern software design thought, but its formulation remains casual and its emphasis on changeability is imperfectly related to the goal of creating added value in a given context. We need better explanatory and prescriptive models of the nature and value of information hiding. We evaluate the potential of a new theory---developed to account for the influence of modularity on the evolution of the computer industry---to inform software design. The theory uses design structure matrices to model designs and real options techniques to value them. To test the potential utility of the theory for software we apply it to Parnas's KWIC designs. We contribute an extension to design structure matrices, and we show that the options results are consistent with Parnas's conclusions. Our results suggest that such a theory does have potential to help inform software design.

This paper begins with a discussion of the importance of software development and the problems encountered by those trying to work effectively on software project teams. It is argued that for students to be effective in working on teams they need the discipline and organization offered by a rigorous team software process. The author describes his experiences in using the Team Software Process (TSP) to teach an introductory course in software engineering. The structure and key elements of the process are presented, along with techniques used in selecting and forming teams. The paper examines the TSP quality assurance features and finishes with a discussion of the techniques used to acquire feedback and to evaluate the affect of the TSP on student learning.

The re-use of software components during the software development is considered to be an important factor to improve the quality and productivity and thus to reduce the time to market of the final product. In this paper we will present a proposal for a description model for re-usable components. We will also present the results of case studies concerned with both telecom specific and ,,generic" IT-components. These components have been examined using the description model and a further set of (empirical) criterions. Based on the results a model concept for the empirical assessment of JavaBeans, which is currently under development, is presented..

In practice, object-oriented design models have been less useful throughout the lifetime of software systems than they should be. Design models are often large and monolithic, and the structure of the designs is generally quite different from that of requirements. As a result, developers tend to discard the design, especially as the system evolves, since it is too difficult to keep its relationship to requirements and code accurate, especially when both are changing. This paper presents a different approach to designing systems, based on flexible decomposition and composition, that closely aligns designs with both requirements specifications and with code. We illustrate how this approach permits the benefits of designs to be maintained throughout a system’s lifetime.

Many undergraduate software engineering courses combine team projects with discussion of development cycle concepts. It can be difficult to connect these elements in a coherent way, especially when the lecture is a broad survey and the project is sharply focused on meeting the needs of a client.This paper describes one attempt to bridge this gap, by incorporating the iterative development of a classroom example and an object-oriented process based on two commercial software tools. Although the course time frame (an academic quarter) is too short for significant iteration on the team project, students can participate in an accelerated version of the process by making a small increment to the non-trivial example.This approach retains the benefits of a realistic, client-centered team development project, while providing experience in a contemporary software development process based on commercial CASE tools.

Interest in software architecture as an area of research, education, and practice within software engineering has been growing steadily over the past decade. Software architecture is concerned with the principled study of large-grained software components, including their properties, relationships, and patterns of combination. It is becoming clear that one key to the effective development, operation, and evolution of software systems is the design and evaluation of appropriate architectures.As a complement to the Fourth Symposium on the Foundations of Software Engineering (FSE-4), whose theme was software architecture, the Second International Software Architecture Workshop (ISAW-2) brought together practitioners and researchers for two intense days of discussion and work. The ISAW-2 proceedings [6] were published in the Joint Proceedings of the SIGSOFT '96 Workshops, ACM Press, ISBN 0-89791-867-3.The participants were organized into three parallel working groups each focused on a different topic within software architecture.• Styles and Patterns ---Techniques and models for centering software architecture activities on generally useful design methods, components, and assemblages of components.• Architecture Description ---Languages and methods for the capture of architectural designs.• Tools and Methods ---Automated aids for designing, evaluating, validating, implementing, and evolving software architectures.Tying these work groups together was the use of a common case study derived from a real-world architecture found in industry. Each working group studied this architecture from its particular perspective and, to a greater or lesser extent, used the case study to organize their discussions. It is interesting to note, for example, that the three groups created specialized depictions of the architecture for their discussion (see figures 6, 8, and 10).The case study was the architecture of the Call Center Customer Care (C4) System, which was developed by Andersen Consulting. A description of the architecture and some of its more interesting challenges appears in Section 2. It is reproduced here in the hopes that it might be prove of continued use to the community.Also appearing here are reports from each working group. The Styles and Patterns Working Group was led by Frances Paulisch, of Siemens, and Mary Shaw, of CMU. The group tried to uncover the styles and patterns that underlay various components of the C4 architecture. In the process, they defined a new kind of architectural style that they named the Data Ooze. The Architectural Description Working Group was led by Paul Clements, of the SEI, and Jeff Magee, of Imperial College. The group concentrated on identifying critical aspects of architectures that require description and on identifying important areas where further work in architectural description is needed. The Tools and Methods Working group was led by William Griswold, of UCSD, and Philippe Kruchten, of Rational. The group pretended to go through a development cycle for the C4 system in order to uncover various architectural tool and method needs.At the conclusion of the workshop, the working group chairs held a panel session in which each group asked a "challenge" question of the other two groups. The questions and responses appear in Section 5.2.We hope that these succeedings capture at least some essence of the very fruitful discussion that occurred at the workshop. Of course, this report cannot replace the benefits of actual attendance. The workshop will indeed continue, and we hope that the reader will be interested in attending a future ISAW.

The 1999 Mike Judge film Office Space enjoys a cult following, particularly amongst software engineers. Despite its mass appeal and broad comedic base, the film contains many hidden gems of wisdom regarding the craft of software engineering. In this short paper I discuss six rules that are embodied in the film's plot line and characterizations, and what the film has to teach us about each of them. The rules are: design for change; software engineering is a social activity; an untested program does not work; not everyone gets to write video games; Brooks' Law; and, you will be expected to work long hours.

Nowadays achieving green software by reducing the overall energy consumption of the software is becoming more and more important. A well-known solution is to make the software energy-aware by extending its functionality with energy optimizers, which monitor the energy consumption of software and adapt it accordingly. Modular design of energy-aware software is necessary to make the extensions manageable and to cope with the complexity of the software. To this aim, we require suitable methods that guide designers through the necessary design activities and the models that must be prepared during each activity. Despite its importance, such a method is not investigated in the literature. This paper proposes a dedicated design method for energy-aware software, discusses a concrete realization of this method, and—by means of a concrete example—illustrates the suitability of this method in achieving modularity.

In this paper we present a logical framework for evolving software systems in which the critical aspects of large-scale software systems maintenance are treated by an approach which considers that configuration management is essentially concerned with the management of system changes. The basis of this framework is a formal description of transitions that might be made in the soft-ware change process, the purpose of the formalism is to allow deductions to be made about the validity of such transitions. A generalised formal description of software system architectures from the viewpoint of evolving software systems is also provided in the paper. Reasoning about functional aspects of these descriptions is achieved through the interaction of a theorem prover for the proposed metalogic formalism and a theorem prover for reasoning about sequential programs. In our approach the alterations of software descriptions can be viewed as programming-in-the-large transformations which are stated by means of the descriptive/prescriptive (deontic) features of actions.

One of the main goals of software engineering is to assess the quality of the software we develop, however this is to be measured. A software metric, assigning a number to each piece of program text, will generally attempt to address one or more quality attributes in its assessment. These might include software reliability, testability, maintainability, and the like, and, in general, a kind of complexity of the software in some specific and restricted sense. In this tutorial a new cubic flowgraph model is introduced and shown to be useful in exploring a whole range of software metric design and analysis techniques, specifically in reference to the subclass of software metrics that are said to be hierarchical. In particular, the cubic flowgraph model leads to the discovery of certain inequalities among existing metrics, serves to provide a new characterization of the important class of prime flowgraphs, and points the way to an. effective method for counting and enumerating the primes.

It is the aim of this paper to present a model conceived for supporting the initial, critical phases of PLC software life cycle, namely requirement specification, requirement analysis and software design, to obtain reusable code. The model, named EASIER, is based on an object-oriented paradigm where the message-method mechanism is replaced by the law and action primitives, since they are more suitable to cope with the real-time, cyclic nature of PLC software. Software re-usability is pursued by identifying independent control modules through a proper bedded encapsulation mechanism, representing system dynamics by means of synchronized state diagrams, expressing context-free behaviour of system components by introducing virtual objects. The EASIER approach is presently validated with respect to relevant reverse and forward engineering applications; from one of these cases we derive the examples used in the paper.

The object-oriented (OO) paradigm is rapidly gaining acceptance in the software industry. However, the powerful features of this new paradigm also introduce a new set of OO software testing and maintenance problems. The pioneering work in identifying these new problems includes [7, 10-12, 14, 16, 18]. The problems can be summarized as: 1) the understanding problem; 2) the complex interdependency problem; 3) the object state behavior testing problem; and 4) the tool support problem. Detailed discussions of these problems will be provided later. Our industrial experience confirms these discoveries.

We describe a logical framework PR for verification of reusable software components. Within our system, developers can employ the advantages traditionally associated with software reuse to reduce the cost of software verification by reusing abstract proofs and specifications. One can construct an algorithm with parameters, a specification with parameters, and a proof that the algorithm satisfies the specification provided the parameters satisfy certain conditions. Proofs in PR will themselves contain parameters for subproofs concerning those conditions. In this framework, typing, type checking, and proof checking are decidable.

The application of measurement technology in software engineering was not recognised enough in last decades, but recent trends show that software metrics are becoming more and more important. Indeed the development and use of adequate measurement of software and its design process are essential to the production of cost-effective and quality software. Actually, software metrics are not only significant as analysis instruments, but regarding the present iterative software design paradigms, they are likewise becoming powerful synthesis mechanisms. The main objective of this paper is to show that modern software tools and especially compiler-compilers, metric life cycle model and fractal metrics can improve the situation and make the development and use of software metrics more efficient and effective.

Adoption of object-oriented technology by the software industry is to a large extent interfered with a lack of appropriate evaluation criteria. Measures of object-oriented systems are necessary in order to realize and achieve expected benefits and advantages of object technology. This paper presents some evaluation criteria, measures and metrics, suitable for object-oriented software development. The implemented prototype of OOMetTool that provides an automatic support for metric data gathering is described and some initial findings are presented.