korban.net

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.

Announces the final release date for Practical Elm book and provides updates on Elm 0.19 developments including new installers and package updates.

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.

Announces the early access availability of the Practical Elm book for busy developers, focusing on intermediate-level practical topics rather than basic syntax.

Explains the technical mechanics behind Json.Decode.Pipeline's chaining syntax, showing how partial application and applicative functors enable the convenient decoder DSL.

Shows techniques for decoding JSON with more than 8 fields and handling nested sub-objects using Json.Decode beyond the standard map functions.

Explains how to organise Elm code using modules, covering module creation, imports, exports, and best practices for splitting code into manageable files.

Announces Elmstatic 0.3.1 features including subsections with their own posts, index pages, and page aliases for better site organisation.

Introduces Elmstatic, a static site generator that allows writing pages in Elm with support for CSS generation, Markdown posts, and RSS feeds.

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.

Demonstrates how to extract values from union types in Elm using case expressions, including the destructuring shortcut for single-tag union types.

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.

Explores debugging techniques for complex PostgreSQL queries, introducing pgdebug as a debugging tool.

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.

Shares techniques for writing readable SQL queries, particularly useful for complex 100+ line queries written without ORMs.

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.

Applies Haskell to a real-world problem involving graph analysis, finding cycles in database-loaded graphs and writing results back.

Explores the practical side of Haskell by attempting to build a minimal web application with database connectivity using Yesod and Scotty frameworks.

Learning journal covering Haskell homework challenges, pattern matching on constructors, and reflections on the learning approach.

Maps out the new concepts encountered while learning Haskell, highlighting why it's particularly challenging compared to other programming languages.

Learning journal documenting work on CIS194 Homework 2, exploring Haskell constructs and functional programming concepts.

Learning journal covering CIS194 Homework 1, exploring basic Haskell interactivity and fundamental programming concepts.

Compares object-oriented and functional programming paradigms, focusing on the key difference of state management between the two approaches.

First entry in a learning diary documenting the journey of learning Haskell and functional programming, starting with basic syntax and fundamentals.

Curated collection of Haskell learning resources for beginners, compiled during the author's functional programming learning journey.

Practical guide to setting up a Haskell development environment, focusing on tools and setup steps for learning functional programming.

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.

Addresses the lack of built-in uninstall mechanism for .pkg installers on macOS, presenting both automated and manual removal methods.

Practical guide to configuring zsh keyboard shortcuts on macOS, navigating the complexity of shell configuration and character sequences.

Step-by-step instructions for displaying random quotes on the desktop using NerdTool and simple shell commands.

Reflects on fascinating computing talks and demos from history, including Doug Engelbart's groundbreaking 1968 presentation and other influential works.

Step-by-step instructions for installing PostGIS using Homebrew on macOS, since official documentation didn't cover this method.

Explores why technological advancement often appears to reinvent the wheel, examining how hardware constraints, abstraction levels, and innovation cycles drive this seemingly repetitive process.

A brief overview of less known HTML5 features and capabilities available on iOS and Android mobile devices as of early 2013.

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.