Introduction To Software Development

Software development is a complicated process. It requires careful planning

and execution to meet the goals. Sometimes a developer must react quickly and
aggressively to meet ever changing market demands. Maintaining software
quality hinders fast-paced software development, as many testing cycles are
necessary to ensure quality products.

A commercial software product is usually derived from market demands. Sales

and marketing people have first-hand knowledge of their customers’
requirements. Based upon these market requirements, senior software
developers create an architecture for the products along with functional and
design specifications. Then the development process starts. After the initial
development phase, software testing begins, and many times it is done in parallel
with the development process. Documentation is also part of the development
process because a product cannot be brought to market without manuals. Once
development and testing are done, the software is released and the support cycle
begins. This phase may include bug fixes and new releases.
 Introduction To Software
Development
Life Cycle of a Software Development Project
Software development is a complicated process comprising many stages. Each stage requires a
lot of paperwork and documentation in addition to the development and planning process. This
is in contrast to the common thinking of newcomers to the software industry who believe that
software development is just “writing code.” Each software development project has to go
through at least the following stages:
• Requirement gathering
• Writing functional specifications
• Creating architecture and design documents
• Implementation and coding
• Testing and quality assurance
• Software release
• Documentation
• Support and new features

 There may be many additional steps and stages depending upon the nature of the software
product. You may have to go through multiple cycles during the testing phase as software
testers find problems and bugs and developers fix them before a software product is officially
released.
 Introduction To Software
Requirement Gathering
Development
Requirement gathering is usually the first part of any software product. This stage
starts when you are thinking about developing software. In this phase, you meet
customers or prospective customers, analyzing market requirements and features that
are in demand. You also find out if there is a real need in the market for the software
product you are trying to develop.

In this stage, marketing and sales people or people who have direct contact with the
customers do most of the work. These people talk to these customers and try to
understand what they need. A comprehensive understanding of the customers’ needs
and writing down features of the proposed software product are the keys to success in
this phase. This phase is actually a base for the whole development effort. If the base is
not laid correctly, the product will not find a
place in the market. If you develop a very good software product which is not
required in the market, it does not matter how well you build it. You can find many
stories about software products that failed in the market because the customers did
not require them.
Introduction To Software
Development
 Introduction To Software
The marketing people usually create a Marketing Requirement Document or MRD that contains
Development
formal data representation of market data gathered.
Spend some time doing market research and analysis. Consider your competitors’ products (if any), a
process called competitive analysis. List the features required by the product. You should also think
about the economics of software creation at this point. Is there a market? Can I make money? Will the
revenue justify the cost of development?
Writing Functional Specifications
 Functional specifications may consist of one or more documents. Functional specification
documents show the behavior or functionality of a software product on an abstract level. Assuming the
product is a black box, the functional specifications define its input/output behavior.
Functional specifications are based upon the product requirements documentation put forward by
people who have contact with the end user of the product or the customers.
Functional specifications are important because developers use them to create design documents.
The documentation people also use them when they create manuals for end users. If different groups
are working in different physical places, functional specifications and architecture documents
(discussed next) are also a means to communicate among them. Keep in mind that sometimes during
the product development phase you may need to amend functional specifications keeping in view new
marketing requirements.
 Introduction To Software
Development
Creating Architecture and Design Documents
When you have all of the requirements collected and arranged, it is the turn of the
technical architecture team, consisting of highly qualified technical specialists, to create
the architecture of the product. The architecture defines different components of the
product and how they interact with each other. In many cases the architecture also defines
the technologies used to build the product.
While creating the architecture documents of the project, the team also needs to consider
the timelines of the project. This refers to the target date when the product is required to
be on the market. Many excellent products fail because they are either too early or late to
market.
The marketing and sales people usually decide a suitable time frame to bring the product
to market. Based on the timeline, the architecture team may drop some features of the
product if it is not possible to bring the full-featured product to market within the
required time limits.
 Once components of the product have been decided and their functionality defined,
interfaces are designed for these components to work together. In most cases, no
component works in isolation; each one has to coordinate with other components of the
product
 Introduction To Software
Development
Interfaces are the rules and regulations that define how these components will interact with each
other. There may be major problems down the road if these interfaces are not designed properly and in a
detailed way. Different people will work on different components of any large software development
project and if they don’t fully understand how a particular component will communicate with others,
integration becomes a major problem.
For some products, new hardware is also required to make use of technology advancements. The
architects of the product also need to consider this aspect of the product.
 After defining architecture, software components and their interfaces, the next phase of
development is the creation of design documents. At the architecture level, a component is defined as a
black box that provides certain functionality. At the design documents stage, you have to define what is
in that black box.
 Senior software developers usually create design documents and these documents define individual
software components to the level of functions and
procedures. The design document is the last document completed before development of the
software begins. These design documents are passed on to software developers and they start coding.
Architecture documents and MRDs typically need to stay in sync, as sales and marketing
will work from MRDs while engineering works from engineering documents.