Course Description

Language of Instruction:English|Category: Computer Graphics

 

Experience high quality learning at fraction of a cost of most providers!

 

Most of the providers charge $1500 or more for such a course.

 

After completing this course you will be able to construct better distributed applications using collective real-world knowledge. The attendees would be able to design and influence their development teams with a common terminology, a common programming methodology, and a shared point of reference for analysis and design.

 

You should enroll in this course to:

 

• Understand how to design real world applications using design patterns
• Upgrade your knowledge to the next level and get promoted
• Demonstrate your ability to design applications

 

This course provides you with enough time to understand all concepts and complete exercises to further enhance your knowledge.

 

This course is structured in 8 classes of 2 hours each, spread across 3 weeks. Each class describes the concept using “tell a story” model where you first learn theory with examples and ask the students to complete relevant exercises to get a grip over the concepts. This course is unique as it offers in-depth knowledge of design patterns without rushing you to grasp in everything at one go. It promotes thinking and application of design patterns using the exercises.

 

This course is ideal for developers who have spent 3-6 years in programming field and are not getting opportunities to get promoted to the next level because of lack of designing skills. This course can also help people who want to understand how to best utilize design patterns in solving real world problems and how to promote unified development terminologies for doing software development or code refactoring.

 

Course details:

 

• 8 classes of 2 hours each
• 2 Tests with multiple choice questions and 1 code scenario to refactor
• This course will run during 6:00 PM IST – 8:00 PM IST on Monday, Wednesday and Friday

 

What does the course cost?

 

The course is very economically priced. Most of the providers charge $500 or above for an advanced course like this. However, this course is available at a special price of $99 pm on WizIQ.

 

Course outline:

 

Class 1: Why Patterns and Introduction to UML

 

This chapter discusses the reasons why you should study design patterns. Design patterns offer the ability to reuse solutions, not just code. By reusing already established designs, you get a head start on problems and avoid gotchas, you benefit by learning from the experience of others, and you don’t have to reinvent solutions for commonly recurring problems. Design patterns establish a common terminology allowing developers to use a common vocabulary and share a common viewpoint of the problem. Design patterns provide a common point of reference during the analysis and design phase of a project. The course will use UML as a means to communicate pattern intent, and this chapter introduces key UML concepts.

 

Class 2: Singleton and Factory

 

Singleton
Few solutions require the use of a single object instance across the whole solution, for example naming services or cached objects. This chapter will introduce the singleton pattern as a solution, along with variations for thread safety, and other varieties of single instance based on thread affinity.

 

Factory
There are occasions when you want to decouple the knowledge of which type to create from the client code that creates that type. Factories allow you do this by encapsulating the necessary knowledge of how to create the object thus allowing the actual implementation used to vary at runtime. Factories are useful for building pluggable architectures and for creating application extension points.

 

Class 3: Decorator and Observer

 

Decorator
One of the key design pattern goals is to write code that is closed for modification and open to extension. This pattern shows that an object’s behavior and responsibilities can be extended at runtime, as opposed to design time using inheritance. This allows us to combine a variety of behaviors far more efficiently that normal inheritance. Examples of decorators in the framework are BufferedStream, SynchronizationWrappers, and XmlValidatingReaders. We will examine how to create and use decorators.

 

Observer
The ability to notify interested entities of changes to an object state is a fundamental requirement of most object-oriented solutions. There are many ways to do this, but there is a danger that we will build a tightly coupled system and we prefer to build a loosely coupled system. The typical way of implementing the observer pattern is to use interfaces, but here we show that delegates and events are a far more flexible and efficient way of implementing the pattern on the .NET framework.

 

Class 4: Strategies and Templates
What we can be 100% sure of with software is that it constantly needs to evolve. What we also know is every time we change existing working code there is a risk that we break it. What we need is an approach that allows the software to evolve without having to modify existing working code. The strategy and template patterns allow us to build solutions that can evolve without the risk of effecting existing well-tested code.

 

Class 5: Command I and Command II and State
Command I
In this chapter, we examine the command pattern. The command pattern allows us to encapsulate invocation, allowing the invoker to be decoupled from the client and the recipient, this enables us to build a variety of different invokers to deliver custom thread pooling, and invocation logging to build fault tolerant solutions.

 

Command II
In this chapter we extend the command pattern to not only encapsulate forward invocation but also undo invocation, allowing us to build a complex undo sequence through a series of simple undo commands. This pattern can then be combined with transaction support inside .NET to build transaction aware types.

 

State
In many cases object behavior depends on the state an object is in. When the state of an object changes the behavior of the object also changes. This is typically modeled through the use of finite state machine. This pattern provides a means to map a finite state machine into a series of classes where each class represents a different state, thus providing different behaviors. This approach allows us to add new states and transitions without effecting existing code, continuing the theme of being closed for modification, open for extension.

 

Class 6: Adapter and Facade
Client's code is often written against a specific interface. As classes evolve, interfaces may change and the client needs a way to adapt to the changing interface. If there are many clients this would result in a lot of dangerous change. The adapter pattern solves this problem by building an adapter that can convert calls from one type hierarchy to another. Facade allows us to simplify an interface by providing more course grain operations; this is typically used for remote access to reduce the number of roundtrips.

 

Class 7: Iterator, Composite, and Visitor
There is often a need to touch and process every object inside an object hierarchy, for example walking over user interface control objects, XML documents, business entities, file systems, etc. The iterator pattern provides a standard means to achieve this. .NET provides a standard implementation of iterator, further the C# language simplifies the implementation further through language extensions. The visitor pattern gives us the ability to layer behavior onto the hierarchy without the need to change the underlying implementation of the hierarchy, continuing the theme closed for modification open for extension.

 

Class 8: Anti Pattern and Best Practices

During software development, we often come across common recurring problems in our code. These can be categorized as anti patterns. In this chapter, we will look at common anti patterns and how to fix them and avoid them.

 

*All students will need to purchase First Design Patterns by Elizabeth Freeman - easily available everywhere!