Tales

On bits of code: printb_flags()

Sat, 27 Dec 2025 00:00:00 +0000

Reflexion, oil on canvas, 1905 by William-Adolphe Bouguereau through wikimedia.org – Public domain While browsing OpenBSD’s httpd’s code, I stumbled upon “weird” flags packed to a char *, used via a function printb_flags(). Turn’s out the way it works is quite fun; here’s a runnable excerpt: #include <ctype.h> #include <stdio.h> #include <stdint.h> #include <string.h> #define SRVFLAG_BITS \ "\10\01INDEX\02NO_INDEX\03AUTO_INDEX\04NO_AUTO_INDEX" \ "\05ROOT\06LOCATION\07FCGI\10NO_FCGI\11LOG\12NO_LOG\13ERRDOCS" \ "\14SYSLOG\15NO_SYSLOG\16TLS\17ACCESS_LOG\20ERROR_LOG" \ "\21AUTH\22NO_AUTH\23BLOCK\24NO_BLOCK\25LOCATION_MATCH" \ "\26SERVER_MATCH\27SERVER_HSTS\30DEFAULT_TYPE\31PATH_REWRITE" \ "\32NO_PATH_REWRITE\34NO_BANNER\33GZIP_STATIC\37LOCATION_FOUND" \ "\40LOCATION_NOT_FOUND" const char * printb_flags(const uint32_t v, const char *bits) { static char buf[2][BUFSIZ]; static int idx = 0; int i, any = 0; char c, *p, *r; p = r = buf[++idx % 2]; memset(p, 0, BUFSIZ); if (bits) { bits++; while ((i = *bits++)) { if (v & (1 << (i - 1))) { if (any) { *p++ = ','; *p++ = ' '; } any = 1; for (; (c = *bits) > 32; bits++) { if (c == '_') *p++ = ' '; else *p++ = tolower((unsigned char)c); } } else for (; *bits > 32; bits++) ; } } return (r); } int main(void) { printf("%s\n", printb_flags((1 << 0) | (1 << 3) | (1 << 30), SRVFLAG_BITS)); return 0; } Below’s a commented version of the previous excerpt; I encourage you to think about it on your own though.

On exceptions in Go

Sun, 22 Sep 2024 00:00:00 +0000

Gouache study for a kids’ course by M. Bivert through instagram.com Error handling in Go is typically performed by returning an additional error value. The pros/cons of it has been largely debated: essentially, it’s more verbose that what we could have had, but it’s dumb, simple, and tend to encourage a thorough handling of error cases. By comparison, a crucial drawback of a major alternative to this approach – exceptions – is that they’re essentially a non-local goto: in practice, they tend to hide where/when an error can occur, require a smart IDE to understand which functions in a try{} block can throw() what; lazy programmers’s Gotta Catch ‘Em All!

On a 𝕏-like service part. 1: user handling (Django tutorial)

Thu, 22 Aug 2024 00:00:00 +0000

(WIP) We propose a step-by-step implementation of a 𝕏-like service, with a specification essentially based on CS50’s Project 4’s. We’ll focus in this article on custom user handling. As for the previous project, the code is available on github. Setting up # Create a directory and get in % mkdir django-network % cd django-network # I'd recommend to version things with git(1). You can version # things after every exercices for example.

On a paste service (Django tutorial)

Tue, 13 Aug 2024 00:00:00 +0000

The Django tutorial is a great first resource to get a feel for how Django works. However, Django being rather sophisticated, I think it’s best to repeat some of those steps a few times in slightly different settings to help internalize the knowledge. We build here on said tutorial: for the most part, we repeat very similar steps, encouraging the reader to use his memory over googling around, and also progressively incorporate bits that haven’t been explored in the tutorial.

On "pure" refactoring

Thu, 01 Aug 2024 00:00:00 +0000

I’m confident there’s nothing new here, but I’ve never saw this approach being linked to (functional) purity, as in, side-effects free. Let’s say that you have a piece of code to be refactored. What we’ll do is implement, aside of the current implementation, the new implementation. Saying it otherwise, the old implementation won’t be removed until the refactoring is complete, and guaranteed to be correct. A pleasant addition to this is to have extra layer of indirection(s), allowing to isolate both implementations, and eventually select either one via a configuration flag.

On writing OpenBSD services (e.g. for chrooted Go servers)

Mon, 29 Jul 2024 00:00:00 +0000

Introduction Services are sh(1) scripts, installed in the /etc/rc.d/ directory. Enabled services are executable (chmod +x /etc/rc.d/$service); disabled services aren’t. rc.subr(8) clarifies what such a service is supposed to be doing: Every script under /etc/rc.d follows this pattern: Define the daemon variable. Define service-specific defaults for one or more daemon_* variables (optional). Source rc.subr, which defines default shell functions and variable values. Override the pexp variable or any of the rc_* functions and set the rc_bg or rc_reload variables, if needed.

On doing OOP with Scheme

Mon, 22 Jul 2024 00:00:00 +0000

I struggled to find something similar last time I googled around, and had to unearthed this from a venerable, fragile hard drive (school project, 10/15 years ago). It doesn’t compile (racket) anymore as-is (something something “unholly macros usage”). I’ll eventually clean it up one day, but in the mean time, if it may help or be of curiosity to anyone. Pygmalion adoring his statue, 1717, oil on canvas by Jean Raoux through wikimedia.

On denotational, operational and axiomatic semantics

Sun, 14 Jul 2024 00:00:00 +0000

Bethsabée, 1889. Oil on canvas, 60.5×100 cm (23.8×39.3 in). Louvre, Paris by Jean-Léon Gérôme through wikimedia.org – Public domain The notion of the syntax of a programming language is usually well-understood: it’s essentially the grammar, the rules for writing “correct” sentences within this language. Amusingly, the way people usually describe semantics is much less clear, for example: In programming language theory, semantics is the rigorous mathematical study of the meaning of programming languages.

On cars vs. trains & public transports: Ford, GM's influence

Thu, 27 Jun 2024 00:00:00 +0000

A short note, mainly quoting a few references for those who ever wondered about why cars are so prominent, and why public transports or trains aren’t better developed. Think of the amount of needless: deaths by accidents; direct and indirect pollution, and related health hazards; waste caused by “forced” car updates every few years or so; systematic noise pollution in every city; oil related conflicts; space and soil wasted for roads/motorways/parking; time spent driving; etc.

On some tips for oil painting

Sun, 14 Apr 2024 00:00:00 +0000

Introduction Note: This is a WIP; I’ll slowly add to this article over time, and probably restructure it later once I’ve got most of it down. Painting is complex enough of an activity to require a precise adjustment of many bolts and nuts to systematically achieve a predictable result. I’ll try to document here a few things pertaining to oil painting that I’ve learned over the years. You may also be interested in this series about watercolor material.

On composition: Leonardo's Virgin of the rocks

Wed, 17 Jan 2024 00:00:00 +0000

This has been generated from $\LaTeX$ by Pandoc; the corresponding pdf file looks better. A key observation Consider first where Jesus, the bottom right child, is looking at: At first sight, one may think that he’s looking at John the Baptist (the second child). But upon closer investigation, paying attention in particular to Jesus’s chest and eyes, we can see that he’s looking beyond. More precisely, he’s looking in the direction of the Source of Light – an obvious metaphor for God in a Christian setting – which can be estimated from the position of highlights and shadow patterns.

On the multi-dimensional chain-rule

Sun, 10 Sep 2023 00:00:00 +0000

Note: This article has been generated from a $\LaTeX$ file by Pandoc; some things are/may be broken. The .pdf is available.

On piping a Go text/template to/from a shell command

Mon, 14 Aug 2023 00:00:00 +0000

This article shows how to send the content of a Go template to the stdin of an arbitrary command, and capture its output. To make things clearer, consider the following example: assume you’ve installed pygmentize(1), the command line interface for the famous Pygments syntax highlighter, and want to use it to highlight a chunk of code, say, in the context of a static site generator. The idea is to first define a template containing the code to highlight: {{- define "the-code-to-highlight" -}} #include <stdio.

On a pool of Go text/template

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

The goal here is to see how: to load a first batch of templates from a toolbox/ directory, and how to use them while iterating on a second set of templates. As a syntactical refinement, we’ll see how to call the first batch of templates from the second one as functions. Meaning, if you have a template toolbox/tool.tmpl, we’ll see how to use it from the second set of templates as: {{ tool arg0 arg1 }}

On Parseval's theorem (proof)

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

PDF: schuller-QM18-parseval.pdf. Commented proof for Parseval’s theorem, used in F. Schuller - QM18 - Fourier Operator1. Note that this theorem seems to also be referred to as Plancherel identity/theorem, for example in Teschl. Definition 1. The Fourier operator is the linear map $\mathcal{F} : S(\mathbb{R}^d) \rightarrow S(\mathbb{R}^d)$ defined for $x\in\mathbb{R}^d$ by: \[\boxed{( \mathcal{F}(f))(x) := \frac1{(2\pi)^{d/2}}\int_{\mathbb{R}^d} \exp{(-ixy)}f(y)d^dy }\] Theorem 1. $\mathcal{F} : S(\mathbb{R}^d) \rightarrow S(\mathbb{R}^d)$ is invertible and: \[\boxed{ (\mathcal{F}^{-1}(g))(x) = \frac1{(2\pi)^{d/2}}\int_{\mathbb{R}^d} \exp{(ipx)}g(p)d^dp }\]

On the inverse Fourier transform (proof)

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

PDF: schuller-QM18-fourier-inverse.pdf. Commented demonstration of the invertibility of the Fourier transform on Schwartz space. Reworked from: F. Schuller QM18 - Fourier Operator; Corresponding lectures notes (Simon Rea & Richie Dadhley) Definition 1. The Fourier operator is the linear map $\mathcal{F} : S(\mathbb{R}^d) \rightarrow S(\mathbb{R}^d)$ defined for $x\in\mathbb{R}^d$ by: \[\boxed{( \mathcal{F}(f))(x) := \frac1{(2\pi)^{d/2}}\int_{\mathbb{R}^d} \exp{(-ixy)}f(y)d^dy }\] Result 1. A well-known integration result, recalled in the lecture: \[\boxed{\int_{\mathbb{R}}\exp{(-\sigma x^2)}dx = \sqrt{\frac\pi\sigma}}\] Which generalizes to $\mathbb{R}^d$ to: \[\boxed{\int_{\mathbb{R}^d}\exp{(-\sigma x^2)}d^dx = \left(\frac\pi\sigma\right)^{d/2}}\]

On R's language: Introduction

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

Introduction This is a basic introduction to R, showcasing features and idiosyncrasies that I’ve needed/stumbled upon while automatize some matrix computations. For completeness, I’ve included the resulting script at the end. The Rainbow Valley Conservation Reserve, located about 75km south of Alice Springs in the Northern Territory of Australia, is known for its spectacular red sandstone bluffs. Panaroma shot of eight portrait format pictures, taken in the late afternoon by Christian Mehlführer through wikimedia.

On exporting complex matrices from R to LaTeX via xtable

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

The xtable (pdf) R package generates $\LaTeX$ code for tables, in particular for matrices. However, exporting a complex (as in $\mathbb{C}$) matrix fails (mind the boilerplate, which strips the default, full-blown table display): library("xtable") sigma_y <- matrix(c(0, 1i, -1i, 0), 2, 2) m <- xtable( sigma_y, align=rep("",ncol(sigma_y)+1)) digits(m) <- xdigits(m) print(m, floating = FALSE, tabular.environment = "pmatrix", hline.after=NULL, include.rownames=FALSE, include.colnames=FALSE ) Error in x < 0 : invalid comparison with complex values Calls: print -> print.

On the best (figure) drawing course

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

Despite the popularity of the question, a honest answer must be disappointing: there’s no such thing. Some options will be generally better than others, but you’ll generally want to balance multiple sources of knowledge. That’s where having an experienced teacher, or following a well-established curriculum can help. Young man carying an old man on his back, sanguine on paper, 1514 by Raphael (Raffaello Sanzio) through artsandculture.google.com wikimedia.org – Public domain

On the (real) spectral theorem

Wed, 05 Apr 2023 00:00:00 +0000

What follows is a partial proof of the (real) spectral theorem, as a complement of the first exercise, third lesson, of Leonard Susskind’s The Theoretical Minimum: Quantum Mechanics book.

If you’re interested in solutions to other exercises, you may want to head here.

Note: This article has been generated from .tex files by Pandoc. Pandoc works reasonably well, but tackles a sophisticated problem, full of corner cases; I’ve tried to fix a few issues, but for instance, references to labels are broken. If that really bothers you, you can still read the .pdf.

Note: In a near future, this should be included in a series of notes on linear algebra, covering all the sufficient background (matrix representation, inverses, diagonalization, all in finite dimension).

On using YouTube's API with Go

Mon, 03 Apr 2023 00:00:00 +0000

YouTube’s UI is a bit limited when it comes to exploring the content of rich channels (e.g. MIT OpenCourseWare, which has over 7k videos): in such cases, text tables with playlists / available videos are much easier and lighter to inspect, with a bare text editor or Unix CLI tools. This is the kind of simple use of the API that I’ll present here, but it should get you started for more sophisticated use cases.

On pencils for Bargue's drawing course

Wed, 29 Mar 2023 00:00:00 +0000

Native graphite from Chardonnet in Haute-Savoie, France, given by Mr Gaultier of Chambéry. Gallery of Mineralogy of the Muséum National d’Histoire Naturelle in Paris. by Jastrom (Marie-Lan Nguyen) through wikimedia.org – CC-BY-SA-4.0 Following on paper recommendations for Bargue’s course, here’s a follow-up on pencils & cie. You may also enjoy the following series: On Bargue's drawing course: introduction (1/3) On Bargue's drawing course: a holistic teaching (2/3) On Bargue's drawing course: going further, drawing 'gong-fu' (3/3) Short answer: Bargue plates are often copied religiously rigorously, and they most often present a smooth rendering.

On Frameworkless JavaScript

Wed, 15 Mar 2023 00:00:00 +0000

Introduction I’ve recently been reworking zhongmu’s UI, which so far managed not to use any framework. But, some aspects of the code were a bit clumsy, so I decided to see if I couldn’t use a variant of a previous framework I wrote to make it nicer. It did bring some improvements, but there were still a few subtle bits. It turns out, after reading a few React tutorials, that there’s an even simpler way to write non-trivial UIs without relying on any framework:

On tagging files simply

Fri, 10 Feb 2023 00:00:00 +0000

2018, Toulouse, France by M. Bivert – CC-BY-SA-4.0 It’s common to need to organize large filesets (pictures, papers, etc.). There are specialized programs, but they can get hairy quickly, and simple prototypes are easy to think of, e.g.: have a special directory containing one subdirectory per tag, and use ln(1) to tag files, by storing links under such directories. There are a few drawbacks, for example: Not resilient to file renaming (or requires at least to duplicate files); Some queries (e.

On Plan9's Acme: events management, shortcuts

Tue, 31 Jan 2023 00:00:00 +0000

Introduction One can poll various acme(1) events via its 9P file system, documented in acme(4). For some general ideas about acme(1), see this article; for some extra tools, see this article. Regarding events, some aspects are unclear from the man pages, hence this little article. There are two sources of events, that we’ll explore in the following two sections. A third section demonstrates with an example how to use events to implement shortcuts.

On Heraeus's Winter School missing tutorials/PDFs (Gravity and Light)

Wed, 21 Dec 2022 00:00:00 +0000

Introduction In 2015, a course (International Winter School on Gravity and Light), on the mathematical foundations of general relativity (manifolds, differential geometry, etc.) was held by Frederic P. Schuller (and others) at the Johannes Kepler University, Linz, Austria, 2015. There are two main playlists on YouTube: Central lecture course; Tutorials. And, somewhat complementary, some unofficial notes (.pdf) by Richie Dadhley. Finally, it seems that a considerable amount of time was dedicated to workshops (10h over two weeks, “where more advanced problems are solved in teams”, by comparison with the tutorials, 12h, “to practice the basics”), but unfortunately, nothing has been found pertaining to their content1.

On Plan9's Acme

Wed, 21 Dec 2022 00:00:00 +0000

Tools shape one’s perceptions and thinking. Programming languages constitute a common example: consider for instance how regular iteration encourages a certain mindset, while recursion coupled with purity encourages different trains of thoughts.

What is true with languages remains true, for instance with text editors. And is maintained outside of the programming realm.

A side-effect is that, once we’re comfortable with a given way to achieve a certain result, it can be psychologically demanding to switch to another approach.

As an example, however great debuggers are, not having a debugger forces you to read code more carefully, and to think more. Perhaps then, it’s not much of a loss not to have a debugger in the long run (over decades). But that doesn’t mean debuggers should be absolutely avoided either.

In particular, acme(1) encourages a peculiar mindset, by comparison with mainstream editors. I’ll try in this article to explore this difference, while highlighting a similar dichotomy in woodworking.

On Nix's language: Lambda calculus interpreter

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

This is the last article of this series. It’ll be a bit different than the previous ones: most of it will be about a step-by-step implementation of a λ-calculus interpreter (I’ll give you some starting points, in case you want to do it on your own).

We’ve already brushed upon the λ-calculus in the third article of this series on closures: Church encoding of booleans/integers/lists originates in the λ-calculus, where the only computation mean available precisely are functions/closures.

As a final conclusion, I’ll give you a few suggestions of code to read, and ideas to help you push your skills further, in continuation to what has been developed in those articles.

The code for this series remains available on github.

On Nix's language: Mathematical expressions, Brainf*ck

Thu, 08 Dec 2022 00:00:00 +0000

A great thing about Nix (the language) is that it’s tiny. Tiny enough that besides some builtins and a few NixOS/Nixpkgs centered features (e.g. paths), we’ve covered, for most intent and purposes, all of it.

The next article will be about writing a λ-calculus interpreter. In preparation, we’ll focus here on implementing three small projects:

A prefix/polish expression evaluator (e.g. something that reads a string like + + 3 * 5 + 2 2 19, and interprets it as 3+5*(2+2)+19=42);
A Brainf*ck evaluator (if you don’t know what it is, I guess an example wouldn’t help much);
A mathematical expression evaluator (e.g. something that reads and interprets 3+5*(2+2)+19);

The code for this series is still available on github.

On Nix's language: Pragmatism, laziness

Mon, 05 Dec 2022 00:00:00 +0000

Lately, we’ve been hanging around a rather theoretical corner of computer science. However interesting and insightful, that aspect must almost always be balanced. For instance, Church booleans/integers are, at least on modern ordinary hardware, impractical compared to fixed-size 32/64 bits integers.

Often in engineering, pragmatism is a decisive way to select between multiple options, an approach which often leads to simple(r/st) choices.

We’ll use some aspects of the design of Nix itself to exemplify this point. Our roadmap for this article will include some more details on laziness, as in lazy evaluation (and not as a variant of “pragmatism”), and genuine Nix lists/sets. Genuine in the sense, not some hand-implemented ones out of closures, but the ones provided by the language.

Again, the code for this series is available on github.

On Nix's language: Closures

Wed, 16 Nov 2022 00:00:00 +0000

We saw by the end of the previous article a first example of “closure”, which you can grossly think of as “function”. We’re going to progressively explore this notion in-depth here: we’ll see in particular how they can be used to encode all kinds of data structures: lists, integers, booleans, objects, graphs, etc.

Some tiny programming languages like the λ-calculus, of which we’ll implement an interpreter to conclude this series, is essentially reduced to closures: this minimalism is convenient for theoretical/mathematical analysis, or for programming practice. But it’s naturally ill-suited for real-life programming.

Besides, we’ll also re-implement many ordinary functions on lists, using an ad hoc, closure-based list implementation, instead of genuine Nix’s lists, genuine lists that we’ll explore soon enough.

As always, the code for this series is available on github.

On Nix's language: Recursive functions

Mon, 07 Nov 2022 00:00:00 +0000

We’ve previously explored how to run Nix code, and basic Nix features: variables, conditions, “print/debug” “statement”, etc. But, we still haven’t saw anything analogue to loops, providing us with iteration. This, will be our subject for today, and will allow us to start writing something more substantial than a hello world.

I assume little to no experience in functional programming from the reader; I however assume familiarity with programming.

Note: I won’t bother with performances in general in this series: the focus is on correctness (well, hopefully…), and on developing an understanding of functional programming. But why can’t I still care about performances, and why do people often treat them as second-class citizens? I think there are two main reasons. In tutorials, focusing on performances adds noise, thus making the transmission of core concepts more difficult. Furthermore, in real life, they are to be treated cautiously:

optimizations have a cost: they can make the code more subtle, more complex, more difficult to write and maintain;
intuition can be wrong: you may think some function is slow and spend considerable time fixing it, but proper instrumentation/measurements may reveal unexpected bottlenecks.

Systematically improving performances locally, without proper instrumentation, is a great way to degrade the quality of a codebase.

Parenthesis aside, the code for this series is available on github.

On Plotting Complex Curves Transformations (Gnuplot, PGF/TikZ, PGFPlots)

Fri, 04 Nov 2022 00:00:00 +0000

Typical early examples in Complex analysis involve plotting simple complex (as in $\mathbb{C}$) curves under (complex) transformations. This help gain intuition on otherwise rather opaque transformations; see for instance those two videos from Michael Penn’s Youtube channel: Plotting such curves, regardless of the software (Mathematica, Gnuplot, etc.) is performed in three steps: parametrize the curves; compute the transformation by applying it to the parametrization; isolate the real and imaginary parts of the last result.

On Nix's language: Introduction

Thu, 03 Nov 2022 00:00:00 +0000

NixOS is, to my surprise, an already 20+ years old Linux distribution (as of 2023), based on the Nix package manager, itself based on the Nix expression language, which will be the focus of this article and this series (I won’t talk about NixOS, nor about the Nix package manager, neither about how to use Nix’s language to interact with Nix package manager).

Nix’s language is:

functional: essentially, λ-calculus based;
lazy: expressions’s evaluation is delayed as much as possible;
dynamically typed: typing is performed during evaluation, not at compilation (i.e. not statically);
pure: in the modern, practical sense, we can still do I/O for instance;
minimal: the language has been designed for a peculiar/narrow purpose; its feature set is limited, and it isn’t the most sensible choice for general purpose computing.

It “feels” either like a lazy Scheme (tuples, dynamic typing), or a stripped-down Haskell (laziness, not a S-expression based syntax).

The goal of the current article is to introduce elementary technical elements:

Installation;
Running code;
Major language features (variables, functions, conditions, etc.).

We’ll later use this knowledge to explore recursive functions in the next two articles, and show how much we can achieve with mere recursive functions. We’ll then shift our focus on Nix’s lists & sets, before concluding with two project-based articles, the last one being about implementing a simple λ-calculus interpreter, which is the main goal of this series.

All the code is available on github.

Note: Thanks Pete Dietl for the various suggestions!

On httpd(8) logs parsing on OpenBSD

Thu, 27 Oct 2022 00:00:00 +0000

I’ve “recently” wrote a few tools (github) to help parsing logs on OpenBSD, mainly httpd(8) logs; this can for instance be used to provide basic, JS-free analytics.

From there, parsing other logs, or doing other kind of analysis isn’t much more complicated either. The code could be refined and extended in many ways, but so far, it covers all my needs, so I’ve got little incentive to push it further.

On papers for Bargue's drawing course

Wed, 19 Oct 2022 00:00:00 +0000

An accurate answer would depend on the medium you’re using (graphite, charcoal, etc.), whether you want to use tinted paper, have control over the tint, on your personal preferences, on what’s available to you (e.g. price, physical availability), etc. That being said, for graphite1, I guess the best option would be 100% cotton, white, hot pressed (smooth) watercolor paper (e.g. by Arches or Fabriano): stretchable: if thick enough (≥300gsm; some artists prefer to work on stretched paper); tintable: using lightfast watercolors paints (have a look at this page and handprint.

On watercolor material: Palettes, easel

Mon, 17 Oct 2022 00:00:00 +0000

On watercolor material: Paper

Mon, 17 Oct 2022 00:00:00 +0000

On watercolor material: Pigments

Mon, 17 Oct 2022 00:00:00 +0000

On watercolor material: Tubes, pans, paint grades

Mon, 17 Oct 2022 00:00:00 +0000

On using Google's Search Console API with Go

Wed, 14 Sep 2022 00:00:00 +0000

Google’s Search Console API provides statistics regarding how users interact with your websites via Google search (keywords, impressions, clicks, etc.)

While Google provides a Web Console, it can be convenient to programmatically access the API, for instance to be forwarded analytics in a daily/weekly/monthly email. The article:

Introduces the necessary boilerplate to use the Search API (create a project, a specific user, a key for that user, how to allow that user to access stats for a given site);
Presents how to use the official Go wrapper to
- list domains;
- access statistics for the most recent day for which there is analytics data;
- and perform a bit of server-side filtering to look for the Google search queries matching a given page.

search-console is a small tool, wrapping the Go code presented in this article.

On figure drawing: mannequin handling

Fri, 09 Sep 2022 00:00:00 +0000

Maybe you’ve been studying simplified anatomy/mannequinization, got yourself a virtual 3D model, bought a old school wooden mannequin, or a fancier one, perhaps convinced by some great, dynamic pictures. Basic wooden mannequin by Hannah Alkadi through wikimedia.org – Public domain Ink on toned paper, likely in preparation of a painting, mid 1500s by Luca Cambiaso (1527 – 1585) through drawingseeing.blogspot.com mountshang.blogspot.com – Public domain Lay figure made by Albrecht Dürer (1471-1528) c.

On solutions to the Theoretical minimum (classical/quantum mechanics)

Thu, 08 Sep 2022 00:00:00 +0000

The Theoretical Minimum is a book series by Leonard Susskind, and others, containing three books, with a fourth one to be published soon:

Classical Mechanics, with George Hrabovsky;
Quantum Mechanics, with Art Friedman;
Special Relativity and Classical Field Theory, with Art Friedman again;
General Relativity, with André Cabannes, who contributed to the French translation of the three previous works.

The books are relatively short (say, compared to Feynman’s lectures), self-contained (well, depending on how curious you are; they do go as far as to cover a great deal of mathematical background, but they just can’t be exhaustive either), and, at least for the Classical Mechanics one, aimed at presenting general theoretical formulations: the Lagrangian and Hamiltonian formalisms, based on the stationary-action principle and the principle of conservation of energy.

They all come with a few exercises, often rather simple, focused on making sure you understand the key concepts.

On the harmonic oscillator

Thu, 08 Sep 2022 00:00:00 +0000

What follows is an introduction to the harmonic oscillator, as a complement of the fourth exercise, third lesson, of Leonard Susskind’s The Theoretical Minimum: Classical Mechanics book.

If you’re interested in solutions to other exercises, you may want to head here.

On using OVH's API

Sun, 21 Aug 2022 00:00:00 +0000

OVH provides a HTTP(s) API to automatize various tasks. There are multiple official wrappers (Python, PHP, Java, etc.); I’ll use here the Go one (static typing, cross-compilation with a single static binary)

All the code presented below can be found in this github repository, containing a small CLI tool, ovh-do, that can be used to access the API from the CLI and sh(1) scripts.

Our end goal here is to automatically re-install the latest Debian image on an existing VPS, with a pre-installed ssh(1) key.

On art pricing

Sun, 14 Aug 2022 00:00:00 +0000

Nowadays, art pricing can be confusing, as the price of an artwork isn’t necessarily correlated to a certain skillset, effort or subject.

We put into perspective traditional and modern perceptions of art, and propose a few pricing criteria, that can be weight so as to capture both ancient and present mindsets.

On evaluating art

Sun, 14 Aug 2022 00:00:00 +0000

Relativity of art appreciation is nowadays common knowledge.

The same work will move different people in different manners, at a different intensity. Even the same work can move the same individual in various ways, depending on various factors (mood, education, observation time, etc.)

Yet, despite this intrinsic subjectiveness, there are objective ways to appreciate a work of art.

On master studies

Sun, 14 Aug 2022 00:00:00 +0000

Of the order of learning to draw

First draw from drawings by good masters done from works of art and from nature, and not from memory;
then from plastic work, with the guidance of the drawing done from it;
and then from good natural models and this you must put into practice.

– Leonardo Da Vinci, Notebooks, Vol. 1, IX. The Practice of Painting

Master study is the archetypal drawing exercise, East and West, where the student is expected to learn from a master by studying, often copying, his work.

This is similar to how classical musicians start their journey by learning the works of great composers (Mozart, Bach, etc.)

This article merely introduces the concept; for a more in-depth exploration, the series on Bargue’s drawing course provides a nice example:

On simple software: examples

Mon, 08 Aug 2022 00:00:00 +0000

When in doubt, use brute force.
One of my most productive days was throwing away 1000 lines of code.

– Both quotes by Ken Thompson (UTF-8, Plan9, grep(1), Golang, etc.)

On OpenBSD's sendmail(8) and gmail

Tue, 26 Jul 2022 00:00:00 +0000

The following explores the configuration of an OpenBSD base install to send emails from the CLI (mail(1), sendmail(8), etc.), relaying them to an existing Gmail account. We’re not touching upon reading emails here; we’ll present some tools to help with attachments.

Essential bits of smtpd(8) configuration to achieve email relaying are actually the first example setup from smtpd.conf(5):

EXAMPLES
     The default smtpd.conf file which ships with OpenBSD listens on the
     loopback network interface (lo0) and allows for mail from users and
     daemons on the local machine, as well as permitting email to remote
     servers.  Some more complex configurations are given below.

     This first example is similar to the default configuration, but all
     outgoing mail is forwarded to a remote SMTP server.  A secrets file is
     needed to specify a username and password:

           # touch /etc/mail/secrets
           # chmod 640 /etc/mail/secrets
           # chown root:_smtpd /etc/mail/secrets
           # echo "bob username:password" > /etc/mail/secrets

     smtpd.conf would look like this:

           table aliases file:/etc/mail/aliases
           table secrets file:/etc/mail/secrets

           listen on lo0

           action "local_mail" mbox alias <aliases>
           action "outbound" relay host smtp+tls://bob@smtp.example.com \
                   auth <secrets>

           match from local for local action "local_mail"
           match from local for any action "outbound"

On simple software: unimpressiveness

Sat, 23 Jul 2022 00:00:00 +0000

This is perhaps one key characteristic of simple software. It’s humble, doesn’t look like much, its potential is not always easy to understand, nor is the underlying trade-offs balance.

The issue isn’t specific to software, but in fact arises in unrelated areas: simplicity tend to be overlooked, and to require a certain degree of mastery to be appreciated.

Simplicity is the ultimate sophistication.

– Leonardo Da Vinci

On a function-based test framework/pattern

Sat, 09 Jul 2022 00:00:00 +0000

Simplicity is the ultimate sophistication

– Leonardo Da Vinci

There’s plenty of tests frameworks out there, but I am often left disgruntled by their sheer amount of complexity, and by lack of uniformity of the tests/inability to programmatically manipulate them.

This article presents what is arguably the simplest test framework for function-based code: each test is basically about ensuring that applying a function on some input yields the expected output.

All tests have the exact same format, and can be stored in an array, and thus altered programmatically/systematically. Sophisticated cases (e.g. objects, side effects) can be managed by involving a few ad-hoc lambdas to alter the input/output so as to fit in this format.

In the end, it’s costless to:

implement;
audit;
add to an existing codebase, even alongside an already existing test framework;
migrate away from in the future (perhaps not costless, but definitely easier than your usual tests);

And, most importantly, makes it effortless to write batches of straightforward tests in almost any language. Its main requirement is for the implementation language to easily allow deep-comparison; in the worst cases, this can often be achieved by comparing JSON dumps, or more generally, text dumps.

On Let's Encrypt on OpenBSD

Wed, 01 Jun 2022 00:00:00 +0000

Let’s encrypt is a widely used, free TLS certificate provider. OpenBSD’s base system comes with everything needed to setup a basic secure web server, including:

httpd(8): a HTTP server;
relayd(8): a load-balancer, gateway, etc.;
acme-client(1): an ACME client, to manage TLS certificates.

This article will start by building a few simple sample setups. The goal being to make sure that the configuration is fully understood, and not something that happens to work “by accident”.

Then, we’ll quickly present how to fully automate the certificates renewal/acquisition with sugar(1), a small (~150LOC shell) remote server administration tool. Code for the final automated setup is available here.

Note: This article is most suitable for people with limited experience with OpenBSD. For a more succinct approach, see this blog post by Roman Zolotarev.

On figure drawing: gesture

Sun, 29 May 2022 00:00:00 +0000

In the previous article, we’ve already skimmed over “gesture” and its confusing, loose definitions, such as “the flow of the form”. Some authors have even more peculiar use of the term, and will happily call a bunch of hasty scribbles “gesture”, while others will talk about “gesture” within a landscape.

We’ll dissolve the confusion progressively, by actually studying how can gesture, as a tool, be of use for a draftsman.

That being said, to help make things clear, from a practical point of view, one can think of gesture as composition lines, generally applied to the human figure.

On figure drawing

Wed, 11 May 2022 00:00:00 +0000

Historically, human figure depiction has always been a fundamental aspect of Western fine-art. The gracefulness of the poses, the subtle variations of volumes, induced by a complex underlying anatomy, often geometrically simplified, the diversity of complexions, our high-sensibility to its visual correctness, its semantical role in artworks, all contribute to making it a key part of a painter’s education.

As for watercolors or drawing courses, a contemporary issue isn’t the scarcity of instruction, as it once was, but rather its abundance, potentially confusing for (self-taught) students.

As such, the goal of this series, rather than to contribute to the noise, is to provide a map, to help navigate the existing material.

On sugar, a sweeter Salt: Annexes

Sun, 20 Mar 2022 00:00:00 +0000

The complete code is available on github; the OpenBSD setup scripts, hooks, templates & all are available in a distinct repository. We include below a few excerpts to give an idea on how some features actually are implemented.

On sugar, a sweeter Salt: documentation

Sun, 20 Mar 2022 00:00:00 +0000

Before diving into example usage, reader may find below an excerpt from the documentation and from the code, to help fix ideas.

On sugar, a sweeter Salt: multiple systems

Sun, 20 Mar 2022 00:00:00 +0000

We add a bit of complexity to the previous setup, by sharing code & data between multiple OpenBSD boxes, and exploring one way of writing sh(1) OS-agnostic code for sugar(1), using a well-known “ducktyping” method.

On sugar, a sweeter Salt: one OpenBSD box

Sun, 20 Mar 2022 00:00:00 +0000

Update: While this article focuses on bringing up an OpenBSD box with a configured pf(8) and sshd(8), the underlying code has been updated to support SSL/TLS via Let’s Encrypt, and thus also manage httpd(8) and relayd(8).

This is the main article of the series, explaining how to automatize a typical OpenBSD box setup via sugar(1), focusing on basic services (httpd(8), pf(8) and sshd(8)). By the end of this article, a complete, idempotent setup of the box can be performed by a single command (think, salt’s highstate):

(local)% sugar -s $name setup
hook-pre-setup-pf                       : Preparing pf.conf for sync...
hook-pre-setup-pf                       : Ensure we have a backup ssh link...
hook-pre-setup-sshd                     : Preparing sshd_config for sync...
hook-pre-setup-sshd                     : Ensure we have a backup ssh link...
setup-pf                                : Asserting pf is enabled...
setup-pf                                : Installing pf.conf...
setup-pf                                : Checking pf.conf syntax...
setup-pf                                : Loading pf with new pf.conf...
setup-sshd                              : Asserting sshd is enabled...
setup-sshd                              : Installing /etc/ssh/sshd_config...
setup-sshd                              : Checking sshd_config...
setup-sshd                              : Restarting sshd
hook-post-setup-pf                      : Ensuring port 22 is closed from outside...
hook-post-setup-pf                      : Ensuring ssh port is opened from outside...
hook-post-setup-pf                      : Close backup ssh link...
OK

On Bargue's drawing course: a holistic teaching

Mon, 14 Mar 2022 00:00:00 +0000

In the West, over the course of a few centuries, people have progressively rationalized, studied and decomposed the act of drawing as a collection of primitive skills. Learning to draw is then a matter of mastering such sub-skills individually, and understand how they interact with each other.

For instance, reproducing what you see could be one skill, composing an other, and by combining the two, you could alter your visual perception to answer specific æsthetical criteria, which is a key aspect of realism, and a reason why realism differs from photography: the greatest paintings are better than life.

Among the Sierra Nevada, California, oil on canvas, 1868 by Albert Bierstadt through wikimedia.org – Public domain

Regarding Bargue’s course, many of those sub-skills are silently taught, entangled with each other. It’s interesting to note that, some of the skills may become more or less developed, more or less consciously, depending on the student’s curiosity and critical thinking. A good teacher should be able to perceive students’ issues on specific sub-skills, and to help them to train more efficiently.

On Bargue's drawing course: going further, drawing 'gong-fu'

Mon, 14 Mar 2022 00:00:00 +0000

For students willing to go the extra-mile, the following exercises can be used to foster one’s handling of material, and progressively develop the ability to draw from imagination. Bargue’s plates, because of their simplicity and diversity, make very good models for such technical drills.

On Bargue's drawing course: introduction

Mon, 14 Mar 2022 00:00:00 +0000

Charles Bargue (c. 1826 - 1883)’s drawing course is often used and recommended as a first stepping stone in modern realistic art education.

The course itself, created under the supervision of Jean-Léon Gérôme (1824 - 1904), consists of a series of wordless plates (lithographies), divided in 3 sections, which have recently been compiled into a book (pdf) by Gerald M. Ackerman (1928 - 2016), thereby augmenting the plates with some notes, recommendations and models’ pictures.

The upcoming articles are technical, written for self-taught students confused about Bargue plates, or willing to study them most efficiently. This first article introduces the course, and the most common way of studying the course.

On "same-size": a better sight-size for copying from the flat

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

Sight-size is a drawing method currently taught at some modern ateliers, where students are expected to reproduce what they perceive with great exactitude.

The method as a few advantages, such as easing comparisons between models and copies, useful for people with underdeveloped vision, but it shows some limitations early on, especially when working from living subjects. On the other hand, comparative measurements and constructed approaches are often much more flexible, but perhaps less suitable for replicating things with perfect accuracy.

As far as copying from the flat is concerned, that is, copying existing drawings, which is and has always been a core element in students education, we suggest to use what we could call a same-size approach, which is basically about using non-sight-size technique with a sight-size-like setting, and which in essence, is very similar to what was used traditionally since the Renaissance.

This article aims at being useful to self-taught students, especially those confused about whether to use sight-size or not.

On the academic block-in as an optimized grid system

Sat, 26 Feb 2022 00:00:00 +0000

We argue that what we call the “academic block-in”, which mainly consists in indicating the main volumes of a subject on a sheet of paper, through a set of lines, often mostly straight nowadays, is actually a refined grid system, that may sacrifice a bit in accuracy to greatly improve fluidity and speed, thus making the drawing process more enjoyable.

This point of view may help people overusing grid systems; this article assumes the reader has at least some experience with drawing.

On sugar, a sweeter Salt/Chef/Ansible/Puppet

Sat, 19 Feb 2022 00:00:00 +0000

sugar(1) is a simple remote servers management tool, written in POSIX sh(1), slightly more complex/complete than drist or apply, still much simpler than slack.

And, as it aims to solve a different problem space, orders of magnitude simpler than Ansible, Salt, Chef, Puppet, etc..

Its main purpose is to provide a thin layer of abstraction, just thick enough to automate typical UNIX servers manual administration.

On OpenBSD automatic installation an OVH's VPS

Fri, 11 Feb 2022 00:00:00 +0000

Update: I’ve just learnt that OVH provides a rescue mode for its VPSs, from which we can boot a qemu(1) instance, configured to use the VPS’s disk as a drive. From there, we should be able to leverage qemu(1) abilities (for instance, its tftp server) to avoid tweaking the bsd.rd through an existing OpenBSD instance, which definitely is the sore point of the procedure below. Unfortunately, it seems rebooting the VPS in rescue mode can’t be performed from the API (yet?).

OVH does not provide a default OpenBSD image for its VPSs, nor, AFAIK, does it provide the ability to use one own image (e.g. qcow2) for VPSs, while the feature is available for other services.

However, OVH does provide an API allowing to automatize default images (re)installation, including setting up SSH’s authorized keys. Besides, OpenBSD can be manually installed on such VPSs; autoinstall(8) provides a way to automate the installation process.

On watercolor painting tutorials

Fri, 04 Feb 2022 00:00:00 +0000

In order to complete the article on watercolor material, we provide here links to some watercolor painting YouTube video tutorials, by established artists/instructors.

There is an abundance of literature and video courses covering this topic, to the point that having a few cherry-picked courses might be helpful for beginners.

Were you to want to dig deeper, most of the artists quoted here provide more complete materials, books of video tutorials, usually on their website.

On drawing and computer science

Thu, 03 Feb 2022 00:00:00 +0000

From the outside, drawing/painting and computer science may look irreconcilably different. Yet, many aspects of both fields can be drawn together: put into mathematical language, we can establish some sort of morphism between the two fields (I wonder how rigorously such a connection can be made).

Note the informality of the mapping: the goal is, by squinting a little, to help artists and computer scientists to navigate the theoretical aspects of an unknown field through familiar notions.

Note also that we will use “drawing” and “painting” interchangeably. Finally, we will mostly focus on fine-art, to be defined as a technically involved realistic depiction. Most of what we’re expressing would also be valid for abstract or naive forms of visual arts, but the situation, although fascinating, is too complicated to be explored here.

On drawing and computer science: a shape based painting process, axioms and Turing machines

Thu, 03 Feb 2022 00:00:00 +0000

In the old days, the painting process was often unrefined Cennino Cennini’s Il libro dell’arte is an example of accumulation of techniques aiming at specific subjects’ depiction. Those processes have progressively been abstracted and some some elements of science, such as its understanding of light, have been assimilated.

To the point that nowadays, we can take a shortcut and talk about an axiomatisation of the painting process: there are small sets of rules, axioms, that can be combined at will to help create a wide variety of artwork. This is even closer to be true for digital art.

On watercolor material: Introduction

Mon, 31 Jan 2022 00:00:00 +0000

This series is an introduction to watercolor material, with some practical advices on how to use watercolors. This is not an introduction watercolor painting: if that’s what you’re looking for, this article is a selection of YouTube (free video) tutorials and demonstrations, by established artists, that better serves such a purpose.

I try to condense here a few years of experimentation with the medium. Despite being rather extensive, it’s still far from exhaustive; one can refer to Bruce MacEvoy’s website (handprint.com) for a far more complete, encyclopedic exposé.

This first article quickly introduces the medium and distinguishes it from its closest peers (gouache and tempera).

About

Wed, 27 Oct 2021 00:00:00 +0000

On some tools for Plan9's acme

Wed, 18 Aug 2021 00:00:00 +0000

Acme is a text editor/IDE developed by Rob Pike (Go, UTF-8, Sam, etc.) for the Plan9 operating system; the editor is available via e.g. Plan 9 from User Space on UNIX.

In comparison to other modern editors, it is characterized by a restricted features set. The editor is succinctly presented, followed by a quick presentation of some scripts aiming at improving acme(1)’ usability/programmability.

On composition study: Videos thumbnails

Tue, 03 Aug 2021 00:00:00 +0000

Video thumbnails for YouTube, Dailymotion, PeerTube, etc. give personality to the content, and imprint durable first impressions, as would a person’s appearance.

As such, it’s only natural to cautiously design them.

Not only is this a great subject to apply and expand our knowledge of composition, beyond fine-art, but also to understand how subtle design decisions can (un)consciously affect ourselves/others, thus, a good starting point in advertisement study.

On composition

Thu, 29 Jul 2021 00:00:00 +0000

Composition is the key to a pleasant painting; proper lighting ennobles to the eyes even the most modest subjects. The study of composition is a way to understand why something is, or isn’t, beautiful.

In essence, the rules of composition reflect either the inner-working of human vision and/or archetypal natural structures, like our eyes being attracted to strong contrasts, repetition of similar shapes in vegetation, or the common grouping/alternation between warm (orange-ish) and cool (blue-ish) colors.

On Chinese language

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

Visually, Chinese language clearly exposes what somehow corresponds to Western’s languages Greek/Latin etymology, and which is, to most westerners, hidden by languages’ evolutions.

We propose here to clarify this point through to study of a few Chinese characters. There doesn’t seem to be a consensus regarding how to interpret characters, but regardless, such studies still have values as mnemonic.

I encourage the reader to extend such analyses as he sees fit.

On composition study: Empty Space in Chinese paintings

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

Lots of Chinese paintings contain a great deal of empty space, emanating a certain calm, tranquility, serenity.

This peculiar æsthetical choice could at least be unconsciously rooted in a fundamental Eastern philosophical concept: emptiness

On composition study: Zhang Lu - Laozi Riding an Ox

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

A composition exegesis proposal based on Chinese language, allowed by a broadness of interpretation rooted in the simplicity of the notions involved.

On simple software: the benefits of complex software

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

Experienced programmers tend to appreciate simplicity for its numerous blessings:

less code;
less potential bugs;
generally less cognitive effort to read, write, understand, maintain, augment the code;
etc.

Such benefits growing virtuously over time.

Nevertheless, human nature at work, those local benefits don’t necessarily scale as virtuously.