CORE PRINCIPLES

Software engineering is guided by a collection

of core principles that help in the application of
a meaningful software process and the
execution of effective software engineering
methods. At the process level, core principles
establish a philosophical foundation that guides
a software team as it performs framework and
umbrella activities and produces a set of
software engineering work products
 CORE PRINCIPLES
At the level of practice, core principles
establish a collection of values and rules that
serve as a guide as you analyze a problem,
design a solution, implement and test the
solution.
Principles That Guide Process
The following set of core principles can be
applied to the framework, and by extension, to
every software process.
1. Be agile. Whether the process model you
choose is prescriptive or agile. Every aspect of
the work you do should emphasize economy of
action—keep your technical approach as simple
as possible.
 
 Principles That Guide Process
2. Focus on quality The exit condition
for every process activity, action, and task
should focus on the quality of the work product
that has been produced.
3. Be ready to adapt. Process is not a
religious experience. When necessary, adapt
your approach to constraints imposed by the
problem, the people, and the project itself.
 Principles That Guide Process
4. Build an effective team. Software
engineering process and practice are important,
but the bottom line is people. Build a self-
organizing team that has mutual trust and respect.
5. Establish mechanisms for communication
and coordination. Projects fail because important
information falls into the cracks and/or
stakeholders fail to coordinate their efforts to
create a successful project. These are
management issues and they must be addressed.
 Principles That Guide Process
6. Manage change. The approach may
be either formal or informal, but mechanisms
must be established to manage the way of
changes.

7. Assess risk. Lots of things can go

wrong as software is being developed. It’s
essential that you establish contingency plans.
 Principles That Guide Process
8. Create work products that
provide value for others.
Create only those work products that provide
value for other process activities, actions, or
tasks. A list of required functions and features
will be passed along to the person (people) who
will develop a design, the design will be passed
along to those who generate code, and so on.
 Planning Principles
The planning activity encompasses a set of
management and technical practices that
enable the software team to define a road map
as it travels toward its strategic goal and
objectives.
The following principles always apply:
1. Understand the scope of the
project. It’s impossible to use a road map if
you don’t know where you’re going. Scope
provides the software team with a destination.
 Planning Principles
2. Involve stakeholders in the
planning activity. Stakeholders define
priorities and establish project constraints. To
accommodate these realities, software
engineers must often negotiate order of delivery,
time lines, and other project-related issues.
3. Recognize that planning is
iterative. A project plan is never engraved in
stone. As work begins, it is very likely that things
will change.
 Planning Principles
As a consequence, the plan must be adjusted to
accommodate these changes. In addition,
incremental process models dictate preplanning
after the delivery of each software increment
based on feedback received from users.
4. Estimate based on what you
know. The intent of estimation is to provide
an indication of effort, cost, and task duration,
based on the team’s
 Planning Principles
current understanding of the work to be done. If
information is unreliable, estimates will be
equally unreliable.
5. Consider risk as you define the plan.
If you have identified risks that have high impact
and high probability planning is necessary. In
addition, the project plan (including the
schedule) should be adjusted to accommodate.
 Planning Principles
6. Be realistic. People don’t work 100 percent
of every day. Omissions and ambiguity are facts
of life. Even the best software engineers make
mistakes. The other realities should be
considered as a project plan is established.
7. Adjust granularity as you define the plan.
Granularity refers to the level of detail that is
introduced as a project plan is developed.
 Planning Principles
8. Define how you intend to ensure quality.
The plan should identify how the software team
intends to ensure quality.. If pair programming is
to be used during construction, it should be
explicitly defined within the plan.
9. Describe how you intend to accommodate
change. You should identify how changes are
to be accommodated as software engineering
work proceeds.
 Planning Principles
10. Track the plan frequently and make
adjustments as required.
Software projects fall behind schedule one day
at a time. Therefore, it makes sense to track
progress on a daily basis
 Coding Principles.
Understand of the problem you’re trying to
solve.
Understand basic design principles and
concepts.
Pick a programming language that meets the
needs of the software to be
Select a programming environment that
provides tools that will make your work easier.
Create a set of unit tests that will be applied
once the component you code is completed.
 Programming principles:
Constrain your algorithms by following
structured programming practice.
Consider the use of pair programming.
Select data structures that will meet the needs
of the design.
Understand the software architecture and
create interfaces that are consistent with it.
Keep conditional logic as simple as possible.
Create nested loops in a way that makes them
easily testable.
 Programming principles:
Select meaningful variable names and follow
other local coding standards
Write code that is self-documenting.
 Testing Principles.
1. All tests should be traceable to
customer requirements.
The objective of software testing is to uncover
errors. It follows that the most severe defects
(from the customer’s point of view) are those
that cause the program to fail to meet its
requirements.
 Testing Principles.
2. Tests should be planned long before
testing begins. Test planning can begin as
soon as the requirements model is complete.
Therefore, all tests can be planned and
designed before any code has been generated.
3. The principle applies to software
testing. In this context the principle implies
that 80 percent of all errors uncovered during
testing will likely be traceable to 20 percent of all
program components.
 Testing Principles.
4. Testing should begin “in the small”
and progress toward testing “in the
large.”
The first tests planned and executed generally
focus on individual components. As testing
progresses, focus shifts in an attempt to find
errors in integrated clusters of components and
ultimately in the entire system.