Software Development

The development of a software can be divided basically in four sub fields

Software
Development

Problem Engineering
programming Team work
solving logic practices

Problem Solving Logic

A set of ordered steps for solving a problem, such as a mathematical formula or the instructions
in a program. The terms algorithm and logic are synonymous. Both refer to a sequence of steps
to solve a problem. However, an algorithm implies an expression that solves a complex problem
rather than the overall input-process-output logic of typical business programs.

Pseudo code is the explanation of program logic in simple English phrases. A pseudo code
should not contain keywords or standard notation from any language. The basic idea of writing a
pseudo code is to communicate the details in a simple understandable way. A pseudo code can
act as a common vocabulary between programmers of different language, say Java and Fortran.
Though there is no terse syntax and grammar for writing pseudo code, it should be written in an
understandable way. Though pseudo codes are not mandatory, for writing a software and may
not be required in many standard situations. However, in situation where the logic is intricate and
complex, pseudo code helps in arranging the thought process in a better way. Later on. pseudo
code helps in communicating the logic to the other stakeholders. Pseudo code being written in
simple English, facilitates easy sharing among technical and well as non technical users.
A flowchart is a type of diagram, that represents an algorithm or process, showing the steps as
boxes of various kinds, and their order by connecting these with arrows. This diagrammatic
representation can give a step-by-step solution to a given problem. Data is represented in these
boxes, and arrows connecting them represent flow / direction of flow of data. Flowcharts are
used in analyzing, designing, documenting or managing a process or program in various fields

There are four general types.

 Document flowcharts, showing controls over a document-flow through a system

 Data flowcharts, showing controls over a data flows in a system
 System flowcharts showing controls at a physical or resource level
 Program flowchart, showing the controls in a program within a system

Programming paradigm
A programming paradigm is a fundamental style of computer programming. (Compare with a
methodology, which is a style of solving specific software engineering problems.) Paradigms
differ in the concepts and abstractions used to represent the elements of a program (such as
objects, functions, variables, constraints, etc.) and the steps that compose a computation
(assignment, evaluation, continuations, data flows, etc.).

There could be three approaches to writing a program

Unstructured programming

A program in non-structured language usually consists of sequentially ordered commands, or

statements, usually one in each line. The lines are usually numbered or may have labels: this
allows the flow of execution to jump to any line in the program.

Non-structured programming introduces basic control flow concepts such as loops, branches and
jumps. Although there is no concept of procedures in the non-structured paradigm[citation needed],
subroutines are allowed. Unlike a procedure, a subroutine may have several entry and exit points,
and a direct jump into or out of subroutine is (theoretically) allowed. This flexibility allows
realization of co routines, which is difficult to impossible in true procedural programming.
Structured programming

In the world of computer programming, structured programming is a logical construct that allows
for the efficient operation of a program. With this in mind, many programmers understand
structured programming as being one of the disciplines that make up the overall process of
procedural programming. One of the advantages to the implementation of a structured model of
programming is the ability to either eliminate or at least reduce the necessity of employing the
GOTO statement.

The essential composition of any type of structured programming tends to include three basic
elements. Concatenation is the element that has to do with the logical sequence of the statements
that make up the basics for the order to be executed. Each step in the sequence must logically
progress to the following step without invoking any undesirable activities.

Selection is the second element included in a process of structural programming. Essentially, this
step allows for the selection of any one of a number of statements to execute, based on the
current status of the program. Generally, the selection statements will contain keywords that help
to identify the order as a logical executable, such as “if,” “then,” “endif,” or “switch.”

A third component in structural programming is repetition. Within this element, a selected

statement remains active until the program reaches a point where there is a need for some other
action to take place. A repetition normally will include keywords such as ”repeat,” “for,” or
“do…until.” Essentially, the repetition instructs the program how long to continue the function
before requesting further instructions

Object oriented programming

It is a programming paradigm that uses "objects" – data structures consisting of data fields and
methods together with their interactions – to design applications and computer programs.
Programming techniques may include features such as data abstraction, encapsulation,
modularity, polymorphism, and inheritance. It was not commonly used in mainstream software
application development until the early 1990s. Many modern programming languages now
support OOP.

An object-oriented program may thus be viewed as a collection of interacting objects, as opposed

to the conventional model, in which a program is seen as a list of tasks (subroutines) to perform.
In OOP, each object is capable of receiving messages, processing data, and sending messages to
other objects. Each object can be viewed as an independent 'machine' with a distinct role or
responsibility. The actions (or "methods") on these objects are closely associated with the object.
For example, the data structures tend to 'carry their own operators around with them' (or at least
"inherit" them from a similar object or class). In the conventional model, the data and operations
on the data don't have a tight, formal association.
Inheritance

Inheritance is a process in which a class inherits all the state and behavior of another class. this
type of relationship is called child-Parent or is-a relationship. "Subclasses" are more specialized
versions of a class, which inherit attributes and behaviors from their parent classes, and can
introduce their own.

Multiple inheritance is inheritance from more than one ancestor class, neither of these ancestors
being an ancestor of the other. For example, independent classes could define Dogs and Cats,
and a Chimera object could be created from these two which inherits all the (multiple) behavior
of cats and dogs. This is not always supported, as it can be hard to implement

Encapsulation

Encapsulation conceals the functional details of a class from objects that send messages to it.

For example, the Dog class has a bark() method variable, data. The code for the bark() method
defines exactly how a bark happens (e.g., by inhale() and then exhale(), at a particular pitch and
volume). Timmy, Lassie's friend, however, does not need to know exactly how she barks.
Encapsulation is achieved by specifying which classes may use the members of an object. The
result is that each object exposes to any class a certain interface — those members accessible to
that class. The reason for encapsulation is to prevent clients of an interface from depending on
those parts of the implementation that are likely to change in the future, thereby allowing those
changes to be made more easily, that is, without changes to clients.

Polymorphism

Polymorphism allows the programmer to treat derived class members just like their parent class's
members. More precisely, Polymorphism in object-oriented programming is the ability of objects
belonging to different data types to respond to calls of methods of the same name, each one
according to an appropriate type-specific behavior. One method, or an operator such as +, -, or *,
can be abstractly applied in many different situations. If a Dog is commanded to speak (), this may
elicit a bark(). However, if a Pig is commanded to speak(), this may elicit an oink(). Each subclass
overrides the speak() method inherited from the parent class Animal.
Systems Development Life Cycle

Systems and Development Life Cycle (SDLC) is a process of process used by a systems analyst
to develop an information system, including requirements, validation, training, and user
(stakeholder) ownership. Any SDLC should result in a high quality system that meets or exceeds
customer expectations, reaches completion within time and cost estimates, works effectively and
efficiently in the current and planned Information Technology infrastructure, and is inexpensive
to maintain and cost-effective to enhance.

Software Development Life Cycle

A Systems Development Life Cycle (SDLC) adheres to important phases that are essential for
developers, such as planning, analysis, design, and implementation, and are explained in the
section below. Several Systems Development Life Cycle Models exist, the oldest of which —
originally regarded as "the Systems Development Life Cycle" — is the waterfall model: a
sequence of stages in which the output of each stage becomes the input for the next. These stages
generally follow the same basic steps, but many different waterfall methodologies give the steps
different names and the number of steps seems to vary between four and seven. There is no one
correct Systems Development Life Cycle model.
Requirements Gathering and Problem Definition:

Any project starts with the Initiation phase in which the need for such a solution is identified.
During this phase the software requirements are identified and scope for the project is frozen.
Explicit requirements is important:
Explicit requirements help to avoid arguments. If programmers have a disagreement about what
the program must do, they can always look at the requirements.
If requirements errors are identified during the coding phase, then the change in requirement has
to be considered and make necessary changes in the design as well

Analysis and Design:

After the requirements are collected from the client using a requirements specifications
document, these are analyzed. The requirements after analysis are translated to define the actual
structure of the project during the design phase. The output of the design phase is „program
specifications‟ .Software architecture is the high level part of software design, the frame that
holds the more detailed parts of the design.Architecture is also known as “system architecture”,
”design”, ”high level design”, ”top level design”.Good architecture makes the construction easy,
bad architecture makes construction almost impossible.
Design bugs often occur with early assumptions being forgotten or as new features are added to
the system.

Code Generation

The design must be translated into a machine-readable form. The code generation step performs
this task. If the design is performed in a detailed manner, code generation can be accomplished
without much complication. Programming tools like compilers, interpreters, debuggers etc...
are used to generate the code. Different high level programming languages like C, C++, Pascal,
Java are used for coding. With respect to the type of application, the right programming
language is chosen.

Testing

The code is tested at various levels in software testing. Unit, system and user acceptance testings
are often performed. This is a grey area as many different opinions exist as to what the stages of
testing are and how much if any iteration occurs. Iteration is not generally part of the waterfall
model, but usually some occur at this stage.
Below are the following types of testing:

 Data set testing.

 Unit testing
 System testing
 Integration testing
 Black box testing
 White box testing
 Regression testing
 Automation testing
 User acceptance testing
 Performance testing
 Production

definition:- it is a process that ensures that the program performs the intended task.

Maintenance:

Software undergoes change after it is delivered to the customer, because of errors made during
development, because of changes in the larger system of which the software is a part, or because
the customer requires functional or performance enhancements.
Maintenance essentially consists of reapplying each of the above stages to existing software
rather than new software.