Agile Development

Module 3

Pavan M,IS& E

JNNCE,Shimoga

December 13, 2024

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 1 / 94

Outline
1 Agile Development
2 Agility in Software Engineering
3 Agility and Cost of Change
4 What is an Agile Process?
Agility Principles
The Politics of Agile Development
Human Factors
5 Extreme Programming (XP)
Overview of XP
XP Values
The XP Process
The IXP Process
Debate on XP Practices

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 2 / 94

Outline

6 Other Agile Process Models

Adaptive Software Development (ASD)
Scrum
Dynamic Systems Development Method (DSDM)
Crystal
Feature Driven Development (FDD)
Lean Software Development (LSD)
Agile Modeling (AM)
Agile Unified Process (AUP)

7 A Tool Set for the Agile Process

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 3 / 94

Agile Development I

* In 2001, Kent Beck and 16 others (known as the “Agile Alliance”) cre-
ated the Manifesto for Agile Software Development, emphasizing:

- Individuals and interactions over processes and tools

- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
* Agile development seeks to replace traditional software engineering’s
perceived weaknesses and promotes adaptive change management.
Benefits and Challenges of Agile Development
* Agile methods benefit from responsiveness to fluid business needs,
where traditional requirements are hard to define from the start.
* Allows better adaptation to evolving market conditions and end-user
needs.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 4 / 94

Agile Development II
* Reduces costs associated with change by promoting flexibility through-
out the software process.
Agile vs. Traditional Software Engineering
* Agile methods complement, rather than replace, valuable software en-
gineering principles.
* Adapts to challenges without discarding fundamental engineering con-
cepts, evolving software practices.
Human-Centered Approach in Agile
* Alistair Cockburn critiques rigid process models, emphasizing human
variability in skill, creativity, and communication.
* Argues for balancing discipline with tolerance in process models:
- Discipline: Necessary for consistency but can be difficult to maintain.
- Tolerance: Allows easier adoption but may impact productivity.
* Agile practices support flexibility by recognizing software engineers as
diverse individuals, needing adaptable frameworks.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 5 / 94
What is Agility? I

* Agility is essential in modern software processes, allowing teams to

respond effectively to changes.
* Ivar Jacobson defines agility as a “nimble” approach where teams han-
dle changes in:
- Software requirements and functionality
- Team composition and resources
- New technology and environmental factors
* Agility treats change as inherent to software development, making
adaptability the core focus of an agile team.
Agility as a Broader Philosophy
* Agility is not only about responding to change but also about:
- Facilitating communication between all project stakeholders, including
team members, managers, and customers.
- Prioritizing rapid delivery of functional software over intermediate doc-
uments or non-essential work products.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 6 / 94

What is Agility? II
- Including customers as active participants in the development process,
eliminating an “us vs. them” approach.
- Maintaining flexibility in planning to account for uncertainties in require-
ments and technology.
Implementing Agility in Software Processes
* Agility can be integrated into any software process by designing pro-
cesses that allow the team to:
- Adapt and streamline tasks to minimize unnecessary activities.
- Plan with fluidity, understanding the dynamic nature of agile develop-
ment.
- Eliminate non-essential work products, keeping documentation and
deliverables lean.
- Adopt an incremental delivery strategy to release functional software
to customers as soon as possible.
* The goal is to enable teams to adapt to changes effectively while main-
taining productivity and meeting customer needs.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 7 / 94

Agility and Cost of Change I

Conventional Cost of Change in Software Development:

▶ Change costs tend to increase non-linearly as a project progresses.
▶ Early-stage changes (e.g., during requirements gathering) have minimal
impact:
⋆ Modifying a usage scenario or extending a function list can be done with
low time and cost.
▶ Later-stage changes (e.g., during validation testing) are costly:
⋆ Major changes can require architectural modifications, new components,
and re-testing.
⋆ This significantly impacts cost, time, and quality assurance.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 8 / 94

Agility and Cost of Change II

Agility’s Approach to Flattening the Cost Curve:

▶ Agile methods aim to ”flatten” the cost of change curve, reducing the
cost and time impact of late-stage changes.
▶ Practices that support this include:

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 9 / 94

Agility and Cost of Change III

⋆ Incremental delivery: Facilitates manageable, staged progress with early

feedback.
⋆ Continuous unit testing: Identifies potential issues early, reducing de-
bugging and change costs.
⋆ Pair programming: Enhances quality and understanding, minimizing
rework for late-stage modifications.
Evidence for Cost Reduction:
▶ Studies suggest a well-designed agile process can significantly reduce the
cost of changes.
▶ Although debates continue, agile proponents argue for its effectiveness
in managing project adaptation.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 10 / 94

What is an Agile Process? I
Key Assumptions of Agile Software Processes:
▶ Predicting software requirements and customer priorities in advance is
challenging and subject to change.
▶ Design and construction activities often need to be interleaved:
⋆ Design models are refined as construction progresses.
⋆ Pre-defining the necessary extent of design before construction is chal-
lenging.
▶ The stages of analysis, design, construction, and testing are inherently
unpredictable and difficult to plan precisely.
Creating a Process to Manage Unpredictability:
▶ Agile processes are designed to be adaptable to changing project and
technical conditions.
▶ However, adaptation must occur incrementally to ensure progress is con-
tinuous:
⋆ Customer feedback is essential to guide the necessary adaptations.
Adopting an Incremental Development Strategy:
▶ Use of incremental development allows for regular delivery of functional
prototypes or portions of the software:
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 11 / 94
What is an Agile Process? II

⋆ Short development cycles support rapid adaptation to changes.

⋆ Iterative delivery enables customer feedback at each increment.
⋆ Feedback-driven changes allow the agile team to adjust the process as
needed.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 12 / 94

Agility Principles I
Agile Alliance’s 12 Principles of Agility:
1 Prioritize customer satisfaction through early and continuous delivery of
valuable software.
2 Embrace changing requirements, even in late stages of development, for
the customer’s competitive advantage.
3 Deliver functional software frequently, preferring shorter timeframes (weeks
to months).
4 Ensure daily collaboration between business stakeholders and developers
throughout the project.
5 Center projects around motivated individuals; provide them with the
necessary support and trust.
6 Promote face-to-face conversations as the most efficient way to convey
information within development teams.
7 Define working software as the primary measure of progress.
8 Sustain a constant pace indefinitely, with sponsors, developers, and users
engaged at a manageable pace.
9 Emphasize technical excellence and good design to enhance agility.
10 Simplify—maximize the amount of work not done to focus on essentials.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 13 / 94

Agility Principles II

11 Allow the best architectures, requirements, and designs to emerge from

self-organizing teams.
12 Regularly reflect on team effectiveness and adjust behaviors to improve
continuously.
Agility in Practice:
▶ Agile process models may not apply each principle equally; some princi-
ples may be downplayed depending on the model.
▶ However, these principles form the core agile spirit, underpinning the
agile methods discussed in this framework.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 14 / 94

The Politics of Agile Development I
Debate Around Agile vs. Traditional Software Engineering:
▶ Agile proponents (“agilists”) may view traditionalists as overly focused
on documentation over functionality.
▶ Traditionalists may view agilists as prioritizing speed over structure, po-
tentially compromising scalability for larger projects.
Key Questions in Agile Development:
▶ What methods best achieve agility in a project?
▶ How can software meet current customer needs while maintaining quality,
scalability, and adaptability for future needs?
Diverse Agile Models:
▶ Various agile process models offer different approaches to implementing
agility, each with unique elements.
▶ Agile practices often represent modified versions of established software
engineering concepts, blending agility with best practices.
Balanced Approach:
▶ Combining strengths from both agile and traditional methods can en-
hance project outcomes.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 15 / 94
The Politics of Agile Development II

▶ Avoiding rigid adherence to either camp may allow teams to adopt the
most effective practices from each.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 16 / 94

Human Factors I
People-Centric Approach:
▶ Agile development prioritizes individual skills and talents, tailoring pro-
cesses to fit the team’s specific needs.
Essential Traits of Agile Teams:
▶ Competence:
⋆ Members should have talent, relevant skills, and process knowledge.
⋆ Training in skill and process knowledge is essential for all team members.
▶ Common Focus:
⋆ All members focus on delivering functional software increments to cus-
tomers as promised.
⋆ The team should adapt the process continually to meet its needs.
▶ Collaboration:
⋆ Effective teamwork requires constant communication and collaboration
among members and with stakeholders.
⋆ Collaboration enables the team to provide software solutions that add
business value.
▶ Decision-Making Ability:
⋆ Agile teams need autonomy for technical and project-related decisions.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 17 / 94
Human Factors II

▶ Fuzzy Problem-Solving Ability:

⋆ Agile teams need to be flexible with problem-solving, adapting to new
and evolving challenges.
⋆ Lessons learned, even from solving the wrong problem, can benefit the
team in future tasks.
▶ Mutual Trust and Respect:
⋆ A “jelled” team, where members respect and trust each other, increases
cohesion and effectiveness.
▶ Self-Organization:
⋆ Agile teams self-organize their workflow, processes, and schedules to
deliver the software increment.
⋆ This autonomy enhances collaboration and team morale, as members
manage their commitments.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 18 / 94

Extreme Programming (XP) I
Overview of XP:
* Extreme Programming (XP) is a widely-used agile software devel-
opment approach.
* Initially developed in the late 1980s, with significant contributions by
Kent Beck.
* Industrial XP (IXP) is a variant of XP, specifically refined for large
organizations, enhancing XP’s scalability.
XP Values: XP is guided by five core values that shape its activities,
actions, and tasks.
* Communication:
- Promotes close, informal, and verbal collaboration between develop-
ers and stakeholders.
- Avoids excessive documentation, emphasizing verbal exchanges to clar-
ify requirements.
- Utilizes effective metaphors and continuous feedback to ensure clear
concept sharing.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 19 / 94
Extreme Programming (XP) II
* Simplicity:
- Focuses on designing only for immediate needs, postponing complex
future requirements.
- Aims to create simple designs that are easy to implement and refine
(refactoring) if needed.
* Feedback:
- Feedback is obtained from three main sources:
• The software, through regular testing.
• The customer, who reviews each software increment.
• Team members, who share insights on process and code improvements.
- Unit tests check each component as it’s developed to ensure quality.
- Acceptance tests, based on user stories or use cases, validate each
increment against customer expectations.
* Courage:
- Requires discipline to avoid planning for uncertain future needs.
- Encourages designing for current requirements only, reducing wasted
efforts.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 20 / 94

Extreme Programming (XP) III

* Respect:
- Built as team members work collaboratively and deliver software suc-
cessfully.
- Respect grows among team members and stakeholders as they see
the process’s value.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 21 / 94

Extreme Programming (XP) I
* Extreme Programming (XP) is an agile, object-oriented approach
for software development.
* It includes four core framework activities: planning, design, coding,
and testing.
* Each activity has specific rules and practices for guiding development.
Planning:
* Known as the planning game, begins with listening to gather initial
requirements.
* Requirements are documented as stories (user stories) on index cards
by the customer.
* Each story receives a priority value and development cost based on
importance and estimated time.
- Stories requiring more than three weeks are split into smaller parts.
* Stories are grouped into the next release (software increment) with
prioritization based on:
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 22 / 94
Extreme Programming (XP) II

- Immediate implementation,
- High-value first, or
- High-risk stories first.
* After the first release, project velocity is calculated to:
- Estimate future delivery dates,
- Adjust for overcommitments if necessary.
* Customers can update stories, prompting replanning as needed.
Design:
* Follows the Keep It Simple (KIS) principle, focusing only on imme-
diate requirements.
* Uses CRC (Class-Responsibility-Collaborator) cards to organize object
oriented classes:
- CRC cards are the main design tool in XP.
- Simplifies organization and communication of design concepts.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 23 / 94

Extreme Programming (XP) III

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 24 / 94

Extreme Programming (XP) I
Handling Complex Design Problems:
* For challenging design issues, XP suggests creating a temporary pro-
totype, called a spike solution.
* The spike solution is a quick prototype to:
- Test ideas,
- Reduce risks for future implementation, and
- Validate initial time estimates for complex stories.
Refactoring:
* Refactoring improves the internal structure of code without altering
its behavior.
* It involves making small, incremental design improvements throughout
development.
* XP sees refactoring as an ongoing process to keep the design optimized
and the code clean.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 25 / 94

Extreme Programming (XP) II
* While beneficial, refactoring efforts can increase as the application
grows in size.
Coding:
* Before coding, the team creates a series of unit tests for each story.
* Unit tests help clarify requirements, focusing the developer on what is
needed to pass the test.
* A pair programming approach is used, where two developers work
together at one computer.
- One person focuses on coding details, while the other checks coding
standards and test requirements.
- Real-time problem-solving and quality checks are achieved through con-
tinuous peer review.
* After coding, continuous integration combines code from different
pairs regularly to detect issues early.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 26 / 94

Extreme Programming (XP) III
Testing:
* Unit tests created before coding are set up in a framework allowing
automated testing.
* Automated testing promotes regression testing each time the code is
modified.
* XP’s focus on automated, frequent testing ensures code reliability and
early error detection.
Universal Testing Suite:
* All unit tests are compiled into a universal testing suite.
* This suite allows for daily integration and validation testing of the
system.
* Frequent testing gives continuous updates on progress and flags poten-
tial issues early.
* Fixing smaller issues regularly is faster and less disruptive than address-
ing major issues close to deadlines.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 27 / 94
Extreme Programming (XP) IV

Acceptance Tests (Customer Tests):

* Acceptance tests are also called customer tests.
* These tests focus on system features and functionalities visible to
the customer.
* Acceptance tests are based on user stories implemented in each soft-
ware release.
* These tests ensure that the system meets customer expectations and
validates the end-user experience.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 28 / 94

Industrial Extreme Programming (IXP) I
Overview:
* Industrial XP (IXP) is an extension of XP, designed for larger organi-
zations and more significant projects.
* IXP retains XP’s minimalist, customer-centric, and test-driven princi-
ples.
* IXP differs from XP with a greater focus on management inclusion,
an expanded role for customers, and upgraded technical practices.
New Practices in IXP:
Readiness Assessment:
▶ Determines if the organization is prepared for IXP.
▶ Assesses if a suitable environment, necessary stakeholders, a quality
program, and supportive culture are in place.
Project Community:
▶ XP’s team concept expands to a broader community with
technologists, customers, and additional stakeholders (e.g., legal,
quality auditors).
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 29 / 94
Industrial Extreme Programming (IXP) II
▶ Community roles are defined, and communication and coordination
mechanisms are established.
Project Chartering:
▶ Evaluates business justification and alignment with organizational goals.
▶ Examines project context to see if it complements or replaces existing
systems.
Test-Driven Management:
▶ Sets measurable goals (destinations) to assess project progress.
▶ Implements mechanisms to verify if these goals are met.
Retrospectives:
▶ Conducts post-increment reviews to examine issues, events, and lessons
learned.
▶ Aims to enhance the IXP process through reflection and improvement.
Continuous Learning:
▶ Encourages the team to adopt new techniques and methods.
▶ Aids in continuous improvement and delivery of higher-quality products.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 30 / 94

Industrial Extreme Programming (IXP) III

Modifications to XP Practices:
Story-Driven Development (SDD):
▶ Stories for acceptance tests are written before any coding begins.
Domain-Driven Design (DDD):
▶ Builds a domain model that aligns with how experts view their subject.
Pairing:
▶ Extends pair programming to include managers and stakeholders.
▶ Promotes knowledge sharing across team members.
Iterative Usability:
▶ Favors usability design that evolves with each increment.
▶ Prioritizes user feedback over initial, rigid interface designs.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 31 / 94

The XP Debate I
Overview:
* XP has sparked discussions and debate on its effectiveness.
* Stephens and Rosenberg [Ste03] acknowledge some beneficial practices
but argue that some XP practices may be overhyped or problematic.
* The codependency of XP practices is seen as both a strength and a
weakness.
* Critics and proponents offer differing views on various XP aspects as
the methodology matures.
Key Issues in XP:
Requirements Volatility:
▶ Customer involvement leads to informal requirement changes,
potentially altering project scope and requiring modifications to earlier
work.
▶ Proponents argue that XP provides mechanisms to control scope
creep despite changes.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 32 / 94

The XP Debate II
Conflicting Customer Needs:
▶ In projects with multiple customers, each may have different needs.
▶ Critics worry that the team may lack the authority to reconcile these
needs effectively.
Informal Requirements Expression:
▶ Requirements in XP are expressed through user stories and
acceptance tests.
▶ Critics believe a formal specification or model is necessary to avoid
omissions, inconsistencies, and errors.
▶ Proponents argue that formal models become obsolete as requirements
evolve.
Lack of Formal Design:
▶ XP minimizes the need for extensive architectural design, favoring
informal design methods.
▶ Critics argue that formal design is essential for complex systems to
ensure quality and maintainability.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 33 / 94

The XP Debate III

▶ XP proponents emphasize that simplicity and incremental development

reduce complexity, diminishing the need for extensive design.
Conclusion:
Every software process has strengths and flaws.
Organizations should recognize potential weaknesses in XP and adapt
it to meet specific needs.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 34 / 94

Other Agile Process Models I
Introduction:
* The history of software engineering includes numerous methodologies
and tools that were widely used but later replaced.
* The agile movement has introduced various process models, many of
which have gained popularity in the software development community.
Most Common Agile Process Models:
* Extreme Programming (XP) - One of the most widely adopted agile
models, known for its customer-centric and test-driven approach.
* Adaptive Software Development (ASD) - Focuses on iterative de-
velopment with an emphasis on adapting to change.
* Scrum - Based on incremental, iterative work cycles called sprints,
emphasizing team collaboration and regular feedback.
* Dynamic Systems Development Method (DSDM) - A structured
agile model, suited for projects with strict time and budget constraints.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 35 / 94

Other Agile Process Models II

* Crystal - Emphasizes human interaction, communication, and is adapt-

able to project size and criticality.
* Feature-Driven Development (FDD) - Centers on designing and
building prioritized features.
* Lean Software Development (LSD) - Inspired by lean manufactur-
ing, focusing on eliminating waste and maximizing efficiency.
* Agile Modeling (AM) - Encourages modeling and documentation
practices that align with agile principles.
* Agile Unified Process (AUP) - A streamlined version of the Rational
Unified Process, aligning with agile values and iterative development.
Key Notes:
* All agile process models align to some degree with the Agile Manifesto
and its core principles.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 36 / 94

Adaptive Software Development (ASD) I

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 37 / 94

Adaptive Software Development (ASD) II
Overview:
* Proposed by Jim Highsmith, ASD is designed for developing complex
software with a focus on collaboration and team self-organization.
* Emphasizes an adaptive, agile approach that values collaboration as
much as discipline and engineering.
ASD Life Cycle Phases:
* Speculation:
- The project initiation and adaptive planning stage.
- Uses the customer’s mission, constraints, and requirements to
define release cycles.
- Plan adjustments occur based on feedback at each cycle’s completion.
* Collaboration:
- Involves communication, teamwork, and trust within the team.
- Emphasizes trust, where team members:
@ Criticize constructively without animosity.
@ Assist each other willingly.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 38 / 94

Adaptive Software Development (ASD) III

@ Work with commitment and a relevant skill set.

@ Communicate issues effectively for prompt action.
* Learning:
- Focuses on acquiring knowledge alongside development progress.
- ASD teams improve understanding via focus groups, technical
reviews, and postmortems.
Core Principles:
* ASD emphasizes self-organizing teams, collaboration, and contin-
uous learning.
* Promotes a flexible mindset for managing project complexities.
* Applicable across various process models to strengthen team dynamics
and project success.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 39 / 94

Scrum I

Overview:
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 40 / 94
Scrum II
* Scrum is an agile development method created by Jeff Sutherland
and further refined by Schwaber and Beedle.
* Scrum principles align with the Agile Manifesto and support devel-
opment within the framework activities of requirements, analysis,
design, evolution, and delivery.
Core Scrum Process Patterns:
* Backlog:
- A prioritized list of project requirements or features that provide busi-
ness value to the customer.
- The product manager updates and reprioritizes items in the backlog as
necessary.
* Sprints:
- Work units focused on completing a requirement from the backlog within
a predefined time-box (usually 30 days).
- Changes are not introduced during a sprint, providing a stable, short-
term work environment.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 41 / 94

Scrum III
* Scrum Meetings:
- Daily meetings (around 15 minutes) where team members discuss:
@ What was completed since the last meeting.
@ Current obstacles or issues.
@ Planned tasks for the next day.
- Led by the Scrum master, who identifies potential issues based on
responses.
- Promotes knowledge sharing and a self-organizing team structure.
* Demos:
- Software increments are demonstrated to the customer for evaluation.
- Shows only completed functionality within the sprint time-box, regard-
less of unimplemented plans.
Key Principles:
* Scrum acknowledges and operates within an environment of chaos and
uncertainty.
* Enables teams to manage projects effectively, even with unpredictable
factors.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 42 / 94
Dynamic Systems Development Method (DSDM) I
Overview:
* DSDM is an agile development approach providing a framework for
building and maintaining systems under tight time constraints.
* Uses incremental prototyping within a controlled project environ-
ment.
* Based on a modified Pareto principle—80 percent of an application
can be delivered in 20 percent of the total development time.
DSDM Life Cycle Activities:
* Feasibility Study:
- Defines basic business requirements and constraints.
- Assesses whether the application is a suitable candidate for DSDM.
* Business Study:
- Establishes functional and information requirements needed to de-
liver business value.
- Defines basic application architecture and maintainability require-
ments.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 43 / 94
Dynamic Systems Development Method (DSDM) II

* Functional Model Iteration:

- Develops incremental prototypes showcasing functionality to the cus-
tomer.
- Gathers additional requirements through user feedback.
* Design and Build Iteration:
- Revisits prototypes from the functional model iteration to ensure they
deliver operational business value.
- May occur concurrently with the functional model iteration.
* Implementation:
- Places the latest software increment (operational prototype) into pro-
duction.
- Allows for incremental changes based on new feedback.
- Returns to functional model iteration as needed for further develop-
ment.
Additional Notes:

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 44 / 94

Dynamic Systems Development Method (DSDM) III

* DSDM can be combined with XP to create a hybrid process model

that benefits from DSDM’s structured life cycle and XP’s practical
development practices.
* Emphasizes collaboration and self-organizing teams, concepts adapted
from ASD.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 45 / 94

Crystal I
Overview:
* Created by Alistair Cockburn and Jim Highsmith.
* Designed for maneuverability in resource-limited, cooperative en-
vironments.
* Sees development as a game of invention and communication fo-
cused on:
- Primary goal: Delivering useful, working software.
- Secondary goal: Preparing for future development iterations.
Crystal Family Structure:
* Contains a set of methodologies tailored to different project types.
* Each methodology includes:
- Core elements that are consistent across all Crystal methods.
- Specific roles, process patterns, work products, and practices unique
to each methodology.
Customization:
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 46 / 94
Crystal II

* Enables teams to select the Crystal method best suited to their

project needs and environment.
* Supports flexibility, allowing each project to leverage an approach that
matches its ;[size], complexity, and communication requirements.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 47 / 94

Feature Driven Development (FDD) I

Overview:
* Developed by Peter Coad and refined by Stephen Palmer and John
Felsing.
* An agile, feature-based process model suited for object-oriented
software engineering.
* Adapted for moderately-sized and larger projects.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 48 / 94

Feature Driven Development (FDD) II
Key Principles:
* Collaboration: Emphasis on team collaboration within the FDD frame-
work.
* Feature Decomposition: Manages project complexity by breaking
down work into features, followed by incremental integration.
* Communication: Use of verbal, graphical, and text-based communi-
cation for technical details.
Feature Definition:
* A feature is a client-valued function implementable within two weeks.
* Benefits of feature-based approach:
- Easier for users to describe and understand features.
- Features are organized into business-related groups.
- Facilitates incremental delivery with operational features every two
weeks.
- Simplifies inspection of design and code representations.
- Project planning and tracking driven by feature hierarchy.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 49 / 94
Feature Driven Development (FDD) III
Feature Template:
* Defined in the form: <action> the <result> <by for of to> a(n)
<object>.
* Example features for e-commerce:
- Add the product to shopping cart.
- Display the technical specifications of the product.
- Store the shipping information for the customer.
* Feature Sets: Groups related features, e.g., “Making a product sale.”
Framework Activities:
* FDD defines five core framework activities (termed processes in
FDD).
Project Management Emphasis:
* FDD includes specific project management guidelines for larger projects
* Uses six milestones to track progress:
- Design walkthrough, design, design inspection, code, code
inspection, promote to build.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 50 / 94
Lean Software Development (LSD) I

Overview:
* LSD adapts lean manufacturing principles to software engineering.
* Core principles are: eliminate waste, build quality in, create knowl-
edge, defer commitment, deliver fast, respect people, and opti-
mize the whole.
Principles Applied to Software Development:
* Eliminate Waste:
- Avoid adding unnecessary features.
- Assess cost and schedule impact of new requirements.
- Remove superfluous process steps.
- Streamline information access for team members.
- Ensure effective testing to catch maximum errors.
- Reduce decision-making time for software-related changes.
- Enhance information flow to stakeholders.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 51 / 94

Agile Modeling (AM) I
Overview:
* AM is a practice-based methodology for modeling and document-
ing software systems.
* It aims to create lightweight models that are just barely good enough,
emphasizing effective communication over perfection.
Key Characteristics:
* Agile Principles:
- Aligns with the Agile Manifesto values.
- Encourages refactoring and humility in design decisions.
* Model with a Purpose:
- Define the goal of the model (e.g., communication, understanding) be-
fore creation.
- Choose appropriate notation and detail level based on the goal.
* Use Multiple Models:
- Use a variety of models to represent different system aspects.
- Only models providing value to the intended audience should be kept.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 52 / 94
Agile Modeling (AM) II
* Travel Light:
- Keep only useful models and discard unnecessary ones.
- Ensure that every retained model is maintained, balancing agility with
information availability.
* Content Over Representation:
- Focus on the value of the content rather than syntactic perfection.
* Know Your Models and Tools:
- Understand the strengths and limitations of each modeling technique
and tool used.
* Adapt Locally:
- Tailor the modeling approach to the specific needs of the agile team.
Use of UML:
* UML is widely used for analysis and design models.
* Scott Ambler’s simplified version of UML integrates agile principles.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 53 / 94

Agile Unified Process (AUP) I
Overview:
* The AUP adopts a ”serial in the large” and ”iterative in the small”
approach.
* Combines the classic Unified Process (UP) phases with agile iteration
within each phase.
Phases of AUP:
* Inception: The initial phase where high-level planning occurs.
* Elaboration: Focus on refining requirements and architecture.
* Construction: Builds and tests the product incrementally.
* Transition: Delivers the final product and acquires feedback.
AUP Iteration Activities:
* Modeling:
- UML representations of the business and problem domains.
- Models are ”just barely good enough” for progress.
* Implementation:
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 54 / 94
Agile Unified Process (AUP) II

- Models are translated into working source code.

* Testing:
- Design and execute tests to identify errors and validate requirements.
* Deployment:
- Deliver software increment and gather user feedback.
* Configuration and Project Management:
- Manage change, risk, and control of work products.
- Track and coordinate team progress and activities.
* Environment Management:
- Manage process infrastructure, tools, and support technology.
Relationship to UML:
* AUP is historically connected to UML, but UML can be used with other
agile processes.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 55 / 94

A Tool Set for the Agile Process I
Overview:
* Some agile proponents argue tools are secondary to team success.
* Alistair Cockburn suggests that tools can be beneficial for agile teams,
particularly those enabling rapid understanding.
Types of Tools in Agile:
* Social Tools:
- Include team collaboration tools, even starting from the hiring process.
- Example: Pair programming during hiring to assess team fit.
* Technological Tools:
- Assist distributed teams in simulating physical presence.
* Physical Tools:
- Tools that allow manipulation, such as whiteboards and sticky notes.
Key Agile Tools:
* Collaboration and Communication Tools:
- Low-tech tools such as whiteboards, index cards, and sticky notes.
Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 56 / 94
A Tool Set for the Agile Process II

- Active communication (e.g., pair programming) and passive communi-

cation (e.g., information radiators like status displays).
* Project Management Tools:
- Replace traditional Gantt charts with earned value charts and progress
graphs.
* Environmental and Process Tools:
- Optimize team workspace and culture (e.g., efficient meeting areas, col-
located teams, electronic whiteboards).
- Enhance processes (e.g., pair programming, time-boxing).
Tools and Success:
* Tools are valuable if they enhance the agile team’s work and improve
the end product.

Pavan M,IS& E (JNNCE,Shimoga) Agile Development December 13, 2024 57 / 94

 Principles that guide practice
Module 3

Pavan M,IS& E

JNNCE,Shimoga

December 13, 2024

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 58 / 94
Outline
8 Software Engineering Knowledge
9 Core Principles
Principles That Guide Process
Principles That Guide Practice
10 Principles That Guide Each Framework Activity
Communication Principles
Planning Principles
Modeling Principles
Requirements Modeling Principles
Design Modeling Principles
Construction Principles
Coding Principles
Validation Principles
Testing Principles
Deployment Principles

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 59 / 94
Software Engineering Knowledge I
Overview:
* Steve McConnell’s editorial in IEEE Software highlights the distinction
between technology-specific knowledge and software engineering prin-
ciples.
* Emphasizes the importance of understanding both types of knowledge
for a successful career in software development.
Technology-Specific Knowledge:
* Includes languages and platforms like Java, Perl, HTML, C++, Linux,
Windows NT.
* Necessary for performing computer programming tasks.
* Has a short half-life (approximately 3 years).
* Constantly evolving, requiring continuous learning and adaptation.
Software Engineering Principles:
* Do not become obsolete quickly.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 60 / 94
Software Engineering Knowledge II
* Serve as a foundation for a professional programmer’s career.
* Include concepts such as modularity, abstraction, encapsulation, and
software lifecycle management.
* Provide guidelines for designing, developing, and maintaining software
systems.
Stable Core of Knowledge:
* By the year 2000, a stable core of software engineering knowledge had
evolved.
* Represents about 75% of the knowledge needed to develop complex
systems.
* Core principles guide the application and evaluation of software engi-
neering models, methods, and tools.
* Includes best practices, design patterns, and methodologies that remain
relevant over time.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 61 / 94
Software Engineering Knowledge III

Implications for Software Practitioners:

* Balancing the acquisition of technology-specific knowledge with a deep
understanding of software engineering principles is crucial.
* Continuous learning and professional development are necessary to keep
up with technological advancements.
* Applying core principles can lead to more robust, maintainable, and
scalable software systems.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 62 / 94
Core Principles I
Overview:
* Core principles guide the application of a meaningful software process
and effective software engineering methods.
* Establish a philosophical foundation for software teams.
* Guide framework and umbrella activities, process flow, and production
of software engineering work products.
Process Level Principles:
* Provide a foundation for navigating the process flow.
* Help in performing framework and umbrella activities.
* Ensure the production of effective software engineering work products.
Practice Level Principles:
* Establish values and rules for analyzing problems, designing solutions,
implementing and testing solutions, and deploying software.
General Principles:
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 63 / 94
Core Principles II
* Provide value to end users.
* Keep it simple.
* Maintain the vision of the product and the project.
* Recognize that others consume and must understand what you produce.
* Be open to the future.
* Plan ahead for reuse.
* Think!
Challenges:
* General principles are highly abstract and can be difficult to translate
into day-to-day practice.
Detailed Principles:
* The following subsections provide a more detailed look at the core
principles that guide process and practice.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 64 / 94
Principles That Guide Process I
Overview:
* Importance of the software process and various process models.
* Core principles applicable to all process models.
Principle 1: Be Agile
* Emphasize economy of action.
* Keep technical approaches simple.
* Produce concise work products.
* Make decisions locally whenever possible.
Principle 2: Focus on Quality at Every Step
* Ensure the quality of work products at every process activity, action,
and task.
Principle 3: Be Ready to Adapt
* Adapt approach to constraints imposed by the problem, people, and
project.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 65 / 94
Principles That Guide Process II

Principle 4: Build an Effective Team

* Build a self-organizing team with mutual trust and respect.
Principle 5: Establish Mechanisms for Communication and
Coordination
* Address management issues to prevent project failures due to poor
communication and coordination.
Principle 6: Manage Change
* Establish mechanisms to manage changes in a formal or informal man-
ner.
Principle 7: Assess Risk
* Establish contingency plans to handle potential issues during software
development.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 66 / 94
Principles That Guide Process III

Principle 8: Create Work Products That Provide Value for Others

* Produce work products that provide value for subsequent process ac-
tivities, actions, or tasks.
* Ensure work products impart necessary information without ambiguity
or omission.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 67 / 94
Principles That Guide Practice I
Overview:
* Goal: Deliver on-time, high-quality, operational software meeting stake-
holder needs.
* Core principles guide technical work regardless of methods, techniques,
or approaches used.
Principle 1: Divide and Conquer
* Emphasize separation of concerns (SoC).
* Subdivide large problems into manageable elements.
* Each element should deliver distinct functionality.
Principle 2: Understand the Use of Abstraction
* Simplify complex elements to communicate meaning.
* Use different levels of abstraction in analysis and design.
* Recognize that abstractions can sometimes ”leak” details.
Principle 3: Strive for Consistency
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 68 / 94
Principles That Guide Practice II
* Ensure consistency in requirements models, designs, code, and test
cases.
* Consistent user interfaces enhance usability.
Principle 4: Focus on the Transfer of Information
* Pay attention to information transfer across interfaces.
* Address potential errors, omissions, and ambiguities.
Principle 5: Build Software That Exhibits Effective Modularity
* Ensure each module focuses on a well-constrained aspect.
* Modules should be cohesive and exhibit low coupling.
Principle 6: Look for Patterns
* Use patterns to resolve recurring problems.
* Create a shared language for communicating solutions.
Principle 7: Represent the Problem and Solution from Different
Perspectives
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 69 / 94
Principles That Guide Practice III

* Use multiple viewpoints to gain insights and uncover errors.

* Examples: data-oriented, function-oriented, behavioral viewpoints.
Principle 8: Remember That Someone Will Maintain the Software
* Facilitate maintenance by applying solid software engineering practices.
* Software will be corrected, adapted, and enhanced over time.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 70 / 94
Principles That Guide Each Framework Activity I

Overview:
* Principles have a strong impact on the success of each generic frame-
work activity in the software process.
* These principles are refinements of the core principles discussed in Sec-
tion 4.2.
* They are stated at a lower level of abstraction.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 71 / 94
Communication Principles I
Overview:
* Effective communication is crucial for gathering customer requirements.
* Applies to communication among technical peers, customers, stake-
holders, and project managers.
Principle 1: Listen
* Focus on the speaker’s words.
* Ask for clarification if needed.
* Avoid interruptions and contentious behavior.
Principle 2: Prepare Before You Communicate
* Understand the problem before meetings.
* Research business domain jargon if necessary.
* Prepare an agenda for meetings.
Principle 3: Facilitate the Activity
* Have a leader to guide the conversation.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 72 / 94
Communication Principles II
* Mediate conflicts and ensure principles are followed.
Principle 4: Face-to-Face Communication is Best
* Use visual aids like drawings or documents to support discussions.
Principle 5: Take Notes and Document Decisions
* Assign a recorder to document important points and decisions.
Principle 6: Strive for Collaboration
* Use collective knowledge to describe functions or features.
* Build trust and create common goals through collaboration.
Principle 7: Stay Focused; Modularize Your Discussion
* Keep discussions on one topic until resolved.
* Facilitator should manage the flow of conversation.
Principle 8: If Something is Unclear, Draw a Picture
* Use sketches or drawings to clarify points.
Principle 9: Move On When Necessary
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 73 / 94
Communication Principles III

* Agree and move on, or if unclear, move on to avoid endless iteration.

Principle 10: Negotiation is Not a Contest
* Aim for win-win outcomes.
* Compromise is necessary for successful negotiation.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 74 / 94
Planning Principles I
Overview:
* Planning defines a road map to achieve strategic goals and tactical
objectives.
* Effective planning balances detail and flexibility to accommodate changes.
Principle 1: Understand the Scope of the Project
* Scope provides the destination for the software team.
Principle 2: Involve Stakeholders in the Planning Activity
* Stakeholders define priorities and establish constraints.
* Negotiation may be required for delivery order, timelines, and other
issues.
Principle 3: Recognize That Planning is Iterative
* Plans must be adjusted as work progresses and changes occur.
* Replanning is necessary after each software increment based on user
feedback.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 75 / 94
Planning Principles II
Principle 4: Estimate Based on What You Know
* Estimates should reflect the current understanding of the work.
* Unreliable information leads to unreliable estimates.
Principle 5: Consider Risk as You Define the Plan
* Identify high-impact, high-probability risks and plan contingencies.
* Adjust the project plan to accommodate potential risks.
Principle 6: Be Realistic
* Consider human factors, communication noise, and the inevitability of
change.
* Acknowledge that mistakes will happen.
Principle 7: Adjust Granularity as You Define the Plan
* High-granularity plans provide detailed tasks over short time incre-
ments.
* Low-granularity plans provide broader tasks over longer periods.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 76 / 94
Planning Principles III

* Granularity should decrease as the timeline extends.

Principle 8: Define How You Intend to Ensure Quality
* Identify quality assurance activities such as technical reviews and pair
programming.
Principle 9: Describe How You Intend to Accommodate Change
* Define how changes will be managed and assessed.
* Determine the process for handling customer change requests.
Principle 10: Track the Plan Frequently and Make Adjustments as
Required
* Monitor progress daily to identify and address issues.
* Adjust the plan to reflect actual work conducted.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 77 / 94
Modeling Principles I
Overview:
* Models help understand the entity to be built.
* Software models represent information, architecture, functions, fea-
tures, and behavior.
* Models operate at different levels of abstraction.
Types of Models:
* Requirements Models: Represent customer requirements in informa-
tion, functional, and behavioral domains.
* Design Models: Represent software characteristics like architecture,
user interface, and component-level detail.
Principle 1: Build Software, Not Models
* Focus on delivering software quickly.
* Avoid models that slow down the process or add little value.
Principle 2: Travel Light
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 78 / 94
Modeling Principles II
* Create only necessary models.
* Keep models up-to-date.
Principle 3: Simplify Models
* Produce the simplest model that describes the problem or software.
* Simple models are easier to integrate, test, and maintain.
Principle 4: Build Changeable Models
* Assume models will change.
* Ensure requirements models are reasonably complete.
Principle 5: Purpose of Models
* State an explicit purpose for each model.
* Avoid creating models without solid justification.
Principle 6: Adapt Models to the System
* Adjust model notation or rules to fit the application.
Principle 7: Useful, Not Perfect Models
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 79 / 94
Modeling Principles III

* Aim for useful models, not perfect ones.

* Avoid endless iterations to achieve perfection.
Principle 8: Flexible Syntax
* Focus on successful communication of content.
* Consistent notation is secondary to effective communication.
Principle 9: Trust Your Instincts
* Experienced engineers should trust their instincts about models.
* Re-examine or develop new models if concerns arise.
Principle 10: Get Feedback
* Review models with the software team.
* Use feedback to correct mistakes and improve models.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 80 / 94
Requirements Modeling Principles I
Overview:
* Numerous requirements modeling methods developed over the past
three decades.
* Methods address analysis problems and their causes using various no-
tations and heuristics.
* All methods share a set of operational principles.
Principle 1: Represent and Understand the Information Domain
* Encompasses data flowing into the system, out of the system, and data
stores.
* Includes data from end users, other systems, external devices, user
interfaces, reports, etc.
Principle 2: Define Software Functions
* Functions provide direct benefit to end users and internal support.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 81 / 94
Requirements Modeling Principles II
* Functions can transform data, control internal processing, or affect
external elements.
* Described at various levels of abstraction.
Principle 3: Represent Software Behavior
* Driven by interaction with the external environment.
* Includes input from end users, control data from external systems, and
monitoring data.
Principle 4: Partition Models to Uncover Detail
* Use a layered or hierarchical approach.
* Divide complex problems into manageable subproblems.
* Employ partitioning or separation of concerns.
Principle 5: Move from Essential Information to Implementation
Detail
* Start with the end-user’s perspective.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 82 / 94
Requirements Modeling Principles III

* Describe the essence of the problem without considering implementa-

tion.
* Transition to implementation details in the design model.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 83 / 94
Design Modeling Principles I
Overview:
* Design model is analogous to an architect’s plans for a house.
* Provides various views of the system, refining details progressively.
* Different methods (data-driven, pattern-driven, object-oriented) can be
used.
* All methods share common design principles.
Principle 1: Traceability to Requirements Model
* Design elements should be traceable to the requirements model.
* Translates information into architecture, subsystems, and components.
Principle 2: Consider System Architecture
* Architecture is the system’s skeleton, affecting interfaces, data struc-
tures, control flow, and more.
* Start with architectural considerations before component-level issues.
Principle 3: Importance of Data Design
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 84 / 94
Design Modeling Principles II
* Data design is crucial for architectural design.
* Well-structured data design simplifies program flow and improves effi-
ciency.
Principle 4: Careful Interface Design
* Design internal and external interfaces with care.
* Well-designed interfaces enhance integration and testing.
Principle 5: User Interface Design
* Tune user interface to end-user needs, emphasizing ease of use.
* Poor interface design can negatively impact software perception.
Principle 6: Functional Independence
* Components should be functionally independent and cohesive.
* Focus on single functions or subfunctions.
Principle 7: Loose Coupling

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 85 / 94
Design Modeling Principles III
* Components should be loosely coupled to each other and the external
environment.
* Lower coupling reduces error propagation and improves maintainability.
Principle 8: Understandable Design Representations
* Design models should be easily understandable.
* Effective communication medium for coding, testing, and maintenance.
Principle 9: Iterative Design Development
* Develop design iteratively, striving for simplicity with each iteration.
* Refine design and correct errors in early iterations.
Quality Factors:
* External Quality Factors: Observable by users (e.g., speed, reliability,
correctness, usability).
* Internal Quality Factors: Important to software engineers, leading to
high-quality technical design.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 86 / 94
Construction Principles I
Overview:
* Encompasses coding and testing tasks leading to operational software.
* Software ready for delivery to customer or end user.
Coding:
* Direct creation of programming language source code (e.g., Java).
* Automatic generation of source code from design-like representations.
* Automatic generation of executable code using fourth-generation pro-
gramming languages (e.g., Visual C++).
Testing:
* Unit Testing: Focus on individual components.
* Integration Testing: Conducted as the system is constructed.
* Validation Testing: Assesses whether requirements are met for the
complete system or software increment.
* Acceptance Testing: Conducted by the customer to exercise all re-
quired features and functions.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 87 / 94
Coding Principles I
Overview:
* Principles align with programming style, languages, and methods.
* Fundamental principles guide the coding task.
Preparation Principles:
* Understand the problem to be solved.
* Understand basic design principles and concepts.
* Choose a programming language suitable for the software and its envi-
ronment.
* Select a programming environment with helpful tools.
* Create unit tests for the component to be coded.
Programming Principles:
* Follow structured programming practices.
* Consider pair programming.
* Select appropriate data structures for the design.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 88 / 94
Coding Principles II

* Ensure interfaces are consistent with the software architecture.

* Keep conditional logic simple.
* Create easily testable nested loops.
* Use meaningful variable names and adhere to coding standards.
* Write self-documenting code.
* Use a visual layout (indentation, blank lines) that aids understanding.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 89 / 94
Validation Principles I

Overview:
* Validation principles ensure code quality after the first coding pass.
Steps to Follow:
* Conduct a code walkthrough when appropriate.
* Perform unit tests and correct any uncovered errors.
* Refactor the code to improve its structure and readability.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 90 / 94
Testing Principles I
Overview:
* Testing aims to find errors in the software.
* A good test case has a high probability of finding undiscovered errors.
* A successful test uncovers an undiscovered error.
Principle 1: Traceability to Customer Requirements
* Tests should be linked to customer requirements.
* Most severe defects are those that cause the program to fail to meet
requirements.
Principle 2: Plan Tests Early
* Test planning should begin as soon as the requirements model is com-
plete.
* Define test cases once the design model is solidified.
Principle 3: Apply the Pareto Principle
* 80
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 91 / 94
Testing Principles II
* Isolate and thoroughly test these components.
Principle 4: Test from Small to Large
* Begin with individual components (unit testing).
* Progress to integrated clusters and the entire system.
Principle 5: Exhaustive Testing is Impossible
* Too many path permutations to test every combination.
* Adequately cover program logic and conditions in component-level de-
sign.
Benefits of Testing:
* Uncovers errors in the software.
* Demonstrates that software functions according to specifications.
* Provides data on software reliability and quality.
* Cannot show the absence of errors, only their presence.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 92 / 94
Deployment Principles I
Overview:
* Deployment includes delivery, support, and feedback.
* Occurs multiple times as software evolves.
* Each cycle provides operational software increments, documentation,
and guidance for future increments.
Principle 1: Manage Customer Expectations
* Avoid overpromising and underdelivering.
* Communicate clearly and conscientiously.
Principle 2: Assemble and Test a Complete Delivery Package
* Include all executable software, support files, and documentation.
* Thoroughly beta-test with actual users in various configurations.
Principle 3: Establish a Support Regime
* Plan and prepare support materials.
* Ensure responsiveness and accurate information for end users.
Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 93 / 94
Deployment Principles II

Principle 4: Provide Instructional Materials

* Develop training aids and troubleshooting guidelines.
* Publish descriptions of new features in each increment.
Principle 5: Fix Bugs Before Delivery
* Do not deliver low-quality increments with promises of future fixes.
* Ensure high-quality product delivery, even if slightly delayed.
Benefits of Deployment:
* Provides operational software to end users.
* Offers feedback for the software team to improve future increments.
* Encourages user comments on features, ease of use, reliability, etc.

Pavan M,IS& E (JNNCE,Shimoga) Principles that guide practice December 13, 2024 94 / 94