Interested in a private company training? Request it here.
When software development first came to life. People that wanted to start developing, obviously had no prior knowledge. Thus, everyone started applying their own ways of how they thought software should be written. The SOLID principles were introduced by Robert C. Martin (a.k.a Uncle Bob) in 2000. The intention of these principles is to make software designs more understandable, easier to maintain and extend. These principles are essential for every developer to know, because it will help them in writing better code an better understanding other code that was written with these principles in mind.
One might not believe it, but design patterns do not find their origin in software architecture. Patterns were first described in the 1970s by a real "Bricks and Stones" architect. A pattern is defined as a re-usable solution to a common type of problem, without ever repeating the actual way the solution is implemented. This means that patterns are an ideal learning tool and also ideal for communicating design ideas. Of course there are also anti-patterns, things often used, but actually better avoided.
When creating software, you feel yourself continuously creating new objects. Although the basic form of creating new objects is not bad, it can result in design problems or added complexity to the design. Creational patterns will help you deal with object creation that is suitable to the situation.
Once your objects are created, they start interacting. When you're not careful, these interactions can quickly start leading into code that is tightly coupled. Behavioral design patterns help identifying common communication patterns between objects and realize these patterns. By correctly applying these patterns, you can increase flexibility in carrying out the interaction between objects.
When writing code, you have to make sure you are not introducing unnecessary dependencies on other objects. Dependencies will just cost you on the long run since they are harder to maintain, not easily testable, exchangeable, ... . If you need to depend on another, then depend on the interface. Interfaces describe the dependency, but do not force it. Now, you don't want those dependencies to be filled hard coded and this is where dependency injection (DI) can help you. Dependency injection can help you at runtime dynamically deciding which implementations to plug into the dependencies.
Created objects do not tend to stand on their own. No, they start encapsulating other objects trying to create structure in, what otherwise would be a chaotic software environment. Structural patterns help at identifying and setting up relationships between objects.
Programming languages also use a bunch of patterns in their implementation. In this chapter you will build your own little programming language, which is extensible by the way. While doing so you will discover and apply some very important patterns which are perfectly useable outside of the scope of building programming languages!
Most developers make lousy graphic designers. That is why we see the emergence of patterns that allow developers to focus on writing code to implement the behavior of the application, while allowing graphics designers to build kick-ass user interfaces. The main pattern is called Model-View-*Whatever*, with *Whatever* replaced depending on the technology you are using. Understanding the MVW pattern is important as it is used to develop both windows and web applications.
Have you ever heard of Reactive Programming? This is an important new development where you learn to program using Observables. You will learn to apply this technique to solve some common, hard-to-solve problems with classic Object-Oriented Programming, and we will also explore the Redux pattern.
Every developer's dream: maintainable code that works. How do you keep your code maintainable? And how do you ensure some small change does not break your code? Unit testing to the rescue!
In this chapter we will look at building unit tests with the built-in features of Visual Studio.
When do you need patterns the most?! When you are building a framework yourself. Building a framework means handling new features while keeping backward compatibility. This very hard task can be make easier with the proper use of patterns. So in this last part of the training we will build a reusable library, and while doing so encounter some problems and then solve these problems by applying the right pattern.
So how can you become a better developer? One of the best ways is by learning design patterns. Design Patterns provide reusable solutions to solve common software design problems. In this training we identify software design problems and see how to address these using the best suited Design Pattern. This course teaches you the art of building maintainable and testable code through unit testing. We will also look at modern C# language features, S.O.L.I.D. principles, and apply what we've learned. Modern day developers should also know about Reactive Programming which makes certain complex problems a breeze to implement. Finally we finish building a reusable library always keeping things like backward compatibility and developer ease-of-use in mind!
This course is intended for experienced programmers who are very familiar with VB.NET or C# and have a working experience with the .NET Framework.