A Safety Mechanism Using Software Patterns

Software patterns have been widely studied in order to reuse of design knowledge in software design phase. However, few patterns have been known in the area of safety. This paper addresses a mechanism for safety and its software pattern in a reactive system. We construct a pattern composed of a mechanism called an event checker including several software patterns to check scenarios, i.e., the order of events and their timing constraints. Next, we show examples of its implementation to railroad models using Java. Moreover, we discuss the safety in the domain of a reactive system by means of this event checker and its software reliability by using this pattern.     

Generating code for engineering design systems using software patterns

We illustrate here how software engineers developing engineering design systems can introduce patterns into the conceptual modeling techniques that were developed in the database community and integrate them with techniques that are emerging in the object-oriented analysis and engineering design community. The goal is to raise the level of abstraction used to communicate software specifications and to build applications. This will speed the development and improve the quality of engineering design tools. We show by an example how this can be accomplished through an example software pattern from the software engineering discipline (the observer pattern) [12]. We show how patterns can be automatically supported using the general techniques that were developed in the Semantic Objects, Relationships, and Constraints (SORAC) project [20] for the development of tools, for the specification of databases and for building design systems.     

Application of ontology modularization to human-web interface design for knowledge sharing

Ontology has received considerable attention in the semantic technology community. This paper discusses the roles of ontology modularization in human-web interface design for knowledge sharing. It stresses that ontology can support human-web interaction as a key component of knowledge sharing on the Internet. The paper proposes an approach of ontology modularization to navigating and searching web portals for the purposes of knowledge sharing. A case study of human-web interface design using ontology modularization for a commercial software web portal is used to illustrate the application of the proposed approach.     

Design pattern evolutions in QVT

One of the main goals of design patterns is to design for change. Many design patterns leave some room for future changes and evolutions. The application of design patterns leads to adaptable software since the design pattern instances could be changed with minimal impact on other parts of the system. Such changes, called the evolution of a design pattern instance in this paper, typically involve the addition or removal of a group of model elements, such as classes, attributes, operations, and relationships. However, the possible evolutions of each design pattern are often not explicitly documented. Missing a part of the evolution process may result in inconsistent evolutions. In this paper, we present our approach to assist the evolution processes of design patterns by model transformation technology. We provide a formal foundation for our approach by defining the predicates that can be used to describe the properties of each design pattern, software system design, and design pattern evolutions. We also provide tool support to automate the evolution processes based on the Query, View, and Transformation standard. A case study of a large open-source software system is conducted to illustrate and evaluate our approach.     

Rule-based detection of design patterns in program code

The process of understanding and reusing software is often time-consuming, especially in legacy code and open-source libraries. While some core code of open-source libraries may be well-documented, it is frequently the case that open-source libraries lack informative API documentation and reliable design information. As a result, the source code itself is often the sole reliable source of information for program understanding activities. In this article, we propose a reverse-engineering approach that can provide assistance during the process of understanding software through the automatic recovery of hidden design patterns in software libraries. Specifically, we use ontology formalism to represent the conceptual knowledge of the source code and semantic rules to capture the structures and behaviors of the design patterns in the libraries. Several software libraries were examined with this approach and the evaluation results show that effective and flexible detection of design patterns can be achieved without using hard-coded heuristics.     

OWL本体到软件代码模型映射的研究

OWL本体在知识工程中有着广泛应用,人们考虑用它来解决软件开发中的问题。该文分析OWL本体和Java面向对象模型问的差别,指出直接映射存在的问题,阐述OWL本体映射到面向方面模型的特点,并提出OWL本体向AspectJ面向方面模型映射的具体方法,较好实现OWL本体向软件代码模型的映射。     

Blending design patterns with aspects: A quantitative study

Design patterns often need to be blended (or composed) when they are instantiated in a software system. The composition of design patterns consists of assigning multiple pattern elements into overlapping sets of classes in a software system. Whenever the modularity of each design pattern is not preserved in the source code, their implementation becomes tangled with each other and with the classes’ core responsibilities. As a consequence, the change or removal of each design pattern will be costly or prohibitive as the software system evolves. In fact, composing design patterns is much harder than instantiating them in an isolated manner. Previous studies have found design pattern implementations are naturally crosscutting in object-oriented systems, thereby making it difficult to modularly compose them. Therefore, aspect-oriented programming (AOP) has been pointed out as a natural alternative for modularizing and blending design patterns. However, there is little empirical knowledge on how AOP models influence the composability of widely used design patterns. This paper investigates the influence of using AOP models for composing the Gang-of-Four design patterns. Our study categorizes different forms of pattern composition and studies the benefits and drawbacks of AOP in these contexts. We performed assessments of several pair-wise compositions taken from 3 medium-sized systems implemented in Java and two AOP models, namely, AspectJ and Compose*. We also considered complex situations where more than two patterns involved in each composition, and the patterns were interacting with other aspects implementing other crosscutting concerns of the system. In general, we observed two dominant factors impacting the pattern composability with AOP: (i) the category of the pattern composition, and (ii) the AspectJ idioms used to implement the design patterns taking part in the composition.     

设计模式组合操作优化研究

作为软件设计经验的总结,恰当使用设计模式能够有效提高软件系统的可复用性,确保最终所得软件产品的质量。但在实际应用中,人们很少使用单一的设计模式,通常需要根据实际的应用场景进行多个模式的组合,这可能会导致所得结果不确定,严重影响软件产品的质量。虽然现有的模式组合形式化方法能够有效地表达模式组合后的结果,但是组合方法逻辑复杂并包含大量的冗余操作,设计人员很难熟练使用。针对上述模式组合过程中存在的问题,文中对多模式之间的组合关系进行了深入探讨,从设计模式的形式化描述出发,结合Z语言的特点对现有的模式组合形式化方法进行了深入研究,并对现有的模式组合操作符进行了初步优化;在现有操作符集合的基础上提出了基于模式的约束、叠加和扩展操作符,通过操作符定义了模式组合的精确语义,并采用代数推理过程验证了优化后的方法可以有效地替代现有的模式组合形式化方法,且能够解决现有模式组合形式化方法中操作符冗余、数量过多导致的效率低等问题。最后,通过模式组合案例的研究,验证了所提方法的有效性。     

Bridging the HASM: An OWL ontology for modeling the information pathways in haptic interfaces software

Haptics technology has received enormous attention to enhance human computer interaction. The last decade has witnessed a rapid progress in haptic application software development due to the fact that the underlying technology has become mature and has opened up novel research areas. In an attempt to organize the path between cause and effect we envision a need for a standard for haptic application software modeling. In order for the software to better enhance the tactile information sensation, flow and perception and also make interaction between humans and haptics more efficient and natural, we need a formal representation of the haptics domain. This article proposes the use of HASM, a haptic applications software modeling ontology to formally model the haptics domain in order to be used during the specifications and design phases of developing software applications for haptic interfaces. The presented ontology captures the existing knowledge in haptics domain, using OWL, and defines the pathways that the haptic information follows between the human and the machine haptic system, using SWRL rules. The haptic ontology that has been developed will be used as a basis to design effective user interfaces and assist the development of software modeling for haptic devices. A case study is demonstrating how this haptic ontology can be used to design a software model that analyzes the perception of a haptic property of an object by interacting with a haptic device.     

基于角色的设计模式建模和实现方法

虽然设计模式有利于软件的重用,但当设计模式实例化时,存在模式的重叠、可追踪性以及模式代码难于重用等问题.提出一种基于角色的设计模式的建模和实现方法,在设计和实现两个层面上解决上述问题.该方法把设计模式的角色作为独立的建模元素,在应用程序类和角色间导入RoleOf关系,使应用逻辑和模式逻辑完全分离,从而提高其重用性.使用UML的标准扩充机制,给出了RoleOf关系的元模型和语义,以及标识模式信息的构造型和标记值,以此解决模式的重叠和可追溯性等问题.通过对Java语言进行扩充(称为Rava),实现了应用逻辑和模式逻辑的动态绑定.该方法较好地解决了设计模式实例化时的模式重叠和可追踪性问题,提高了模式逻辑的可重用性,对运用设计模式开发软件有一定的指导作用.     

软件设计模式及其在Java类库中的典型实现

软件设计模式代表了从成功的系统设计中分离出来的可复用的优秀设计经验,已成为现代软件系统设计的重要研究对象。文章介绍了设计模式的主要特点和使用设计模式给软件设计带来的好处,并就设计模式在Java类库中的一些典型实现进行了分析。     

An exploratory study on cooccurrence of design patterns and bad smells using software metrics

A design pattern is a general reusable solution to commonly recurring problems in software projects. Bad smells are symptoms existing in the source code that possibly indicate the presence of a structural problem that requires code refactoring. Although design pattern and bad smells be different concepts, literature has shown that they may be related and cooccur during the evolution of a software system. This paper presents an empirical study that investigates cooccurrences of design patterns and bad smells as well as identifies the main factors that contribute to the emergence of the relationship between them. We carried out a case study with five Java systems to: (1) investigate if the use of design pattern reduces bad smell occurrence, (2) identify cooccurrences of design patterns and bad smells, and (3) identify situations that contribute for the cooccurrence emergence. As the main result, we found that the application of design pattern not necessarily avoid bad smell occurrences. The results also show that some design patterns such as composite, factory method, and singleton, are intrinsically modular and might be useful in creating high-quality systems. However, other design patterns such as adapter-command, proxy, and state-strategy, have presented high cooccurrence frequency with bad smells; therefore, they require attention in their implementation. Finally, via manual inspection in the components with cooccurrence, we found that the identified cooccurrences appeared due to poor planning and inadequate application of design patterns.     

Thesaurus or Logical Ontology,Which One Do We Need for Text Mining?

Ontologies are recognised as important tools, not only for effective and efficient information sharing, but also for information extraction and text mining. In the biomedical domain, the need for a common ontology for information sharing has long been recognised, and several ontologies are now widely used. However, there is confusion among researchers concerning the type of ontology that is needed for text mining , and how it can be used for effective knowledge management, sharing, and integration in biomedicine. We argue that there are several different ways to define an ontology and that, while the logical view is popular for some applications, it may be neither possible nor necessary for text mining. We propose a text-centered approach for knowledge sharing, as an alternative to formal ontologies. We argue that a thesaurus (i.e. an organised collection of terms enriched with relations) is more useful for text mining applications than formal ontologies.     

Onyx: A new Canvas-based tool for visualizing biomedical and health ontologies

Ontologies provide formal, machine-readable, and human-interpretable representations of domain knowledge. Therefore, ontologies have come into question with the development of Semantic Web technologies. People who want to use ontologies need an understanding of the ontology, but this understanding is very difficult to attain if the ontology user lacks the background knowledge necessary to comprehend the ontology or if the ontology is very large. Thus, software tools that facilitate the understanding of ontologies are needed. Ontology visualization is an important research area because visualization can help in the development, exploration, verification, and comprehension of ontologies. This paper introduces the design of a new ontology visualization tool, which differs from traditional visualization tools by providing important metrics and analytics about ontology concepts and warning the ontology developer about potential ontology design errors. The tool, called Onyx, also has advantages in terms of speed and readability. Thus, Onyx offers a suitable environment for the representation of large ontologies, especially those used in biomedical and health information systems and those that contain many terms. It is clear that these additional functionalities will increase the value of traditional ontology visualization tools during ontology exploration and evaluation.     

Kumbang: A domain ontology for modelling variability in software product families

Variability is the ability of a system to be efficiently extended, changed, customised or configured for use in a particular context. There is an ever-growing demand for variability of software. Software product families are an important means for implementing software variability. We present a domain ontology called Kumbang for modelling the variability in software product families. Kumbang synthesises previous approaches to modelling variability in software product families. In addition, it incorporates modelling constructs developed in the product configuration domain for modelling the variability in non-software products. The modelling concepts include components and features with compositional structure and attributes, the interfaces of components and connections between them, and constraints. The semantics of Kumbang is rigorously described using natural language and a UML profile. We provide preliminary proof of concept for Kumbang: the domain ontology has been provided with a formal semantics by implementing a translation into a general-purpose knowledge representation language with formal semantics and inference support. A prototype tool for resolving variability has been implemented.     

基于知识图的领域本体构建方法

提出了一种基于知识图的领域本体半自动构建方法。以《知网》为语义知识资源,知识图为语义表示方法,采用成熟的软件工程流程,最终构建出的领域本体具有结构明确、语义清晰的特点。对于在其上的语义网、信息抽取等应用提供了有效支持。介绍了本体的概念、设计的准则、建模的流程,并对未来的本体的移植性进行展望。实验结果表明该方法在不确定性知识处理上优于传统本体构建方法。     

Automated verification of design patterns: A case study

Representing design decisions for complex software systems, tracing them to code, and enforcing them throughout the lifecycle are pressing concerns for software architects and developers. To be of practical use, specification and modeling languages for software design need to combine rigor with abstraction and simplicity, and be supported by automated design verification tools that require minimal human intervention. This paper examines closely the use of the visual language of Codecharts for representing design decisions and demonstrate the process of verifying the conformance of a program to the chart. We explicate the abstract semantics of segments of the Java package java.awt as a finite structures, specify the Composite design pattern as a Codechart and unpack it as a set of formulas, and prove that the structure representing the program satisfies the formulas. We also describe a set of tools for modeling design patterns with Codecharts and for verifying the conformance of native (plain) Java programs to the charts.