Move from Junior to SENIOR with these 7 Applications

Welcome everyone to a new post for the channel. In this post, we're going to look at 7 apps that will allow or help you learn to program in the language of your choice.

First of all, I want to mention that doing these 7 apps doesn't mean you will instantly move from a junior to a senior level, but they will give you the knowledge you need to progress from one level to another.

The code examples are written in C#, but honestly, it doesn't matter: just use whatever language you want to learn.

1 - Basic projects to learn programming

So the first project I'm going to suggest is a Hello World. Making a Hello World might seem simple and silly, but it's not that easy: you need to install everything necessary to make that output on the screen, and this could take you a couple of hours. 

Once you have everything set up correctly, the next thing to do is to continue with basic programming where you should understand what variables are, operators, or how to debug;

An example of this kind of project could be the Fibonacci sequence, which is very popular and can be done in different ways. Here is an example.

public static int Fibonacci(int n)
{
    if (n <= 0)
        return 0;
    else if (n == 1)
        return 1;
    else
        return Fibonacci(n - 1) + Fibonacci(n - 2);
}

Or its iterative form, which is much more efficient for large numbers

public static int Fibonacci(int n)
{
    if (n <= 1)
        return n;

    int fib = 1;
    int prevFib = 1;

    for (int i = 2; i < n; i++)
    {
        int temp = fib;
        fib += prevFib;
        prevFib = temp;
    }

    return fib;
}

Once you have this project working, you can move to the next level: do something simple but at the same time very rewarding. In my case, I choose the Snake game or Snake. 

• You have the code available on GitHub.

To do this exercise, you will need to know what classes and objects are at a basic level. Optionally, you can add the feature that the highest score is saved in a file with the date, so you will have worked with files and dates.

Personally, I think this is the basic level of programming because, as I said, it includes basic object-oriented programming knowledge, use of arrays for the size of the snake, and files and dates for the score. 

2 - Intermediate projects to improve programming

For the intermediate projects, we're going to move to a second level. We're no longer going to work with the most basic elements of the language, but instead, we'll look a little more in detail. Within object-oriented programming, we'll work with interfaces, inheritance, polymorphism, concurrent or asynchronous programming.

An example of an intermediate level exercise for me is simulating the operation of a barbershop/hairdresser.

At a barbershop, we have the barbers who cut hair, and then there are customers who need a haircut. Of course, each one takes a random amount of time; they're not all going to take the same.

For example, the first customer might take 1 hour for his particular haircut, while the second takes 15 minutes and the third 25 minutes. 

If we have two barbers, one will be busy while the second one deals with the second and third customer and starts with the fourth.

To do this exercise, you will need knowledge about concurrency and threads, which in .NET is done with the Task class. Here is a post about asynchronous programming in C#.

This could be an example, where we have a number of barbers and a predefined number of clients:

Console.WriteLine("Welcome to the barber shop!");
int barbers = 2;

ConcurrentQueue<Client> clients = new ConcurrentQueue<Client>() { };

foreach (int i in Enumerable.Range(0, 10))
{
    NewClient(i);
}

await DoWork();


void NewClient(int number)
{
    Random random = new Random();
    clients.Enqueue(new Client($"Client {number}", random.Next(1,10)));
}

async Task CutHair(Client client)
{
    Console.WriteLine($"The {client.Name} started to cut his hair");
    await Task.Delay(client.TimeInSeconds * 1000);
    Console.WriteLine($"The {client.Name} finished in {client.TimeInSeconds} seconds");
}

async Task DoWork()
{
    List<Task> workingBarbers = new List<Task>();
    while (clients.Any() || workingBarbers.Count>0)
    {
        while (workingBarbers.Count < barbers && clients.TryDequeue(out Client client))
        {
            Task barberTask = CutHair(client);
            workingBarbers.Add(barberTask);
        }
        Task freeBarber = await Task.WhenAny(workingBarbers);
        workingBarbers.Remove(freeBarber);
    }
}

record Client(string Name, int TimeInSeconds);

But we can complicate it a little further, modifying the code so new customers arrive while we're cutting the hair of customers already at the barbershop. 

Here is an example:

using System.Collections.Concurrent;

Console.WriteLine("Welcome to the barber shop!");
int barbers = 2;
bool isBarberShopClosed = false;

ConcurrentQueue<Client?> clients = new ConcurrentQueue<Client?>() { };

foreach (int i in Enumerable.Range(0, 10))
{
    NewClient(i);
}


await Task.WhenAll(AttendClients(), MoreClients());


void NewClient(int number)
{
    Random random = new Random();
    Console.WriteLine($"New Client {number} arrival");
    clients.Enqueue(new Client($"Client {number}", random.Next(1, 10)));
}

async Task CutHair(Client client)
{
    Console.WriteLine($"The {client.Name} started to cut his hair");
    await Task.Delay(client.TimeInSeconds * 1000);
    Console.WriteLine($"The {client.Name} finished in {client.TimeInSeconds} seconds");
}

async Task AttendClients()
{
    List<Task> workingBarbers = new List<Task>();
    while (clients.Any() || workingBarbers.Count > 0)
    {
        while (workingBarbers.Count < barbers && clients.TryDequeue(out Client client))
        {
            Task barberTask = CutHair(client);
            workingBarbers.Add(barberTask);
        }

        Task freeBarber = await Task.WhenAny(workingBarbers);
     

In C#, we're lucky because all the thread and concurrency stuff is behind the Task type, which greatly simplifies the work, but in other languages it can be more complex.

• You have the code available on my GitHub.

As an exercise to understand concurrency, I think it's very good. 

The second project that I consider intermediate level is one that is very useful for the real world and business applications: 

Create a Forum or a Blog like this one where you're reading this post. 

Personally, for practice, I think a forum can be more complete, as you have several users (sessions), you will need to include a database as well as provide features such as locking threads so no one can reply or only admins can, categories, etc. 

Initially, you should make the application Full Stack, meaning all in one language, as a single monolithic application, for example in ASP.NET Core, keeping the layers separated using hexagonal architecture. 

Then, try to dive into a front-end technology, either Blazor if you want to stick with .NET or go for JavaScript technologies like Vue, React, or Angular.

Also, this step will lead you on the back end to implement an API which is very important nowadays, as that's where 90% of Backend jobs are. Make sure your API handles all HTTP methods (GET, POST, PUT, DELETE), provides consistent responses, and is well documented.

As you can imagine, this project is VERY big and can take you from a week to several months, depending on how many hours you dedicate each day. 

And don’t forget to write tests, as they are a fundamental part of development.

2.1 - Intermediate programming in a specific language

Another way to understand intermediate programming, or even advanced programming, is by focusing on a specific language, not just the general concepts of making a blog or forum, but by understanding what an indexer is and how it works in C#, or what a Dictionary in C# is and how it's different from a List.

When we talk about intermediate programming, I understand it this way: we have two options. One is about a specific language, and the other is a more global scope, completely independent of language. 

3 - Advanced projects to take you to the next level

In this section, I have two main projects.

The first one could be a real-time application or game. I'm not saying you should create Clash Royale, but you can make a game where two users play Parcheesi or cards. A version of poker or blackjack where you play with a friend could be a great example.

You will have to touch technologies that you already encountered in the blog/forum version, like server-side languages or databases, but you'll also need to gain some knowledge of websockets and how they work. 

• In .NET you can do this with SignalR. 

Finally, the one that, for me, can open the most doors for you professionally is a distributed system, which is key in today’s business world. 

Start by making a web shop where products are created, orders are created, and the products are sold. You can do this with microservices. In the first version, you have to include the same ideas as you did for the forum or blog, but in a distributed way. For example, you will no longer maintain sessions; instead, you’ll have a JWT token. 

Then, once it’s running with microservices and works correctly, continue with truly asynchronous architectures, such as including a service bus for communication, abstracting credentials, logs, monitoring, etc. 

You must be able to set everything up on your machine with containers (e.g. docker) or even set it all up in Kubernetes using helm.

• On this blog, I have a course on distributed systems you can access here.  

If you are able to master all the projects I have proposed, you will most likely never have a problem finding a job. 

Give it your best shot!