Tag programming
78 bookmarks have this tag.
78 bookmarks have this tag.
I feel uneasy about design patterns.
On the one hand, my university class on design patterns revived my interest in programming.
On the other hand, I find most patterns in the Gang of Four book to be irrelevant to my daily work;
they solve problems that a choice of programming language or paradigm creates.My litmus test of a good design pattern is its cross-disciplinary applicability.
I’m more likely to accept an idea that pops up in fields beyond software engineering.
And the most convincing patterns are the ones that help me in everyday life.This article describes a universal pattern that billions of people rely on daily, but software engineers rarely discuss—the plan-execute pattern.
In functional programming,
combinator libraries refer to a design style that emphasizes bottom-up program construction.
Such libraries define a few core data types
and provide constructors—functions that create initial objects—and combinators—functions that build larger objects from smaller pieces.Combinators enable the programmer to use intuitive visual and spatial reasoning
that’s vastly more powerful than linear language processing.
As a result, solving problems with combinators feels like playing with lego pieces.
I just learned that
you can use it to review a git commit like this and I thought that was really
cool.
zb is a tool for reproducibly building software, similar to Bazel.
(See the comparison page if you’re curious to know the differences.)
When a software build process is reproducible,
it will produce the exact same output
when given the same inputs.
Reproducibility is a desirable property for a software build process to have:
it simplifies debugging,
it enables build speed-ups,
and it is essential for digital supply chain security.
However, reproducibility is a difficult goal to achieve.
I have been using IntelliJ Idea at work for a decade or so by now, and it’s been a reliable companion. JetBrains IDEs have a bit of a reputation for being slow, but their feature set is incredible: powerful refactoring tools, a great VCS UI (though I like magit even more!), a huge number of supported frameworks, integration with just about any testing library for any language, code coverage tools, powerful debuggers, etc.
The solution to all of these problems
I humbly put forward that modern web development provides us all the utilities to move away from class names and implement something much more robust, with some fairly straightforward changes:
Attributes
Attributes allow us to parameterise a component using a key-value representation, very similar to Map<string, T>. Browsers come with a wealth of selector functions to parse the values of an attribute.
I have a lot of thoughts about the design of compiler intermediate representations (IRs). In this post I’m going to try and communicate some of those ideas and why I think they are important.
Extra is different than More. Extra is finishing those two screens, but then researching a new library for form validation that might reduce the boilerplate code. Or it's learning ways to protect against common security vulnerabilities from data entry. These little off-ramps from the main highway of Normal Work could be dead-ends and not have any practical value to the project. But they might also be important contributions. And that's the thing with Extra. While the tangible value to the project is uncertain (it could be nothing this time or it could be something), the value to you is real.
Why do people keep telling me to use PGP? The answer is that they shouldn’t be telling you that, because PGP is bad and needs to go away.
There are a lot of guides about how to use async Rust from a "user's
perspective", but I think it's also worth understanding how it
works, what those async blocks actually mean.
The share_target manifest member allows installed Progressive Web Apps (PWAs) to be registered as a share target in the system's share dialog.
This post is all about speculative compilation, or just speculation for short, in the context of the JavaScriptCore virtual machine.
Every so often I come across a paper, blog post, or (occasionally) video that completely changes how I think about a topic in programming languages and compilers. For some of these posts, I can’t even remember how I thought about the idea before reading it—it was that impactful.
When people say Rust is a “safe language”, they often mean memory safety.
And while memory safety is a great start, it’s far from all it takes to build robust applications.
Memory safety is important but not sufficient for overall r…
Storage for private, distributed, offline-first applications. Earthstar is a specification and JavaScript library for building connected applications owned and run by their users.
In modern Java, the visitor pattern is no longer needed. Using sealed types and switches with pattern matching achieves the same goals with less code and less complexity.
Solving AoC on the DS with Rust.
Reading through the Emacs 30 NEWS file and picking
out the stuff I think is the most interesting.
My take on what could be a project template for Django advanced usage, with modern tooling (for Python and UI dependencies, as well as configuration/environment management), but not too opinionated.
Security testing starts with understanding vulnerabilities. The CVE website lists known software flaws. The OWASP Top Ten highlights common weaknesses. With this knowledge, we can improve our Go development. This article shows how to put in place robust practices. They are to: fuzz inputs, verify dependencies, and use static analysis tools (SAST).
I recently wrote about Async Pool, one of my favorite JavaScript / TypeScript helpers, and today I want to share an even simpler yet extremely useful utility
useDeferredValue is one of the most underrated React hooks. It allows us to dramatically improve the performance of our applications in certain contexts. I recently used it to solve a gnarly performance problem on this blog, and in this tutorial, I'll show you how! ⚡
Everything you need to write flexible, future-proof Rust applications using hexagonal architecture.
This blog series creates a small operating system in the Rust programming language. Each post is a small tutorial and includes all needed code.
A somewhat compact implementation of the awk programming language
There's a concept that I've heard called by a lot of different names, but my favorite name for it is …
A write-ahead log is not a universal part of durability
plainweb is a framework using HTMX, SQLite and TypeScript for less complexity and more joy.
Most functional languages rely on some garbage collection for automatic memory management. They usually eschew reference counting in favor of a tracing garbage collector, which has less bookkeeping overhead at runtime. On the other hand, having an exact reference count of each value can enable optimizations, such as destructive updates. We explore these optimization opportunities in the context of an eager, purely functional programming language. We propose a new mechanism for efficiently reclaiming memory used by nonshared values, reducing stress on the global memory allocator. We describe an approach for minimizing the number of reference counts updates using borrowed references and a heuristic for automatically inferring borrow annotations. We implemented all these techniques in a new compiler for an eager and purely functional programming language with support for multi-threading. Our preliminary experimental results demonstrate our approach is competitive and often outperforms state-of-the-art compilers.
The expression problem describes how most types can easily be extended with new ways to produce the type or new ways to consume the type, but not both. When abstract syntax trees are defined as an algebraic data type, for example, they can easily be extended with new consumers, such as print or eval, but adding a new constructor requires the modification of all existing pattern matches. The expression problem is one way to elucidate the difference between functional or data-oriented programs (easily extendable by new consumers) and object-oriented programs (easily extendable by new producers). This difference between programs which are extensible by new producers or new consumers also exists for dependently typed programming, but with one core difference: Dependently-typed programming almost exclusively follows the functional programming model and not the object-oriented model, which leaves an interesting space in the programming language landscape unexplored. In this paper, we explore the field of dependently-typed object-oriented programming by deriving it from first principles using the principle of duality. That is, we do not extend an existing object-oriented formalism with dependent types in an ad-hoc fashion, but instead start from a familiar data-oriented language and derive its dual fragment by the systematic use of defunctionalization and refunctionalization. Our central contribution is a dependently typed calculus which contains two dual language fragments. We provide type- and semantics-preserving transformations between these two language fragments: defunctionalization and refunctionalization. We have implemented this language and these transformations and use this implementation to explain the various ways in which constructions in dependently typed programming can be explained as special instances of the phenomenon of duality.
Most programming language ecosystems provide assert functions in their testing libraries but not Go's. Go's standard testing package follows a more direct and to-the-point approach.
build2 is an open source (MIT), cross-platform build toolchain that aims to approximate Rust Cargo's convenience for developing and packaging C/C++ projects while providing more depth and flexibility, especially in the build system.
Aurora: An extensible, Python-based static site generator.
I make mostly IRC software in C. I like OpenBSD but also the GPL. I just want to read books and try to learn to be kinder. When I can I'd like to talk to strangers and experience more magic.