Sometimes there’s just too many words and I want to look at visualizations and graphics. A collection of links.

The Information is Beautiful Awards are a good place to start. Entry Showcase. 2017 winners. 2018 winners.

Bloomberg Graphics is a nice collection. Or follow @BBGVisualData.

The Economist Graphic detail is a nice collection.

The Financial Times Graphics is a nice collection.

The Wall Street Journal Graphics is a nice collection . Or follow @wsjgraphics. 2017 Year in Graphics. 2018 Year in Graphics.

The Chicago Sun-Times Graphics collection doesn’t see many updates.

The Los Angeles Times Graphics collection doesn’t see many updates.

The Chicago Tribune doesn’t seem to have a dedicated page. Or follow @ChiTribGraphics.

The New York Times has a multimedia section, but it’s still photos. Or follow @nytgraphics. 2017 Year in Graphics. (2018?)

The Washington Post also seems to lack a dedicated page. Or follow @PostGraphics. 2017 Year in Graphics. 2018 Best Graphics.

Depending on whether it is day or night, I prefer a light screen or a dark screen. I would like switching between these two modes of operation to be quick and easy. Easy in this case means I am willing to run a command, but not ctrl-click on 21 different xterms.

more...

Some thoughts on cowboys vs conservatorships after reading De-facto closed source: the case for understandable software. I can’t say I disagree with anything there. Software is too complicated and should be simpler. There is, however, an angle which wasn’t examined. Or at least an alternative that wasn’t fully explored, which is to trust authors in a way which works.

The original problem (or one of them) is the result of a fiercely independent code slinging cowboy distribution model. You write some code, toss it on the tubes, people use it, and then... you move on and hand your star over to somebody else. The de jure maintainer has changed. There’s no continuity.

Another model is to place the code in a conservatorship. Like a curated list of awesome, except actually curated. When the original author steps away, nothing changes. The de jure maintainer is the same. Continuity.

There are many examples of such conservatorships, although we rarely use the term. We might consider the OpenBSD project. Some time ago, Sylvestre wrote and contributed a fuse implementation. Then life moves on, as it does, and so did he, leaving the code without a direct maintainer. But OpenBSD didn’t just hand the code over to somebody else. It’s still ours, even if we could be doing a better job improving it. To be completely honest, although it gets the occasional commit, it may be close to de facto unmaintained. The important fact, however, is that it’s de jure maintained. Users of the fuse code can trust that it won’t get randocoined.

This isn’t an all or nothing proposition. Handing over maintenance doesn’t require assigning copyright. The code is still open, it can be forked out of the conservatorship at any time. And in exchange, there are other people to help fix bugs and answer questions when you go on vacation. You’re not trapped working on a project you’ve lost interest in out of a sense of duty because there’s a succession plan.

See also: Towards a more collaborative OSS model.

My ERL melted itself. Again. Time for a replacement. I went with a Protectli FW4A. It’s a small industrial enclosure, fanless, with four ethernet ports.

more...

Contrary to popular belief, C does have types. It even has type qualifiers. Unfortunately, the selection is somewhat limited and there are several implicit conversions that may lead to less than robust code. The good news is that with a little effort we can define our own types and enforce our own rules. I’ve forgotten where I first saw this, and don’t really have a good name for it.

more...

You have a blog. You write stuff. This is all good.

But it’s a technical blog. And so you write articles that include code or URLs or auth tokens or hex coded hashes or other horrors like AbstractImplementationOfBorrowCheckerFactoryPatternMatcher which results in words of unusual size. And this being important technical content, it’s styled as whitespace preserving per the fashion of our times.

This is problematic on narrower screens because those great big long words completely blow out your page width, with the resulting effect that the main content is a tiny sliver running down the side of the screen. You’ve gone to the trouble of picking a responsive layout because you want to be mobile friendly, but your selected styles respond to such content rather poorly.

There is an easy fix. Or two.

The CSS white-space property has a value called pre-wrap which in many cases is probably better than plain pre. Long code lines will wrap, so it doesn’t really look like code anymore, but hey, I’m reading this on a phone, not compiling it.

The CSS overflow-wrap property (previously word-wrap) has a value called break-word which will split up not just lines, but long words too.

There are other possible values as well, to suit your preference, but I’d be willing to bet most people (or their readers) would be happier with values other than the ones they are using (probably the defaults). Sacrificing a small amount of technical fidelity can greatly improve the readability of the prose, and with no negative effect on desktop viewers.

Zeno scrolling requires javascript.

Everybody loves infinite scrolling.

Which is to say everybody hates it, but we love to use it anyway.

There’s just one problem. Infinite scrolling requires infinite data.

What if we don’t have that much content? Or what if we are old school enough to still care about bandwidth?

I have just the thing. Zeno scrolling. Infinite scrolling with finite data.

You read half the content. You’re going to read the second half of the content next.

But now the content is bigger. You scroll some more. The content gets bigger again.

In order to get to the second half you have to get past the first half.

It may be a little annoying to the user never reaching the end. But that’s no different than before, right?

On the plus side, as a site operator, I can make more economical use of my limited content.

Progress is an illusion.

There is no Zuul, only Zeno.

(Script is no longer inlined.)

var scroller = document.scrollingElement
var el = document.getElementsByClassName("post")[0]
var lh = 1
var fs = 2
var scrollit
function fixer() {
        var h = scroller.scrollHeight
        scroller.scrollTop = h * 0.4
        setTimeout(scrollit, 1000)
}
scrollit =  function() {
        var h = scroller.scrollHeight
        var t = scroller.scrollTop
        var p = t / h
        var r = scroller.scrollHeight / scroller.clientHeight
        var adjust = p > 0.5 || r < 2
        var withfix = p > 0.5
        if (adjust) {
                console.log("adjusting")
                fs *= 1.5
                el.style.fontSize = fs + "em"
                lh *= 1.5
                el.style.lineHeight = lh + "em"
        }
        if (withfix) {
                setTimeout(fixer, 1)
        } else {
                setTimeout(scrollit, 1000)
        }
}
el.style.fontSize = fs + "em"
el.style.lineHeight = lh + "em"
setTimeout(scrollit, 1)

Is a magic command without magic still a command? And if a feature was a bug, can a new bug be a feature?

more...

A few thoughts after reading The History of a Security Hole about a series of bugs in the OpenBSD kernel. It’s a good explanation of an instance of a problem I’ll call hard state soft state confusion, which can lead to some serious bugs, occurs with some regularity, but doesn’t seem to be often discussed.

more...

I was at Deconstruct, a little conference. It has no sponsors, a single track, no lunch, no public schedule, and no particular focus except computering. It was quite nice. Some notes from the talks.

more...