Emacs grew support for displaying colour emojis recently (and this
is included in the release branch, which will become Emacs 28.1 in
some months). This includes support for the grapheme cluster emojis
(that consist of a number of Unicode code points, joined together
with zero-width joiners and magic).
The first time you encounter something, you're probably going to
make some mistakes. There's a post going around tonight about how
someone forgot to put an index on some database thing and wound up
doing full table scans (or something like that). The rub is that
instead of just being slow, it also cost a fair amount of money
because this crazy vendor system charged by the row or
somesuch. So, by scanning the whole table, they touched all of
those rows, and oh hey, massive amounts of money just set ablaze!
The usual venues are discussing it, and I get the impression some
people have the wrong approach to this. I want to describe a truly
bad database schema I encountered, and then tell you a little about
what it did to the system performance.
One of the most interesting emergent properties of the Rust language
has been the desire and ability to push more and more information
into the type system. Other programming languages allow this, but
Rust’s combination of speed, safety, and extremely powerful
compile-time computation through both types and macros, have lead to
a large ecosystem of highly capable libraries that do much of their
work before the program ever runs.
Recent developments in the type system are making it easier than
ever for programmers to take advantage of that power, and things are
only going to get more interesting.
The Parser in CPython is currently a PEG (Parser Expression
parser. The first version of the parser used to be an
LL(1) based parser that
was one of the oldest parts of CPython implemented before it was
replaced by PEP
617. In particular,
both the current parser and the old LL(1) parser are the output of a
means that the way the parser is written is by feeding a description
of the Grammar of the Python language to a special program (the
parser generator) which outputs the parser. The way the Python
language is changed is therefore by modifying the grammar file and
developers rarely need to interact with the parser generator itself
other than use it to generate the parser.
Go’s place between C and Python in terms of abstraction and garbage
collection memory management model has made it attractive to
programmers looking for a fast but reasonably high level
language. However, there is no free lunch. Go’s abstractions,
especially with regards to allocation, come with a cost. This
article will show ways to measure and reduce this cost.
When I used to run a scraping service, I managed to scrape at most a
couple of million Google SERPs per week. But I never ever purchased
proxies from proxy providers such as
In the C programming language, we allocate memory dynamically (on
the heap) using the malloc function. You pass malloc a size
parameter corresponding to the number of bytes you need. The
function returns either a pointer to the allocated memory or the
NULL pointer if the memory could not be allocated.
Most of my time over the past two years has been developing primary
in Go. If you’re not familiar with the Go programming language let
me sum it up for you real quick: take a modern, statically-linked,
type-strict language and remove every advancement in development in
the last 10 years or so, do some pretentious talks about how your
language is the best one out
there, and you have
Go. Now, don’t get me wrong, Go is a fantastic language. The problem
is that its also a horrible language.
Today will I take you through the
keyhole to look at a group of
software systems not well known to the public, which I call "Bank
Python". Bank Python implementations are effectively proprietary
forks of the entire Python ecosystem which are in use at many (but
not all) of the biggest investment banks. Bank Python differs
considerably from the common, or garden-variety Python that most
people know and love (or hate).
So, if you’re interested in low-level optimization of your Haskell
programs then this article is for you. I’ll demonstrate the use of a
valgrind tool, cachegrind, to inspect the behavior of the canonical
leaky Haskell program: a lazy left fold. You’ll get three things:
(1) a step-by-step tutorial on running cachegrind on your
programs. (2) a section-by-section breakdown of the cachegrind
profile, and (3) some guidance on interpreting the results.
Using the Network Time Protocol (NTP) is a simple and effective way
to set your local time. But how can you ensure that the time you are
getting is correct, what can you do to improve time accuracy, and
how do you decide which NTP servers are best for you?
Though Haskell is already quite widely used in the industry, it’s
still sometimes believed to be an “academical” language used
exclusively for scientific purposes. In this post, I’d like to tell
you about several rather popular Haskell tools which may be of use
Async await is part of the new structured concurrency changes that
arrived in Swift 5.5 during WWDC 2021. Concurrency in Swift means
allowing multiple pieces of code to run at the same time. This is a
very simplified description, but it should give you an idea already
how important concurrency in Swift is for the performance of your
apps. With the new async methods and await statements, we can define
methods performing work asynchronously.
You might have read about the Swift Concurrency Manifesto by Chris
before, which was announced a few years back. Many developers in the
Swift community are excited about the future to come with a
structured way of defining asynchronous code. Now that it’s finally
here, we can simplify our code with async-await and make our
asynchronous code easier to read.
SSH is the best option in most cases. It is widely used, usually
installed by default, and clients exist for every platform. However,
there are a few cases where you may want to consider an SSH
alternative. I was recently looking for ways to solve these edge
cases. These are my notes on alternative SSH servers.
When it comes to packages probably every Python developer thinks of
pypi. This is the most common way of
distribution them in the ecosystem.
But there are several cases where packages are in a progress or pre
alfa state in which a package maintaner considers a release is too
early. Or in other cases packages are only ment to be used
internally. One solution is to install such packages is via git.
People tend to associate intelligence with brain size. And as a
general guideline, this makes sense: more brain cells, more mental
capabilities. Humans, and many of the other animals we’ve come to
think of as unusually bright, such as chimpanzees and dolphins, all
have large brains. And it’s long been assumed that the smallest
brains simply don’t have the capacity to support complex mental
processes. But what if they do?
The vast majority of Earth’s animal species are rather small, and a
vanishingly small portion of them have been studied at all, much less
by cognition researchers. But the profile of one group of diminutive
animals is rapidly rising as scientists discover surprisingly
sophisticated behaviors among them.
“There is this general idea that probably spiders are too small,
that you need some kind of a critical mass of brain tissue to be
able to perform complex behaviors,” says arachnologist and
evolutionary biologist Dimitar Dimitrov of the University Museum of
Bergen in Norway. “But I think spiders are one case where this
general idea is challenged. Some small things are actually capable
of doing very complex stuff.”