Flexible Software Development – Introduction
The focus of the project is to design and implement flexible and maintainable software in order to reduce maintenance time and from reducing maintenance time get the benefit of speeding up software development process.
This project report provides an overview of the project with its problem areas and indication of how to solve the problem areas. It also reviewed the background to the project followed by aim and objectives and methods, which will be used in the research and development of the software techniques.
Architects are trained to take your brief and can see the big picture-they look beyond your immediate requirement to design flexible buildings that will adapt with the changing needs of your business. Architects solve problems creatively-when they are involved at the early planning stages (Bennet et al, 2006). The type of architect that he addressed is.
“A common four layer architects separates the business logic into application logic and domain layers. It is easy to see that it is possible to map the boundary classes onto a presentation layer, the control class onto an application logic layer and the entity classes on a domain layer.” (Bennet et al., 2006, p. 354)
On the other hand, it has been reported by Linthicum (2001) that the three-tier architecture is the most significant architecture among packaged application developers, with good explanation. It offers a clean separation between the user interface, the business logic or domain logic, and the data source.
For the business logic Fowler (2003) suggested one pattern for designing good business logic in the three layer software architecture is the Transaction Script pattern.
“A transaction Script organises all this logic primarily as single procedure, making calls directly to the database or through a thin database wrapper. Each transaction will have its own Transition Script.” (Fowler, 2003, p. 110)
Fowler (2003) also suggested another domain logic pattern a Table Model:
“A Table Module organizes domain logic with one class per table in the database, and a single instance of class contains the various procedures that will act on the data.” (Fowler, 2003, p. 119)
From the above literatures review it appears in software development that the most important point is to measure the software for maintainability and flexibility by placing further changes to the software and record the changes to know how long the modification took. Researchers in software design have various opinion and they each have different methodologies for implementing software. From the previous research it can be noticed that there are many ways to built software. Some methodologies lend themselves to flexibility more than others for example in the list below the issues addressed by the above researchers are:
- Four layers architects is ease of communication from one layer to another. (Bennet et al, 2006)
- Three layers architect is good and has clear separation between the layers. (Linthicum, 2001)
- In business logic of three layer software architecture Domain Model is good for big applications and Transaction Script is good for small applications. (Fowler, 2003)
The above researchers addressed good issues, what really counts is how they perform their intended support of the business, both now and in the future. Assume the business never changes and the software requires a lot of calculation and validation or the business system doesn’t require a lot of calculation and validation in its initial design period, but after the system has delivered and business environment suddenly changes, what will happen to the system?
To solve the problem this project will conduct experiments on the various methods to find out which method is the most flexible for software design and implementation. The experiment will use the design and implementation of a library borrowing system to test the effectiveness of different designs when subjected to adaptive maintenance. From the experiment it will be possible to establish which software architecture is appropriate and how it could be used to improve the design of flexible and maintainable software.
1.3 Project Scope
Library borrowing system will be developed which will run from a single server over the library intranet to several librarian workstations to maintain data for the library. From the implemented system it will be demonstrated how adaptable and maintainable the system is when the changes are made to it.
There would be two modifications to the system; each modification will test and demonstrate the maintainability and flexibility of the software. Basically, initial system will be first developed, refer to (Appendix A), and further modifications to the system will not be released or in other word, the system will each time get completed first then another modification will be carried to measure ease and speed of the system.
There would be similar GUI Layer for the applications build thus GUI Layer would not be considered too much throughout the project.
1.4 Aim and Objective
The aim of the project is to develop flexible and maintainable software which can prove by saving maintenance time when change request arise in the business environment of the software.
The following objectives must be met in order to fulfil the aim of the project:
- Carrying literature review to find different methods for designing and implementing flexible software.
- Two development methods or architectures will be selected which, according to the literature, lead to systems that have different levels of flexibility, maintainability as well performance of the patterns will be considered too.
- According to the proposal requirement, two implementation of the same proposal requirement should be build by applying the selected methods. System should ensure that one method to be easier to maintain than the other.
- For difficulty of applying a series of adaptive maintenance changes to each system, project should ensure to collect enough data that ease the maintenance.
- Software Testing should ensure that system is in the process of success and operates correctly.
Throughout the project for the developing of flexible and maintainable software, the software architecture and design patterns will be used. According to the problem area of the project, experimental research will be used over the design patterns.
According to the type of research that will be conducted on this subject area is measurement and analysis of quantitative data, Oates (2006) suggested in everyday language, we often speak of doing an experiment when we mean we will try something out and find out what happens. For example in this subject area I compare one method with another by measuring how long method A (Table Module) will take to get completed comparing to method B (Transaction Script), etc.
Berndtsson et al (2002) described the research method as:
“Research is normally used to refer to the activity of some diligent and systematic inquiry or investigation in an area, with the objective of discovering or revising facts, theories, applications etc. “ (Berndtsson et al., 2002, p. 10)
The difference between software development methodology (SDM) and research method is that research method is used to find the problem, in this cause (software flexibility), planning the research and then “how” to solve the problem and get the result. When come to the “how” part of the research, an appropriate software development methodology has to be found which can be used throughout the research to solve the problem. Freeman et al. (1982) said that the software development methodology is:
“Software Life Cycle Methodology is a collection of tools, techniques, and methods which provide roles and guidelines for ordering and controlling the actions and decisions of project participants during the software life cycle.” (Freeman et al., 1982, p. 46)
The system will be completed using “Iterative Waterfall Lifecycle” in order to ensure that the project runs through efficiently from one phase of the project lifecycle to the next. The reason for choosing Iterative Waterfall Lifecycle is that this methodology ensures to visit any previous phase of the project if required.
In the design part of the software development lifecycle “Object-Oriented System Analysis and Design using UML” of (Bennet et al, 2006) will be used for the designing of the system.
The Three Principle Layer Architecture will be used to break apart the complexity of software system. In the domain logic of the software architecture, Transaction Script for one application and Table Module for another application will be selected. Comparison of the applications will be performed and from the design and implementation of the system it will be established which application is the most maintainable, flexible and fast performable. For the testing part of the SDM V-Model testing will be used, because the testing will ensure that system operates correctly.
1.6 Programme of Work
The following tasks indicate the total number of chapters in the project and milestones have been set for each task.
Milestone 1: Project Overview: (The project plan get completed and to be sent)
Proposal of the project is the current chapter. It says what this research is about, and why the research is in this subject area. (Read the Background of this chapter to find out the problem area)
Milestone 2: Literature Review: (Detailed problem area in the previous research to be indicated)
This chapter will explore past literature in the subject area. The current research will then bring up further improvement in the previous research in this subject area, which will be covered in the next stage. (Objective 1)
Milestone 3: Methodology: (Appropriate SDM & research method to be found)
This chapter will describe the various methodologies available in order to design, implement and successfully test the system. It will also describe justification of experimental design and what data is needed for the project to be collected. (Objective 2)
Milestone 4: Design: (Get the system ready for implementation and design get completed successfully)
In this chapter the project will show the design of the system using UML diagrams. It will also show the overall system architecture for example how many layers the current software will have. (Objective 3), (Objective 4) AND (Objective 5)
Milestone 5: Implementation: (System to be developed in this section)
This chapter will show the implementation of the current system assessed by the previous chapter (Design). The system will be built in java programming language and database language “MySQL”. (Objective 3), (Objective 4) AND (Objective 5)
Milestone 6: Testing (System to be tested & operate correctly)
Testing of the system will be described, using V-Model. Testing will ensure that the system operates correctly before starting the next chapter. (Objective 5)
Milestone 7: Research Results & Evaluation: (The result of the research to be found and project evaluated)
This chapter will analyze the overall result of the project. Analysis over the subject area will be carried e.g. comparison of patterns for flexibility & performance will be considered too. (Objective 2), (Objective 3) AND (Objective 4)
Milestone 8: Conclusion: (The overall project to be concluded & ready to send)
This chapter of the project will define the difficulties and ease of development tackled throughout the project.
This project planning document is an overview of the project that will be carried out. It represents that in software development the most important point is software flexibility and maintainability. While this is the important issue of the software development lifecycle, therefore the aim is to develop flexible system and to do that the set of objectives were identified and those will be met in the next chapters of the project.
CONTINUE reading -:)