This thesis investigates a novel approach to reverse engineering, in which modeling information such as UML associations, state machines and attributes is incrementally added to code written in Java or C++, while maintaining the system in a textual format. Umple is a textual representation that blends modeling in UML with programming language code. The approach, called umplification, produces a program with behavior identical to the original one, but written in Umple and enhanced with model-level abstractions. As the resulting program is Umple code, our approach eliminates the distinction between code and model. We implemented automated umplification in a tool called the Umplificator. The tool is rule-driven: code, including Umple code, is parsed and processed into an internal representation, which is then operated on by rules; transformed textual code and model, in Umple, is then generated. The rules used to transform code to model have been iteratively refined by using the tool on a variety of open-source software systems. The thesis consists of three main parts. The first part (Chapters 1 and 2) present the research questions and research methodology, as well as introducing Umple and the background necessary to understand the rest of the thesis. The umplification method is presented at increasing levels of detail through Chapters 3 and 4. Chapters 5 and 6 present the tool and evaluation of our approach, respectively. An analysis of related work, and comparison to our own, appears in Chapter 7. Finally, conclusions and future work directions are presented in Chapter 8.

We use a system model expressed in a subset of the Unified Modeling Language to perform fault isolation in large object oriented control systems. Due to the severity of the failures considered and the safety critical nature of the system we cannot perform fault isolation online. Thus, we perform post mortem fault isolation which has implications in terms of the information available; the temporal order in the error log can not be trusted. In our previous work we have used a structural model for fault isolation. In this thesis we provide a formal framework and a prototype implementation of an approach taking benefit of a behavioral model. This gives opportunities to perform more sophisticated reasoning at the cost of a more detailed system model. We use a model-checker to reason about causal dependencies among the events of the modeled system. The model-checker performs reasoning about temporal dependencies among the events in the system model and the scenario at hand, allowing for conclusions about the causal relation between the events of the scenario. This knowledge can then be transferred to the corresponding fault in the system, allowing us to pinpoint the cause of a system failure among a set of potential causes. / <p>Report code: LiU-Tek-Lic-2000:59.</p>

Due to increased urgency regarding environmental concerns within the transportation industry, sustainable solutions for combating climate change are in high demand. One solution is a widespread transition from internal combustion engine vehicles (ICEVs) to battery electric vehicles (BEVs). To facilitate this transition, reliable energy consumption modeling is desired for providing quick, high-level estimations for a BEV without requiring extensive vehicle and computational resources. Therefore, the goal of this paper is to create a simple, yet reliable vehicle model, that can estimate the energy consumption of most, if not all, electric vehicles on the market by using parameter normalization techniques. These vehicle parameters include the vehicle test weight and performance to obtain a unified net Willans line to describe the input/output power through a linear relationship. A base model and three normalized models are developed by fitting the UDDS and HWFET energy consumption test data published by the EPA for all BEVs in the U.S. market. Out of the models analyzed, the normalization with weight performs best with the lowest RMSE values at 0.384 kW, 0.747 kW, and 0.988 kW for predicting the UDDS, HWY, and US06 data points, respectively, and 0.653 kW for all three data sets combined. Consideration of accessory loads at 0.5 kW improves the model normalized by weight and performance by a reduction of over 20% in RMSE for predictions with all data sets combined. Removing outliers in addition to consideration of accessory loads improves the model normalized by weight and performance by a reduction of over 36% in RMSE for predictions with all data sets combined. Overall, results suggest that a unified net Willans line is largely achievable with accessible energy consumption data on U.S. regulatory cycles. / Master of Science / Due to increased urgency regarding environmental concerns within the transportation industry, sustainable solutions for combating climate change are in high demand. One solution is a widespread transition from conventional internal combustion engine vehicles (ICEVs) to battery electric vehicles (BEVs). To facilitate this transition, reliable energy consumption modeling is desired to support quick, high-level analyses for BEVs without requiring expensive resources. Therefore, the goal of this paper is to create a simple vehicle model that can estimate the energy consumption of most, if not all, electric vehicles by scaling the data using vehicle parameters. These parameters include the vehicle test weight and performance to obtain a unified net Willans line model describing the input/output power through a linear relationship. The UDDS (city) and HWFET (highway) energy consumption data points used to develop the model are easily accessible from published EPA data. Out of the models analyzed, the normalization with test weight performs best with the lowest error values at 0.384 kW, 0.747 kW, and 0.988 kW for predicting the UDDS, HWFET, and US06 (aggressive city/highway cycle) data points, respectively, and 0.653 kW for all three data sets combined. Consideration of accessory loads at 0.5 kW improves the model normalized by weight and performance by a reduction of over 20% in error for predictions with all data sets combined. Removing outliers in addition to consideration of accessory loads improves the model normalized by weight and performance by a reduction of over 36% in error for predictions with all data sets combined. Overall, results suggest that a unified net Willans line is largely achievable with accessible energy consumption data on U.S. regulatory cycles.

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