Today, unified modeling language (UML) has become a standard modeling language in object-oriented systems analysis and design. Specifying the business logic constraint with object constraint language (OCL) and transforming the specification into code has become a main trend in this area. This research presents a classification of OCL expressions to specify the attribute, operation and relationship constraint on Class diagram. A sample case and a CASE tool are used to test the usability (including the concepts, application, and advantages) of the proposed method. With this approach, the system developer can specify the constraints easily and transform them into code automatically and thereby enhance the efficiency and reusability of system development.

Traditionally software testing is performed at the coding stage and is costly. Prior research indicated that if the errors can be found prior to the coding stage, the cost for fixing the errors can be reduced. Today, Unified Modeling Language (UML) has become a standard modeling language in object-oriented systems analysis and design. Over the past few years a considerable effort has been made in synthesizing UML, MDA (Model-Driven Architecture), and CASE tool to increase the productivity of the system development. Specifying the business logic constraints with Object Constraint Language (OCL) has become a main trend in this area. This study presents a methodology to specify the business logic constraint with OCL on the platform independent model during the systems analysis and design stage, then transform the OCL expressions into the code model and do the model testing simultaneously with a CASE tool. Three real-world cases and a CASE tool are used to test the usability (including the concepts, application, and advantages) of the proposed methodology. With this approach, software bugs related to business logic constraints can be found at the systems analysis and design stage and thereby reduce the cost of software testing and enhance the efficiency of system development.

No description available.

Made available in DSpace on 2014-07-29T14:57:46Z (GMT). No. of bitstreams: 1 Dissert parte 1 Glauber Boff.pdf: 3627301 bytes, checksum: a9c5bc5ed01e465f7ee93a59c0da1439 (MD5) Previous issue date: 2010-04-12 / The development of Information Systems (IS) should be performed so that changes in the client s business, which may be common, may be reflected in the system, without reducing its consistency and reliability. To achieve these features, portability and maintainability, which are challenges for Software Engineering, are very important. There are two essential requirements which, when present in the development process, make it easier to deal with the system complexity. The first requirement states that it should be possible to describe the IS business rules (BR) using a high level language, generating a single, implementation independent model. The second requirement demands that it should be possible to generate software source code from the abstract BR model, and to integrate this code to the IS. This work presents an approach to meet these requirements. This approach covers the specification, modeling, implementation and evaluation of business rules in software to facilitate the development and maintenance of complex IS. Instead of hard-coding the BR into the applications, this approach adopts OCL as a platform independent high-level language to define a single BR model for the IS. To store the rules safely throughout the IS life cycle, a centralized repository in the database was developed, which enables control over all BR versions. During implementation, rules in OCL are automatically converted to SQL and stored in the database as stored procedures for further evaluation by a specific component of the application. This approach facilitates the maintenance of the IS by the centralized and high-level description of all BR. To demonstrate the feasibility of the proposed approach, an empirical validation was performed in the context of a research project funded by CNPq, which aims to optimize the production of beef cattle. / O desenvolvimento de Sistemas de Informação (SI) deve ser realizado de forma que as mudanças no negócio do cliente, que podem ser frequentes, possam ser refletidas no sistema, sem que ele perca sua consistência e confiabilidade. Para se atingir essas características, a portabilidade e manutenibilidade, que são desafios para a Engenharia de Software, são importantes. Há dois requisitos essenciais que, quando presentes no processo de desenvolvimento, facilitam o tratamento da complexidade do sistema. O primeiro requisito diz que deveria ser possível descrever as regras de negócio (RN) usando uma linguagem de alto nível, gerando um modelo único e independente de implementação. O segundo requisito demanda que deveria ser possível gerar código fonte a partir do modelo abstrato de RN e integrá-lo ao SI. Neste trabalho é apresentada uma abordagem para atender a esses requisitos. Esta abordagem abrange especificação, modelagem, implementação e avaliação de regras de negócio em software de forma a facilitar o desenvolvimento e a manutenção de SI complexos. Em vez de codificar as RN diretamente nas aplicações, adotou-se a linguagem OCL, uma linguagem abstrata e independente de plataforma, para definir um modelo único de RN para o SI. Para armazenar as regras ao longo do ciclo de vida do SI de forma segura e de fácil acesso foi criado um repositório centralizado no banco de dados, que permite realizar o controle de todas as versões das RN. Na implementação, regras em OCL são convertidas automaticamente para SQL e armazenadas em banco de dados como procedimentos armazenados para posterior avaliação por um componente específico da aplicação. Esta abordagem facilita a manutenção do SI pela descrição centralizada e em alto nível de todas as RN de um sistema. Para demonstrar a viabilidade da abordagem proposta, uma validação empírica foi realizada no contexto de um projeto de pesquisa apoiado pelo CNPq que visa a otimização da produção de gado de corte.

Today, modeling the software with unified modeling language (UML), model driven architecture (MDA) concept, and computer-aided software engineering (CASE) tool are the main trend for the objected-oriented systems analysis and design. Furthermore, to enhance the degree of transformation automation and design reuse in the system development process, object constraint language (OCL) is used in UML modeling to specify the navigation, constraint, operation specification, and so forth. However, the guideline for using OCL in class diagram specification and its transformation to JAVA code is lacking. This research presents an approach utilizing the OCL to specify the constraint and operation specification for the class diagram when modeling the platform independent model (PIM), which can then be transformed into the JAVA platform specific model (PSM) and code using a CASE tool. A real-world case using the integrated techniques is presented and a CASE tool is used to illustrate the concepts, application, and the advantages of using the proposed approach. With this approach, the system developer can transform PIM into PSM and code automatically and thereby enhance the efficiency of system development.

Today, unified modeling language (UML) has become a standard modeling language in object-oriented systems analysis and design. Over the past few years a considerable effort has been made in synthesizing UML, MDA (model driven architecture), design patterns and CASE tool to increase the productivity of the system development. Specifying the design patterns with object constraint language (OCL) has become a main trend in this area. This study classifies the OCL expressions and design patterns and presents a method to specify each design pattern with the OCL and UML when modeling the platform independent model which can then be transformed into the platform dependent model, and to a code model. A real-world case using the integrated techniques is presented and a CASE tool is used to illustrate the concepts, application, and the advantages of using the proposed approach. With this approach, the system developer can transform PIM into code automatically and thereby enhance the efficiency and reusability of system development.

Made available in DSpace on 2014-06-12T15:49:38Z (GMT). No. of bitstreams: 1 license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5) Previous issue date: 2011 / Antonius de Castro Tavares, Marcellus; Pierre Louis Robin, Jacques. Behavioral java code generation from imperative object constraint language expressions in plataformindependent UML models. 2011. Dissertação (Mestrado). Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Pernambuco, Recife, 2011.

Metamodellierung im Sinne der Meta Object Facility (MOF) stellt eine Methode für die strukturelle Definition der abstrakten Syntax von Modellierungssprachen und Modellen im Softwareentwicklungsprozess dar. Um Modellsimulation und dynamische Analysen für metamodellbasierte Sprachen zu unterstützen, fehlt es an einem Kalkül zur operationalen Semantik. In dieser Arbeit wird ausgehend von MOF die Aktionssemantik MActions entwickelt, die die Definition von operationaler Semantik als Verhalten in Metamodellen ermöglicht. Diese Erweiterung geht einher mit der Beschreibung von Laufzeitmodellen sowie Zuständen und Parallelitätseigenschaften, so dass eine Verifikation von dynamischen Eigenschaften möglich wird. Zu diesem Zweck wird mit der Linear Temporal Object Constraint Language (LT-OCL) exemplarisch eine prädikatenlogische Temporallogik entwickelt, die eine metamodellunabhängige Analyse für ausführbare Modelle erlaubt. Dabei ist die Semantik von temporalen Ausdrücken über Zuständsänderungen von (aufgezeichneten) Ausführungsläufen beschrieben, wobei eine Linearisierung parallele Änderungen zusammenführt. Als weiteren Anwendungsfall der dynamischen Analyse untersuchen wir die Relation zum Verhaltensvergleich im Sinne der Bisimulationstheorie. Metamodelle, Aktionssemantik und Temporallogik werden mittels einer erweiterten Abstract State Machine (ASM) formal beschrieben und kommen in zwei Fallstudien zur Anwendung (Timed Automata und C#). / Object-oriented metamodelling as defined by the Meta Object Facility (MOF) provide a means to describe the structure of models and the abstract syntax of modelling languages at various stages in a software development process. However, MOF lacks concepts for the definition of operational semantics and there is no support for dynamic model analysis based on the semantics and abstract states of a language definition. This thesis investigates on extending the metamodelling framework with an action semantics - the MActions - to support the definition of operational semantics in metamodels and enable simulation as well as verification of dynamic properties. For this purpose, runtime models are incorporated with semantics for states, time, and properties of parallelism that allow a generic analysis solely bound to a certain metamodel definition. Furthermore, we develop the Linear Temporal Object Constraint Language (LT-OCL) to perform a dynamic analysis of execution runs based on the executable models. The semantics of this temporal predicate logic is bound to state changes of (recorded) execution traces that are linearizations of parallel changes of the runtimes model. This establishes the link to the theory of bisimulation as a second application case of dynamic analysis. Abstract State Machines (ASM) have been used to formally define the action language in conjunction with metamodels and the temporal logic. As proof of concept of the whole approach, the framework has been implemented and applied to two languages as case studies (namely Timed Automata and C#).

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.

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