There are choices a developer can make that will make the software they write harder to maintain or extend and choices that will make it easier. This course helps developers make better choices for more longevity and flexibility in their code without introducing undue complexity.


This course addresses key questions in modern development such as how to design systems that have changeability as a fundamental quality and how the team can communicate effectively when a design is in a constant state of change.


Find out more at Net Objectives University.


Watch a webinar for An Introduction to Sustainable Design


Course Objectives: 

There are eight sessions in the course, each focused on one aspect of sustainable design. 

In this course, you will:

  • Identify the seven factors of sustainable design.

  • Explore your understanding through guided exercises and discussions with fellow students.

  • Assess your understanding with quizzes for each factor.


Learning Objectives: 

Upon completion, developers should be able to:

  • Identify properties of a design that will limit a product’s shelf life.

  • Propose improvements to extend and expand the usefulness of a software product.

  • Determine when they need to pull in a more experienced software designer.

  • Communicate effectively about design with other developers using a common language.

  • For new code, reduce the incidence of the following:

    • Needing to make the same fix in several places.

    • “Cascading” changes, where one small change leads to another, then another, et cetera.

    • Long searches to determine where all the related parts of a requirement live.

    • Surprising impacts on consumers of code.

    • Writing inscrutable code.

    • Unexpected side-effects within a body of code.

    • Difficulty testing.

  1. Introduction

    • Introduction to the course

    • Foundations of Sustainable Design

    • About code qualities

    • Introducing yourself and sharing concerns and goals

  2. Coupling

    • Define “coupling.”

    • Delineate between desirable and undesirable coupling.

    • Identify and name different types of coupling in code.

  3. Cohesion

    • Define "cohesion."

    • Identify different types of cohesion in code.

    • Describe how to recognize cohesion in code.

  4. Encapsulation

    • Review essential aspects of UML.

    • Define “encapsulation.”

    • Investigate what can be encapsulated.

    • Discuss how good design promoted encapsulation.

  5. Non-Redundancy

    • Define “non-redundancy.”

    • Investigate what things can be redundant.

    • Examine techniques for detecting and eliminating redundancies.

  6. Focus

    • Define “focus.”

    • Explain how focus relates to cohesion, encapsulation, and the separation of concerns.

    • Examine some examples of improving focus in code.

  7. Readability

    • Define “readability.”

    • Delineate between acceptable and unacceptable readability.

    • Identify and name different types of readability in code.

  8. Testability

    • Define “testability.”

    • Delineate between acceptable and unacceptable testability.

    • Identify and name different types of testability in code.

Full Description

What does it mean for a design to be “sustainable”? At the core it means that the effort developers expend to create a solution continues to return value for as long as possible. This is critical because developer time and effort is the most expensive part of software development. 


Good design helps us to mitigate risk and minimize waste, specifically in the face of change. Change can come from many places: new requirements, dependencies (on the work of other teams, on vendors, on tools, on technology itself), new opportunities and challenges arising in the marketplace, shifting business priorities, moving targets in the schedule, innovation, and so on.


We seek to create designs that can scale, extend, and accommodate change without extensive rework, and thus without losing the value of our previous work. The value of software is directly related to its ability to persistently meet the ever-changing needs of businesses, individuals, and the economy at large. So we want designs to be changeable in a way that is safe and efficient. 


Part of design “changeability” comes from modularization. If we can add elements to a design without having to rework it, if we can “plug in” new classes or modules cleanly, then we have gone a long way toward achieving this goal. However, the world is so unpredictable and the pace of change is so rapid that there will always be times when we must alter existing code rather than add new code. Thus, at the foundation of a changeable design is code that facilitates, rather than resists, change.


Think of legacy code that you have inherited. Some of it is very difficult and risky to modify. Some is less so. What we are outlining in this course are the aspects of code that affect its changeability. We seek to identify and give names to these various aspects so that we can improve our collaboration and increase the return on the investment of the effort we expend to create it. 


We have chosen the term “Code Qualities” to describe these aspects. In this course, each code quality will be given a name. We will examine how each code quality makes code more or less risky to change. It is possible you are familiar with each term; however, we want to ensure that everyone agrees on what they mean and that we all understand them to the same depth.

We will take these code qualities one by one, explain them, and allow you to engage in some exercises around them. We encourage you to collaborate with other students in the discussion forums, to share ideas and help each other deepen your understanding of these foundational elements of good code.



Max class size







Foundations of Sustainable Design