Narrow Results

Parallel programming continues to be difficult and error-prone, whether starting from specifications or from an existing sequential program. This paper presents (1) a methodology for parallelizing sequential applications and (2) experiments in applying the methodology. The methodology is based on the use of stepwise refinement together with what we call parallel programming archetypes (briefly, abstractions that capture common features of classes of programs), in which most of the work of parallelization is done using familiar sequential tools and techniques, and those parts of the process that cannot be addressed with sequential tools and techniques are addressed with formally-justified transformations. The experiments consist of applying the methodology to sequential application programs, and they provide evidence that the methodology produces correct and reasonably efficient programs at reasonable human-effort cost. Of particular interest is the fact that the aspect of the methodology that is most completely formally justified is the aspect that in practice was the most trouble-free.

Many mobile and wireless devices are connecting to the Internet nowadays, among them, mobile phones and PDAs are the most popular ones. Thus, in this paper, we will focus on how to develop embedded software running on the two devices by using design patterns and Java based software components. Notably, some components may be used directly in an embedded software system, whereas most components must be specialized prior to reuse. Developers have to identify the variation points on these components. In order to develop a reusable embedded software system, we will identify several variation points with some variants, and introduce some useful design patterns for implementing variation points. Consequently, we can customize an embedded software system just through attaching variants on corresponding variation point in our system.

The design patterns we are using are property container, strategy, decorator, and model-view-controller. The component technology we are using is J2ME. J2ME is a specification focused on the development of mobile applications. It provides a similar environment as standard Java environment. J2ME's components programming includes the Spotlet programming for PDA, and the MIDlet programming for Java phone. In addition, along with the XML, J2ME can also provide the XMIDlet programming for dynamic downloading and execution of XML-based applications for PDA and Java phones.

Service-Orientated Computing (SOC) has become a main trend in software engineering that promotes the construction of applications based on the notion of services. SOC has recently attracted the researchers' attention and has been adopted industry-wide. However, service composition that enables one to aggregate existing services into a new composite service is still a highly complex and critical task in service-oriented technology. To enhance availability of composite services, we propose a discovery-based service composition framework to better integrate component services in both static and dynamic manner, including (1) to devise a notion of service availability especially for composition; (2) to develop a dynamic service composition (DSC) pattern for addressing the issues of service availability; and (3) to extend Contract Net Protocol (ECNP) to coordinate service discovery, composition and invocation based on the composite pattern. The main benefit of the proposed approach is better availability through attaching multiple candidate services for future binding.

Design patterns capitalize the knowledge of expert designers and offer reuse that provides for higher design quality and overall faster development. To attain these advantages, a designer must, however, overcome the difficulties in understanding design patterns and determining those appropriate for his/her particular application. On the other hand, one way to benefit from design patterns is to assist inexperienced designers in pattern detection during the design elaboration. Such detection should tolerate variations between the design and the pattern since the exact instantiation of a pattern is infrequent in a design. However, not all variations of a pattern are tolerated. In particular, some structural variations may result in non-optimal instantiations where the requirements are respected but the structure is different; such variations are called spoiled patterns and should also be detected and transformed into acceptable pattern instantiations.

This paper first presents an improvement of our design/spoiled pattern detection approach, named MAPeD (Multi-phase Approach for Pattern Discovery). The latter uses an XML information retrieval technique to identify design/spoiled pattern occurrences in a design using, first, static and semantic information and, secondly, dynamic information. This multi-phase detection approach tolerates structural differences between the examined design and the identified design pattern. Furthermore, thanks to the matching information it collects, our identification technique can offer assistance for the improvement of a design. In its second contribution, this paper evaluates MAPeD by comparing its recall and precision rates for five open source systems: JHotDraw, JUnit, JRefactory, MapperXML, QuickUML. The latter were used by other approaches in experimental evaluations. Our evaluation shows that our design pattern identification approach has an average improvement of 9.98% in terms of precision over the best known approach.

Usability is a software system quality attribute. Although software engineers originally considered usability to be related exclusively to the user interface, it was later found to affect the core functionality of software applications. As of then, proposals for addressing usability at different stages of the software development cycle were researched. The objective of this paper is to present three reusable solutions at detailed design and programming level in order to effectively implement the Abort Operation, Progress Feedback and Preferences usability functionalities in web applications. To do this, an inductive research method was applied. We developed three web applications including the above usability functionalities as case studies. We looked for commonalities across the implementations in order to induce a general solution. The elements common to all three developed applications include: application scenarios, functionalities, responsibilities, classes, methods, attributes and code snippets. The findings were specified as an implementation-oriented design pattern and as programming patterns in three languages. Additional case studies were conducted in order to validate the proposed solution. The independent developers used the patterns to implement different applications for each case study. As a result, we found that solutions specified as patterns can be reused to develop web applications.

Design patterns are generic solutions to common programming problems. Design patterns represent a typical example of design reuse. However, implementing design patterns can lead to several problems, such as programming overhead and traceability. Existing research introduced several approaches to alleviate the implementation issues of design patterns. Nevertheless, existing approaches pose different implementation restrictions and require programmers to be aware of how design patterns should be implemented. Such approaches make the source code more prone to faults and defects. In addition, existing design pattern implementation approaches limit programmers to apply specific scenarios of design patterns (e.g. class-level), while other approaches require scattering implementation code snippets throughout the program. Such restrictions negatively impact understanding, tracing, or reusing design patterns. In this paper, we propose a novel approach to support the implementation of software design patterns as an extensible Java compiler. Our approach allows developers to use concise, easy-to-use language constructs to apply design patterns in their code. In addition, our approach allows the application of design patterns in different scenarios. We illustrate our approach using three commonly used design patterns, namely Singleton, Observer and Decorator. We show, through illustrative examples, how our design pattern constructs can significantly simplify implementing design patterns in a flexible, reusable and traceable manner. Moreover, our design pattern constructs allow class-level and instance-level implementations of design patterns.

While constructing supervised learning models, we require labeled examples to build a corpus and train a machine learning model. However, most studies have built the labeled dataset manually, which, on many occasions, is a daunting task. To mitigate this problem, we have built an online tool called CodeLabeller. CodeLabeller is a web-based tool that aims to provide an efficient approach to handling the process of labeling source code files for supervised learning methods at scale by improving the data collection process throughout. CodeLabeller is tested by constructing a corpus of over a thousand source files obtained from a large collection of open source Java projects and labeling each Java source file with their respective design patterns and summaries. Twenty-five experts in the field of software engineering participated in a usability evaluation of the tool using the standard User Experience Questionnaire online survey. The survey results demonstrate that the tool achieves the Good standard on hedonic and pragmatic quality standards, is easy to use and meets the needs of annotating the corpus for supervised classifiers. Apart from assisting researchers in crowdsourcing a labeled dataset, the tool has practical applicability in software engineering education and assists in building expert ratings for software artefacts.

This paper introduces a strategy for identifying design patterns in quantum circuits. The foundation of this approach relies on using the information procured from both the segmentation and the analysis of these circuits as primary data. The approach of the methodology is based on the novel interpretation of quantum circuit components through the lens of an automaton. Additionally, the method entails the generation of input symbols for this finite automaton. The symbols are derived from the matching process between design patterns and components of quantum circuits. Two tool prototypes, QPainter and QCDPDTool, have been developed to represent quantum circuits graphically and automatically detect quantum patterns. Using them, the primary reasoning process is carried out by an automaton that can manage representations of quantum circuit components. A suite of experiments on a set of quantum circuit sequences reveals promising results and offers empirical support for our approach. Furthermore, we explore how these experimental findings can be leveraged to improve the efficacy of design pattern identification in quantum circuits.

Fostering interaction between end-users and developers is one of the most important issues when developing groupware. Insufficient interaction leads to groupware systems that do not fulfill the group's requirements and thus to low acceptance. Furthermore, as group processes change dynamically the requirements are not static as well. Groupware system development and use, therefore, have to address users' changing needs. Current design methodologies insufficiently focus on this aspect. Therefore, we propose the Oregon Software Development Process (OSDP) that fosters end-user participation throughout the whole groupware life cycle, structures the interaction between end-users and developers, and emphasizes the use of a shared language between users and developers. We illustrate the application of the process with experiences made in an interdisciplinary development project of a collaborative learning platform.

This paper addresses the problem of knowledge creation, integration and dissemination in communities of software designers. The solution identified is represented by design patterns, tools to support social creativity providing a way of capturing and sharing knowledge related to design problems arising in creative collaborative design processes. Inter-related design problems are documented by inter-related design patterns, which form pattern languages. The paper describes design patterns and pattern languages and illustrates the ways in which they support social creativity and knowledge creation, integration and dissemination in communities of software designers.

Due to the large and complex nature of the Internet of Things (IoT), various analysis and design methodologies are proposed. Design pattern is one of them to provide the solution for a design problem, which is recurring in nature. In this approach, we have presented design patterns for the IoT use cases such as service integration and IoT security. But the semi-formal nature of software patterns may lead to bugs in the proposed pattern. Hence, an ontology-based approach is considered for modelling of the IoT design patterns. Further, we have presented an ontology-based framework for the specification and refinement of IoT design patterns. In this approach, an analysis of meta-models and ontologies has also been performed for reducing the gap between high-level design abstraction of Unified Modeling Language (UML)-based IoT patterns and formal ontology.

Software patterns are attempts to describe successful solutions to common software problems [26]. Software patterns reflect common conceptual structures of these solutions, and can be applied over and over again when analyzing, designing, and producing applications in a particular context.

The purpose of this chapter is to gradually introduce the concept of software patterns and describe most frequently used classes of patterns. Key ideas are first presented by describing some practical needs and experiences of software designers. Then a commonly used classification of software patterns is shown, followed by an informal example that illustrates the presence of patterns in different fields of software engineering and knowledge engineering. The introductory part of the chapter closes with a brief history of software patterns.

The central part begins with a discussion of how the information and the knowledge of patterns are organized in practice and how designers should use that information/knowledge. Then the chapter dedicates one entire section to each one of the frequently used classes of patterns. Within any such a section, the objectives and the scope of the corresponding class of patterns are stated, and an example pattern is described in detail. The remainder of the chapter discusses the concept of pattern languages and some important research issues.

The practice of software reengineering has not been fully exploited industrially in significant ways. In this paper, we will report our experience with the architecture based reengineering on a Network Planning System (NPS). Our approach for effective reengineering is focusing on architecture recovery and component reuse. The new architecture is built based on the recovered architecture, which is augmented with new architectural requirements, correcting old design flaws, and incorporating design patterns. The presented approach is evaluated with the reengineering of the NPS where performance, productivity, code quality and extensibility are compared with the conventional approach. The experiments show that our strategies are very successful.

Multi-Agent Systems (MAS) architectures are gaining popularity over traditional ones for building open, distributed, and evolving software required by today's corporate IT applications such as eBusiness systems, Web services or enterprise knowledge bases. Since the fundamental concepts of multi-agent systems are social and intentional rather than object, functional, or implementation-oriented, the design of MAS architectures can be eased by using social patterns. They are detailed agent-oriented design idioms to describe MAS architectures as composed of autonomous agents that interact and coordinate to achieve their intentions, like actors in human organizations. This chapter presents social patterns and focuses on a framework aimed to gain insight into these patterns. The framework can be integrated into agent-oriented software engineering methodologies used to build MAS. We consider the Broker social pattern to illustrate the framework. The mapping from system architectural design (through organizational architectural styles), to system detailed design (through social patterns), is overviewed with a data integration case study. The automation of patterns design is also overviewed.