An Agile Architecture for a Legacy Enterprise IT System

2018 ◽  
pp. 155-190
Author(s):  
Chung-Yeung Pang
Keyword(s):  
Architectural Design ◽  
Development Process ◽  
Agile Development ◽  
Centralized Control ◽  
Model Driven ◽  
New Business ◽  
Service Oriented ◽  
Agile Software ◽  
New Applications ◽  
Model Driven Approach

Back in the 1970s, applications mainly comprised programs written in COBOL. Many of these applications are still in operation. To meet new business demands, new applications that have to collaborate with existing programs need to be developed. It is possible to have an agile software architecture that enables easy development, extension and maintenance in COBOL. Such an architecture, and the agile development process, are presented in this article. The architectural design is a combination of the layered, component-based and service-oriented architectural patterns. It also includes features such as the centralized control of the business process, plug-and-play autonomous COBOL modules and context container for storing state data. A model-driven approach is used in the agile development process. Application models include UML class diagrams, state charts and activity diagrams from which various software artefacts and COBOL codes are generated. The architecture and development approaches were first introduced in 2004 and have been successfully applied to 13 applications since then.

An Agile Architecture for a Legacy Enterprise IT System

2016 ◽  
Vol 6 (4) ◽  
pp. 65-97 ◽  
Author(s):  
Chung-Yeung Pang
Keyword(s):  
Architectural Design ◽  
Development Process ◽  
Agile Development ◽  
Centralized Control ◽  
Model Driven ◽  
Architectural Patterns ◽  
New Business ◽  
Service Oriented ◽  
Agile Software ◽  
New Applications

Back in the 1970s, applications mainly comprised programs written in COBOL. Many of these applications are still in operation. To meet new business demands, new applications that have to collaborate with existing programs need to be developed. It is possible to have an agile software architecture that enables easy development, extension and maintenance in COBOL. Such an architecture, and the agile development process, are presented in this article. The architectural design is a combination of the layered, component-based and service-oriented architectural patterns. It also includes features such as the centralized control of the business process, plug-and-play autonomous COBOL modules and context container for storing state data. A model-driven approach is used in the agile development process. Application models include UML class diagrams, state charts and activity diagrams from which various software artefacts and COBOL codes are generated. The architecture and development approaches were first introduced in 2004 and have been successfully applied to 13 applications since then.

Reuse in Agile Development Process

2022 ◽  
pp. 1511-1534
Author(s):  
Chung-Yeung Pang
Keyword(s):  
Software Development ◽  
Development Process ◽  
Agile Development ◽  
Reusable Software ◽  
Model Driven ◽  
Development Processes ◽  
Agile Approach ◽  
Similar Solutions ◽  
Agile Software ◽  
Model Driven Approach

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

Reuse in Agile Development Process

2020 ◽  
pp. 164-187
Author(s):  
Chung-Yeung Pang
Keyword(s):  
Software Development ◽  
Development Process ◽  
Agile Development ◽  
Reusable Software ◽  
Model Driven ◽  
Development Processes ◽  
Agile Approach ◽  
Similar Solutions ◽  
Agile Software ◽  
Model Driven Approach

Reusability is a clear principle in software development. However, systematic reuse of software elements is not common in most organizations. Application programmers rarely design and create software elements for possible future reuse. In many agile software development processes, the project teams believe that the development of reusable software elements can slow down the project. This can be a misconception. This chapter examines various ways to reuse software. Three approaches to developing reusable software artifacts from 15 years of experience in the agile development process are presented. The first approach is to create generic programs or configurable frameworks that support similar solutions for a variety of use cases and environments. The reuse of patterns is the second approach presented. Another effective way is to use a model-driven approach with model patterns. These approaches help to speed deployment software. The final product is flexible and can easily be adapted to changes. This is one of the main goals of an agile approach.

Agile Development Methods and Component-Orientation

2011 ◽  
pp. 1-22
Author(s):  
Zoran Stojanovic ◽  
Ajantha Dahanayake ◽  
Henk Sol
Keyword(s):  
Software Development ◽  
Architectural Design ◽  
Development Process ◽  
System Modeling ◽  
Theory And Practice ◽  
Agile Methods ◽  
Agile Development ◽  
Model Driven ◽  
Agile Software ◽  
Development Methods

Agile software development methods have been proposed as the way to address the problem of delivering high-quality software on time under constantly and rapidly changing requirements in business and IT environments. An agile development process is characterized by extensive coding practice, intensive communication between stakeholders, fast iterative cycles, small and flexible teams, and minimal efforts in system modeling and architectural design. This paper presents the state-of-the-art of agile methods and analyzes them along the selected criteria that highlight different aspects of their theory and practice. Certain limitations of agile methods are identified. The chapter presents the component paradigm as a way of balancing traditional (model-driven or plan-driven) and agile development, depending on the project settings. Service-based component concepts applied at the level of modeling, architectural design and development can ensure and strengthen agile development principles and practices, and at the same time introduce necessary agility to more traditional development. By using components, the software development process can easily scale in size, robustness, and the level of details. This provides an effective balance between the requirements for agility in software development and needs for a disciplined, design-driven way of building complex software.

An Evolutive Component-Based Method for Agile Development of Service Oriented Architectures

2017 ◽  
Vol 9 (3) ◽  
pp. 37-57 ◽  
Author(s):  
Hamza Chehili ◽  
Lionel Seinturier ◽  
Mahmoud Boufaida
Keyword(s):  
Development Process ◽  
Business Processes ◽  
Agile Development ◽  
Service Oriented Architectures ◽  
Development Method ◽  
Service Oriented ◽  
Agile Software Engineering ◽  
Agile Software ◽  
Incremental Process

The adoption of the agile methods' principles has emerged as an effective way to develop service oriented architectures as it paves the way for a better reply to the changing needs of the environment and even the customer. However, these changes may also require the evolution of the development process itself. This paper presents an agile and service-oriented software development method that combines concepts from the Service-Oriented Computing (SOC) domain and the agile software engineering one. This method provides an iterative and incremental process to deliverer business processes, implemented as an assembly of components. This leads to a faster response to the change of needs by reconfiguring the assembly of components. The method is based on a framework that implements its phases as an assembly of components to allow a dynamic reconfiguration of it in case of a development process evolution. Finally, a case study is presented to illustrate the use of the presented method.

Service-Oriented Development of Fault Tolerant Communicating Systems

2010 ◽  
Vol 1 (2) ◽  
pp. 61-85 ◽  
Author(s):  
Linas Laibinis ◽  
Elena Troubitsyna ◽  
Sari Leppänen
Keyword(s):  
Formal Methods ◽  
Formal Specification ◽  
Development Process ◽  
Formal Model ◽  
Fault Tolerant ◽  
Model Driven ◽  
Telecommunication Systems ◽  
Service Oriented ◽  
Model Driven Approach ◽  
High Degree

Telecommunication systems must have a high degree of availability, that is, a high probability of correct and timely provision of requested services. To achieve this, correctness of software for such systems should be ensured. Application of formal methods helps increase confidence in building correct software. However, to be used in practice, formal methods should be well integrated into existing development process. In this paper, the authors propose a formal model-driven approach to development of communicating systems. The authors formalize and extend the Lyra approach—a top-down service-oriented method for development of communicating systems. Lyra is based on transformation and decomposition of models expressed in UML2. The authors formalize Lyra in the B Method by proposing a set of formal specification and refinement patterns reflecting the essential models and transformations of the Lyra phases. Moreover, this paper extends Lyra to integrate reasoning about fault tolerance in the entire development flow.

Modeling Process-Driven SOAs

2011 ◽  
pp. 27-48
Author(s):  
Huy Tran ◽  
Ta’id Holmes ◽  
Uwe Zdun ◽  
Schahram Dustdar
Keyword(s):  
Business Process ◽  
Process Development ◽  
Control Flow ◽  
Levels Of Abstraction ◽  
Service Oriented Architectures ◽  
Model Driven ◽  
Service Oriented ◽  
The One ◽  
Abstraction Levels ◽  
Model Driven Approach

This chapter introduces a view-based, model-driven approach for process-driven, service-oriented architectures. A typical business process consists of numerous tangled concerns, such as the process control flow, service invocations, fault handling, transactions, and so on. Our view-based approach separates these concerns into a number of tailored perspectives at different abstraction levels. On the one hand, the separation of process concerns helps reducing the complexity of process development by breaking a business process into appropriate architectural views. On the other hand, the separation of levels of abstraction offers appropriately adapted views to stakeholders, and therefore, helps quickly re-act to changes at the business level and at the technical level as well. Our approach is realized as a model-driven tool-chain for business process development.

Design and Deployment of Service Oriented Applications with Non-Functional Requirements

2011 ◽  
pp. 315-339
Author(s):  
László Gönczy ◽  
Dániel Varró
Keyword(s):  
Architectural Design ◽  
Model Transformations ◽  
Functional Requirements ◽  
Application Development ◽  
Tool Chain ◽  
Model Driven ◽  
Enterprise Application ◽  
Functional Aspects ◽  
Early Validation ◽  
Service Oriented

As the use of SOA became a mainstream in enterprise application development, there is a growing need for designing non-functional aspects of service integration at the architectural level, instead of creating only technology specific assets (configuration descriptors). This architectural design supports flexibility and early validation of requirements. This chapter presents a model-driven method supporting the automated deployment of service configurations. This deployment technique is supported by an extensible tool chain where (i) service models are captured by a service-oriented extension of UML enabling to capture non-functional requirements, and (ii) configuration descriptors for the target deployment platform are derived by automated model transformations within the VIATRA2 framework.

An Effective Approach for Context Driven Testing in Practice — A Case Study

2020 ◽  
Vol 30 (09) ◽  
pp. 1245-1262
Author(s):  
Quyet-Thang Huynh ◽  
Le-Trinh Pham ◽  
Nhu-Hang Ha ◽  
Duc-Man Nguyen
Keyword(s):  
Software Development ◽  
Development Process ◽  
Continuous Process ◽  
Minimum Cost ◽  
Agile Development ◽  
Software Products ◽  
Engineering Company ◽  
Quality Product ◽  
Software Engineers ◽  
Agile Software

Software testing is a continuous process during the software development stages to ensure quality software products. Researchers, experts and software engineers keep going on studying new techniques, methods and approaches of testing to accommodate changes in software development because of the flexible requirement along with the changing of technology. So, developers and testers need to have effective methods, tools and approaches to create a high-quality product at an efficient cost. This paper provides an effective approach for context-driven testing (CDT) in an agile software development process. CDT is a testing approach that supports the tester to choose their testing techniques and test objectives based on specific contexts. The aim of this paper is to propose an effective approach for implementing the CDT in practice, called CDTiP. Through an analysis of two case studies using an agile development process with different contexts, we validate the effectiveness of the approach in terms of test coverage, detect errors, test effort. The empirical results show that CDTiP is suitable for the agile development process that can help the tester to detect defects faster at minimum cost. The results of this method have been applied at Enclave, an ODC Software Engineering company, on real projects.

Sign in / Sign up

Export Citation Format

Share Document