![\"Screen-shot](\"/images/2020-03/Query-trello-json-with-postgres_A.png\")
\n\t\t![\"Screen-shot](\"/images/2020-03/Query-trello-json-with-postgres_B.png\")
\n\t\tI spoke on PyGrunn this year (May 8th 2026). See the details of this talk below for future reference.
\n\n| Title | \nList-Man: Pragmatic System Integration | \n
| Timeslot | \n15:00 - 15:30 | \n
| Location | \nCamera 4 (84 people) | \n
Time is always limited, but when you have big plans, it’s time to get smart and pragmatic. At the time, the company was rapidly growing and processes were getting more mature every day. It was a dynamic environment with a heterogenous landscape of different information systems. That mix also puts a demand on the data-quality of all those systems; an error quickly goes unnoticed.
\n\nBig companies often deploy some kind of enterprise service bus for these kinds of problems, but that was clearly overkill. So I made a plan how to tackle this problem, and presented the vision within ArchiLab, our companies internal vehicle for innovation.
\n\nIn this presentation I will present a number of examples of what I built, which address actual use-cases within the company. Examples include publishing data on the intranet, visually comparing lists for inconsistencies and recording data on ever changing lists. With these examples I will address things like bootstrapping your project, having an information architecture, software reusability and just building cool stuff. My tooling of choice were Debian Linux (development on Mac OS X), Python, Flask and Postgresql.
\n\nDoeke is a versatile software developer living in the city of Groningen.\nToday he’s programming in Python, but in the past decades he also wrote other languages like Java, C# and Objective-C for Atos, KPN and AkzoNobel amongst others.
\nHe gets energy from roles where structure and creativity come together.
Below are the links on the internet-tab’s I found on my devices. I did a virtual cleanup of my browsers. I’ll keep the links for reference, but I doubt I’ll need them again. The list is obviously slightly redacted.
\n\nI used these instructions (I’m using Safari on my Apple devices) to save the links. With the use of an editor and macro’s, I converted the list to MarkDown. However, the iPhone-list didn’t come with titles, so I wrote a simple Python script to fetch the titles. I did get around 10 403 Forbidden responses, they probably thought I was an AI crawler. I fixed the titles by hand. Then I did a visual inspection, and fixed some other problems (no | allowed in MarkDown link-text? Some WFT-8 problems with my script).
\n To add some actual use to this page, I've added the following button (style by this CodePen):\n
\n \n
Update: to add insult to injury, I found a document with a list of links I saved because I had to re-install my MacBook Pro:
\n\n<col>)And a list of links from email messages, also around the same date:
\n\nMacOS comes with an ancient version of bash, due to licensing issues. You can install a modern version of bash with brew, but I broke my shell after updating bash.
\n\nWhat happened? I changed my default shell via de GUI (System Settings > Users & Groups > Advanced options... (ctrl+option-click on your own name or avatar) > Login shell > Choose).
If you do that, the path to specific version of bash will be stored. It even does that if you choose the path /opt/homebrew/bin/bash (which is a symbolic link to the latest version). So when you update, and start a new shell, you get the old version of the shell. And when brew cleaned it’s cellar, the old version would have been deleted. This is when I noticed my shell was broken.
You can solve this problem in two ways. What I did: I added the path to the symbolic link to the approved list of shells. First I ran sudo mate /etc/shells (I still use mate, but you can use your favorite editor). After that I added the line /opt/homebrew/bin/bash to the end of the file. And finally I saved it.
The new entry didn’t show in System Settings, so I restarted it. After that, it showed up, so I could choose the symbolic linked version of bash from homebrew.
\n\nAnother way might be sudo chsh -s /opt/homebrew/bin/bash, but I didn’t try this one.
I published the export of my Pocket archive on this site. Below a short description how I made this with Jekyll (this site is generated by it). The basic gist of this post is to show how publishing this is (and also CSV is awesome).
\n\nThe export of Pocket is in CSV format, which Jekyll handles well. Below an example:
\n\ntitle,url,time_added,tags,status\nhttp://www.linfo.org/unix_philosophy.html,http://www.linfo.org/unix_philosophy.html,1484426802,,archive\nField Of Dreams,http://www.imdb.com/title/tt0097351/,1424351431,,archive\nhttps://en.wikipedia.org/wiki/Community_of_practice,https://en.wikipedia.org/wiki/Community_of_practice,1450194942,,unread\nThe first row contains column names, which can be used in the Jekyll-template:
\n\n\n{% assign pocket_export = site.data.pocket_export | sort:'time_added' | reverse %}\n<ul>\n{% for row in pocket_export %}\n <li>\n <a href=\"{{row.url}}\">{{row.title}}</a> \n saved on <time data-timestamp=\"{{row.time_added}}\">calculating...</time>\n {% if row.tags %}<span class=\"tags\">[{{row.tags}}]</span>{% endif %}\n </li>\n{% endfor %}\n</ul>\n\nThe template is straight forward. It could be much more fancy, but I’m probably not using it much after this.\nThere was one snag though. The format of the time_added in the export in seconds after the start of 1970.\nI’ve used JavaScript for this to format the date.
<script>\n document.addEventListener('DOMContentLoaded', function() {\n let date = new Date();\n for(let ts of document.querySelectorAll('[data-timestamp]')) {\n date.setTime(ts.dataset.timestamp * 1000);\n ts.setAttribute('datetime', date.toISOString());\n ts.innerText = date.toLocaleString();\n }\n });\n</script>\nI could have pre-processed the export to include an ISO-8601 formatted date. That would give me the option to group the items per month, but for now I’m done (I mean, this topic is a sinkhole. I could stylize the tags. I could add filter options. Heck, I could even rebuild Pocket).
\n\nSometimes it’s better to ship.
\n", "summary": "I published the export of my Pocket archive on this site. Below a short description how I made this with Jekyll (this site is generated by it). The basic gist of this post is to show how publishing this is (and also CSV is awesome).", "date_published": "2025-05-26T00:00:00+02:00", "tags": [] }, { "id": "/ict/2024/08/01/transfer-git-changes-with-a-pasteboard-workflow", "url": "https://blog.zanstra.com/ict/2024/08/01/transfer-git-changes-with-a-pasteboard-workflow.html", "title": "Transfer git Changes With a Pasteboard-Workflow", "content_html": "Sometimes you want to transfer changes you made to a source tree from one computer to the other. The source tree on both computers are managed by git. One reason to do this, is because you tried something on your laptop. But you changed your mind, and want to work on a desktop computer with a big screen and real keyboard. And you don’t want to re-type everything.
\n\nAnother reason might be, because you debugged a problem on a production machine (I never do this, of course). The production machine only has readonly access to git. You want to secure these changes exactly, because they work.
\n\nThe commands are pretty simple, but I keep forgetting them. The commands use the diff format. If possible, I try not to create temporary files, because often they leave a mess. If the source machine is on MacOS, I use this command to secure patch:
\n\n$ git --no-pager diff | pbcopy\nWhen on Linux via ssh in a Terminal.app window, I copy by hand:
\n\n$ git --no-pager diff\n# Press cmd+A to select output from last command, and press cmd+C to copy\nWith help of the universal clipboard, I can paste this on the target machine. But before I do that, I first check the status of the target repository:
\n\n# Checking if the index is clean, and we are on the right branch\n$ git status\n# Now we can apply the patch\n$ pbpaste | git apply -\nNow I can review and commit the changes, and push the changes to our origin. Normally I would use GitHub Desktop for this, because I like working with GUI’s for this kind of work.
\n\nAfter pushing, we have to cleanup things on the source machine. With older git-versions, you didn’t need to reset the working folder. But since I don’t know when this is necessary:
\n\n# Undo all the changes we secured in previous steps\n$ git reset --hard\n# Now get the changes \n$ git pull\nFinally you might want to restart any processes that need restarting.
\n\nYou can of course use temporary files. Files are more reliable anyways.
\n\n", "summary": "Sometimes you want to transfer changes you made to a source tree from one computer to the other. The source tree on both computers are managed by git. One reason to do this, is because you tried something on your laptop. But you changed your mind, and want to work on a desktop computer with a big screen and real keyboard. And you don’t want to re-type everything.", "date_published": "2024-08-01T00:00:00+02:00", "tags": [] }, { "id": "/ict/2024/05/14/google-oauth-invalid-grant-nightmare-and-how-i-fixed-it", "url": "https://blog.zanstra.com/ict/2024/05/14/google-oauth-invalid-grant-nightmare-and-how-i-fixed-it.html", "title": "Google OAuth \"Invalid-Grant\" Nightmare — and How I Fixed It", "content_html": "I’m maintaining a couple of web applications, which use login-with-google for authentication. It also uses OAuth to access some of Google API’s. They are private applications, with less than 100 users.
\n\nA while ago, one user reported an error with an application. Said user could log in, but when accessing a Google API, it would return the error “invalid-grant”.
\n\nI tried a lot of things, but this blog article was most helpful (see also this Stack Overflow entry). But solving the problem was not possible at the time. Nothing from the article worked. The user didn’t need to call the Google API since there was a workaround, so I left it at that.
\n\nMonths later, one direct collegue reported the same thing. Again, nothing I could think of or found on the internet seemed to work. This was more of a problem, since the collegue actually needed the functionality. And also, this not understood behaviour of OAuth was a ticking time bomb. And then, without an plain reason, I had an epiphany. Why not generate new credentials within the same project?
\n\nIt was worth a try. So I generated a new “OAuth 2.0 Client IDs” entry within the Google Cloud console. In the database, I emptied the oauth-session table. I made a backup, so I could revert the change if necessary. I also emptied the web application’s session table in the database. Via this way, all users are forced to re-authenticate. The web session table doesn’t have important data in it, so in my case this was possible.
\n\nAnd the fix worked well. Users did need to re-authenticate, but they didn’t need to grant permissions to use the app. I guess permissions are stored on project level, so this was not neccssary. It still is a bit unsatisfactory the underlying problem isn’t known, but I’m pretty happy the error is gone now.
\n\n", "summary": "I’m maintaining a couple of web applications, which use login-with-google for authentication. It also uses OAuth to access some of Google API’s. They are private applications, with less than 100 users.", "date_published": "2024-05-14T00:00:00+02:00", "tags": [] }, { "id": "/ict/2024/04/18/stylize-text-files-on-the-terminal-with-awkcss", "url": "https://blog.zanstra.com/ict/2024/04/18/stylize-text-files-on-the-terminal-with-awkcss.html", "title": "Stylize Text Files on the Terminal With awkcss", "content_html": "Since I’ve been introduced to UNIX, I’ve been intrigued by the awk program. Most of the time when I use it, it’s to extract a value from a text file. Yet it can do so much more than that: it’s a full blown programming language. It’s a text processing language, which runs one or more pattern/action combinations:
\n\npattern { action }\n...\nWhen the pattern matches a line, the action is executed. But at a certain moment I realized the pattern/action-combo looked a lot like CSS. In CSS you have rules, which are made up by selectors and property assignments. awk also calls them rules. Selectors and properties. Patterns and actions. A light bulb 💡 moment: awkcss was born.
\n\nThe pattern in awk can be seen as an expression which selects a line or not. In the actions part we can use function calls as property setters. So, what properties would be easy to set? I would like to show the capabilities of awkcss by providing some examples.
\n\nTake for example this zebra.awkcss stylesheet:
NR % 2 == 1 { \n color(black);\n background_color(gray);\n}\nNR % 2 == 0 { \n color(white);\n background_color(black);\n}\nTo show the file README.md with zebra stripes, run the following command:
$ awkcss -f zebra.awkcss README.md\nThe first pattern/action combo (“rule”) selects odd lines (in awk, the NR variable contains the 1-based line number). For properties I’ve created the color- and background_color-functions. As property values I’ve used variables, although you can also use strings.
About the naming convention: CSS claimed the dash-separator, and JavaScript is doing camelCasing. To differentiate awkcss from the CSS and JavaScript, I was forced to use snake_casing as a naming convention. Having the best readable CSS-dialect is considered a bonus.
\n\nTo create a simple MarkDown stylizer, checkout this markdown.awkcss stylesheet:
BEGIN {\n width(72);\n}\n/^#+ / {\n color(yellow);\n font_weight(bold);\n}\n/^\\t| {4,}/ {\n color(\"gray\");\n}\nThe BEGIN-rule sets the default width. It’s like the CSS *-selector. The second rule matches any lines starting with a #-sign to match MarkDown headings. And the third rule matches code-blocks, starting with a tab character, or 4 spaces.
Suppose you don’t want to render code-blocks, you can use the display-property with the none-variable:
/^\\t| {4,}/ {\n display(none); \n}\nThere is also a box-model:
\n\n/^>/ {\n block_name(\"block_quote\");\n border(ascii);\n border_style_left(none);\n}\nThis rule matches block quotes, and draws a border around it. Since a block quote already starts with a border-like character, the left border is set to none.
An issue with awk is that a pattern selects one line only. For inline-properties like color this is not a problem. But we don’t want to draw a border around every line. We need a mechanism to draw a border around the whole block quote instead. For this the block_name property can be used. All consecutive lines with the same block name are considered to be part of the same block.
There is also support for media-queries:
\n\n/^\\t| {4,}/ {\n color(\"gray\");\n}\n/^\\t| {4,}/ && LINES <= 25 {\n white_space(pre);\n text_overflow(ellipsis);\n}\nThis stylesheet renders MarkDown-code gray. For terminals with limited height, lines are not wrapped (default white_space is pre_wrap). And when the line overflows, it is truncated and an ellipsis (…) is shown at the end. Besides the number of lines, there are also variables for number of columns and colors.
Finally, you can use some pseudo-elements as well:
\n\n/^#+ / {\n color(bright_blue);\n}\n/^#+ / && select(\"::after\") {\n content(\"------------------------------------------------\");\n select();\n}\nThis will display a line under every heading. Because of the way awk works, the selector will need to be reset at the end of the rule by calling select with no arguments. The inserted pseudo-element is block level, meaning it will insert a line below the heading. Of course, the ::before pseudo-element is also supported.
Although I used MarkDown in this blog as an example, the use cases don’t stop there. It can be used to better inspect /etc/passwd by hiding system accounts, printing comments gray and high lighting accounts.
And I didn’t even touch everything. Check out the properties margin (including margin-collapse), tab_size, text_decoration (both underline and/or blink) and width: they are all documented in the AWKCSS Reference.
Getting started: Check out the repository on GitHub; the README.md contains all information to get you started using awkcss!
If you want to know exactly how awk is called, just add the --debug argument, and the command that would have been ran is displayed (§ is the repository-home):
$ awkcss --debug -f zebra.awkcss README.md\n awk -v COLS=180 -v LINES=50 -v COLORS=256 -f §/library.awk -f §/awkcss/defaults.awkcss \n -f §/awkcss/examples/zebra.awkcss -f §/awkcss/render.awk README.md\nThe reference also contains some technical information about this awk-implementation. Finally, if you are interested in the source code, I suggest to check out the version 0.1-branch first. This contains the initial implementation without buffering and other more advanced stuff.
There is still a lot left to be desired. There are bugs, more test coverage will be very helpful. But the biggest missing feature is table-support. After all, working with columns/cells (like $3) is awk’s biggest feature. However, to implement support for that, the render engine needs to be re-architected. We’ll see what the future holds.
For a company-internal web application I’ve used NoTemplate.js (disclosure: I’m a contributor to the project). It’s a minimal library for dynamically generating DOM nodes. And really like it. It hardly introduces abstractions. It wraps the W3C DOM API with a simple interface. And with “simple” I mean more JavaScriptesque, if that’s a word.
\n\nThe biggest reason to use NoTemplate was its simplicity. I probably won’t work much on this internal application, but when I do I don’t want to spend a lot of time getting up to speed. I won’t be working on it within 6 months, but it also can be 2 years. So I was happily surprised I’m not alone in wanting to keep things simple. See for example this piece about Writing Javascript without a build system. So when Julia Evans wrote about her new playground, I got the idea to rewrite this playground with NoTemplate.
\n\nWith this blog, I try to show the process of this rewrite. Not sure if this is interesting. I do get technical, but I try only to mention the interesting and relevant bits. Well, let’s get on with it.
\n\nIn this part I’m going to explain how I approached the rewrite. The code is published on GitHub, and every step is a commit in the git repository. I primary written this section as a way to prevent myself from writing the code, and end up not blogging about it. So if you don’t think this is interesting, you can skip to the next section. And when I say “rewrite”, I probably should say “rewire”. I reused most of the code from script.js and only made minor changes.
First step in the rewrite is to copy the source files and use these as a base for the rewrite. If you want, you can follow these steps on GitHub as I’ve created a commit for every step (commit 11c34fa Initial).
The first step is to replace the Vue library include with the NoTemplate one. I also emptied the script.js file. Now I look at the Vue template. It’s the HTML contained by the <div id=\"app\"> tag/element. With NoTemplate, we write the view-template with JavaScript. So let’s first translate the HTML without the behavior (events).
To keep things simple at this point, the UI will display 16 bit by default. Also, I only show the 16-bit pattern for now. And as I mentioned, the app is not interactive. The form-method in script.js generates the HTML view (commit 9551612 Static version).
We want to render the view from values. For that, I introduced the state property, and some property getters. One thing to note is how the bit pattern-section is generated. With NoTemplate, everything is an expression. So first an array is created for every byte. Then this array is mapped to span-elements.
This version of the code doesn’t respond to dynamic input. But when you change the state-properties in an editor, the form reflects these new values. I tested some different values, and compared them to the output of the original version. Later I realized there are also span-elements with the doublebyte-class. I haven’t actually observed any different rendering without this class usage. So I skipped implementing them (commit d12e82f Dynamic state).
And now the step to make it all interesting. Attaching event handlers, and all that is necessary. First I added the property setters and operator methods (not-, shift left-operator etcetera). When working on the event handlers for the text-inputs, I discovered an important disadvantage of using NoTemplate. Later in this blog I will elaborate on this. So with all the click, keyup and blur handlers in place, the rewrite is almost complete (commit 6d8b93f Event handlers).
Until so far I didn’t notice the original script used an indent of two spaces, while I was using four. Since I copied most code, I now have mixed code. Let’s fix that now (commit fee5e6c Fix leading whitespace).
The last part to write is to save the form state into the hash part of the URL. I had a little trouble understanding Vue, and how it handles changes of the hash. My initial code seemed to call the render-method twice. So I added the settingHash property to prevent this. And I’ve used the same code to set the state from the hash before the initial render (commit b7df8f1 Handling hash).
While playing with the playground I missed a button to reset the display to zero. The playground resembles a calculator, so that must have been why I wanted to add it (commit 49a20c5 Clear operator).
▶️ You can play with the rewrite here.
\n\nAbout tooling, and especially the simple kind: I’ve used WorldWideWeb for this project. It’s a simple, personal web server for macOS. It’s like python3 -m http.server, but it has a GUI and it adds niceness. For example, it automatically reloads the webpage if one of the source files have changed.
How do the two implementations compare? For me, two things stand out. First, with Vue the view is rendered before JavaScript has ran because it’s HTML. With NoTemplate you can get a render flash, because JavaScript has to run before the form is displayed. But if you watch close, you might see a glimpse of several {{ bit }} items at the bit pattern part in the Vue-app. You can see this better when you turn off JavaScript. With NoTemplate you can overcome this by rendering the form at compile time with some kind of build-system. But yeah, you’ll need a build system then…
But there is one problem with NoTemplate I don’t directly have a solution for. Let me explain. When a value in the application changes, NoTemplate renders the complete form and replaces the original form with the new one. While this might sound wasteful, in practice with small applications this is not a problem. Until I realized after a blur-event, the focus on the input element was lost (for example changing the signed value of the integer and pressing enter). And that is pretty annoying when you are using the keyboard.
\n\nMy first impulse is to solve this problem. I’m a programmer after all. But this is beyond the scope of this project. However, I will explore three solution directions. The first is to store what element has the focus into the application state. Now the focus can be set after rendering with a calls to setfocus(). Or during rendering with the autofocus-attribute on the appropriate element.
We can determine the current focussed element by calling document.activeElement. But how do you serialize this into some string? Some kind of DOM-index would be problematic. In a templating system, the number of nodes can differ from render to render. When the element has an id-attribute, this is not a problem. But this is not always the case. This could be solved by the NoTemplate library by generating id-values for the DOM elements that can have the focus.
Another problem to tackle is how to determine which element has the focus in all situations. When pressing tab from an input-element, the active element in the blur-event is document.body. The same is true for the change-event. Not 100% sure why this is. It might be set at a later stage in the event pipeline.
The second direction is not to replace the DOM-node, but to apply changes. Make some DOM diff thing. Not sure how this exactly would work, because event-handlers change too (there’s probably an NPM module for this). Not too fond of this idea.
\n\nI guess the best direction would be just to encode the form in plain HTML, like it was 2002. Only the bit-pattern part is dynamic after all. This part could be generated by NoTemplate.js. And perhaps for attaching the events, I could create something like Dean Edwards JSB. I always liked that idea too.
\n\nIt has been a fun project. The outcome is not completely what I wanted, but I learned a lot. The goal was not to create a working app, but to explore after all.
\n\nI discovered that writing the blog while doing the project has a lot of advantages. It keeps me focussed, and it let me do a bit of work while being on the train. I hope this blog makes sense, and like to hear your thoughts on this topic.
\n\nVia Mastodon I got the tip to defer the blur-event handler, to find out the actual active element. I directly used setTimeout, and I got the result I wanted: the activeElement was the element I tabbed to.
But since it’s not 2002 anymore, and setTimeout feels like a hack I looked into promises. So I replaced setTimeout with Promise.resolve(null).then. But this didn’t work. The activeElement was document.body again…. What’s going on?
After reading about the event loop on MDN, I read about using promises, and found this quote:
\n\n\n\n\nPromise callbacks are handled as a microtask whereas setTimeout() callbacks are handled as task queues.
\n
Long story short: defering code with setTimeout works because it’s a task, and not a microtask. My understanding is that a microtask would be ran right after the event-handler, while a task would be scheduled in the next iteration of the event loop. Apparently after the blur-handler, there is a task or microtask setting the activeElement. But now I know setTimeout is not as much as a hack I thought it was. It’s just wat I needed.
So now we can make the render-method preserve the activeElement. To do so, I first gave every element that can be active an id-attribute. And after that, I altered the render-method to remember and set the active element around the render. The render is wrapped within a setTimeout, so it is executed as a seperate task. I also used the optional chaining operator (?.), because the activeElement can be null and focusable elements may be disappear between renders.
Also, I changed the blur-events to change, because we don’t need a render when a text-value hasn’t been changed. Also, I wanted to make all the controls accessible by the keyboard. So I changed the span-items for the bit selector and the bit pattern to button elements, and gave them an id- and tabindex-attribute. To fix their appearance, I only needed to set a couple of CSS properties. As value I used unset, and it works like a charm. Now we can tab through all controls, and use the spacebar (or enter) to select or toggle them (commit e98e782 Retaining active element).
On thing that still bugged me a bit were the bit buttons (pun not intended, but still enjoyed). In the user interface, they differ from the other controls (tab-bar, buttons, text inputs). On macOS, when pressing tab links are skipped. Only “proper” controls get the focus. If you want the next link to get the focus, one can press option+tab (also known as alt+tab). So a-elements for the bits seemed a better fit.
But how should this work? A click handler would not suffice, I would need a keyboard-handler as well. And also MDN suggested to use buttons instead. But then I realized, I just can use a hash-link, like <a href=\"#0x01\"…. When I supply the right value for the right bit, no additional scripting is needed. The hashchange-handler will handle it all. And tabbing (or option-tabbing) to the elements, and pressing enter toggles the bit (commit xxx A@href bits).
That’s it. With this addition I learned even more about JavaScript and the microtasks. Also, the playground is now a bit more accessible, and that’s nice.
\n\n", "summary": "For a company-internal web application I’ve used NoTemplate.js (disclosure: I’m a contributor to the project). It’s a minimal library for dynamically generating DOM nodes. And really like it. It hardly introduces abstractions. It wraps the W3C DOM API with a simple interface. And with “simple” I mean more JavaScriptesque, if that’s a word.", "date_published": "2023-05-03T00:00:00+02:00", "date_modified": "2023-05-13T00:00:00+02:00", "tags": [] }, { "id": "/ict/2021/09/08/wat-heeft-archipunt-te-maken-met-de-ingenuity-mars-helicopter-", "url": "https://blog.zanstra.com/ict/2021/09/08/wat-heeft-archipunt-te-maken-met-de-ingenuity-mars-helicopter.html", "title": "Wat heeft Archipunt te maken met de Ingenuity Mars Helicopter?", "content_html": "Op 30 april 2021 keek ik op m’n GitHub pagina, en zag ik dat ik de volgende “achievement” erbij had gekregen:
\n\n\n\n\nMars 2020 Helicopter Contributor
\n
\nDoeke Zanstra contributed code to 1 repository used in the Mars 2020 Helicopter Mission
\npallets/werkzeug
Ik was echt totaal verbaasd. Hoe kan dit? Wat heb ik hieraan gedaan? Maar ik las de tekst hierboven nog een keer, en toen viel het kwartje bij me. Tijdens het werken bij Archipunt heb ik aan software gewerkt wat ook gebruikt is bij het laten vliegen van een helicopter op Mars.
\n\nOK. Dit behoeft enige toelichting.
\n\nAan het eind van 2017 was ik bij Archipunt aan het werk aan APAWA. Dit is een web-applicatie voor het berekenen van het lokale effect (voor een specifiek adres dus) van aardbevingen. Ik kan hier verder uitleggen wat dat precies is, maar het is misschien gemakkelijker om voorgenoemde link te klikken en zelf een kijkje te nemen.
\n\nTerloops noemde ik het woord “web-applicatie”: dit is de software van het internet. In feite een gewone applicatie, zoals bijvoorbeeld Microsoft Word, alleen dan voor het web.
\n\nEn die software was ik dus aan het schrijven. Maar om het wiel niet iedere keer opnieuw uit te vinden maak ik gebruik van software componenten. En voor het web-applicatie aspect van deze software maak ik gebruik van het open source component met de naam Flask.
\n\nOpen source is erg handig. De broncode is beschikbaar. Zodat als je een fout tegenkomt, kun je deze analyseren. Meestal heb je zelf een fout gemaakt, en is de broncode handig om daar achter te komen. Heel, heel soms kom je iets tegen wat verbetering behoeft. Ook dan is open source handig: niet alleen de broncode is open, maar het hele proces is open. Ook verbeter trajecten. Voordat ik hier op in ga nog even het volgende.
\n\nFlask zelf bestaat ook weer uit componenten. Ik liep tegen een onvolkomenheid aan in het component Werkzeug (overigens: zowel Flask als Werkzeug is niet in Amerika, maar bij onze Oosterburen bedacht).
\n\nEén van de functionaliteiten van Werkzeug is het bepalen welke browser (zoals Chrome, Safari of Firefox) een eind-gebruiker gebruikt. In een moderne applicatie wil je niet dat er een gedateerde browser gebruikt: de belangrijkste reden hiervoor is om de test-inspanning niet te groot te laten worden.
\n\nNu was er een gebruiker die Microsoft Edge (de opvolger van Internet Explorer) gebruikte. En deze werd niet herkend door Werkzeug, en dus ook niet door Apawa. Edge maakt onder water gebruik van hetzelfde component als Chrome, en is dus modern. Reden om Edge toe te voegen. Als je wilt zien hoe dit er exact uit ziet, kijk dan hier voor de details.
\n\nTot hier heb ik uitgelegd hoe software ontwikkeling kan leiden tot een toevoeging van een open source component. Maar wat heeft dit met Helicopters, Mars en NASA te maken?
\n\nLaat ik om te beginnen verwijzen naar het Engelstalige artikel Open Source on Mars: Community powers NASA’s Ingenuity Helicopter. Erg interessant om te lezen. NASA maakt dus gebruik van open source code. Waarschijnlijk worden Flask en dus ook Werkzeug gebruikt bij ground control om de helicopter aan te sturen.
\n\nIn het stuk valt ook te lezen hoe men bepaald heeft welke software gebruikt werd voor het project. NASA heeft een lijst van componenten en hun versienummers aangeleverd aan GitHub, de centrale plek waar open source opgeslagen wordt.
\n\nOmdat open source ontwikkeling zich in de openbaarheid voltrekt, kan elke wijziging in open source code gekoppeld worden aan een identiteit. De lijst van componenten en hun versienummers levert dan ook een éénduidige lijst op van namen. Mijn wijziging is opgenomen in Werkzeug versie 0.14 en voor Ingenuity wordt versie 0.16 gebruikt. Inmiddels is versie 2.0.0 net uit. Degene die aan versies na 0.16 hebben bijgedragen worden derhalve niet genoemd bij de “achievement”. Maar wellicht wordt deze code in toekomstige missies gebruikt.
\n\nIk vond het leuk om achter dit feit te komen, en uit te zoeken hoe het precies zit. En ik hoop in de toekomst nog aan andere projecten te kunnen bijdragen.
\n\nClosures in programming languages are pretty intuitive to use. Understand what they are is actually a bit more difficult.
\n\nA closure is a function, but not a regular function. And to better understand closures, it helps me to understand regular functions. So first I explain how regular functions work. After that I’ll make the connection to functional closures.
\n\nWhen you call a regular function, a lot of things are going on. Under the hood a stack-structure is used.\nThings the function needs, like arguments and the return address, get pushed up this stack. This is a bit of a simplification. There are optimising compilers, but I want explain the principle here. If you want to delve into the nitty-gritty details, please checkout calling conventions on Wikipedia.
\n\nSo how does this work, what gets pushed up our stack-for-algorithmic-purposes? Let’s explain this with a JavaScript example.
\n\n1: function test(a, b) {\n2: \tvar c = a + b;\n3: \tconsole.info('The sum of %s + %s is %s', a, b, c);\n4: }\n5: test(1, 2);\nThe program runs the following steps.
\n\ntest, the return address is pushed onto the stack. With this info, the function knows where to “return” to. So let’s push the address of line 5 onto the stack.1 and 2 are pushed onto the stack. Now there are 3 items on the stack.goto line 1. I will indent steps that are within the function call:\n c. Locals are stored on the stack too, so 3 will get pushed onto the stack, and we have 4 items on the stack.At first glance this may seem a bit tedious and boring. Yet, some smart stuff is going on. When the function returned at line 4, all local variables, arguments and return address have been cleaned up. No need for garbage collection or reference counting. Very efficient.
\n\nAnd it works pretty well when calling other functions or even with recursive calls. The stack-size is the limit! Only a stack-overflow comes after that, but that is about it.
\n\nAnd yes, I left out handling return values, stack pointers and reference types. We do not need to worry about those for this explanation.
\n\nTo summarise: arguments and local variables live on the stack. They only exist between function entry and exit. In regular functions, that is.
\n\nBefore we go to closures, it is important to know what first class functions are. JavaScript has them, but what defines them? At first you might think nesting functions is a property of first class functions, but it is not. Turbo Pascal supports inner functions, yet it doesn’t have support for first class functions.
\n\nWhen you can assign a function to a variable, the language supports functions as a first class citizen. It should be no different as assigning an integer or a string to a variable.
\n\nAnd when you can assign a function to a variable, you also can pass them around to other functions. Or let functions return functions or assign functions to data structures. This also seems reasonable, but Turbo Pascal can’t do this. For that one needs something extra.
\n\nSo let us explore functional closures. By the way: closure, lexical closure or function closure; all the same thing. Take the following example:
\n\nfunction test_two(a, b) {\n\tvar c = a + b;\n\treturn function inner() {\n\t\tconsole.info('The sum of %s + %s is %s', a, b, c);\n\t}\n}\nvar result = test_two(1, 2);\nThe function test_two returns a nested function, which is assigned to the variable result. So you would expect to execute the inner function by running result(). And this indeed works in JavaScript.
But, when you think of the stack-based system of regular functions, as described above, something is off. The stack-algorithm says when the function test_two returns, the arguments a and b and variable c are popped from the stack, and would not be accessible anymore. A call to the inner function would refer to variables that don’t exist anymore!
Functional closures solve this. I like to think of a closure as function with a shopping bag that contains all the variables (state) which are necessary to perform its function. So the variable result contains a reference to the function test_two together with a bag with values for a, b and c.
When you would run var result2 = test_two(3, 4), the variable result2 will not contain the same thing as result. The reference to the function is the same, but this closure has its own bag of state.
How exactly this is implemented is not important for my explanation. Different languages do implement this behaviour differently, but the principle is the same. I found some more technical info about JavaScript closures on MDN, and also a blog about C# closures.
\n\nThe Wikipedia article on closures has the line “Operationally, a closure is a record storing a function together with an environment.” in the introduction. That summarises the point of my explanation pretty well. I hope you now have a better understanding of closures. Let me know what you think.
\n\n", "summary": "Closures in programming languages are pretty intuitive to use. Understand what they are is actually a bit more difficult.", "date_published": "2021-04-12T00:00:00+02:00", "tags": [] }, { "id": "/2021/01/31/Building-Another-Blog-Engine", "url": "https://blog.zanstra.com/2021/01/31/Building-Another-Blog-Engine.html", "title": "Building Another Blog Engine", "content_html": "I have some ideas for a blog engine I want to explore. Instead of creating a new website, I’m planning to make incremental changes/improvements to this website. Baby steps. That’s why I’ve named this project BABE: Building Another Blog Engine.
\n\nAt the moment I’m using GitHub Pages for this blog. When I push a commit, GitHub schedules a task of transforming the source via Jekyll. And the resulting files live somewhere on a webserver. It’s convenient, but it doesn’t give me the control I need.
\n\nStep one is to build the website local, and push the resulting files to GitHub. I don’t want to create another repository for the build result, as this adds confusion. Fortunate, git has a nice solution for this. Create a branch for Jekyll’s build result, and tell GitHub Pages to serve the website from there.
\n\nI’m using the branch feature in an unusual way: it is not intended for merging into the main branch. And this way, the published source doesn’t show up in my blog’s history.
\n\nThis branch should contain no files other than the build result. The obvious choice to do this would be to create a branch and remove all files. But why not use the powers of git and create a branch from the initial commit, way in the past!
\n\ninitial_hash=$(git rev-list HEAD | tail -n 1)\ngit branch web-stek $initial_hash\nWe now have an (almost) empty branch. How do we get the output from Jekyll’s build command to this branch?
\n\nOne way might be by having the ignored folder _site (which contains the Jekyll build result) on the master branch. Somehow bring the changes to the web-stek branch by switching branches. That would work with new files, but I don’t know how to transfer modified files this way.
Two alternatives come to mind. Either use two git repositories on the same machine in different folders. Or use an intermediate folder for Jekyll’s build result. For simplicity and less confusion, I’ve chosen to work with an intermediate folder.
\n\nIn the example below, rsync transfers the build result to the /docs folder instead of /_site. I’ve changed the name, because /_site is not listed with the settings for the publication source on GitHub Pages. So /docs it is. The build process works like this:
jekyll build --destination \"$jekyll_build\"\ngit checkout web-stek\nrsync -av \"$jekyll_build\" ./docs/\nTo finish up, I need to add the folders .jekyll-cache and .sass-cache to the .gitignore file on the web-stek branch. Also, some empty folders might be there, because git only works with actual files. Finally, you might want to remove the files from the initial commit in the branch.
I compared the result in /docs with GitHub’s copy by fetching the pages via wget -r https\\://blog.zanstra.com. I only found one major difference. GitHub Pages would normalizes time-zone offsets to zero. That might be an issue for RSS readers, but I can live with it.
So after pushing all this, and setting up the publication source you are good to go. The next step is to automate publishing, but that has to wait for an other time.
\n\nUPDATED 2021-04-06: A bit mind-bending, but the publication source is considered to be in Jekyll format. How I learned this? I wanted the folder .well-known to be copied to my website, but Jekyll ignored this file. Hidden files are on the ignore list. Luckily there is an easy fix. Add a file at the root of your site called .nojekyll. The file can be empty.
At Archipunt we manage around 100 macOS computers. We used to manage them via Server.app. Because of several reasons, we now are moving to an all-MDM solution with Jamf Pro.
\n\nTo migrate the computers, we identified the following things to be fixed on these computers:
\n\nBecause of COVID-19, most computers need to be migrated by the users themselves at home. Luckily, all users have elevated privileges. Otherwise, this migration would take a lot more time on our side.
\n\nTo migration will be done by a custom application. The GUI part will be written in AppleScript because it is so well suited for this. The actual migration is done via a shell-script. I couldn’t have written this without the this script by Rich Trouton: I made it work with Open Directory (which Server.app users), instead of Active Directory. Another post that helped enormously was this check and fix for an expired Apple Push Service Delivery certificate.
\n\nI designed the shell-script via a “check-fix” strategy: I first check if something needs to be fixed, and if so, fix it. For example, first I check if the machine is linked to a network account server. If so, the link is disconnected. This way, the script can be run as often as one wants without breaking stuff. Most items about are coded via a check/fix pair. An added advantage is separate parts can easily be tested.
\n\nIt’s also handy in the case the machine has to be rebooted. After that, just run the script again, and it factually starts where it was before the computer was rebooted.
\n\nThe AppleScript front-end handles the start screen and the request for the elevated privileges. When an error occurs within the shell-script, the user is advised about this and the log file is shown in the finder. I reserved exit-code 199 via which the shell-script can tell AppleScript the computer needs to be rebooted.
\n\nTo test the AppleScript without running the actual migration shell-script, I used the user defaults system. By writing a key/value pair to the application bundle domain (defaults write nl.archipunt.public.go-jamf-pro test -string \"PASS\") the test-application’s behaviour can be influenced. When the key is not present, the actual migration code will be used.
For source-code, please check out the repository on bitbucket.
\n\nAbout implementation: we first asked a small group of users to test the script, so we could detect common problems early and fix them. This worked very well. After errors from this initial group were fixed, most errors we experienced where plain user errors and could be handled via the phone very quickly.
\n\nThe hardest error to fix was a user who just didn’t get the enrolment notification. Turned out, the user accidentally had switched on do not distrub. And also had no idea that option existed…
\n\n", "summary": "At Archipunt we manage around 100 macOS computers. We used to manage them via Server.app. Because of several reasons, we now are moving to an all-MDM solution with Jamf Pro.", "date_published": "2021-01-11T00:00:00+01:00", "tags": [] }, { "id": "/2020/10/05/Pretty-printing-JSON-with-a-twist", "url": "https://blog.zanstra.com/2020/10/05/Pretty-printing-JSON-with-a-twist.html", "title": "Pretty Print JSON with a Twist", "content_html": "TLDR; You can pretty print JSON in a different manner. Try it here.
\n\nMy second programming language was Turbo Pascal (first one GW-Basic). From a BBS-pal I learned a notation in Pascal that has the semicolon at the start of the line, instead of at the end of the line, as most people did. Sometimes I still apply the same formatting to JSON.
\n\nIn this blog, I want to explore how such formatting can be done using Python and JavaScript. Just for the record: Pascal uses semicolons as statement separator, where as languages like C use them as statement terminator. JSON shares this behaviour with Pascal.
\n\nTo make clear what I want, here’s an example JSON file in the desired layout:
\n\n{ \"type\": \"pedant\"\n, \"enabled\": true\n, \"tags\":\n [ \"nag\"\n , \"prick\"\n , \"pin\"\n ]\n, \"data\":\n { \"test\": 123\n , \"cooperate\": null\n }\n}\nAt first it looks pretty weird. However, there is an obvious advantage. You can visually follow the nesting-level of the data-structure in any editor. And you never place a comma too many.
\n\nBut why would one with a sane mind want to do this? Well, for starters because it is interesting. And also fight the orthodoxy. And it’s an ideal project to learn something new along the way.
\n\nAnyways. Python’s json module provides a dump-method to convert a native data-structure to JSON:
\n\nimport json\ndata = {'type': 'pedant', 'enabled': True, 'tags': ['nag', 'prick', 'pin'], 'data': {'test': 123, 'cooperate': None}}\njson = json.dumps(data, indent=2)\nprint(json)\nWhen you run this, it will print out the formatted JSON below.
\n\n{\n \"type\": \"pedant\",\n \"enabled\": true,\n \"tags\": [\n \"nag\",\n \"prick\",\n \"pin\"\n ],\n \"data\": {\n \"test\": 123,\n \"cooperate\": null\n }\n}\nTo better understand what’s happening, I visualized this formatting by adding colored borders.
\n\nblue Providing the indent argument will kick-off the pretty printing. A positive integer will indent that many spaces per level. If you provide a string, that value is being used per indent-level. In this example I specified two spaces.
red If indent is specified, a newline will be inserted just before the indentation.
green You can also change the separator behavior. From the documentation: “If specified, separators should be an (item_separator, key_separator) tuple”. So by providing the tuple (';', ': ') for separators, one could create European JSON. Here I provide a semi-colon instead of a comma, which is obviously not valid JSON. So just be aware, you could produce invalid JSON with this option. However, when indent is specified, the tuple (', ', ': ') is automatically used, adding spaces after both separators.
So, these arguments were a bit of a disappointment. It didn’t seem possible to format the JSON the way I wanted it.
\n\nHowever, the API provides another option. We could specify a custom JSONEncoder subclass via the cls argument (you can inspect the code I linked to). This class is heavily optimized and caters for all sorts of requirements. I made a copy of the code, and made some modifications. It just seemed like a lot of work. The code is not really designed for reuse (for example: encoding value types, like boolean, are duplicated multiple times), so I decided to take a different route to a solution at this time.
Look at the color-coded JSON above. What if we replaced comma newline indent by newline indent comma? Yes, I’m talking string-replacement. Any newline in JSON can safely be recognized as whitespace, since newlines in strings are always encoded like \\n (or when reading code, the newline \\n is encoded as \\\\n).
The only tweak we need is there should be a little bit indentation after the comma (group \\2 in the code below). The remaining indentation should be placed before the comma (group \\1). For now, I assumed the indent to be two spaces. The ((?: )*) construct is to see the two spaces as one “thing”, so it could be matched multiple times. The ?: makes sure it is not remembered as a match. I do want to match multiples of two spaces here, hence the double parentheses.
import re\ndef my_json_pretty_print(json):\n return re.sub(r', *\\n((?: )*)( )', r'\\n\\1,\\2', json)\nAs a side-note: since this is a learning exercise, I tried to make the regular expression more readable by using verbose regular expressions. The idea about it whitespace (not used in special ways) is ignored, so you can use multi-line strings. You also can add comments to parts of the regular expression. However, I intend to match whitespace, but I couldn’t get it working. And because I also didn’t think the regular expression was more readable this way, I abandoned it.
\n\nIf we combine the two code-snippets from above, we get the following output printed:
\n\n{\n \"type\": \"pedant\"\n, \"enabled\": true\n, \"tags\": [\n \"nag\"\n , \"prick\"\n , \"pin\"\n ]\n, \"data\": {\n \"test\": 123\n , \"cooperate\": null\n }\n}\nNot bad. Not bad at all! When we compare this to the desired layout from above, we can note the following:
\n\n{ and [) are followed by a newline. This needs to be addressed.} and ]) seem to be at the right place, so we are fine there.First thing I want to fix is to support all sorts of indentations, and not only hard coded two spaces. I figured it is best to define a new function, which will call json.dumps, so there is only need to pass indent once. Addressing the issue with the extra space in the indentation: this is caused by the comma that is also functioning as an indentation character. Basically I need to delete the first character of the last indent, marked visually by the X: x .
I played a bit with parameterizing the indentation into the regular expression. String concatenation looked terrible. Formatting with {} and .format() wasn’t a good match either, because curly braces are also special characters in regular expressions. printf-style formatting (%s) is a good alternative, while the regular expression stays readable.
While playing with it, I discovered that the handling of the [- and {-characters are the same the ,-character, so I generalized the regex by changing , to a capturing group that matches all three characters, and add a back-reference to the replacement. The code now looks like this:
def json_stringify(obj, indent=2):\n if not isinstance(indent, str): indent = ' ' * indent\n result = json.dumps(obj, indent=indent)\n rx_indent = r'([,{[]) *\\n((?:%s)*)%s(%s)' % (indent, indent[0], indent[1:])\n result = re.sub(rx_indent, r'\\n\\2\\1\\3', result)\n # Special case: remove inserted newline with top-level array or object\n return result[1:] if result[0]=='\\n' else result\nSo, if we run the code now, we get this:
\n\n{ \"type\": \"pedant\"\n, \"enabled\": true\n, \"tags\": \n [ \"nag\"\n , \"prick\"\n , \"pin\"\n ]\n, \"data\": \n { \"test\": 123\n , \"cooperate\": null\n }\n}\nThis is exactly how we want it. As always, there are some things to be desired:
\n\n*) make the program fail: the indent-string should be converted to a valid regular expression string first.indent=0 with an IndexError: string index out of range on the code indent[0]. This is easy fixable by using slices, like indent[:1]So that brings us to the following code:
\n\ndef json_stringify(obj, indent=2):\n if not isinstance(indent, str):\n indent = ' ' * indent\n result = json.dumps(obj, indent=indent)\n r_indent=re.escape(indent)\n if indent[:1]=='\\t':\n r_indent0 = ''\n r_indent1N = re.escape(indent)\n else:\n r_indent0 = re.escape(indent[:1])\n r_indent1N = re.escape(indent[1:])\n rx_indent = r'([,{[]) *\\n((?:%s)*)%s(%s)' % (r_indent, r_indent0, r_indent1N)\n result = re.sub(rx_indent, r'\\n\\2\\1\\3', result)\n return result[1:] if result[:1]=='\\n' else result\nSo, that’s it. I made this code into a shell script, so it can be run from the command line (don’t forget to chmod +x it before you start it). So how does it perform?
$ ls -lh\n-rw-r--r-- 1 doekman staff 4,9M 22 sep 17:08 big_trello_export.json\n-rwxr-xr-x 1 doekman staff 705B 22 sep 17:10 json-pp.py\n$ time ./json-pp.py < big_trello_export.json > big_test.json\nreal\t0m0.849s\nuser\t0m0.734s\nsys\t0m0.069s\n$ ls -lh\n-rw-r--r-- 1 doekman staff 7,3M 22 sep 17:11 big_test.json\n-rw-r--r-- 1 doekman staff 4,9M 22 sep 17:08 big_trello_export.json\n-rwxr-xr-x 1 doekman staff 705B 22 sep 17:10 json-pp.py\n$ \nNot bad. Five megabytes within the second on my 2017 iMac. I expected worse. But to state the obvious: don’t use this in production.
\n\nAs I mentioned at the start: I couldn’t have ended this quest without back-porting this code to the origins of JSON. The advantage of string substitution: it can easily be converted to JavaScript.
\n\nConverting the code to JavaScript was pretty straight-forward. Things worth mentioning:
\n\n$1 instead of \\1 in Python4*' '. I couldn’t find the JavaScript equivalent first, so I used new Array(1+4).join(' ') but then I found out you can use ' '.repeat(4) in modern browsers[1:2] are calls to .substring(1,2) in JavaScript. Why can’t I remember this?You can try the JavaScript version here. Thanks for reading!
\n\n", "summary": "TLDR; You can pretty print JSON in a different manner. Try it here.", "date_published": "2020-10-05T00:00:00+02:00", "tags": [] }, { "id": "/2020/04/03/query-trello-json-with-postgres", "url": "https://blog.zanstra.com/2020/04/03/query-trello-json-with-postgres.html", "title": "Query Trello data with Postgres (JSON)", "content_html": "Recently, I was working on a project to automatically create Trello-cards via their API. To do that, I needed some id-values from the Trello-board which are not shown in the user-interface. But where does one get these values?
\n\nGlad you asked. Every Trello-board can be exported to JSON, and the values I was looking for are available in this export. However, JSON gives you the data in one big piece of text. Wouldn’t it be handier to have it available as tabular data in a database?
\n\nSo I created this git-repository to do just that (you will need the Postgres-database for this).
\n\nThe table in which the JSON is stored, is modelled after an idea of Rob Conery which basically is: store the JSON in a column, along with another column that uniquely identifies the document. This unique value is also available within the JSON itself.
\n\nFor example:
\n\nid, json\n12, '{\"id\":12, \"other\":\"data\"}\n13, '{\"id\":13, \"other\":\"info\"}\nThe actual table definition is different, but you get the idea. And don’t worry about storing the id-value twice: this small abstraction will make your life a bit easier.
\n\nOn top of this document table, I created views for most used objects, like cards and lists. The pretty simple idea of “views on top of json” is pretty powerful. You get a lot of bang for your buck!
\n\nIf you’re on a Mac, Postgres.app is the easiest way to setup a database, but Homebrew works fine too. As client, I use Postico which I really like a lot.
\n\nSo if you have a postgres database setup, and have cloned the git project, it’s easy to create the database object via the terminal by typing:
\n\nmake trello\nThis will create the trello schema and within the schema the document table in which the json will be loaded and a bunch of views. I’ve included a Trello export file, so you can load it by running the following command:
tool/loaddoc.sh data/simple_board_v1.json\nloaddoc inserts the JSON-document in the database, unless it already exists. In that case it will update the row. To aid this upsert behaviour, I’ve added a trigger to the database schema that updates the id-column. Ideally, this would be handled by the tool itself. However: this is a minimum-imlementation. I couldn’t find anything to load json into the database from the command line.
A note about the id-column. Trello uses hexadecimal identifiers of 24 positions. That’s easy for computers, but a little harder for humans. So to ease filtering the views, I’ve added an integer-column with auto-numbering.
\n\nBelow the screenshot showing the result in Postico with this Trello-board loaded; the same one as we just loaded. On the left you see the table and views. Above I’ve applied a filter, so I only see the lists from the first JSON document. All columns are type-cast. When you hover the image, the right pane is shown which also show type information.
\n\n\n\t\n\t\t\n\t\tSince I talked a lot about tooling: when you run cat .ok on the command line, you will find some often used commands on your screen. It’s called an ok-profile. The ok-bash-tool will make it easier to work with this. It also makes you smarter and more efficient.
So if you develop for Trello, you should really give this a try. And if you are working with JSON documents from other origins, I’m very much interested in your ideas.
\n\nOriginally published at this gist on GitHub.
\n", "summary": "Recently, I was working on a project to automatically create Trello-cards via their API. To do that, I needed some id-values from the Trello-board which are not shown in the user-interface. But where does one get these values?", "date_published": "2020-04-03T00:00:00+02:00", "tags": [] }, { "id": "/2020/02/17/ok-bash-and-python", "url": "https://blog.zanstra.com/2020/02/17/ok-bash-and-python.html", "title": "ok-bash and Python on macOS", "content_html": "Development on Python 2 has been stopped, and the default availability of Python on macOS will be deprecated anywhere in the nearby future. Last week, Scripting OS X wrote about how to deal with this from an admin-perspective.
\n\nHere I would like to explain how we deal with this from the perspective of a small but very handy tool called ok-bash. This nifty tool helps you free brainspace by creating .ok-folder profiles for bash. You should check it out: it really makes you smarter and more efficient.
Since the default availability of Python on macOS is threatened, this article is written from a macOS point of view. But the tool itself works on all systems that run bash.
\n\nThe tool is exposed via a bash-function, with a Python-backend helping with more complex tasks like syntax highlighting and other formatting. We need a bash-frontend, so the tool can work in the current shell environment.
\n\nWe want to keep installation of ok-bash simple, so users can just clone the git-repository and initialize it via the shell startup file.
\n\nSince there are so many ways to manage Python, we decided to resolve the used python-binary that’s within the current PATH. This is termined via the command which python3 || which python, so Python 3 is used when available (the Python-backend works both in versions 2 and 3). Also, when only Python 2 is available (or if Python 3 is symlinked to python), ok-bash still works.
It’s also possible to manually override the path to Python, by setting an environment variable.
\n\nIn the future, ensuring Python’s availability can be done via a homebrew recipe. An extra advantage of homebrew is it supports the use of virtual environments.
\n\n", "summary": "Development on Python 2 has been stopped, and the default availability of Python on macOS will be deprecated anywhere in the nearby future. Last week, Scripting OS X wrote about how to deal with this from an admin-perspective.", "date_published": "2020-02-17T00:00:00+01:00", "tags": [] }, { "id": "/2019/10/02/To-the-point", "url": "https://blog.zanstra.com/2019/10/02/To-the-point.html", "title": "To the Point", "content_html": "Already two internet aeons ago, secretGeek came up with some handy bash-aliases to ease navigating the folder hierarchy:
\n\nalias ..='cd ..'\nalias ...='cd ../..'\n#and so on\nTwo dots plus an enter navigate you one directory down¹, three dots do that twice, and so on. However, a single dot doesn’t go anywhere and gives you rudely some error message. No help there:
\n\n$ .\n-bash: .: filename argument required\n.: usage: . filename [arguments]\nTurns out the . is a shell buildin command that requires at least a filename as an argument. How rude.
Wouldn’t it be handy and appropriate to print the current path when no argument is given? In that case, you could try adding the following to your .profile or equivalent startup file:
function . { if [[ $# -eq 0 ]]; then pwd; else source \"$@\"; fi }\nNow a single dot will be more polite and will show the current path. Used with arguments, it works like before. So you still can use it to source scripts, like ok-bash.
\n\n\n\t\n\t\t¹) I've been told a hierarchy of folders/directories is a tree structure. When navigating into a folder, like cd some_folder, to my earnest knowledge one moves up. Branches mostly grow to the light where the sun is, which is up in the sky. So if you go back from said folder with cd .. one would move down. So secretGeek's aliases better be called down_down_down but maybe that has a less engaging ring to it. Also: the base of the hierarchy —one could go there with cd /— is called the root, which is a kind of odd, because the root is as branched as the part of the tree that grows in the air. And at the file system, it's only one place! Anyways, the proposed function neither goes up nor down, so at least we have no confusion there.\n\t\n
From the Coding Guidelines of NetNewsWire:
\n\n\n\n\nVersion Control
\n
\nEvery commit message should begin with a present-tense verb
Initial Add Add Add Add Remove Add Add Add Add Add Add Add Add Fix Make Add Unbreak Add Add Add Add Add Add Add Add Add Add Add Delete Add Remove Drop Add Add Add Add Add Add Comment Allow Put Make Update Make Show Wire Avoid Replace Add Add Ignore Add Write Update Remove Merge Generate Merge I Merge.
\n\nProvide If Add Merge Fix Merge Fix Merge Merge Update Merge Use Use Start Create Start Extract Start Make Make Get Start Add Turn Add Add Move Fix Add Add.
\n\nCommit Continue Move Add Work Continue Continue Delete Convert Convert Convert Convert Convert Remove Converrt Add Replace Set Begin Move Remove Set Continue Add Back Make Start Make Make I Rename Give Start Continue Create Add Make Do.
\n\nGet Make Get Attach Progress Make More Continue Make LookupTable. Using Yet More Merge Remove Start Checking Added Start Progress Make Finish Make Turn Make Decide Progress Make Fix Make Create Make Delete Progress. Implement Start.
\n\nImplement Create Make Make Make Make Continue Continue Make Continue Deal Get Make Use Call Add Delete Fix Make Marked Use Make Make Update Fix Make Rename Remove Add Prune Switch Save Update Move Merge Fix Update Merge Remove Update Move Update Fix Create Slightly Cache Use Delete Implement Update Update Make Update Move Create Delete Fix Get Move Delete Replace Continue Fix Continue Continue Continue Continue Continue Make Get Make Continue Continue Start Use Create Switch Simplify Update Start Remove Start Rename Do Move Make Fix Start Start Make Init Make Fix Make Init Fix Perform Edit Add.
\n\nMake Fix Fix Fix Fix Fix Fix Create Move Remove Make Create Make Rewrite Use Fix Fix Remove Require Add Use Use Send Move Update Keep Update Create Make Call Save Fix Avoid Avoid Set Set Simplify Save Comment-out Add Remove Update Update Include Fix Update Refactor Avoid Handle Handle Rename Update Use Show Make Add Implement Show Update Make Fix Create Update Update Define Handle Make Update Differentiate Add Use Removed Update Change Make Make Post Rejigger Send Rewrite Use Update Move Make Fix Update Maintain Update Update Start Create Switch Begin Clear Rename Update Move Fix Edit Put.
\n\nFlesh Craete Fix Create Start Do Start Fix Move Move Read Show Use Use Make Make Make Upgrade Upgrade Upgrade Upgrade Fix Make Switch Make Add Display When Mark Use Add Add Add Add Create Write Allow Write Check Add Remove Calculate Draw Close Start Show Draw Create Add Show Change Add Add Merge Rename Add Post Make Make Run Move Update Add Show Add Remove Add Skip Add Bump Add Add Change Add Change Bump Use Lighten Switch Set Decode Add Expand Set Bump Create Fix Use Create Add Add Add Add Fix Create Treat Update Make Use Add Delete Create Move Implement Remove Bump Switch Disallow Save Start Save Save Create Create Make Create Make Make Bump Make Update Set Darken Create Create Switch Create Make Make Replace Fix Make Create Make Use Fix Implement Use Update Show Return Add Bump Update Check Add Fix Fix Put Note Edit Avoid Log Normalize Print Log Simplify Log Add Start Adjust Pull Add Use Rebuild Add Fix Keep Add Make Parse Get Add Start Add Add Prefer Bump Add Add Add Fix Do Don’t Add Hide Add.
\n\nAvoid Update Update Bump Fix Save Use Make Start Add Fix Get Add Add Use Bind When Create Delete Fix Do Increase Fetch Set Show Create Refresh Make Use Update Merge Update Add Start Add Fix Continue Make Define Make Create Make Create Create Parse Fix Base Cache Update Clean Fix Remove Remove Get Increase Add Create Create Remove Remove Remove Add Add Add Make Use Add Draw Skip Add Delete Reuse Parse Remove Bump Update Merge Add Save Refresh Parse Make Add Prefer Test Add Support Add Parse Add Add Make Add Add Fix Add Add Add Add Make Implement Add Style Display Normalized Continue Progress Make Edit Implement Position Bump Update Add Add Update Fix Add Add Link Add Add Add Fix Add Add Fix Add Continue Add Fix Update Use Merge Set Add Merge Update Update Move Implement Merge Clean Move Validate Add Use Use Remove Merge Simplify Return Validate Popup Add Remove Create Improve Set Start Don’t Set Use Use Bump Remove Update Implement Go Add Use Make Bump Update Remove Remove Create Merge Make Continue Continue Show Update Add Update Fix Show Use Put Add Fix Use Update Add Add Show Make Fix Comment Bump Update Freeze Fix Make Show.
\n\nMove Move Add Show Fix Check Use Update Make Make Turn Create Remove Draw Add move Merge Merge, Bump Increase Make Start Check Remove Merge Make Decrease Make Update Continue basic Merge revert Merge Make Add Use Add Switch Make User Use Fix Increase Add Bump Change Update Update Add Add Create Add Make Use Use Bump Update Make Unbreak Create Scripting Merge Add revert Merge Add Remove Layout Create Create Make Continue Keep Adjust Remove Reopen Open Restore Hide Display Continue Increase Continue Set Share Create Send Extend Make Add Revise Refer Move Add Handle Use Update Merge Scripting revert Add Merge Remove Download Switch Remove Remove Back Use Remove Add Add Set Make Add Add Add Add Validate Set Merge Consider Register Merge Re-sort Create Build Add Add Create Change It Accept Remove Sender Merge Merge Merge.
\n\nMerge convert Merge Merge Start Merge Create Layout Change Add Wire Try Disable Make Delete Remake Make Remove Continue Get Add Add Move Make Remove Bump Update Reorder Remove Create Merge Merge Remove Show Make Show Change Update Restore implement Merge Merge Start Add Merge Add Pass Rearrange Add Use Add Create Add Make Add Add Remove Fetch support Merge Merge Fetch Rename Bump Update Remove Skip Make Remember Fix Make Skip Disallow Punt Make Create Implement Support Add Start Make Support Make Remove Update Bump Update When Skip Make Add Do Merge Hide When Make Update Make Create Delete Remove Add Add Use Use Use Remove Remove Use Create Use Create Use Don’t Use Add Remove Create Move Remove Move Move Fix Remove Move Darken Do Start Show Skip Add Mark Release Make Remove Rewrite Define Tweak Bump Update Give Tweak Draw Show Make Update Merge Switch Remove Create Add Turn Reenable Make Add Use Make Don’t Don’t Remove Replace Make support Remove Start Continue Use Fix Turn Reduce Lower Lighten Tweak Add Skip Make Turn Fix Match Adjust Use Make Turn Revert Hide Fix Make Make Deal Rebuild Bump Update Force Draw Reduce Save Bump Update Start Clean.
\n\nSupport Merge revert Reset Merge Merge.
\n\nAdd Merge add Merge better.
\n\nMerge Add Merge.
\n\nAdd Remove Break Break Break Break Break First Merge use Break Break Rename Rename Add Add Add Add Build Update.
\n\nAdd Get Get Make Add Use Nuke Fix Remove Remove Remove Use Update Merge Really Use Use Make Submodule Remove Submodule Start RSDatabase Remove Rename Move Delete Remove Include.
\n\nUpdate Add Unbreak Merge Oops Merge Add I Change Merge Fix Changes Merge Simplify Update Fix Use Unignore Use Use Use Use Update Use Update Use Use Use Use Use Use Use Use Use Update Update Update Add Update Update Use Update Merge Finish Use 🎉Start Continue🏡 Update Update Revise Merge.
\n\nRemoved Rename Update Change Use Use Merge Switch Merge Merge Hide Allow Normalize Normalize Fix Make Update Stop Merge Don’t Rename Add Update Add Update Start Keep Use Merge Merge Manually Add Bump Bump Hide Add Add Fixed Fix Merge Merge Don’t Merge Removed Fixed Merge Merge Update Update Change Changed fixed Merge Added Merge Remove Update Bump Update Enabled Merge Enabled Merge Bump Fix Print Fix Give Update Implemented Start Update Rolledback Enabled Changed Enabled Stop Update Update Stop Give Store Stop Merge Don’t Write Merge Merge Changed Added Merge Merge Save Merge Store Store Make Store Store Store Store Skip Write Added On Remove Stop Delete Remove Made Update Skip Merge Modified Updated Disallow Include Register Create Made Made Remove Start Make Refactor Merge Normalize Register Validate Add Accept Make Get Validate Make Added Added Sorted Redo Start Improve Merge Merge Merge 5.0d7. Update Temporarily Fix Include Merge.
\n\nUpdate Continue Complete Fix Similar Merge Merge.
\n\nRemove Update Re-enable Make Allow Update Make Update Increment Install Clean Update Update Update.
\n\nClean Update Merge Add Add Make Override Use Enable Add Add Update Update Get Do Disable Update Move Add Remove Add Remove Start Continue Make Remove Add Remove Add Use Rename Remove Make Move Fix Remove Remove Remove Make Add Add Add Add Make Make Add Remove.
\n\nchanged Merge added Merge Start Merge Send Add Fix Update Run Don’t Start Add Add Add Update Update Add Fix Update Bind Add Switch Keep Update Update Fix Set Bump Close Add Bind Refresh Check Add Fix Switch Update Remove Enable Update Make Bump Tighten Reduce Further Update Bump.
\n\nMoving Remove Updates Update Re-sort Restore Make Set Start Update Refresh Bump Drop Update Use Make Add Implement Add Implement Bump added Merge Don’t Don’t Update Make Allow Queue Do Remove Remove Remove Skip Fix Fix Discard Bump Update Skip Stop Update Remove Remove Remove Remove Remove Fix Merge Move Merge Remove Get Delete Delete Simplify Simplify Simplify Rationalize Import Start Make Update Quiet Merge Create Update Remove Move Make Remove Make Place Move Create Add Start Start Differentiate Merge Change Fix Merge Work Merge Make Continue Start Continue Remove Make Make Continue Rewire Fix Merge. Update Make Remove Remove Make Update Make Update Update Implement Make Add Index Update Revise Create Show Add Update Remove Revert Bump.
\n\nImplemented added Use Remove Get Remove Remove Create Made Recalculate Merge Merge Remove Comment-out Rolled Merge Updated Merge Switch Merge Made Merge updated Merge made Merge add Merge Change Document Delete Create Update Continue Add Import Pull Change Remove Start Continue Update Make Make Skip Remove Remove Perform Do Give Pay Start Update Continue Make Make Move Finish Continue Continue Update Merge Store Update Convert Convert Post Convert Convert.
\n\nRemove Set Drop Merge Remove Removed Create Merge Updated Remove Remove Remove Remove Merge Made updated Changed Updated Use Remove Remove Remove Remove Remove Remove Update Move Fixed Merge Remove Merge Delete Fix Move Move Remove Remove Major Move set Added updated Remove Work Start Update Save Update Take Made updated Added added Added adding Merge cleared Attempted Design Removed Merge Added Fixed Combined Combined Fixed Implemented Implemented Updated Group Merge Update Update Update Update Merge Updated Established Adjusted Fixed Fixed Changed Cleaned Fixed Added Added Made Added Reduced Fixed Implemented Refactored Made Added Changed Renamed Added Made Implemented Add Remove Add Update Start Create Switch Change Fix Implement Make Fix updated Update Fix Remove Tweak Fixed Change Revise Merge Removed Restored Fix Change Prevent Create Change Update implement Move Change Refactor Encapsulate Implement Add Finish Hide Move Prevent Fix Removed Hide Change Add Implement Fix Make Make Skip Remove Change Add Rename Make Change Add Refactor Enable Comment Implement Change updated Fix Add Implement Updated Add Add Prevent Add Rework Update Change Remove Add Rollback Enable Add Added Made Remove Change Add Enable Tweak Add Add Change Tweak Hack Provide Delete Rename implement Fix Fix Force Fix Made Deselect Deleted Align Make Respond Fix Align Change Slightly Increase Changed Use Add Merge Update Add Merge Add Add Merge Add Change Merge Change Create Change Fix Merge Refer Implement Make Made Merge Set Add Fix Add Fix Reuse Merge Write Add Make Merge.
\n\nRename Add Add Make Rename Rename Add Load Enable Delete Refine Make Make Prevent Implement Make Make Add Implement Implement Tweak Expand Prevent Show Update Updated validate Make Update Made change Add Add refactor Upgraded Pass Modify Rename Add Add Update Fix update make Add Added Fix Add Change Add Save added Add Keep Add Add Add added Update Add Fix Add Update Add Change Use Add Capture Refactor Add Restrict Move add store make Make Place Make Added Change Delete Set Change Add Put Stub Make Speed Use Set Update Merge Add Save Add Fix Delegate Make Save Change Scale Add Add Fix Upgraded Fix Fix Removed Fix Restore Update Add Start Update Add Add Add Rename Add Align Switch Prevent Retrieve Add Fix Scale Merge Update Show Fixed Disable Merge Move Make Remove Remove Add Disable Merge Remove Rename Dismiss Don’t Removed Disable Don’t Dismiss Rename Updated Improved Further Made Add Made Updated Set Add Moved Always Made Merge Allow Update Decrement Simplify Increase Merge Add Add Merge Make Make Updated Implement Make Make Remember Fix Update Remember Add Remember Make Update Update Send Fix Enhance Use Change Merge Remove Correct Use Cleaned Left Improved Removed UI Show Centered Merge Made Fixed Use Update Add Update Remove Update Merge Reformat Remove Add Set Merge Update Merge Correct Update Add Fixed Change Add Wrap Update Update Tweak Revise Add Fix Fix Add Tweak Change Make Update Change Merge Allow Enable Updated Updated Merge Refactor Correct Remove Google Use Point Enable Prevent Remove Handle Enforce Update Authentication Update Merge Rework Enable Corrected Remove Correct Refactor Rename Rename Add Ensure Modify Enable Handle Decoding Refactor Update Validate Fix Clear Remove Make Merge Merge Update Update Remove Provide Made Bump Update Fix.
\n\nCleanup Cleanup Add Make Pop Add Prevent Fix Fix Fix Ensure Fix Remove Fix Move Revert Fixed Merge Resolved Fix Merge Fix escape Fix Merge NetNewsWire upgraded Fix Changed Add Update Make Updated Updated Change Request Show add Merge Update Update Unread Mark Convert Make Add Update Add Fix Dismiss Merge Added Merge Updated Revert Add Added Updated Updated Marking moved Add Use fixed Refactor adding trying fix Merge Add Merge adjusted Made Made Refactor Add Correct Add Update center add Add Merge Revert Add Added Merge Fixes Merge Need Updated Add Merge Merge submodules Merge Move Subscribing Rename Port Add Merge Opens Update Update Update Merge Move Add Add Disbale removed Merge Merge FIrst Change use Fixed Wiring Code Begin Update Update Only Update Merge Update Remove Skip Use Merge Merge Change Move Update Implement Cleanup Merge Merge Adds Merge Renamed Merge Updated some Merge Merge Merge Merge Renamed restores restores Restrict Corrects Merge Merge Changed Switches Adds Switches Rebrand Merge Update Ensure Reduce Update Make Support Low Set SF Merge SF Rolls Deletes Merge Implement Merge Retrieve Temporarily Move Force Navigate Correct Fix Fix Removed Move Temporally Add Change Rename Fix.
\n\nMove Run Merge Update Add Encapsulate Move Move Move Remove Change Merge Write Update Update Make Update Add Note Remove Update Merge Update Make Merge Use Update Update Update Mark Make Merge Remove Make Delete Make Make Make Make Make Make Merge Update Use Update Merge Create Merge Merge Add Merge Add fiddle Merge Merge Use Merge Create Merge Updated Use Remove Merge Merge Create Merge Create Create Make Merge Create merge Merge Add Prevent Added Add Fix Hook Change Show Fix Initial Fix Merge Make Merge Help Remove Merge Remove Automatically Rename Change Merge Show Merge In Restore Merge Remove Merge Merge Make Merge Remove Trying Get Merge make Merge rename CLean Skip Merge Integrate Check Merge Merge Merge revert Revert Try Exempt Merge Helpbook: Merge Add Merge Prevent Merge fix Fix fix Merge Merge.
\n\nMerge Refactor Make Add Remove Implemented Correctly Adjust Correct The Merge Merge Replace Merge Fix Fix Fix Remove Merge Made Keep Fix Wire Merge Fix Merge Enable Add Merge Fix Deleted Made Remove Fix Fix Merge Reformat Merge Refactor Fix Change Reenable Correct Removed Fix Fix Fix Helpbook: Merge Remove Merge Help Merge Change Merge Merge fix undo Bump Merge Add, Merge Merge Update Fix Merge Bump Merge Use Merge Break Merge Update Add Add Get Update Merge Bump Merge Update Bump Merge Now Merge Update Fix Rearrange Add Add Add Add Center Add Add Add Add Change Do Implement Add Merge Add Remove Move Add Merge Add Add Add Add Move Merge Commenting Fix Work Change fix Replace, Merge Start Port Change Optimize Remove Make Give Refetch Bump Merge Update Add Merge Hack Remove Add Fix Reload Center Center Center Bump Update Merge Bump Merge Add Leverage Merge add Change Add Update.
\n\nCongratulations to Brent and others. Enjoy NetNewsWire 5.0…
\n\n", "summary": "From the Coding Guidelines of NetNewsWire:", "date_published": "2019-08-26T00:00:00+02:00", "tags": [] }, { "id": "/2019/08/17/Office-for-OS-X-icons", "url": "https://blog.zanstra.com/2019/08/17/Office-for-OS-X-icons.html", "title": "Office for OS X icons", "content_html": "Updated 2021-05-19: added Big Sur icons.
\nUpdated 2023-06-21: Added 2023 “Show your pride”-variation (2022 update apparently)
OS X, now called macOS, was based on the NeXTSTEP operating system. And one innovation of this operating system was large full-color icons.
\n\nWith the introduction of new icons this year with Office 365 (including the 2019 retail version), I felt the need to create this:
\n\n\n\t![\"Office](\"/images/office-for-os-x-icons-2023.png\"){kind=icon}
\n\t\t![\"Office](\"/images/office-for-os-x-icons.png\"){kind=icon}
\n\t\tIn 2001, Office v. X was released. It’s design was very distinct from Windows, and also very aqua-y. The maximum size was 256×256 pixels. The 2004 icons I found were oddly sized 128×128 pixels. The resolution of the 2008 and 2011 icons went up to 512×512 pixels. These were also the last OS X-specific icons for Office.
\n\nStarting with the 2016 version, the icons design of the Windows version was also used with macOS. And because of higher resolutions of displays, the dpi-count of the icons went up from 72dpi to 144dpi, making the 2016 and 2019 icons sized 1024×1024 pixels.
\n\nHaven’t had enough? At the excellent Version Museum they have all Windows icons of Word including screenshots. They also have a page on Excel .
\n\n", "summary": "Updated 2021-05-19: added Big Sur icons.Updated 2023-06-21: Added 2023 “Show your pride”-variation (2022 update apparently)", "date_published": "2019-08-17T00:00:00+02:00", "date_modified": "2023-06-21T00:00:00+02:00", "tags": [] }, { "id": "/2019/06/12/Rename-github-repo", "url": "https://blog.zanstra.com/2019/06/12/Rename-github-repo.html", "title": "On renaming a GitHub repository", "content_html": "Did you know you can rename GitHub-repositories? There are some quirks though.
\n\nCheck it out: https://github.com/doekman/You-are-so-lame
\n", "summary": "Did you know you can rename GitHub-repositories? There are some quirks though.", "date_published": "2019-06-12T00:00:00+02:00", "tags": [] }, { "id": "/2019/05/06/Introducing-osagitfilter", "url": "https://blog.zanstra.com/2019/05/06/Introducing-osagitfilter.html", "title": "A third way of putting AppleScript into git", "content_html": "There are currently two ways of putting AppleScript into git. First is just by adding the binary .scpt-files. You don’t get much benefit from using git, but it works.
The second way is to save your AppleScript source as text-files, and put these into git. You get advantages from git, but it is not as seamless as the first way.
\n\nNow you can combine those two ways by using the osagitfilter utility. Technically, it’s a git filter that translates AppleScript’s binary format into the text-representation which then will be used by git’s internal workings.
\n\nSee the repository’s readme for installation instructions. After that, you can put compiled script files, AppleScript applications and script bundles in git as if they where regular text-files. When you then clone this repository, the files are re-assembled bit-perfect.
\n\nLet me demonstrate this by an example. First create a git-repository:
\n\ngit init osagitfilter-demo\ncd osagitfilter-demo\nNow create the AppleScript-file my_script.scpt in this folder with the following contents:
display dialog \"What's your name\" default answer \"\"\nsay \"Hi there, \" & text returned of result\nSince we don’t want to add a binary file to git, we first need to associate the .scpt-extension with the osagitfilter (you need to explicitly opt-in every repository). This can be done by adding a line to the .gitattributes-file, connecting the .scpt-extension to the osa filter:
echo \"*.scpt filter=osa\" >> .gitattributes\nNow the files can be added to git:
\n\ngit add .gitattributes my_script.scpt\ngit commit -m Initial\nNow let’s change the script by appending & \", I like your name\" to the say command in the my-script.scpt file. Don’t forget to save.
Now when you run git diff, you can see the changes you made as you would with text-files. You don’t need to stick with the command-line: I can confirm it works with GitHub Desktop. It should also work with other GUI’s, but I haven’t tested this.
The program is called osagitfilter, so you can also add JavaScript .scpt-files. There is also a feature that prevents you from accidently adding AppleScript-debugger files to git (a special file format used by the indispensible Script Debugger).
I hope osagitfilter will be useful tool. It will not completely replace the first two methods, but it’s nice to have an alternative to them.
\n\nLet me know what you think on twitter or at this thread on Late Night Software’s AppleScript forum.
\n\n", "summary": "There are currently two ways of putting AppleScript into git. First is just by adding the binary .scpt-files. You don’t get much benefit from using git, but it works.", "date_published": "2019-05-06T00:00:00+02:00", "tags": [] }, { "id": "/2019/03/08/Git-Url", "url": "https://blog.zanstra.com/2019/03/08/Git-Url.html", "title": "git-url", "content_html": "A while ago, I created a shell script called git-url. It prints the remote origin URL of your current git-repository (or exit 1 if no git-repo is found). If the URL is in git: format, it is converted to http: format.
Why would one write this? Because of open `git-url`.
This will open the GitHub- or BitBucket-repository in your favorite browser. I use it all the time!
\n\nAbove works on macOS. Windows uses start instead of open, but I don’t know how it works with Windows Subsystem for Linux.
Updated 2019-12-04: you now can add a SHA1 hash to go directly to that commit in the browser (GitHub and BitBucket) like\nopen `git-url 7593e1a`, which opens this link).
This summer I went to Ecolonie, a very nice place in France. It is an idealistic place that doesn’t want to exclude anyone.\nSo they don’t allow digital wireless connections like Wifi and Bluetooth, because this can make some people sick.
\n\nSo I thought of connecting my iPad via Ethernet to internet.\nI’m not the first one to try this, but I wanted to share my experiences.\nI first bought the Apple Lightning to USB 3 camera adapter (you can get cheaper clones, but non-Apple periferals can suffer from some kind of compatiblity issue).\nNext was a powered USB hub from the Aukey, which already has an ethernet LAN adapter build in!\nSo there’s no need to buy an external USB Ethernet Adapter.
\n\nThis setup works (almost) perfectly with both iPhone 5 (iOS 10.3.3), iPhone SE and iPad Air 2 (both iOS 11.4.1).\nI didn’t test my original iPad, since I don’t have a camera adapter with a dock connector.
\n\nWhen connecting the setup, you’ll get an entry between Wifi and Bluetooth in the settings menu, where you can check your TCP/IP settings.\nWhen I plugged in my Apple USB Ethernet Adapter, the Ethernet menu shows two adapters (also one for the build-in Aukey ethernet).\nLike in macOS, it will prioritize the adapters automatically and choose the “best” one.\nI performed some speed tests, and I didn’t find significant differences between Wifi and Ethernet.
\n\nI found one downside which stops it from working perfectly. I switch on Airplane Mode to make sure no digital wireless signals were emitted.\nHowever, in that case for almost every app you open, you’ll get a warning to switch off Airplane Mode.\nLuckily these warnings can be dismissed without any problems, and bytes will happily flow between your device and the internet.
\n\nOther findings: I charged by iPad via a cable between the lightning connector in the Camera Adapter and the fast-charge port in the USB hub.\nThis caused noise on the speaker I had connected to the iPad via the 3½mm audio jack.\nThe noise disappeared when removing the charging cable from the USB hub and did not return when connecting to iPad’s charging adapter.
\n\nOne final note on USB Ethernet adapters: naturally they have built-in MAC-addresses. But you can expect some complications on your network when you use a MAC-addresses to identify all allowed devices.\nDevices, like in Lisa’s tablet and Bart’s iPhone… D’oh!
\n\n", "summary": "This summer I went to Ecolonie, a very nice place in France. It is an idealistic place that doesn’t want to exclude anyone.So they don’t allow digital wireless connections like Wifi and Bluetooth, because this can make some people sick.", "date_published": "2018-12-31T00:00:00+01:00", "tags": ["does-it-work"] }, { "id": "/2018/09/13/Jump-around", "url": "https://blog.zanstra.com/2018/09/13/Jump-around.html", "title": "Jump around", "content_html": "There are more ways to navigate the file system in bash than I imagined when I still was using cmd.exe. Let me name some:
\n\ncd navigates to the home folder. Like cd /users/$(whoami) or cd \"$HOME\" but shorter.cd - navigates to the previous directory. It’s like the zap-button on your television remote control!cd ~/Doc␉ tab-completion works like Visual Studio’s intelli-sense, but without the dropdown and it’s case sensitive. If there is one choice, it will complete it. If there is more, you need to press tab twice, and it will show a list.pushd/popd/dirs save/load/show a directory to/from the stack. Especially handy in complex scripts.However, I noticed I was always navigating to not that many different number of folders. I thought, wouldn’t it be handy if one could save/load folders to some kind of dictionary. I did extensive research and couldn’t find anything, so I created go. It was great. Typing go gh performed cd ~/prj/GitHub. To save the current folder under the name “here” would be performed by go here .. And go would show all the current stored definitions.
As I mentioned before, I performed thorough extensive research. I didn’t take it lightly. However. Apperently, the subject sometimes needs time to sink in. As today I learned from a guy I have known some time, that he created a tool called markjump. This is basically what I made, only for powershell. But his work was inspired by Jeroen Janssens’ shell script, from five years ago. And he’s a Dutchie too! How could I have missed that? And his code is 1500% better!
\n\nTo complete my story line: Half a year ago I ran into the z-utility (can’t remember how), which has the description jump around. I was intrigued! I learnt descriptions of utilities are pretty important. And it turns out to be a pretty clever and helpful utility. It automatically remembers where you navigate to; no need to keep a list manually. And it will also keep statistics.
\n\nIt uses regular expressions to find which folder you want to navigate to. And it’s case-insensitive, so z dow will navigate to ~/Downloads. No need to type a capital-D. When the regular expression matches multiple folders, it uses the statistics (how recent and how frequent) to decide where to navigate to.
I must say I was a bit hesitant to use it, because it seemed so… technical. In the beginning of the man-page it says something like “Tracks your most used directories, based on ‘frecency’..” But the “jump around” reeled me in. I never used my own go-utility, and only just now looked back. Thanks rupa!
The following entries are supposedly missing from emojis.wiki. However, you could also read this article as a proposal for alternate descriptions of a part of the Miscellaneous Technical range of the Basic Multilingual Plane of the Unicode standard.
\n\n\n\nIf you have any corrections or addendums, please let me know on Twitter.
\n\n", "summary": "The following entries are supposedly missing from emojis.wiki. However, you could also read this article as a proposal for alternate descriptions of a part of the Miscellaneous Technical range of the Basic Multilingual Plane of the Unicode standard.", "date_published": "2018-08-28T00:00:00+02:00", "tags": [] }, { "id": "/2018/07/08/Vowel-case", "url": "https://blog.zanstra.com/2018/07/08/Vowel-case.html", "title": "To vowel case", "content_html": "There already was Sentence case, lower case, UPPER CASE, Capitalized Case, AlTeRnAtInG CaSe and Title Case.
\n\nAnd nOw YOU cAn dO vOwEr cAsE tOO!
\n\nfunction toVowelCase(text) {\n return text.toLowerCase().replace(/[aeiouy]+/g, match => match.toUpperCase());\n}\nUpdated: a correct implementation of toVowelCase is locale-dependend. In English, the letter y is sometimes a vowel, and at other times a consonant. The above works for the Dutch language and some other languages. Your mileage may vary.
Updated: bookmarking https://headlinecapitalization.com and https://titlecaseconverter.com.
\n", "summary": "There already was Sentence case, lower case, UPPER CASE, Capitalized Case, AlTeRnAtInG CaSe and Title Case.", "date_published": "2018-07-08T00:00:00+02:00", "tags": ["one-liner"] }, { "id": "/2018/06/29/Refactoring", "url": "https://blog.zanstra.com/2018/06/29/Refactoring.html", "title": "To refactor, or not to refactor", "content_html": "The code iteration below is a contemporary comment on the use of refactoring.
\nWe start with this code:
function isLeapYear(year) {\n if (year % 4) {\n return false;\n } else {\n if (year % 100) {\n return true;\n } else {\n if (year % 400)\n return false;\n else return true;\n }\n }\n}\nAll code has to be unit tested, so we write this (normally I start with this before writing actual code, but you know…):
\n\nfunction unitTests() {\n describe(\"leapYear tests\", function() {\n expect(isLeapYear(1900)).toBe(false);\n expect(isLeapYear(1971)).toBe(false);\n expect(isLeapYear(1972)).toBe(true);\n expect(isLeapYear(2000)).toBe(true);\n expect(isLeapYear(2003)).toBe(false);\n });\n}\nAnd to stay very agile, I wrote some minimal unit testing “library” (individuals over tools, anyone?):
\n\nfunction describe(testName, tests) {\n var groupTitle = 'Name: '+testName+' - Start: '+(new Date).toISOString();\n console.group(groupTitle);\n expect.nr = 0;\n expect.errors = 0;\n tests();\n if (expect.errors == 0) console.info('All %s tests OK', expect.nr);\n else console.error('%s of %s tests failed', expect.errors, expect.nr);\n console.groupEnd(groupTitle);\n}\n\nfunction expect(x) {\n return {\n toBe: function(y) {\n if (x === y) console.info(\"%s: OK 👍\", expect.nr++);\n else console.error(\"%s: Error 👹\", expect.nr++), expect.errors++;\n }\n };\n}\nThe unit tests all passed. Can’t wait to start with refactor step 1: removing unnecessary nesting. One step at a time.
\n\nfunction isLeapYear(year) {\n if (year % 4) {\n return false;\n }\n if (year % 100) {\n return true;\n }\n if (year % 400) {\n return false;\n }\n return true;\n}\nYes…, much better! All tests pass. Refactor step 2, fold down into one if:
\n\nfunction isLeapYear(year) {\n if (year % 4 || (!(year % 100) && year % 400)) {\n return false;\n }\n return true;\n}\nAnd for the heck of it, remove the unnecessary if as well:
\n\nfunction isLeapYear(year) {\n return !(year % 4 || (!(year % 100) && year % 4000));\n}\nOopsy. The fourth test failed. Just a typo, no worries. And since there’s already too much negativity around, I’ll fix that in the next iteration, and while we are at it, move the negation to another function.
\n\nfunction isLeapYear(year) {\n return !isCommonYear(year);\n}\nfunction isCommonYear(year) {\n return year % 4 || (!(year % 100) && year % 400);\n}\nThe committee unanimously decided: don’t rely on javascript’s truthiness, we want explicit code! So fixing that:
\n\nfunction isLeapYear(year) {\n return !isCommonYear(year);\n}\nfunction isCommonYear(year) {\n return year % 4 != 0 || (!(year % 100 != 0) && year % 400 != 0);\n}\nRefactor step 6, the overload of negativity was back. Fixing:
\n\nfunction isLeapYear(year) {\n return !isCommonYear(year);\n}\nfunction isCommonYear(year) {\n return year % 4 != 0 || (year % 100 == 0 && year % 400 != 0);\n}\nRefactor step 7 should be a charm. I still don’t like the code at all, so f$*# it, just use the native function:
\n\nfunction isLeapYear(year) {\n return new Date(year, 2 - 1, 29).getDate() == 29;\n}\nDone!
\n\nCode can also be found here on GitHub.
\n\n", "summary": "The code iteration below is a contemporary comment on the use of refactoring.We start with this code:", "date_published": "2018-06-29T00:00:00+02:00", "tags": ["refactor"] }, { "id": "/2017/05/19/JSON-feed", "url": "https://blog.zanstra.com/2017/05/19/JSON-feed.html", "title": "Jekyll template for JSON Feed", "content_html": "When I learned about JSON Feed, I immediately liked the idea. It’s like RSS/Atom, with the good parts (it’s de-central) and without the bad parts (no more XML, well thought of standard attributes).
\n\nI’m not to sure how it will be used in practise, but it was easy enough to create a Jekyll template (source on GitHub). I learned it’s handy to add a base-tag to the content_html-attribute, after trying this app.
And I made myself a nice square logo too.
\n\n", "summary": "When I learned about JSON Feed, I immediately liked the idea. It’s like RSS/Atom, with the good parts (it’s de-central) and without the bad parts (no more XML, well thought of standard attributes).", "date_published": "2017-05-19T00:00:00+02:00", "tags": ["meta"] }, { "id": "/2017/05/14/JSON-the-game-nr2", "url": "https://blog.zanstra.com/2017/05/14/JSON-the-game-nr2.html", "title": "JSON, the game #2: The parsings", "content_html": "For some reason, I imagined the next step in the development of the game was to make the ‘block’ move. Like up and down, and sliding to the left. For agile reasons, I want to make progress that is reflected and visible in the software. So no spending time at writing libraries first. You probably end up writing stuff you don’t even need. But when starting, I realized the partial-JSON part needed to be worked on first.
\n\nTo display the partial-JSON, I need a model of that JSON. That model should be capable of annotating the partial-JSON with grammar issues (like missing bracket/comma, incomplete strings or just plain errors). Indentation should be addressed too. Also some dimension-data is needed, so we can determine whether the block can move up/down and when it has reached the partial-JSON surface (sorry, I can’t stop thinking in planet metaphors).
\n\nWhen pondering on these requirements, I realized a tokenizer/parser was necessary. A library! Not very agile, right? Perhaps skipping the grammar issues first and add it later would have been a wiser choice. We will never know. Writing a parser does takes some time, but it sure is fun.
\n\nFirst I started writing a tokenizer. And since it’s not your average code, I used the most annoying coding convention I could think of. I learned this style with Turbo Pascal in my BBS days. Years later I discovered you can use it with languages like JavaScript, CSS, C# and even PL/SQL. But it’s too annoying for everyday use. Not only do you get The Eye from your colleagues; every editor I’ve tried actively works against you by messing up the indentation. Again, and again. With. Every. Single. Edit.
\n\nThe tokenizer splits the JSON into tokens like a string, boolean value or comma. With the parser we then can reason about tokens instead of characters, which makes life much simpler. Because we work with partial JSON, the tokenizer is made to recognizes unfinished strings and other values. Every token has an is_complete-attribute, so when rendering we can show if a brace is missing, or a string is unfinished.
![\"HTML/CSS](\"/images/json-state-machine.jpg\" "\\"HTML/CSS")
The parser was a dragon to me. I made a lot of diagrams to create a state machine, see above, and played with GraphViz (which is pretty cool, and a little weird). Finally I thought the state machine was right, and started coding. After writing some unit tests and identifying some failures, I did realize I went in the wrong direction. A state machine is apparently not the best solution to parse JSON and the answer was right in front of me. While I was focussing on the nice flow diagram at json.org (which I coincidently also knew from the Turbo Pascal manual; I know, grandpa speaking), the program I needed to write was listed as an inset on the right of that same web page! object := {} | { members }… Elementary, dear Watson…
A well, adventures in failure. Start all over, and everything will be fine. At the moment, I have a validating parser (source here). It says whether the JSON is correct or not. There are still loose ends, which I will fix when needed. For example, I ignored Unicode for a big part and focussed on ASCII for now.
\n\nOn a side note: I also wanted to check out those new EcmaScript 2016 features, since every browser seems to be supporting them. It’s nice to see the language is evolving, after multiple timespans of stagnation. The best feature IMHO is string interpolation.
\n\nNext step is adding code to the parser for annotating tokens, and insert missing-tokens. And render the thing in HTML naturally.
Around a year ago, I had the daft idea to create some nerdy JSON-game. I had good fun thinking about some concepts, made some notes, and that was about it. Until now that is. The game: It’s coming… It has already started. To keep me focussed, I will keep a journal of the creation, and you’re reading the first part.
\n\nI got the ideas from series like the Brent Simmons’s Vesper Sync Diary and Jon Skeet’s Reimplementing Linq to Objects. I found them enjoyable; a bit of a nerdy soap opera. And now is the time for me to get of my comfy sofa and produce some soap of my own.
\n\nThe idea of the game: JSON tokens are coming in, and you need to place them correctly. The initial form of the game will be Tetris-like with your head on your right shoulder: the tokens come in from the right and go to the left (alternative gravity you can think). However, this form might change from level to level (I’m thinking of the partial JSON document as a starship, crashing into JSON stars/tokens as it cruises through the JSON universe).
\n\nThe first step is to create some user interface mockup. A guy gotta start somewhere. My weapon of choice is HTML/CSS. At the top we have a dashboard providing some game details. Unformatted JSON will do for now. The playing field (where the partial JSON is) will have a fixed width, while the height might grow during gameplay when tokens are inserted between lines.
\n\n![\"HTML/CSS](\"/images/json-html-mock.png\" "\\"HTML/CSS")
Positioning is done with the em and ch CSS units with a position relative/absolute container-combo, so I can position things absolute within the relative container. Every character is one ch and every line is one em. One little problem though: em is font-height, not line-height. And a line-height of 100% just doesn’t look right. But there is no such thing as a line-height unit. (Or is there?) This is easy fixable with a calculation, but line-height will appear in multiple places in CSS.
Also some color coding needs to be added, so we can identify unbalanced grouping tokens, missing separators, incomplete tokens and downright errors. That’s why I’m not using a pre-element. I don’t have a definite idea about gameplay, but some ideas come to mind. An obvious solution for an error would be “Game over”. This can also be postponed by counting “lives”. The error will vanish and you loose a life. Or an error could be cleared with the incoming JSON token \\b. That choice will depend on the level. But I digress.
This is not all markup we need (we will need a dialog-box, for the start and end of a level), but it will do for now. I put the source-code on GitHub, and every instalment will point to a commit so you can see how this game comes to shape. You can also “run” the game here (nothing to play for now).
\n\nI hope to find a good balance between enjoyability, a bit of fun and some technical remarks. And I like to hear your thoughts on Twitter.
\n\nThe next instalment will be about moving those incoming tokens.
\n\n", "summary": "Around a year ago, I had the daft idea to create some nerdy JSON-game. I had good fun thinking about some concepts, made some notes, and that was about it. Until now that is. The game: It’s coming… It has already started. To keep me focussed, I will keep a journal of the creation, and you’re reading the first part.", "date_published": "2017-04-30T00:00:00+02:00", "tags": ["game"] }, { "id": "/2016/09/08/Only-my-warnings", "url": "https://blog.zanstra.com/2016/09/08/Only-my-warnings.html", "title": "Only my warnings", "content_html": "Don’t you hate to be put in a situation like the following?
\n\n\n\n\nYou are assigned by your company to add some functionality to some software at\nsome client. The client has standards and practices in place stating you can’t checkin code that produces warnings, only to find\nout that a clean checkout produces loads of warnings when building!
\n\nBut you can’t fix 😢 those warnings. You, the super star programmer™ (whose boss is getting\npaid big dollars for high quality, virtually bug-free software), cannot get rid of those pesky lines of inability…
\n\nFor starters, why judge those warnings in the first place. You’re just the new guy, you don’t want to get into any trouble. Also, \nby solving warnings, you may introduce new bugs (even though you’re super competent, after all creating bugs is just a matter of probability). \nNobody wants that! And finally, you’re a professional. The client is only paying for the new functionality, not for you to clean\nup the place. And about your collegues, you don’t want to hurt anyones feelings. \nSo in short: the man says no. No way fixing those warnings, José!
\n
Situations like these inspired us to envision a new kind of solution to those issues at hand. Let me introduce to you, without further ado, the Visual Studio extension Only My Warnings.
\n\nWhen your solution is under source control a new list button is added to the Error List pane, with the options All, Only Mine and Local Only. \nWith the option Local Only selected, the pane will only show errors, warnings and messages caused by local changes, i.e. by you!\nAll other messages are hidden, so you don’t have to deal with them. Victory!
\n\n![\"screen](\"/images/Only-my-warnings_error-list.png\" "\\"Error")
The extension doesn’t get in the way; it only adds this one list button.\nWhen selecting Only Mine-option, the tool will gather all messages from your checkins, and show only the messages caused by you. \nAnd it follows branches, so you can focus at the feature that is imporant at any given moment.
\n\nNow you can be productive, and still have a chat with your collegues without having an argument! While using this extension, you\nwill contribute to your team’s productivity. You will be a team productivity enabler! That’s how 10× developers are bred!\nIn a way, only my warnings contributes to world peace.
\n\nFor now, the extension is still in its early alpha phase. If you want to participate in the beta-program, or want to get notified\nwhen the extention will be released to the Visual Studio Gallery, please \nfill out this form.
\n\n(this is a blog post in the series: I’m perfect, communicate better with tools)
\n", "summary": "Don’t you hate to be put in a situation like the following?", "date_published": "2016-09-08T00:00:00+02:00", "tags": ["tools"] }, { "id": "/2016/03/06/Console-log-adventure", "url": "https://blog.zanstra.com/2016/03/06/Console-log-adventure.html", "title": "A console.log() adventure; pimped", "content_html": "Over a year ago, my interwebfriend secretGeek created a thing. I created a fork, and pimped it into this (and copied some of his blog lines too). I urge you to go and try it out before you read on. Unfortunately you’ll need to be on a desktop computer, not a mobile phone.
\n\n![](\"/images/console_best.png\" "\\"a")
In case you don’t have a desktop computer anymore (woah, futuristic!), or have already tried it out, I’ll give some spoilers and discussion now.
\n\nActually, I’ll give some space before the spoilers. Scroll now for spoilers.
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\n↓ spoilers ahead ↓
\n\nHere is secretGeek’s blog-entry. When playing the game I had loads of fun. \nKeeping a map on graph paper, just to make sure the map is deterministic and doesn’t use some random numbers. \nAfter some more playing, I started looking at the code and wanted to tinker with it. So I forked it. I had some wild and interesting ideas.
\n\nBut somehow, nothing happened.
\n\nI guess I was overthinking it. A year later, I remembered one time at work while being bored, I created the so called mini-webventure. I didn’t think too much back then, so why do it now?
\n\nSo I just started. After running around in the forest (in the game, that is), I got tired of entering parenthesis. And with \nproperties around in all browsers nowadays, there’s no need for it. So instead of typing n(), you now can enter n to go north.
An other thing: in a JavaScript game, I don’t consider inspecting and modifying variables cheating.\nSo I prevented that with an iife and some help of strict mode (to eliminate global variables).
\n\nMultiple lines are now returned after entering a command, so they are displayed in the same font and color. And deaths \nare a bit more dramatic now. You should really try it, if you haven’t already…
\n\nAfter dying too often, implementing load/save was next. First I just saved the game state, but then I realized\nthis was another way to cheat, so now only the entered commands are stored. Then I realized, a demo-mode\nis very easy to implement. Couldn’t resist it, but it’s hidden somewhere in the game.
\n\nI didn’t want to change the map or story. Just wanted to share the fun I had, both playing and pimping the game.
\n\n", "summary": "Over a year ago, my interwebfriend secretGeek created a thing. I created a fork, and pimped it into this (and copied some of his blog lines too). I urge you to go and try it out before you read on. Unfortunately you’ll need to be on a desktop computer, not a mobile phone.", "date_published": "2016-03-06T13:45:00+01:00", "tags": ["refactor","game"] }, { "id": "/2016/01/09/First-post", "url": "https://blog.zanstra.com/2016/01/09/First-post.html", "title": "First post!", "content_html": "OK, I started yet another blog.
\n\nHere are the predecessors (and thank my public backup service for most of this):
\n\nI also have a Tumblr micro-blogging thing called dd3v, and I used to have a micro blogging service on doekman.micro.blog backed via Kickstarter (png archive or PDF print).
\n", "summary": "OK, I started yet another blog.", "date_published": "2016-01-09T20:30:00+01:00", "tags": ["meta"] } ] }![png archive](\"/images/archive/doekman.micro.blog.png\"){kind=link}