Gain insights into software design patterns in C, explore their implementation, discover underlying principles, and learn to build a vocabulary for better communication and coding practices.

c.tar.gz

main+customer.c

main+customer.c-copy

watches

customers

observer

Reactor

Reactor-copy

observer-copy

Software design patterns are a valuable tool in any software developer's skill set. However, most design patterns are described in the context of an object-oriented programming language such as C++ or Java. The C language is sadly absent in the pattern literature. This course is here to change that by demonstrating that it is possible to use patterns in C programs and how it adds benefits to C programmers. You will learn why design patterns are more of a communication tool than technical solutions, and how patterns let you build and share a common vocabulary that simplifies communication.

The course presents a number of patterns and explains how to implement them in C. Each pattern is introduced via the problem it solves and the domains where the pattern can be used. We also discuss the underlying design principles as well as the trade-offs when applying the pattern. Finally, the course covers a set of coding idioms that will guide you when applying design patterns in C.

Software Design Patterns in C

Augmented Design Theory, which lets us document all assumptions we made in a given high-level design

Alternate Domain Type, which means we have another option for representing data when our domain types are too complex to validate.

Abstract Data Type, which is a module that specifies a set of values and operations on these values. 

Architectural Driven Tests, which are automated tests written against the interface of our architectural building blocks.

What does ADT stands for?

The C language does not allow an incomplete type to be dereferenced, so with a pointer to an incomplete type, clients are constrained to use the provided interface, which enforces true information hiding.

An incomplete type is always going to use less memory, which is vital to many embedded devices.

The C language guarantees that a pointer to an incomplete type is always initialized.


It's an interesting edge case in the C standard, which makes for great job interview questions but has few practical uses.


C allows us to declare a pointer to an incomplete type. Why is this so fundamental to the First-Class ADT pattern?

C allows us to declare a pointer to an incomplete type. Why is this so fundamental to the First-Class ADT pattern?

Yes, we cannot instantiate an incomplete type otherwise.

No, the beauty of the information hiding that the First-Class ADT pattern enables means we're free to choose any memory allocation approach we need.

Certain domains like embedded or safety-critical systems have coding standards that prohibit dynamic memory allocation. Is dynamic memory allocation (e.g., ```malloc```) a fundamental part of the First-Class ADT pattern?

Certain domains like embedded or safety-critical systems have coding standards that prohibit dynamic memory allocation. Is dynamic memory allocation (e.g., <code>malloc</code>) a fundamental part of the First-Class ADT pattern?

Stronger coupling since clients now depend on implementation details.

Less control over when an object gets created as clients can instantiate our ADT at any time.

There's a slight performance cost since all operations on the ADT imply one extra level of indirection. 

All clients have to be re-compiled if the implementation of the ADT changes.

A pattern always comes with trade-offs; without context, a pattern is neither good nor bad. Which of the following is a consequence of applying the First-Class ADT pattern?

A pattern always comes with trade-offs; without context, a pattern is neither good nor bad. Which of the following is a consequence of applying the First-Class ADT pattern?

The pattern lets us encapsulate the implementation details so that a client doesn’t rely on things we intend to change.

The pattern allows a clear separation between a module's external behavior and its internal details.

The pattern lets us erect boundaries between different layers in an application.

The pattern facilitates parallel work by multiple teams. They have one team work against a published interface, while other works on the implementation details.

All of the above alternatives are correct. 

A key part of any pattern is the resulting context. When implementing a pattern, we expect certain effects on our software design. Which effects can we expect when applying the First-Class ADT pattern?

A key part of any pattern is the resulting context. When implementing a pattern, we expect certain effects on our software design. Which effects can we expect when applying the First-Class ADT pattern?

Introduction to Pattern in C

The First-Class ADT Pattern

The State Pattern

The Strategy Pattern

The Observer Pattern

The Reactor Pattern

Idiomatic Expressions

Conclusion

Quiz: The First-Class ADT Pattern