BadproG.com

In this tutorial we are going to see how two computers can communicate with each other through the SSH protocol.

Why do we need SSH keys and how to use them?

We will use one computer as Server and another one as Client.

What is really annoying is to do again and again the same task without having something new to do.

Set a Visual Studio project is one of this thing that you would like to automatize.

The property manager allows us to do this kind of mechanism.

The Command design pattern creates a list of objects on which we're going to apply a generic method.

It's a bit unusal because an object will request a method as parameter.

This makes the Command design pattern a versatile one but maybe not so easy to handle at first.

The Memento design pattern allows an object to retrieve last states of another object.

This is used for example in the undo mechanism.

So it's a very interesting pattern that doesn't use any interface.

But instead it uses an opaque pointer in order to store old states of the main object.

The Strategy design pattern allows to change behaviour of a program depending on a context.

It means that a single class can manage many others without knowing that those classes even exist.

Interesting isn't it?

Let's see that in this Strategy design pattern tutorial.

The Proxy design pattern is in charge of managing another class.

It's like a firewall that you cannot overstep.

There are several reasons to use a Proxy instead of directly another class.

The Mediator design pattern allows to unlink objects from each other.

It's like a manager that centralizes every action performed by a component in order to dispatch these events to all other objects that need to know information.

It could be seen as a design pattern quite accessible in term of complexity.

The move template function allows to change an object owner.

We're not going to dive in the heart of the move semantics because it's a quite complex subject.

Instead we're going to see a really easy example of how it works.

Let's get started.

The Decorator design pattern allows an object to be decorated in different ways not by inheriting from another class but by adding features directly to this object.

It's main interest is to avoid multiplication of classes that would be almost the same as the main one.

The Prototype design pattern is used in order to clone an object.

Main goal to prototype design pattern is to create new objects with default values.

This cloning operation is actually a copy of an object and can be made with a shallow or a deep copy.