DEV Community: Rafael Ahrons

Using MongoDB with Docker

Rafael Ahrons — Tue, 13 Jul 2021 01:40:56 +0000

Using MongoDB with Docker

What you need to have installed:

Docker

With you want to learn more about Docker, you can check my blog post about it by clicking here

Downloading MongoDB Image

docker image pull mongo

Run a container

docker run -e MONGO_INITDB_ROOT_USERNAME=root -e MONGO_INITDB_ROOT_PASSWORD=root -p 27017:27017 mongo

Change password and username for a suitable for you

What this command does

It will initialize your container and show you the logs while is initializing, so you can track if some errors appear in the console log.

-e will add MONGO_INITDB_ROOT_USERNAME environment variable with the value root. With that, your username to connect will be root.

-e will add MONGO_INITDB_ROOT_PASSWORD environment variable with the value root. With that, your password to connect will be root.

-p will share your local port with the port of the container. 27017 is the port that mongodb use.

Executing the same mongodb container after ended

You need to get the container ID from your mongodb container.
```
docker container ps -a
```
With the container Id, now you can enter using the following command:
```
docker start containerId
```
It will enter inside the container with a bash terminal executing.

Testing your connection

Testing your connection

You must have some program to connect with MongoDB. You can use or Mongo Compass or Robot3 or the one you prefer.

To connect you will need a connection string.
```
mongodb://root:root@localhost:27017/admin
```
This is the connection string to connect inside mongodb of our container.

What does that connection string means:

First root is the username (if you changed, you must change in the connection string as well)
Second root is our password (if you changed, you must change in the connection string as well)
After @ is the IP you are trying to connect and the database that holds your user.

References

Using MySQL with Docker

Rafael Ahrons — Tue, 13 Jul 2021 00:48:48 +0000

Using MySQL with Docker

What you need to have installed:

Docker

With you want to learn more about Docker, you can check my blog post about it by clicking here

Downloading MySQL Image

docker image pull mysql:5.7

Run a container

docker run -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -v folderForVolume:/var/lib/mysql mysql:5.7

Change folderForVolume for a path from a folder to create the volume.

What this command does

It will initialize your container and show you the logs while is initializing, so you can track if some errors appear in the console log.

-e will add MYSQL_ALLOW_EMPTY_PASSWORD environment variable with the value yes. With that, you can enter in mysql without a password.

-v will create a volume with the container to share some data between your pc and the container. With this, you will be able to create another container with the same data without losing any tables or queries.

Entering the container

You need to get the container ID from your mysql container.
```
docker container ls
```
With the container Id, now you can enter using the following command:
```
docker exec -it containerID bash
```
It will enter inside the container with a bash terminal executing.
Enter MySQL
```
mysql
```
If it works, then will show in the console that you are inside the mysql. To test just execute a

show databases

to check.

References

Testing with XUnit and Moq

Rafael Ahrons — Mon, 17 May 2021 16:40:40 +0000

Testing with XUnit

In this article we will learn how to test your Web API with XUnit.

What is XUnit

Is an open source tool for testing C# applications.

How to configure

First you need to initilize your project:

   dotnet new webapi -n MoqXUnit

Then you need to initialize a XUnit project for testing

 dotnet new xunit -n MoqXUnit.Test

This command will create a Test Project on your root folder.

Now you need to add MoqXUnit project reference to MoqXUnit.Test

 dotnet add MoqXUnit.Test reference MoqXUnit

Having the reference you can access classes from the other project. In another words, now you can test them.

Now we conclude the configuration part. Let’s make some tests.

Testing

Let’s add some features to ours MoqXUnit Web API.

Create another controller calling CalculatorController inside MoqXUnit/Controller folder and add this code.

using Microsoft.AspNetCore.Mvc;

namespace MoqXunit.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class CalculatorController : ControllerBase
    {
        [HttpGet]
        public ActionResult SumTwoNumbers([FromQuery] int num1, 
                                          [FromQuery] int num2)
        {            
            return Ok(num1 + num2);
        }
    }
}

SumTwoNumbers endpoint will only sum two numbers. Now let’s add some tests.

Inside MoqXunit.Test add a .cs file and add a code more like:

using System;
using Microsoft.AspNetCore.Mvc;
using MoqXunit.Controllers;
using Xunit;

namespace MoqXunit.Teste
{
    public class CalculatorControllerTest
    {
        [Theory]
        [InlineData(1, 2)]
        [InlineData(1, 5)]
        [InlineData(1, 6)]
        [InlineData(10, 2)]
        [InlineData(1999, 2)]
        public void Sum_Two_Numbers_using_theory(int num1, int num2)
        {
            //arrange
            CalculatorController controller = new CalculatorController();
            int expected = num1 + num2;

            //act
            var response = controller.SumTwoNumbers(num1, num2).Result as OkObjectResult;

            //assert
            Assert.NotNull(response);
            Assert.Equal(response.Value, expected);
        }

        [Fact]
        public void Sum_two_numbers_using_fact()
        {
            //arrange
            CalculatorController controller = new CalculatorController();
            int num1 = 1;
            int num2 = 2;
            int expected = num1 + num2;            

            //act
            var response = controller.SumTwoNumbers(num1, num2).Result as OkObjectResult;

            //assert
            Assert.NotNull(response);
            Assert.Equal(response.Value, expected);
        }
    }
}

XUnit has two types of anottations to say that this method is a Test Method: Fact and Theroy.

Fact for methods with invariant data.
Theory with variant data and those data is set by using InlineData anottations.

Using Asset Methods you can validade the results from your test. Go check the available ones.

Using Moq

Moq is a library to Mock some interfaces to make testing easier.

How to add to your test project

you can just execute the following command:

dotnet add .\MoqXunit.Teste\ package Moq

Change .\MoqXunit.Teste\ to the name of your project.

Now you have it installed.

How to use Moq

You gonna use to mock some integrations that you don’t want to execute in your test, like, databases.

Let’s create a folder inside MoqXunit project called Interfaces and add a interface for a ICalculatorRepository.cs We are not implementing calculator repository, it’s just an example.

using System.Collections.Generic;
using MoqXunit.Models;

namespace MoqXunit.Interfaces 
{
    public interface ICalculatorRepository
    {
        IEnumerable<Calculation> GetAllCalculations();
        void SaveCalculation(Calculation calc);
    }
}

And let’s create this Calculation class:

namespace MoqXunit.Models
{
    public record Calculation
    {
        public int Value1 { get; init; }
        public int Value2 { get; init; }
        public int Result { get; init; }

    }
}

Now let’s make some changes in our code to use this interface and calculation class.

using System.Linq;
using Microsoft.AspNetCore.Mvc;
using MoqXunit.Interfaces;
using MoqXunit.Models;

namespace MoqXunit.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class CalculatorController : ControllerBase
    {
        private ICalculatorRepository _repository;

        public CalculatorController(ICalculatorRepository repository)
        {
            _repository = repository;
        }

        [HttpGet]
        public ActionResult SumTwoNumbers([FromQuery] int num1,
                                          [FromQuery] int num2)
        {

            var allCalculations = _repository.GetAllCalculations();
            if (allCalculations.Any(e => e.Value1 == num1 && e.Value2 == num2))
            {
                return Ok(allCalculations.First(e => e.Value1 == num1 && e.Value2 == num2));
            }
            else
            {
                var calculation = new Calculation
                {
                    Value1 = num1,
                    Value2 = num2,
                    Result = num1 + num2
                };

                _repository.SaveCalculation(calculation);

                return Ok(calculation);
            }
        }
    }
}

We add ICalculatorRepository as a dependency to our controller, and add a few changes on SumTwoNumbers to use GetAllCalculations and SaveCalculation method. Now we have this endpoint that if calculation exist in the database, it will return the result from it. Else it will create a instance of Calculation and save it with the result. The two paths will return Calculation object as response.

To test this controller we need to make some changes and configurate the responses from GetAllCalculation and SaveCalculation methods. We do not want to execute the implementation of this interface.

Moq solve this issue by using a class called Mock. With Mock you can create a setup to the interface by setting it’s methods income and output when it will be called inside the method that we are testing.

[Fact]
        public void Sum_two_numbers_using_fact()
        {
            //arrange
            var mock = new Mock<ICalculatorRepository>();

            var controller = new CalculatorController(mock.Object);

            //... all the other operations above
        }

Instantiate a Mock object by setting ICalculatorRepository as the type and pass mock.Object as parameter to CalculatorController and now you have mocked ICalculatorRepository.

Inside SumTwoNumber method from CalculatorController we have a call to GetAllCalculations that will return all calculation in a IEnumerable. How to set that? By calling Setup and Return in mock instance.

Example:

mock.Setup(e => e.GetAllCalculations()).Returns(Enumerable.Empty<Calculation>());

Our full method test will be something like this:

        [Fact]
        public void Sum_two_numbers_using_fact()
        {
            //arrange
            var mock = new Mock<ICalculatorRepository>();
            mock.Setup(e => e.GetAllCalculations()).Returns(Enumerable.Empty<Calculation>());
            mock.Setup(e => e.SaveCalculation(It.IsAny<Calculation>()));
            var controller = new CalculatorController(mock.Object);

            int num1 = 1;
            int num2 = 2;
            int expected = num1 + num2;            

            //act
            var response = controller.SumTwoNumbers(num1, num2) as OkObjectResult;

            //assert
            Assert.NotNull(response);
            Assert.Equal(response.Value, expected);
        }

You can also mock a method from a class that does not have a interface by setting virtual in the method declaration.

How to configure Azure Applications Insights on .Net 5

Rafael Ahrons — Thu, 29 Apr 2021 13:58:17 +0000

How to configure Azure Applications Insights on .Net 5

Application insights is a wonderful tool to help you track log, see performance issues and application map. It's more like CloudWatch on AWS.

First, you need to download two packages from nuget to start.

dotnet add package Microsoft.ApplicationInsights.AspNetCore --version 2.17.0
dotnet add package Microsoft.Extensions.Logging.ApplicationInsights --version 2.17.0

After that, you need to initialize the configurations from application insights on Statup.cs and Program.cs

On Startup.cs, you need to add the service dependency.

public void ConfigureServices(IServiceCollection services)
{
    services.AddApplicationInsightsTelemetry();

    //others dependencies
}

On Program.cs, you need to set the Log Level and your Instrumentation Key.

public static IHostBuilder CreateHosBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging(logging =>
        {
            logging.AddApplicationInsights("your-instrumentation-key");
            logging.AddFilter<ApplicationINsightsLoggerProvider>("", LogLevel.Trace);
        })
        .ConfigureWebHostDefaults(webBuilder => 
        {
            webBuilder.UseStartup<Startup>();
        });

Now you can use ILogger to create logs on Azure Application Insights.

Don't forget to eat clean and drink water.

Peace!!

C# - Jokenpo Challenge

Rafael Ahrons — Thu, 26 Mar 2020 11:37:40 +0000

You can check the repository right here.

Jokenpo Challenge

I like to solve problems and challenges, they make me feel excited about coding because I have to be on my best game and try to solve the problem is exciting . It gives that feel of accomplishment and victory when you finished.

The challenge consist of making a Jokenpo game logic, by all means, you must implement the rules of the game. Rock wins against Scissor and lose against Paper, Paper wins against Rock and lose against Scissor, Scissor wins against Paper and lose against Rock. How can we implement that in C#?

For this I thought that I must have some way of validation. The validation I wanted was to make it more “generic” and easy to create. Each validation only works for that one had form. To do it, I made an Enum for Hand forms:

public enum HandForm
{
    Rock,
    Paper,
    Scissor
}

Now the problem is: How to validate the Enum? How the Enum will have it’s own Rule?

The way I thought of solving was: create an extension for this enum that will return the Rule Class.

public static class HandFormExtensions
{
    public static AbstractRules ToRule(this HandForm handForm)
    {
        if (handForm == HandForm.Rock)
            return new RockRules();
        else if (handForm == HandForm.Paper)
            return new PaperRules();
        else if (handForm == HandForm.Scissor)
            return new ScissorRules();
        else
            throw new ArgumentException("There is no hand form rule for this option");
    }
}

Rule class will implement the AbstractRule class that will contain an abstract method that returns the result of that play, this means that the Rule class will have the checks for that hand form against the opponent hand form.

public abstract class AbstractRules
{
    public abstract GameResult WinAgainst(HandForm opponent);
}

Now the Judge of the Jokenpo will have only one line of code:

public GameResult ValidateGame(Player player1, Player player2)
{
    return player1.HandForm.ToRule().WinAgainst(player2.HandForm);             
}

So, whenever someone call the Judge class to validate the game, it will only return the result of the game based on the first Player passed as Parameter.

That’s it folks. Don’t forget to eat clean and drink water.

Peace.

Devlog #03 - Final day from My First Game Jam Winter 2020 - from 29/01 to 08/02

Rafael Ahrons — Wed, 26 Feb 2020 19:14:18 +0000

You can read this in my personal blog

Finally released my first game

It's finished? No, it is not. It is cool? You good damn right (at least I enjoyed making and playing the microgame).

What happend

The game jam was tough. I've learned a lot and got passionate with game dev. It's my first game that I made by myself. The result of the game jam isn't that good, but I'm proud of it.

In the middle of the jam I got sick and couldn't code till I get bether, so for some days I didn't code at all :(

The final days was insane. I've code a lot and try to fix some bugs, but in programming code = new bugs.

First, let's get to the results. You can play Survive the night on itch.

What the game has:

A player with animations for: running, idle and attack.
A monster (Treant) with animations for: running, iddle and death.
Pathfinder for the Treant can find and run to the Player
Health bar for the Treant.

The game is simple for now. If you kill the treant, the game ends.

I got so happy with the results that even when it's finished I started coding to improve the game.

The next features that I want is:

Spawn for Treants
Adjust the ground layout. Because it doesn't fit the collor pallet and doesn't look natural.
Add a combat system for the Treants
Maybe add more creatures, but this would be made by me
Add a bonfire
Add light to the bonfire
Logo for the Survive the night
End screen when you win or loose.
Intial start game screen with the main character and the bonfire just vibing

This the features that I want to add for the next release.

Don't forget to eat clean and drink water.

Peace!! ✌️

Devlog #02 - Fixing bugs from pass days and adding Particle System Day 3~4

Rafael Ahrons — Wed, 12 Feb 2020 20:44:05 +0000

You can read the original post in my personal blog

Days: 28/01 and 29/01

Bugs fixed

In the last devlog we had an issue with the collision that I couldn't solve. But fortunately we found the answer in Unity API!. The answer was in the rigid body added to Treant.

Colliders on a GameObject that has a Rigidbody are known as dynamic colliders. Static colliders can interact with dynamic colliders but since they don’t have a Rigidbody, they do not move in response to collisions

Particle System

After the bug was fixed we add a particle system to make a blood effect for when the monster or player got a hit it shows up. In the beginning, it won't show in the treant. We had to make a Prefab from the particle system, edit the properties to make small and finally add to the Enemy script.

When we called from the script, it won't show the particles. To fix that bug we use this answer Particle System object (tab Renderer) value of "Sorting Fudge" to -100.

Now we have this:

The code to execute this is simple:

var bloodClone = Instantiate(bloodEffect, 
                             gameObject.transform.position, 
                             gameObject.transform.rotation);

Destroy(bloodClone, bloodClone.GetComponent<ParticleSystem>().main.duration);

Added to Enemy.cs, TakeDamage method. Now every time the object gets hit, it will instantiate a particle system that will be destroyed when it`s over

For the next days, we want to:

Change the scene layout for one that has snow ground and with trees
Add the bonfire
Add idle animations from is a side character
Fix the bug that character can damage enemy hitting from down or up if the enemy is near

Devlog #01 - My first game jam winter 2020 Day 2

Rafael Ahrons — Wed, 29 Jan 2020 00:36:49 +0000

You can read my original post in my personal blog

The Jam

I've received an e-mail last week about a game jam that is happening right now. My First Game Jam Winter 2020 is for begginers like me, so you can try to learn a new tool, try to learn how to code and receive a feedback of your work.

The theme is Cold.

Let me tell you my background. I work as a software engineer and know how to code in C# and my brother work as a software engineer too but knows Java. So to help each other, we are going to try to lear Unity engine. C# is similar to Java, hence he won't be facing such difficulty in syntax.

Our Idea

While talking to my brother we got an idea that both of us got interested of doing. The ideia is:

We are going to try to build a survival game more like an Enfos map from Warcraft 3 that you have to protect something and has a hero. That hero will be you. So you have to protect a bonfire in the snow from monsters trying to extinguishement the bonfire. If the bonfire extinguishes you gonna die from cold and wont be able to see in the night. You must survive till dawn.

The player will be able to move up, down, right and left. Will be able to attack other monsters and if he got hit by a monster than we want to display an animation for that, same as if he dies. Monsters will be able to do the same, but we wont be able to control.

What we want is the monster to have a path finder to got directly to the bonfire or to the player if he is near the monster.

Our development journey from Day 2

Day 1 we were in the beach and couldn't code, so we started coding in day 2 (sunday 26/01/2020).

We don't know how to use Unity... We are using tutorials from Brackeys and Blackthornprod to learn how to do the stuffs we want.

In day one, we built the movements from player and the add animations parameters to activate the right animation when he is going up, down, left and right. We add a simple combat system that when the player gets near to a monster he can hit until he kills them.

The monster can't move yet, soon we will add movement animations and a path finder.

We hope that in the next days, we add some art made by us.

You can check ours repository in github to check our progress.

This is what we have right now:

The player can attack the monster if he gets near and can walk up, down, left and right with their own animations.

Problems that we faced

Gizmos doesn't appear

While in the development we could add a Gizmos Sphere to see the range of the attack object. We add a gizmos in some scriptable object but it wasn't showing up. I've been searching in a lot how to fix it but when I found one, i laught about it. Gizmos was disable in the scene...

Collider from player is pushing monster away when collide

As the title suggest, the player couldn't attack the monster because he was pushing them away. The bug is funny, but we couldn't solved very well yet. We changed the rigid body property to use kinematics instead of dynamic. Now the player can pass through the monster, but it isn't what we want. We want the player can't pass through the monster.

Even posted a question to Game Development stackexchange to get some help.

Docker 102 - What is Docker image and Dockerfiles

Rafael Ahrons — Thu, 10 Oct 2019 11:46:55 +0000

You can check the original post in my personal blog

What is Docker Image

Docker image is a snapshot of a container. It's immutable and inert. Container is an instance of an image.

What is Dockerfiles

Is a file that contains instructions to create an image and running it the way you want.

Creating a Dockerfile

This is an example of code that we're gonna put inside a docker image after creating one from a dockerfile.

Python code to app.py

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "hello world!"

if __name__ == "__main__":
    app.run(host="0.0.0.0")

Example of Dockerfile that will build the image:

FROM python:3.6.1-alpine
RUN pip install flask
CMD ["python", "app.py"]
COPY app.py /app.py

FROM python:3.6.1-alpine means that you're using a python 3.6.1 built-in Alpine image, you can see what have in the image looking for the tag in the official Python page on Docker Hub. More light the OS, faster is the deploy.

By security measures it's recommended to verify if the image you are using is the official from the app or language and if it's certified by Docker. Also, verify what have in the dockerfile.

RUN pip install flask is the call to run pip install flask command, which is the dependency of our app. Run serves to execute the following command to configure the container environment. Usually used to install dependencies or build the project.

CMD ["python", "app.py"] is the command that will be executed after you initialized the container You must be careful to only have one CMD for dockerfile. If have more than one, it will always execute the last.

COPY app.py /app.py add a copy of app.py file inside the container in the /app.py folder. It looks kind of odd putting after CMD command, but because of layers, in case you change the file, the cache will only modify the last line in the image.

There is no need to have python, pip, and flask installed. The vantage of using docker is that you don't need to have all installed to run the app, only need a container. After you finished using, just delete the container.

The dockerfile has all the instructions the built the image and have it running (container) the way you desire.

Building the image

docker image build -t python-hello-world .

-t allows you to add a name to the image.

If you change some file, just run docker image build again

Check if the image was built.

docker image ls

Shows all images that you have created or download from docker hub.

Executing the docker image

docker run -p 5001:5000 -d python-hello-world

-p maps the port that is running inside the container with the one from the host.
-d run the image in the background

You can check on localhost:5001 if the container is running correctly.

Layers

It's basicly the series of steps which the container will built from the image. Which command on the docker file will be a layer. It's important to notice that everytime a layer is changed, the consectives are gonna change either. Because if one step has changed, the consectives steps must run to create the image. So, for bether performance, add the line that will have more changes for the last.

This question from stackoverflow has a good answer for that and this medium post from Jessica G either

So that's all, folks. You learned how to create a dockerfile and image. Thanks for reading and keep going. Don't forget to drink water and eat clean..

Docker 101 - What it is and how to start using

Rafael Ahrons — Fri, 04 Oct 2019 02:24:02 +0000

You can see the original post in my personal blog

What is Docker?

Docker is a tool which controls containers and makes it possible for developers to use container with their own applications.

Putting on a container, you have the advantage to grant that your application will always run fine and with the same environment every time, cause it is configurated in a container with all needed specifications.

Docker has it's own interface standardized for all operations.

Has it's own container orchestration.

What is a container?

It's something that packages up all application dependencies and code so the application runs as fine as it can. You can read more at What is a Container? from docker page

Running a container

docker container run -t ubuntu top

docker container run initialize a container.

-t add an pseudo-TTY to the image.

run first execute a docker pull to get ubuntu image for the host. After downloaded, initialize the container with the Ubuntu image.

top is a Linux command that shows all active process order by memory consumption.

Looking at the output on bash you gonna see only the root process running, which means that all container is isolated from which other, avoiding conflicts between one and another.

Even using the same image from Ubuntu, it's important to note that the container does not have it's own kernel. It uses the host kernel and the image is used only to provide the file system and tools available on Ubuntu.

Get inside the container

docker container exec -it

Allows you to enter the container terminal.

-it allows you to enter without executing any command and you can navigate on it.

Show all containers

docker container ls

Shows all the containers that are running.

Using container ID to get into it's terminal

docker container ls
--Get the container ID
docker container exec -it CONTAINER_ID bash

--to leave from the container
exit

The last argument selects the terminal to use. You can see on Docker hub which terminal is available to use.

Stopping a container

docker container stop container_id

You can use only the first 3 digits in the container ID to identify the contaier, those digits is whats make a container unique.

It's possible to stop more than one container at once:

docker container stop d67 ead af5

Removing a container

docker system prune

Remove all stopped containers.

Thanks for reading it. I've been using docker for a while now and it's amazing having all my projects running without conflict and even their on database. I'm tired to install and configure all different types of databases...

Don't forget to drink water and eat clean.

Game dev for beginners like me

Rafael Ahrons — Sat, 07 Sep 2019 20:49:05 +0000

You can see the original post with the game developed in my personal blog

In the beginner of this is, I've got into a vibe of thoughts which I questioned what I liked to program. The good side and bad of been a dev is that you end up doing a lot of different stuff and, by consequence of the market, you end up in other fields of acting. I went through the banking sector, ERP of small enterprises, hospital management, and maybe in the near future banking sector again. The point is that in programming, you can do a lot of stuff, a lot of interesting stuff. But knowing what you really like to program is another 500.

Been in love with programming is an extra bust of productive, that even when you're tired and exhaust you are going to code because you like it. You enjoy coding that, so you will do, you will learn and get motivated by the end of the day.

What was always in love was RPG games, so I'm gonna on an adventure to learn how to make games.

Found out some dev.to articles to help me find the right path to follow.

This article by @arnaudmorisset clarify some doubts of which language and where to start. It made go motivated to C# and Unity. Why? Just because I know how to code in C# and I like it.

Thus, I followed a Youtube tutorial from GamePlusJames and learn it a lot of stuff about 2D games and scripting with Unity. The fact of knowing C# helped a lot but still got some doubt.

Doubts that came while doing Snowball Fight Tutorial:

How to build the project? Unity has a lot of different types of building your project and configs. Which one I use and why? In the last video, he explains how to build and configure to play on windows.
There is a way to make Unit Test to my business logic?
How to connect on database?
How to use HTTP Request to other services?

The path I've found:

This tutorial from GamePlusJames is perfect for those that don't know yet how to programming and don't know anything about Unity. He explains very well what he is doing through the videos.

There is this Udemy class Complete C# Unity Developer 2D: Learn to Code Making Games that teaches you how to program C# from the start and stuff about Unity. You will code at least 4 projects during the classes.

How I made my first blog with Jekyll and why

Rafael Ahrons — Tue, 06 Aug 2019 00:22:05 +0000

You can ready the original in my personal blog

Motivation

After wanting to make a blog and discuss it with my brother. I've got the conclusion that is necessary to have a blog to learn more about programming and to teach others that may be struggling with the same subject that I was. Now I'm gonna create a series of posts about Jekyll, Liquid templates and Css as I learn it and modify my blog to have more of me on it. In an article about DevOps from Henry Quinn @quinncuatro on dev.to, I got really intrigued with Learning in Public.

What is learning in public?

Is exposing for all what you are learning or developing in that moment. Why? Because, when you teach others you end up learning more about it and helping others with the same subject. It helps you to memorize and practice the subject.

Benefits to learn in public

You would be helping others to not struggle as you when you were learning, you will be practicing journaling and maybe another language (my case).

Let's do it

To begin, what I'm gonna be writing in this series are CSS, Liquid Template and Jekyll, becauses that's what I'm dealing with to build my personal blog. Feel free to give me a feedback in the end to help me more.

Why Jekyll?

Didn't want to host my blog anywhere and didn't want to have cost and problems with infrastructure and security, I really just want to focus in programming with a simple and fast result, so I end up picking Jekyll (and it's recommended by Github Pages tutorial).

Jekyll is a generator of statics sites from a specific template.

It's created in Ruby, so you have to have installed on your computer. In Jekyll's site has a tutorial to install Ruby and Jekyll.

To initialize your project you have to execute the command below:

jekyll new nome-do-blog

It will create the structure of your project in his own folder.

Jekyll default is to use Minimal template. To find where the files are, just use the command bellow:

bundle show minimal

It will show you the directory of it.

If you want to change the template and have in your versioning program, then you should copy the files to your project directory.

To build and execute your site it was never that easy!! Only execute the commands bellow on your project main folder.

bundle exec jekyll build

After built:

bundle exec jekyll s

Now you have your personal blog with Minimal Template on localhost:4000.

As I learn more and modify my personal blog to have my own style, I'll be doing more posts and explain it.

That's all folks.

Don't forget to drink water.