From 0 to 1: Design Patterns - 24 That Matter - In Java

Name: From 0 to 1: Design Patterns - 24 That Matter - In Java
Rating: 3.8 (556 reviews)

An intensely practical, deeply thoughtful and quirky look at 24 Design Patterns. Instructors are ex-Google, Stanford.

Created byLoony Corn

Last updated 3/2016

English

What you'll learn

Identify situations that call for the use of a Design Pattern
Understand each of 24 Design Patterns - when, how, why and why not to use them
Distill the principles that lie behind the Design Patterns, and apply these in coding and in life, whether or not a Design Pattern is needed
Spot programming idioms that are actually built on Design Patterns, but that are now hiding in plain sight

Course content

23 sections • 63 lectures • 11h 43m total length

What this course is about6:40
We - the course instructors - start with introductions. We are a husband-wife team, studied at Stanford, and spent several years working in top tech companies, including Google, Flipkart and Microsoft.

Next, we talk about the target audience for this course: Engineers and Product Managers, certainly, but also Tech Executives and Investors, or anyone who has some curiosity about technology.

By the end of this class, students will be able to: spot situations where design patterns lead to better designs, and deploy those patterns effectively. Product managers and executives will learn enough of the 'how' to be able intelligently converse with their engineering counterparts, without being constrained by it.

That's it for preliminaries - with this we plunge right in!

"Design Patterns are canonical solutions to recurring problems". We start by understanding what Design Patterns are, and why these patterns are still so popular decades after they were first put together.

Design Patterns, Libraries and Frameworks: A martial arts analogy illustrates the difference

Broad Categories of Patterns: We also take a quick swing through the major categories of Design Patterns - creational, structural and behavioral.
Creational, Behavioural and Structural Paradigms7:03
Design patterns are often divided into three categories - creational, behavioural and structural. Let's understand what these categories represent.
Design Principle #1: Rely on Interfaces, not Implementations4:14
'Program to interfaces, not implementations' said Eric Gamma. Of course he was right.
Design Principle #2: The Open/Closed Principle5:31
Code should be open for extension but closed for modification. How can this be achieved? Well, there are 3 possible ways: inheritance, delegation, and composition.
Design Principle #3: Principle of Least Knowledge4:39
Like children, code should only talk to friends, never to strangers!
Design Principles #4 and #5: Dependency Inversion and the Hollywood Principle5:46
Always rely only on abstractions, never on details. Oh - and don't call us, we'll call you. That's how Hollywood works, and that's how the Hollywood Principle reads.
Quiz : Design Patterns
A taste of things to come12:17
We will cover a fair bit of ground in this class. Here's a quick look at what's coming your way.

The Strategy Design Pattern: Introduction via String Sorting14:25
The Strategy Design Pattern helps modify the behavior of classes at run-time - and does so using composition (member variables) rather than inheritance (parent classes). We examine how the Collections.sort method embodies the Strategy Pattern.
The Strategy Pattern and Dependency Injection - I10:23
Dependency Injection is a widely-used design technique that is closely related to the Strategy Design Pattern. This lecture details how dependency injection is used to specify complex user interfaces in Java FX using an XML representation called FXML. This is a common technique used in modern UI frameworks in Java.
The Strategy Pattern and Dependency Injection - II10:44
Dependency Injection is a widely-used design technique that is closely related to the Strategy Design Pattern. This lecture continues detailing the use of dependency injection to specify complex user interfaces in Java FX, and then ties back to the Strategy Design Pattern
Quiz : Strategy Pattern
Quiz : Strategy Pattern
Quiz : Strategy Pattern

The Decorator Design Pattern8:43
The Decorator Design Pattern comes in handy when a class hierarchy needs to take into account multiple independent implementation details. One decorator class for each independent variable, each of which can be created from another. All decorator objects implement the same interface of course.
The Decorator Design Pattern In Action: Java File APIs13:26
The Java File APIs are a classic use-case of the Decorator Pattern - it would be difficult to imagine an efficient way to implement these APIs without using the Decorator.
Quiz : Decorator Pattern
Quiz : Decorator Pattern

The Factory Design Pattern: Introduction14:57
Let's say your organization is moving from one database (say MS SQL-Server) to another (say Oracle). How would you use the Factory Pattern to minimize the effort needed for this enormous move?
The Factory Design Pattern In Action: Database Drivers5:43
We continue with our planning for the move to Oracle from MS-SQL Server - we see how the Decorator Pattern, combined with the use of reflection and config files, can save us many late nights and bug bashes
The Abstract Factory Design Pattern16:03
The Abstract Factory Pattern is closely related to the Factory Design Pattern, but is a better fit when entire different hierarchies of related objects need to be created. We also examine the Open-Closed Principle, which specifies that classes should open for extension but closed for modification.
The Abstract Factory Design Pattern: Families of classes8:48
Let's see an example of how we can use the Abstract Factory pattern to create families of classes. We'll work with the same example of moving from Microsoft to Oracle as our database provider.
The Factory Design Pattern In Action: Reflection - I15:47
These days, the Factory Design Pattern is increasingly implemented via Reflection, so it makes sense for us to understand the pros, cons, and complexities of Reflection
The Factory Design Pattern In Action: Reflection - II10:33
As previously discussed, these days, the Factory Design Pattern is increasingly implemented via Reflection. In this video, we describe a specific use-case when Reflection is exactly the right tool for what we are seeking to accomplish.
Quiz : Factory Pattern
Quiz : Factory Pattern
Quiz : Factory Pattern
Quiz : Factory Pattern

The Singleton Design Pattern: Introduction9:05
The Singleton Pattern is beautiful - a unique object, usually implemented via a private constructor and a static getter method.
The Singleton Design Pattern: Double-Checked Locking13:14
The Singleton Pattern is very elegant in its construction, but there are important nuances that we should be aware of, specifically related to multi-threading and to class loaders in Java. In this lecture, we explore how a concurrency-related Design Pattern called Double-Checked Locking can come in handy while implementing the Singleton in a multi-threaded environment.
The Singleton Design Pattern: The Synchronized Keyword12:17
The Singleton Pattern in a multi-threaded environment is surprisingly hard to get exactly right - we dig deeper into the subtleties - this requires us to understand the exact semantics of the Synchronized keyword.
The Singleton Design Pattern: Pulling together a multi-threaded solution13:51
We tie together the different threads (bad pun!) we had going on multi-threading, and present a final thread-safe implementation.
Quiz : Singleton Pattern
Quiz : Singleton Pattern
Quiz : Singleton Pattern
Quiz : Singleton Pattern

The Adapter Design Pattern: Introduction5:18
The Adapter Pattern is often used in converting data from one representation to another: we understand how an adapter can help with loose coupling of classes. Also, classes need not be rewritten to support additional interfaces, a new adapter is all that is needed.
The Adapter Design Pattern: Introduction - II7:07
We continue with the benefits of adapters, and see a simple example of adapters - wrapping arrays so that all of the powerful functionality available for working with Collections can be easily applied to arrays too.
The Adapter Design Pattern In Action: Tables and Charts12:59
The Adapter Pattern is simple: an adapter takes in an object (usually singular) of one interface, and gives back another object (also singular) of another interface.
Quiz : Adapter Pattern

The Template Design Pattern: Introduction via Text Auto-Summarization16:10
The Template Design Pattern is perfect when we need to specify a complex algorithm, and leave room for a client to plug in a specific implementation for a specific step. We examine this via an example from Natural Language Processing: automatically summarizing a document. We see how classic NLP algorithms can be plugged into the more general summarization algorithm via the Template Pattern.
The Template Design Pattern In Action: Frameworks15:19
The Template Pattern was the precursor to Frameworks - both embody the Dependency Inversion Principle, where high-level objects say to low-level objects "don't call us - we'll call you".
The Template Design Pattern In Action: Frameworks - II5:58
The Template Pattern was the precursor to Frameworks - both embody the Dependency Inversion Principle, where high-level objects say to low-level objects "don't call us - we'll call you". We consider Java FX, a framework where the client plugs in code into a specific method, the framework does the rest (which is a lot!)
Quiz : Template Pattern

The Iterator Design Pattern: Introduction12:25
The Iterator Design Pattern has become part of the daily idiom of programming; iterators offer a standard way to access elements in a collection, independent of the implementation of the collection.
The Iterator Design Pattern: Type Safety via Generics12:02
We look at how generics help enforce type-safety in collections - and how iterators are correspondingly also generic.
The Iterator Design Pattern: Internal and External Iterators7:58
We explore in further detail the differences between Internal and External Iterators, and also how the for-each operator has become a standard part of language support for iterators in Java, Python and other major languages
The Iterator Design Pattern: Language Support for Iterators in Python and Java15:48
We continue look at how Python and Java have explicitly added language support for iterators, and also examine how iterators in Python are inextricably linked to the language (far more than in Java)
Quiz : Iterator Pattern

The Model View Controller Design Pattern: An Introduction13:59
The Model-View-Controller (MVC) paradigm is ubiquitous in UI programming; along with the Observer and Command patterns, MVC has practically defined modern User-Interface programming.
The Model View Controller Design Pattern In Action: A MediaPlayer Example8:11
Models contain data, views define the UI, and controllers respond to user input and update the model and the view. We see how this plays out in a Media Player application.
The Model View Controller Design Pattern In Action: A Chart Example8:42
Models contain data, views define the UI, and controllers respond to user input and update the model and the view. We see how this plays out in a Charting application.
Quiz : MVC
Quiz : MVC
Quiz : MVC

Requirements

There are no pre-requisites other than curiosity - about Design, about Patterns, about Life :-)

Description

Prerequisites: Basic understanding of Java
Taught by a Stanford-educated, ex-Googler, husband-wife team
More than 50 real-world examples

This is an intensely practical, deeply thoughtful, and quirky take on 24 Design Patterns that matter.

Let’s parse that.

The course is intensely practical, bursting with examples - the more important patterns have 3-6 examples each. More than 50 real-world Java examples in total.
The course is deeply thoughtful, and it will coax and cajole you into thinking about the irreducible core of an idea - in the context of other patterns, overall programming idioms and evolution in usage.
The course is also quirky. The examples are irreverent. Lots of little touches: repetition, zooming out so we remember the big picture, active learning with plenty of quizzes. There’s also a peppy soundtrack, and art - all shown by studies to improve cognition and recall.
Lastly, the patterns matter because each of these 24 is a canonical solution to recurring problems.

What's Covered:

Decorator, Factory, Abstract Factory, Strategy, Singleton, Adapter, Facade, Template, Iterator, MVC, Observer, Command, Composite, Builder, Chain of Responsibility, Memento, Visitor, State, Flyweight, Bridge, Mediator, Prototype, Proxy, Double-Checked Locking and Dependency Injection.
The only GoF pattern not covered is the Interpreter pattern, which we felt was too specialized and too far from today’s programming idiom; instead we include an increasingly important non-GoF pattern, Dependency Injection.
Examples: Java Filestreams, Reflection, XML specification of UIs, Database handlers, Comparators, Document Auto-summarization, Python Iterator classes, Tables and Charts, Threading, Media players, Lambda functions, Menus, Undo/Redo functionality, Animations, SQL Query Builders, Exception handling, Activity Logging, Immutability of Strings, Remote Method Invocation, Serializable and Cloneable, networking.
Dependency Inversion, Demeter’s Law, the Open-Closed Principle, loose and tight coupling, the differences between frameworks, libraries and design patterns.

Who this course is for:

Yep! Engineers - from street-smart coders to wise architects - ought to take this course. After this class, you'll look at software design with a new pair of eyes.
Yep! Product Managers ought to take this course - you will learn to understand the 'how' of Software Design without being constrained by it.
Yep! Technology executives and investors who don't write code ought to take this course - after this you will always have an intelligent point-of-view on software, and won't find your eyes glazing over when its time to talk nitty-gritty
Computer Science majors (undergrad or grad) - if you are among the folks that make 'real world example Observer Pattern' such a common search phrase on Google, this is precisely the place for you.
Yep! Journalists, Wall Street types or IP lawyers seeking to understand recurring patterns of problems and solutions in technology.
Yep! If you are prepping hard for software engineering interviews :-)
Nope! This course is not right for you if you are looking for a Programming 101 course. That's not because there are pre-requisites, but simply because a Programming 101 course focuses on syntax, and on doing, while this course focuses on design, and on thinking.

From 0 to 1: Design Patterns - 24 That Matter - In Java

What you'll learn

Explore related topics

Course content

What are Design Patterns?7 lectures • 46min

The Strategy Pattern3 lectures • 36min

The Decorator Pattern2 lectures • 22min

The Factory Pattern6 lectures • 1hr 12min

The Singleton Pattern4 lectures • 48min

The Adapter Pattern3 lectures • 25min

The Facade Pattern1 lecture • 16min

The Template Pattern3 lectures • 37min

The Iterator Pattern4 lectures • 48min

The MVC Paradigm3 lectures • 31min

Requirements

Description

Who this course is for: