Adapting Test-Driven Development to Build Robust Web Services

Web services are increasingly being used in business critical environments as a mean to provide a service or integrate distinct software services. Research indicates that, in many cases, services are deployed with robustness issues (i.e., displaying unexpected behaviors when in presence of invalid input conditions). Recently, Test-Driven Development (TDD) emerged as software development technique based on test cases that are defined before development, as a way to validate functionalities. However, programmers typically disregard the verification of limit conditions, such as the ones targeted by robustness testing. Moreover, in TDD, tests are created before developing the functionality, conflicting with the typical robustness testing approach. This chapter discusses the integration of robustness testing in TDD for improving the robustness of web services during development. The authors requested three programmers to create a set of services based on open-source code and to implement different versions of the services specified by TPC-App, using both TDD and the approach presented in this chapter. Results indicate that TDD with robustness testing is an effective way to create more robust services.

User-Centered Business Process Modeling and Pattern-Based Development for Large Systems

In agile software development, it is imperative for stakeholders such as the users and developers of an information system to collaborate in designing and developing the information system, by sharing their knowledge. Especially in development of a large-scale information system, such collaboration among stakeholders is important, but difficult to achieve. This chapter introduces a modeling method of business processes for requirements analysis and a development framework based on Web-process architectures. The modeling method makes it easier for stakeholders to agree upon requirements. It also employs a formal method to allow business process models to satisfy both understandability and accuracy. On the other hand, the development framework above enables rapid spiral development of short-term cycles through the collaboration of developers and users. This chapter also introduces an example that compares the workloads of two requirement analyses of large-scale system developments for a government service and a financial accounting service, in order to evaluate the advantages of the proposed modeling method.

The Incremental Commitment Spiral Model for Service-Intensive Projects

To provide better service to customers and remain competitive in the business environment, a wide variety of ready-to-use software and technologies are available for one to “grab and go” in order to build up software systems at a rapid pace. Currently, a wide variety of Web services are available and ready to use for this purpose. Current software process models also support commercial-off-the-shelf (COTS)-based development processes. However, although COTS and Web Services are similar, they are different in many perspectives. On one hand, there are various software process models that support Web services development. Yet there is no process model that supports the project that uses services provided by others. This chapter introduces the Incremental Commitment Spiral Model (ICSM), a new generation process model that provides development guidelines, from exploring a Web service alternative to deployment and maintenance with case studies.

Addressing Highly Dynamic Changes in Service-Oriented Systems

This chapter sets out to introduce relevant foundations concerning evolution and adaptation of service-oriented systems. It starts by sketching the historical development of software systems from monolithic and mostly static applications to highly-dynamic, service-oriented systems. Then, it provides an overview and more thorough explanation of the various kinds of changes that may need to be faced by service-oriented systems. To understand how such changes could be addressed, the chapter introduces a reference service life-cycle model which distinguishes between evolution, viz. the manual modification of the specification and implementation of the system during design-time, and (self-)adaptation, viz. the autonomous modification of a service-oriented system during operation. Based on the discussion of the key activities prescribed by that life-cycle, the chapter elaborates on the need for agility in both adaptation and evolution of service-oriented systems.

Test Driven Decomposition of Legacy Systems into Services

A number of questions have been raised by both practitioners and researchers regarding the compatibility of service oriented architectures and agile methods. These are compounded when both approaches are combined to maintain and migrate legacy systems. In particular, where test driven development is practiced as a core component of an agile development process, both legacy systems and service oriented architectures can present an incongruous set of development challenges. In this chapter, the authors provide experience reports on how legacy systems have been adapted to an agile, test driven development context by a process of decomposition into testable services. They describe two domains and technology contexts where automated agile testing at multiple interface layers has improved both quality of service and functionality.

Analyses of Evolving Legacy Software into Secure Service-Oriented Software using Scrum and a Visual Model

This chapter explores using service-oriented computing to reengineer non-secure legacy software applications to create new secure target applications. Two objectives of this chapter are: (1) to analyze the architectural changes required in order to adopt new web technologies and cope with resultant vulnerabilities in source code; and (2) to measure the level of effort required to modernize software by adopting new web technologies and adding security countermeasures. To meet these objectives, a model-driven Scrum for Service-Oriented Software Reengineering (mScrum4SOSR) methodology was chosen and applied to a reengineering project. Scrum is employed to manage the reengineering project, as well as to measure implementation effort related to the modernization process. Further, a re-documentation technique called 5W1H Re-Doc is used to re-document the non-secure software application at a high level of abstraction in order to help project participants comprehend what is needed to identify candidate services for service-oriented reengineering. Case studies with and without security features are created for different types of applications - a desktop graphical user interface, a web application, a web services application, a restful web services application, and an enterprise service bus application.

Agile, Lean, and Service-Oriented Development, Continuum, or Chasm

A fad, hype, and a paradigm shift are often the words that are used about the agile, lean, and now also about service-oriented development. What starts as a step in evolution, grows into a mass movement in Internet and social media, and results in an avalanche of books, training, and consultancy services. Each proponent tries to differentiate from others with extreme statements of own superiority and blames of others’ shortcomings. Only a next fad, hype, or paradigm shift seems to be able to override the previous. This chapter looks through the fad, hype, or paradigm shift statements and describes the principles of the agile and lean approaches to the software development. Then it introduces the service orientation that is expected to be the next major shift. If it will overshadow the agile and lean excitement in the software industry, is discussed at the end of the chapter. In addition, this chapter looks into the past in order to find a continuum between these topics till today and to the future. Further some chasms in this continuum are identified, where a new idea has made a major shift and consequently has become a major force in the field. The service orientation in the software development is in the early phase of its lifecycle. The question is: will it still go through some chasm until it settles for large use, or is it already through all of adaptations and ready to be the next wave of evolution, or the next fad, hype and paradigm shift in software industry? The last part of this chapter proposes one more adaptation that creates continuum from the agile and lean approaches but brings up also the revitalization of architecting and design methodologies.

An Agile and Tool-Supported Methodology for Model-Driven System Testing of Service-Centric Systems

In this chapter, the authors present an agile and model-driven system testing methodology for service-centric systems called Telling TestStories. The methodology has a tool implementation and is based on separated system, requirements, and test models that can be validated in an integrated way. Test models contain test stories describing test behavior and test data in an integrated way. The underlying testing process is iterative, incremental, and supports a test-driven design on the model level. After a general overview of the artifacts and the testing process, the authors employ the methodology and the tool implementation on a case study from the healthcare domain.

Agile Development of Security-Critical Enterprise System

The effective provision of security in an agile development requires a new approach: traditional security practices are bound to equally traditional development methods. However, there are concerns that security is difficult to build incrementally, and can prove prohibitively expensive to refactor. This chapter describes how to grow security, organically, within an agile project, by using an incremental security architecture that evolves with the code. The architecture provides an essential bridge between system-wide security properties and implementation mechanisms, a focus for understanding security in the project, and a trigger for security refactoring. The chapter also describes criteria that allow implementers to recognize when refactoring is needed, and a concrete example that contrasts incremental and “top-down” architectures.

Service Science

The discipline of service science encourages the need to develop alternative and more scientific approaches to conceptualise modern service network environments. This chapter identifies the opportunity to apply organisational network analysis (ONA) as a novel approach to model agile service interaction. ONA also supports the visualisation of a service infrastructure which sustains agile practice. The objective of this chapter is to demonstrate how the concept of agile service network (ASN) may be examined through an unconventional method to model service operations. ONA demonstrates the exchange of resources and competencies through an ASN infrastructure. Ultimately, this chapter provides a platform to develop an audit framework with associated metrics borrowed from ONA. ONA concepts offer a new analytical approach towards ASN (for example, structural, composition, behavioural, and functional). This has a significant theoretical contribution for software engineering performance.