Prologue

I love dark themes. I think they are a bless for the eyes.

With monochrome displays (those chunky CRTs) we once already had bright on dark. As technology evolved we gained the possibility of enjoying full color monitors, where we seemingly could simulate the more relatable paper office featuring black ink on white paper. For the next 30 years or so everybody was exposed to the dogma of the bright background.
The comparison to paper was always deeply flawed in my opinion, since paper has no backlight. Rest assured: if paper would be illuminated we would have had dark paper.

Technically spoken there is no big difference in photons; it doesn’t matter if they are emitted or reflected. However reflected light matches almost by definition the brightness of the surrounding environment and also shares its white balance.
Also note: normal paper is not really white ⊕Nothing in the real world is a truly Lambertian surface, and nothing is of fully white color either, which would make the object perfectly specular (all photons are reflected). A classic mistake in rendering is trying to make a clay model render happen with a fully diffuse and fully white material – those two cancel each other out, leading to long render times and a bland image.– we know it should be white, so our brain does some pretty good job on white balancing it for us so we think it looks white. In RGB color terms a white paper is more along the lines of a light grey (value of ~225–230 per color channel).
Long story short: Representing the white paper model on screen with a full RBG white of 255 is wrong, misleading, and hurts your eyes.

But let’s fast forward to this day and let’s have a look on what your website might look in my browser:

Both webpages were featured on the HN frontpage on 2020-01-13.

Golden rule

This leads us to the following golden rule which can improve the life of everybody:
Be explicit, not implicit! ⊕Or don’t style at all, so the users preferences can take over.
Never trust that a user has the same settings as you do. Or in other words: Your defaults aren’t mine.

Expectation and Reality in Webdesign

For those of you who are doing webdesign let me rephrase it into one simple rule:
If you style the background, you have to style the foreground (i.e. text).
And vice versa. I will thank you for it.

Have you also noticed how “digitalization” is still a foreign concept for many out there? Especially for those who deal with “official” stuff.
Of course you just can not send them an email with the PDF filled in digitally!
Heck, some people still even want to get a FAX!

A few days back someone on HackerNews posted a link to a service he built, where you can upload a PDF and you will get it back looking like if it was scanned in – a bit blurry, not well aligned, etc. ⊕There is also FalsiScan, which carries it to extremes giving you the possibility to insert your signature in the step as well. [HN comments]

But basically it’s just these two shell commandsEasily doable with WSL as well. who do all the work:

convert -density 150 input.pdf -colorspace gray -linear-stretch 3.5%x10% -blur 0x0.5 -attenuate 0.25 +noise Gaussian -rotate 0.5 temp.pdf

gs -dSAFER -dBATCH -dNOPAUSE -dNOCACHE -sDEVICE=pdfwrite -sColorConversionStrategy=LeaveColorUnchanged -dAutoFilterColorImages=true -dAutoFilterGrayImages=true -dDownsampleMonoImages=true -dDownsampleGrayImages=true -dDownsampleColorImages=true -sOutputFile=output.pdf temp.pdf

But it turned out not to be that easy: ImageMagick has now a security policy in place which will prohibit processing PDFs and PostScript files. Trying to invoke ImageMagick with convert will fail with the fairly ambigous not authorized 'file.pdf' @ <somewhere>
What a nice and helpful error message! It ticks all points:

• ✅ Doesn’t tell you what’s wrong. (What do you mean, ‘not authorized’?)
• ✅ Doesn’t tell you how to resolve it.
• ✅ Gives you superfluous information you can’t use. You don’t care at all where the precise location of this error in the code is.

Poking around a bit gives the answer of an aggressive security safeguard in place. Since we only edit our very own PDF files we don’t care about malicous content – we want to get work done! To read more about this topic in detail I can recommend this article, which also supplies the solution:
Just edit this file /etc/ImageMagick-6/policy.xml to make sure the rights are not set to ‘none’.

<policy domain="coder" rights="read|write" pattern="PDF,PS" />

Having done that you’re good to go to and enjoy your circumvention of this bureaucratic system.

I already used it now in various correspondence – among others with a bank, who rejected a digitally signed PDF. Welp, then they got my faux-printed doc. You fools!

If you are an Archicad user and employ a multi monitor setup, most possibly with a notebook, you might have encountered this problem already:
When detached from the external monitor you are missing some of the palettes! They are still there in fact – just offscreen, outside of the boundary of your current monitor with no way of getting them back.

Some tips online seem to suggest that applying one of the default work environments (or workspace schemes) might help to mitigate this. This did not work for me however, so I went to look for another solution to get my missing Archicad palette back.

Craft your own solution

We still have an ace up our sleeve! Archicad lets us ex- and import the settings of our work environment which includes the workspace schemes.
Let’s do that! Go to Options > Work Environment > Workspace Schemes and export your current scheme. Then open the file you just saved – it’s a “simple” XML and can be opened with any editor.

First we need to find the GUIDGlobally unique identifier of the palette we need to get back onto our screen. For me it was the PhotoRendering Settings palette. You can find all palettes under the <PaletteVisibilityTable> node. The code looks like this:

<PaletteVisibility comment="PhotoRendering Settings" guid="6E7F80CC-565C-4D21-814C-7D6865DFB6F2" value="1"/>

Write that GUID down, we will need it in a minute! Also set value to 1, so you can see directly if it worked, when we load the scheme back into Archicad.

Now scroll down until you see the <SizeableFloatingRootNodes> node. Inside you can basically copy and paste any of the existing items. There are two things that need our attention: the paletteGuid attribute inside of <DockPalette>, where you have to put the GUID you just copied, and the Rect attribute of <SizeableDockData>.

<SizeableDockData Rect="334, 220, 681, 876" ScaleFactor="100" Type="Floating">
    <DockPalette comment="PhotoRendering Settings" paletteGuid="6E7F80CC-565C-4D21-814C-7D6865DFB6F2" ratio="0" visibility="true">
    </DockPalette>
</SizeableDockData>

This part is the key. Note 'Rect' and 'paletteGuid' attributes.

Rect has four comma separated values. They are the pixel coordinatesWith the upper left corner of your main screen being 0,0. of the upper left and lower right corner of the paletteWithout any window decorations. See also image.. Positive X-values are to the right, positive Y-values are below.

When editing the numbers just be sure the palette will now sit inside the dimensions of your monitor. If you’re done save the file and load it right back into Archicad. Apply the workspace scheme and you should see your formerly missing palette!

What do we learn?

To be safe also keep a separate work environment for your multi monitor setup – otherwise you’d easily be upset.

From time to time I roam around Kickstarter and take a close look at some of the campaigns. Pretty often their descriptions read like they re-invented <basic item> and furthermore promise fantastic things. One of these is “The New 30° Ruler”, which claims to be a superior ruler in every way.

This is not their first Kickstarter campaign; I pledged during their last campaign and got a ruler similiar to those in this campaign. They are well made and the artisanal quality is out of question.

I’d rather question a particular design decision they made, and why it’s made wrongly.

Maybe you can already spot what’s looking off here.

As usual there is an introduction video at the top of the Kickstarter page, which highlights all the good stuff this campaign has to offer.

Funnily enough they even show how you would expect how to operate a ruler first:

Right after you can see the shiny 30° ruler:

Apparently the “designers” behind this Kickstarter campaign are of the opinion that a ruler has been held fundamentally wrong by all people so far.

A bold claim, to be sure! And one I can not really agree on.
Of course you’re free to hold it the other (the “right”) way, but then the numbers aren’t any longer facing you. And if you are right handed, you will always draw lines from left to right, which complicates one of the main missions of a ruler: Drawing a line with a certain length.

In the short clip they seem to make the point that their method is much more precise. But how to hold this ruler? You’d always need to juggle your pen beneath your holding hand…

I even wrote to them to explain what problem I have with this design. They shrugged it off however. I’m a bit disappointed to see they made their mistake twice…

Lately I stumbled over such a weird behaviour which not only irritated, but highly frustrated me.

The Story

A friend of mine took some pictures for me to edit. We use a Google Drive folder to sync our work. Google can preview a lot of file types (more than e.g. Dropbox) – but it has a “bug”: It disregards the metadata of the RAW files. If we wouldn’t have used a system, that didn’t implemented the spec, I would never have found out.

The Problem

Let’s have a closer look at the problem I encountered.
See, the image to the right is the preview I got on Google Drive.
Looking good so far, doesn’t it?

Now, that’s the same photo, downloaded, viewed as thumb in Windows Explorer.
Do you spot anything fishy?

How about now: The same photo openend in Camera Raw.
Exactly. There is missing a whole part of the image.

The Search

At first I believed it was a thing only occuring due to up- and downloading the RAW files via Google Drive. This “easy” solution was shortly after ruptured by the insight that my friend faced the same issue with the files coming directly of his camera.

My second guess was that there could be some kind of “pre-cropping” taking place – and I was right – it’s just you simply can’t see, or let alone change it in Camera Raw, Lightroom, etc.

This is an excellent example of being spec compliant but losing your user along the way. Even worse: no program actually gives you a hint saying that there is some weird bullshit going on. So what exactly happenend?

The camera did set a 16:9 cropping to be applied to the photographs taken. That is either a setting, which was surely not activated deliberately by the photographer, ⊕Why would you even activate it? You will have to develop the photos no matter what, so you can always crop them later or some online sources suggest that it’s happening automatically if you use certain focal lengths (not really sure about that).
All of the programs, and even Windows, respect the spec and will use the crop setting from the RAW’s metadata. But again: They do, without telling the user about it – which I think is certainly a dark pattern.

exiftool -AspectRatio="" -AspectFrame="0 0 0 0" -DefaultCropOrigin="" -DefaultCropSize="" -CroppedImageWidth="<width from exiftool>" -CroppedImageHeight="<height from exiftool>" -o output.dng input.dng

$format = "dng"  # change to cr2 or orf if needed
$search = "*." + $format
$suffix = "-da"  # suffix for renaming of the de-aspected files

function Deaspect($Filename){
    # those are getting the true original sizes
    $CmdWidth = exiftool -ImageWidth $Filename
    $CmdHeight = exiftool -ImageHeight $Filename

    $ImgWidth = $CmdWidth -replace '\D+'
    $ImgHeight = $CmdHeight -replace '\D+'

    $NewFilename = $Filename.BaseName + $suffix + $Filename.Extension

    &exiftool -AspectRatio="" -AspectFrame="0 0 0 0" `
    -DefaultCropOrigin="" -DefaultCropSize="" `
    -CroppedImageWidth="$ImgWidth" `
    -CroppedImageHeight="$ImgHeight" `
    -o $NewFilename $Filename
}

Get-ChildItem -Filter $search -Recurse | ForEach-Object { Deaspect -Filename $_ }

One day in 2012 I logged into my server to only get really weird responses. When I checked the dashboard I saw what might have been the cause:

It seemed I owned 0,2‰ of all InternetHow big is the internet? at this point in time.
This seems to be not that much, but be aware that all of Wikipedia is just about 10 GB in total, and all of Wikimedia is just about 23 TBSize of Wikpedia. I honestly thought it to be bigger.

Sadly my hoster didn’t had any humour. When I wrote to their support team I got a somewhat snotty answer. (It was still resolved the day later.)

A reoccurring question in Archicad’s GDL ⊕Geometric Description Language, a proprietary BASIC-dialect made by Graphisoft is how to tackle localization. While Graphisoft localizes and translates their objects before shipping Archicad (sometimes done not by GS itself but by local resellers), independent manufacturers and programmers rather keep their objects together than splitting and duplicating the code for every language they support.

A user on Architalk wanted to know if there is the possibility to get to know which language Archicad is running on.
While there is REQ("GDL_Version"), which tells us the version number of ArchicadAt least indirectly, since GDL_Version and the Archicad version number relate to each other, but are different: E.g. for Archicad 23 build 3003 the output of the request would be 2.300000., there is no dedicated command or request to get to know the language the user is using.

<productversion>
  <buildnumber>2800</buildnumber>
  <projectbuildnumber>4010</projectbuildnumber>
  <codename>v2019</codename>
  <versionstring>23.0.0</versionstring>
  <shortversionstring>23</shortversionstring>
  <platform>MAC32</platform>
  <gslanguage>GER</gslanguage>
  <gsprodtype>FULL</gsprodtype>
  <prefspostfix>v2019 GER 2800.4010</prefspostfix>
  <guid>{6108D34D-A54F-49CE-A83C-9B805F956D74}</guid>
  <supersedes-lib name="BIBLIOTHEKEN 20" guid="{FF6B2803-AC38-48C2-ABD6-6D56DD453444}"/>
  <supersedes-lib name="BIBLIOTHEKEN 21" guid="{7A18EB31-3044-4E99-8F54-B6CB16B6CE88}"/>
  <supersedes-lib name="BIBLIOTHEKEN 22" guid="{C46B01B7-097F-4F18-9B3D-71413F211E37}"/>
  <collapse-branches/>
</productversion>

ARCHICAD Library.version

_dummy = "" ! only made so it can be ignored…
pos    = ""
nodename  = ""
nodevalue = ""
nodetype  = ""

easy stuff, right?

ch = OPEN ('xml', 'ARCHICAD Library.version', 'rl')

The first parameter is the add-on type, the second the file name, and the third is the operation mode; in this case we want the flags set to `l` locally loaded file which should be opened as `r` readonly.

r = INPUT (ch, "NewPositionDesc", _dummy, pos)

`pos` will return a new position descriptor.

rr = INPUT (ch, "MoveToNode FromFirstChild g* ELEM 1", pos, nodename, nodevalue, nodetype)

rrr = INPUT (ch, "MoveToNode FromFirstChild * TXT", pos, nodename, nodevalue, nodetype)

Basically the same as above, but this time we explicitely want a `TXT` value.

Judging by looking at my Github account and its many repositories one might say I’d be pretty skillful at using Git.
However, I am – or was – a satisfied user of the official Github Desktop GUI ⊕I know some of you will turn up your noses now.. While I do not feel uncomfortable using a CLI I liked how easy it was plus enjoyed having a nice graphical overviewgit status is now my favorite command. And yes – maybe I was a bit frightened.
Having a nice GUI seemed just more fulfilling. But alas! the Github GUI client has one disadvantage: You can’t add multiple remotes! The only option to go on from there is to rely on the good ol’ command line.

What I wanted to achieve was having a remote copy of this website right here on a Github repository (so I’d would have access from everywhere), but also a live copy on my server – because FTP’ing into your server and putting files into the right places manually is no fun at all! I also could have used a webhook to transfer my data to my server whenever I push to Github – I just couldn’t be bothered by it. ¯┐(´-｀)┌¯

Hey, this one seems easy, right?
Well – it could be, if only…

… if only I had experience in Git. The GUI is maybe too user-friendly. You can easily operate it without ever having any deeper knowledge. Something many folks actually are perturbed by. ⊕xkcd at it again

The roadmap seemed clear, though the details were not. First I needed to turn my server into something Git would understand, then add my server to the local git config, and … that’s it?!

$ git push live
remote: error: refusing to update checked out branch: refs/heads/master
remote: error: By default, updating the current branch in a non-bare repository
remote: error: is denied, because it will make the index and work tree inconsistent
remote: error: with what you pushed, and will require 'git reset --hard' to match
remote: error: the work tree to HEAD.
[…]

#!/bin/sh
git --work-tree=/var/www/fileshereplz --git-dir=/var/myrepo/site.git checkout -f

chmod +x post-receive

After my Git debacle I saw this tweet. It just sums it all up very well:

Only one thing left

I want to push to my server without the need of typing in my password every time. This task seems easy at first glance, but vast amounts of information on the internet is just plain wrong.

There is the Git Credential Manager for Windows, but it sadly only works with HTTPS repos, not with SSH ones (like the one I have set up).
All other things I’ve found need ridiculous amounts of workarounds and third-party programs or are actually talking about the Linux Subsystem. It’s totall nuts!

But lo and behold! For once Microsoft is aware of the needs of its users, and has an article on this topic.
In the more recent versions of Windows 10 we can easily get a copy of OpenSSH:

• Open Manage optional features from the start menu and make sure you have Open SSH Client in the list. If not, add it.
• Open Services from the start menu.
• Scroll down to OpenSSH Authentication Agent > right click > properties
• Change the startup type from Disabled to Automatic (Delayed Start)
• Open cmd and type where ssh to confirm that indeed OpenSSH is living. You should see C:\Windows\System32\OpenSSH\ssh.exe as the path.
• If you use Git you maybe need to specifically point it to the ssh.exe.

Now every time you start your PC the ssh-agent will be fired up as well.
With the help of ssh-keygen we can generate a public/private key pair, which can (but doesn’t need to) be encrypted with a passphrase.

Your generated keys will reside in ~\.ssh\. ⊕~ can be used in powershell, but not in cmd. For the latter you can use %USERPROFILE% tho.
First the private key needs to be loaded into the ssh-agent by using

ssh-add ~\.ssh\id_rsa

The public key then has to be put onto your server. Some providers have an online GUI for that, others don’t. The manual way would be to put the content of id_rsa.pub into a file called authorized_keys in ~/.ssh/.

If you’ve done everything correctly so far you should be able to git push myserver without ever typing in your ssh password again in cmd. 👍
PS: Color your Windows CMD appropriately!

---

If you want to learn Git as well, try this beginner friendly guide. It helped me a bit. 🙃

You should always own your platform. So I built a site where I can write and publish things on, as well link to other cool stuff. In a fit of IndieWeb I “scratched my own itch”, if you will.

Does it come with RSS? Hell yeah! It has Atom & RSS.

(•_•)
<) )╯ Always
/  \

\(•_•)
 ( (>   Own
  / \

(•_•)
<)  )>   Your Platform
/  \