Modeling Services Using ISE Framework

The Internet of services introduces new requirements for service engineering in terms of addressing both business and technical perspectives. The inherent complexity of the new wave of services that is emerging requires new approaches for an effective and efficient service design. In this chapter a novel service engineering framework is introduced: the Integrated Service Engineering (ISE) framework. With its ISE workbench, it can address the emerging requirements of Internet of services. The chapter presents the foundations on how the service engineering process can be conducted by applying the separation of concerns to model different service dimensions within various layers of abstraction. Additionally, three novel extensions are presented to the aforementioned ISE workbench in order to enrich the capabilities of the service modeling process.

Cognitive Complexity Measures

Cognitive informatics (CI), a multidisciplinary area of research tries to solve the common problems in the field of informatics, computer science, software engineering, mathematics, cognitive science, neurobiology, psychology, and physiology. Measurement in software engineering is also a core issue which is still striving for its standardization process. In recent years, several cognitive complexity measures based on CI have been proposed. However, each of them has their own advantages and disadvantages. This chapter presents a critical review on existing cognitive complexity measures. Furthermore, a comparative study based on some selected attributes has been presented.

Analyzing Concurrent Programs Title for Potential Programming Errors

Today, multi-core/multi-processor hardware has become ubiquitous, leading to a fundamental turning point on software development. However, developing concurrent programs is difficult. Concurrency introduces the possibility of errors that do not exist in sequential programs. This chapter introduces the major concurrent programming models including multithreaded programming on shared memory and message passing programming on distributed memory. Then, the state-of-the-art research achievements on detecting concurrency errors such as deadlock, race condition, and atomicity violation are reviewed. Finally, the chapter surveys the widely used tools for testing and debugging concurrent programs.

Model-Driven Development of Multi-Core Embedded Software

Multi-core processors are becoming prevalent rapidly in personal computing and embedded systems. Nevertheless, the programming environment for multi-core processor based systems is still quite immature and lacks efficient tools. This chapter will propose a new framework called VERTAF/Multi-Core (VMC) and show how software code can be automatically generated from high-level SysML models of multi-core embedded systems. It will also illustrate how model-driven design based on SysML can be seamlessly integrated with Intel’s Threading Building Blocks (TBB) and Quantum Platform (QP) middleware. Finally, this chapter will use a digital video recording (DVR) system to illustrate the benefits of the proposed VMC framework.

Software Development Governance

Software development governance can be defined as the application of “governance” in software engineering in order to increase the probability of success in the level of individual projects as well as in the level of the organization comprising many interrelated projects. The topic deserves an interdisciplinary perspective, as the general subject of governance has been analyzed quite extensively under the field of Transaction Cost Economics. This interdisciplinary approach enabled the identification of three main modes of governance for software engineering, namely: top-down governance, bottom-up governance and reuse governance, each having unique transaction cost characteristics. To be cost effective, (1) the organizations should adapt the right governance structure for their projects based on their characteristics, and (2) the software development tools should support and be in alignment with the underlying governance structure. In this chapter, we briefly overview the first premise and then outline an approach to address the second premise, specifically tackling the issue of tools integration, for software modeling and configuration management tools. We use Dependency Structure Matrix (DSM) to represent the mapping between governance structures and software modules, propose a configuration management approach for each mode of software governance, and demonstrate a successful integration using Lattix LDM, IBM Rational ClearCase and IBM Rational Rhapsody, three broadly available tools in the software industry.

Introducing Agility into Plan-Based Assessments

Agile or Plan-driven approaches to software process improvement (such as the Capability Maturity Model Integration (CMMI) and the ISO/IEC 15504 standard) claim to provide companies with improved processes, higher quality software and faster software development. Assessment is an important component of any software process improvement programme, as in order for an organisation to commence an improvement programme, they must first be aware of the current state of their software development practices. Therefore, in the case of small companies such assessments need also to be cost effective and focused only on the most relevant process areas.

Formalization Studies in Functional Size Measurement

Functional size has been favored as a software size attribute that can be measured early in the software development cycles. Its characteristics of being independent of implementation language, technique and technology promoted the use in software cost estimation and other project management practices. It has been about three decades since Albrecht introduced the concept of functional size and a variety of measurement methods have been developed, some of which have been published by International Organization for Standardization (ISO). Although the concept is recognized in the software community, and there is a growing interest in Functional Size Measurement (FSM), the applications in software organizations have not been common as expected. The problems with FSM method structures and practices have been discussed to be the major factors to explain this situation. This chapter reviews the research papers that propose solutions to the problems with FSM via formalizations in FSM practices or related concept definitions. The associations of the formalization ideas to the abstract software models that represent the view of functionality for FSM methods are of particular interest of the chapter.

Visual Semantic Analysis to Support Semi-Automatic Modeling of Semantic Service Descriptions

The service-oriented architecture has become one of the most popular approaches for distributed business applications. A new trend service ecosystem is merging, where service providers can augment their core services by using business service delivery-related available functionalities like distribution and delivery. The semantic service description of services for the business service delivery will become a bottleneck in the service ecosystem. In this chapter, the Visual Semantic Analysis approach is presented to support semi-automatic modeling of semantic service description by combining machine learning and interactive visualization techniques. Furthermore, two application scenarios from the project THESEUS-TEXO (funded by German federal ministry of economics and technology) are presented as evaluation of the Visual Semantic Analysis approach.

OntoArch Reliability-Aware Software Architecture Design and Experience

Reliability-aware software architecture design has recently been gaining growing attention among software architects. This chapter tackles the issue by proposing an ontology-based, reliability-aware software architecture design and evaluation approach, called OntoArch, which incorporates quantitative reliability evaluation in software architecture design by the means of the OntoArch ontology and the OntoArch tool. The OntoArch approach is characterized by: (1) integration of software reliability engineering and software architecture design; (2) proposing a reliability-aware software architecture design process model; (3) developing the OntoArch ontology in the context of software architecture design and software reliability engineering; and (4) the OntoArch tool not only enabling software architects to design architectures and model reliabilities, but also functioning as a knowledge management platform relying on reliability-aware software architecture design. The OntoArch approach is validated for a software architecture design; for example, Personal Information Repository (PIR), with the use cases of OntoArch-based software architecture knowledge management, software reliability profiling, and software architecture modeling and evaluation.

A Software Cost Model to Assess Productivity Impact of a Model-Driven Technique in Developing Domain-Specific Design Tools

Programming languages have evolved through the course of research from machine dependent to high-level “platform-independent” languages. This shift towards abstraction aims to reduce the effort and time required by developers to create software services. It is also a strong indicator of reduced development costs and a direct measure of a positive impact on software productivity. Current trends in software engineering attempt to raise further the abstraction level by introducing modelling languages as the key components of the development process. In particular, modelling languages support the design of software services in the form of domain models. These models become the main development artefacts, which are then transformed using code generators to the required implementation. The major predicament with model-driven techniques is the complexity imposed when manually developing the domain-specific design tools used to define models. Another issue is the difficulty faced in integrating these design tools with model validation tools and code generators. In this chapter a model-driven technique and its supporting model-driven environment are presented, both of which are imperative in automating the development of design tools and achieving tools integration to improve software productivity. A formal parametric model is also proposed that allows evaluating the productivity impact in generating and rapidly integrating design tools. The evaluation is performed on the basis of a prototype domain-specific design tool.