DEV Community: Felipe Castillo

Why Are We Still Using Markdown in 2026?

Felipe Castillo — Sat, 04 Apr 2026 23:38:14 +0000

The Genius of Markdown's Original Design

To understand why Markdown persists, we need to appreciate what made it revolutionary.

Simplicity Above All

Markdown's genius was its deliberate simplicity. Gruber designed it to be:

Readable as plain text: No tags, no formatting symbols cluttering the content
Convertible to HTML: One tool, one output
Writers-friendly: You write like you're drafting an email

# This is a heading

**This is bold**

- This is a list item
  [This is a link](https://example.com)

Compare that to the HTML equivalent:

<h1>This is a heading</h1>
<strong>This is bold</strong>
<ul>
    <li>This is a list item</li>
</ul>
<a href="https://example.com">This is a link</a>

For a writer in 2004, the choice was obvious.

The Network Effect

Markdown spread because of GitHub. When GitHub launched in 2008 and made Markdown the default for README files, it created the world's largest Markdown ecosystem overnight.

Today:

Every repository has a README.md
Every GitHub issue and pull request uses Markdown
Millions of developers write Markdown daily

The Problems Nobody Talks About

Markdown's dominance doesn't mean it's perfect. In fact, several issues have plagued it since the beginning.

Problem 1: There Is No Markdown Standard

This is the elephant in the room. Markdown has no official specification that all implementations follow.

The original Markdown syntax from 2004 has been extended by:

GitHub Flavored Markdown (GFM)
CommonMark
Markdown Extra
MDX
Dozens of other variants

The result? The same file renders differently depending on the parser.

# This might work

## In this parser

### But not in this one

Some parsers support tables, others don't. Some support task lists, others ignore them. Your Markdown is not my Markdown.

Problem 2: The Ecosystem Is Fragmented

Because there's no standard, developers have built competing tools:

Tool	What It Does	The Problem
VS Code	Markdown preview	Extensions behave differently
HackMD	Collaborative Markdown	Sync issues
Obsidian	Markdown-based notes	Vault portability problems
Docusaurus	Markdown sites	Complex setup

Lock-in is real. Your notes in Notion aren't Markdown. Your notes in Obsidian are Markdown, but try moving to Logseq or Bear.

Problem 3: Advanced Use Cases Break the Model

Markdown was designed for prose and basic formatting. When you need more, it starts to crack:

<!-- Trying to do something complex in pure Markdown -->

For technical documentation, you end up embedding HTML anyway:

<details>
    <summary>Click to expand</summary>
    This works, but now you're writing HTML inside Markdown.
</details>

At that point, why not just write in a format designed for complex content?

Problem 4: Security Vulnerabilities

Markdown parsers have been the source of real security vulnerabilities:

XSS attacks via malicious links
HTML injection through crafted input
Path traversal in some implementations

Because parsers handle HTML differently, some render dangerous content that others block.

What Are the Alternatives?

If Markdown has these problems, what should we use instead?

Alternative 1: AsciiDoc

AsciiDoc is what Markdown wants to be when it grows up.

= Document Title
Author Name <author@example.com>

== Section Title

Here's a paragraph with *bold* and _italic_ text.

[source,ruby]
----
puts "Hello, World!"
----

Pros:

True standard (AsciiDoc Specification)
Native tables, includes, and advanced features
Excellent for technical documentation

Cons:

Steeper learning curve
Less adoption than Markdown
Fewer tooling options

Alternative 2: reStructuredText

Popular in the Python world, reStructuredText is powerful but verbose.

==============
Document Title
==============

This is a paragraph with *emphasis* and **strong** text.

.. code-block:: python

   print("Hello, World!")

Pros:

Used by Python's documentation (Sphinx)
Extremely powerful for technical docs
Built-in cross-referencing

Cons:

Ugly syntax
Limited adoption outside Python community
Complex build process

Alternative 3: MDX

MDX extends Markdown with JSX components.

import { Chart } from './components/Chart'

# My Document

<Chart data={salesData} />

Pros:

Markdown + React components
Great for documentation with interactive elements
Used by content platforms

Cons:

Requires build step
Not plain text anymore
Limited editor support

Alternative 4: Plain HTML + CSS

Some argue we should just use the web's native technologies.

<article>
    <h1>Document Title</h1>
    <p>This is a paragraph.</p>
</article>

Pros:

Full power of the web
No parsing ambiguity
Every tool supports it

Cons:

Verbose for writers
Steep learning curve
No lightweight editing experience

Why Markdown Won Anyway

Despite its flaws, Markdown dominates. Here's why that makes sense:

1. The Network Effect Is Unbeatable

GitHub has over 100 million users, all writing Markdown. When everyone around you uses a tool, you use it too. This is Metcalfe's Law in action.

2. "Good Enough" Beats "Better"

Yes, AsciiDoc is technically superior. Yes, reStructuredText has more features. But Markdown is good enough for 80% of use cases, and that 80% doesn't need more.

3. The Tooling Has Matured

Look at the Markdown tooling available today:

VS Code with Live Preview
Typora, Obsidian, iA Writer
GitHub, GitLab, Bitbucket all support it natively
Static site generators: Jekyll, Hugo, Docusaurus, Astro

Once an ecosystem reaches this size, switching costs become prohibitive.

4. It's Human-Readable by Default

Unlike HTML or XML, Markdown files are readable without rendering. You can read a README.md in a terminal and understand it.

This matters for:

Code reviews
diffs in version control
grep searching files
plain text editors

5. The Rise of the Markdown-First Workflow

Modern tools have embraced Markdown as the universal format:

Tool	Role
Obsidian	Local Markdown notes
GitHub	Markdown repositories
Notion	Hybrid (exports to Markdown)
Astro	Markdown based sites
VS Code	Markdown editing

Your Markdown files today will be readable in 50 years. Can you say the same about your Notion notes or Google Doc?

The Future: What Comes After Markdown?

So if Markdown isn't perfect, what might replace it?

Possibility 1: A Standardized Markdown 2.0

Some are pushing for a unified Markdown specification that addresses the fragmentation. CommonMark was a step in this direction, but adoption remains incomplete.

Possibility 2: AI-Assisted Writing

What if your editor understood your intent?

[AI interprets: "add a table comparing X and Y"]

AI tools might abstract away formatting entirely, letting you write naturally while the system handles structure.

Possibility 3: Structural Editors

Tools like Tldraw's dev edgition or Canva's Docs show a future where you manipulate structure visually, not through text.

Instead of writing:

# Heading

Paragraph text

You'd manipulate blocks directly, with the text format being an export option.

Conclusion

Markdown isn't the best format. It's not even particularly good in some ways. But it's good enough, everywhere, and established.

Here's the pragmatic truth:

For documentation and READMEs: Markdown is the de facto standard. Use it.
For technical documentation with complex requirements: Consider AsciiDoc or reStructuredText.
For notes and personal writing: Markdown gives you portability. Use Obsidian or plain files.
For content heavy websites: Use Astro with Markdown/MDX. You'll thank yourself later.

The question isn't whether Markdown is perfect. It's whether switching to something better is worth the cost.

In 2026, for most developers and writers, it isn't.

What do you think? Is Markdown still the right choice, or have we been too quick to accept "good enough"? Share your thoughts below.

How to Solve Your First LeetCode Problem: A Beginner's Guide

Felipe Castillo — Sat, 04 Apr 2026 03:06:50 +0000

How to Solve Your First LeetCode Problem: A Beginner's Guide

LeetCode has become the favorite playground for developers preparing for technical interviews. With over 3,500 problems ranging from "easy" to "hard," it's easy to feel overwhelmed before you even write your first line of code.

If you've ever opened LeetCode, stared at a problem for 30 minutes, and closed the tab in frustration, you're not alone. This guide exists because every developer who now aced their coding interview was once exactly where you are now.

We'll solve a real LeetCode problem together, step by step. By the end, you'll have a repeatable system for tackling any new problem.

Índice

Why LeetCode Matters
Before You Start: The Right Mindset
Understanding the Problem: Two Sum
Step 1: Read and Break Down the Problem
Step 2: Think Through Examples
Step 3: Identify the Data Structure
Step 4: Write the Solution
Step 5: Test Your Solution
Common Patterns to Memorize
Resources to Keep Learning
Conclusion

Why LeetCode Matters

LeetCode isn't just about solving puzzles. It's about developing algorithmic thinking, the ability to break down complex problems into manageable pieces.

What LeetCode Actually Tests

Problem decomposition: Can you understand what the problem is asking?
Pattern recognition: Have you seen similar problems before?
Code implementation: Can you translate your idea into working code?
Optimization: Can you improve your initial solution?

Real-World Benefits

Beyond interviews, LeetCode helps you:

Think like a programmer: You learn to approach problems systematically
Understand data structures deeply: Implementation teaches more than reading
Build confidence: Solving hard problems feels rewarding
Join a community: Millions of developers share solutions and discuss approaches

Before You Start: The Right Mindset

Before diving into problems, set realistic expectations:

The 30-Minute Rule

Never stare at a problem for more than 30 minutes without help. If you're stuck:

Re-read the problem description
Try manually solving with examples
Check hints (LeetCode provides them)
Look at similar problems tagged with the same concepts

Easy Doesn't Mean Easy

LeetCode's "Easy" problems are called Easy because their solution is short, not because they're trivial. Many Easy problems still require insight that comes from practice.

You Will Fail

Every expert has solved hundreds of problems wrong before finding the right approach. Failure is part of the process, not a sign you don't belong.

Understanding the Problem: Two Sum

We'll solve LeetCode #1: Two Sum, the classic introductory problem that every developer encounters.

The Problem

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example:

Input: nums = [2, 7, 11, 15], target = 9
Output: [0, 1]
Explanation: nums[0] + nums[1] = 2 + 7 = 9

This problem has been solved by over 1 million users on LeetCode. Let's solve it together.

Step 1: Read and Break Down the Problem

Before writing any code, answer these questions:

Questions to Ask Yourself

What are the inputs? → An array of integers, a target integer
What are the outputs? → Indices of two numbers (array order doesn't matter)
What are the constraints? → We need to find exactly one solution, can't reuse the same element
What should I return if no solution exists? → The problem guarantees exactly one solution exists

Write Down What You Understand

Input:  nums = [2, 7, 11, 15], target = 9
Output: [0, 1]

We need: nums[i] + nums[j] = target, where i ≠ j

Step 2: Think Through Examples

Manually solve a few examples to build intuition.

Example 1

nums = [2, 7, 11, 15], target = 9
2 + 7 = 9 ✓ → indices [0, 1]

Example 2

nums = [3, 2, 4], target = 6
3 + 2 = 5 ✗
3 + 4 = 7 ✗
2 + 4 = 6 ✓ → indices [1, 2]

Example 3

nums = [3, 3], target = 6
3 + 3 = 6 ✓ → indices [0, 1]

Step 3: Identify the Data Structure

This is where pattern recognition kicks in.

The Naive Approach (O(n²))

The brute force solution checks every pair:

def two_sum(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

Time Complexity: O(n²) - we check every pair
Space Complexity: O(1) - no extra space needed

This works, but LeetCode will likely time out on large inputs. We can do better.

The Optimal Approach (O(n))

Key Insight: For each number x, we need to find target - x.

Instead of looking backward (checking all previous numbers), we can look forward using a Hash Map:

def two_sum(nums, target):
    hashmap = {}  # value -> index

    for i, num in enumerate(nums):
        complement = target - num
        if complement in hashmap:
            return [hashmap[complement], i]
        hashmap[num] = i

    return []

How it works:

For each number, calculate what we need to reach the target
If that complement already exists in our map, we found our pair
Otherwise, store this number and its index for future lookups

Time Complexity: O(n) - single pass
Space Complexity: O(n) - storing numbers in the map

Step 4: Write the Solution

Here's the complete solution in Python:

from typing import List

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashmap = {}  # Maps number -> index

        for i, num in enumerate(nums):
            complement = target - num

            if complement in hashmap:
                return [hashmap[complement], i]

            hashmap[num] = i

        return []  # No solution found (shouldn't happen per problem constraints)

Alternative Solutions

JavaScript:

var twoSum = function (nums, target) {
    const hashmap = new Map()

    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i]

        if (hashmap.has(complement)) {
            return [hashmap.get(complement), i]
        }

        hashmap.set(nums[i], i)
    }

    return []
}

C++:

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashmap;

        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];

            if (hashmap.count(complement)) {
                return {hashmap[complement], i};
            }

            hashmap[nums[i]] = i;
        }

        return {};
    }
};

Step 5: Test Your Solution

LeetCode provides test cases automatically, but you should verify your solution manually.

Test Cases to Try

# Test 1: Basic case
print(two_sum([2, 7, 11, 15], 9))  # Expected: [0, 1]

# Test 2: Mid-array solution
print(two_sum([3, 2, 4], 6))  # Expected: [1, 2]

# Test 3: Duplicate values
print(two_sum([3, 3], 6))  # Expected: [0, 1]

# Test 4: Negative numbers
print(two_sum([-1, -2, -3, -4, -5], -8))  # Expected: [2, 4]

Common Mistakes to Avoid

Forgetting to check the complement before adding - Always check, then add
Using the same index twice - Our approach naturally avoids this
Not handling edge cases - Negative numbers, zeros, large arrays

Common Patterns to Memorize

LeetCode problems often reuse these fundamental patterns:

1. Two Pointers

# Use when: You need to find pairs in a sorted array
def two_pointer_example(arr, target):
    left, right = 0, len(arr) - 1
    while left < right:
        current = arr[left] + arr[right]
        if current == target:
            return [left, right]
        elif current < target:
            left += 1
        else:
            right -= 1

2. Sliding Window

# Use when: Finding subarrays/substrings with specific properties
def sliding_window_example(arr, k):
    window_sum = sum(arr[:k])
    max_sum = window_sum

    for i in range(k, len(arr)):
        window_sum += arr[i] - arr[i - k]
        max_sum = max(max_sum, window_sum)

    return max_sum

3. Hash Map for Lookups

# Use when: You need O(1) lookups for previous elements
def hashmap_example(nums, target):
    hashmap = {}
    for i, num in enumerate(nums):
        if target - num in hashmap:
            return [hashmap[target - num], i]
        hashmap[num] = i
    return []

Resources to Keep Learning

Practice Platforms

Platform	Best For	Difficulty Range
LeetCode	Interview prep, curated problems	Easy → Hard
NeetCode	Structured learning, video solutions	Easy → Medium
Codeforces	Competitive programming, speed	Medium → Hard
HackerRank	Fundamentals, certificates	Easy → Medium

Study Plans

NeetCode 150: Curated list of 150 essential problems
LeetCode Top 100 Liked: Problems the community loves
Grind 75: 75 problems optimized for interview prep

YouTube Channels

NeetCode: High-quality video explanations
Take U Forward: Systematic approach to problems
BackToBack SWE: Detailed visual explanations

Conclusion

Solving your first LeetCode problem is a milestone. What felt impossible becomes manageable once you have a systematic approach.

What We Learned

Understand the problem before writing code
Work through examples manually first
Identify patterns you've seen before
Start simple (brute force), then optimize
Use the right data structure for fast lookups

Your Next Steps

Practice: Solve 1-2 Easy problems daily for the first week
Review: After solving, read other solutions to learn alternatives
Time yourself: Eventually aim for 15-20 minutes per Easy problem
Build habits: Consistency matters more than intensity

The Truth About LeetCode

You don't need to solve 1,000 problems to ace your interview. Most engineers who pass interviews have solved 100-300 problems with genuine understanding, not memorization.

The difference between those who succeed and those who give up isn't intelligence, it's persistence and methodical practice.

If you found this guide helpful, share it with fellow developers starting their LeetCode journey. See you in the next post!

Ready for more? Check out our guide on Data Structures Every Developer Must Know to build the foundation for tackling harder problems.

How to Install Arch Linux with Archinstall in 2026 (Quick Guide)

Felipe Castillo — Fri, 03 Apr 2026 07:40:38 +0000

Archinstall Quick Guide

If you're really interested in getting an Arch system but don't have time for a manual installation, this guide is for you. Archinstall is an official Arch Linux tool that lets you install the operating system semi-automatically, guiding you through an interactive process. Here's a quick guide to installing Arch Linux with Archinstall in 2026.

This guide includes the script for a video created by @barrazadev, which can be found at the following link: Link.

ISO and Boot

First, we need to download the Arch ISO and use our USB drive with Rufus or Ventoy. Don't worry—there's a link in the description below explaining how to do the latter. Rufus Video Tutorial and Ventoy Video Tutorial. Once you have your bootable USB drive, you need to boot from it. To do this, depending on your computer, press a key such as F12, F2, or Del to access the boot menu and select your USB drive.

Once you've booted the Arch Linux ISO on your Virtual Machine or Physical Hardware, a small interface with various options will appear; select the first one (Arch Linux Install Medium), To continue, we need to verify that we have an Internet connection. We’ll run the “ping” command to the IP address “1.1.1.1” as follows: “ping 1.1.1.1”. If you only have Wi-Fi to connect to the Internet, don’t worry— here’s a video explaining how to connect to Wi-Fi networks using the Terminal How to connect to Wi-Fi via the terminal. Once you’re ready, simply type the command: “archinstall”.

Archinstall

Next, we'll look at the ArchInstall menu with its various options. To navigate through them, use the up and down arrows; to select an option, press the Enter key; and to go back, press the Escape key.

I’ll go over each of the options available in the Archinstall menu.

Installation Guide

Language

Here you can select the installer's language. If you like, you can choose your native language—in my case, Spanish—but for the purposes of this guide, I'll keep the language set to English by pressing the Enter key.

Locales

Here, you need to select the keyboard layout; in your case, you can choose ES for Spanish or US for English.
Under “Local Language,” select the one that corresponds to your country, such as es_CL.UTF-8 or en_US.UTF-8. It's important that it be UTF-8. Leave the last option as the default and click “Back.”

Mirrors

In this section, I recommend selecting your country or the one closest to you. This is to ensure that package downloads are as fast as possible. When selecting the country, press the “Space” key and then return.

Disk Configuration

In this menu, select the option labeled “Partitioning,” and choose the first option again—the one that says “Use a default partition layout.” You must be very careful with this step, all the disks on your machine will appear here; you must select the disk where you want to install Arch. Keep in mind that this will completely format that disk, erasing any files or data on it. Always make sure to back up your files before performing any installations. If you’re sure about the disk, select it using the “Space” key and press “Enter” to continue. We’ll select “EXT4” as our filesystem. If you see an option that says: “Would you like to create a separate partition for /home?”, I recommend selecting “Yes.” This will be helpful if you decide to do distrohopping frequently.

We won't be touching the LVM and encryption options today; they're basically for encrypting the disk, but they aren't necessary for your first installation.

Swap

The Swap option is enabled by default, and we'll leave it that way, since swap space is a portion of storage used as virtual memory when RAM runs out. Although it isn't as fast as RAM, it can help prevent the system from crashing when it runs out of memory.

Bootloader

In the bootloader, we’ll also leave it as is, selecting the Grub option. This is because it’s the most common bootloader and is compatible with most systems, unless you have a specific reason to choose another one, such as if you want to use systemd-boot or rEFInd.

Kernels

Under the “Kernels” option, only one Linux kernel is included by default. To ensure greater security against potential failures, we will also add the Linux-LTS kernel. The LTS (Long-Term Support) kernel is a version of the kernel that receives long-term support, meaning it receives security patches and bug fixes over an extended period, typically several years. The LTS kernel tends to be more stable and reliable.

Hostname

In the “Hostname” field, you can enter the machine's name. You should only change this if you wish to do so; it is not necessary for the system to function, but it is good practice to identify your machine on the network.

Authentication

In the Authentication section, the first step is to create a password for the Root user. This password is important, so make sure you don’t forget it. Confirm the password, then go to User Account and add a user by clicking Add a User. Enter a name and password, confirm the password, and when asked if you want to make this user a superuser, click Yes. Finally, click Confirm and Exit to return to the menu.

Profile

In the “Profile” option, you need to select the type of profile you want; there are four in total (Desktop, Server, Minimal, and Xorg). We’ll focus on the first option, called Desktop. Now you’ll see the different desktop environments. You can select more than one, but I recommend playing it safe and choosing just one—it could be KDE, XFCE, or Cinnamon. In my case, I’ll select XFCE. Once you’ve selected the ones you want, press “Enter.”

When it comes to graphics drivers, it depends on each person and their settings; in my case, I'll leave it set to “All open-source.”

In the login manager (or Greeter), select the default option and click Back.

Applications

Under “Applications,” select ‘Bluetooth’ and “Audio.” For Bluetooth, select “Yes,” and for Audio, I recommend Pipewire.

Network Configuration

In the network settings, select the option labeled Use Network Manager (default backend).

Additional Packages

In the “Additional Packages” section, this isn't necessary, since we can install any missing programs later.

Timezone

Here we need to select our time zone; in my case, America/Santiago.

NTP

We leave the NTP option enabled, as it is by default.

Pasos Finales

And that's it! Here we have an Arch Linux system ready to be installed, with video drivers and a graphical environment set up in no time.

As a final step, click Install. You’ll be asked if you want to apply the settings; click Yes, and the installation will finally begin. This may take a while depending on your computer and internet connection. Once the installation is complete, you’ll see three options. Select the first one, which says Exit Archinstall, and enter the command “shutdown now” to shut down the computer immediately. Once the computer is off, remove the USB drive and turn the computer back on.

Post Install

When you log in, you'll see a login screen; enter the user's password, and you'll be able to see the desktop.

To check your internet connection, simply open a terminal and type the same command as before, “ping 1.1.1.1”, and you'll see that you have an internet connection.

We’ll also check for any pending updates by entering the command “sudo pacman -Syu”. When we do this, it will ask for the root password; we’ll type it in and press “Enter.” Since there are no pending updates, I’ll install a small script to view the machine’s components. To install it, I’ll type “sudo pacman -S fastfetch” in the terminal; it will ask for confirmation and begin installing. Once the package is installed, I’ll run it from the console by typing “fastfetch”, and it will display my system’s components.

Conclusion

As you saw in both the video and this guide, installing Arch Linux with Archinstall is a fairly simple and quick process, ideal for those who want to enjoy the benefits of Arch without the hassle of a manual installation. Archinstall offers a guided experience that simplifies the process, allowing you to set up your system efficiently and customize it to your liking. If you’re new to the world of Arch Linux or simply want a quick installation, Archinstall is an excellent option to start your adventure with this powerful distribution.

Best Linux distributions to get started in 2026

Felipe Castillo — Fri, 03 Apr 2026 07:06:50 +0000

Which distribution should I choose?

If you've made it this far, you're probably tired of forced Windows updates and privacy issues, or you're simply curious about which “penguin” (Tux) distribution everyone's been talking about.

Making the switch to Linux in 2026 is easier than ever, but the first hurdle is often a common dilemma: Which distribution should I choose from the hundreds of options out there? In this post, we’ll demystify the process of choosing your first “distro” and introduce you to the best options so you can make the switch to Linux once and for all.

What is a Linux distribution?

For a beginner, the word “distribution” (or distro) might sound intimidating or confusing. But think of it this way:

The Linux kernel is the engine of a vehicle. It’s the part that makes everything move, but you can’t sit on an engine and drive it around town. You need a chassis, seats, a steering wheel, lights, and a dashboard.

A Linux distribution is the complete vehicle. It’s a package that takes the engine (Kernel) and adds a visual interface (Desktop), a window manager, an app store, and configuration tools.

The best thing about Linux is that, unlike Windows or macOS, there are manufacturers in the Linux world that create vehicles for racing, others for the countryside, and others for everyday use in the city. Those are the distros.

Criteria for Choosing Your Distro

Before downloading any ISO file, you should make sure that the distribution you choose meets these three essential requirements:

Ease of use (Learning curve):

As a beginner, you don’t want to spend hours typing strange commands on a black screen (the famous terminal). We’re looking for a distro where you can set up Wi-Fi, install Chrome or Spotify, and change the wallpaper with just a couple of clicks. If you already have experience, you can opt for more advanced distros.

Community support (Forums and documentation):

Sooner or later, you’ll want or need to do something and won’t know how. If you use a popular distro, the answer to your problem will be just a Google search away. A large community means YouTube tutorials, active forums, and plenty of documentation. Honorable mention to the Arch wiki.

Stability:

There’s nothing more frustrating than your system breaking after an update. For your first experience, you need what we call “stability”—software versions that have been thoroughly tested and won’t throw you a curveball on a Monday morning when you have a deadline.

Recommended Distributions

Ubuntu

Ubuntu is, without a doubt, the most recognizable face of Linux today. Developed by the company Canonical, its goal since 2004 has been to bring Linux to everyday users and those unfamiliar with it.

Why choose it?: It is the distribution with the most support in the world. If a program exists for Linux, it will almost certainly have a version designed specifically for Ubuntu.

Interface: It uses a desktop environment called GNOME. It is modern, somewhat resembles the logic of a smartphone (with an activities button and an app dock), and is very visually clean.

Strength: Its LTS (Long-Term Support) version. This means that if you install the stable version, you’ll have support and security updates guaranteed for 5 or even 10 years without having to reinstall everything.

Weakness: “Snap” (its app store) can be a bit slow when opening apps.

Alternatives: Debian, Xubuntu, Lubuntu.

Linux Mint

If you close your eyes and think about what a computer should look like, you probably imagine a Start button in the bottom-left corner, a taskbar, and windows that minimize. That’s exactly what Linux Mint offers with its “Cinnamon” desktop.

Why choose it?: It’s incredibly lightweight and “familiar”. You don’t have to relearn where things are. Mint feels like what Windows 11 should have been: fast, sleek, and without telemetry.

Ease of use: It includes a “Driver Manager” that automatically detects if your graphics card or Wi-Fi card needs software and installs it for you.

Strength: Its “if it ain’t broke, don’t fix it” philosophy. It’s one of the most robust and least error-prone distros available today.

Weakness: Its update cycle is more conservative; you won’t always have the latest version of programs as soon as they’re released.

Fedora

Fedora is the distribution typically used by the creator of Linux himself, Linus Torvalds. It is known for serving as a “testing ground” for new technologies.

Why choose it?: If you want to try out the latest Linux features before anyone else, Fedora is the place for you. Despite using very modern software, it is surprisingly stable.

Focus: It is fully committed to free software. It does not install proprietary programs by default, giving you a very pure Linux experience.

Strength: It’s a favorite among software developers. If you plan to learn to code, Fedora offers the most up-to-date tools on the market.

Weakness: Its lifecycle is short (you must update the entire system every 6–12 months).

Arch Linux

There are no fancy installers with buttons here. Arch is installed from a terminal, and you decide which components to include in your system.

Why choose it?: You want a minimalist operating system where you have complete control over every aspect of your system.

Target audience: Advanced users who want to learn how Linux works from the inside out, or those who want a unique, customized system.

Strength: The AUR (Arch User Repository), where you can find practically any software in existence.

Weakness: It’s easy to break the system if you don’t read the update news, if you configure something incorrectly, or if you overuse the AUR.

Alternatives: Manjaro, EndeavourOS, CachyOS.

NixOS

A revolutionary distribution that treats your operating system as if it were a **time machine.

Why choose it?: If something goes wrong, you can roll back to a previous state with a single click at boot.

Target audience: DevOps and system administrators who need to replicate the same configuration across 100 computers.

Strength: Declarative configuration. Your entire system lives in a single text file.

Weakness: Its file structure is completely different from any other Linux distribution, which can be confusing at first.

Comparison Chart

Distribution	Ease of use	Community support	Stability	Target audience
Ubuntu	Very high	Excellent	High	Beginners, general users
Linux Mint	Very high	Excellent	Very high	Users switching from Windows
Fedora	High	Very Good	Medium-High	Developers, advanced users
Arch Linux	Low	Excellent	Medium	Advanced users, enthusiasts
NixOS	Medium	Good	Very high	DevOps, system administrators

Which one should you choose based on your profile?

If, even with all the information provided, you’re still wondering “Which one should I download right now?” Let’s break it down:

The User Looking to Escape Windows:

If you want your PC to run fast, without the menus being moved around, and to be able to use your usual files, Linux Mint is the winner. It’s the smoothest possible transition.

Student or First-Time User:

If you need a laptop for browsing, writing documents, watching Netflix, and maybe playing a few games on Steam, Ubuntu is the way to go. Since it’s the most popular, any online tutorial will work for you right away.

Programmer, Self-Taught User, or Tech Enthusiast:

If you like to tinker, want to understand how the system works from the inside, and always have the latest software versions for your coding projects, install Fedora or Arch. It will force you to learn a little more, but the reward is worth it.

Conclusion

The most important thing to understand is that in Linux, there are no wrong choices. Unlike other systems, nothing here is permanent. You can try Ubuntu today, and if you’re not convinced, switch to Fedora in 20 minutes without losing your files—provided you do things right (by separating / and /home onto different partitions).

There is no such thing as the “perfect distro” or the “perfect desktop”; there is only what best suits your needs today. Linux is freedom, and that freedom starts with choosing your own adventure.

Python vs JavaScript vs Go in 2026: Which Language Should You Learn Right Now?

Felipe Castillo — Fri, 03 Apr 2026 05:26:06 +0000

Choosing your first or next programming language is one of the most consequential decisions you'll make as a developer. The language you learn shapes not just how you write code, but what kinds of problems you can solve, where you can work, and how much you can earn.

In 2026, three languages dominate the conversation: Python, JavaScript, and Go. Each has distinct strengths, different ecosystems, and caters to different career paths. But which one should you invest your time in learning right now?

This guide breaks down each language objectively so you can make an informed decision based on your goals, not hype.

Índice

The Quick Answer
Python: The King of Data and AI
JavaScript: The Language of the Web
Go: The Modern Systems Language
Head-to-Head Comparison
Use Cases and Job Markets
Learning Curve and Resources
Salary Insights
Which Language Should You Learn?
Conclusion

The Quick Answer

There is no single "best" language only the right language for your goals:

Choose Python if you want to work in data science, machine learning, AI, automation, or scientific computing
Choose JavaScript if you want to build websites, web apps, or work in frontend/full-stack development
Choose Go if you want to work in backend systems, cloud infrastructure, DevOps, or high-performance services

Still unsure? Read on for the detailed breakdown.

Python: The King of Data and AI

Python has been the most popular introductory programming language for years and for good reason. Its readable syntax, gentle learning curve, and incredible ecosystem make it the default choice for beginners and experts alike.

Why Python Dominates in 2026

Python's momentum hasn't slowed. If anything, the AI revolution has accelerated its adoption:

AI/ML Frameworks: TensorFlow, PyTorch, Keras all Python first
Data Science Stack: pandas, NumPy, SciPy, Matplotlib are industry standard
Automation: Scripts, bots, and workflow automation with minimal boilerplate
Scientific Computing: Bioinformatics, physics simulations, financial modeling

Code Example: Python's Simplicity

# Data analysis with pandas
import pandas as pd

df = pd.read_csv('sales_data.csv')
top_sellers = df.groupby('product')['revenue'].sum().sort_values(ascending=False)
print(top_sellers.head(10))

# Machine learning with scikit-learn
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)
accuracy = model.score(X_test, y_test)
print(f"Model accuracy: {accuracy:.2%}")

The Trade-offs

Strength	Weakness
Easy to learn	Slower execution than compiled languages
Massive ecosystem	Not ideal for mobile development
AI/ML dominance	Global Interpreter Lock (GIL) limits true parallelism
Great for scripts and automation	Weak for browser-based frontends

JavaScript: The Language of the Web

JavaScript is the only language that runs natively in browsers, making it indispensable for web development. But in 2026, JavaScript has expanded far beyond the browser.

Why JavaScript Remains Essential

Full-Stack Development: Node.js brought JavaScript to the server
Frontend Frameworks: React, Vue, Angular power modern UIs
Mobile Apps: React Native, Expo build cross-platform mobile apps
Desktop Apps: Electron allows building desktop apps with JavaScript
Serverless Functions: AWS Lambda, Vercel, Netlify all support JavaScript

Code Example: JavaScript's Versatility

// Frontend: React component
function ProductCard({ name, price, image }) {
    const [inCart, setInCart] = useState(false)

    return (
        <div className='product-card'>
            <img src={image} alt={name} />
            <h3>{name}</h3>
            <p>${price.toFixed(2)}</p>
            <button onClick={() => setInCart(true)}>{inCart ? 'Added!' : 'Add to Cart'}</button>
        </div>
    )
}

// Backend: Express.js API endpoint
app.get('/api/products/:id', async (req, res) => {
    const product = await Product.findById(req.params.id)
    res.json(product)
})

The Trade-offs

Strength	Weakness
Runs everywhere (browser, server, mobile)	Callback hell and async complexity
Massive ecosystem (npm has 2M+ packages)	Type safety issues without TypeScript
High demand for web developers	Can be inconsistent across environments
Great community and learning resources	Security vulnerabilities in dependencies

Go: The Modern Systems Language

Go (or Golang), developed by Google in 2009, was designed to solve specific problems: fast compilation, easy concurrency, and simplicity. In 2026, it's become the language of cloud infrastructure and backend systems.

Why Go Is Winning in 2026

Cloud Native: Kubernetes, Docker, Terraform all written in Go
Backend Services: High-performance APIs and microservices
DevOps Tools: CI/CD pipelines, monitoring, logging
Concurrency: Goroutines make parallel programming elegant
Fast Compilation: No waiting minutes to compile

Code Example: Go's Simplicity and Power

package main

import (
    "encoding/json"
    "net/http"
    "github.com/gin-gonic/gin"
)

type Product struct {
    ID    string  `json:"id"`
    Name  string  `json:"name"`
    Price float64 `json:"price"`
}

func getProduct(c *gin.Context) {
    id := c.Param("id")

    // Simulated database call
    product := Product{ID: id, Name: "Laptop", Price: 999.99}

    c.JSON(http.StatusOK, product)
}

func main() {
    r := gin.Default()
    r.GET("/products/:id", getProduct)
    r.Run(":8080")
}

Concurrency Example: Goroutines

func fetchData(url string, results chan<- string) {
    resp, _ := http.Get(url)
    defer resp.Body.Close()
    results <- fmt.Sprintf("Fetched from %s: status %d", url, resp.StatusCode)
}

func main() {
    urls := []string{"https://api.github.com", "https://api.twitter.com", "https://api.linkedin.com"}
    results := make(chan string, len(urls))

    for _, url := range urls {
        go fetchData(url, results)
    }

    for i := 0; i < len(urls); i++ {
        fmt.Println(<-results)
    }
}

The Trade-offs

Strength	Weakness
Blazing fast compilation and execution	Smaller ecosystem than Python/JavaScript
Built-in concurrency (goroutines)	Verbose error handling
Statically typed with simplicity	No generics (until recently)
Excellent for cloud infrastructure	Limited use outside backend/systems

Head-to-Head Comparison

Criteria	Python	JavaScript	Go
Syntax Ease	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Performance	⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐
Job Market	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Ecosystem Size	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
AI/ML Support	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐⭐
Web Dev	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Systems/DevOps	⭐⭐	⭐⭐	⭐⭐⭐⭐⭐
Learning Resources	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Salary Potential	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐

Use Cases and Job Markets

Python: Data, AI, and Automation

Primary Roles:

Data Scientist
Machine Learning Engineer
AI Researcher
Backend Developer (Django/FastAPI)
DevOps Engineer (automation scripts)
QA Engineer (test automation)

Industries: Tech, Finance, Healthcare, Research, Government

Job Market Size: Very large, growing fast due to AI boom

JavaScript: The Full Stack

Primary Roles:

Frontend Developer
Full-Stack Developer
React/Node Developer
Mobile App Developer (React Native)
UI/UX Engineer

Industries: Every industry that has a web presence (basically all of them)

Job Market Size: Largest of the three—every company needs web developers

Go: Cloud and Infrastructure

Primary Roles:

Backend Engineer
Cloud/DevOps Engineer
Site Reliability Engineer (SRE)
Systems Programmer
Platform Engineer

Industries: Cloud providers (AWS, GCP, Azure), FinTech, Startups

Job Market Size: Smaller but highly specialized and well compensated

Learning Curve and Resources

Python: Easiest Entry

Why it's easy:

English-like syntax reads almost like pseudocode
Extensive documentation and tutorials
"Batteries included" philosophy less boilerplate
Massive beginner-friendly community

Best Resources:

Time to Basic Proficiency: 2-3 months of consistent practice

JavaScript: Steeper but Essential

Why it's challenging:

Async programming (promises, async/await) adds complexity
Prototype-based inheritance confuses OOP developers
Rapidly changing ecosystem (frameworks evolve fast)
TypeScript now expected for serious work

Best Resources:

Time to Basic Proficiency: 3-4 months (6+ for full-stack)

Go: Simple but Different

Why it's straightforward:

Minimal syntax only 25 keywords
No classes, only functions and structs
Explicit error handling (no exceptions)
Excellent documentation

Why it can be tricky:

Goroutines and channels have a learning curve
Memory management differs from Python/JS
Smaller community means fewer learning resources

Best Resources:

Time to Basic Proficiency: 2-3 months

Salary Insights

Salaries vary significantly by location, experience, and company size. Here's a general 2026 US baseline:

Role	Python	JavaScript	Go
Junior (0-2 years)	$70,000 - $95,000	$65,000 - $90,000	$80,000 - $110,000
Mid-Level (3-5 years)	$95,000 - $140,000	$90,000 - $130,000	$120,000 - $160,000
Senior (5+ years)	$130,000 - $200,000+	$120,000 - $180,000+	$150,000 - $220,000+
Specialized (ML/AI)	$150,000 - $300,000+	N/A	N/A

Key Insight: Go developers command the highest average salaries due to scarcity and demand in cloud infrastructure. Python specialists in AI/ML can exceed these ranges significantly.

Which Language Should You Learn?

Learn Python if...

You want to break into data science, machine learning, or AI
You're interested in automation, scripting, or bots
You're coming from a non-technical background
You need to quickly prototype ideas
You're targeting research or academia

Learn JavaScript if...

You want to build websites or web applications
You're interested in full-stack development
You prefer visual, interactive results early on
You want the largest job market and most flexibility
You enjoy working with frameworks and libraries

Learn Go if...

You want to work on cloud infrastructure or DevOps
You're interested in high-performance backend systems
You prefer simplicity and explicitness over flexibility
You want to work at tech companies (especially FAANG-adjacent)
You're tired of complexity in other languages

The "Why Not Both" Approach

These languages aren't mutually exclusive. Many developers learn multiple:

Python + Go: Data engineer or ML ops roles
JavaScript + Python: Full-stack with data skills
Go + Python: Cloud native developer with automation
All three: Senior roles with maximum flexibility

Conclusion

There's no wrong choice here only a choice that may be more or less aligned with your goals.

Python remains the gateway drug to programming and the dominant language for the AI era. If you want to work with data, build AI models, or automate tasks, Python is your safest bet.

JavaScript is the language of the web, and the web isn't going anywhere. If you want to build websites, apps, or dive into full-stack development, JavaScript is non negotiable.

Go is the language of the cloud, and cloud infrastructure is the backbone of modern tech. If you want performance, simplicity, and top salaries in backend systems, Go is your fastest path.

My recommendation: If you're completely new to programming, start with Python. If you know Python and want to expand, learn Go for systems work or JavaScript for web work. If you're already a web developer, add Go to your toolkit for backend opportunities.

Whatever you choose, commit to building projects. No language is mastered by watching tutorials alone. The best developer is the one who ships code, regardless of the language.

Axios Compromised: How a Backdoored npm Package Dropped a RAT on 100M+ Downloads

Felipe Castillo — Wed, 01 Apr 2026 07:48:17 +0000

Axios Compromised: How a Backdoored npm Package Dropped a RAT on 100M+ Downloads

The JavaScript ecosystem just suffered one of its most significant supply chain attacks in recent memory. Axios, the ubiquitous HTTP client library downloaded over 100 million times per week, was compromised when attackers gained access to a maintainer's npm account and pushed malicious versions containing a Remote Access Trojan (RAT).

This is not just another security headline. If you use Node.js in any capacity—whether for backend APIs, frontend builds, or DevOps scripts—this incident affects you directly.

Índice

What Happened
How the Attack Worked
The Timeline of Events
Which Versions Were Affected
How to Check if You Were Affected
What Attackers Could Do With the RAT
The npm Ecosystem Problem
How to Protect Yourself
Lessons Learned
Conclusion

What Happened

On March 30, 2026, security researchers at StepSecurity discovered that the popular axios npm package—used by millions of developers for making HTTP requests in JavaScript and TypeScript applications—had been backdoored.

Attackers compromised an existing maintainer's account and published malicious versions (axios@1.14.1 and axios@0.30.4) that included a Remote Access Trojan. The trojan was disguised within the package's build process, making it difficult to detect through standard auditing methods.

The attack was sophisticated: it didn't modify the source code directly but injected malicious code during the post-install script execution, allowing attackers to:

Execute arbitrary code on developer machines
Steal environment variables (including API keys and credentials)
Establish persistent remote access
Spread laterally within CI/CD environments

How the Attack Worked

The attackers leveraged a technique that security teams call "dependency confusion" combined with "typosquatting" elements. However, in this case, they went straight for the maintainer account—indicating either a phishing compromise or credential stuffing attack.

The Infection Vector

// Malicious code was injected into postinstall scripts
// disguised as part of the normal build process

// The RAT connected to an external server and awaited commands
const net = require('net')
const { exec } = require('child_process')

// This code ran silently during npm install
// Exfiltrating environment variables and system info

Why This Was Effective

Trusted package: Axios is used by major frameworks and companies
Silent execution: The malicious code ran in postinstall scripts
Wide reach: 100M+ weekly downloads meant massive impact potential
Persistence: The RAT could survive reinstallation attempts

The Timeline of Events

Date	Event
March 28, 2026	Attackers compromise maintainer account
March 29, 2026	Malicious versions published to npm
March 30, 2026	StepSecurity researchers discover the breach
March 30, 2026	npm removes malicious versions, notifies users
March 31, 2026	Full disclosure and technical analysis published

The attack went undetected for approximately 48 hours before being discovered and remediated.

Which Versions Were Affected

According to the official axios security advisory, the following versions were compromised:

axios@1.14.1
axios@0.30.4

How to Check if You Were Affected

Run these commands in your project directory:

# Check your axios version
npm list axios

# View detailed dependency tree
npm ls axios

# Check for postinstall scripts
grep -r "postinstall" node_modules/axios/package.json

For Package.json Inspection

// Check your package.json for affected versions
{
    "dependencies": {
        "axios": "1.14.1" // VULNERABLE
    }
}

GitHub's Advantage

If you use Dependabot or GitHub Actions, check your security advisories tab. GitHub automatically flagged projects using vulnerable versions.

What Attackers Could Do With the RAT

Once installed on a developer's machine, the Remote Access Trojan had broad capabilities:

Data Exfiltration

// The RAT could steal:
// - AWS/GCP/Azure credentials from environment
// - npm tokens and registry authentication
// - SSH keys
// - Database connection strings
// - API keys for third-party services

process.env.API_KEYS // All environment variables
process.env.AWS_ACCESS_KEY
process.env.NPM_TOKEN

Lateral Movement

The RAT wasn't limited to the developer's machine. In CI/CD environments, it could:

Access production credentials stored in secrets managers
Modify build artifacts to inject backdoors into released software
Pivot to internal corporate networks
Establish command-and-control channels for future attacks

Real-World Impact Scenarios

Developer machine compromised → SSH keys stolen → Production servers accessed
CI/CD pipeline compromised → Malicious code injected into app → Users download backdoored software
npm token stolen → More packages compromised → Supply chain escalates

The npm Ecosystem Problem

This incident highlights a systemic vulnerability in the JavaScript package ecosystem. With over 2 million packages and billions of daily downloads, npm has become an attractive target for attackers.

The Numbers

2.1M+ packages in the npm registry
100B+ weekly downloads
17M developers using npm
1 compromise can affect millions of projects

Why Traditional Security Fails

Security Measure	Effectiveness Against This Attack
Code review	❌ Malicious code injected at build time
npm audit	❌ RAT was obfuscated
Lockfiles	❌ Lockfile guarantees the malicious version
Type checking	❌ Runtime malicious code not caught

The Maintainer Account Problem

The root cause is simple: account security. npm's model relies on maintainers securing their accounts, but:

No mandatory 2FA enforcement (until recently)
Password reuse across breaches
Lack of behavioral monitoring
No hardware security key requirement

How to Protect Yourself

Immediate Actions

Update axios immediately

npm install axios@1.14.0
# or
yarn add axios@1.14.0

Rotate all credentials that were present during the affected period:
- npm tokens
- Cloud provider keys
- API keys
- SSH keys
Audit your environment variables for suspicious access

Long-Term Security Practices

Use `npm audit` and `socket.dev`

# Install socket.dev for enhanced package analysis
npm install -g @socket.dev/npm
socket npm audit

Implement Lockfiles Strictly

# Ensure your CI/CD uses --frozen-lockfile
npm ci --frozen-lockfile

Enable npm's Enhanced Security Features

# Enable 2FA with security keys
npm profile enable-2fa --security-key

# Use token-based authentication
npm token create --readonly

Monitor Your Dependency Tree

# Use tools like Socket, Snyk, or GuardDog
npx @socket.dev/npm audit --package axios@>=0.21.0

Lessons Learned

For Developers

Lock your dependencies: Use package-lock.json and npm ci in CI/CD
Verify package integrity: Use npm audit and third-party tools
Principle of least privilege: Don't give packages more permissions than needed
Monitor your environment: Use secret scanning tools like GitHub's secret scanning

For Organizations

Supply chain security is critical: Treat dependencies as first-class security concerns
Implement runtime protection: Use tools like Sysdig, Falco, or similar
Network segmentation: Isolate CI/CD environments from production
Incident response plans: Have a playbook for supply chain attacks

For the Ecosystem

Mandatory 2FA: npm should enforce hardware security keys for popular packages
Code signing: Implement provenance attestation for packages
Automated threat detection: AI/ML-based anomaly detection for package behavior
Maintainer security training: Education on phishing and credential security

Conclusion

The Axios supply chain attack is a stark reminder that open-source security is everyone's responsibility. While the JavaScript ecosystem's scale and convenience are remarkable, that same scale makes it an attractive target for malicious actors.

The good news: this attack was discovered and remediated relatively quickly. The malicious versions were available for only 48 hours before npm removed them. However, in that window, thousands of projects may have been compromised.

Immediate action items:

Update axios to version >= 1.14.0
Rotate any credentials that were exposed
Implement the security practices outlined above
Share this information with your team

The security of your applications depends not just on your code, but on the code you trust. Stay vigilant, audit your dependencies, and never assume that popular packages are automatically safe.

If you found this article helpful, share it with your fellow developers. See you in the next post!

I built an open source developer hub to showcase projects and profiles – looking for feedback

Felipe Castillo — Fri, 27 Mar 2026 04:47:02 +0000

Hi everyone,

I’ve been building OpenCodex, a developer hub focused on helping developers showcase their work, projects and skills in a simple and structured way.

The idea came from a personal frustration:

LinkedIn feels too formal and not dev-focused
GitHub is great, but it’s just code and not very “presentable” as a profile

So I’m trying to build something in between a personal hub for developers.

Current features:

Developer profiles (/username)
Featured profiles
Better profile SEO and indexing for Featured profiles

Future features:

Harvard-style CV generation (/username/cv)
GitHub README sync (using raw README)
GitHub stats cards integration
Project pages with README rendering (/username/projectId)
Dev Card generator (exportable profile card)
GitHub OAuth

I’m currently looking for early users and, more importantly, honest feedback from developers.

If you have thoughts, I’d really appreciate it.

Link: https://opencodex.app