MoreRSS

site iconThe Practical DeveloperModify

A constructive and inclusive social network for software developers.
Please copy the RSS to your reader, or quickly subscribe to:

Inoreader Feedly Follow Feedbin Local Reader

Rss preview of Blog of The Practical Developer

So, you want to vibecode a linkblog?

2026-03-05 20:27:56


I'm starting here a series of posts about diverse projects I'm developing using some vibecoding (and, sometimes, some manual intervention to organize the resulting code). I'm not going to provide prompts (there are lots of 'experts' out there that can prepare suggestions for you, hehe).

For the first project, a bit of context: I've been sharing links in my social accounts (let's use the Mastodon one for reference, https://mastodon.social/@fernand0, but there are instances at Bluesky, Tumblr, LinkedIn, ...). The origin was Twitter, where some of my friends were sharing links from time to time in their accounts; but, you know, maybe you are reading the web, you see things that are interesting and you start posting them. The result is that in a short period of time you see a lot of links from you friend (good if you have time at that moment and can check them; bad if you are paying attention to other things and you forget about it). When I decided to share my own links I thought that it would be nice to do this along the day with two obectives: to not contaminate the timeline of my followers with a sudden burst of links, and to allow some of them to see a link at an appropriate moment and, maybe, if they were interested they could check other previously posted links.

I started with some external tools and later I developed my own (see for example, So, you want to publish in Bluesky with a python program?) but I wanted to keep a record of them in some more permanent place (social networks are becoming less and less reliable, difficult to find, ...) so I decided to setup a linkblog.
You can check some steps in the process in this X thread (in Spanish).

Voy a probar a hacer un linkblog con gemini, poniendo los enlaces que publico en redes sociales. A ver qué sale.

— fernand0 (@fernand0) December 10, 2025

First of all, I modified my publishing programs to keep a (local) copy of each link published modulePublicationCache and then I thought about using it for my linkblog.
I like very much jekyll for a blog and I requested to some AIs (mainly Qwen and Gemini) to help me to develop a blog based on the links I has posted the previous day, prepare a list with them, and prepare a Jekyll post. I also requested to set up a site, following my 'corporative' look and feel from my other sites and, voilà!

It started coding, the list_links_by_date.py program which generates the list of links, prepares the markdown jekyll post, the daily_post.sh, which calls the previous program and makes the 'administrative' stuff: add, commit, push, ....
I requested them to add a README.md and the thing started publishing (using a VPS server I have and a cron job)

 15 0 * * * $HOME/usr/src/web/deGitHub/linkblog/scripts/daily_post.sh

and generating the fernand0's linkblog under my domain, hosting it using GitHub pages.

I haven't paid much attention to it but it published reliably each night the daily post (it has failed once for some GitHub problem).

Some ideas about the process:

  • It was impressive to see it create a new Jekyll site for you, and it was a bit more of work to request for changes in order to obtain the desired look and feel.
  • The program part is quite simple, almost any junior programmer could do it, but it is the sort of things that you do not start because there is a not so short list of small things that are easy to do but you always have other things that need more attention.
  • The AIs can help you with the steps to configure everything. With this basic (free) versions you'll need to follow the steps (they won't do for you everything) but it is quite easy.
  • Sometimes when vibecoding one feels as shepherding: you give instrucctions to the tool and you need to pay attention to what it is doing in order to get what you want.
  • It is easy to test 'whatifs': what if I write the list in such a way? What if you generate this in this alternative way?

The result? fernand0's linkblog. I'm sharing like a dozen of links each night.

The following steps could be:

  • Generate an email with these links and send them to anybody interested (I started something like this with Revue, the newsletter tool that allowed you to create a mailing list with your posts, which was bought and closed as a service Twitter shuts down Revue, its newsletter platform).
  • Improving my linkblog with some comments about each link: it would be some manual work (I wouldn't like to add an AI generated abstract, that's not the idea). If I found an easy way to extract/write some ideas when reading the articles (I'm posting links to sites that I've actually read, or, sometimes, that I will read) it could be attached to the links, but I need to think a bit more about how to manage this.
  • More cosmetic improvements (could the main page show the latest posts and then a list of the other posts? Maybe we should add pagination?,...)

Step-by-Step Guide: Deploy a Containerized App to AWS

2026-03-05 20:27:30

This guide explains the steps I followed to containerize an application and deploy it to AWS using Docker, Terraform, ECS Fargate, and GitHub Actions.

The goal is simple.
Build the app, package it in Docker, store the image in ECR, run it on ECS Fargate, and automate the deployment with GitHub Actions.

Let's get started

1. Prepare the Application

Create a simple Node.js application.

Example project structure:

app/
server.js
package.json
Dockerfile
terraform/

Install dependencies:

npm install

Run the application locally to confirm it works.

node server.js

Open:

http://localhost:3000

2. Containerize the Application

Create a Dockerfile.

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install --production

COPY . .

EXPOSE 3000

CMD ["node", "app/server.js"]

Build the image:

docker build -t job-tracker-app .

Run the container locally:

docker run -p 3000:3000 job-tracker-app

Open the browser:

http://localhost:3000

Application on local

3. Create an Amazon ECR Repository

Open AWS Console.

Go to:

ECR → Create repository

Give it a name:

job-tracker-app

After creating the repository, push your Docker image.

Login to ECR:

aws ecr get-login-password --region us-east-1 \
| docker login --username AWS --password-stdin ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com

Tag the image:

docker tag job-tracker-app:latest ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/job-tracker-app:latest

Push the image:

docker push ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/job-tracker-app:latest

AWS ECR

4. Provision Infrastructure with Terraform

Create infrastructure using Terraform.

Resources created include:

  • VPC
  • Public subnets
  • Security groups
  • ECS cluster
  • ECS service
  • Application Load Balancer

Initialize Terraform:

terraform init

Apply infrastructure:

terraform apply

Confirm the ECS service is running.

You should see:

1/1 tasks running

ECS

5. Verify the Application

Once the ECS task is running, the application can be accessed using the public IP assigned to the service.

Open the IP address in the browser to confirm the application is working.

Application on AWS

6. Push the Project to GitHub

Initialize git:

git init
git add .
git commit -m "Initial commit"

Create a repository on GitHub.

Connect the repo:

git remote add origin YOUR_REPO_URL
git branch -M main
git push -u origin main

7. Add GitHub Actions for CI/CD

Create this folder in your repository:

.github/workflows

Create a file:

deploy.yml

The workflow should:

  • build the Docker image
  • push the image to ECR
  • update the ECS service

8. Add AWS Credentials to GitHub

In your GitHub repository, go to:

Settings → Secrets → Actions

Add these secrets:

AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY

These allow GitHub Actions to deploy to AWS.

9. Trigger Deployment

Push a change to the repository:

git push

GitHub Actions will start the pipeline.

The pipeline will:

  • build the Docker image
  • push it to ECR
  • update the ECS service

Your application will be redeployed automatically.

Final Result

You now have:

  • A containerized application.
  • Infrastructure created with Terraform.
  • Containers running on ECS Fargate.
  • Automated deployment using GitHub Actions.

This setup removes manual deployment and keeps the application updated whenever code changes.

If you found this article helpful, share it with others who may find it interesting.

Other Helpful Resources

Stay updated with my projects by following me on Twitter, LinkedIn, and GitHub.

Thank you for reading

The Adventures of Blink S5e1: Kicking off the Build

2026-03-05 20:25:00

Hey friends, welcome to Season 5 of The Adventures of Blink! Today we kick off the new season of Youtube videos with the setup work for a retro gaming build: We're writing Breakout in Python!

Make sure to leave me a Like 👍🏻, a Comment 💬, and Subscribe to the channel. It's free for you, but it helps me reach more people who can learn from our adventures together!

#java #collections #programming #datastructures

2026-03-05 20:19:39

Java Concepts I’m Mastering – Part 12: ArrayList vs LinkedList

Continuing my journey of mastering Java fundamentals.

Today’s concept: ArrayList vs LinkedList — two important classes from the Java Collections Framework.

Both store collections of elements, but they work differently internally.

ArrayList

ArrayList is backed by a dynamic array.

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");

Best for:

Fast random access

Reading data frequently

Limitation:

Inserting or deleting elements in the middle can be slower.

LinkedList

LinkedList is implemented using nodes connected by pointers.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("Java");
list.add("Python");

Best for:

Frequent insertions and deletions

Working with queues or stacks

Limitation:

Accessing elements by index is slower.

Key Difference
ArrayList LinkedList
Dynamic array Doubly linked list
Faster access Slower access
Slower insert/delete Faster insert/delete

What I Learned

Use ArrayList for fast data access.

Use LinkedList when modifying data frequently.

Understanding data structures helps write efficient programs.

Next in the series: HashMap in Java (Key-Value Data Storage)

Surviving an Apple "Sherlock" and a 12-month cash burn

2026-03-05 20:19:25

What do you do when you spend months building an AI-powered iOS keyboard to proofread text, and then Apple announces native proofreading in iOS 26? You panic, joke that Tim Cook is stealing your ideas, and then you adapt.

I just published a 16-month retrospective on building my app, Smart Keys. It started as a basic WordPress site using ChatGPT prompts and evolved into a full iOS and MacOS tool for text transformation.

The biggest technical and product takeaways:

  • Platform native is hard: The iOS ecosystem is tough for acquisition, but building the MacOS version actually became my personal favorite (even if I have no idea how to market it).

  • Retention over Acquisition: We burned cash for a year with a low ROAS. But because our Month 4 retention was >60%, the math eventually flipped in our favor.

I wrote a detailed breakdown of the development journey, the failed marketing experiments, and how I finally reached profitability without taking VC money. You can read the full architecture and business teardown on my dev log: diego.horse

Why Most WordPress Websites Fail Accessibility (WCAG) And How to Fix It

2026-03-05 20:17:52

Web accessibility is becoming an increasingly important topic in modern web development. As websites become more complex, ensuring that everyone can access and use them properly is no longer optional.

Many developers assume that accessibility is automatically handled by modern frameworks or themes. Unfortunately, that is rarely the case.

Even well-designed WordPress websites often contain accessibility barriers that make them difficult to use for people who rely on assistive technologies such as screen readers or keyboard navigation.

In this article, we will look at why accessibility issues are common in WordPress websites and what developers can do to improve them.

What is Web Accessibility?

Web accessibility refers to designing and developing websites so they can be used by people with different abilities.

This includes users who rely on:

  • screen readers
  • keyboard navigation
  • voice control software
  • alternative input devices

The most widely accepted accessibility standards are the Web Content Accessibility Guidelines (WCAG) published by the World Wide Web Consortium.

Most organizations aim for WCAG Level AA, which balances accessibility and practical implementation.

Why Many WordPress Websites Have Accessibility Issues

WordPress powers a large portion of the web, but accessibility problems are still common. Here are several reasons why.

1. Themes Are Not Always Fully Accessible

Many WordPress themes focus heavily on visual design but overlook accessibility structure.

Common problems include:

  • missing ARIA labels
  • incorrect heading hierarchy
  • poor color contrast
  • inaccessible navigation menus

Even premium themes sometimes fail accessibility tests.

2. Plugins Can Break Accessibility

Plugins add powerful features to WordPress, but they can also introduce accessibility barriers.

For example:

  • popups that trap keyboard users
  • forms without labels
  • dynamic content that screen readers cannot interpret

Because plugins are developed by different teams, accessibility standards are not always consistent.

3. Automated Accessibility Tools Are Limited

Many developers rely entirely on automated tools to detect accessibility issues.

While these tools are helpful, they typically detect only a portion of WCAG violations.

Manual testing is often required to identify issues such as:

  • screen reader behavior
  • keyboard navigation flow
  • focus management

Common Accessibility Problems in WordPress

Some of the most frequent issues include:

Missing alternative text

Images without alt text cannot be interpreted by screen readers.

Improper heading structure

Skipping heading levels (for example H1 → H4) makes navigation difficult for assistive technologies.

Poor keyboard navigation

Interactive elements should be accessible without using a mouse.

Low color contrast

Text that blends into the background becomes difficult to read for visually impaired users.

How Developers Can Improve WordPress Accessibility

Improving accessibility does not always require rebuilding a website from scratch. Small changes can make a big difference.

Here are some practical steps developers can take.

Use semantic HTML

Proper HTML structure improves how assistive technologies interpret your website.

Examples include:

  • using <button> instead of clickable <div>
  • proper heading hierarchy
  • labeled form inputs

Test with keyboard navigation

A quick way to check accessibility is to navigate the website using only the keyboard.

If users cannot reach menus, forms, or buttons without a mouse, accessibility needs improvement.

Check color contrast

Ensure that text meets recommended contrast ratios so it remains readable for users with visual impairments.

Test with screen readers

Testing with screen readers can reveal issues that automated tools miss.

Common screen readers include:

  • NVDA screen reader
  • VoiceOver screen reader

These tools help developers understand how their websites are interpreted by assistive technologies.

Accessibility Is an Ongoing Process

Accessibility should not be treated as a one-time task.

As websites evolve with new features and content, accessibility should remain part of the development workflow.

Improving accessibility benefits not only users with disabilities but also overall usability, SEO, and long-term website quality.

Final Thoughts

WordPress provides a powerful platform for building websites, but accessibility requires intentional effort from developers.

By following WCAG guidelines, testing with assistive technologies, and maintaining proper HTML structure, developers can build websites that are more inclusive and usable for everyone.

Small accessibility improvements can make a meaningful difference in how people experience the web.

WordPress ADA Compliance Service That Protects Your Business