Abstract
Algebraic specification languages have been successfully used for the formal specification of abstract data types (ADTs) and software components, and there are several approaches to automatically derive test cases that check the conformity between the implementation and the algebraic specification of a software component. However, existing approaches do not assure the coverage of conditional axioms and conditions embedded in complex axioms. In this paper, we present a novel approach and a tool to automatically derive test cases from bounded algebraic specifications of ADTs, assuring axiom coverage and of all minterms in its full disjunctive normal form (FDNF). The algebraic specification is first translated into the Alloy modelling language, and the Alloy Analyzer tool is used to find model instances for each test goal (axiom and minterm to cover), from which test cases in JUnit are extracted.

Abstract
Over the years software quality is becoming more and more important in software engineering. Like in other engineering disciplines where quality is already a commodity, software engineering is moving into these stages. The Team Software Process (TSP) was created by the Software Engineering Institute (SEI) with the main objective of helping software engineers and teams to ensure high-quality software products and improve process management in the organization. This paper presents a methodology for assessing an organization against the TSP practices so that it is possible to assess the future gains and needs an organization will have during and after the implementation of TSP. The gap analysis methodology has two pillars in terms of data collection: interviews and documentation analysis. Questionnaires have been developed to guide the assessment team on the task of conducting interviews and further guidance has been developed in what and where to look for information in an organization. A model for the rating has also been developed based on the knowledge and experience of working in several organizations on software quality. A report template was also created for documenting the analysis conclusions. The methodology developed was successfully applied in one well known Portuguese organization with the support and validation of SEI, and several refinements were introduced based on the lessons learnt. It is based on the most know reference models and standards for software process assessment - Capability Maturity Model Integration (CMMI) and ISO/IEC 15504. The objective of this methodology is to be fast and inexpensive when compared with those models and standards or with the SEI TSP assessment pilot.

Abstract
User interface testing is a very important but time consuming activity. To automate and systematize the testing process, models can be used to derive test cases automatically - a technique known as model-based testing. Given a model representing the intended system behavior and a test suite derived from the model or produced manually, the coverage of the test suite over the model is an important early indicator of the quality and completeness of the test suite. This paper presents a novel tool that shows visually the coverage achieved by a test suite over an UML model of an interactive system. This model is based on activity and class diagrams, with special user interface modeling features (stereotypes and keywords) inspired in ConcurTaskTrees and Canonical Abstract Prototypes. The tool receives a UML model file and a test suite, determines the model coverage by simulating the execution of the test suite over the model, and produces a colored UML model showing the elements covered. An example is presented to illustrate the approach.

Abstract
In this paper, we envision an approach for the automatic generation of a user interface (W) prototype from a system domain model (or core model), that captures the main domain entities and transactions, and a system use case model, which captures. the intended user tasks. This prototype allows the early validation of executable core system models, and can be used as a basis for subsequent developments. The envisioned solution uses OCL to add preciseness and semantic richness both to the domain and use case UML models. The generated UI provides some usability enhancements that are derived from the model's pre-conditions.

Abstract
High-maturity software development processes, making intensive use of metrics and quantitative methods, such as the Personal Software Process (PSP) and the Team Software Process (TSP), can generate a significant amount of data that can be periodically analyzed to identify performance problems, determine their root causes and devise improvement actions. Currently, there are several tools that automate data collection and produce performance charts for manual analysis in the context of the PSP/TSP, but practically no tool support exists for automating the data analysis and the recommendation of improvement actions. Manual analysis of this performance data is problematic because of the large amount of data to analyze and the time and expertise required. Hence, we propose in this paper a performance model and a tool (named PSP PAIR) to automate the analysis of performance data produced in the context of the PSP, namely, identify performance problems and their root causes, and recommend improvement actions. The work presented is limited to the analysis of the time estimation performance of PSP developers, but is extensible to other performance indicators and development processes.

Abstract
This paper proposes a new approach to reduce the effort of building formal models representative of the structure and behaviour of Graphical User Interfaces (GUI). The main goal is to automatically extract the GUI model with a dynamic reverse engineering process, consisting in an exploration phase, that extracts information by interacting with the GUI, and in a model generation phase that, making use of machine learning techniques, uses the extracted information of the first step to generate a state-machine model of the GUI, including guard conditions to remove ambiguity in transitions. © 2012 IEEE.