This is an intensely practical, deeply thoughtful, and quirky take on 24 Design Patterns that matter.
Let’s parse that.
Using discussion forums
Please use the discussion forums on this course to engage with other students and to help each other out. Unfortunately, much as we would like to, it is not possible for us at Loonycorn to respond to individual questions from students:-(
We're super small and self-funded with only 2 people developing technical video content. Our mission is to make high-quality courses available at super low prices.
The only way to keep our prices this low is to *NOT offer additional technical support over email or in-person*. The truth is, direct support is hugely expensive and just does not scale.
We understand that this is not ideal and that a lot of students might benefit from this additional support. Hiring resources for additional support would make our offering much more expensive, thus defeating our original purpose.
It is a hard trade-off.
Thank you for your patience and understanding!
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!
'Program to interfaces, not implementations' said Eric Gamma. Of course he was right.
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.
Like children, code should only talk to friends, never to strangers!
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.
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.
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
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?
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 Singleton Pattern is beautiful - a unique object, usually implemented via a private constructor and a static getter method.
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.
We tie together the different threads (bad pun!) we had going on multi-threading, and present a final thread-safe implementation.
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 Pattern is simple: an adapter takes in an object (usually singular) of one interface, and gives back another object (also singular) of another interface.
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.
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
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.
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.
Loonycorn is us, Janani Ravi and Vitthal Srinivasan. Between us, we have studied at Stanford, been admitted to IIM Ahmedabad and have spent years 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
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 :-)