Deferring elimination of design alternatives in object‐oriented methods

While developing systems, software engineers generally have to deal with a large number of design alternatives. Current object‐oriented methods aim to eliminate design alternatives whenever they are generated. Alternatives, however, should be eliminated only when sufficient information to take such a decision is available. Otherwise, alternatives have to be preserved to allow further refinements along the development process. Too early elimination of alternatives results in loss of information and excessive restriction of the design space. This paper aims to enhance the current object‐oriented methods by modeling and controlling the design alternatives through the application of fuzzy‐logic‐based techniques. By using an example method, it is shown that the proposed approach increases the adaptability and reusability of design models. The method has been implemented and tested in our experimental CASE environment. Copyright © 2001 John Wiley & Sons, Ltd.     

HOOD方法与形式化技术的集成研究

ＨＯＯＤ是由欧洲ＥＳＡ公司开发的一种面向对象软件结构设计方法,它使用图形,结构化英语和Ａｄａ伪码来描述系统的设计规约,本文首先概述了ＨＯＯＤ方法的基本概念和对它进行的改进,然后提出了一种集成ＨＯＯＤ和形式化技术的方法,借助该方法可以获得更为严格的软件设计规约,最后简要介绍了其机器支持系统。     

Agents in object‐oriented software engineering

Software engineers of multi‐agent systems (MASs) are faced with different concerns such as autonomy, adaptation, interaction, collaboration, learning, and mobility, which are essentially different from classical concerns addressed in object‐oriented software engineering. MAS developers, however, have relied mostly on object‐oriented design techniques and programming languages, such as Java. This often leads to a poor separation of MAS concerns and in turn to the production of MASs that are difficult to maintain and reuse. This paper discusses software engineering approaches for MASs, and presents a new method for integrating agents into object‐oriented software engineering from an early stage of design. The proposed approach encourages the separate handling of MAS concerns, and provides a disciplined scheme for their composition. Our proposal explores the benefits of aspect‐oriented software development for the incorporation of agents into object‐oriented systems. We also illustrate our aspect‐oriented approach through the Portalware multi‐agent system, a Web‐based environment for the development of e‐commerce portals. Copyright © 2004 John Wiley & Sons, Ltd.     

基于角色的设计模式形式建模及演化

重用设计在改善软件开发过程中的作用越来越受到人们的重视.面向对象的软件设计模式概念的提出为软件设计的重用打开了新的局面.但在设计模式的具体应用中存在实现、文档和组合的问题.给出了一种基于角色的设计模式形式建模方法,将类、类属性、类之间的关系等都看作角色,并用形式建模语言Object-Z形式表示这些角色,可有效地解决设计模式实例化时存在的问题.基于角色的设计模式形式模型在演化时也基于角色进行演化,将模式的演化分为角色层演化和模式层演化,模式层演化是由多个角色层演化组成的.演化后的模型可以通过定理证明器验证与前模型是否保持一致.     

A theory-based representation for object-oriented domain models

Formal software specification has long been touted as a way to increase the quality and reliability of software; however, it remains an intricate, manually intensive activity. An alternative to using formal specifications directly is to translate graphically based, semiformal specifications into formal specifications. However, before this translation can take place, a formal definition of basic object oriented concepts must be found. The paper presents an algebraic model of object orientation that defines how object oriented concepts can be represented algebraically using an object oriented algebraic specification language O-SLANG. O-SLANG combines basic algebraic specification constructs with category theory operations to capture internal object class structure, as well as relationships between classes     

BCOOPL: Basic concurrent object‐oriented programming language

A small, object‐oriented language is introduced: BCOOPL (Basic Concurrent Object‐Oriented Programming Language). This language is specifically targeted to support component‐oriented programming. The main design goal of BCOOPL was to provide a small, but powerful set of language features that supports the construction of high‐quality components through well‐established software engineering practices, which include the separation of interfaces and implementations, weakly‐coupled objects, and abstraction. A number of design patterns based on these principles is actually built in the language. In particular, the observer, the mediator and the bridge are supported directly. This provides a strong foundation on which higher level component specification languages can be built. BCOOPL has a long research history. Its roots can be traced back to path expressions, and the concurrent object‐oriented programming languages Procol and Talktalk. As a result, BCOOPL only integrates essential language features that blend well and have proven their value in practice. Copyright © 2000 John Wiley & Sons, Ltd.     

Converting command‐line applications into binary components

A binary component is a separately compiled program that can be used as a part of a larger program. Binary components generally conform to an accepted technology such as JavaBeans or ActiveX, and generally support a rich program interface containing properties, methods and events. Binary components are generally used in a graphical user interface (GUI) environment. There are a number of benefits to be realized by converting command‐line software into binary components. The most important of these is that GUI environments are more popular and more familiar to most people than command‐line environments. Using binary components can greatly simplify a GUI implementation, to the point where it is only slightly more complicated than a typical command‐line implementation. However there are benefits that go beyond mere convenience. Binary components have much richer interfaces than command‐line programs. Binary components are service‐oriented rather than task‐oriented. A task‐oriented program has a main routine that is devoted to accomplishing a single task. A service‐oriented component has no main routine or main function, but instead provides a variety of services to its clients. Binary components can be easily integrated with one another, which permits a design where each major feature of an application is implemented in a different component. Such a design encourages software reuse at the component level and facilitates low‐impact feature upgrades. We first delineate a design‐pattern‐based methodology for converting command‐line programs into components. We then illustrate these principles using two projects, a simulation system for digital circuits, and a data generation system for software and hardware testing. Copyright © 2005 John Wiley & Sons, Ltd.     

面向对象的组合软件工程研究

组合软件工程技术是当今软件工程技术发展的主流。本文综述了作者在基于对象的组合软件工程研究方面的最新进展，包括语义模型、描述语言、设计方法学和支持环境等方面。     

泛型编程与设计模式

现今面向对象已经成为软件业内的主流技术，然而它存在很多的弱点，使得它的通用性和抽象程度受到很大限制。设计模式作为面向对象领域内的高级软件复用技术，同样摆脱不了相同的困扰。泛型编程是面向对象的进一步发展，从更高的角度对世界进行抽象，为面向对象的不足之处提供了解决之道。将设计模式泛化带来更大规模的代码复用，使得设计模式的实现得以自动化，从而使开发人员能以面向设计的方式让使用者自行装配所需机能，产生能表达原始设计意图的代码，实现设计与编码之间的无缝过渡。     

设计模式及其在AMCCS中的应用

虽然目前已存在多种面向对象的软件设计方法,但在面向对象建模中仍存在不尽人意之处。进行面向对象的软件设计是比较困难的,而设计可复用的面向对象软件就更加困难。设计模式是面向对象建模的一种辅助设计手段,它总结了面向对象设计的成功设计经验,使得在遇到相似场景时可以直接套用。结合民航维修成本控制系统(AMCCS)的开发工作,使用设计模式细化具体组件和部件的对象建模方法,取得了较好的效果。     

Petri net modelling and design of task oriented messaging system for robot control

Manufacturing Message Specification (MMS) is an international standard for shop floor machine control. It defines a set of conceptual schema and an interactive software object known as Virtual Manufacturing Device (VMD). Many systems have been established using this protocol but very few formal methods have been used to build such systems. This paper addresses the problems of the design and analysis of a network-based task oriented messaging system for flexible robot task control using a Petri net. The information and message transfer processes of the MMS systems were analysed. The modelling methodology allows a top down approach by which the net model is decomposed into fine details with clear identification of components which can be realised directly from the model. This approach is illustrated in this paper by a Windows-based robot control prototype system implemented from the Petri net model. The prototype was built using Object Windows Library and the NetBIOS session layer protocol on a PC network.     

An aspect‐oriented software architecture for code mobility

Mobile agents have come forward as a technique for tackling the complexity of open distributed applications. However, the pervasive nature of code mobility implies that it cannot be modularized using only object‐oriented (OO) concepts. In fact, developers frequently evidence the presence of mobility scattering in their system's modules. Despite these problems, they usually rely on OO application programming interfaces (APIs) offered by the mobility platforms. Such classical API‐oriented designs suffer a number of architectural restrictions, and there is a pressing need for empowering developers with an architectural framework supporting a flexible incorporation of code mobility in the agent applications. This work presents an aspect‐oriented software architecture, called ArchM, ensuring that code mobility has an enhanced modularization and variability in agent systems, and is straightforwardly introduced in otherwise stationary agents. It addresses OO APIs' restrictions and is independent of specific platforms and applications. An ArchM implementation also overcomes fine‐grained problems related to mobility tangling and scattering at the implementation level. The usefulness and usability of ArchM are assessed within the context of two case studies and through its composition with two mobility platforms. Copyright © 2008 John Wiley & Sons, Ltd.     

Understanding design patterns — what is the problem?

Design patterns codify proven solutions to recurring design problems. Their proper use within a development context requires that: (i) we understand them; (ii) we ascertain their applicability or relevance to the design problem at hand; and (iii) we apply them faithfully to the problem at hand. We argue that an explicit representation of the design problem solved by a design pattern is key to supporting the three tasks in an integrated fashion. We propose a model‐driven representation of design patterns consisting of triples < MP, MS, T > where MP is a model of the problem solved by the pattern, MS is a model of the solution proposed by the pattern, and T is a model transformation of an instance of the problem into an instance of the solution. Given an object‐oriented design model, we look for model fragments that match MP (call them instances of MP), and when one is found, we apply the transformation T yielding an instance of MS. Easier said than done. Experimentation with an Eclipse Modeling Framework‐based implementation of our approach applied to a number of open‐source software application's raised fundamental questions about: (i) the nature of design patterns in general, and the ones that lend themselves to our approach, and (ii) our understanding and codification of seemingly simple design patterns. In this paper, we present the principles behind our approach, report on the results of applying the approach to the Gang of Four (GoF) design patterns, and discuss the representability of design problems solved by these patterns. Copyright © 2011 John Wiley & Sons, Ltd.     

A multiple case study of design pattern decay, grime, and rot in evolving software systems

Software designs decay as systems, uses, and operational environments evolve. Decay can involve the design patterns used to structure a system. Classes that participate in design pattern realizations accumulate grime—non-pattern-related code. Design pattern realizations can also rot, when changes break the structural or functional integrity of a design pattern. Design pattern rot can prevent a pattern realization from fulfilling its responsibilities, and thus represents a fault. Grime buildup does not break the structural integrity of a pattern but can reduce system testability and adaptability. This research examined the extent to which software designs actually decay, rot, and accumulate grime by studying the aging of design patterns in three successful object-oriented systems. We generated UML models from the three implementations and employed a multiple case study methodology to analyze the evolution of the designs. We found no evidence of design pattern rot in these systems. However, we found considerable evidence of pattern decay due to grime. Dependencies between design pattern components increased without regard for pattern intent, reducing pattern modularity, and decreasing testability and adaptability. The study of decay and grime showed that the grime that builds up around design patterns is mostly due to increases in coupling.     

A Matrix-Based Approach to Recovering Design Patterns

Design patterns describe good solutions to common and recurring problems in software design. They have been widely applied in many software systems in industry. However, pattern-related information is typically not available in large system implementations. Recovering these design pattern instances in software systems can help not only to understand the original design decisions and tradeoffs but also to change the systems with quality assurance. This paper presents our approach on recovering design patterns based on matrices and weights. We formally specify our methods to encode both the systems and the design patterns into matrices and weight. Our formal specification rigorously defines the structural, behavioral, and semantic analyses of our approach. A set of experiments on real-world systems is also carried out to evaluate our approach with analysis results.     

一种面向对象的形式化设计方法──从COOZ需求规格说明到设计

本文介绍了一种基于形式化规格说明语言ＣＯＯＺ的面向对象设计方法并给出实例。该方法用ＣＯＯＺ描述类的设计规格说明，实现了从形式化需求描述到形式化设计的平滑过渡。文中重点讨论了与设计方法有关的一些面向对象概念：对象类型和类的分开、子类型和继承的分开、灵活的消息传递和参数转换机制、主动对象和被动对象、根类的定义等。