>vs slavchev's cyberspace

Previous: part 2, scanning the key matrix and fixing ghosting.

If I wanted to rebind a key on my custom keyboard I needed to reprogram it: open the keyboard case, connect with a cable, edit the firmware source, compile, and flash the board. But when I made two keyboards for friends they wanted to rebind some keys too, and that was a problem. I imagined having a nice UI for the task and making it even a fun experience. There is something special in taking care of your comfort and knowing that a minor improvement will pay off in the long run.

The solution also needed to be wireless and since the keyboard was already using BLE I only had to extend it. But first I had to learn how it really works. The way devices find each other is through advertising: a peripheral (the keyboard) repeatedly broadcasts small packets saying it exists. A central (the PC) scans for these packets and can initiate a connection. Once connected, both sides stop advertising and communicate through a client-server model called GATT (Generic Attribute Profile).

GATT structures data as characteristics contained inside services. A service groups related functionality, and each characteristic in it is a value that can be read, written, or subscribed to for notifications. A keyboard exposes a standard HID (Human Interface Device) service. At connect time the PC reads a report descriptor that tells it the shape of the data — in this case an 8-byte struct: one byte for modifier keys (Ctrl, Shift, Alt, GUI), one reserved byte, and six slots for simultaneously held key HID codes. Every time a key is pressed or released the keyboard sends an updated report via a GATT notification and the PC translates it into key events.

The ESP32 microcontroller has BLE built in and the Arduino BLE library provides all the GATT plumbing. The keyboard object sets up a BLEHIDDevice with the standard keyboard report descriptor. When a key is pressed the firmware resolves the physical position through a matrix scan, looks up the keycode in the active layout level, and calls keyboard.press(keycode) which updates the 8-byte report and notifies the host.

The key rebinding part is a second BLE service sitting alongside the HID one. It has three characteristics:

• A readable characteristic that returns the current layout as 192 bytes (2 layers × 4 rows × 12 keys × 2 bytes per key — one for the keycode, one for an optional modifier).
• A writable data characteristic that accepts chunks of new layout bytes, so the whole layout can be sent in small BLE packets.
• A writable control characteristic that accepts commands: enter config mode (pauses HID output), commit (applies and saves the received layout), or exit (cancels and resumes normal typing).

Another technology I wanted to learn about was the NVS (Non-Volatile Storage). The layout is persisted in the ESP32's NVS, a key-value flash store that survives power cycles. So on boot the firmware reads the stored layout and validates it with a simple XOR checksum before applying it. If the checksum fails — for example after a firmware update that changes the layout size — the default layout is used instead.

Security is worth thinking about for this new keyboard setup because we don't want someone to change our keys. Normally BLE keyboards are open to pairing from any device in range. For our case: to pair a new device you have to physically hold a four-key combo on the leftmost column at the same time. While the combo is held the firmware opens advertising to all, the LEDs stay on as a visual indicator, and keypresses from the combo keys are suppressed so nothing reaches the PC. A reconnect from a paired device works normally without any combo.

The web app that handles rebinding connects using the Web Bluetooth API, which lets a browser act as a BLE central directly — no native app or driver needed. The browser's navigator.bluetooth.requestDevice() shows the system Bluetooth picker filtered to devices advertising the config service UUID. After connecting, the app reads the full current layout from the keyboard, renders it as a 4×12 grid with one button per key, and lets you click any key to open a picker with all available keys. When you hit save the app sends an enter-config command, streams the 192-byte layout in 18-byte chunks, and finishes with a commit command. The keyboard applies the new mapping immediately and writes it to flash. The web app only works in Chromium-based browsers since Firefox and Safari have not implemented the Web Bluetooth spec.

The result is a keyboard that can be configured wirelessly with a webapp: check it out!

References:

• Web Bluetooth Community Group. "Web Bluetooth specification." Accessed 5 May, 2026. https://webbluetoothcg.github.io/web-bluetooth/
• Espressif. "ESP32 Non-Volatile Storage Library." Accessed 5 May, 2026. https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/storage/nvs_flash.html

permalink

Single-table design is a way to model your data so that all your entities and their relationships are in a single table in DynamoDB. This allows querying data in a single request and avoiding joins as they are not supported by DynamoDB, and has other cost and performance benefits.

To find an object in DB we need to query it using both its PK (partition key) and SK (sort key).
PK: "USER#123"
SK: "USER#123"
We must specify a sort key, so here both keys have the same value. This is the case for simple entities only. The id of the user is prepended by the type of entity and a '#' to delimit them.

Now if we want to specify the relation that a user can have a house, we can do that in the same table like so:
PK: "USER#123"
SK: "HOUSE#456"

This enables us to find the house if we know both user id and house id. Also to find all houses owned by the user only using their id:
query conditions: PK = "USER#123" and SK beginsWith "HOUSE#"

We can expand the house entry to contain info on the state of the house:
PK: "USER#123"
SK: "HOUSE#IN_CONSTRUCTION#456"
This way we can query all houses of this user, or only those in a specific state.
query conditions: PK = "USER#123" and SK beginsWith "HOUSE#FINISHED#"
This stacking can be done multiple times to allow range queries on different attributes. A drawback here is that to get a house by user id and house id, we also need to know its state. This is why we need to know our access patterns before making the schema.

Another technique to allow flexibility of queries is adding more indexes. DynamoDB supports multiple GSIs (global secondary indexes) per table. For example:
GSI1 PK: "CITY#Sofia"
GSI1 SK: "HOUSE#456"
We can now query all houses in a city without knowing the user id. The index stores its own copy of every item it contains, so it takes up extra storage. Which fields are copied (projected) is chosen when the index is created: only the PK and SK, a selection of fields, or all of them.

GSI overloading is a trick to serve more access patterns than you have global secondary indexes for, or than the per-table limit allows. It's good practice to keep the GSIs to a minimum to save on storage and write costs. We can do this by using the same GSI with a different PK and SK for each entity.

To demonstrate this design process we can go through the steps as I did for SpeedCook. The entities are:

• Users
• Recipes
• Unlocked recipes
• Cooked meals

And the properties and relations they have:

• Recipes have details
• Users have details
• User has many unlocked recipes
• User has many cooked meals

The rough functionality we want is:

• CRUD users and recipes
• Unlock recipe for user
• List unlocked recipes for user
• Record cooked meals and see their history

Based on the above we need to come up with the access patterns for each entity:

• User
  • Get user profile
• Recipe
  • Get single recipe
  • Get all recipes that can be cooked: open + unlocked
  • Get all locked recipes in a dietary category when choosing what to unlock
• Unlocked recipe
  • Unlock a locked recipe (unique, only once for a single user)
  • Get all unlocked recipes for user
• Cooked meal
  • Complete a cooking of a recipe by a user, non-unique - a user can cook the same recipe multiple times
  • See history of completed meals

Now we have everything we need to specify our schema. For each access pattern we specify if it reads or writes or both, if the target is the main index or a global secondary one, what is the query and a note on how it will be used:

References:

• Dynobase. “DynamoDB single table design made easy.” Accessed 25 Sept, 2024. https://dynobase.dev/dynamodb-single-table-design-tool
• AWS. “Data modelling foundations in DynamoDB.” Accessed 25 Sept, 2024. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/data-modeling-foundations.html
• AWS. “Best practices for using sort keys to organize data in DynamoDB.” Accessed 25 Sept, 2024. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-sort-keys.html

permalink

Run the animation again

A nice looking effect can be achieved by gradually drawing a SVG. You can do this for an icon or some text that is made out of paths.

SVG files are just XML so you can use a SVG editor to make the paths and open the file with a text editor. When copying the tags to your HTML you should check if the code is also valid HTML, maybe you need to close the tags or delete some attributes.

You can fit this to your needs by having it also draw backwards by reducing the length that is overwritten each tick on the strokeDasharray. You can have this run when the page opens or an element is hovered or a menu text/icon is rendered.

/* original idea from: https://stackoverflow.com/a/14282391 by https://stackoverflow.com/users/405017/phrogz */

var percentageChangePerTick = 0.01;
var drawFPS = 60;

var paths = document.querySelectorAll('path.animatable');
var timer;

function startDrawingPath(){
  for (var i = 0; i < paths.length; i++) {
    paths[i].style.stroke = '#00FF66';
    paths[i].style.strokeDasharray = 0;
  }
  clearInterval(timer);
  increaseLength();
  timer = setInterval(increaseLength,1000/drawFPS);
}

function increaseLength(){
  var finished = true;
  for (var i = 0; i < paths.length; i++) {
    var totalPathLength = paths[i].getTotalLength();
    var currentLength = parseFloat(paths[i].style.strokeDasharray.split(",")[0]);
    var newLength = currentLength + (percentageChangePerTick * totalPathLength);
    paths[i].style.strokeDasharray = [newLength, totalPathLength].join(' ');
    if (newLength <= totalPathLength) {
      finished = false;
    }
  }
  if (finished) {
    clearInterval(timer);
  }
}

permalink

Learning words in a new language is best done when connecting the concept of something directly to the word in the new language - as opposed to mapping the new word to the one in your mother tongue which is in turn mapped to the concept.

To help you and me form the habit of directly mapping the new word to the concept, I will show an example with words that makes this approach a necessity: the pronouns in the German language. German has multiple uses for 'sie' and in English we say 'you' for many different cases, so this mismatch and repeatedly using the same word for different meanings is a good example.

So first let's imagine or visualise the concepts:

sources:
https://en.wikibooks.org/wiki/German/Grammar/Pronouns
https://german.stackexchange.com/a/48144

permalink

In the time of high attention to AI and data science we talk about the high value of data and how large amounts of it are precious. Governments try to regulate how it is collected, shared and protected. But do you know who are the fathers of information science?

I stumbled upon this wikipedia article of a Belgian who lived in the 19th and 20th centuries. The article had only 1400 visitors over the last 30 days. I thought it was a pity that I had never heard of that man. His name was Paul Otlet and he wanted access to knowledge for people. His friend and colleague Henri La Fontaine was the first president of the International Peace Bureau - the world’s oldest international peace organisation, with 10 of its members having received a Nobel Peace prize - his article even less visited.

In short Otlet got fascinated by sharing information and set up a service where cards containing text were carefully curated and systematically queried. The amount of requests quickly grew in a matter of years. This is why I mentioned wikipedia earlier - it was the same idea - just in 1896, and much slower. It was meant to be easy to use for searching information and used a concept similar to hyperlinks.

The government of Belgium gave him buildings and budget to expand his efforts. But then the Great War started, where one of his sons lost his life. Otlet believed that forming an international organisation that promotes knowledge sharing can prevent future wars and he defined a charter of human rights.

I felt strange that the information about this man is not more well known. And it makes me think not about the man, but about the relationship we as a civilisation have with information. Its value over the centuries and our desire to ask for it and use it.

Another thing I found interesting is that he was not stuck in his ways and beliefs. When new tech like radio and microfilm came up he started incorporating it in his efforts. I can imagine how someone else would have seen these new changes as a threat.

He did also have dreams of building a utopian city that would be the center of the knowledge of the world, but despite never being even started he still worked on what he believed for the rest of his life.

References:

• Britannica. "Paul Otlet". Accessed 22 Feb, 2025. https://www.britannica.com/biography/Paul-Otlet

permalink

Previous: part 1, planning a handwired, 3D-printed keyboard.

Because we don't have enough inputs on the Arduino we can implement a key matrix to detect which keys are pressed. This way the number of inputs needed is the number of columns plus rows.

The way it works is that we send a signal on one row and check which columns receive it. Then check the next row the same way.

The basic idea of the matrix scanning:

There is the problem called ghosting - keys which are not really pressed register as being pressed. Using diodes we can prevent the effect.

Here is how it happens when diodes are not present:

As you can see the right column does receive a signal when it is the top row's turn to send it, because the signal goes through the top-left pressed key to the left column, then through the bottom-left key to the bottom row, and then through the bottom-right key to the right column. That means that the top right switch is registered as pressed, but it's not.

And here is the same scenario, but with diodes:

It is a good idea to test by soldering using very little tin - just enough to hold on, instead of trying to fiddle with holding them in place.

I decided to switch the wiring from the blogs I read - my rows are connected directly and columns use diodes

You can use this jewelry making pliers to make little loops that can go onto the switch legs or the wires.

The next problem to solve is debouncing - detecting that a key is pressed and released many times in a short time, while in fact the key is only being pressed or released, but the contact between the metal plates in the switch is not really solid while in the process of moving. After doing the research I found there are hardware and software ways to solve this problem. The hardware one is with capacitors, but that makes it more of a hassle for me. There are multiple ways to solve it with software:

• waiting for a certain amount of time over which no change happens - this way we can be sure that the state is stable and we can read this as the current situation - this is slower, but might not be noticeable
• detecting the first change and registering that one, then ignoring changes for some time and checking the state after this time - this is per key and is making the decision faster than the previous one
• only checking for changes every 50 milliseconds, for example - this is fast and easy to do, but is on all keys
• track the state over time and accumulate the values to calculate to which extreme it is more close - this is not fast and might not be very robust without tuning

My first approach is to do it the simple way and put more effort when those results become unsatisfactory for my needs. So I will only check the state of all keys every 25 milliseconds.

The next thing to do is make a layout for our keys. I decided to have preprocessor macros that map a readable name to a keycode of type byte. I can send these bytes to the receiving host without mapping them. The key names I can use to initialize a 2D array which will represent how I want my keys to be ordered. When I know the position of a pressed key in terms of row and column I can then access the resulting keycode through the array.

Later on this could become a 3D array when we need to have multiple layouts.

Next: part 3, rebinding keys wirelessly over BLE.

permalink

A colleague of mine has a fancy keyboard - the OLKB Planck. It is sold as a DIY kit that you assemble and program yourself. I was unsure how I feel about it when I first saw it. But his explanations quickly got me fascinated and I decided to make my own - even more DIY style. I would 3D print everything and make some improvements like bluetooth. Another problem he had with his was the lack of a way to indicate on which layout level you are. And maybe a gesture sensor to swipe with. And maybe a gyroscope to use it like a mouse or driving wheel.

First I decided to go simple and just make a keyboard without bluetooth or anything fancy. Then learn from the mistakes and improve to make a second one that is closer to the real goal.

I ordered cheap switches and a pcb to make the process easier. At this point I thought that a big step of this project will be coming up with a good layout for my needs. Also because I take key bindings too seriously.

I found 3D models from the original designer and decided to print them. I also found a model of a keycap and modified it to make it printable without much support and add a bump for the index fingers. The keycaps turned out not fitting the switches, so I had to rework them a few more times.

The 3D models can be found here on my github.

The pcb was not fitting the models I found and was not very happy with them anyway, and they were not designed to be 3D printed to start with. I started planning how could I make a case that does not use bolts and nuts.

I printed a few simple clips to see if I could use those. Some of them I printed improperly, some were very stiff and I struggled to design better ones. I realised something very important then: instead of going for a perfect solution I should have gone for a satisfactory one and improve when needed.

I immediately made a few simple holes in a new top half model and found some M3 and M2 12mm bolts. After that I started designing a new bottom case, but adjusting its height would have to wait.

Another problem was that I damaged or bricked the PCB so I also had to start again with that. The big problem was that I had soldered the switches onto the PCB, so I had to unsolder them one by one. It cost me 4 hours and a few burns to do that. But I did learn to do less ambitious planning upfront. I will never forget this lesson because fixing broken switches is one of the most tedious and fiddly things I’ve ever done.

The next step was to figure out how to use an Arduino for the keyboard: I could flash it with the QMK firmware, or write some code myself.

Detecting button presses on 48 keys with fewer than 48 pins is not straightforward. So I found a few excellent blogs on how matrix scanning works:

• https://pcbheaven.com/wikipages/How_Key_Matrices_Works/
• https://komar.blog/posts/how-to-make-a-keyboard-the-matrix/

After understanding the hardware I did some searching. First I found the matrix scanning code in a file from the Keypad library for Arduino. Then I found a file from a stenography keyboard open source project, which also did a similar job. It was very helpful to learn from this available code.

Making a keyboard without a pcb is called handwiring and I found a nice post about it: https://geekhack.org/index.php?topic=87689.0.

With the plan changed, and my student budget limits, I actually had more fun finding my way through.

Next: part 2, scanning the key matrix and fixing ghosting.

permalink

I wanted to make a murder mystery for my DnD group. When the moment came and I started preparing for the session I found there is a lot of advice, but not a lot of easy inspiration. There are a few prepared adventures, and those are not very polished or detailed. I used some of them for inspiration and a base and stole some ideas from them. Maybe you can take mine and improve it to have fun with your players.

I had planned this for a long time as I expected that one of my players would not attend at some point. Perfect opportunity to throw the characters into a pocket dimension for a one shot without advancing the main story. I gave one of them this book with empty pages and a whirlpool on the cover.

Make sure to have prepared statblocks for all the stuff they can encounter.

I was greatly inspired by the adventure called "How not to host a murder mystery"

I have not used names as I think it's easier to navigate the story with roles since we are looking at its structure and not for entertainment.

Everything starts in a whirlpool in the sea, hence the cover of the book. The characters are on a small ship with Victim heading to the city on the coast. During the whirlpool another group of adventurers (goblins?), who read another book of the same type, are summoned on the ship. Victim, Innocent and his colleagues are on the ship, and the characters are offered to stay in the Victim's mansion. They were all summoned because he found this book and wanted to figure it out so cast some spells and activated all the books. Victim introduces Innocent as his brave but foolish, quick to act apprentice.

The mansion, Victim explains was built thanks to his father's successful business of trading rapiers, short swords and daggers. His father died 6 years ago.

Garden:
Morning glory - a flower that blooms in the morning because of sunlight and its petals are closed when in shadow or darkness; a letter is hidden under the open petals in the day, but when darkness makes them close it is easy to spot. The letter is written with the same handwriting as the book of the Killer, it is to the girl of the apprentice saying that he will not give up on their love. This can be used to have the Killer try to frame Innocent.

Time before dinner: the players are invited to do something before it is time for dinner:

• With Killer and Innocent to practice spells [openly said] (so all 3 including the PC seem suspicious); Killer doesn't want to waste mana; The Innocent calls Killer by his middle-name. The other players will not know whom this name belongs when they see it.
• With sister to show you around: offers a reward a knife from the father's collection of rare craftsman knives [openly said] (so the sister and the PC sound suspicious) In private they find that one specific knife is missing from its stand - Lord Kelnor's pearl dagger
• With cook to help prepare the big dinner. [openly said]; In private he tells the motive of both Innocent and Sister. He is grumpy and very skilled with cutting meat with his knife; he says the sister has a necklace with a gem that allows her to seduce and control weak men

The players are given the information separately through notes and they should get a bit confused and suspect each other.

Dining room:
During dinner the characters can talk to Innocent, Killer, Victim's sister who is a paid assassin, the cook, the old nanny

Killer says he will go and help the cook to set up the table. Innocent says that he will go and find the host Victim because he should have been here already. He leaves the room and in a bit everyone hears him scream.

Victim is stabbed in the heart in his study. There is no weapon there. Actually the knife Killer used was conjured by Spiritual weapon.

Killer points the finger at innocent and explains his motive. Innocent explains that he had the choice to give up on his study, but made up his mind and was no longer interested in marrying the girl. Innocent has a fresh letter to her stating that he will find a way to be with her and won't give up on their love.

The real killer has to be found before sunrise otherwise the framed Innocent will be hanged.

Innocent is a young novice, brave but foolish, quick to act. Victim doesn't let Innocent marry the daughter of a blacksmith because she will distract him from his studies.

Cook - not speaking a lot / low voice / bitter

The study:
Has a book with spells (belongs to:Killer's name on the inside cover), every page has notes in the margins. Some of the notes are crossed out and with another color and handwriting more notes are taken. The second notes match the handwriting on the papers on Victim's desk. On the spell Spiritual weapon there are a lot of scribbles and in all caps: HAVE TO ASK <Killer's middle name> HOW TO CAST THIS!

Trophies on a shelf saying: First place in spellcasting/conjuring/arcana competition - Victim

Building the structure of the mystery:

• Innocent has motive and opportunity(to go bring victim), but no means
• Killer has motive(fame,praise), means(stabbing), opportunity(the fact that the apprentice and the sister now have a motive)
• Cook has means(knife with blood), no motive and no opportunity
• Sister has motive(she is younger and can inherit the mansion that she likes very much if her brother dies), but no means and no opportunity, but definitely suspicious being an assassin
• Old nanny - no motive, no means, no opportunity

permalink

Hello! Read on if you decided to switch to IntelliJ, set it up, make it comfortable and learn how to be more productive with it. This post covers some settings and custom shortcuts.

The first things that annoyed me were the popups in the top-right corner. To disable some of them: 'Event log' on the bottom-right (or Speech bubble icon) -> Settings. Disabling the balloons doesn't hide the notifications from the event log, so you can check that if you need to.

Next up is removing the default comment generated at the top of a new class file.
File -> Settings -> Editor -> File and Code Templates -> 'Includes' tab -> File header -> the comment is on the right -> delete it. If you would like to use this feature make sure to print the date in a less ambiguous format.

Another one is the vertical line in the editor that is set to 120 chars per line by default. To change the line limit:
File -> Settings -> Editor -> Code Style -> Right margin columns.
The Google Java Style Guide recommends a column limit of 100 chars.

Ok hotkeys. Some are very hard to reach, hard to learn or conflict with something else. Here are some recommendations how to make your life easier. You don't need to remove the old shortcut, so if someone else wants to use your Idea they can still use the default keys they know. Go to
File -> Settings -> Keymap
and find the ones you need to change, then click on them and select 'Add keyboard shortcut'. All of the recommended ones are unused and should be added as alternatives. For each entry I have specified: the name of the command, the default shortcut, the suggested one and an explanation.

Rename: default - Shift F6, suggested - Alt R. This default key is famous for being so hard to reach. Usage of rename should be encouraged as naming things is one of the hardest tasks in programming. Remember it as R stands for rename.

Find usage: default - Alt F7, suggested - rightAlt U. Shows you where a method/variable is used. One hand - easy. Associate U with usage.

Surround with...: default - Ctrl Alt T, suggested - Alt T. Surrounds the selected code with if/elseif/while/for/try... etc. Some Linux distros have the terminal shortcut bound to Ctrl Alt T so that causes a conflict. Even if you don't care about that the alternative is still 1 less key to press.

Delete line at caret: default - Ctrl Y, suggested - Alt X. In Eclipse it was easy to Ctrl D with one hand, but Ctrl Y requires both hands. The Alt and X keys are next to each other and this one is very easy to press. The X can be associated with double-crossing something.

Run: default - Alt Shift F10, suggested - Alt P. Usefulness depends on how often you run the project. P as in play for the green arrow icon. An even easier variant is Alt E as in execute.

Next, I have compiled a list of the more notable shortcuts. Some are based on people's opinion from Stackoverflow. A more complete list can be found here and you can always check the key for actions by pressing Ctrl Alt A in Idea.

Go to declaration => Ctrl B

Open class => Ctrl N

Rename refactor => Alt R; Shift F6

Refactor variable from expression => Ctrl Alt V

Extract method => Ctrl Alt M

Smart completion => Ctrl Shift Space

Cyclic expand word => Alt forwardslash

Complete statement => Ctrl Shift Enter

Reformat, Checkstyle, fix imports => Ctrl Alt L

Find in whole project => Ctrl Shift F

Switch tabs => Ctrl Tab

Quick fix/intentions => Alt Enter

Smart template => iter/psf/thr Tab

Find Usage => rightAlt U; Alt F7

Brief info => Ctrl mouseover

Duplicate => Ctrl D

New line below => Shift Enter

New line above => Ctrl Alt Enter

Expanding select => Ctrl W

Delete to word start => Ctrl Backspace

Delete line => Alt X; Ctrl Y

Paste previous copies => Ctrl Shift V

JavaDoc => Ctrl Q

Run => Alt P; Alt Shift F10

Go to previous/next method => Alt Up/Down

Go back to code => Ctrl Alt Left

Go to next error => F2

Expand all folded => Ctrl Shift =

Parameter info in method call => Ctrl P

Show TODO list => Alt 6

Bring up the file/class/method quicksearch => Shift Shift

Open the switcher => Ctrl Tab

Hide active window => Shift Escape

If you think a shortcut or setting you often use is missing - tell me!

permalink

Until the 1960s scientists could not explain how termites manage to organise their activity to gather and pile up in one place all the wood pieces they find. Different theories tried to explain this like inaudible languages, but the truth was that they just followed simple rules, from which emerged a complex behaviour.

By taking a piece of wood when they encounter it and dropping it when they encounter another one the termites move the pieces to one or more piles, which in turn also get combined into bigger piles. The result is cleared areas and compact piles.

My implementation of the simulation: on github

permalink