1.2 Principles that guide practice

• Software Engineering Practice

  Is a broad array of principles, concepts, methods, and tools that you must consider as software is planned and developed
• Principles that guide practice

  Establish a foundation from which software engineering conducted.
• Simplified Process Framework

  1. Communication
  2. Planning
  3. Modeling
  4. Constructions
  5. Deployment
• Principles that Guide Process

  1. Be agile- The basic tenets of agile development should govern your approach
  2. Focus on quality at every step- The exit condition for every process activity, action, and task should focus on the quality of the work product produced.
  3. Be ready to adapt- Process is not a religious experience and dogma has no place in it. When necessary, adapt your approach
  4. Build an effective team- Build a self-organizing team that has mutual trust and respect.
• Principles that Guide Process

  5. Establish mechanisms for communication and coordination- Projects fail because important information falls into the cracks and/or stakeholders fail to coordinate

  6. Manage change- The approach may be either formal or informal, but establish mechanisms to manage how changes are requested, assessed, approved and implemented.

  7. Assess risk- Things can go wrong as software is being developed so establish contingency plans.

  8. Create work products that provide value for others- products that provide value for other process activities, actions or tasks.
• Principles that Guide Practice

  1. Divide and conquer- Analysis and design should always emphasize separation of concerns (SoC).
  2. Understand use of abstraction- An abstraction is a simplification of some complex element of a system used to communicate meaning in a single phrase.
  3. Strive for consistency- A familiar context makes software easier to use.
  4. Focus on the transfer of information- Pay special attention to the analysis, design, construction, and testing of interfaces
  5. Build modular software- Modularity provides a mechanism for realizing the philosophy
• Principles that Guide Practice

  6. Look for patterns - “The goal of patterns is to create a body of literature to help software developers resolve recurring problems that come up in software development

  7. When possible, represent the problem and its solution from a number of different perspectives.

  8. Remember that someone will maintain the software.
• Communication Principles

  1. Listen- Try to focus on the speaker’s words, rather than formulating your response to those words
  2. Prepare before you communicate- Spend the time to understand the problem before you meet with others.
  3. Someone should facilitate the activity- Every communication meeting should have a facilitator to: (1) keep the conversation productive; (2) to mediate any conflict that does occur, and (3) to ensure than other principles are followed.
  4. Face-to-face communication is best- But it usually works better when some other representation of the relevant information is present.
• Communication Principles

  5. Take notes and document decisions- Someone participating should serve as a “recorder” and write down all important info.

  6. Strive for collaboration- Occurs when knowledge of team members of is combined

  7. Stay focused, modularize your discussion- The more people involved in communication, the more likely that discussion will bounce from one topic to the next

  8. If something is unclear, draw a picture.

  9. Once you agree to something, move on; If you can’t agree to something, move on; If something is unclear move on.

  10. Negotiation- Works when everyone wins
• Iterative Planning Process

  1. Identify the risks and scope
  2. Identify highest risks
  3. Plan and develop
  4. Asses (either risk is eliminated or step 5)
  5. Revise risk assessment
  6. Revise project plan
  7. back to 1
• Planning Principles

  1. Understand the scope of the project- It’s impossible to use a roadmap if you don’t know where you’re going. Scope provides a destination.
  2. Involve the customer in the planning activity- The customer defines priorities and establishes project constraints.
  3. Recognize that planning is iterative- A project plan is never engraved in stone. As work begins, it very likely that things will change
  4. Estimate based on what you know- The intent of estimation is to indicate effort, cost, and task duration, based on the team’s current understanding of the work to be done.
• Planning Principles

  5. Consider risk as you define the plan- If you have identified risks that have high impact and probability, contingency planning is necessary

  6. Be realistic- People don’t work 100 percent of every day

  7. Adjust granularity as you define the plan- Granularity is the level of detail that is introduced as a project plan is developed.

  8. Define how quality will be ensured-

  9. Describe how change will be to accommodated- Even the best planning can be obviated by uncontrolled change

  10. Track the plan frequently and make adjustments as required-
• Software Modeling (Iterative loop)

  1. Communication
  2. Quick Design
  3. Modeling Quick Design
  4. Construction of prototype
  5. Deployment, Delivery, Feedback
• Modeling Principles

  There are two types:

  1. Requirements models (analysis models) represent the customer requirements by depicting the software in three different domains: the information domain, the functional domain, and the behavioral domain.
  2. Design models represent characteristics of the software that help practitioners to construct it effectively: the architecture, the user interface, and component-level detail.
• Agile Modeling Principles

  1. The primary goal of the software team is to build software not create models
  2. Travel light – don’t create more models than you need.
  3. Produce the simplest model to describe the problem or the software.
  4. Build models that are amenable to change
  5. Be able to state an explicit purpose for each model.
  6. Adapt the models you create to the system.
  7. Try to build useful, not perfect models.
  8. Don’t become dogmatic about model syntax.
  9. If your instincts tell you a paper model isn’t right you may have a reason to be concerned
  10. Get feedback as soon as you can.
• Construction Principles - Coding

  Before you write one line of code:

  1. Understand the problem to be solved
  2. Understand basic design principles and concepts
  3. Pick a programming language that meets the needs of the software to be built
  4. Select a programming environment that provides tools that will make your work easier.
  5. Create a set of unit tests that will be applied once the component you code is completed
• Construction Principles - Coding

  when you start writing the code:

  6. Constrain your algorithms by following structured programming practice

  7. Consider pair programming

  8. Select data structures that will meet the needs of the design

  9. Understand the software architecture and create interfaces that are consistent with it.

  After you’ve completed your first coding pass, be sure you:

  10. Conduct a code walkthrough when appropriate

  11. Perform unit tests and correct errors you’ve uncovered

  12. Refactor the code to improve its quality.
• Agile Testing (loop)

  1. User Stories
  2. Evaluate and Test
  3. Mock-ups Design Deployment
  4. Evaluate and Test
  5. Acceptance Testing
  6. Feedback and Review
  7. Accept ? Release (if accept is yes)
  8. Document and Review (if accept is no)
• Testing Principles

  1. All tests should be traceable to customer requirements.
  2. Tests should be planned before testing begins.
  3. The Pareto principle applies to software testing (roughly 80% of the effects come from 20% of the causes.)
  4. Testing should begin “in the small ” and progress toward testing “in the large .”
  5. Exhaustive testing is not possible
  6. Testing effort for each system module commensurate to expected fault density
  7. Static testing can yield high results.
  8. Track defects and look for patterns in defects uncovered by testing
  9. Include test cases that show software is behaving correctly
• Deployment Principles

  1. Customer expectations for the software must be managed
  2. A complete delivery package should be assembled and tested.
  3. A support regime must be established before the software is delivered
  4. Appropriate instructional materials must be provided to end-users
  5. Buggy software should be fixed first, delivered later.