Susan Potter

What if your language tooling was AI-native?

Wed, 25 Jun 2025 00:00:00 +0000

I know, I know. I almost puked writing “AI-native”, but I thought it would be a good way to get your attention. This is my elbow-in-the-ribs nudge to tool makers to get them to (thoughtfully) leverage the rich tapstry of AI capabilities into our software tools already and get over ourselves.

The Perfection Paradox: Why 'Good Enough' is Often Better

Wed, 20 Nov 2024 00:00:00 +0000

Explore the Perfection Paradox: where striving for flawlessness can hinder progress, and learn strategies to balance quality with action.

Software Optimization Through Property-Based Thinking

Thu, 31 Oct 2024 00:00:00 +0000

Explore how to apply property-based thinking to the practice of software optimization.

Software Optimization Mental Models for Software Engineers

Mon, 21 Oct 2024 00:00:00 +0000

Explore useful mental models for software engineers to apply to the practice of software optimization

The costs of digital twins and solving the 200% problem

Thu, 26 Sep 2024 00:00:00 +0000

Digital twins can be valuable, but they’re not a silver bullet. Effective abstractions are crucial for managing complex infrastructure. Choose the right approach for your needs. Avoid bad abstractions that can lead to bloatedness and confusion. Focus on building powerful, intuitive interfaces.

An Ode To ISO 8601

Wed, 04 Sep 2024 00:00:00 +0000

A ISO 8601 guide to date, time, duration, interval formats and more for working developers.

Why Early-Stage Software Startups Need Strategic Engineering Leadership

Sun, 05 May 2024 00:00:00 +0000

In today's economy, new businesses live or die based on their ability to deliver products and services that exceed customer needs especially since it has never been cheaper to start a software business before. Yet all too often, early-stage startups are led by founding teams who are incredible at sales, marketing, or building prototype-quality MVPs but lack the deep or strategic technical expertise required to scale their brilliant ideas into full-fledged, production-ready offerings after validating their idea.

A Haskell view of functional programming ("effectful")

Tue, 18 Jul 2023 00:00:00 +0000

This article explores Haskell’s techniques for isolating side effects, starting with the IO monad, which encapsulates impure code to enable reasoning about pure portions. It explains IO’s benefits like sequencing effects and isolating them from infecting other code. The article then provides a high-level overview of more advanced Haskell effect systems including MTL-style monad transformers and freer algebraic effects, comparing their strengths and weaknesses through code examples. In summary, the article demonstrates Haskell’s functional approaches to managing effects through tools like IO, MTL, and freer algebras, allowing programmers to maintain purity without sacrificing real-world capabilities and enabling the construction of reliable, testable programs.

A Haskell view of functional programming (well-typedness)

Mon, 10 Jul 2023 00:00:00 +0000

Dive into an educational journey exploring the power of strong static typing, enforcing domain-specific constraints, and ensuring the validity of values. Uncover how well-typedness enhances code reliability, maintainability, and understandability, while enabling robust composability and scalability.

TypeScript's Mapped Types

Fri, 23 Jun 2023 00:00:00 +0000

In this in-depth exploration we discover the power of mapped types in TypeScript through numerous examples. At the end working through the article you will be able to transform properties with ease, and master best practices when adopting mapped types.

Cross-runtime TypeScript Library Development: A Deno-Node Workflow

Wed, 21 Jun 2023 00:00:00 +0000

Are you a TypeScript developer who loves Deno’s safe and sandboxed environment and its out-of-the-box TypeScript, LSP, linting, formatting, stdlib testing and benchmarking support? Join me as I walk you through a possible workflow that combines the best of Deno tooling with Node.js compatibility.

Rapid Data Exploration with DuckDB: An In-Depth Tutorial

Mon, 19 Jun 2023 00:00:00 +0000

A comprehensive guide that explores the power of DuckDB for efficient and effective data exploration. The tutorial covers the entire process, from setting up DuckDB and loading data to advanced querying, visualization, and optimization techniques. It highlights the capabilities of DuckDB in performing advanced analytics and statistical functions, as well as creating interactive charts and graphs. With real-world case studies and examples, this tutorial equips readers with the knowledge and tools to unlock the full potential of data exploration using DuckDB, empowering data scientists, analysts, and business professionals to make informed decisions based on valuable insights gained from their datasets.

Using Conditional Types in TypeScript

Wed, 31 May 2023 00:00:00 +0000

Dive into TypeScript's conditional types and discover how they empower developers to create flexible type mappings and enhance type safety. This article explores the mechanics of conditional types, demonstrates their application through practical examples, and showcases their ability to eliminate runtime bugs and improve code resilience. Embrace the power of TypeScript's conditional types and unleash the full potential of your code!

Chip War: The Fight for the World's Most Critical Technology

Fri, 26 May 2023 00:00:00 +0000

Through vivid and colorful anecdotes, historian Miller breathes life into the past, recounting the incredible stories of figures like Andy Grove and Morris Chang, who rose from the ashes of World War II to create powerhouse companies Intel and TSMC.

Discombobulated thoughts on generative artificial intelligence

Sun, 21 May 2023 00:00:00 +0000

Brace yourself for a wild expedition through the tangled maze of generative artificial intelligence (AI) in this engaging and thought-provoking article. Dive into the misconceptions surrounding generative AI, explore its potential impact on the workplace and the life of a consumer, and unravel the shadows and challenges that lie ahead. Join the author on a rollercoaster ride of hope and despair, as they navigate the intricate complexities of AI's power and its implications for humanity.

The Pitfalls of Serverless Hosting

Fri, 19 May 2023 00:00:00 +0000

Join us as we dive into the world of serverless hosting and uncover the hidden challenges that come with this revolutionary approach. While serverless architectures promise scalability, cost-efficiency, and ease of deployment, they also present a range of obstacles that developers need to be aware of. From cold start latency to vendor lock-in, debugging woes to resource constraints, and limited visibility to scaling challenges, we explore the pitfalls that can impact your application's performance and user experience. By understanding these issues and adopting informed strategies, you can navigate the bumpy road to success in the serverless landscape.

Extracting Your Twitter Archive into DuckDB

Sun, 18 Dec 2022 00:00:00 +0000

Discover how to extract and analyze your Twitter archive using DuckDB, a lightweight and fast embeddable SQL database. This article provides step-by-step instructions for extracting data from your Twitter archive, converting it into a CSV file, and importing it into a duckdb database. By leveraging the power of DuckDB, you can query your tweets based on specific criteria and gain valuable insights. Whether you're interested in republishing popular tweets or exploring different data sets, this guide empowers you to make the most of your Twitter archive. Get ready to unleash the potential of your social media history with DuckDB!

Flix Series Part 1: Higher-order functions & infix combinators

Mon, 04 Jul 2022 00:00:00 +0000

This article delves into the world of functional programming with the Flix programming language with higher-order functions and user-defined infix operators.

Flix Series Part 0: Getting Started & Setup

Sun, 05 Jun 2022 00:00:00 +0000

Are you ready to embark on a coding adventure with Flix? This article introduces Flix, a programming language that combines the best features of functional languages like Scala and Haskell. But that's not all—Flix also brings its own innovative additions, such as row polymorphic extensible records and first-class support for Datalog constraints.

Unikernels: A Strategic Technology Assessment for Engineering Leaders

Sun, 19 Dec 2021 00:00:00 +0000

A comprehensive guide for CTOs and engineering leaders evaluating unikernels as a strategic technology investment, covering business impact, implementation considerations, and decision frameworks.

Review: Remarkable2 e-ink (paper) tablet

Tue, 27 Jul 2021 00:00:00 +0000

Unveiling my first public product review, I invite you on an exciting journey of expectations and surprises. In this comprehensive evaluation, I'll share the background of my purchase, including motivations and any discounts received. Then, I'll delve into vital aspects such as delivery, product quality, setup, customization, regular usage, and its transformative impact. To top it off, I'll compare this product to others I own.

Track diffs by scoping file, range, function, method, class changes

Tue, 22 Dec 2020 00:00:00 +0000

Discover the power of scoping change differentials in Git by focusing on specific files, line ranges, functions, methods, or classes. This article demonstrates various commands using the Ruby language repository, allowing developers to track changes in a particular semantic scope rather than at a file or directory level. Learn how to scope log diffs per file, identify diffs within a line range of a file, and limit change log noise by scoping diffs to named blocks in a file. With these techniques, you can review the history of specific code elements and gain a deeper understanding of how they have evolved over time.

TypeScript's keyof operator and possible uses

Sun, 18 Oct 2020 00:00:00 +0000

Discover the incredible potential of the keyof operator in TypeScript and revolutionize your code for a better development experience.

How to make seemingly impossible decisions

Sat, 17 Oct 2020 00:00:00 +0000

Originally published as a Twitter thread starting here. In the realm of technical and people management leadership, decisions loom large, often presenting themselves as formidable challenges. But fear not! Join me on a recent coaching expedition, where I guided a colleague through the treacherous terrain of decision-making. Surprisingly, what seemed insurmountable at first turned out to be conquerable. So, let's embark on this process together and unlock the secrets to confident decision-making.

JavaScript objects to TypeScript enumerations, const enums, ambient enums

Fri, 25 Sep 2020 00:00:00 +0000

Learn how to leverage TypeScript's enums, const enums, ambient enums and how they impact generated JavaScript code. Unveil the benefits and drawbacks of using const enums.

Using three-way diffing context for merge conflict style in Git

Thu, 24 Sep 2020 00:00:00 +0000

It recently came to my attention that not everyone overrides the default merge.conflictStyle git-config setting. So in case anyone here wanted to try something new out that would provide more context during a Git conflict resolution scenario here you go. I use diff3 which you can set like this to override the default.

Work-from-Home Work and Home Separation Tips

Sun, 23 Aug 2020 00:00:00 +0000

Since 2006 I have been working from home (starting part-time) and ever since March (2020) friends have been asking me to write an article about how I separate my work from home life when working from home (WFH). Define your work space Whether it's a dedicated room or a corner, make your work space a place you can focus. Those with space constraints can define spaces with movable room dividers or furniture like a colleague of mine with a studio in Manhattan used to do.

Algebraic Data Types in TypeScript

Tue, 11 Aug 2020 00:00:00 +0000

Note: the code for the TypeScript (to help you follow along) is available here: Encoding Algebraic Data Types in TypeScript code Background Recently I've been reviewing TypeScript code at work. A common pattern I've observed in pull requests and some open source projects is a type that looks like the following: type FooTag = 'Bar' | 'Baz' | 'Qux'; type Foo<A> = { _tag : FooTag, /* Required for the 'Bar' tagged values of Foo */ bar?

Algebraic Data Types: For the math(s) inclined

Tue, 11 Aug 2020 00:00:00 +0000

Unlock the mathematical elegance of algebraic data types (ADTs) and revolutionize your understanding of data modeling! Discover how algebraic principles can determine the cardinality of ADTs, allowing you to represent an astonishing number of values. Explore the power of sum types, where you can "sum up" the cardinalities of different data constructors to find the overall cardinality of the type. Dive into practical examples, such as representing colors with RGB and CMY models, and witness how the choice of representation affects the total number of possible colors. This teaser article provides a glimpse into the fascinating world of ADTs, with recursive types and zippers waiting to be explored further. Whether you're a math aficionado or just curious about the beauty of data modeling, this journey will leave you enlightened and inspired.

Thinking in Properties (and Beyond), Testing edition

Sat, 01 Aug 2020 00:00:00 +0000

Slide deck from conference talk discussing how property-based testing offers a launchpad to discover and practice thinking in properties in your software development activities to test your software smarter.

Experience report deploying PureScript to AWS Serverless (Lambda)

Wed, 03 Jun 2020 00:00:00 +0000

In this blog post, an experienced software engineer shares their successful deployment of a pure functional serverless function to AWS using PureScript. They spent around $15 per day on API Gateway and Lambda invocations without cost optimization, handling a peak load of 32k invocations per minute with low latency. The engineer highlights the need for adjustment in debugging and deployment processes and discusses challenges with tools and automation. Despite concerns, costs remained manageable, and there is potential for further optimization.

`any` versus `unknown` in TypeScript: When to use one over the other

Wed, 29 Jan 2020 00:00:00 +0000

Discover the critical distinctions between `any` and `unknown` in TypeScript, and unleash the full potential of static typing. Join this TypeScript journey, where I advocate for stronger types and prefer the vigilant guardian, `unknown`, whenever possible. Say goodbye to chaotic code and runtime errors, and embrace a smoother development experience with `unknown`. While `any` may seem tempting with its reckless freedom, it's time to make a choice that prioritizes safety and reliability. Let's delve into real-world examples and equip ourselves for an exhilarating TypeScript adventure filled with confidence and type safety.

DynamoDB: The Basics

Wed, 30 Oct 2019 00:00:00 +0000

Dive into the fundamentals of DynamoDB and discover its unique data modeling concepts. This article explores the similarities and differences between DynamoDB and relational databases, highlighting the importance of data modeling in DynamoDB. Learn about primary keys, secondary indices, and the flexible attributes that make DynamoDB a powerful NoSQL solution. Gain insights into access patterns, self-describing keys, and best practices for designing efficient DynamoDB tables. While cost optimization and other topics are left for future exploration, this article sets the foundation for leveraging DynamoDB effectively in your projects.

From Zero to Haskell: Lessons Learned (ZuriHac)

Sat, 15 Jun 2019 00:00:00 +0000

Embarking on functional programming within an established software organization is a daunting task, but this talk reveals some secrets and wisdom acquired from experience trying to build a team this way. Discover how to manage existing systems while incorporating a functional mindset and building expertise. Learn approaches to reduce risks, foster a learning culture, and transition from ad-hoc workarounds to a profound understanding of the problem domain. Join us on this extraordinary journey of transformation and unlock the true potential of functional programming in software development.

Shorts

Sat, 11 May 2019 22:41:25 -0500

My absolute favorite format of film is the short film. Here are a list of short films I loved watching: Re-Gifted (2018): CGI 3D short film that follows the life of a decrative ornament. 3x3 (2009): A tale of two different approaches to mastery. The Bigger Picture (2015): Two brothers struggling to cope with their elderly mother's care. Round About Five (2005): A bicycle courier and a businessman share a fleeeting moment during a London rush hour.

Dynamically scaling a news and activism hub (5x traffic in 20 mins)

Fri, 26 Apr 2019 00:00:00 +0000

On any given day this news discussion site can receive traffic peaks up to five times our base traffic, sometimes requiring us to scale out to double our backend app server capacity within a 10-20 minutes window (sometimes at unpredictable times). In this talk, Susan Potter will discuss DailyKos's use of autoscaling in EC2 from the essential components to some gotchas learned along the way.

Socket Statistics on Linux with ss

Wed, 03 Apr 2019 18:44:52 -0500

An excellent tool when you need to troubleshoot distributed systems is ss, which provides visibility into TCP states of your live connections. Even if you know netstat this is a command you should get acquainted with because of its more powerful interface which requires fewer pipes to find the connection information you need and it is probably already installed on your favorite distribution. In this post, we walk through a couple of examples, and then show a real-world production problem that can be diagnosed by effective use of ss.

Profunctor exploration in less than 100 lines of Haskell

Tue, 30 Oct 2018 00:00:00 +0000

A snippet showing the design space around profunctors using Haskell as the teaching language Includes sighting of Strong, Choice, Cartesian and more profunctors.

Decoding lens operators

Sat, 21 Apr 2018 14:15:59 -0500

Notation conventions The following table provides a quick overview of conventions used in symbolic operators in the lens library. Symbol Concept Denotes ^ getter gets value from structure ~ setter sets values in structure % over apply transformation over selected substructure = state threads state through << before change returns value before specified change < after change returns value after specified change ? Maybe optionality ! force force value

Functional Operations (Functional Programming at Comcast Labs Connect)

Fri, 09 Mar 2018 00:00:00 +0000

Maintaining configurations for different nodes and cloud resources in a [micro]service architecture has been an absolute nightmare in the past. The separation between CI/CD environments and production configuration has led to unpredictable results and false positives. Deploying code to staging and production has often resulted in unforeseen consequences that can't be identified beforehand, leaving users frustrated when problems arise. This session introduces the Nix and NixOS ecosystem, which offers a transparent and reliable approach to defining and building packages. By leveraging this system, you can configure systems and test multiple machines with coordinated scenarios, providing a solid foundation for your operations. Additionally, with reliable packaging, you can establish a consistent CI/CD pipeline, ensuring that upgrading the JVM won't bring your CI build servers to a halt for days. Say goodbye to operational nightmares and embrace a more controlled and dependable environment.

Economic concepts applied in software development and leadership

Thu, 22 Jun 2017 15:42:40 -0500

Discover how economics concepts can change your approach to software development, technical leadership, and reliability engineering. This article explores various economic principles and their practical applications in the tech industry. Learn how concepts like opportunity cost, causal inference, comparative advantage, thinking on the margins, and the lump of labor fallacy can provide valuable insights and help you make informed decisions. By applying these economic ideas, you can optimize resource allocation, drive efficient decision-making, and enhance the overall effectiveness of your engineering organization. Find out how cross-disciplinary knowledge can reshape your strategies and take your team to new heights.

Ruby 2.4 changes overview

Sun, 25 Dec 2016 00:00:00 +0000

Unified Fixnum and Bignum into Integer It’s backward compatible too. $ irb irb(main):001:0> RUBY_VERSION => "2.3.1" irb(main):002:0> (2**100).class => Bignum irb(main):003:0> 2.class => Fixnum irb(main):004:0> Fixnum => Fixnum irb(main):005:0> Bignum => Bignum irb(main):006:0> Bogonum NameError: uninitialized constant Bogonum from (irb):6 from /home/spotter/.nix-profile/bin/irb:11:in `<main>' irb(main):007:0> quit $ nix-env -f . -iA ruby_2_4_0 replacing old ‘ruby-2.3.1-p0’ installing ‘ruby-2.4.0’ $ irb irb(main):001:0> RUBY_VERSION => "2.4.0" irb(main):002:0> (2**100).class => Integer irb(main):003:0> 2.class => Integer irb(main):004:0> Fixnum (irb):4: warning: constant ::Fixnum is deprecated => Integer irb(main):005:0> Bignum (irb):5: warning: constant ::Bignum is deprecated => Integer irb(main):006:0> Bogonum NameError: uninitialized constant Bogonum from (irb):6 from /home/spotter/.

Functional and Reactive Operations

Tue, 04 Oct 2016 00:00:00 +0000

If we were starting greenfield development of a service or web application today we would likely employ a number of practices and design choices that are known to optimise application responsiveness, resiliency, elasticity, and/or composability. Delivering our reactive applications on top of predictable infrastructure will set our project up for success. Some of us don't have that luxury. We must provision, deploy, and operationally maintain legacy monolithic Rails web applications and HTTP APIs that are hard to refactor without introducing new bugs, poorly performing, and struggle to meet user load/peak demand. Built during a prior era of the company where fast and loose practices were rewarded, startup cowboys delivered the first set of features promptly at the expense of subsequent velocity, long-term maintainability, and high risk deployments. When living in this reality, our infrastructure must be reliable or our application needs constant babysitting, leading to on-call fatigue and high staff turnover. The good news is there are core principles we can apply to produce more reproducible systems, failstop deployments, and consistent environment configurations to eliminate a large class of bugs inherent in legacy applications and minimize related business risks. This will be the focus of the session and applies to both greenfield and legacy cases. Code examples given using NixOS and Haskell, but focus remains on the underlying principles.

Put a Type On It: Idris Types as Propositions

Wed, 21 Sep 2016 00:00:00 +0000

Note from a talk I gave at Strangeloop showing how Curry-Howard can be applied to structuring types to represent logical propositions using Idris as the teaching language.

Nix in your home directory

Tue, 30 Aug 2016 00:00:00 +0000

Prerequisites wget is installed tar is installed Purpose If you really don't want to install Nix under /nix (or you can't) then you can install Nix in your home directory like in the homedir_install.sh script included in this Gist. Now whenever you want to run a command under Nix's control, you should prefix with nixrun. Good luck. homedir_install.sh function install_nix() { local -r bindir="${HOME}/opt/bin" local -r proot_url="https://github.com/proot-me/proot-static-build/blob/master/static/proot-x86_64?raw=true" local -r nixdir="${HOME}/mnt/nix" local -r nixver="1.

To Type or not to Static Type

Sun, 01 May 2016 00:00:00 +0000

Originally published as a Gist here: https://gist.github.com/mbbx6spp/60577af8dc4106d6e710cd804292ce20 Minor modifications in formatting and an extra line of no-judgement was added to this text from the original Gist. Purpose, Disclaimer and Confessions This is the (mostly) no nonesense guide to studies and research that measures and/or compares a variety of facets, characteristics, or manifestations of software development in dynamically vs statically typed programming languages. Disclaimer: For larger, more complex codebases, I do advocate for statically typed languages that also support algebraic data types (ADTs), generic types, type classes, and preferrably a form of typelevel expressiveness (e.

From Zero To Production (NixOS, Erlang)

Tue, 08 Mar 2016 00:00:00 +0000

This talk will introduce the audience to the Nix packaging, NixOS, and related ecosystem tools for Erlang/Elixir developers. By reviewing common development, testing, and deployment problems we will look at what Nix has to offer to aid Erlang/Elixir developers in these areas. From seamless developer environment bootstrapping to consistent CI environments and beyond.

Parametricity: A Practitioners Guide

Thu, 25 Sep 2014 00:00:00 +0000

This post is a quick and handy guide that introduces the concept of parametricity and explains how it can be leveraged in software development. The article aims to target industry practitioners familiar with mainstream languages and methods, providing them with a practical understanding of parametricity and its benefits. It discusses the prerequisites and terminology related to parametricity, including the need for pure functions, total correctness, and support for parametric polymorphism. The article also explores different forms of reasoning, such as abduction, induction, and deduction, and their relevance to software development. Through examples and type signatures in Haskell, the article demonstrates how parametricity can enable reasoning about code and lead to more reliable and predictable software. Overall, it offers a valuable resource for developers looking to enhance their understanding and application of parametricity.

Scalaz By Example (An IO Taster)

Thu, 09 Jan 2014 00:00:00 +0000

Explore the building blocks in Scala using Scalaz that offer enormous benefits of algebraic thinking from domain modeling, validation, data types, and even the intricate realm of distributed systems. Wield the power of Scala's implicits, unleashing ad-hoc polymorphism to support functional programming abstractions like monoids, functors, applicatives and monads.

Algebraic Data Types

Tue, 27 Nov 2012 00:00:00 +0000

Unlock the power of algebraic data types to revolutionize your programming! Discover the flexibility of sum types, also known as tagged unions, and product types, also called record types. Dive into Scala examples and see how algebraic data types provide exhaustive and type-safe constructions. Explore the hybrid sum-product types and their applications in modeling complex domains like social network notifications. With algebraic data types, you can build robust and expressive code by combining smaller pieces into a cohesive whole. Don't miss out on this opportunity to level up your programming skills!

Functional Algebra: Monoids Applied

Sat, 10 Nov 2012 00:00:00 +0000

In functional programming, words from Category Theory are thrown around, but how useful are they really? This session looks at applications of monoids specifically and how using their algebraic properties offers a solid foundation of reasoning in many types of business domains and reduces developer error as computational context complexity increases. This will provide a tiny peak at Category Theory's practical uses in software development and modeling. Code examples will be in Haskell and Scala, but monoids could be constructed in almost any language by software craftsmen and women utilizing higher orders of reasoning to their code.

Why Haskell? Embrace Correctness

Fri, 16 Mar 2012 00:00:00 +0000

Discover the hidden gems of pure functional programming, immutability, and static typing, as we delve into the realm of elegance, robustness, and concise code. Challenge the status quo and embrace a new paradigm to unlock a world of limitless possibilities.

Erlang OTP Glossary of Terms

Tue, 10 Jan 2012 00:31:13 -0500

I am hoping this will serve as a reference for coworkers and others new to Erlang and OTP to be able to figure out the terminology easier than I had to. I learned the hard way, so you don't have to!:) Erlang/OTP - The set of libraries and conventions that are used as part of the core Erlang distribution by Ericsson to build fault-tolerant, distributed systems more effectively. OTP Release - A fully deployable distribution to run on an "Erlang node" (see below).

Dynamo: Not just for datastores

Mon, 19 Sep 2011 00:00:00 +0000

Find out how to build decentralized, fault-tolerant, stateful application services using core concepts and techniques from the Amazon Dynamo paper using riak_core as a toolkit.

Distributed Developer Workflows using Git

Mon, 01 Aug 2011 00:00:00 +0000

This meetup I will be walking the audience through how to setup, configure and maintain distributed development workflows using Git (the distributed VCS developers either love or hate). Much of the workflows suggested here will be applicable to other dVCSes like Mercurial, Darcs and Bazaar.

Why JSON Pointer falls short (and why XPath for JSON would be great)

Sun, 31 Jul 2011 00:00:00 +0000

Discover the limitations of JSON Pointer as a querying mechanism for JSON documents and the potential solution lying in XPath. This engaging article explores real-world scenarios, showcasing the challenges of extracting multiple values efficiently using JSON Pointer. It then introduces XPath, a powerful selector language known for its flexibility and descriptiveness in the XML world. Drawing a comparison between JSON Pointer and XPath, the article highlights the unmatched capabilities of XPath in retrieving data from complex JSON structures.

Erlang Meck API notes

Wed, 23 Mar 2011 01:11:30 -0500

Here is a snippet showing how to use the Meck API which is a mocking library in Erlang. We will show how to create a fully mocked version of an existing module, unloading mocks, removing functions from a mocked module, and getting a list of all function calls to a module.

Deploying Distributed Software to the Cloud (w/o Breaking a Sweat)

Sat, 05 Mar 2011 00:00:00 +0000

The promise of cloud computing provides business benefits from reduced costs to increased flexibility. One struggle organizations face as they move to run on cloud infrastructure is automating complex dsitributed deployments.

Designing for Concurrency

Sun, 22 Aug 2010 00:00:00 +0000

Presenting traditional and less traditional approaches to designing concurrent systems in the 2010s using approaches that can be used across many languages and some runtimes.

Erlang's "let it fail" philosophy

Sat, 30 Jan 2010 00:00:00 +0000

Erlang, a powerful programming language designed for fault tolerance and high availability, challenges traditional error handling with its groundbreaking concept of "let it fail." Instead of obsessively anticipating and accounting for every possible error scenario, Erlang embraces failures as a natural part of the system and provides tools to gracefully handle them. This philosophy revolutionizes software design by promoting a resilient approach that saves time and resources, enables rapid error detection and diagnosis, and enhances system resilience and scalability. Erlang's unique features, such as lightweight processes, built-in fault tolerance, hot code swapping, and concurrency-oriented programming, make it an ideal environment for adopting the "let it fail" philosophy. However, it's important to strike the right balance and identify critical failures that require immediate attention. Embracing failure in Erlang empowers developers, liberates their creativity, and transforms the software development landscape.

Predicate Algebra in Python

Mon, 09 Nov 2009 00:00:00 +0000

Updated for Python3 recently: class Predicate: """ Define predicate algebra. >>> isEven=Predicate(lambda x: x % 2 == 0) >>> isOdd=Predicate(lambda x: x % 2 == 1) >>> isEven(6) True >>> isOdd(6) False >>> isEmpty=Predicate(lambda s: s == "") >>> isNotEmpty=~isEmpty >>> isEmpty("c") False >>> isNotEmpty("") False >>> isNotEmpty("hello") True """ def __init__(self, predicate): self.predicate = predicate def __or__(self, other): return Predicate(lambda x: self.predicate(x) or other(x)) def __and__(self, other): return Predicate(lambda x: self.

Scala versus Erlang for Managers

Wed, 15 Apr 2009 00:00:00 +0000

The demise of Moore's Law has ushered in a new era of multi-core processors, posing challenges for software professionals. In this article, we explore the debate between Scala and Erlang as languages at the forefront of addressing the multi-core challenge, considering factors such as legacy systems, scalability, and the availability of skilled practitioners.

SCM: The Next Generation

Thu, 25 Jan 2007 00:00:00 +0000

Have you heard of Darcs or Git? Many developers are familiar with traditional version control systems like Subversion and CVS, but the next generation of source control management will be distributed version control systems (DVCS) such as Darcs and Git. Darcs, written in Haskell, offers a user-friendly alternative to Git with some powerful features. In a recent experience using Darcs, the author found it pleasurable and efficient. As the need for concurrent work increases, exploring these cutting-edge SCM systems becomes crucial for developers.