10th Class Agile Lean Software Development

Class #10 Topics

• Topics covered in class #10 include Design Patterns, Code Management, and 7 Wastes.

Agile Lean Software Development

• Optimize the whole: A key aspect of Agile Lean Software Development.
• Eliminate Waste: A core principle, aiming to remove unnecessary steps and resources.
• Create Knowledge: Focus on learning and improving processes, ensuring knowledge is shared and accessible.
• Build Quality In: Building quality from the start, rather than fixing problems later.
• Fast Delivery: Delivering working software quickly.
• Delay in Making Decisions: A significant waste to be avoided when making timely decisions.
• Empower Your Team: Give team members the autonomy and responsibility to make decisions.

7 Wastes in Software

• Partially Done Work: Unfinished tasks accumulating, leading to slower cycles, increased context switching, and integration issues.
• Extra Features (Gold Plating): Adding unnecessary features not requested by the customer, increasing complexity, maintenance costs, and risk of defects.
• Relearning: Rediscovering information already known, wasting time and resources, leading to inconsistent practices.
• Handoffs: Transferring information or tasks between team members or departments. This can cause miscommunication, delays, knowledge loss, and inefficiency.
• Delays: Waiting time that slows the development process (waiting for approvals, feedback, or resources), delaying deadlines and bottlenecks.
• Task Switching: Frequently switching between tasks or projects, reducing productivity, increasing errors, and causing burnout.
• Defects: Bugs or errors requiring rework and corrections. This reduces software quality, increases costs, and damages customer satisfaction

Partially Done Work

• Description: Features or tasks that are started but not completed.
• Impact: Longer cycle times, increased context switching, potential integration issues.
• Example: A team starts a new feature but is interrupted to fix a bug, leaving the feature incomplete, accumulating technical debt.

Extra Features (Gold Plating)

• Description: Adding more features than strictly necessary or requested by the customer.
• Impact: Increased complexity, higher maintenance costs, and greater risk of defects.
• Example: Adding extra features to a user profile page (background themes, fonts, colors) that are not requested by users.

Relearning

• Description: Rediscovering already known information that isn't documented or shared properly.
• Impact: Time and resource waste, leading to inconsistent practices.
• Example: A developer struggles to fix a bug in a module without proper documentation, needing to rediscover its functionality.

Handoffs

• Description: Transferring information or tasks between team members or departments.
• Impact: Miscommunication, delays, loss of information.
• Example: Feature transfer from requirements gathering to design, implementation, and testing stages, each handoff involves knowledge transfer.

Delays

• Description: Waiting time during development (approvals, feedback, resources).
• Impact: Longer development cycles, missed deadlines, bottlenecks.
• Example: A feature waiting days for code review due to reviewer's busy schedule.

Task Switching

• Description: Frequent shifts between tasks/projects.
• Impact: Reduced productivity, increased errors, and potential burnout.
• Example: A developer working on multiple projects simultaneously, switching between them, diminishing focus.

Defects

• Description: Bugs or errors needing fixing.
• Impact: Compromised software quality, increased costs, and disappointed customers.
• Example: Released feature with significant bugs identified after testing, needing rework.

Code Management and Branching

• Manual Code Changes: Problems with manual code changes include increased error risk, poor collaboration, lack of traceability, and insufficient security measures.
• Git Flow - Diagram: A graphical representation of the branching strategy (Master, Pull Request, Discussion, Deploy). Showing branching for Hotfixes, Release Branches, and Develop Feature Branches.

Design Patterns

• Types of Design Patterns: The categories include Creational (object creation), Behavioral (communication of objects), and Structural (compiling into larger structures).

Singleton Design Pattern.

• A design pattern where a class only has one instance. Preventing multiple instantiations of a class, ensuring that a class is instantiated only once.

Factory Design Pattern

• A design pattern that creates objects without specifying the exact class of object that will be created.

Adapter Design Pattern

• A design pattern where an object is converted from one interface to another, making it compatible with other objects.

Bridge Design Pattern

• A design pattern that decouples an abstraction from its implementation, making it flexible and independent from each other.

Chain of Responsibility

• A design pattern where multiple objects are chained together, handling requests in a defined sequence.

Observer Design Pattern

• A design pattern where one object (subject) notifies other objects (observers) about any changes it might have, informing other objects of changes.

Other aspects

• The image or graphics from the slides give information on different applications of the particular design, not just definitions.

This quiz covers key concepts from class #10, focusing on Agile Lean Software Development principles such as optimizing processes, eliminating waste, and empowering teams. You'll explore the importance of building quality in from the start and delivering software quickly while avoiding common pitfalls. Test your knowledge on the 7 wastes in software development and learn how to improve efficiency in your projects.