9661
Literate SQL
Complex queries are hard to read. Literate SQL is about writing queries that are as easy to read as a good novel.
New
The latest blog posts to take off on Hacker News. 14,544 posts.
9662
How LZ4 works (2016)
LZ4 is an exciting algorithm, but unfortunately there is no good explanation on how it works. This blog post tries to explain it in terms that everybody can understand.
9663
Why Choose Vue.js
In the past five years or so, while the web development world was going mad with the JavaScript revolution – I stayed mostly indifferent, occupying myself with backend work and distracting myself with things like Kubernetes .
9664
Ways to Get Better at C++
Expressive code in C++
9665
What Challenges and Trade-Offs Do Optimising Compilers Face?
After immersing oneself in a research area for several years, it’s easy to feel like the heir to a way of looking at the world that is criminally underrated: why don’t more people want what I want? This can be a useful motivation, but it can also lead to ignoring the changing context in which most research sits. So…
9666
What the heck is a parser-combinator?
Introduction to parser combinators. Understand this functional programming concept for building parsers from smaller components.
9667
9668
Opus 1.2 Released
For music encoding Opus has already been shown to out-perform other audio codecs at both 64 kb/s and 96 kb/s . We originally thought that 64 kb/s was near the lowest bitrate at which Opus could be useful for streaming stereo music. However, with variable bitrate (VBR) improvements in Opus 1.1, suddenly 48 kb/s became…
9669
Tabs, spaces and your salary – how is it really?
Tabs and spaces are not what they seem.
9670
Why Python Is Not My Favorite Language (2016)
Historical reference to Ian Denhardt’s Why Python Is Not My Favorite Language (2016-12-25), with archive and current documentation links.
9671
Django project optimization guide – Part 1
Django is a powerful framework used in many great projects. It provides many batteries, that speed up development and therefore reduces the price of it. When a project becomes large and is used by many users you inevitably will run into performance problems. In this guide, I will try define potential problems and how…
9672
9673
One-Hour Mandelbrot: Creating a Fractal on the Vintage Xerox Alto
I wrote a short program to generate the Mandelbrot set on the Xerox Alto, a groundbreaking minicomputer from the 1970s. The program, in...
9674
The Aggregate Magic Algorithms (2015)
There are lots of people and places that create and collect algorithms of all types ( here are a few WWW sites). Unfortunately, in building systems hardware and software, we in The Aggregate often have found it necessary to do relatively obscure low-level things very efficiently. Many of the tricks we've devised or…
9675
9676
9677
Go and Simplicity Debt Redux
In my previous post I discussed my concerns the additional complexity adding generics or immutability would bring to a future Go 2.0. As it was an opinion piece, I tried to keep it around 500 words. This post is an exploration of the most important (and possibly overlooked) point of that post.
9678
Curl doesn’t spew binary anymore
One of the least favorite habits of curl during all these years, I've been told, is when users forget to instruct the command line tool where to store the downloaded file and as a direct consequence, curl instead sends a lot of binary "gunk" to the terminal. The end result of that is at best … Continue reading curl…
9679
How the .NET Runtime Loads a Type
It is something we take for granted every time we run a .NET program, but it turns out that loading a Type or class is a fairly complex process.
9680
TLA+ in Practice and Theory, Part 4: Order in TLA+
We learn how to encapsulate and compose TLA+ specifications, of the precise mathematical definition of abstraction, and compare TLA+'s notion of abstraction with those of other formalisms. Plus some various cool stuff.
9681
Go and Simplicity Debt
Fifteen years ago Python’s GIL wasn’t a big issue. Concurrency was something dismissed as probably unnecessary. What people really was needed was a faster interpreter, after all, who had more than one CPU? But, slowly, as the requirement for concurrency increased, the problems with the GIL increased.
9682
System programming in Rust: beyond safety
System programming in Rust: beyond safety Balasubramanian et al., HotOS’17 Balasubramanian et al. want us to switch all of our systems programming over to Rust. This paper sets out the case. …
9683
9684
Rust as a gateway drug to Haskell
For work-related reasons, I had to recently get up to speed on programming in Haskell. Before that, I had very little actual experience with the language, clocking probably at less than a thousand lines of working code over a couple of years. Nothing impressive either: some wrapper script here, some experimental…
9685
Writing a Unix Shell – Part II
Building your own UNIX shell in parts. This post explains how to execute commands.
9686
Compiling the Original Commodore 64 KERNAL Source
Many reverse-engineered versions of “KERNAL”, the C64’s ROM operating system exist, and some of them even in a form that can be built into the original binary. But how about building the original C64 KERNAL source with the original tools?
9687
The Design and Use of QuickCheck
QuickCheck is the grandfather of property-based testing libraries. Despite being imitated in over thirty languages, the original implementation remains pre-eminent due to the type system and consistent logic of the Haskell language in which it is written.
9688
9689
9690
Translating a C++ parser to Haskell
nix-derivation 1.0 announcement post