Training > Design Patterns, Testing and Programming Skills

Design Patterns, Testing and Programming Skills
for Agile Developers

Thinking About Design Patterns Training for yourself or your team?

Design Patterns Training for your team will help them produce better quality software. Your problem domain is complex and changing. This means that your software needs to be designed to easily adapt to changing requirements. Understanding the forces that design patterns address will help your team achieve higher code quality overall.

Much of the buzz today in software development is about process rather than code. Scrum, Kanban, Agile, TDD and other process related topics have many people looking for ways to increase the predictability and throughput of their development teams. The code quality and changeability of designs gained from learning Design Patterns is a vital aspect creating better software faster.

At Net Objectives we are all about helping teams create better software faster at a reasonable cost. This can start with Design Patterns training from Net Objectives.

Our Related Courses

  • Design Patterns for Agile Developers
    Development organizations working in an Agile, iterative process must accept, even embrace change. The three-day Design Patterns for Agile Developers course illustrates how the use of abstract coupling, design patterns, testability, emergent (just-in-time) design, and other key principles and practices can create systems with changeability as a fundamental quality.
  • Sustainable Test-Driven Development
    This course teaches the skills of unit testing, refactoring, and incremental development, but we take it farther than this.  Unless developers are trained about which tests to write, how to write them, when to refactor code, and techniques for breaking dependencies, testing can become unsustainable as projects mature.

    We teach sustainable test-driven development, with a focus on deriving maximum value (technical and business) from minimal effort and cost.

  • Emergent Design
    System development has a natural flow.  Emergent Design helps developers work with the flow, instead of against it. This 5-day course introduces the principles and practices of emergent design one step at a time, showing how to promote the natural evolution of software systems over time, making systems work better and provide greater value. This course provides developers, project leads, and testers powerful new ways to collaborate, achieve immediate goals, and build systems that improve in quality with each iteration.
  • Acceptance Test-Driven Development
    A major challenge with requirements is misunderstanding them. The people who define, implement, and test the product all have a different understanding of what needs to be done. This misunderstanding begets waste, slipped schedules, and mistrust within the organization.  Moreover, big requirement stories are often decomposed into technical tasks that are not focused on the customer’s needs, leading to implementations that are unnecessarily complex to build and maintain.

    This course teaches the skills needed to transform uncertain requirements into small, clear and succinct stories that are focused on user needs. It also teaches how to create acceptance tests that verify their correct implementations.

    Applying these skills will streamline the communication within the organization, hence decreasing rework, raising customer satisfaction, and promoting trust within the organization.

  • Implementing Story Acceptance Tests
    This course teaches the participants how to automate story tests using the Fit framework. Fit allows tests to be easily automated and at the same time does not limit the vocabulary available for the test writers. At the end of the course the participants will understand the importance of automating story tests (STDD), how to use Fit to implement STDD/automate story tests/extend it, and understand test interfaces and how to reuse story tests.
  • Story Writing With Tests
    A common thread amongst virtually all software development organization is the lack of efficient and effective communication between the various functions – product definition, development, testing, documentation, training and deployment, to name a few. This results in a lower product quality through more defects and less customer satisfaction, as well as longer development cycles and unreliable estimates.

    In agile organizations the problem manifests itself through stories that are not focused on value but on system change, sans the big picture, are too big, and are written by the wrong people, at the wrong time. Agile story writing through the practice of acceptance testing is a very effective solution to this problem.

  • Database Agility Online Training
    This is an online course to teach the core skills required for true Database Agility.
  • Essential Skills for the Agile Developer
    This is an online course to teach the Essential Skills that every developer should have.
  • TDD Database Boot Camp
    This course teaches testing disciplines which enable emergent design in a database. Hands-on lab exercises are provided. Comes with a license to a tool that help facilitate the process.
  • Advanced Software Design
    This two-day course continues the exploration of design patterns begun in our Agile Analysis and Design Patterns course. This course presents detailed case studies and additional patterns.
  • Design Patterns Explained
    This three-day course goes beyond merely teaching several design patterns. It also teaches the principles, practices, and approaches to design that make design patterns "good designs". This empowers students to use these advanced design techniques in their problems whether design patterns are even present. After teaching several patterns and the principles underneath them, the course goes further by showing how patterns can work together to create robust, flexible, maintainable designs.
  • Lean-Agile Testing Practices
    Lean-Agile methods promote the rapid delivery of value to the customer. One way they do this is to defer detailed definition and design of system features until the “last responsible moment.” This challenges the whole team to stay continuously synchronized within very short iteration cycles. The team must be creative, smart, and efficient with their verification and validation testing activities.
  • Effective Object-Oriented Analysis and Design
    This three-day course covers fundamental Object-Oriented (OO) Programming strategies and explains what makes them so powerful. After completely establishing the strengths and usefulness of the strategies, the course then focuses on how to apply the strategies to new designs, and how to recognize opportunities to use them in your analysis of existing code. This course can be taught in C++, C#, Java, and VB.NET.