Best of General Programming — April 2026

1. 1
   Article

   Programming Digest·7w

   Sorting algorithms

   Simon Willison used Claude Artifacts on his phone to build interactive animated demonstrations of common sorting algorithms (bubble sort, selection sort, insertion sort, merge sort, quick sort, heap sort). He then prompted Claude to add Python's Timsort by cloning the CPython repo from GitHub and consulting the source files. A 'run all' button was added to display all algorithms simultaneously in a grid. Notably, when GPT-5.4 Thinking reviewed Claude's Timsort implementation, it found it to be a simplified, Timsort-inspired adaptive mergesort rather than a true Timsort.

   143

   8
2. 2
   Article

   TkDodo·5w

   The Vertical Codebase

   Horizontal codebase structures that group code by type (components, hooks, utils, types) create poor cohesion and make large codebases hard to navigate. The alternative is a vertical structure that groups code by domain or feature — everything related to 'widgets' lives in src/widgets/, regardless of whether it's a component, hook, or utility. This mirrors how product teams are organized and reduces cognitive load. Shared code that spans multiple features becomes its own vertical. To enforce boundaries between verticals, tools like pnpm workspaces, Nx dependency rules, or eslint-plugin-boundaries can define public interfaces and prevent unintended coupling. The tradeoffs include difficulty choosing the right vertical and risk of duplicated implementations across teams.

   72

   4
3. 3
   Article

   freeCodeCamp·4w

   How AI Changed the Economics of Writing Clean Code

   AI coding tools have collapsed the cost of writing code, but the cost of reading and understanding code remains unchanged. This creates a new economic argument for using abstractions like interfaces: the boilerplate cost that historically justified skipping them is now near zero, while the cognitive load reduction they provide is as valuable as ever. Backed by neuroscience (Cognitive Load Theory, fMRI studies), historical CS wisdom (Dijkstra, Parnas, Fowler), and recent data (GitClear's code churn analysis, METR productivity study, Anthropic's comprehension study), the argument is that AI-generated code without good abstractions accumulates 'comprehension debt' — invisible erosion of team understanding that doesn't show up in velocity metrics. The contrarian cases against abstraction (performance, premature abstraction) are addressed and shown to be arguments against bad abstraction, not abstraction itself. The conclusion: with AI handling boilerplate, there's no longer an economic excuse to skip interfaces and proper abstractions.

   109

   19
4. 4
   Article

   Laravel·7w

   Meet Maestro: How We Manage 21 Laravel Starter Kit Variants

   Maestro is an internal orchestration tool built by the Laravel team to manage 21 starter kit variants across 8 repositories. Instead of manually propagating changes across every repo, Maestro uses a layered build system where shared, framework-specific, auth-specific, and feature-specific layers are composed into final runnable kits. Contributors work on a built variant in a single directory, and a watcher syncs changes back to the correct source layer using priority-based ownership logic. Placeholder restoration ensures framework-specific values don't leak into shared source files. The tool also provides CLI commands for linting, validation, and browser testing across the full matrix or a targeted subset, significantly reducing the cognitive overhead for contributors.

   31

   1
5. 5
   Article

   Baeldung·6w

   Getting a Cron Expression From Database for a Spring Boot Scheduled Job

   Two approaches for loading cron expressions from a database in Spring Boot are compared. The first uses a Spring bean (cronLoader) referenced via SpEL in @Scheduled, which is simple but only reads the value once at startup. The second uses SchedulingConfigurer to register a trigger task that re-reads the cron expression from the database before each execution, enabling runtime schedule changes without restarting the application. An H2 in-memory database with JPA is used for demonstration, along with a REST endpoint to update the cron value on the fly.

   20
6. 6
   Video

   Google for Developers·6w

   What is the most underrated tool for developers?

   Developers share their picks for the most underrated AI tool, with multiple respondents highlighting Anti-gravity as a standout multi-agent coding system. It is described as VS Code-like but with native AI capabilities spanning design to execution, generous model quotas, and usefulness for testing and building applications.

   15
7. 7
   Article

   Nx·5w

   Sharing Tailwind CSS Styles Across Apps in a Monorepo

   Tailwind v4's CSS-first configuration with @theme makes it straightforward to share design tokens across multiple apps in a monorepo. By placing a globals.css file with @theme directives in a dedicated shared package and referencing it via pnpm/npm workspaces, all apps can import the same colors, typography, and spacing tokens. Each consuming app just needs the @tailwindcss/vite plugin and a CSS entry point that imports both Tailwind and the shared package. For automating @source directives so Tailwind scans the right files across the dependency graph, the @juristr/nx-tailwind-sync Nx sync generator handles this automatically. A full working GitHub example is provided.

   15

   1
8. 8
   Article

   Whitespectre·6w

   Open-Source CMS as a Backend Platform: What It Replaces, and What's Still Custom

   A hybrid backend architecture pattern using an open-source CMS as a platform for a content-heavy mobile app is examined. The CMS handles collections, REST/GraphQL APIs, admin UI, database migrations, background jobs, and TypeScript types automatically. Custom engineering is reserved for composite endpoints, runtime personalization, and AI chatbot orchestration built on top of CMS hooks. A monorepo with shared TypeScript definitions between the CMS backend and React Native client catches schema mismatches at compile time. The post outlines when this pattern fits (frequent content model changes, small teams, predictable retrieval) and when it doesn't (highly relational data, mostly custom business logic, mature internal tooling already in place).

   14