We’ve all been there. You start with a productivity tool, full of hope, only to find yourself six months later spending more time maintaining the system than doing the actual work. You end up with a chaotic web of disconnected notes, scattered task lists, and a feeling that your Personal Knowledge Management (PKM) system is actively working against you.

Today, I’m introducing CUBE (Capture, Understand, Build, Execute): A frictionless, context-aware protocol designed from the ground up for Obsidian, ready for those who still like the old way of doing stuff but also ready for the age of AI… it’s timeless!

No matter how you locate yourself in the trends, this system adapts to you.

CUBE relies on a fluid-yet-hierarchical structure that mimics the neural pathways of your brain. It ensures that every tiny task is anchored to a piece of information, and every piece of information is anchored to a high-level concept. That’s the core of the framework, any other piece of structure built into it is there for convenience, however adhering to them is not strictly mandatory.

🏗️ The Core Architecture (The 3 Tiers)

CUBE is built on a strict “Map of Content” (MoC) pipeline consisting of three tiers:

1. Concepts (The Hubs): Your master dashboards for major areas of focus, projects, people, or recurring events (e.g., [[Homelab Overhaul 2026]] or [[John Doe]]). They sit at the top of the hierarchy to give you a bird’s-eye view. A concept is always accompanied by a Canvas file and a Base file (more on these later)

2. Items (The Raw Material): The spokes! (Your captures); Articles, meeting notes, PDFs, AI chat logs and every other piece of information you save to Obsidian can become an Item. Every Item contains a Concept link pointing directly to its parent higher order concept hub.

3. Tasks (The Actionables): Action items are handled as Inline Tasks (- [ ]). We do not create separate task notes. You write them directly inside your Items. This keeps the action visually tied to the exact context that spawned it through the Item.

The 4 Stages of Workflow

• Capture: Dump everything into your 00_Inbox folder.

• Understand: Process your inbox into Items by filling out native YAML Properties (Category, Format) and linking the note to a Concept Hub.

• Build: Extract actionables by writing inline tasks (- [ ] Buy cables #p1) directly in the note.

• Execute: Use your Daily Note Dashboard to keep track of your daily progress regarding projects. List your priorities for the day and tackle them, make use of backlinks to associate your concepts and items accordingly.

📁 The Setup Guide

Because Obsidian relies heavily on search and links, we keep the folder structure mostly flat. Use numbers to enforce sorting (if desired):

• 00_Inbox: The ultimate capture zone.

• 10_Categories: Broad domains of responsibility (e.g., Coding, Work, Personal, etc.); Items get organized into category folders as they’re processed (however you can also choose to just archive them if that’s more your style).

• 20_Concepts: The dedicated home for your high-level dashboard notes. A concept is always a folder containing the concept note itself, a base and a canvas related to it.

• 90_Archive: A vault for your Vault. Either cold storage for inactive notes, a place for orphaned notes and/or the place where everything goes after being processed, your choice.

💡 Pro-Tip for Fast Setup: Don’t build this manually! The easiest way to start with this system is to download the Vault below and extracting it in your system to be used by Obsidian.

DOWNLOAD HERE

⚙️ The Templates (The Engine)

You only need 3 templates to run your entire life. They rely on Obsidian’s YAML Properties (frontmatter) to make your vault machine-readable.

1. The Item Spoke Template

Use this for 90% of your notes: web clippings, one-off meeting notes, PDFs, and random thoughts.

• Properties: Includes Type: Item, Category, Format, Date and the crucial Concept: [[Concept]] link.

• Content: Features a Summary section for a quick TL;DR, a Notes section for the raw data or additional captures, and an Actionables section where you write your inline Tasks.

The template itself:

---
Type: Item
Category: Templates
Concept: "[[tpl-concept-hub]]"
Format: Template
Date: {{date}}
---

# {{title}}
  
**Source/Link:**

## ⚡ Summary / TL;DR



---  
  
## 🧠 Notes & Captures



---  
  
## ✅ Actionables

- [ ]   

2. The Concept Hub Template

Use this for your projects, people, or broad domains. Recurring meetings can be classified as concepts too. A concept is always enclosed in its respective folder with an Obsidian Base (.base file that holds a reference to all the items linked to that concept) and an Obsidian Canvas (.canvas file for easy visualization and management of the internal connections relative and related to its items)

• Properties: Includes Type: Concept, Category, Date, and Status: Active.

• Content: Features a Description statement and one Obsidian Base block titled Knowledge Base to aggregate all linked Items (The canvas link is also available there for convenience). You also have a Related Concepts section to build up your network of connected ideas.

The template itself:

---
Type: Concept
Category: Templates
Status: Active
Date: {{date}}
---

# {{title}}
  
**Description:** 

*Write a 1-2 sentence definition of what this concept/project is about: its goals, purpose, etc.*
  
---
  
## 🗂️ Knowledge Base
*All captures and items anchored to this Concept.* 
  
> [!info] Item Base
> **Insert a Base View here**
> Filter: `Type: Item` AND `Concept: [[{{title}}]]`
> *(This will automatically display every Item note that you linked to this Hub)*  

![[10_Categories/Templates/tpl-concept-hub/tpl-concept-hub.base]]

**Canvas:** [[tpl-concept-hub.canvas]]

---

## 🕸️ Related Concepts

- [[ ]]
- [[ ]]

3. The Daily Note Template

Your daily command center for Execution and Capture.

• Properties: Type: Daily and Date.

• Content: Features a Quick Capture scratchpad so you don’t break focus, an Execution section featuring a place to organize your day in tasks, a Daily Log section for journaling, personal introspection or outlining timed events and an End of Day shutdown checklist.

The template itself:

---
Type: Daily
Date: {{date}}
---

# 📅 {{date}}
  
## 📥 Quick Capture (The Daily Inbox)
*Dump your quick notes here. Process them later into proper Items if needed.*

-  

---

## 🎯 Execution (Today's Priorities)
*Your daily task list. Check these off as you work throughout the day.*

- [ ] 
  
---

## 📓 Daily Log & Timeline
*Bullet journal your day here. Log events, decisions, or fleeting thoughts.*

- **09:00** -

---

## 🔄 End of Day Shutdown (Review)
- [ ] Review **Quick Capture** section above (Convert to Items, archive or delete)
- [ ] Process `00_Inbox` (Move Items into Categories, archive or delete)
- [ ] Update status/priority tags on any lingering **tasks** here or in your Items

🤖 Supercharging CUBE: Giving AI the Keys

If you use AI tools to summarize articles or transcribe meetings, pasting raw AI text into your vault usually creates disorganized “text sludge”; CUBE solves this! Because it relies on strict YAML Properties and standard Markdown, it is highly machine-readable. By using a command-line AI agent (like gemini-cli or claude code), you can place a master instruction file (GEMINI.md/CLAUDE.md) directly in the root of your Obsidian vault teaching it your exact taxonomy. Here you have a sample file you can use as a template:

See on Github

You can feed the agent a chaotic meeting transcript and it will automatically generate a perfectly formatted Item note, assign the correct YAML (with Format: Meeting), add the bi-directional link to the Concept related to it (Concept: [[Project Name]]), then extract native inline Tasks (- [ ] Send the report #p1) for the item.

Example AI Prompts for CUBE

If you are passing data to an AI agent configured for your vault, use prompts like these to achieve zero-touch processing:

Prompt 1: The Article Processor

“Read this article URL. Create a new note using the Item Spoke structure. Set the Category to ‘AI/ML’ and Format to ‘Article’. Write a 2-sentence summary, extract the key arguments into bullet points, and link it Up to the [[Artificial Intelligence 2026]] concept.”

Prompt 2: The Meeting Extractor

“Analyze this raw meeting transcript. Format it as an Item Spoke with Format: ‘Meeting’. Link it Up to [[Client X]]. Do not give me a generic summary of next steps; instead, write explicit inline markdown checkboxes for every action item mentioned, appending the #p2 tag to each.”

Prompt 3: Generic

“Read the ‘PROMPT.md’ file and process this [Input] accordingly.”

🧹 Weekly Maintenance (Keeping it Clean)

To prevent your system from turning into a chaotic web, perform a 10-minute scrub once per week:

• Inbox Zero: Ensure every note in 00_Inbox has Properties assigned to it and that it is linked Up to a Concept, then move it to 10_Categories as needed or archive it.

• Task Scrub: For any ongoing project/concept, review your list of tasks in the related items. Demote stale #p1 tasks to #p3, or delete the checkbox entirely if you are never going to do them.

• Concept Audit: Change completed projects to Status: Archived and move them to the 90_Archive folder to keep your active dashboards clean.

• The Orphan Hunt: Open Obsidian’s Graph View. Spot any nodes floating completely disconnected from the main clusters. Click them and assign an appropriate link so they rejoin the ecosystem (or if needed, just archive/delete them).

Settings I recommend

I know that Obsidian settings can get very personal, that’s why I will mostly focus on recommendations that specifically leverage the CUBE system, check the screenshots below:

• Files and links settings

  

• Daily notes settings

  

• Templates settings

  

Personal Advice: Don’t sweat it!

CUBE is not a rigid system. It is a framework that aims to help you find the connections between your thoughts and transforming such connected thoughts into tangible actions that deliver results for you. That process cannot happen in rigidity. It can only happen in a flow state.

That’s why I say: Don’t fear the orphans! Although I’m a firm believer that anything can be turned into an Item and every item is part of some Concept and thus can also belong in some Category (no matter how broad), I also think not everyone should strictly process everything they capture if they don’t feel like doing so. Perhaps for you a specific capture is not worth an item note. Perhaps for you, an item should not be categorized or perhaps you haven’t found a concept you’d want to use for such item (although this last one would be more difficult to come by, more so if you decide to use AI to help you create the notes but it could still happen);

In such cases remember:

Your Archive is the vault for your Vault. Send such notes to the Archive. At some point as you look at your knowledge graph the connections would naturally reveal themselves.

About the Graph View

This is how a linked concept will look like in your Knowledge Graph:

P.S. you can use the filter -path:"10_Categories/Templates" in the graph view to hide the templates folder from it in order to prevent unnecessary clutter.

Ready to build your CUBE?

Stop managing notes. Start achieving results!

Drop the starter vault into Obsidian, go with the flow, and experience the power of a system that finally works with you. Let’s C.U.B.E. the chaos together.

I can’t wait to hear what you create with it.

In an era where almost every message we send passes through some company’s servers, Signal has become the gold standard for private communication. But… What is Signal and what is it used for around the world? Well, Signal is a secure messaging app (free and open-source) focused on end-to-end (E2E) encryption. It is widely used by journalists, activists, technical teams, and anyone who wants to protect their conversations from providers, operators, and attackers on public networks. It offers encrypted calls and messages, security number verification between contacts, and a clean design that popularized end-to-end encrypted messaging on a global scale.

Signal has earned its reputation by merit: It democratized E2E encryption for messages with a clean interface, the transparency of open-source code, and the Double Ratchet algorithm that forever changed secure messaging.

But even Signal has its limitations, some of them are:

• Limit of 5 linked devices (which could be particularly frustrating for multi-device users)

• Centralized servers: You depend completely on Signal’s infrastructure.

• Identity based on phone number, which complicates anonymity

For me, the first point was the deciding factor. I needed something that could:

• Be used on as many devices as I wanted/needed

• Operate from a text interface (for example, on servers)

• And still maintain encryption at Signal’s level

That’s when I rediscovered the XMPP protocol, specifically through PidginChat + OMEMO, which motivated me to write this article about my setup and how to replicate it, plus some variants and other useful information.

Without further ado, let’s get to it!

🧩 Under the Hood: XMPP (feat. PidginChat) + OMEMO

XMPP: The Backbone of Open Messaging

XMPP (Extensible Messaging and Presence Protocol) is an open standard for messaging: the same protocol that powered Google Talk and Facebook Chat in their early days… It’s federated just like email: anyone can host a server, and servers communicate with each other.

OMEMO: Signal-Level Security, Federated

OMEMO is an encryption layer for XMPP that implements the same Double Ratchet algorithm used by Signal. It offers support for offline messages, multi-device synchronization, and forward secrecy.

What is forward secrecy? Also known as perfect forward secrecy, it’s basically a cryptographic implementation that means if a long-term encryption key were to be compromised today, your past messages would still be protected; OMEMO/Double Ratchet constantly rotates keys and discards the old ones; each message (or batch of messages) is protected with fresh and ephemeral cryptographic material.

💜 Pidgin & PidginChat

Pidgin is one of the oldest and most respected open-source chat clients. It was born in the early 2000s as Gaim, and evolved into what we know today as a multi-protocol application powered by libpurple, a plugin-based library that supports dozens of messaging protocols (IRC, XMPP, ICQ, and more). For many GNU/Linux users, Pidgin was (and remains) essential for talking to people who have a presence on different messaging networks (proprietary and open alike).

PidginChat, on the other hand, is a modern XMPP service hosted and managed by the community that maintains Pidgin. It uses a lightweight XMPP server that anyone can join, making it perfect if you want a ready-to-use network in a configuration scoped to be similar to Signal after setting up the proper encryption needed (without having to set up your own server from the start)

Quick Registration on PidginChat

Short and concise: Go to https://pidgin.im/about/pidginchat/ and follow the instructions.

Elaborating:

Basically, you’ll need to create an account on their JetBrains Hub instance (https://hub.imfreedom.org/) by logging in with your preferred method; that will automatically create your PidginChat account (you can change your assigned username later right there in their web interface)

Note your XMPP address (JID): it looks like username@pidginchat.com where username refers to the username assigned in the JetBrains Hub instance.

Use it to log in with any XMPP client: I’ll recommend you some below.

🖥️ XMPP Clients: Choose Your Platform

There’s no one-size-fits-all: Choose the one that best fits your workflow:

My Particular Case: Secure Messaging Between Servers

I started researching this topic because I wanted to find an option to establish an E2E encrypted chat via command line between servers on my VPN/LAN. No graphical interface: just the terminal.

That led me to find Profanity, a TUI (terminal user interface) XMPP client that supports OMEMO once you compile it correctly with the proper plugin set. We’ll deviate a bit into this tangent (feel free to skip this section if you wish) and here I’ll write up the guide on how exactly I made it work with Homebrew libraries on AlmaLinux 10; a GNU/Linux distribution compatible with Red Hat Enterprise Linux (RHEL) 10.x and other derivatives of it like RockyLinux, for example.

Let’s see…

How to Install Profanity with OMEMO Support on AlmaLinux 10 (and other RHEL-compatible distros)

Profanity is a fast and minimalist XMPP client with support for OMEMO, OTR, and PGP. Compiling it with all dependencies on a modern RHEL-like distro (AlmaLinux 10 as an example) can be tricky, which is why I’m documenting a reproducible process here as a reference for posterity.

NOTE: The commands you’ll see below are meant to be executed in a bash shell.

Step 1: Prepare the Base System

Install development tools and kernel headers:

sudo dnf -y groupinstall "Development Tools"
sudo dnf -y install glibc-devel glibc-headers libstdc++-devel binutils kernel-headers pkgconf-pkg-config

This ensures we can create executables with /usr/bin/gcc (otherwise the configure step might fail with a message like: “C compiler cannot create executables”).

Step 2: Install Linuxbrew / Homebrew (if you don’t have it installed already)

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

The script explains what it will do and pauses before doing it. After installation, add brew to your PATH (the same STDOUT after installation will give you the instructions on how to do so) and install gcc from its repositories with:

brew install gcc

Step 3: Install Dependencies via Linuxbrew

brew install autoconf automake libtool pkgconf autoconf-archive readline ncurses glib curl libxml2 openssl@3 sqlite libstrophe libsignal-protocol-c libgcrypt libgpg-error

This brings the libraries that Profanity needs for OMEMO and more (ncurses, cryptography, XMPP, etc.).

Step 4: Ensure pkg-config Finds GLib

Some installations need explicit hints for GLib’s .pc files:

export PKG_CONFIG_PATH="$(brew --prefix)/lib/pkgconfig:$(brew --prefix)/share/pkgconfig:$(brew --cellar glib)/*/lib/pkgconfig:$(brew --cellar glib)/*/share/pkgconfig:${PKG_CONFIG_PATH:-}"

Test:

pkg-config --modversion glib-2.0

Expected: 2.xx.x

If you see “not found”:

brew reinstall pkgconf

Step 5: Prepare Build Flags with brew paths

RLB="$(brew --prefix readline)"
NCB="$(brew --prefix ncurses)" 
GCR="$(brew --prefix libgcrypt)" 
GGE="$(brew --prefix libgpg-error)" 
SIG="$(brew --prefix libsignal-protocol-c)"
GLB="$(brew --prefix glib)" 
HB="$(brew --prefix)"

export CC=/usr/bin/gcc
export CXX=/usr/bin/g++
unset CFLAGS CXXFLAGS LIBRARY_PATH CPATH

export CPPFLAGS="-I$RLB/include -I$NCB/include -I$GCR/include -I$GGE/include -I$SIG/include -I$GLB/include/glib-2.0 -I$GLB/lib/glib-2.0/include"

export LDFLAGS="-L$RLB/lib -L$NCB/lib -L$GCR/lib -L$GGE/lib -L$SIG/lib -L$GLB/lib -Wl,-rpath,$HB/lib -Wl,-rpath,$NCB/lib -Wl,-rpath,$GCR/lib -Wl,-rpath,$GGE/lib -Wl,-rpath,$RLB/lib -Wl,-rpath,$SIG/lib -Wl,-rpath,$GLB/lib"

This helps the configure step find:

• libsignal-protocol-c

• libgcrypt + libgpg-error

• readline + ncurses

• GLib

Step 6: Get the Profanity Source Code

cd ~

[ -d profanity ] && (cd profanity && git fetch -p && git reset --hard origin/master) || git clone https://github.com/profanity-im/profanity

cd profanity

git clean -xfd
rm -f config.cache

Step 7: Initialize the Build System

./bootstrap.sh

This generates configure and other files via autotools.

Step 8: Configure with OMEMO Support

Add these extra flags to try to avoid a common cURL warning that seems to be affecting the profanity build right now (it might be fixed later by the community):

LIBS="$(pkg-config --libs libsignal-protocol-c) -lgpg-error -lgcrypt -lncursesw -lreadline"
CFLAGS="-Wno-error -Wno-error=attribute-warning"
CXXFLAGS="-Wno-error -Wno-error=attribute-warning"

./configure --enable-omemo --prefix="$HOME/.local"

Step 9: Compile

make -j"$(nproc)"

sed -i 's/\(CURLOPT_TIMEOUT,\s*\)2)/\12L)/' src/common.c
make clean
make -j"$(nproc)"

Step 10: Install and Validate

If there were no more errors, we can install profanity at user level and validate at the same time with:

make install
~/.local/bin/profanity -v

Expected:

Profanity 0.15.x

Features: OMEMO, libsignal-protocol-c, ncurses, readline

Done! Profanity is installed! Start it with:

~/.local/bin/profanity

Common Troubleshooting

I’ll summarize it in a table for you below:

🧭 (Optional) Host Your Own XMPP Server

It’s possible (and often recommended) to host your own XMPP server (for example, using prosody or ejabberd); By doing this, you control the metadata, retention policies, and physical location of the service, as well as its availability, access, rules, and features. In a later tutorial, we’ll explore the step-by-step setup of a self-hosted XMPP server for those curious about the topic.

🔐 So… How Secure Is This?

Let’s be clear and transparent:

The cryptography between both options is equivalent, but real-world privacy depends on where (and how) your server is hosted. If you self-host or use a trusted provider, you get a security level very close to Signal’s without centralization.

Some additional (and somewhat basic) privacy tips

• Register with a pseudonym; Take advantage that unlike Signal, for example in this case PidginChat does not require a phone number.

• Delete the vCard data generated in the JetBrains Hub instance (if you choose to set up with PidginChat) and/or change your JID later.

• Consider using a VPN when registering on the hub for greater privacy.

• If your client allows it, force TLS and configure it to use port 443 instead of the default port (I think it’s 5222) to connect. Note, this does not interfere with other processes running on your client device.

Addendum: OMEMO Fingerprint Verification

Like Signal, OMEMO uses fingerprints per device. To avoid man-in-the-middle attacks, verify the fingerprints with your contacts. In almost any XMPP client, you’ll find OMEMO details in the contact’s information. Compare those fingerprints out-of-band (i.e., through a trusted channel different from the messenger, like a phone call or exchanging a QR code); Once verified, manually mark the device as trusted.

That said, for practicality, you can allow blind trust between devices (many XMPP clients do this by default, so you don’t have to manually verify keys before starting to chat to avoid friction), but anyhow, it’s always good to review their cryptographic fingerprints in one way or another.

Similarly, it’s very common for XMPP clients to have an icon or indication (usually a padlock icon in graphical clients, or the OMEMO status in text clients) within the conversation window to signal (pun not intended) whether that conversation is being end-to-end encrypted or not; So… always check the user interface: Verify that the indicator (graphical or not) shows that encryption is enabled for the conversation.

🧐 Closing thoughts

I’m not here to lightly claim that this setup is more secure than Signal; Signal is still unbeatable for its simplicity and network effect (many people use it); But setting up XMPP + OMEMO is a different kind of security: a scenario where you can own the infrastructure (your own server) and this brings freedoms like:

• Chat privately within your own network (or even with yourself just to pass messages between devices)

• Depending on the platform, integrate with automation scripts

• Connect any number of devices

• Run a chat system that never sends telemetry to third parties

Signal gave us easy-to-use encrypted messaging. XMPP + OMEMO gives us sovereign encryption: The ability to control, host, and understand everything that comprises our communications stack. You can start easily with PidginChat and evolve to a self-hosted service later.

🛠️ Mentioned Tools

1. PidginChat: https://pidgin.im/about/pidginchat

2. Gajim: https://gajim.org

3. Monal: https://monal-im.org

4. Converse.js: https://conversejs.org

5. Conversations: https://conversations.im

6. Profanity: https://profanity-im.github.io

7. Homebrew: https://brew.sh

Until next time! Don’t forget to subscribe and share.

Introduction

A common question from users migrating from Windows to Linux is: "How do I run .bat files on Linux?" In Windows, .bat files allow you to automate tasks by executing a series of sequential commands. In Linux, the functional equivalent is .sh files, also known as Bash scripts.

In this article, I will explain to you how to run .bat files on Linux using Wine, and also I’ll show you how to create and use .sh scripts to automate tasks on your Linux system, similar to what you can achieve on Windows with .bat files.

Executing .BAT files directly on Linux

Using Wine

Wine is a compatibility layer that allows you to run Windows programs and scripts on Linux systems. Although it's not always perfect, Wine can run many .bat files.

Installing Wine

To install Wine on Debian/Ubuntu based systems, execute

sudo apt-get install wine

For Fedora/CentOS, use

sudo dnf install wine

Running .BAT files with Wine

Once Wine is installed, you can run a .bat file with the following command

wine cmd /c file.bat

This command runs the .bat file in a simulated Windows console on Linux.

Limitations of Wine

• Compatibility: Wine does not guarantee that all Windows programs or scripts will work properly.

• Alternatives: If Wine cannot run your .bat file, consider rewriting it as a .sh script, or try other tools such as PlayOnLinux or Proton for more complex applications (note that using other compatibility tools does not guarantee the expected result)

Linux equivalent: .sh files

What is a Bash script?

A .sh file is a Bash script, a set of commands that are executed sequentially. These scripts allow you to automate tasks in Linux similar to how .bat files work in Windows, but with more flexibility.

To create a .sh script

Choose a text editor: You can use any text editor to create your .sh script. Some popular options are:

Nano (easy and available in most distributions):

nano script.sh

Vim (more advanced):

vim script.sh

Gedit (graphical interface, similar to Notepad on Windows)

gedit script.sh

Writing the script

Shebang (#!/bin/bash): This line should be at the top of the file. It tells the system to execute the script using bash.

#!/bin/bash

Basic structure

Here's a simple example of a script that updates the system and installs two programs:

#!/bin/bash
sudo apt-get update && sudo apt-get upgrade
sudo apt-get install program1 program2

Interactive example

.sh scripts can also interact with the user by prompting for input. Here's an example of an interactive .sh script:

#!/bin/bash
echo "What is your name?"
read name
echo "Hello, $name! This is an example of an interactive script."

This script prompts the user for their name and then prints it to the terminal.

Syntax Comparison Between .bat and .sh

Saving the file

Save the file with the .sh extension, for example: installer.sh

Making the script executable

To run the file, you must first make it executable with the following command

chmod +x installer.sh

You can also do this graphically: go to the file's properties, select the "Permissions" tab, and check the "Allow execution as program" box.

Running the script

There are two ways to execute the script:

1. From the terminal:

./installer.sh

2. Using the bash directly:

bash installer.sh

The difference is that the ./installer.sh command requires the file to be executable, while bash installer.sh can run the file without special permissions.

Scripting Basics

Using Variables

Variables allow you to store values for later use:

name="World"
echo "Hello, $name!"

Conditionals

You can execute commands based on conditions:

if [ -f file.txt ]; then
  echo "The file exists"
else
  echo "The file does not exist"
fi

Loops

Use loops to repeat commands:

for i in {1..5}
do
   echo "Number $i"
done

Practical script examples

System update script:

#!/bin/bash
sudo apt-get update && sudo apt-get upgrade

Backup script:

#!/bin/bash
tar -czvf backup.tar.gz /path/to/backup

Log analysis script:

#!/bin/bash
grep "error" /var/log/syslog > errors.txt

Advanced Topics

Debugging scripts

You can run a script in debug mode using the -x parameter:

bash -x script.sh

This will show every command that is executed and help you find errors.

You can also use set -e in your scripts. This command causes the script to stop immediately if an error occurs:

#!/bin/bash
set -e
sudo apt-get update
sudo apt-get install program1

Environment Variables

Environment variables allow you to set global configurations:

export PATH=$PATH:/new/path

Scheduling tasks with cron

You can automate the execution of your script using crontab:

1. Edit the crontab with

crontab -e

2. Add this line to run your script every day at 8:00 a.m:

0 8 * * * /path/to/script.sh

Wrong permissions

If you get a "Permission denied" error, make sure you've given your script execution permissions:

chmod +x script.sh

Syntax errors

If you get errors like "command not found", check the syntax of the script. Make sure all commands are spelled correctly and paths are correct.

Problems with sudo

If your script fails to execute commands with sudo, make sure the user has the appropriate privileges or run the entire script as superuser (root):

sudo ./script.sh

Using sudo in scripts

Use sudo only when necessary. If the entire script requires superuser privileges, you can run it like this

sudo ./installer.sh

Input Validation

It's important to validate the input your script receives to avoid errors or security issues. Here's an example of how to validate user input:

#!/bin/bash
read -p "Enter your age: " age
if ! [[ "$age" =~ ^[0-9]+$ ]]; then
   echo "Error: You must enter a valid number." >&2
   exit 1
fi
echo "Your age is: $age"

This script checks that the input is a valid number before continuing.

File Permissions

Make sure your scripts have the correct permissions. Use chmod to give them the proper permissions:

chmod 755 script.sh

Useful command line tools for creating scripts

When working with scripts, these command line tools can be very useful:

• grep: allows you to search for patterns in files.

• sed: useful for making substitutions and edits in text files.

• awk: helps you manipulate and extract data from files.

Glossary

• Shebang: the line at the beginning of a script that tells the system which interpreter to use (there are several interpreters or shells; bash, dash, zsh, fish, nushell, etc.)

• chmod: command to change the permissions of a file

• Cron: tool to schedule the execution of commands at regular intervals

• Variable: Container that stores values to be used within a script

• Debugging: Process of identifying and correcting errors in a script

Conclusion

.sh scripts are a powerful tool that allows you to automate a variety of tasks in Linux. Now that you know the basics and some advanced topics, I encourage you to keep exploring and practicing. Soon you'll be writing scripts that will save you a lot of time!

Related Resources

• Bash manual (Documentation)

• Bash Guide for Beginners

• Learn Shell: Interactive Online Tutorial

I have great news to share: Today marks the beginning of a new project that represents an evolution in my career in the world of technology: my newsletter on Substack.

A Passion Turned Into Reality

Over 15 years ago, I launched a digital consulting company with a simple idea: to create my own job. What started as a small personal project soon became much more: the venture grew, providing me not only with a source of income but also the opportunity to offer employment to others, forge lasting friendships, and build a client base that allowed us to dive into various areas and projects.

Through this venture, I immersed myself fully in the world of technology. I participated in open-source software projects and events, experimented with new tools, and most importantly, connected with a vibrant community of tech enthusiasts around the world. This experience eventually led me to the corporate world as a professional software developer, a journey I will always be grateful for. Having worked in large corporations, startups, “unicorns,” and renowned tech companies, that journey shaped me to get where I am now and has influenced much of who I am as a professional and person.

The Legacy Goes Beyond the Business

However, beyond the local and business scope, my consulting firm became an international community of tech enthusiasts, mostly united by open-source software. The digital channels (our blog, YouTube, social media, etc.) through which we reached so many people in Mexico and beyond were meeting points where we shared knowledge, debated ideas, and grew together (both us creating content and our followers interacting through comments and other means); Without much thought, I can say this was my favorite part of running a business. For me, one of the greatest satisfactions was creating content as a form of expression: writing a detailed technical article for the blog or doing a "distro review" (of GNU/Linux) for YouTube were processes I enjoyed a lot (albeit in different measures) because I knew I was making a lasting impact (no matter how big or small) on an international stage.

The Challenges of Change on the Internet

But, like everything in life, things changed one day: The internet evolved, and with it, content consumption preferences. Written format lost ground to videos, which demanded increasingly sophisticated production and specific durations: Blogs became video blogs, and little by little, attention cemented itself as the de facto currency of the internet, leading to the creation of a new content economy that, due to high levels of competitiveness, made content increasingly shorter, more visual, and faster to digest: Instagram Stories, TikToks, YouTube Shorts, and similar formats now dominate the audiovisual landscape on the internet.

For me, this transition (from its beginnings to its current evolution) was not easy. My passion has always been in writing, not so much in video production. Additionally, the idea of creating this type of content as a means of livelihood never really resonated with me... What did resonate was that, even though the AdSense or YouTube income was always minimal, my love for sharing knowledge never faded.

A New Horizon: Substack

And this is where Substack comes in.

The world of technology doesn’t stop, and with my years of experience, I still have a lot to share. After much research and reflection, I’ve decided to use Substack as a new channel to write, create audiovisual content, and share knowledge with you. No longer as a corporate entity (or necessarily part of one), but simply as Manuel Escudero, with all kinds of content formats condensed into one place.

I see Substack as the potential "YouTube of written format," reviving blogging and the community around it, but in an evolved way adapted to the current times (with relevant additions like podcasting features and video creation, use, and management in one platform); as a whole, Substack offers me the opportunity to reconnect with the previous community of my venture (and also with a new audience) in a way that feels authentic and fits perfectly with my love for writing as the main form of expression and content delivery.

What You Can Expect

1. Frequency: My plan is to publish about one or two articles per week. Quality will be my priority.

2. Topics: I’ll focus on practical issues I encounter in my daily endeavors, covering topics such as:

• Programming

• Open Source and GNU/Linux

• Machine Learning Ops

• Artificial Intelligence

• Cryptocurrencies and other relevant tech trends

(Also occasionally branching into topics outside the main editorial line)

3. Approach: I’ll share knowledge in the same way and with the same line of thinking as before: "This is a new challenge, a new project, a new problem I faced, and this is how I solved it." My goal is to foster discussions on ideas, techniques, and strategies in the realm of technology applied to real-world scenarios.

4. Free and Premium Content: I’ll offer both free articles and paid content. I believe a good balance can be focused on delivering high-quality free articles of general interest to most of the audience and dedicating the paywall to more specific topics like courses or similar formats of in-depth exploration and serialization. However, this strategy is flexible and something I’ll measure over time to adapt as needed.

A Bridge Between the Old and the New

While I already have some articles in the pipeline mainly centered on Artificial Intelligence (reflecting a recent personal project) and, interestingly, Evernote (something I’ve recently revisited after leaving personal knowledge management systems for quite some time), for those who have read me before, I say: Don’t worry! I won’t abandon the topics that brought us together in the first place, it’s important to clarify that:

• I’m still an active GNU/Linux user (mainly on servers)

• I maintain a homelab with a personal server on RHEL 8 for experiments (from which there’s plenty of material to write about)

• Although I now use OS X professionally, my main personal device is an iPad Pro that I use for everything, from web browsing to programming (I’ve always liked the idea of fringe computing, and that hasn’t changed)

And for those who are unfamiliar with my previous publications, I warmly welcome you and appreciate your attention to this project. I will strive to make the content useful and interesting for everyone who comes across it.

A bit of housekeeping: by the way, there will be a publication in both English and Spanish, you can visit the Spanish version here:

*Leunam (es-MX)

And if you’d like, I’d appreciate your proactive support by purchasing a subscription to this publication with over a 40% discount (22% additional lifetime discount added to the annual subscriptions for premium content); this promotion is intended for early adopters at the following link:

Get 22% off forever

Conclusion

I’m excited about this new beginning and grateful to everyone who chooses to join me in this new experiment. Technology continues to evolve, and with it, we must adapt and grow. The internet may have changed, but my passion for sharing knowledge remains intact. I’m sure this will be an interesting journey for all of us.

Talk soon!

Manuel.