DEV Community: Adriano Gil

Blogging with Obsidian and Jekyll

Adriano Gil — Wed, 05 Feb 2025 23:34:52 +0000

Jekyll is a static site generator that transforms Markdown files into a fully functional website. Everything is generated into plain HTML, which makes it simple to deploy on platforms like GitHub Pages.

Writing in Obsidian

I use Obsidian for writing because:

It supports Markdown, making it easy to format posts.
I can organize posts with tags and metadata.
It keeps my writing centralized before publishing.

Each blog post has metadata that determines if it’s ready for publication. Drafts are excluded from processing.

Using Templates in Obsidian

To standardize my blog posts, I use templates in Obsidian. Templates help maintain consistency across different posts and speed up the writing process. So any time I want to start a new post I first create a planning note with brainstorming ideas and references. Then I create a post note which contains the full text and metadata for each post.

Using Dataview, an Obsidian plugin that allows me to query and display content dynamically based on metadata, I can track posts in different stages of completion, identify missing translations, and view related notes.

Jekyll-Multiple-Languages-Plugin

The jekyll-multiple-languages-plugin helps me to structure my content in multiple languages by creating different versions of each post. Here’s how it works:

My blog supports English, Portuguese, and French, configured in _config.yml:
```
languages:
 - en
 - pt
 - fr
default_lang: en
```

Each language has its own directory inside _i18n/, for example:

_i18n/en/_posts/2025-02-01-my-post.md
_i18n/pt/_posts/2025-02-01-meu-post.md

The plugin automatically generates language-specific URLs:

https://adrianogil.github.io/blog/en/2025/02/my-post/
https://adrianogil.github.io/blog/pt/2025/02/meu-post/

Users can switch languages using a simple language selector in the blog UI.

Automating the Blog Post Processing with Python

Manually copying Markdown files, managing assets, and handling metadata can be time-consuming. To ease my blogging process, I use a Python script that automates the following:

Extracting blog posts from my Obsidian vault.
Copying and processing images.
Formatting metadata for Jekyll.
Placing the final post in my blog’s GitHub Pages repository.

Fetching Notes

First, it gathers notes marked with a specific tag (GilLabs/posts/text).

notes = get_notes_from_index(target_tags=["GilLabs/posts/text"], as_obsidian_notes=True)
notes = [note for note in notes if not note.metadata.get("draft", True)]

This ensures only published posts are processed.

Generating the Jekyll Blog Post File

Each post is formatted into Jekyll’s _posts structure with the correct date, language, and categories. Metadata such as title, layout, and categories are preserved.

---
categories: git
date: '2025-02-01 16:41:00 '
lang: en
lang-ref: intro-git
layout: post
title: "First Steps with Git"
updated: 2025-02-01T16:41
---
## Introduction
Hey there! I often find myself explaining Git from the ground up,...

4. Deploying the Blog

Once the script updates the html files in my Jekyll project, I simply:

Build the site with:

jekyll build

Push the changes to GitHub Pages with:

git add .
git commit -m "New blog post"
git push origin main

Within minutes, my blog is live!

First Steps with Git

Adriano Gil — Sat, 01 Feb 2025 20:46:12 +0000

Introduction

Hey there! I often find myself explaining Git from the ground up, so I decided to write this short introductory guide as a handy reference. This guide will walk you through the very basics. By the end of this post, you'll know how to set up your first repository, make your first commit, and more. Let's get started!

I can't recommend enough having a playground local repository so you can test each command. You should be able to freely move around your repository noticing how each command changes the current state of your files and the commit history.

Setting Up Your First Git Repository

First things first, let's set up your Git repository. This is where your project's history will live.

To create a new Git repository, open your terminal and navigate to your project's directory. Then, run:

git init

This command sets up a brand new Git repository in your project folder. Easy, right?

After running git init, a hidden .git directory is created. This directory contains all the necessary metadata and objects that Git uses to track and manage your project's history.

Adding Files to Your Repository

Next, let's add some files to your repository.

Think of the staging area like a shopping cart—you gather changes here before you check out (commit) To add a file, use:

git add <file_name>

Replace <file_name> with the name of your file. The <file_name> is now on staging area. The staging area lets you review and prepare changes before committing them.

If you want to add all changes in the current folder (including deletions and modifications), you can use:

git add .

To see what's in your staging area and what's changed in your working directory, use:

git status

This command gives you a summary of the current state of your project.

Committing Your Changes

Now, let's commit your changes. A commit is like a snapshot of your project at a specific point in time.

To commit your changes with a message, use:

git commit -m "Your commit message"

Make sure your message is clear and descriptive so you know what this commit is about later.

Visualizing Your Commit History

Seeing your commit history can be very helpful. To visualize your commit history, use:

git log --graph --all --oneline

This command shows a graphical representation of your commit history, which can be really useful for understanding how your project has evolved.

Pushing Changes to a Remote Repository

Once you've made some commits, you might want to share your work with others or back it up to a remote repository like GitHub.

First, you need to add a remote repository. If you're using GitHub, it might look like this:

git remote add origin https://github.com/yourusername/your-repo.git

Then, push your changes:

git push origin main

This command uploads your changes to the main branch of your remote repository.

Understanding the Git Mindset

To really make the most of Git, it helps to get familiar with how it works and the key parts of your project from Git’s perspective: the filesystem, the staging area, and commits. This workflow is all about how changes move through Git until they’re safely recorded in your project’s history.

Working Directory (Filesystem): When you modify files in your project, you're working directly in the filesystem. This is where you create, edit, and delete files. At this stage, these changes are not yet tracked by Git.
Staging Area: After making changes, you add the modified files to the staging area using the git add command. Think of the staging area as a clipboard for changes—it's where you prepare what will be included in your next snapshot. This step allows you to control exactly which changes are part of the next commit.
Commit as a Node in the Tree: When you're ready, you use git commit to take a snapshot of the staged changes. This snapshot acts like a node in Git's version history, forming a connected structure. Each commit points back to its parent, creating a sequence of changes rather than separate folders. A branch is simply a pointer to one of these sequences, not a container of its own. By focusing on how changes flow through the tree, you can navigate Git more effectively and understand its true power.

A common mistake when thinking about Git is to see branches as if they were folders, but this mindset can be misleading. Instead of focusing on individual branches as separate containers, it’s better to see Git as a tree of changes—where each commit is a node and branches are just pointers to different sequences of snapshots.

Conclusion

And that's it! You've just taken your first steps with Git. You now know how to set up a repository, add files, commit changes, push to a remote repository, and understand the basics of how Git works. Keep practicing these commands, and soon you'll be a Git pro!

Remember, where Git is used, there is always hope. With Git, you can rewind changes, recover past versions of your code, and even undo mistakes with ease. It allows multiple developers to work on the same project and it’s the best way to share code with others.

Additional Resources

If you want to dive deeper into Git, check out these resources:

Official Git Documentation
GitHub Guides
Julia Evans' blog – I can’t recommend it enough! Intuitive explanations of Git commands and internals.
Tools for visualizing your Git commit history, like Sourcetree or GitKraken.

My Roadmap for 2025

Adriano Gil — Wed, 01 Jan 2025 23:45:05 +0000

Several years ago, I started this blog as an excuse to document my learning process in some areas and to serve as additional material for courses or talks I've given. In 2025, I'm planning to make better use of this space—to keep track of what I’ve been working on and reflect on my progress. So, as the first post of the year, here are my professional goals for 2025.

Improving Technical Skills

With over 10 years of experience working on Unity projects for games, VR, and AR—plus a background in computer vision algorithms—I’ve had the chance to work on some fascinating challenges. However, over the past year, I’ve shifted my focus toward backend and mobile development, and in 2025, I’m doubling down on these areas.

My main goal is to earn two certifications: AWS Certified Developer and Android Enterprise Professional. These will deepen my understanding of cloud services and enterprise mobile solutions, allowing me to contribute more effectively to my team’s full-stack projects.

On top of this, I’ve started studying Godot and Unreal Engine, exploring procedural content generation (PCG) techniques such as mesh generation. It’s been exciting to dive into these engines and tackle algorithmic challenges, which I plan to continue throughout the year.

PhD Research: Educational Games, LLMs, and Game AI

As part of my PhD studies, I’m researching how large language models (LLMs) can be used in educational games. My goal is to explore methods that reduce development time and create games better aligned with pedagogical goals for classroom use. Over the past few years, I’ve published a couple of papers related to educational games, including one on learning analytics presented at last year’s SBGames conference.

In parallel, I’m also exploring Game AI techniques such as procedural content generation (PCG) and NPC behavior learning, which have the potential to streamline the development of more dynamic and targeted game experiences. These topics have been a focus of mine for some time, and I’m excited to continue working on them.

This year, I plan to advance my research and share updates as they become available. It’s a challenging but rewarding journey, and I look forward to contributing further to the fields of AI and educational games.

Language Learning Goals

Language learning has been a long-term passion of mine, and 2025 is no exception. My plan for the year includes improving my metrics across all the languages I’m studying. Here’s how I’ll approach it:

Spaced Repetition Systems (SRS): I’ll expand my use of tools like Anki and possibly develop new ones to make my study sessions more effective.
Reading and Writing: I’ll continue investing time in both areas to build a stronger foundation. Obsidian will play a key role here as a space to draft new texts and document insights from my reading sessions.
Listening: Podcasts will remain my go-to resource for improving comprehension, and I’ll take notes in Obsidian to capture key phrases or expressions I want to revisit.
Speaking: I plan to practice conversational skills more regularly, including using Advanced Voice Mode in ChatGPT for simulated dialogue practice.

Writing More

Finally, one of my key goals for 2025 is to write more on this blog. Documenting my journey not only helps me reflect but also allows me to share insights with others. Whether it’s about tech, research, or personal growth, I’m excited to post more consistently this year.

That’s my roadmap for 2025! If you have similar goals or are working on something interesting, feel free to share—I’d love to hear about it. Let’s make this year one of progress and growth!