In Emacs version 28 Emacs developers introduced so-called read
symbol shorthands. If you’re interested in the rationale, feel free
to search the Emacs developer mailing list for the
discussion. However, it does seem that not everyone likes the idea
of shorthands as a substitution for namespaces (or packages, if
you’re coming from Common Lisp).
Macpine makes it possible to run LXD/LXC containers on MacOS with
support for both amd64 and arm64 processors, through its lightweight
virtualisation layer. This workflow makes it easy to develop and
test LXD containers locally.
Many users of Python deprioritize performance in favor of soft
benefits like ergonomics, business value, and simplicity. Users who
prioritize performance typically end up on faster compiled languages
like C++ or Java.
One group of users is left behind, though. The scientific computing
community has lots of raw data they need to process, and would very
much like performance. Yet, they struggle to move away from Python,
because of network effects, and because Python’s
beginner-friendliness is appealing to scientists for whom
programming is not a first language. So, how can Python users
achieve some fraction of the performance that their C++ and Java
I’m going to take that post and write a simplified version of part
of it here, as an exercise to help me understand what
happened. After all, the best way to understand something is to try
to explain it to someone else.
A few days ago I wrote a comment on The Orange
Site that seemed to
strike a chord there. The comment was about applying a few
principles of functional
in any language (well, maybe not BASIC from the 70s or 80s, but
these versions of BASIC aren't used much these days). There's no
need for functional application, functional composition, first class
functions, monads, (“Monads! How do they
work?”) or even
currying. No, I feel like you can get about 85% of the way to
functional programming by following three simple principles.
When writing tests for Django
projects, you typically need to create quite a lot of instances of
database model objects. This page documents the patterns I
recommend, and the ones I don’t.
Before I get going, I should mention that a lot of this can be
avoided altogether if you can separate out database independent
logic from your models. But you can only go so far without serious
contortions, and you’ll probably still need to write a fair number
of tests that hit the database.
Best friends Becky and Hunter find themselves at the top of a
2,000-foot radio tower.
In the evening Esme and I watched
Fall. At first I was not
sure if I would be able to watch the movie because I am very afraid of
heights. But with only one short break I managed to watch the whole
movie. I liked it and give the movie a 7 out of 10.
One of the best things to come out of the modern DevOps movement is
the aggressive push for “feature switches” (also known as “feature
flags” or “feature toggles”). At All Around the
World , we strongly recommend them
for our clients and sometimes we implement them, but I’m still
surprised that many companies don’t use them. They’re dead-simple to
build and they’re a powerful tool for site
reliability. Unfortunately, many articles discuss how to build them
or use them, but best practices are neglected. So we’ll skip the
implementation and instead focus on using feature switches
Functional programming offers a bunch of really cool programming
patterns. Two that I really enjoy are tail
especially how they are implemented in OCaml. However, I spend a lot
of time writing Emacs Lisp now, and I was wondering if I could find
a way to use these patterns in that language.
It turns out that it is possible, thanks to named-let and
pcase. It isn’t as pretty and elegant as OCaml, but at least I get
to keep excercising those parts of my programming brain. Maybe next
I’ll try to figure out currying in Emacs Lisp.
I hesitated writing this post, because I don’t want to start, or get
into, a holy war over programming languages. (Just to get the flame
bait out of the way, Visual Basic is the best language ever!) But
I’ve had a number of people ask me about my experience with Rust and
whether they should pick up Rust for their projects. So, I’d like to
share some of the pros and cons that I see of using Rust in a
startup setting, where moving fast and scaling teams is really
I'll describe a simple, one jail installation, not security oriented
nor explaining any single option. If you're managing an instance,
you should be skilled enough to understand what you're doing
here. It would be better to separate the services (Redis,
PostgreSQL, etc.) but, for simplicity, I'll just put everything in a
nice single (movable) jail.
This quickstart guide is intended to quickly familiarize GNU/Linux
users with the basics of OpenBSD and will highlight some of the
technical differences between OpenBSD and the various GNU/Linux
based distributions. It is not intended to be an exhaustive list of
differences, nor will it highlight the rather large philosophical
differences between OpenBSD and GNU/Linux.
12 Strong tells the story of the first Special Forces team deployed
to Afghanistan after 9/11; under the leadership of a new captain,
the team must work with an Afghan warlord to take down the Taliban.
In the evening I watched 12
Strong. I liked the movie and
give it a 7.5 out of 10.
As a Rust programmer you are probably quite familiar with how
references work in Rust. If you have a value of type T you can
generally get various references to it by using the ampersand (&)
operator on it. In the most trivial case &T gives you just that: a
reference to T. There are however cases where you can get
something else. For instance String implements
Deref<Target=&str> which lets you also get a &str from it and
that system also can be extended to work with mutable references as
This question has been answered many times before, but it bears
repeating: Why do people like using dynamic languages? One common
compelling reason is that dynamic languages like Python only require
you to learn a single tool in order to use them well.
One of the nice things about the Rust programming
language is that it makes it easier to
write correct concurrent (e.g. threaded) programs – to the degree
that Rust’s slogan has been, at times, “fearless concurrency.”
But I’d like to tell you about the other side of Rust, which I
think is under-appreciated. Rust enables you to write programs that
are not concurrent. This feature is missing from most other
languages, and is a source of much complexity and bugs.
A war fueled by the powers of dark sorcery is about to engulf the
peaceful land of Osten Ard—for Prester John, the High King, lies
dying. And with his death, the Storm King, the undead ruler of the
elf-like Sithi, seizes the chance to regain his lost realm through a
pact with the newly ascended king. Knowing the consequences of this
bargain, the king’s younger brother joins with a small, scattered
group of scholars, the League of the Scroll, to confront the true
danger threatening Osten Ard.
Simon, a kitchen boy from the royal castle unknowingly apprenticed
to a member of this League, will be sent on a quest that offers the
only hope of salvation, a deadly riddle concerning long-lost swords
of power. Compelled by fate and perilous magics, he must leave the
only home he’s ever known and face enemies more terrifying than
Osten Ard has ever seen, even as the land itself begins to die.
In the morning I started in The Dragonbone
book one of Memory, Sorrow, and Thorn by Tad Williams.
Intervals or ranges pop-up everywhere in the programming world. The
classic example is picking a start and end date, like you would when
booking an AirBnB or a flight. But that's just one example: from
slicing a JS
and even SQL's LIMIT operator, ranges are everywhere.
Have you ever wondered why they are always implemented as [closed, open) as opposed to [closed, closed]?
I have been trying to like static type checking in Python. For most
of my Django projects, I get annoyed and give up, so I’ve had a go
with some smaller projects instead. This blog post documents how it
went with Parsy, a parser
combinator library I maintain.
While it’s easy to fall in love with Nix and
want to use it to build and configure just about everything, let’s
face it: few of us are in a position to do so, especially in the
workplace. “Hey team, let’s Nixify our entire stack!” is unlikely to
endear you to your coworkers at daily standup. Fortunately, Nix is
good at enough things that you can reap many of its potential
benefits by incorporating it into only a subset of an already
existing software pipeline.
In this post, I’ll provide a concrete example of this by using Nix
inside a fairly standard
DevOps pipeline that builds
Docker images and deploys them to
Kubernetes in CI. Nix does a lot of heavy
lifting in this scenario but it doesn’t do everything: it doesn’t
stand up any infrastructure and it doesn’t handle deployment. That’s
all left to popular, trusted tools and platforms from outside the
Nix universe. I hope that this example inspires you to find ways to
incrementally introduce Nix into your own stacks.
I’ve always been intimidated by coding techniques: encryption and
decryption, hashing operations, error correction codes, and even
compression and decompression techniques. It’s not that I didn’t
know what they do, but I often felt that I never quite understood
the basics, let alone had an intuitive understanding of how they
Reed-Solomon forward error correction (FEC) is one such coding
method. Until the discovery of better coding techniques (Turbo codes
and low-density parity codes), it was one of the most powerful ways
to make data storage or data transmission resilient against
corruption: the Voyager
Reed-Solomon coding to transmit images when it was between Saturn
and CDs can recover from scratches that corrupt up to 4000 bits
thanks to the clever use of not one but two Reed-Solomon codes.
The story so far: At the end of the 1980s, Acorn Computers was at a
crossroads. A small team, led by Sophie Wilson and Steve Furber, had
invented a powerful new computer chip, the Acorn RISC Machine
(ARM). Acorn released a new computer line, the Archimedes, that used
these ARM chips. But the world wasn’t beating a path to the