Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add From 0 to 1: Design Patterns - 24 That Matter - In Java to your Wishlist.

Add to Wishlist

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

An intensely practical, deeply thoughtful and quirky look at 24 Design Patterns. Instructors are ex-Google, Stanford.
4.1 (122 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,836 students enrolled
Created by Loony Corn
Last updated 3/2016
English
$10 $50 80% off
4 days left at this price!
30-Day Money-Back Guarantee
Includes:
  • 11.5 hours on-demand video
  • 12 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?
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.

Talk to us!

  • Mail us about anything - anything! - and we will always reply :-)
Who is the target audience?
  • 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.
Students Who Viewed This Course Also Viewed
What Will I 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
View Curriculum
Requirements
  • There are no pre-requisites other than curiosity - about Design, about Patterns, about Life :-)
Curriculum For This Course
Expand All 63 Lectures Collapse All 63 Lectures 11:43:45
+
What are Design Patterns?
7 Lectures 46:10

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.
Preview 06:40

Design patterns are often divided into three categories - creational, behavioural and structural. Let's understand what these categories represent.
Creational, Behavioural and Structural Paradigms
07:03

'Program to interfaces, not implementations' said Eric Gamma. Of course he was right.

Design Principle #1: Rely on Interfaces, not Implementations
04:14

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.

Preview 05:31

Like children, code should only talk to friends, never to strangers!

Preview 04:39

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.

Preview 05:46



Quiz : Design Patterns
1 question

We will cover a fair bit of ground in this class. Here's a quick look at what's coming your way.

Preview 12:17
+
The Strategy Pattern
3 Lectures 35:32
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 Design Pattern: Introduction via String Sorting
14:25

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.

Preview 10:23

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

The Strategy Pattern and Dependency Injection - II
10:44

Quiz : Strategy Pattern
1 question

Quiz : Strategy Pattern
1 question

Quiz : Strategy Pattern
1 question
+
The Decorator Pattern
2 Lectures 22:09
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
08:43

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.
Preview 13:26

Quiz : Decorator Pattern
1 question

Quiz : Decorator Pattern
1 question
+
The Factory Pattern
6 Lectures 01:11:51

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: Introduction
14:57

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 Factory Design Pattern In Action: Database Drivers
05:43

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
16:03

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 Abstract Factory Design Pattern: Families of classes
08:48

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 - I
15:47

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.
The Factory Design Pattern In Action: Reflection - II
10:33

Quiz : Factory Pattern
1 question

Quiz : Factory Pattern
1 question

Quiz : Factory Pattern
1 question

Quiz : Factory Pattern
1 question
+
The Singleton Pattern
4 Lectures 48:27

The Singleton Pattern is beautiful - a unique object, usually implemented via a private constructor and a static getter method.

The Singleton Design Pattern: Introduction
09:05

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: Double-Checked Locking
13:14

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: The Synchronized Keyword
12:17

We tie together the different threads (bad pun!) we had going on multi-threading, and present a final thread-safe implementation.

The Singleton Design Pattern: Pulling together a multi-threaded solution
13:51

Quiz : Singleton Pattern
1 question

Quiz : Singleton Pattern
1 question

Quiz : Singleton Pattern
1 question

Quiz : Singleton Pattern
1 question
+
The Adapter Pattern
3 Lectures 25:24

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
05:18

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: Introduction - II
07:07

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.

Preview 12:59

Quiz : Adapter Pattern
1 question
+
The Facade Pattern
1 Lecture 15:53

The Facade Design Pattern hides in plain sight: complicated operations (such as networking and url handling) used to be incredibly onerous in C, and are incredibly simple in Java. We have the Facade Pattern to thank for this.

The Facade Design Pattern
15:53

Quiz : Facade Pattern
1 question

Quiz : Facade Pattern
1 question
+
The Template Pattern
3 Lectures 37:27
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: Introduction via Text Auto-Summarization
16:10

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
15: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". 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!)
The Template Design Pattern In Action: Frameworks - II
05:58

Quiz : Template Pattern
1 question
+
The Iterator Pattern
4 Lectures 48:13
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: Introduction
12:25

We look at how generics help enforce type-safety in collections - and how iterators are correspondingly also generic.
The Iterator Design Pattern: Type Safety via Generics
12:02

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: Internal and External Iterators
07:58

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)
The Iterator Design Pattern: Language Support for Iterators in Python and Java
15:48

Quiz : Iterator Pattern
1 question
+
The MVC Paradigm
3 Lectures 30:52
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.
Preview 13:59

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.

Preview 08: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 Charting application.

The Model View Controller Design Pattern In Action: A Chart Example
08:42

Quiz : MVC
1 question

Quiz : MVC
1 question

Quiz : MVC
1 question
13 More Sections
About the Instructor
4.3 Average rating
2,954 Reviews
20,598 Students
64 Courses
A 4-person team;ex-Google; Stanford, IIM Ahmedabad, IIT

Loonycorn is us, Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh. Between the four of us, we have studied at Stanford, IIM Ahmedabad, the IITs and have spent years (decades, actually) working in tech, in the Bay Area, New York, Singapore and Bangalore.

Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft

Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too

Swetha: Early Flipkart employee, IIM Ahmedabad and IIT Madras alum

Navdeep: longtime Flipkart employee too, and IIT Guwahati alum

We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!

We hope you will try our offerings, and think you'll like them :-)

Report Abuse