Hey-yo,

A little bit under the weather today. Anyway, here’s the issue.

Made possible through generous sponsorship by:

Why do we use intermediate representations / languages?

Published: 16 June 2024

Tags: compilers, optimization

Edaqa Mortoray discusses the role and benefits of using intermediate representations (IRs) in programming, particularly in the contexts of code analysis, optimization, and translation. He explains how IRs serve as a bridge between high-level code and machine code, enhancing the efficiency and flexibility of software development processes.

Some highlights:

• Intermediate Representations (IRs) are used to bridge the gap between high-level source code and low-level machine code, aiding in translation and optimization.

• IRs facilitate code analysis by providing a uniform framework that supports various programming languages and tools.

• The use of IRs enhances the flexibility of software development, allowing developers to implement optimizations and transformations more efficiently.

ESPHome Server in Python

Published: 15 June 2024

Tags: python, hardware, automation

Pete Keen writes a ESPHome Protocol Server to drive the addressable LEDs on his house.

Some highlights:

• There are “three ways to get arbitrary devices and entities to show up automatically in Home Assistant”: write a home assistant integration, using MQTT autodiscovery, or using ESPHome firmware.

• includes code

• also includes information on deploying the code

The Developer’s Guide to SSO

Published: 27 October 2023

Tags: sponsored, auth, web

WorkOS has published a guide on how to best integrate single sign-on (SSO) in your app.

Some highlights:

• SSO is a common requirement when organizations first start selling to enterprises

• ​describes the general request flow for a user logging in with SSO

• summarizes how to build SSO from scratch and how to use existing providers

A Logic Circuit Simulator with Cats-Actors

Published: 14 June 2024

Tags: scala, functional

Mark Galea dives into building a logic circuit simulator in scala.

Some highlights:

• “Cats-Actors is a reimagining of the actor paradigm model married with the functional paradigm.”

• The task is to “[develop] a logic circuit simulator that accounts for the internal delays of digital circuits, ensuring that all signals stabilize on each clock tick”

• creates basic components like wires and logic gates, and combined them into more complex structures such as half adders, full adders, and demultiplexers

Hey-yo,

Man, crossfit is brutal. Anyway, here’s the issue.

Made possible through generous sponsorship by:

Offering Client Trials: Prototypes vs Auditions

Published: 11 June 2024

Tags: business, philosophy

Erik Dietrich discusses the distinction between prototypes and auditions in the context of offering client trials, emphasizing the different risks each approach mitigates. He argues that for content creation, prototypes are more instructive for evaluating business engagement potential than auditions.

Some highlights:

• Prototypes vs. Auditions: Prototypes focus on measurable outcomes to de-risk achieving specific goals, while auditions are subjective evaluations to see if something is liked.

• Prototyping Approach: Hit Subscribe views trials as prototypes to predict success at scale rather than subjective auditions that may not represent long-term value.

• Audition Pitfalls: Auditions might be useful for evaluating content style but fail to reflect the effectiveness or scalability of content fulfillment processes.

A beautiful Python monstrosity

Published: 8 June 2024

Tags: python, testing

Trey Hunner shares his innovative yet unconventional solution to handle flaky performance tests in Python by creating a decorator that attempts assertions multiple times, enhancing test reliability at the cost of standard decorator usage.

Some highlights:

• Flaky Performance Tests: Trey describes the difficulties in creating reliable performance tests due to variability and the complexity of efficient versus inefficient solutions.

• For-Try-Break-Except-If-Raise Pattern: A verbose and repetitive but initially effective pattern for handling flaky tests.

• Attempt_n_times Decorator: A custom decorator that retries a function multiple times to improve the readability and reliability of performance tests, though it controversially calls the decorated function directly.

What is MFA, and why does your app need it?

Published: 13 December 2023

Tags: sponsored, auth, web

WorkOS describes what multi-factor authentication (MFA) is and why it’s useful.

Some highlights:

• “it’s an added layer of security to your app that makes it more difficult for hackers or impersonators to steal and use a user’s credentials”

• describe the different types of MFA

• summarizes the back-end flow for different types of MFAs

Situational Awareness

Published: 8 June 2024

Tags: ai, machine learning, future

Leopold Aschenbrenner explores the rapid progression from GPT-4 level AI to Artificial General Intelligence (AGI) and the anticipated leap to superintelligence by 2027. It discusses technological advancements, potential risks, and the immense economic and security challenges posed by superintelligence, emphasizing the need for robust security measures and strategic planning to ensure global safety.

Some highlights:

• Path to AGI: The evolution from GPT-4 to AGI by 2027 is seen as likely, driven by trends in computing power, algorithmic efficiencies, and qualitative advancements.

• Intelligence Explosion: Post-AGI, the transition to superintelligence could be swift, compressing decades of AI advancements into a single year due to the recursive improvement capabilities of AGIs.

• Security and Economic Challenges: The emergence of AGI and superintelligence poses significant security threats and demands massive investments in infrastructure and energy, along with the need for stringent measures to safeguard AGI technologies.

Hey-yo,

Another day, another issue.

Made possible through generous sponsorship by:

How to Build an AI Data Center

Published: 10 June 2024

Tags: ai, hardware

Brian Potter explains the key aspects of constructing an AI data center, focusing on the unique challenges and design considerations compared to traditional data centers. He highlights the increased importance of power density, cooling efficiency, and network infrastructure for supporting AI workloads.

Some highlights:

• Power Density and Cooling: AI data centers require significantly higher power density and cooling capabilities than traditional data centers to support the energy demands of AI hardware.

• Network Infrastructure: Enhanced network infrastructure is crucial for AI data centers to handle the immense data throughput and connectivity needs of AI systems.

• Physical Space and Layout: The physical layout of AI data centers must accommodate the specific heat distribution and airflow requirements of AI equipment, leading to different design considerations compared to conventional data centers.

React, Electron, and LLMs have a common purpose: the labour arbitrage theory of dev tool popularity

Published: 2 May 2024

Tags: frameworks, philosophy

Baldur Bjarnason critiques the use of frameworks and standardization in the context of labor arbitrage, arguing that these technologies often prioritize cost savings over quality and performance. He suggests that the pursuit of cheaper development methods can lead to suboptimal software solutions.

Some highlights:

• Technological Trade-offs: Bjarnason discusses how the adoption of frameworks can lead to compromises in software quality and performance due to a focus on reducing development costs.

• Labour Arbitrage: The article highlights the impact of labor arbitrage in software development, where companies leverage global labor markets and cost-cutting measures, often at the expense of product excellence.

• Sustainable Practices: Bjarnason calls for more sustainable software development practices that balance cost with quality, advocating for thoughtful use of technology that aligns with long-term goals rather than short-term savings.

The Developer's Guide to User Management

Published: 25 March 2024

Tags: sponsored, auth

WorkOS published an extensive guide on building modern day user management, diving into various auth topics like SSO, MFA, and even user provisioning.

Some highlights:

• Session management is a foundational piece of user management but is complex to build. Devs need to consider cookie-based vs. JWT-based auth and how to persist login state information for users that are part of multiple orgs

• At the 201 level, things like bot detection and org auth policies become more relevant

• 301 topics include invitation flows, email verification, and more

Failing at Combinatorics with Haskell

Published: 10 June 2024

Tags: haskell, math, functional

Chris explores the challenges and solutions involved in solving a combinatorial math problem using Haskell. The article delves into postfix notation for simplifying arithmetic expressions and presents a detailed implementation for generating and evaluating these expressions in Haskell.

Some highlights:

• Postfix Notation Simplification: Chris uses postfix notation to simplify the handling of arithmetic expressions, avoiding the complexity of parentheses and leveraging the order of numbers and operators.

• State-based Emission: The article introduces a state-based approach to generate valid postfix expressions by tracking previously emitted digits and operators, ensuring the correct formation of arithmetic expressions.

• Combinatorial Complexity: Chris demonstrates the combinatorial explosion when evaluating expressions over increasing digit ranges, illustrating the computational challenges and providing empirical runtime estimates for different digit intervals.

Hey-yo,

Sorry for missing the last two issues. Traveling always messes with my schedule more than I expect it to. Currently in San Diego though, so if anyone is around and wants to meet up, let me know!

Anyway, here’s the issue.

Made possible through generous sponsorship by:

Finding connected cities in a road network

Published: 9 June 2024

Tags: algorithms, games

Edaqa Mortoray details a specialized algorithm to track connections between locations in his game The Way to Hexet. The algorithm uses a flood-fill method to determine connected components by processing placed roads and updating network states dynamically.

Some highlights:

• Uses a matrix for tiles, a list for cities, and another for roads for map structure.

• Flood-Fill Algorithm use to initialize and update network states for cells and cities based on road placements.

• Iterates over roads rather than cells and uses bit-masked values for quick connection checks.

LLM Research Insights: Instruction Masking and New LoRA Finetuning Experiments?

Published: 2 June 2024

Tags: ai, machine learning, research

Sebastian Raschka reviews recent AI research on instruction masking in finetuning and LoRA (Low-Rank Adaptation). Not masking instructions can enhance model performance, while LoRA balances learning efficiency and memory preservation, particularly in knowledge-intensive domains.

Some highlights:

• Not masking instructions improves finetuning, depending on dataset size and response length.

• LoRA: Less effective in learning new knowledge but preserves original capabilities better than full finetuning.

• MoRA: Introduces high-rank updates, improving memory tasks but trailing in instruction finetuning.

A guide to organization modeling

Published: 16 February 2024

Tags: sponsored, auth, architecture

WorkOS has published a guide that “surfaces complexities and implementation details” for supporting user-team-organization relationships in B2B auth.

Some highlights:

• “if you ever want to sell to an enterprise your backend needs to be ready to support complex models of users and teams”

• looks at the different ways you can implement the database tables for modeling the organization

• most of the complexity comes from users that need to be a part of multiple organizations

The Functional Programming Hiring Problem

Published: 9 June 2024

Tags: functional, hiring, philosophy

Noah Snelson addresses the hiring challenges associated with using niche functional programming languages, using a hypothetical language "Gooby" as a stand-in. It argues that while hiring Gooby engineers can bring in highly passionate and skilled individuals, it also attracts a problematic focus on the language itself rather than the pragmatic needs of the company.

Some highlights:

• Hiring for niche functional programming languages like Gooby often yields three main types of candidates: résumé-spammers, enthusiastic but inexperienced undergraduates, and senior engineers deeply invested in the language for its own sake.

• Engineers with a strong focus on niche languages can become too engrossed in the language's complexities, potentially neglecting practical and more critical aspects of software development.

• Companies should avoid language-specific job boards and emphasize flexibility and pragmatism in their hiring processes to mitigate the risks of hiring language zealots who might introduce technical debt and disrupt engineering culture.

Hey-yo,

Here’s the issue.

Made possible through generous sponsorship by:

Your Node is Leaking Memory? setTimeout Could be the Reason

Published: 5 June 2024

Tags: javascript

Armin Ronacher explains how the setTimeout function in Node.js can cause memory leaks due to the retention of Timeout objects and AsyncLocalStorage states. He offers a workaround to manage these leaks until a bug in Node.js is resolved.

Some highlights:

• Timeout objects in Node.js hold references that prevent garbage collection, leading to memory leaks.

• AsyncLocalStorage attaches state to timeouts, exacerbating the issue.

• Using numeric IDs instead of Timeout objects can mitigate the problem, pending a Node.js bug fix.

Chopping UTF-8

Published: 4 June 2024

Tags: perl

Thomas Klausner explains how to chop a string to a specific byte length in Perl, dealing with UTF-8 characters. He highlights challenges in handling Unicode within byte-limited formats like USMARC.

Some highlights:

• UTF-8 uses variable-length encoding, leading to differences between byte and character lengths.

• Perl’s bytes::length() and bytes::substr() can manage byte-specific string operations, but require care with UTF-8 encoding.

• Encode::FB_QUIET can be used to avoid invalid byte sequences when truncating UTF-8 strings.

The Developer’s Guide to Directory Sync / SCIM

Published: 25 January 2024

Tags: sponsored, auth

WorkOS discusses what Directory Sync and System for Cross Identity Management are, and why they’re necessary for large organizations.

Some highlights:

• Directory sync “automates the lifecycle management process by providing a single source of truth for identity”

• “SCIM is an open source protocol for implementing Directory Sync”

• Includes comparison to just-in-time provisioning

From the Circle to Epicycles (Part 1) - An animated introduction to Fourier Series

Published: 24 April 2024

Tags: math

Andrei Ciobanu introduces Fourier Series with animations, starting with trigonometric basics and leading up to complex sinusoids and epicycles. The series aims to make Fourier mathematics more accessible and engaging through visual aids and step-by-step explanations.

Some highlights:

• Trigonometric functions like sine and cosine are foundational to understanding Fourier Series.

• Euler’s identity and formula connect exponential functions to trigonometric functions.

• Fourier Series decompose periodic functions into sums of sinusoids, enabling analysis and reconstruction of complex waveforms.

Hi hi hi,

Whenever I see a while loop in a PR, I instantly leave a comment telling the author to change it to a for loop. I’ve had too many cases of seemingly harmless while loops turning into infinite loops. Of course there are exceptions, but I have yet to run into one. What do you think? Are there any coding constructs you always avoid?

Anyway, here’s the issue.

Made possible through generous sponsorship by:

Building a serverless secured dead drop

Published: 30 May 2024

Tags: architecture, serverless

Oren Eini details the design and implementation of a serverless secured dead drop system for anonymous and secure communication. The system uses serverless functions, encryption, and Tor to protect both the contents and the identities of the communicating parties.

Some highlights:

• Utilizes a serverless architecture to minimize data aggregation and enhance security.

• Employs Tor for anonymous communication and SealedBox for encryption.

• Splits the upload process into multiple stages to obscure sender and receiver identities.

Ruminating about mutable value semantics

Published: 3 June 2024

Tags: zest, language design

Jamie Brandon explores mutable value semantics in programming languages, aiming to balance efficient imperative language features with data value treatment. He discusses methods for managing mutable references without compromising serialization and code integrity.

Some highlights:

• Implicit copies, dynamic alias tracking, and static alias tracking are key methods for handling mutable value semantics.

• Enforcing aliasing rules prevents observable mutations and improves code reliability.

• Static alias tracking, used in languages like Hylo, avoids refcounting overhead but requires more annotations from developers.

Single Sign-On: Acronyms Demystified

Published: 1 June 2024

Tags: sponsored, auth

WorkOS explains all the auth-related protocols and provides additional resources (for further reading) for OAuth, OIDC, and SAML.

Some highlights:

• “OAuth is not an authentication protocol”

• OIDC is built on top of OAuth

• SAML is used for federated authentication

How to consume a paginated API using JavaScript async generators

Published: 26 June 2023

Tags: javascript

James Sinclair demonstrates how to use JavaScript async generators to handle paginated APIs efficiently. He provides a detailed guide on refactoring code for clearer, more maintainable solutions.

Some highlights:

• Async generators can simplify handling paginated API data by yielding results as soon as they arrive.

• Filtering and mapping functions can be used to process data without excessive memory consumption.

• The approach makes code easier to read, test, and maintain by separating concerns and hiding implementation details.

Hey-yo,

Hope you all had a nice weekend. I spent my Saturday fixing the hinges that keep my laptop screen attached to its body. I’ve had this problem for around 2 years now (I’ve been using a clothes peg to keep the monitor from falling apart), but it came to a climax about a month ago when a slightly too aggressive shift of the screen caused the plastic frame to snap, resulting in me having to use two pegs to keep it from falling off. Fortunately I found replacement parts for the plastic frame and back panel online. Below you can see a picture of the laptop mid repair. I also had to pop off the bottom side of the laptop and expose the motherboard to remove the old hinges. Unfortunately the parts I ordered didn’t come with the metal grounding strip (you can see it at the top of the red panel that is above the keyboard), so I had to carefully remove that and stick it onto the new back panel (red rectangle in the top right of the picture). Overall it was a pretty easy repair. On one hand, I appreciate how cheap and easy it is to find the plastic replacement parts, but on the other hand, all of the mechanical issues I’ve had with my laptop have been because of plastic bits snapping and the only solution is to order new parts.

Anyway, here’s the issue.

Made possible through generous sponsorship by:

What We’ve Learned From A Year of Building with LLMs

Published: 8 June 2024

Tags: llm, ai, product development

Eugene Yan, Bryan Bischof, Charles Frye, Hamel Husain, Jason Liu, and Shreya Shankar share their insights from a year of building with large language models (LLMs). They discuss practical tips for prompting, optimizing workflows, and incorporating LLMs into products effectively.

Some highlights:

• Emphasize fundamental prompting techniques like n-shot and chain-of-thought to improve performance.

• Use retrieval-augmented generation (RAG) to ground models and enhance outputs.

• Optimize workflows with multi-turn flows, deterministic plans, and caching to improve reliability and efficiency.

Moving Beyond Type Systems

Published: 31 May 2024

Tags: functional, types

Vhyrro discusses the concept of static effect systems in programming languages, proposing them as a way to manage side effects more effectively than traditional type systems. They suggest this approach could benefit future programming language design.

Some highlights:

• Static effect systems can enforce control over side effects similarly to Rust's borrow checker.

• Effects should be explicitly annotated in code, improving developer awareness and code reliability.

• Separating type systems and effect systems allows parallel analysis during compilation, potentially speeding up the process.

A Developer’s Guide to One-Time Passwords (OTPs)

Published: 28 June 2021

Tags: sponsored, auth, web

WorkOS has published an extensive guide on how one-time passwords work, their benefits, and implementation details.

Some highlights:

• “OTPs come in three different forms, and each form works differently: time-synchronized OTPs, lockstep synchronized OTPs, or transmission-based OTPs”

• OTPs are more secure than static passwords, but can create a frustrating user experience due to potential delays

• Pros and cons for OTPs

Introducing the RIG Model - the Puzzle of Designing Guaranteed Data-Consistent Microservice Systems

Published: 30 May 2024

Tags: architecture, microservices, rig

Kaj Bromose and Lars Lindegaard Mikkelsen introduce the RIG model for designing guaranteed data-consistent microservices systems, using a gamified tool to categorize microservices behavior. This approach addresses the complexities of achieving data consistency in microservice architectures.

Some highlights:

• The RIG model categorizes microservices into Reversible, Irreversible, and Guaranteed to manage data consistency.

• A gamified tool helps teams design sagas that comply with RIG rules, ensuring eventual consistency.

• The RIG system design flow model integrates business requirements into microservices architecture, facilitating consistent and reliable system design.

Hi,

I missed yesterday’s issue because I had a late start and honestly didn’t find anything I thought was worth sharing.

Unrelated to programming, but very much on the data side of things, we launched our use our data page for FindEnergy yesterday. We publish a bunch of electricity rate and production data on a monthly basis, as well as a bunch of other data and launching live power outage monitoring as well. If you think your company would be interested in purchasing this data for anything, let me know! There are lots of useful examples of applications on the page I linked.

Anyway, here’s the issue.

Made possible through generous sponsorship by:

Using Parquet’s Bloom Filters

Published: 28 May 2024

Tags: data processing, data, parquet

Trevor Hilton discusses the use of Bloom filters in Parquet files to improve query performance, especially for high-cardinality data. The article details the effectiveness and storage impact of Bloom filters with various parameters.

Some highlights:

• Moderate Bloom filter settings (FPP 0.01, NDV 1,000) optimize pruning efficiency, reducing query time significantly.

• Bloom filters added storage costs ranging from 2 KB to 8 KB per column per row group.

• Fine-tuning Bloom filter parameters to match data cardinality resulted in high storage penalties without significant pruning benefits.

Your API Shouldn't Redirect HTTP to HTTPS

Published: 23 May 2024

Tags: api, http, infosec, architecture

Juhani Eronen argues against redirecting HTTP API requests to HTTPS, advocating for a fail-fast approach to improve security. The post highlights the risks of silent redirects and suggests disabling HTTP interfaces or returning clear error responses.

Some highlights:

• Redirecting HTTP API calls to HTTPS can expose API keys in plaintext.

• Fail-fast by disabling HTTP or returning errors to make security issues visible early.

• Automatic revocation of API keys sent over HTTP enhances security.

Secrets from the Algorithm: Google Search’s Internal Engineering Documentation Has Leaked

Published: 27 May 2024

Tags: seo, architecture

Not super technical, but we depend on SEO a good bit and I found it an interesting read. Mike King analyzes leaked Google internal documentation revealing insights into Google Search's ranking systems and data storage. He discusses the implications of these findings on SEO practices and Google's transparency.

Some highlights:

• The leak exposes over 14,000 attributes and 2,596 modules used by Google Search.

• Contrary to Google's public statements, the documentation shows the use of "siteAuthority" and click-based metrics in rankings.

• The documentation reveals measures for sandboxing new sites and utilizing Chrome data for ranking.

Hey-yo,

Hope you all had a nice weekend. Here’s the issue.

Made possible through generous sponsorship by:

Stand Out and Dare to Disagree

Published: 16 May 2024

Tags: philosophy

Vadim Kravcenko emphasizes the importance of being opinionated and polarizing (based on reason) in the tech industry to achieve long-term success. Agreeability and risk aversion may hinder professional growth. You definitely shouldn’t be controversial for the hell of it, but having an opinion on the correct way forward and sharing it when you think the development process is going the wrong way is definitely a big plus for any developer I hire.

Some highlights:

• To avoid mediocrity, developers should express strong, fact-based opinions.

• Success often requires making decisions that may alienate some users but resonate deeply with others.

• Handling criticism effectively is crucial for refining and validating one's ideas.

An Introduction to Low-Latency Scripting for Game Engines

Published: 23 May 2024

Tags: c++, games

fwsgonzo introduces the use of libriscv for low-latency scripting, highlighting its effectiveness in game engines and its capability to execute fast, safe function calls. C++ is showcased as a viable scripting language due to its efficiency and familiarity in game development contexts.

Some highlights:

• libriscv is a specialized RISC-V emulator focused on achieving low latency in function calls.

• Using C++ for scripting in game engines allows for consistency and efficiency, leveraging modern idiomatic practices.

• The article provides insights on integrating libriscv into projects using CMake and other tools.

The Developer’s Guide to SSO

Published: 27 October 2023

Tags: sponsored, auth, web

WorkOS has published a guide on how to best integrate single sign-on (SSO) in your app.

Some highlights:

• SSO is a common requirement when organizations first start selling to enterprises

• ​describes the general request flow for a user logging in with SSO

• summarizes how to build SSO from scratch and how to use existing providers

Arenas and the almighty concatenation operator

Published: 25 May 2024

Tags: c++, data structures

Chris Wellons delves into a technique for efficient concatenation within an arena-based memory allocation paradigm, offering a versatile method for dynamic growth of various data types. This method leverages concise C++ templates for performance and simplicity.

Some highlights:

• Introduces a 9-line core function for concatenating data types within an arena.

• Highlights the efficiency of this approach for handling strings and other data structures.

• Demonstrates the extensibility and practical applications, such as constructing file paths and managing dynamic arrays.

Hey-yo,

I thought I was busy before, but managing 8 people and trying to implement new features has taken it to a new level.

I’m going to be in San Diego mid-June. If anyone is around and wants to meet up, let me know!

Anyway, here’s the issue.

Made possible through generous sponsorship by:

WebAssembly: A promising technology that is quietly being sabotaged

Published: 22 May 2024

Tags: wasm, web

Sylvain Kerkour discusses how rust developers might be ruining webassembly (wasm).

Some highlights:

• Wasm is a technology designed to create a universal executable format that runs on various platforms.

• Contends that the introduction of concepts like WIT and the push for async programming are unnecessary and have made WebAssembly difficult to use.

• While WebAssembly has great potential, especially in web browsers, its server-side implementation risks failure due to increasing complexity.

Common Lisp Is Not a Single Language, It Is Lots

Published: 23 May 2024

Tags: common lisp

Artyom Bologov explains that Common Lisp is not a single language but a collection of many languages. This includes core Scheme-y Lisp, the Common Lisp Object System (CLOS), generics, the loop macro, and others.

Some highlights:

• Common Lisp incorporates multiple sub-languages, each with distinct features and programming styles.

• Examples include a Scheme-like core, the object-oriented CLOS, and generics.

• The loop macro and format strings are powerful, language-like constructs within Common Lisp.

The Developer's Guide to Domain Verification

Published: 15 November 2024

Tags: sponsored, networking, auth, dns

WorkOS’ blog “examines best practices to consider when building in-house as well as a simple alternative” that they provide when it comes to domain verification.

Some highlights:

• “Domain verification is a crucial security measure for SaaS providers, ensuring that services are securely delivered to the legitimate owners of a domain”

• “Don’t place TXT records on the root domain”

• WorkOS offers a simple API you can integrate with to do domain verification

Safe terminal escape codes

Published: 22 May 2024

Tags: terminal, graphics

Martin Tournoij discusses the relevance and application of terminal escape codes in modern software terminal emulators. He highlights the importance of terminfo for advanced operations and provides a list of universally supported escape sequences.

Some highlights:

• Terminal escape codes are essential for text styling and cursor operations.

• Compatibility varies, with terminfo being crucial for advanced functions.

• Modern terminal emulators widely support ANSI escape codes for text and color formatting.

Hiya,

I finally ordered some spare parts to fix my laptop lid. The plastic casing on the left side broke years ago and for some reason, it took the same thing happening on the other side to finally motivate me to order what I need to fix it. You can see my high-tech temporary fix in the image below (the two clips keep the screen from falling off). The funny thing is I’ve actually been traveling around with the green clip on the left side for 2-3 years now. I could’ve ordered the parts any time before now from China and paid half the price, but I have to go to a conference in several weeks so I paid double to get something shipped quickly. Sigh. I don’t think I’m necessarily stupid, but sometimes I wish I would think more.

Anyway, here’s the issue.

Made possible through generous sponsorship by:

Residuality Theory

Published: 21 May 2024

Tags: design pattern, architecture, philosophy

Eric Normand dives into “a framework for systems architecture by Barry O’Reilly”, that “attempts to use ideas from complexity sciences to build systems that can better survive the complexities of the real world”.

Some highlights:

• A stressor is an uncontrollable dependency outside of software that can affect the system (DDoS, weather, politics).

• “Residuality Theory suggests that we should mentally simulate the stressors ahead of time to understand how we can engineer the system to exist in the complex real world”

• The objective is to reduce the coupling in the system, while not reducing it to the point of inflexibility.

Stripe's monorepo developer environment

Published: 21 May 2024

Tags: devops

Nelson Elhage shares his experiences working with Stripe's monorepo developer environment, detailing its evolution and key features that contributed to productivity.

Some highlights:

• Stripe used a monorepo primarily written in Ruby, supporting a large codebase with a focus on stability and reliability.

• Development was done using per-developer cloud instances ("devboxes") which facilitated centralized debugging and environment consistency.

• Stripe's developer productivity team invested heavily in tooling, including automatic synchronization and integrated testing commands, enhancing overall developer efficiency.

What is MFA, and why does your app need it?

Published: 13 December 2023

Tags: sponsored, auth, web

WorkOS describes what multi-factor authentication (MFA) is and why it’s useful.

Some highlights:

• “it’s an added layer of security to your app that makes it more difficult for hackers or impersonators to steal and use a user’s credentials”

• describe the different types of MFA

• summarizes the back-end flow for different types of MFAs

A transport protocol’s view of Starlink

Published: 17 May 2024

Tags: tcp, networking

Geoff Huston examines how TCP, the primary transport protocol of the Internet, interacts with the characteristics of the Starlink satellite service, focusing on its performance implications.

Some highlights:

• Geosynchronous satellites provide extensive coverage but suffer from high latency due to their distance from Earth.

• Low Earth Orbit (LEO) satellites, like those used by Starlink, offer reduced latency but require frequent handovers between satellites.

• Starlink’s varying signal-to-noise ratio and dynamic channel rate control impact TCP performance, necessitating protocol adaptations for optimal efficiency.

Howdy,

One of the more uncomfortable feelings is when you swallow a pill and it feels like it gets stuck sideways and doesn’t go fully down. Ugh.

You know what’s odd? Microsoft is investing billions of dollars into OpenAI, but the latter’s recent promos were all done on Apple products. And Apple is making a deal with OpenAI. Isn’t there a conflict of interest there?

Anyway, here’s the issue.

Made possible through generous sponsorship by:

City In A Bottle – A 256 Byte Raycasting System

Published: 19 May 2024

Tags: javascript, html

Frank Force introduces a 256-byte raycasting engine (in an HTML canvas element) that generates a cityscape, demonstrating efficient use of minimal code. The project showcases how to create complex visual outputs with compact JavaScript.

Some highlights:

• The engine uses a combination of HTML and JavaScript to render the scene in a small space.

• The code employs basic algebra and clever tricks to achieve the raycasting and rendering.

• The project highlights the potential of tiny code for generating intricate graphics and structures.

A Low Discrepancy Shuffle Iterator (+Random Access & Inversion)

Published: 19 May 2024

Tags: c++, algorithms

Alan Wolfe describes a low discrepancy shuffle iterator that supports random access and inversion, leveraging irrational numbers like the golden ratio for better sequence properties. This approach improves upon traditional shuffling methods in performance-critical applications.

Some highlights:

• Utilizes irrational numbers to drive the shuffle sequence, ensuring low discrepancy.

• Supports constant-time random access and inversion for efficient element retrieval.

• Demonstrates significant improvements in reducing sequence duplicates and missing values.

The Developer's Guide to User Management

Published: 25 March 2024

Tags: sponsored, auth

WorkOS published an extensive guide on building modern day user management, diving into various auth topics like SSO, MFA, and even user provisioning.

Some highlights:

• Session management is a foundational piece of user management but is complex to build. Devs need to consider cookie-based vs. JWT-based auth and how to persist login state information for users that are part of multiple orgs.

• At the 201 level, things like bot detection and org auth policies become more relevant.

• 301 topics include invitation flows, email verification, and more.

NULL BITMAP Builds a Database #1: The Log is Literally the Database

Published: 20 May 2024

Tags: database, rust

Justin Jaffray begins a series on building an LSM-based database, focusing on a log-structured approach where the log itself functions as the database. This first installment emphasizes the fundamental operations of a key-value store.

Some highlights:

• Introduction of an LSM-based storage engine with basic operations (put and get).

• Explanation of using Rust for implementation, minimizing dependencies.

• Discussion on writing data to a log and ensuring durability with fsync.

Hey-yo,

Hope you all had a nice weekend. I had a no-screen Saturday, which was nice, but for Sunday I wanted to dedicate some time to updating the abyteofcoding.com website (it doesn’t currently have the latest issues and search is nonexistent). I ended up having to fix some data models for findenergy.com, related to monthly electricity rate pricing (extrapolating rates based on historical annual-only data). The latter ended yesterday in a moment of “ugh, why didn’t I just do it this other way?”. I’m not sure if those moments are becoming more or less frequent. Hopefully next weekend I can make the updates I want to make.

Anway, here’s the issue.

Made possible through generous sponsorship by:

Using Rust Macros for Custom VTables

Published: 16 May 2024

Tags: rust

Armin Ronacher discusses using Rust macros to create custom virtual tables (vtables) for dynamic objects in the MiniJinja template engine. He explains the challenges and solutions for implementing dynamic object management in Rust.

Some highlights:

• MiniJinja engine leverages type_erase! macro for dynamic object representation.

• The macro creates a custom DynObject smart pointer, allowing dynamic method invocation.

• Demonstrates how to use Rust’s Arc and unsafe code to manage memory and refcounting effectively.

Data Fetching Patterns in Single-Page Applications

Published: 15 May 2024

Tags: react, webdev, front-end

Juntao Qiu outlines effective data fetching patterns for Single-Page Applications (SPAs) to enhance performance and user experience. He discusses various strategies such as Asynchronous State Handler, Parallel Data Fetching, and Code Splitting.

Some highlights:

• Asynchronous State Handler: Decouples data fetching from UI to streamline application architecture.

• Parallel Data Fetching: Reduces wait time by loading multiple data sets simultaneously.

• Code Splitting and Prefetching: Improves performance by loading only necessary code and data preemptively.

A guide to organization modeling

Published: 16 February 2024

Tags: sponsored, auth, architecture

WorkOS has published a guide that “surfaces complexities and implementation details” for supporting user-team-organization relationships in B2B auth.

Some highlights:

• “if you ever want to sell to an enterprise your backend needs to be ready to support complex models of users and teams”

• looks at the different ways you can implement the database tables for modeling the organization

• most of the complexity comes from users that need to be a part of multiple organizations

A surprising retrospective task estimation dataset

Published: 19 May 2024

Tags: project management

Derek Jones presents an analysis of a dataset concerning task estimation in software projects. The study reveals unexpected insights into how estimations have been historically inaccurate and the variability of these estimates over time (sHoCkEr).

Some highlights:

• The dataset includes 10,100 unique task estimates spanning ten years.

• Analysis shows a significant discrepancy between estimated and actual task completion times.

• Factors such as developer experience and project complexity influence estimation accuracy.

Oops,

Error: not found.

Made possible through generous sponsorship by:

Rebuilding my homelab: Suffering as a service

Published: 15 May 2024

Tags: kubernetes, self hosting

Xe Iaso shares her experience rebuilding her homelab, exploring various operating systems and tools like Rocky Linux, Kubernetes, and Ansible, detailing the challenges and solutions encountered. She highlights the complexities and rewards of managing a personal server environment for development and experimentation.

Some highlights:

• Evaluates Rocky Linux and the practical difficulties of installation on older hardware.

• Discusses the advantages and disadvantages of using Kubernetes in a homelab setting.

• Considers CoreOS and Fedora CoreOS as potential alternatives for an immutable infrastructure.

JavaScript Nulls and Programming Minutiae

Published: 15 May 2024

Tags: javascript

Dan Lew delves into the nuances of handling absent data in JavaScript, comparing the use of null and undefined and their implications for code readability and maintainability. He concludes with practical advice for developers on choosing between these options.

Some highlights:

• Explores the challenges and subtle differences between using null and undefined in JavaScript.

• Recommends using undefined to represent absent data for consistency and ease of handling.

• Suggests using the isNil() function from Lodash for clear and concise null checks.

The Developer’s Guide to Directory Sync / SCIM

Published: 25 January 2024

Tags: sponsored, auth

WorkOS discusses what Directory Sync and System for Cross Identity Management are, and why they’re necessary for large organizations.

Some highlights:

• Directory sync “automates the lifecycle management process by providing a single source of truth for identity”

• “SCIM is an open source protocol for implementing Directory Sync”

• Includes comparison to just-in-time provisioning

Thread Count Scaling Part 1. Introduction

Published: 10 May 2024

Tags: optimization, performance, multithreading, c++

Denis Bakhvalov introduces a case study on thread count scaling for multithreaded applications, analyzing performance across different benchmarks to understand their efficiency on multicore systems. The study reveals that most benchmarks show suboptimal scaling, highlighting the complexities of multithreading.

Some highlights:

• Benchmarks include Blender, Clang, Zstandard, CloverLeaf, and CPython, each tested with varying thread counts.

• The best-performing benchmark, Blender, achieved a 6x speedup with 16 threads, far from ideal linear scaling.

• Clang and Zstd experienced performance degradation beyond 11 threads, indicating challenges in multithreaded optimization.

Hey-yo,

The theme of today’s issue is performance analysis and comparison!

Made possible through generous sponsorship by:

Performance Analysis of Float vs Byte vs Binary Vectors on OpenSearch

Published: 14 May 2024

Tags: search, performance

Sujit Pal explores the performance differences between float, byte, and binary vectors in vector search applications using OpenSearch. He compares their response times and effectiveness in matching vector similarity, showing that while float vectors perform slightly better, binary vectors offer much faster response times.

Some highlights:

• Sujit used the SentenceTransformers model to encode text inputs into vectors and experimented with float, byte, and binary vector types.

• The performance metrics used were Recall and Mean Reciprocal Rank (MRR) across various top-k nearest neighbors scenarios.

• Among the three types, binary vectors had the fastest response times, though float vectors had marginally better precision in similarity matching.

The Insert Benchmark: MariaDB, MySQL, new small server, cached workload, some concurrency

Published: 14 May 2024

Tags: mariadb, mysql, database, performance

Mark Callaghan analyzes the performance of MariaDB and MySQL in an insert benchmark on a new small server with varying levels of concurrency and a cached workload. He provides detailed comparisons of throughput across different configurations and versions of the database systems.

Some highlights:

• The tests measure performance with varying client loads and database configurations, focusing on how MariaDB and MySQL handle insert operations under concurrency.

• Results indicate that modern MariaDB versions generally perform better than MySQL in benchmark tests, often significantly.

• Detailed analysis of performance regression in MySQL over its successive versions, showing a decline in performance compared to earlier versions.

Improving DORA Metrics – Lead Time for Changes

Published: 5 May 2024

Tags: sponsored, dora, devops

Aviator discusses strategies for improving the 'Lead Time for Changes' DORA metric, emphasizing faster software development cycles to enhance productivity and responsiveness to market demands. The article breaks down the cycle time, showing where optimizations can significantly shorten the software development process.

Some highlights:

• The article explains the difference between 'lead time for changes' and 'cycle time', providing a clear framework for measuring and improving these metrics.

• Strategies for improvement include optimizing coding practices, streamlining code reviews, and enhancing merge and deployment processes.

• Practical tips are offered, such as using AI-assisted tools, implementing smaller PRs, and employing feature flags to manage deployments effectively.

Performance comparison of string concatenation in Go language

Published: 13 May 2024

Tags: go, performance

Sonic0002 offers a detailed performance analysis of string concatenation methods in Go language, comparing traditional and advanced techniques like the '+' operator, fmt.Sprintf, strings.Builder, bytes.Buffer, and []byte slice concatenation.

Some highlights:

• strings.Builder and []byte pre-allocated methods show significant performance advantages in terms of both time and memory usage compared to other methods.

• The article details specific code examples and benchmark results for each method, providing clear guidance on their efficiency and practical use.

• Optimization suggestions include choosing the right method based on specific needs, with a strong recommendation for using strings.Builder for general purposes due to its efficiency and simplicity.

Hi,

Not tech related, but I read this interesting article on how the birth date of males for a species of squid determines what mating tactic they use for life. It made me think of the zodiac and astrology. Interestingly the latter assigns personality traits depending on the position of certain planets (and stars?), unlike the squid, whose personality traits depend on environmental factors (ie temperature of water). Why did astronomical factors become more popular than local ones for people?

Anyway, here’s the issue.

Made possible through generous sponsorship by:

Methods Should Be Object Safe

Published: 4 May 2024

Tags: rust, oop

Leonora Tindall proposes “the use of ‘method’, in Rust, to refer specifically to associated functions which would be object safe if put in a trait”.

Some highlights:

• “programmers often act like ‘OOP’ is one big concept, when, really, it’s more like a kind of Vietnamese spring roll of concepts that can be inserted or taken out depending on preference”.

• In rust, an object is “a type with a name including dyn Trait”.

• “In Rust, grouping values by trait rather than type is done through dynamic dispatch”.

What Factors Explain the Nature of Software?

Published: 14 May 2024

Tags: software design, philosophy

Laurence Tratt discusses the interacting factors that define the nature of software. He explores how software exists in a state between real-world constraints and fantastical possibilities, highlighting the complexities involved in specifying and observing software's behavior.

Some highlights:

• Software exists between the physical world's hard constraints and the fantasy of limitless possibilities, which impacts its development and understanding.

• The "circular specification problem" suggests that fully understanding what software should do often only comes after its creation, complicating development.

• The "observer effect" in software shows that seeing software in action can change perceptions and requirements, influencing its final form.

Offline-First/Local-First is a Big Deal, Especially for the Web

Published: 22 November 2023

Tags: sponsored, web

PowerSync dives into why offline-first / local-first apps are advantageous and worth building.

Some highlights:

• Outlines the technical advantages, including fewer back-end compute resources, reduced API burden, and simplified state management.

• Describes the UX improvements, including speed and offline use.

• Highlights important design considerations.

Estimates are Fine. They Build Trust When You Provide Them And Deliver On Them

Published: 10 May 2024

Tags: project management, philosophy, business

Not a typically technical article, but interesting for the more business-oriented. David Bryant Copeland emphasizes the importance of providing and delivering on estimates in software development. He argues that estimates, when done well, build trust and improve project outcomes by aligning expectations and facilitating project management.

Some highlights:

• Providing accurate estimates requires experience and honest assessment of what can be achieved within a given timeframe.

• Estimates help in managing project delivery and stakeholder expectations, reinforcing trust when they are met.

• Copeland suggests strategies for estimation that include assessing known quantities, accommodating uncertainties, and revising estimates based on ongoing project insights.

Howdy,

Hope you all had a nice weekend. I spent most of mine fiddling around with modelling electricity prices for individual providers in the US (for findenergy.com). The issue is we get monthly sales / revenues / customers figures for some big providers in every state, but the rest are all reported anonymously in one block (more than half of the state total). All providers report on an annual basis, but that’s usually 1-2 years behind, compared to monthly data which is only 3 months behind. Obviously the latter is more interesting for most people.

My theory was that if I could find the proportion of total annual sales / revenues / customers for each provider that published monthly data anonymously, I could use that ratio to predict what proportion of the monthly anonymous data could be attributed to them. The result works super well! Except for 2020. Maybe because of the pandemic? For some reason the model amount of electricity sold is much lower than the actual electricity sold, whereas revenues and customers are pretty much on point. Maybe a combination of more electricity use with subsidies that aren’t counted as revenue? What do you think?

Anyway, here’s the issue.

Made possible through generous sponsorship by:

How Good Are the Latest Open LLMs? And Is DPO Better Than PPO?

Published: 12 May 2024

Tags: llm, ai, machine learning

Sebastian Raschka evaluates recent advancements in large language models (LLMs) such as Mixtral, Llama 3, and Phi-3, and discusses reinforcement learning methods for model fine-tuning, comparing Proximal Policy Optimization (PPO) and Direct Preference Optimization (DPO).

Some highlights:

• Compares newer models to previous versions, highlighting improvements in architecture and training strategies.

• Discusses the efficiency and scalability of models, particularly in terms of data use and processing capabilities.

• Reviews practical implications of PPO and DPO in aligning LLMs with human preferences.

When Is a Counter-Strike Player Good?

Published: 10 May 2024

Tags: math, data science, games

Chris reflects on the complexities of measuring skill in Counter-Strike, highlighting the multifaceted nature of in-game performance which extends beyond simple metrics like kills and deaths, focusing instead on strategic gameplay and resource management.

Some highlights:

• Discusses the Leetify rating, a sophisticated metric that evaluates individual performance based on the impact of in-game events on the chances of winning.

• Provides insights into the tactical considerations of Counter-Strike, such as map control and economy management.

• Explores the difficulty of assessing individual contributions to team success in a game where strategic decision-making is crucial.

Single Sign-On: Acronyms Demystified

Published: 1 June 2023

Tags: sponsored, auth

WorkOS explains all the auth-related protocols and provides additional resources (for further reading) for OAuth, OIDC, and SAML.

Some highlights:

• “OAuth is not an authentication protocol”

• OIDC is built on top of OAuth

• SAML is used for federated authentication

Playing with Zig and thinking about its package manager

Published: 12 April 2024

Tags: zig

Paul Hammant explores using the Zig programming language to build a virtual machine configuration tool and discusses the potential of federated Git repositories as a decentralized package management system.

Some highlights:

• Demonstrates a practical application of Zig by creating a command-line tool for virtual machine configuration.

• Proposes leveraging Git for decentralized package management, akin to systems used by Carthage and Ansible Galaxy.

• Discusses the benefits of a Git-based system for robust version control and distribution of software binaries.

Hi hi hi,

Wowza, issue #400. That’s a lotta issues.

Anyway, here’s dat issue.

Made possible through generous sponsorship by:

The await event horizon in JavaScript

Published: 11 December 2023

Tags: javascript

Charles Lowell explores the concept of the 'await event horizon' in JavaScript, likening it to a point of no return for asynchronous operations, highlighting the challenges this poses for error handling and resource management in async functions.

Some highlights:

• Discusses the limitations of current async programming patterns where functions can get indefinitely stuck waiting for promises to resolve.

• Introduces the idea of structured concurrency as a potential solution to mitigate these issues by allowing better control over asynchronous operations.

• Explores the use of generator functions as a more robust alternative to traditional async functions, providing a way to manage and abort asynchronous operations more effectively.

Temporal Fuzzing I: Memory Models

Published: 1 July 2021

Tags: concurrency, memory

Michael Reitzenstein introduces the concept of temporal fuzzing in memory models, explaining its application in analyzing shared memory concurrency and the unexpected outcomes that can arise from different processor memory models.

Some highlights:

• Temporal fuzzing is used to explore and expose concurrency issues by simulating different memory models and observing the outcomes.

• The article provides a detailed pseudocode scenario illustrating how simultaneous operations can lead to various results depending on execution timing.

• Demonstrates how temporal fuzzing can aid in understanding complex systems and predicting their behavior under different conditions.

A Developer’s Guide to One-Time Passwords (OTPs)

Published: 28 June 2021

Tags: sponsored, auth, web

WorkOS has published an extensive guide on how one-time passwords work, their benefits, and implementation details.

Some highlights:

• “OTPs come in three different forms, and each form works differently: time-synchronized OTPs, lockstep synchronized OTPs, or transmission-based OTPs”

• OTPs are more secure than static passwords, but can create a frustrating user experience due to potential delays

• Pros and cons for OTPs

Compiling higher order functions with GADTs

Published: 9 May 2024

Tags: haskell, functional

Srijan explains defunctionalization for flattening out higher order functions in compiler passes.

Some highlights:

• Based on a paper that demonstrates it in OCaml.

• “Defunctionalization is a transform – a way to re-write the original program without using higher order functions such that it can be trivially compiled to a flat IR in subsequent compiler passes.”

• “Defunctionalization can transform first class functions with immutable variable captures”.

Hey hey hey,

Here’s dat issue.

Made possible through generous sponsorship by:

Evolving the Go Standard Library with math/rand/v2

Published: 1 May 2024

Tags: go

Russ Cox discusses the introduction of math/rand/v2 in Go 1.22, a new version designed to address issues with the math/rand package while improving performance and flexibility for future upgrades.

Some highlights:

• The math/rand/v2 package replaces the old pseudorandom number generator to fix repeatability issues and enhance performance.

• The new version introduces breaking changes, including the removal of outdated methods and the adoption of a more secure default random generator.

• It balances backward compatibility with the necessity of modern improvements.

Lessons from building an automated SDK pipeline

Published: 23 April 2024

Tags: sdk

Jacob Bednarz discusses Cloudflare's development of an automated SDK pipeline, which enhances consistency and reduces manual efforts in SDK updates across programming languages using OpenAPI and the Stainless generation engine.

Some highlights:

• The introduction of automated processes reduced the number of required pull requests and increased update frequency.

• Emphasizes the importance of language-specific nuances in SDK generation to improve user experience.

• Utilizes modern tools like codemods for large-scale code transformations and maintaining high quality across APIs.

The Developer’s Guide to SSO

Published: 27 October 2023

Tags: sponsored, auth, web

WorkOS has published a guide on how to best integrate single sign-on (SSO) in your app.

Some highlights:

• SSO is a common requirement when organizations first start selling to enterprises

• ​describes the general request flow for a user logging in with SSO

• summarizes how to build SSO from scratch and how to use existing providers

Speculations on arenas and custom strings in C++

Published: 14 April 2024

Tags: c++, optimization, memory

Chris Wellons discusses his approach to building custom strings and arenas in C++ by minimizing complexity and avoiding extensive use of C++ features, aiming to maintain simplicity and reduce potential errors.

Some highlights:

• Advocates for the use of minimal template usage and simple memory allocation techniques to improve clarity and performance.

• Outlines the benefits and limitations of modifying traditional C++ string handling to better suit specific programming needs.

• Emphasizes practical, straightforward programming without overreliance on C++'s more complex features.

Howdy,

I shared a little SQL snippet yesterday for determining what tables in your postgres database are taking up the most space. It was useful for determining what data I could skip exporting for a dev environment (or prod database is ~100GB, which isn’t huge, but a bit inconvenient to work with). I’d be curious to hear how people handle dev databases in these kinds of situations.

Anyway, here’s the issue.

Made possible through generous sponsorship by:

The evolution of Figma’s mobile engine: Compiling away our custom programming language

Published: 1 May 2024

Tags: typescript

Brandon Lin illuminates how Figma migrated from using their custom language Skew to industry standard TypeScript.

Some highlights:

• Switched because it was hard to ramp on talent and was missing a developer ecosystem.

• Migration became possible because more mobile browsers started supporting WebAssembly.

• The process was broken into three steps, write skew → build skew, write skew → build typescript, write typescript → build typescript

The business of wallets

Published: 30 April 2024

Tags: finance, business

Patrick McKenzie explores the economics and functionality of electronic wallets, detailing how they manage money transfers within their ecosystems and generate revenue through both transaction fees and interest on stored funds.

Some highlights:

• Wallets like PayPal earn money by charging fees on transactions and earning interest on customer balances.

• The business model for wallets involves reducing transaction costs within their ecosystem while monetizing both deposits and withdrawals.

• Discusses how electronic wallets have evolved from simply safeguarding money to becoming complex financial tools with broad applications.

The Developer's Guide to Domain Verification

Published: 15 November 2024

Tags: sponsored, networking, auth, dns

WorkOS’ blog “examines best practices to consider when building in-house as well as a simple alternative” that they provide when it comes to domain verification.

Some highlights:

• “Domain verification is a crucial security measure for SaaS providers, ensuring that services are securely delivered to the legitimate owners of a domain”

• “Don’t place TXT records on the root domain”

• WorkOS offers a simple API you can integrate with to do domain verification

There are Only Four Billion Floats–So Test Them All!

Published: 27 January 2014

Tags: testing

Bruce Dawson explores the idea of exhaustively testing all possible float values in programming to ensure the accuracy of functions that handle floating-point math, highlighting common errors and ways to correct them.

Some highlights:

• Demonstrates how exhaustive testing of all four billion possible floating-point values can identify and help rectify errors in mathematical functions.

• Discusses common issues with ceil, floor, and round functions that fail due to incorrect rounding methods or handling of very small numbers.

• Proposes that while conventional wisdom advises against exact float comparisons, there are situations where such precision is necessary for correctness.