Reflects on using Codex to finish the Algo Elixir package, covering where it helped, where it fell short, and why human review remained the bottleneck.
Introduces Algo, an Elixir utility package for practical data transformations with nested maps, keyword lists, collection helpers, and naming choices that make immutable updates read more clearly.
Brief thought
Whenever problematic effects of technology are discussed in software engineering circles, it’s common to hear “but people did this before technology X as well”. For example, “AI voice cloning supercharges phone scams” is met with “but scams existed before”. This kind of refrain is completely, utterly wrong.
Quantity acquires a quality of its own, ie. the technological leverage changes the situation so much that pointing to history is invalid. Technology has had a transformative effect on many things – spam, social media, social engineering – and it’s also the case with AI slop and other AI-assisted malfeasance.
Brief thought
“There are only two kinds of programming languages: the ones everyone complains about, and the ones nobody uses.” - Bjarne Stroustroup
This quote has been popping up in every C++ discussion for decades and I think it’s less a witticism and more a thought-terminating cliche. It’s extremely reductive and for the most part it serves to shut down the possibility of better languages and better ways of evolving languages.
I can think of languages which are used fairly widely without everyone complaining about them. Elixir would be one example.
Brief thought
So, continuous delivery means automated deployment to staging, and continuous deployment means automated delivery of software to the customer. Got it, very clear terminology!
Shares first impressions of React and TypeScript from the perspective of an experienced Elixir and Elm developer, comparing mainstream and niche development approaches.
Explores the balance between blameless culture and individual responsibility in software development.
Brief thought
My practical experience with microservices bears out what I always thought about them: 99% of the time, they’re introducing more complexity and cost than can be justified, Conway’s law notwithstanding.
Presents a comprehensive catalogue of test code smells, addressing gaps in existing resources and covering important aspects of good test suite design.
Examines how message passing can create more problems than it solves in software architecture, drawing from experience with large embedded C++ codebases.
Documents engineering practices that contributed to a successful software team experience, highlighting autonomy, collaboration, and effective development processes.
Brief thought
Still feeling disappointed that Elm didn’t take over the world while poor abstractions like React are extremely popular.
Brief thought
If null is a billion dollar mistake, then OOP is a trillion dollar mistake.
Shares practical experience with Tailwind CSS in Phoenix LiveView projects, addressing initial scepticism and exploring the value proposition of utility-first CSS.
Reflects on 18 months of commercial Elixir, Phoenix, and LiveView development, covering how the stack exceeded expectations and comparing it to previous experience with Elm.
Creates an Automator workflow for applying syntax highlighting to code snippets in Keynote presentations using Pygments, with clipboard-based text processing.
Introduces Matthew Griffith's elm-animator package for animations in Elm and demonstrates how to integrate it with elm-ui for enhanced user interfaces.
Announces that the Elm Catalog has expanded to include development tools alongside packages, making it a more comprehensive resource for Elm developers.
Explores the unfolding effects of the climate and ecological crisis expected this century, addressing widespread misunderstanding about the current situation and response efforts.
Explains how to configure macOS applications launched from Dock or Launchpad to run with custom PATH environments, overcoming the default limited path.
Reflects on technologies and development practices used during 4 years of product development, focusing on managing complexity with constrained resources.
Introduces a catalog to help developers discover Elm packages more easily, addressing the challenge of finding relevant packages when learning the language.
Demonstrates how to make sequential HTTP requests in Elm using Task, avoiding the complexity of managing multiple messages and intermediate state in the update function.
Explains three fundamental functional programming operations in Elm: mapping (applying functions to elements), filtering (excluding elements), and folding (reducing a list to a single element).
I share my experience with implementing UICards in Elm, showing how they let me create interactive UI elements within a single application model, while also tackling the challenges of message handling and state management along the way.
I found that UICards can really streamline the UI design process by letting me see and interact with different states of my components all in one place, saving me from the tedious back-and-forth of reloading and navigating through my app.
Announces the publication of the Elm 0.19 update for Practical Elm book, explaining why Elm is worth learning and what the book covers for practical application development.
Demonstrates building complex forms with validation using the hecrj/composable-form package, showing type-safe, maintainable form handling with field composition and custom validation.
Announces the revival of the Elm Weekly newsletter to help the community stay up-to-date with articles, packages, and job postings in the Elm ecosystem.
Shows how to test Elm view functions using elm-test's HTML testing modules to avoid tedious manual testing by verifying DOM structure and user interactions.
Introduction to elm-ui package for building UIs in pure Elm without CSS, demonstrated through creating a simplified Slack-like layout with responsive design.
Provides minimal boilerplate code for static content experiments in Ellie, including a shorter alternative that avoids the need for complex Program setup.
Step-by-step guide to publishing Elm packages with 0.19, covering local development, testing, requirements, versioning, and the publishing process via GitHub.
Comprehensive introduction to custom elements and Shadow DOM for integrating complex JavaScript components into Elm applications, including practical examples and polyfill setup.
Explains how to convert Elm values back to JSON strings using Json.Encode, covering complex nested structures and integration with HTTP requests and ports.
Practical introduction to the elm/parser package through building a phone number parser, demonstrating parser combinators and handling complex structured text input.
Comprehensive overview of Elm 0.19 changes including language simplifications, compiler improvements, library updates, and installation/upgrade instructions with performance gains.
Provides a comprehensive curated list of Elm learning resources in 2018, including books, video courses, talks, guides, and community forums for all skill levels.
Discusses principles and best practices for organising Elm applications into modules, handling messages across files, and managing the single update function architecture.
Explains the technical mechanics behind Json.Decode.Pipeline's chaining syntax, showing how partial application and applicative functors enable the convenient decoder DSL.
Announces the early access availability of the Practical Elm book for busy developers, focusing on intermediate-level practical topics rather than basic syntax.
Explains how to organise Elm code using modules, covering module creation, imports, exports, and best practices for splitting code into manageable files.
Walks through the challenges of implementing recursive JSON decoders in Elm, showing how to avoid compiler and runtime errors using `Json.Decode.lazy` and proper type structure.
Explains the technical workings of elm-static-html-lib and how it converts Elm views into HTML strings by creating temporary Elm applications and using native JSON conversion.
Uses actual data and statistics to address concerns about Elm's development activity, comparing community metrics with other functional programming languages like Haskell and PureScript.
Explains how to understand generic types like `Html msg` in Elm by thinking of them as data structures that contain values of the specified type somewhere inside.
Explores different approaches to decoding complex JSON with many fields in Elm, ultimately settling on nested records as the cleanest solution to avoid extensible record limitations.
Shares practical insights from four years of developing a complex iOS and Android application using Cordova with about 20 plugins and advanced features like maps, camera, and offline capabilities.
Argues against using ORMs based on accumulated experience, focusing on ORMs that attempt to reimplement SQL rather than lightweight database helper libraries.
Breaks down database time handling into four complexity levels, from basic date storage to advanced temporal data management, based on experience working with PostgreSQL time features.
Analyses the feasibility of the space-based solar power satellite described in Ben Bova's 2005 novel, calculating the massive launch requirements and questioning the technological assumptions.
Describes how to effectively use Trello for tracking software development work across a team of developers and testers, emphasising lightweight process and minimal friction.
Provides practical notes on implementing push notifications for iOS and Android applications using Node.js, addressing the complexity of the various moving parts.
Discusses how managers can be misled by developers who appear highly productive but produce unmaintainable code, examining the difference between short-term output and long-term quality.
Examines how misapplied abstractions lead to unnecessary complexity in software development, drawing on Dijkstra's principles of simplicity and elegance.
Reflects on the growing popularity of functional programming and whether it will become mainstream, drawing from past experiences with technology adoption.
Explores methods for quickly visualising PostGIS query results from the command line, addressing the lack of convenient tools for ad hoc spatial data exploration.
Reflects on fascinating computing talks and demos from history, including Doug Engelbart's groundbreaking 1968 presentation and other influential works.
Explores why technological advancement often appears to reinvent the wheel, examining how hardware constraints, abstraction levels, and innovation cycles drive this seemingly repetitive process.
Explains how to configure web apps to use the full screen on iPhone 5 devices, addressing the issue of black bands when launched from Home screen shortcuts.
Submission proposing climate change as the most urgent issue, with research themes for renewable energy, sustainable transport, and climate mitigation.
Presentation slides introducing Backbone.js framework to Rails developers, given at WellRailed Rails group in Wellington.
Brief thought
We are disconnected from nature - a very good observation from David Suzuki in an interview:
What’s happened is a fundamental shift in the last 100 years that now blinds us from being able to see our place on the planet. 85 per cent of us in Canada now live in big cities. We’ve been utterly transformed in 100 years from being a farming animal to a big city dweller. And in the big city, people think, “As long as we have parks out there, where we can go camping and playing in, well who needs nature? My important thing is my job; I need a job in order to be able to go out and buy the things I want.”
Explores the advantages of using Cucumber for behaviour-driven development (BDD), highlighting how it forces high-level thinking and creates readable specs that double as tests. Includes a comparison with RSpec and discusses why BDD focuses on user-visible system behaviour.
A guide to setting up CoffeeScript in RubyMine 3 with the CoffeeBrew plugin and configuring the compiler output window. Includes advantages of CoffeeBrew over coffeescript-idea plugin.