The earlier in the development process a fault is found, the cheaper it is to correct the fault. Therefore are verification and validation methods important tools. The problem with this is that there are many methods to choose between. This thesis sheds light on how to choose between four common verification and validation methods. The verification and validation methods presented in this thesis are reviews, inspections and Fault Tree Analysis. Review and inspection methods are evaluated in an empirical study. The result of the study shows that there are differences in terms of defect detection. Based on this study and literature study, guidelines on how to choose the best method in a given context are given. / Desto tidigare i utvecklingsprocessen som ett fel hittas, desto billigare är det att rätt till detta fel. Därför är verifierings- och valideringsmetoder viktiga verktyg. Problemet är att det finns många metoder. Den här rapporten sprider ljus över hur man ska välja mellan fyra vanliga verifierings- och valideringsmetoder. Verifierings- och valideringsmetoderna i den här rapporten är granskningar, inspektioner och "Fault Tree Analysis". Granskningar och inspektioner är utvärderade i en empiriskt studie. Resultatet av studien visar att det finns skillnader mellan metoderna när det gäller att hitta fel.

A common problem experienced by the software engineering community traditionally has been that of understanding legacy code. A decade ago, legacy code was used to refer to programs written in COBOL, typically for large mainframe systems. However, current software developers predominantly use Object Oriented languages like C++ and Java. The belief prevalent among software developers and object philosophers that comprehending object-oriented software will be relatively easier has turned out to be a myth. Tomorrow's legacy code is being written today, since object oriented programs are even more complex and difficult to comprehend, unless rigorously documented. Reverse Engineering is a methodology that greatly reduces the time, effort and complexity involved in solving the program comprehension problem. This thesis deals with Reverse Engineering complex object oriented software and the experiences with a sample case study. Extensive survey of literature and contemporary research on reverse engineering and program comprehension was undertaken as part of this thesis work. An Energy Information System (EIS) application created by a leading energy service provider and one that is being used extensively in the real world was chosen as a case study. Reverse engineering this industry strength Java application necessitated the definition of a formal process. An intuitive Reverse Engineering Process (REP) was defined and used for the reverse engineering effort. The learning experiences gained from this case study are discussed in this thesis. / Master of Science

ITC/USA 2008 Conference Proceedings / The Forty-Fourth Annual International Telemetering Conference and Technical Exhibition / October 27-30, 2008 / Town and Country Resort & Convention Center, San Diego, California / The integrated Network Enhanced Telemetry (iNET) and Test and Training Enabling Architecture (TENA) projects are working to understand how TENA will perform in a Telemetry Network System. This paper discusses a demonstration prototype that is being used to investigate the use of TENA across a constrained test environment simulating iNET capabilities. Some of the key elements being evaluated are throughput, latency, memory utilization, memory footprint, and bandwidth. The results of these evaluations will be presented. Additionally, the paper briefly discusses modeling and metadata requirements for TENA and iNET.

Although originally designed as an extension for the Unifi ed Modeling Language (UML), today, the Object Constraint Language (OCL) has been broadly adopted in the context of both UML and other modeling and domain-specifi c languages. However, appropriate tooling, supporting modelers and software developers on using OCL is still scarce and lacks important features such as debugging support. As OCL constraints are likely to become rather complex for real world examples, it is hard to comprehend the in uence of single OCL expressions and subexpressions on the result of a completely evaluated OCL constraint in the context of speci fic constrained objects. Therefore, debugging is of topmost importance for both constraint comprehension and maintenance. Thus, the major task of this work is to develop a graphical debugger integrated into Dresden OCL and the Eclipse Integrated Development Environment (IDE) to fill this gap.

The cadastre contains parcel related data which must be up-to-date. The cadastral data in any country constitute a very big dataset. Therefore parcel related data should be carefully managed. Today, using a database is an effective way of data management. The relational database management system can be a good one for parcel related data. However when the information system concept is considered, just relational database management system is not enough. Some tools are needed in order to manipulate the data in the relational database management system. Object oriented analysis and design is a good choice to develop these tools. In this study, a parcel-based information system is developed and it is implemented for &Ccedil / ankaya Municipality. During the development relational database management system is used for attribute data management, and object-oriented analysis and design is used for development of application to manipulate the data in the relational database management system. The cadastral data are separated into two parts and each part is handled separately. The first part is the geographic or spatial data. These data are handled by the help of the MapInfo Professional Version 6.5. The other part is the attributes of these spatial data. For this part, relational database is designed and implemented on Microsoft SQL Server Version 2000. During the development of the relational database, conceptual database design is performed by enhanced entity-relationship (EER) model. Then in the logical design, the conceptual model is mapped into the relational model. After data storage area is created, the application is developed on that data by using principles of object-oriented design and analysis and unified modeling language. By the help of the software developed, the data management can be carried out easily. By this study, a solution is proposed for the cadastral data management problem of the municipalities, and this study is one of the first studies developed for parcel related data using object-oriented approach for municipalities.

A tool management system for a job shop was developed in this study. The system is based on the rules of the plant of T&uuml / rk Trakt&ouml / r ve Ziraat Makineleri A.S. in Ankara. An object-oriented methodology was used during the system development. Unified Modeling Language (UML), which is the standard diagramming notation for object-oriented development, is used to model the system. Entity-Relation (E-R) modeling is used during the construction of the database. System was developed using three-tiered Microsoft Windows Distributed Internet Applications (DNA) Architecture. Microsoft Visual Basic 6.0 and Visual InterDev 6.0, which are the members of Microsoft Visual Studio 6.0 were used as programming tools. Internet Information Server was used as web server and Microsoft Transaction Server was used as object broker. Microsoft SQL Server was used as database server. Software was developed in three modules: gage-fixture, cutting tool-tool holder and tool requirement plan modules. Gage- fixture module tracks the location of measuring equipment, fixture and fixture assemblies / keeps the related data about these tools and manage calibration of the measuring equipments. Cutting tool-tool holder module tracks the issue and return of cutting tools and tool holders / sharpening of cutting tools / keeps the related data about these tools. Tool requirement plan module tracks the purchase orders and cutting tool receivings from vendors / prepares tool requirement plan and suggests purchase orders according to the requirement calculation.

Model Driven Development (MDD) and Model Based Testing (MBT) are gaining inroads individually for their application in embedded software engineering projects. However, their full-edged and integrated usage in real-life embedded software engineering projects (e.g. industrially relevant examples) and executing MBT in resource constrained embedded systems (e.g. 16 bit system/64 KiByte memory) are emerging fields. Addressing the aforementioned gaps, this thesis proposes an integrated model-based approach and test framework for executing the model-based test cases, with minimal overhead, in embedded systems. Given a chosen System Under Test (SUT) and the system design model, a test framework generation algorithm generates the necessary artifacts (i.e., the test framework) for executing the model-based test cases. The main goal of the test framework is to enable test automation and test case execution at the host computer (which executes the test harness), thereby only the test input data is executed at the target. Significant overhead involved in interpreting the test data at the target is eliminated, as the test framework makes use of a target debugger (communication and decoding agent) on the host and a target monitor (software-based runtime monitoring routine) in the embedded system. In the prototype implementation of the proposed approach, corresponding (standardized) languages such as the Unified Modeling Language (UML) and the UML Testing Profile (UTP) are used for the MDD and MBT phases respectively. The applicability of the proposed approach is demonstrated using an experimental evaluation (of the prototype) in real-life examples. The empirical results indicate that the total time spent for executing the test cases in the target (runtime-time complexity), comprises of only the time spent to decode the test input data by the target monitor and execute it in the embedded system. Similarly, the only memory requirement in the target for executing the model-based test cases in the target is that of the software-based target monitor. A quantitative comparison on the percentage change in the memory overhead (runtime-memory complexity) for the existing approach and the proposed approach indicates that the existing approach (e.g. in a MDD/MBT tool-Rhapsody), introduces approximately 150% to 350% increase in memory overhead for executing the test cases. On the other hand, in the proposed approach, the target monitor is independent of the number of test cases to be executed and their complexity. Hence, the percentage change in the memory overhead for the proposed approach shows a declining trend w.r.t the increasing code-size for equivalent application scenarios (approximately 17% to 2%). Thus, the proposed test automation approach provides the essential benefit of executing model- based tests, without downloading the test harness in the target. It is demonstrated that it is feasible to execute the test cases specified at higher abstraction levels (e.g. using UML sequence diagrams) in resource constrained embedded systems and how this may be realized using the proposed approach. Further, as the proposed runtime monitoring mechanism is time and memory-aware, the overhead parameters can be accommodated in the earlier phases of the embedded software development cycle (if necessary) and the target monitor can be included in the final production code. The aforementioned advantages highlight the scalability, applicability, reliability and superiority of the proposed approach over the existing methodologies for executing the model-based test cases in embedded systems.

Although originally designed as an extension for the Unifi ed Modeling Language (UML), today, the Object Constraint Language (OCL) has been broadly adopted in the context of both UML and other modeling and domain-specifi c languages. However, appropriate tooling, supporting modelers and software developers on using OCL is still scarce and lacks important features such as debugging support. As OCL constraints are likely to become rather complex for real world examples, it is hard to comprehend the in uence of single OCL expressions and subexpressions on the result of a completely evaluated OCL constraint in the context of speci fic constrained objects. Therefore, debugging is of topmost importance for both constraint comprehension and maintenance. Thus, the major task of this work is to develop a graphical debugger integrated into Dresden OCL and the Eclipse Integrated Development Environment (IDE) to fill this gap.:1 Introduction 2 The Dresden OCL Toolkit 2.1 The Dresden OCL Toolkit 2.2 The Dresden OCL2 Toolkit 2.3 Dresden OCL2 for Eclipse 2.4 Dresden OCL 3 The Eclipse Debugging Framework 3.1 The Debug Model 3.2 Interacting with the Debug Model 3.3 The Execution Control Commands 4 Requirements Analysis and Related Work 4.1 Requirements Analysis 4.2 Related Work 5 Design and Structure 5.1 Architecture 5.1.1 Package Structure 5.1.2 Class Structure 5.2 The OCL Debug Model 5.3 The Mapping from ASM to AST 5.4 The OCL Debugger 5.4.1 The Implementation of the Debugger 5.4.2 Testing the Debugger 6 Graphical User Interface Implementation 6.1 The Dresden OCL Debug Perspective 6.2 Using the Debugger 6.2.1 Selecting a Model 6.2.2 Selecting a Model Instance 6.2.3 Debugging 6.3 Summary 7 Evaluation and Future Work 33 7.1 Evaluation 7.2 Future Work 8 Summary and Conclusion

Property Management, one functional area within Right-of-Way offices in state transportation agencies, is responsible for managing the property acquired for highway projects. These activities are data and document intensive and efficiency for performing them would be improved through the implementation of an information management system. Because of the geospatial nature of many of these activities, geographic information systems (GIS) would increase the effectiveness of this system. A literature review and survey were conducted to understand the current state of practice for the use of GIS and information management systems in Property Management. There is no identified comprehensive system that covers all Property Management activities. An initial step in developing a geospatially-enabled enterprise-level information management system, a logical model was developed. This included developing the business process diagram, business process models, and use case models based on the principles of systems engineering using the Computer Aided Software (CASE) Enterprise Architecture. Activities that would benefit from a geospatial component have been identified and included in the models. The developed models have been validated by working with PennDOT staff. The resulting model serves as a standard template for state transportation agencies and helps conceptualize the advantages of integration and interaction with other systems, and geospatial enablement prior to investment in an information management system. / Master of Science

Deficiencies in software design or architecture can severely impede and slow down the software development and maintenance progress. Bad smells and anti-patterns can be an indicator for poor software design and suggest for refactoring the affected source code fragment. In recent years, multiple techniques and tools have been proposed to assist software engineers in identifying smells and guiding them through corresponding refactoring steps. However, these detection tools only cover a modest amount of smells so far and also tend to produce false positives which represent conscious constructs with symptoms similar or identical to actual bad smells (e.g., design patterns). These and other issues in the detection process demand for a code or design review in order to identify (missed) design smells and/or re-assess detected smell candidates. UML diagrams are the quasi-standard for documenting software design and are often available in software projects. In this position paper, we investigate whether (and to what extent) UML diagrams can be used for identifying and assessing design smells. Based on a description of difficulties in the smell detection process, we discuss the importance of design reviews. We then investigate to what extent design documentation in terms of UML2 diagrams allows for representing and identifying software design smells. In particular, 14 kinds of design smells and their representability in UML class and sequence diagrams are analyzed. In addition, we discuss further challenges for UML-based identification and assessment of bad smells.