Tagged “development”

  1. JavaScript 2025: New Stable Features to Boost Your Code

    ~ cat post <<

    JavaScript 2025: New Stable Features to Boost Your Code

    Hey there! JavaScript became 30 years old in 2025. Despite being created for browsers’ front-end code, it gained more space than expected in the backend. ECMAScript 2025 (ES16), released in June, brought a handful of stable features that make coding smoother without forcing you to kneel before the latest framework altar. In this post, I’ll walk you through the standout additions with practical examples, and for each, I’ll show how you’d do the same thing the old-school way — pre-ES2025. Spoiler: the new features save you some headaches, but the fundamentals still hold strong. Let’s dive in, no fluff, just code!

    1. Iterator Helpers: Functional Programming Without the Headache

    What’s New: Iterator Helpers introduce a global Iterator object that lets you chain operations like .map() and .filter() on any iterable (arrays, sets, generators) in a memory-efficient, lazy way. It’s functional programming without the bloat of intermediate arrays.

    Example with Iterator Helpers: Filtering and transforming a leaderboard of scores.

    //
    // Before
    //
    const scores = [100, 85, 90, 95, 70];
    const topScores = scores.filter((score) => score > 80).map((score) => `Score: ${score}%`);
    console.log(topScores); // ["Score: 100%", "Score: 85%", "Score: 90%", "Score: 95%"]*
    
    //
    // After ES2025
    //
    const scores = [100, 85, 90, 95, 70];
    const topScores = Iterator.from(scores)
    	.filter((score) => score > 80)
    	.map((score) => `Score: ${score}%`)
    	.toArray();
    console.log(topScores); // ["Score: 100%", "Score: 85%", "Score: 90%", "Score: 95%"]*
    
  2. Post Inception

    ~ cat post <<

    Post Inception

    A friend of mine, Rogério Lino, presented WordPress to me in 2005. It was an amazing blog tool: simple, fast, and very easily customizable.

    20 years later, and a dozen abandoned blogs that I've forgotten, I have created my website and professional blog. When I encountered WordPress again and tried to use it for my new blog, I found a bloated tool with excessive options, unnecessary plugins, managers, etc.

    I tried to customize it as I wished, with a layout resembling old green-screen CRT monitors. I gave up quickly and decided to look for an alternative.

    A few days later, I discovered 11ty (Eleventy). It is a static site generator that uses JavaScript, a template language of your choice for layout, and Markdown for post writing.

    In my post about the need for an HTML replacement, I wrote that XML is dying because of plenty of better options. In the same way, Markdown is by far better than HTML for writing text. It requires less code to achieve the same result. Unfortunately, I can't get rid of HTML completely yet, but for my posts, I am now free of it.

    I have created an awesome workflow for my posts (at least for me):

    I write my posts in Notion, where I can keep them, make changes, add links, leave, come back, change them again until I decide I’m done. Afterwards, I ask an LLM to review my poor English grammar—it used to be better when I was a teenager. No shame in that; it would be worse to post incorrect texts. When I finish adjusting the text, I ask an LLM to create an image to illustrate the post, and it's ready to go.

    Now, this is where things get really interesting. I copy the text from Notion into a Markdown file in my project along with its image. Then, I commit and push the project to the release branch on GitHub, where an Action is automatically executed. This action builds the HTML project and synchronizes the files with my hosting via FTP.

    11ty also generates the sitemap, robots.txt, and RSS feed XML (🤢). I really don't use SEO tools for writing: they tend to make my posts feel unnatural. If you don't the way I write, don't read; it's my memory leakage.

    For blog comments and reactions, I use a simple tool called Giscuss: this tool uses GitHub discussions to store these comments and reactions. You only need to configure the plugin to use a public repository discussion on GitHub. The readers must log in with their GitHub accounts to comment.

  3. This is not another post about the developer apocalypse

    ~ cat post <<

    This is not another post about the developer apocalypse

    Hundreds of professions have been completely obliterated since the human brain got smart enough to use a rock shard to defend itself. Today, a fan is so cheap that almost everyone can afford one. Hundreds of years ago, to stay cool, you had to be rich to hire someone to wave a giant fan while you did whatever you wanted.

    The creation of LLMs first created a mesmerizing feeling, but also brought back prophets of newly doomed professions. They’re not wrong: many professions will die, as many have before, and some should already be extinct. IT professions are currently marked for obsolescence, but the people predicting their demise are often the same ones selling AI and LLM solutions.

    However, this post isn’t about the downfall of any profession; it’s about a paradigm shift.

    Modern fans are not only less expensive than old-school human fans but also far more efficient, powerful, tireless, and privacy-preserving. A human fan doesn’t make sense anymore.

    But programmers? I’m sorry, you’re free to dislike them, but you can’t get rid of them: a well-prepared person with a machine is better than a machine alone, and there are many things they can do together.

    The Human in the Loop: Augmentation, Not Replacement

    Although writing software tests is good practice, many companies, especially smaller ones, don’t write them or write them poorly. Why? Writing good tests to cover all happy and sad paths is boring and expensive. Good tests require more lines of code than the tested code itself, and with limited budgets and time, it’s a real problem. On the other hand, using AI to detect potential bugs and implement automated tests is awesome.

    Even though they can generate automated tests, LLMs will always hallucinate: they create tests that don’t make sense and sometimes claim the tests are faulty and should be adjusted to fit the function’s results. This is where developers shine: they can evaluate these issues and make the proper interventions. This human oversight is crucial not just for correcting errors, but for managing the scale of a project.

    To put it another way, let’s suppose you, a regular person, decide to build a house tile by tile. It will take you months and cost more than you can afford. But when you see a house, your brain instantly recognizes it as a house. The same applies to a skyscraper, a neighborhood, or an entire city, and it applies to many things LLM AIs can do. While they can build fast, we can quickly check if it works.

    Those used to LLMs for development know: you must request small portions of code, or you have to write lengthy prompts to specify all restrictions. The latter is a waste of time, while the former is faster than writing every line of code.

~ <<

See all tags .