Design Patterns, A Pragmatic Approach
4.0 (11 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.
142 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Design Patterns, A Pragmatic Approach to your Wishlist.

Add to Wishlist

Design Patterns, A Pragmatic Approach

It's a focussed, simple and practical look into the Gang of Four design patterns
4.0 (11 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.
142 students enrolled
Created by Peter Fajemisin
Last updated 12/2015
English
Current price: $10 Original price: $20 Discount: 50% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 3.5 hours on-demand video
  • 22 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • At the end of the course, you will have a personal practical experience of all Gang of Four design patterns, recognise them and can begin incorporating them into your own code.
View Curriculum
Requirements
  • To take this course, you should be familiar with object oriented design.
Description

We take a pragmatic look at the Gang of Four design patterns with special focus on students being able to understand each pattern very quickly. To achieve this, I will keep it simple and only teach you what you need to know.

You say why do I need to learn design patterns? Well, solving software engineering problems is integral to your job as a software engineer, design patterns gives you a set of re-usable template for doing this.

Consider this scenario, you walk into an interview, the interviewer asks you to give examples of design patterns and how you have used them, you mention the 23 Gang of Four patterns from memory, you then describe in detail how and when to use them. That will be impressive. In this course, I will give you the formula to be able to do just that.

I start you off with the master quiz, use this to guage your understanding before and after the course.

This course focusses on the Gang of Four design pattern and clearly explains each pattern using the structure:

- Explanation

- Real World Example

- UML

- Code Example

- When to use/When not to use

This is followed by a memory exercise aimed at giving you a simple technique for remembering all Gang of Four design patterns from memory.

To take this course, you should be familiar with Object Oriented design. It will use UML and Java, so familiarity with these in particular will be helpful.

At the end of the course, students will be able to use design patterns to find solutions to recurring problems of system architecture. They will have personal practical experience of all Gang of Four design patterns, recognise them and can begin incorporating them into their own code.

OK, let's get started, please enjoy and let me take you on a learning journey.

Who is the target audience?
  • This course is aimed at software engineers.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 28 Lectures Collapse All 28 Lectures 03:21:36
+
Master Quiz
0 Lectures 00:00

40 Questions. Covers all sections of the course. This assessment will allow the students to guage their understanding of the course contents and provide useful feedback to the tutor.

Master Quiz
40 questions
+
Introduction
2 Lectures 04:02

Introducing the course

Preview 01:40

Format. After this section, you will will know the format of the course

Preview 02:22
+
Design Patterns and Gang of Four
1 Lecture 11:34

Design Patterns and Gang of Four - After this lecture, you will be able to define design patterns and know who the Gang of Four are!

Preview 11:34
+
Deep Dive
23 Lectures 02:53:34

Abstract Factory. After this lecture, you should be able to explain the abstract factory design pattern in simple terms and start incorporating it in your own code.

Deep dive - Abstract Factory
12:40

Builder. After this lecture, you should be able to explain the builder design pattern in simple terms and start incorporating it in your own code.

Deep dive - Builder
06:49

Factory methods. After this lecture, you should be able to explain the factory methods design pattern in simple terms and start incorporating it in your own code.

Deep dive - Factory methods
06:00

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

Deep dive - Prototype
08:31

Singleton. After this lecture, you should be able to explain the singleton design pattern in simple terms and start incorporating it in your own code.

Deep dive - Singleton
06:27

Adapter. After this lecture, you should be able to explain the adapter design pattern in simple terms and start incorporating it in your own code.

Deep dive - Adapter
05:18

Bridge. After this lecture, you should be able to explain the bridge design pattern in simple terms and start incorporating it in your own code.

Deep dive - Bridge
09:08

Composite. After this lecture, you should be able to explain the composite design pattern in simple terms and start incorporating it in your own code.

Deep dive - Composite
08:39

Decorator. After this lecture, you should be able to explain the decorator design pattern in simple terms and start incorporating it in your own code.

Deep dive - Decorator
09:37

Facade. After this lecture, you should be able to explain the facade design pattern in simple terms and start incorporating it in your own code.

Deep dive - Facade
06:45

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

Deep dive - Flyweight
09:48

Flyweight. After this lecture, you should be able to explain the flyweight design pattern in simple terms and start incorporating it in your own code.

Deep dive - Proxy
08:54

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

Deep dive - Chain of Responsibility
05:06

Command. After this lecture, you should be able to explain the command design pattern in simple terms and start incorporating it in your own code.

Deep dive - Command
07:30

Iterator. After this lecture, you should be able to explain the iterator design pattern in simple terms and start incorporating it in your own code.

Deep dive - Iterator
08:33

Interpreter. After this lecture, you should be able to explain the interpreter design pattern in simple terms and start incorporating it in your own code.

Deep dive - Interpreter
05:19

Mediator. After this lecture, you should be able to explain the mediator design pattern in simple terms and start incorporating it in your own code.

Deep dive - Mediator
05:18

Memento. After this lecture, you should be able to explain the memento design pattern in simple terms and start incorporating it in your own code.

Deep dive - Memento
06:11

Observer. After this lecture, you should be able to explain the observer design pattern in simple terms and start incorporating it in your own code.

Deep dive - Observer
08:34

State. After this lecture, you should be able to explain the state design pattern in simple terms and start incorporating it in your own code.

Deep dive - State
08:48

Strategy. After this lecture, you should be able to explain the strategy design pattern in simple terms and start incorporating it in your own code.

Deep dive - Strategy
07:21

Template methods. After this lecture, you should be able to explain the template methodsdesign pattern in simple terms and start incorporating it in your own code.

Deep dive - Template methods
05:49

Visitor. After this lecture, you should be able to explain the Visitor design pattern in simple terms and start incorporating it in your own code.

Deep dive - Visitor
06:29
+
Memory Exercise
1 Lecture 03:49

Lets burn GOF into our heads! After this lecture, you should be able to remember all GOF patterns from memory.

Lets Burn GOF into our heads
03:49
+
Non Gang of Four Patterns
1 Lecture 08:37

Other Patterns. After this lecture, you will know some other non-GOF design patterns, some of which are widely used today.

Other Patterns
08:37
About the Instructor
Peter Fajemisin
4.0 Average rating
11 Reviews
142 Students
1 Course
Software Consultant and Trainer

I am an Agile Java developer with over 10 years experience of developing a wide variety of enterprise applications.

I have a passion for learning technology and I actively follow and participate in many technology communities.

Technical Expertise includes: Design Patterns, Scrum, XP, JavaEE, Spring, Maven, Ant, JBoss, Apache Tomcat, Oracle, MSSQL, Query Optimization, JPA, Hibernate, Spring, JavaEE, Wicket, JSF, Struts, Mockito, JBPM, Drools, Comet, SOA, REST, Web Services, F5 Load Balancer, JQuery, Ajax, Comet, Linux, Apache, Tomcat, JMeter, JProfiler, Adobe Day CQ, Jenkins, Git, Subversion, Ehcache and Terracotta, Selenium.

As a software trainer, I strongly believe in simplicity and pragmatism, I will not bore you with hours of lectures and I will keep each topic focussed and to the point.

To take a quote from Albert Einstein “If you can't explain it simply, you don't understand it well enough." To make sure you learn:

I will keep it simple stupid

I will only teach you what you need to know

So please have an open mind and allow me to take you on a learning journey.