somedood

I've been writing a lot of agent skills at my day job. For many enterprises, the humble SKILL.md...

I don't consider myself a vibe coder. I like reading the code. More specifically, I want to architect...

I first joined the DEV community 8 years ago (as of writing) to jump-start my writing journey and get...

Long-running agentic workflows will inevitably hit a context wall: the context window fills, compaction runs, and layered summaries start replacing the details you still needed. In this article, we discuss the Principle of Least Context and what that looks like in practice, especially towards effective map-reduce workflows.

A while back, I wrote about vertically sliced architectures. Today, we revisit the notion of a feature-driven project structure because it also happens to optimize for the way coding agents explore and manipulate codebases.

The difference between iterables, iterators, and generators in Python have always been a tricky topic for beginners to learn—so much so that not everyone can think in terms of iterators even later in the Python journey. This article consolidates into one master reference all of my internal lecture notes, private Notion documents, Discord posts, and direct messages on iterators.

This is the story of how I made a Monte Carlo simulation of student schedule assignments 600x faster with web workers. In this article, we'll discuss how I upgraded CourseCast (a course schedule simulator for the Course Match system of the Wharton School of the University of Pennsylvania) from a prototype that struggled with a hundred concurrent users (with ~60 seconds per simulation request) to an infinitely scalable simulator with sub-second execution speeds (faster than a page load!).

For the longest time, the separation of concerns has been the ultimate guiding principle of software engineering. This eventually gave rise to the ubiquitous MVC architecture. But, in this article, we'll explore a better way to structure a codebase using a vertically sliced architecture.

It is common wisdom in the programming world to discourage the use of global variables. I've recently come across a bug that humbled and reminded me about these pitfalls. Let me tell you a cautionary tale about global configuration objects.

I've dealt with a wide spectrum of programming languages over the years. One common theme that I've observed is that object-oriented programming patterns tend to yield the most verbose and indirect abstractions. In this article, we explore how pure object-oriented code necessarily leads to more verbose code and more opaque indirections.

For the longest time, I've always thought that JavaScript generators perform better than chained array methods in terms of execution time. But are generators actually faster than chained array methods? It's finally time to put that to the test—with statistical rigor of course!

The comma operator is one of the lesser-known operators in C-like languages such as JavaScript and C++. Essentially, it delimits a sequence of expressions and only returns the result of the final one. So why would this ever be useful? In this article, I present a compelling case—perhaps the only one frankly speaking—for the comma operator.

So one of my articles from my naive 2018 self finally bit me in the back side. Six years and one computer science degree later, I have vastly changed my perspective on bitmasks. In this article, we will discuss why bitmasks are not so esoteric and impractical after all.

A recent trend has shaken up the JavaScript-TypeScript community: the anti-build-step movement. In this article, however, I will not argue whether TypeScript is still relevant today. Instead, I reflect on my own journey of stepping away from TypeScript—but for a completely different reason: consumer semantics!

Cybernetically enhanced web apps: Svelte is Stack Overflow's most admired JavaScript UI framework in 2023. In this article, we review the merits of the Svelte framework and its wider ecosystem.

Have you ever spent more than a few seconds staring at the same line of code? How often did you find conditionals that were tricky to parse? In this article, we discuss how confusing conditionals manifest in our code. Along the way, we also explore different refactoring techniques for improving the readability of conditional control flows.

In this article, I reflect on my experiences with trunk-based development as the project lead for DocTrack, my undergraduate project that rewrites the University of the Philippines' document tracking system as a progressive web app.

More often than not, we find that promises and events have fundamental incompatibilities that make them difficult to interleave. Ultimately, can promises and events coexist? In this article, we explore this question and propose a neat solution.

In this article, we implement a safe implementation of a direct-address table using unsafe code in Rust. In doing so, we explore the mindset and thought processes involved when upholding safety.

After an entire semester of C assignments, I share how Rust patterns and idioms helped me power through it all.

If there's anything about Rust that Rustaceans have a particular aversion to, it would most certainly be cloning and heap allocations. In this article, we will explore how taking advantage of immutability allows us to optimize memory usage.

At the moment, there is no standardized way to write asynchronous constructors in JavaScript. However, this does not mean there aren't any workarounds! In this article, we will discuss the various ways to emulate `async` in `constructor`. Most of them are not-so-ideal, but in the end, I will demonstrate the proper way.

As strange as it may seem, generic `impl` blocks actually have macro-like capabilities. When coupled with the trait system, Rust offers a powerful mental framework for composition-based polymorphism. In this article, we will explore how treating generic `impl` blocks like macros can be an insightful shift in perspective when dealing with generics and trait bounds.

The Rust programming language has steadily been on the rise in terms of adoption and popularity. But is all the hype justified? In this article, I reflect on my experience with Rust in the past year, tackling the golden moments as well as the pain points.

The modern Web boasts leaps and bounds of progress in recent years. The Web has truly become a capable, reliable, scalable, and viable platform for modern applications. However, with all of these fancy features comes the cost of complexity. Build systems rendering the Web as a compilation target have become a common trend among production-grade applications. For new aspiring developers (such as ourselves back then), is this really the best path forward?

In the previous article, I discussed the best practices for ES6 promises. Picking up from where we left off, I extend the discussion to ES2017 asynchronous functions, which happen to just be "syntactic sugar" over promises.

ES6 promises are great! Yet... they are still quite painful to deal with. In this article, I share the best practices I have learned over the years that helped me make the most out of asynchronous JavaScript.

Learning JavaScript is a wild, tempestuous journey. With so much to learn, it is difficult to keep up with the times. Here are 18 videos I consider to be "essential" in learning JavaScript at a deeper level. Each of these videos once sparked a "eureka moment" within me that ultimately helped in piecing together the JavaScript puzzle.

Setting aside harsh connotations for now, "constructive stupidity" plays a major role in one's motivation to learn. In this article, I illustrate how a shift in mindset (on "stupidity") can foster a healthy, constructive attitude towards learning.

Cryptography is the fundamental lifeblood of computer security. Unfortunately, with all the hardcore theory and mathematics, it has become one of the least approachable topics in computer science. In this article, as part of our exploration into the essence of cryptography, we will look into the difference between ciphers and hashes.