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.

It is widely believed and empirically shown that component reuse improves both the quality and productivity of software development. This brings the necessity of a graphical editor to model the projects by using components. A graphical editor was implemented for the development of Component Oriented software development. The editor facilitates modeling efforts through application of the graphical modeling language COSEML. Both design patterns and software components have come to play important roles in software development. The correlation between software components and design patterns is apparent. In the design phase of the projects design patterns are used widely both in component and object oriented projects. Design patterns can be used as super components in component-based development . Software reuse, software components, design patterns, use of design patterns in component-based development, and component architectures are studied in details to address the need for the approach. COSE modeling activity starts with the decomposition of the target system into building blocks in a top-down order. Next, interfaces between these blocks are defined. If required design patterns can be added to model as super components.

Component Oriented Software Engineering (COSE) seems to be the future of software engineering. Currently, COSEML is the only modeling language that completely supports the COSE approach. Abstract decomposition of the system and their representing components are shown in a hierarchy diagram to support the COSE process model. In COSEML, only static modeling is supported through this single diagram. However, software is about behavior and static modeling is not sufficient to describe the system. The aim of this thesis is providing the benefits of dynamic modeling to COSEML by adopting collaboration diagrams. For this purpose, first, specification of modified collaboration diagrams is made for COSEML. Then software is developed for supporting collaboration diagrams in COSECASE. Also, an e-store application is modeled with COSEML using the collaboration diagrams. With this work, modeling the dynamic behavior of the system in both abstract and component levels is made possible. Furthermore, use case realization is enabled in the COSE modeling. More important, modeling the sequential interactions among components is made possible. Consequently, a suitable environment is provided for automated testing and application generation from the model.

Capsules are modeling language elements which are sometimes used to develop real-time software. One way to test such capsule elements without relying on dependencies to other units is to use mock objects. The aim of the study was to look at existing object-oriented design patterns and investigate how they could be used for capsules, in order to perform mock testing. The focus was to find solutions that were usable from the programmers’ point of view, meaning that they should promote high user effectiveness, efficiency and satisfaction when implementing them. It was also important that program efficiency wasn’t affected negatively. 5 design- or refactoring patterns were adapted for capsules: Constructor Injection, Setter Injection, Parameterize Method, Factory Method and Abstract Factory. Those patterns were evaluated by 5 programmers in a usability test, where Incarnate Injection (an adaptation of Constructor Injection) and Abstract Factory were considered most usable. Incarnate Injection seemed to be easier to implement and promoted high user efficiency, while Abstract Factory was considered more flexible. The performance tests indicated that Abstract Factory compromises program efficiency when the factory product is resource-heavy and is required frequently by dependent capsules. The study showed that it is possible to adapt design patterns to capsules by looking at conceptual similarities between capsules and classes. However, there are cases when this adaptation is impossible. Furthermore, even when adaptation is possible, it was apparent that different patterns adapt differently well to capsules.

Role-based modeling has been proposed in 1977 by Charles W. Bachman, as a means to model complex and dynamic domains, because roles are able to capture both context-dependent and collaborative behavior of objects. Consequently, they were introduced in various fields of research ranging from data modeling via conceptual modeling through to programming languages. More importantly, because current software systems are characterized by increased complexity and context-dependence, there is a strong demand for new concepts beyond object-oriented design. Although mainstream modeling languages, i.e., Entity-Relationship Model, Unified Modeling Language, are good at capturing a system's structure, they lack ways to model the system's behavior, as it dynamically emerges through collaborating objects. In turn, roles are a natural concept capturing the behavior of participants in a collaboration. Moreover, roles permit the specification of interactions independent from the interacting objects. Similarly, more recent approaches use roles to capture context-dependent properties of objects. The notion of roles can help to tame the increased complexity and context-dependence. Despite all that, these years of research had almost no influence on current software development practice. To make things worse, until now there is no common understanding of roles in the research community and no approach fully incorporates both the context-dependent and the relational nature of roles. In this thesis, I will devise a formal model for a family of role-based modeling languages to capture the various notions of roles. Together with a software product line of Role Modeling Editors, this, in turn, enables the generation of a role-based language family for Role-based Software Infrastructures (RoSI).

Role-based modeling has been proposed in 1977 by Charles W. Bachman, as a means to model complex and dynamic domains, because roles are able to capture both context-dependent and collaborative behavior of objects. Consequently, they were introduced in various fields of research ranging from data modeling via conceptual modeling through to programming languages. More importantly, because current software systems are characterized by increased complexity and context-dependence, there is a strong demand for new concepts beyond object-oriented design. Although mainstream modeling languages, i.e., Entity-Relationship Model, Unified Modeling Language, are good at capturing a system's structure, they lack ways to model the system's behavior, as it dynamically emerges through collaborating objects. In turn, roles are a natural concept capturing the behavior of participants in a collaboration. Moreover, roles permit the specification of interactions independent from the interacting objects. Similarly, more recent approaches use roles to capture context-dependent properties of objects. The notion of roles can help to tame the increased complexity and context-dependence. Despite all that, these years of research had almost no influence on current software development practice. To make things worse, until now there is no common understanding of roles in the research community and no approach fully incorporates both the context-dependent and the relational nature of roles. In this thesis, I will devise a formal model for a family of role-based modeling languages to capture the various notions of roles. Together with a software product line of Role Modeling Editors, this, in turn, enables the generation of a role-based language family for Role-based Software Infrastructures (RoSI).:I Review of Contemporary Role-based Languages 1 Introduction 1.1 Background 1.2 Motivation 1.3 Problem Definition 1.4 Outline 2 Nature of Roles 2.1 Running Example 2.2 Behavioral Nature 2.3 Relational Nature 2.4 Context-Dependent Nature 2.5 Constraints in Role-Based Languages 2.6 Classification of Roles 3 Systematic Literature Review 3.1 Method 3.2 Results 3.3 Discussion 4 Contemporary Role-Based Modeling Languages 4.1 Behavioral and Relational Modeling Languages 4.1.1 Lodwick 4.1.2 The Generic Role Model 4.1.3 Role-Based Metamodeling Language (RBML) 4.1.4 Role-Based Pattern Specification 4.1.5 Object-Role Modeling (ORM) 2 4.1.6 OntoUML 4.2 Context-Dependent Modeling Languages 4.2.1 Metamodel for Roles 4.2.2 E-CARGO Model 4.2.3 Data Context Interaction (DCI) 4.3 Combined Modeling Languages 4.3.1 Taming Agents and Objects (TAO) 4.3.2 Information Networking Model (INM) 4.3.3 Helena Approach 5 Contemporary Role-based Programming Languages 5.1 Behavioral Programming Languages 5.1.1 Chameleon 5.1.2 Java with Roles (JAWIRO) 5.1.3 Rava 5.1.4 JavaStage 5.2 Relational Programming Languages 5.2.1 Rumer 5.2.2 First Class Relationships 5.2.3 Relations 5.3 Context-Dependent Programming Languages 5.3.1 EpsilonJ and NextEJ 5.3.2 Role/Interaction/Communicative Action (RICA) 5.3.3 ObjectTeams/Java 5.3.4 PowerJava 5.3.5 Scala Roles 6 Comparison of Role-based Languages 6.1 Comparison of Role-Based Modeling Languages 6.2 Comparison of Role-Based Programming Languages 6.3 Results and Findings II Family of Role-Based Modeling Languages 7 Foundations of Role-Based Modeling Languages 7.1 Ontological Foundation 7.1.1 Metaproperties 7.1.2 Classifying Modeling Concepts 7.2 Graphical Notation 7.2.1 Model Level Notation 7.2.2 Graphical Modeling Constraints 7.2.3 Instance Level Notation 7.3 Formalization of Roles 7.3.1 Model Level 7.3.2 Instance Level 7.3.3 Constraint Level 7.4 Reintroducing Inheritance 7.4.1 Extending the Banking Application 7.4.2 Model Level Extensions 7.4.3 Instance Level Extensions 7.4.4 Constraint Level Extensions 7.5 Reference Implementation 7.5.1 Translation of Logical Formulae 7.5.2 Structure of the Reference Implementation 7.5.3 Specifying and Verifying Role Models 7.6 Full-Fledged Role Modeling Editor 7.6.1 Software Architecture 7.6.2 Illustrative Example 7.6.3 Additional Tool Support 8 Family of Role-Based Modeling Languages 8.1 Family of Metamodels for Role-Based Modeling Languages 8.1.1 Feature Model for Role-Based Languages 8.1.2 Feature Minimal Metamodel 8.1.3 Feature Complete Metamodel 8.1.4 Mapping Features to Variation Points 8.1.5 Implementation of the Metamodel Generator 8.2 First Family of Role Modeling Editors 8.2.1 Dynamic Feature Configuration 8.2.2 Architecture of the Dynamic Software Product Line 8.2.3 Applicability of the Language Family Within RoSI 9 Conclusion 9.1 Summary 9.2 Contributions 9.3 Comparison with Contemporary Role-Based Modeling Languages 9.4 Future Research

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.

De nos jours, le degré de complexité des systèmes de transport notamment ferroviaires est important et grandissant. En effet, les nouvelles technologies et besoins des grandes métropoles contraignent les concepteurs de ces systèmes à toujours intégrer de plus en plus de fonctionnalités. Cette complexité rend obsolète les méthodes de conception traditionnelles qui reposent sur l'expertise d'ingénieurs. La conception du système est définie sur plusieurs documents de spécification, de centaines de pages chacun. Ces derniers comprennent généralement la description des différentes exigences, fonctionnalités et sous-systèmes, ils sont rédigés en langage naturel. Ceci est source d'erreurs et ambigüités lors des différentes phases de conception et de validation sécuritaire. De ce fait, l'ingénierie système basée sur les modèles propose des solutions outillées afin de structurer et spécifier de manière systématique le fonctionnement du système. Dans cette thèse, nous proposons une approche de rétro-ingénierie de ces spécifications système. Cette approche nous permet de définir une méthodologie orientée-scénarios pour la formalisation et analyse de spécifications système. Elle est basée sur le langage de modélisation semi-formel ScOLa (Scénarios Oriented Language) et un modèle d'exécution formel basé sur le langage AltaRica 3.0. Nous proposons, á partir de ScOLa, des techniques contribuant aux analyses de sûreté fonctionnelles du système. Ces techniques permettent de clarifier, structurer et analyser / As of today, the complexity of transportation systems and especially railways is continuously growing. Indeed, new technologies and needs of major metropolitan areas constrain system designers to integrate more and more functionalities. Traditional methods for the design of systems are mainly based on the knowledge of experts. Systems are specified in several documents, of hundreds of pages each. These documents provide a general description of the requirements, functionalities and sub-systems, and are written in a natural language. This is error-prone and source of ambiguities. Model-based systems engineering proposes systematic solutions to structure and specify systems architectures. In this thesis, we propose a reverse engineering approach that is able to capture systems concepts. This leads us to propose ScOLa, a scenario-oriented modeling language for systems specifications with the following features:- A scenario-oriented approach to provide a more contextual view of the system, at several abstraction levels.- A co-construction of the architecture and behavior of the system in the same model.- The use of ScOLa for a seamless integration of system specification and safety analysis. We propose ascenario-oriented methodology for safety analysis, implemented using AltaRica 3.0.

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