Understanding the concepts of Software Design Patterns

This lecture provides an introduction to the section titled Problems with Software Application Development. In this lesson, it lists the other lectures that are covered in this section. In fact, this is lecture is important, as this brings up the question of the importance of Design Patterns in the world of Software Engineering.

This lecture provides a quick-fire introduction to the evolution of Programming Languages, and also indicate the evolution of Design Patterns in the field of Software Engineering. The subject of Design Pattern, by this name, didn't exist till the early 1990s. Evolution of unstructured, structured and object oriented languages changed all that. This video highlights the the importance of aspects such as Coding Discipline, Principles (of application development) etc. and how they help realize the importance of Design Pattern in the professional life of application developer today.

This lecture brings out the problems and issues that are encountered by a typical software application development professional, in his/her career. Like any other engineering field, the Software Engineering field also expects that the professional needs to deliver an acceptable application that meets the general requirements - such as Robust, Performant, Secure, Elegant application. A developer must ensure that the developed code has the right mix of art, science and engineering to deliver theses requirements.

You already know that discipline is a foremost attribute that must be inculcated by any professional in this/her field of professional work. Coding discipline is the most important attribute that any Software Developer must inculcate to deliver any application. This video emphasize on the importance of coding discipline for the software developer, and at all levels of Software Development Life Cycle.

This lecture, in continuation with the previous one, warns the software developer on the dangers of generating STUPID code. When a negligent, unorthodox and an amateur programmer attempts to application development, one can see a number of problems exploding at every level of SDLC. This lecture sums up some of the most commonly occurring problems as STUPID Coding Practices, and warns the developer of such pitfalls. Also, this lecture suggests some of the guiding principles, referred to as SOLID principles, that can be remembered and applied, while attempting to develop software applications. The lecture also suggests that how these principles act as the foundation to learning the subject of Design Patterns.

This lecture introduces the student to the field of Software Design Patterns, and tracks its evolution. This lecture introduces the professionals behind those who have contributed to the field of Design Patterns. This lecture also indicates the different Schools of Thought that are existing and relevant in the modern-day software application development scenario, and help the student focuses on the main School of Thought, before attempting the learnings of actual design patterns.

This lecture introduces you to the fundamental aspects of Design Patterns Classification, based on the work of Gang of Four (or GOF). It also lists the topics covered in the remaining lectures of the section. At the end, this lecture also sets the expectation of a student on features, limitations and other constraints that must be kept in mind, while going through the rest of the lectures and sections.

Classifications in the field of Software Design Patterns essentially represent the school of thought behind the work on classification. This lecture covers the classification work, based on four individual professionals - Eric Gamma, Richard Helm, Ralph Johnson and John Vlissides. Other schools of thought are also mentioned in this lesson. 

This lecture focuses on three important aspects behind the classification work - creation, structure and communication. Any software application has a varying part of all these three aspects predominantly present. This lecture, buckets the design patterns into these three buckets to point out the importance and relevance of the classification work.

Cataloging is an important and fundamental aspect in any work of classification or categorization. This lecture highlights the importance of cataloging, and indicates why and how the task of cataloging helps in the understanding of software design patterns.

This lecture provides a top-level description on the first of the classification arm - the Creational Design Patterns. This lecture brings out the importance of types of creations of objects and componentss that typically occur in a software application, and provides a top-level definition of each of the five creational design patterns.

This lecture describes the second arm of the classification of the design patterns - the Structural Design Patterns. This lecture emphasizes on the importance of the structure of the application - in terms of the ensemble of objects and classes. Apart from listing the structural design patterns, this lecture provides a simple and working definition of each of the structural design patterns.

This lecture provides a top-level description on the third and the important arm of the design pattern classification - the Behavioral Design Patterns. This lecture also indicates the importance of this design pattern, as a maximum number of design patterns are classified into this bucket.

This lecture lists a set of disclaimers for the students, in terms of expectations on what all design patterns can do, and what are their limitations, and what to expect from them. This lecture also indicates how and what to handle, bringing in the perspective of the software application, its boundaries and limits.

This lecture is a quick introduction to the topic of Creational design pattern category. This lecture also introduces you to other important related topic - introduction to the Unified Modeling Language. Also, this lecture provides the structure of how the individual design patterns are covered in this section.

Since this course has been designed to be platform independent, the best approach to the understanding of this subject would be through the use of UML diagrams. This lecture helps as a quick-fire 10 minute tour on the UML, and help you as a refresher course. Similar UML diagrams would be used in the rest of the course. Of course, most of the design patterns exercises covered are also realized into conceptual level Java applications, demonstrated on the eclipse IDE.

This lecture is a prelude to the Creational design patterns Section. Normally the design patterns are covered in the alphabetical fashion. However, in this Section, I have deviated a little bit, and reason is dependency. This lecture also covers some notes on the demo / hands-on exercises part, wherein the Eclipse setup and pre-requisites are indicated.

This lecture, covers, in detail, on the topic of Factory Method design pattern. This is one of the simplest and most most frequently used creational design patterns, for creating objects, classes and components. This lecture provides a detailed description of the pattern, along with examples. This lecture also highlights the related design patterns, that is of importance. The resource for this lecture include a simple example eclipse Java project that can be imported, tested and suitably modified to have a enhanced understanding of the subject.

This lecture covers another important creational design pattern, which will help in creating a number of different product suites. Again, this lecture also covers an interesting example, along with a hands-on example. The resource included for this design pattern is an eclipse project that can he imported, tested and modified to have a deeper understanding of this design pattern.

When one encounters the need for building complex products from the simple one, this pattern becomes important. This lecture helps the student understand the importance of building or assembling of objects as against creating. The example provided here helps in building complex products such as (customized) computer product. The included resource helps the student to import the eclipse project, test, modify and have better understanding of the design pattern.

Prototype is essentially copying or cloning. This is a faster route to create objects, specifically, when large objects needs to be created and quickly. This lecture also highlights, how the platforms such as Java has inbuilt features with the help of which cloning can be easily done. This lecture also help you understand how to ensure that the cloning process has resulted in generating the right type of prototypical objects. The resource can be used by the students to understand how to clone a sheep object.

This lecture helps the students to understand the concept of Singleton, and its merits as well as disadvantages. The lecture provides how, in a step-by-step way one can create a Singleton object. This lecture also help the student to understand how exactly singleton objects needs to be shared in a multi-client environment. This lecture also includes a resource with the help of which the student can have a hands-on route to understand the singleton design pattern.

This lecture is a short introduction to the subject of Structural design patterns. It lists 7 structural design patterns, and impress on the importance of the physical structure of the objects and classes help in creating software applications.

This lecture covers the first of the structural design pattern - the adapter. With some suitable examples, this lecture helps the student understand the how this design pattern makes two incompatible object to form a structure and operate. The hands-on exercise covered in this eclipse lab is provided here as a resource for the student to practice and understand how this design pattern works.

A bridge connects the gap between two ends of a valley. This is the concept that is discussed in this lecture, and show how an interface supports the implementation that are functionally different. The resource provided in this lecture helps the implementation of Persistence concept with two completely different implementations - SQL implementation and NoSQL implementation. The resource enclosed, which is an eclipse project, in this lecture help the student to understand how bridge design patterns brings functionally different implementations together.

This lecture provide a detailed description on the composite design pattern. Composites, in Software Engineering field, are the tree structures, and are very useful in building composite structures. Almost all domains require tree structures, and this lecture helps you how to build and maintain tree structures, using the composite design pattern. The eclipse project, enclosed as a resource, will help student to hands-on experience to play around with tree structure, and traverse along the branches, leaves, sub-branches etc.

Decorator is a beautifier. With the same meaning this design pattern helps in decorating an object, without touching the underlying implementation of the object. This design pattern also shows you how to decorate an object with multiple decorators, and add value to the underlying object. The enclosed eclipse project helps the student has a hands-on exercise to realize the concept of Decorator design pattern.

Facade design pattern are frequently encountered design pattern in today's online business world. This lecture discusses how simple and plain looking web applications hide complex operations and help the client of the application to smoothly carryout his task. The demo covered in this lecture shows how a travel reservation web portal presents a prefect facade design pattern concept.

This lecture provides a peek into the gaming world and how they leverage the concept of flyweight design pattern to optimize resources and enhance the performance of the gaming and similar applications. This lecture also clarifies concepts of intrinsic and extrinsic states of the objects and help realize the importance of managing them, particularly when a large number of similar objects needs to be used and managed in an application.

This lecture helps the student understand the power of proxy and realize the ability of remotely managing application components. This lecture is packed with demo as well as hands-on exercise to reveal the concept of proxy design pattern. The enclosed small project on eclipse will help the student to have a hands on experience on this design pattern and realize the concepts.

This short lecture provides a quick introduction on the behavioral design patterns and show the generic strategy used to cover the patterns occurring in this section.

This lecture provides a how to handle the passing of message along the chain of objects. This lecture also helps the student how to use this Chain of responsibility (or chain of command) design pattern when there is a need to handle a set of different objects, and there is a need for a different action for different objects. The enclosed eclipse project will allow the student to handle different types of objects such as String, int, double, or even null. 

This lecture explains the command design pattern, with the example of very familiar Macros that is used in the office document software products such as word, excel or other similar products. A command or a key stroke in macro can result in running as a series of sequentially executed commands. The hands-on exercise discuss about how to apply this design pattern in situations such as stock and mutual fund trading system. The enclosed eclipse project will  be of help for the student to realize the power of this design pattern.

This lecture provides a detailed description on the interpreter design pattern. Importance of language, grammar and interpretation of the same is explained in this lecture. Implementation strategies of this design pattern at low level, such as search or search and replace is covered. The example exercise enclosed as a resource, as a part of this lecture, is an example that help in building language rules and using them to interpret the languages.

Iteration is a very common requirement in any field. Where ever collection of objects and primitives are present, iteration is given. This lecture covers the importance of this concept and highlight how to create custom iterators and iterate them, without affecting the collection objects. The enclosed eclipse project shows how to build the collection objects and iterate them to sequentially access them.

Mediator is a broker, in simple terms. In this lecture, the mediator design pattern is covered with the help of demos and examples. This design pattern promotes loose coupling between different interacting objects. The demo on this design pattern cover the familiar handling of this concept in office products such as word processor. Loosely coupled attributes in the word processor can help in marking some test as bold, some as italic, some with color and some with font, size and so on. The hands-on exercise, on the other hand, helps the student realize how the real-estate broker brings about communication among interested parties in a group of people (called colleagues).

This lecture covers, in detail, the Memento design pattern. Memento, specifically, helps in capturing the internal states of the object. During the course of the runtime of the application execution, an object could change its internal attributes, but at some point in time, we need to restore the real state of object. This can be elegantly achieved by the Memento design pattern. The demo packed in this lecture reveals the power of this design pattern, that is packed in the office document applications such as word or power point. A series of Control+Z key can keep restoring the status of the document to different state at that point in time. 

This lecture covers one of the most important design pattern of the modern-day times - the Observer design pattern. This lecture helps the student realize how this design pattern help in creating application, where there are independent objects and dependent objects. When the attributes of independent object changes, their state changes. This is notified to all those dependent objects, and they also appropriately react. This concept is also covered in the hands-on-exercise, and the student can use this eclipse project to learn by playing around with the examples such as online stock trading.

In this lecture, the state design pattern is covered in detail. The lecture covers the day-to-day examples such as NRC or Runtastic to conceptually explain, how to capture and exploit the state changes in an object - running, resting, pausing, stopping etc. This lecture also covers a hands-on exercise that builds a similar application that captures the movement of an athlete. The resource is available to the student to understand and practice on this design pattern.

When there are multiple algorithms available for solving a specific problem, which is the best one to go with? This kinds of problems are solved by Strategy design pattern. This lecture covers the subject of strategy design pattern, with appropriate examples. The hands-on exercise specifically covers the strategy to use the output format, depending on the client demand - HTML output, as desired by the browsers, XML output as desired by integrating applications, or even in the form of JSON. This exercise is available for the student to try out different output strategies.

This lecture covers the Template Method design pattern. This is one of the simplest design patterns, and helps you to build powerful applications that can he appropriately implemented by the down-the-stream developers, who implement the abstract methods, as demanded by the application. This lecture also covers a hands-on-exercise that will help you to implement this design pattern.

This lecture covers one of the frequently used design pattern in the implementation of Shopping cart kind of applications. With suitable examples, this lecture helps the student realize the power of concepts such as Visitor and Visitable, and help in implementing the concept via building a miniature shopping cart application. The eclipse project, enclosed as a part of this lecture, helps the student to understand and appreciate the usefulness of this design pattern in the shopping cart world. 

This lecture provides a short introduction to the world of design pattern, outside the purview of the world of Gang of Four. This lecture also hints about the evolution of platform or language dependent design patterns, as well as the contributions from other sources.

This lecture elaborates, at a very high-level, on platform or programming language dependent design pattern. As a popular example, this lecture covers the Core J2EE design pattern, and its classification.

In this lecture, the contribution from other professional individuals are discussed and highlighted. Contributions from Martin Fowler and Gregor Hohpe is discussed briefly in this lecture.

This lecture summarizes the subject of Understanding Software Design Patterns. The lecture covers the problems that are faced by the developers as a prelude to the need for adopting design patterns. Also, this lecture highlights all the patterns that are covered by the GOF classification, including the importance and relevance of classification.