nikital

I made a WebGL mechanical clock simulation if anyone wants to look at it in motion: https://clock.leshenko.net/

> 8051s love talking to each other after all, otherwise USB would not exist.

Can anyone explain what the author meant by that? I thought 8051 is just an ISA, is there something special there for cross IC communication compared to other ISAs? And what the the connection to USB?

Great presentation! I created something similar — a step-by-step Git implementation that is designed for teaching Git internals:

https://www.leshenko.net/p/ugit/

Awesome post! I'm confused about the schematics of the keyboard and I wonder if anybody here might point me in the right direction: The HWB pin is pulled permanently low, so the MCU runs the default USB DFU bootloader on startup/reset. Then the application firmware can be programmed using dfu-programmer.

But what happens after programming, when you unplug the keyboard and plug it back in? Since HWB is still pulled low, doesn't the MCU go back into the DFU bootloader instead of running the application? How does the keyboard run the actual application firmware rather than the bootloader?

> Git is one of those technologies where it's super important to get a good grasp of how to internals work.

I fully agree, that's why I built a tutorial where you learn about Git internals by implementing Git yourself in Python: https://www.leshenko.net/p/ugit/

Looks nice, I wanted to submit a project and I spent time to fill the forms but I was greeted with a login wall after I filled all the details. There was no indication anywhere in the process that it would be required. It made me feel somewhat deceived.

I think it would be more honest towards your users to be upfront that you require login to submit a project.

I've seen people's Git skills improve after I taught them Git internals, but I taught them in a standard lecture format.

I didn't try teaching Git internals using code before, but I hypothesized it would be a good idea, and here is the result :) I'm curious about its effectiveness as well.

> stripped of factors that obscure the lesson

Yes! I'm going to adopt that wording. Originally I tried to do a screencast about guided Git source code exploration but it didn't work because of that reason.

It was custom made for the tutorial. I didn't release it yet because I mostly focused on polishing the tutorial itself and not the code for the interface. Do you think people would be interested in the interface by itself?

I'm happy to hear that! You can clone the tutorial content using the link in the "Download" section. The interface isn't available yet on Github.

Thanks! Note that ugit isn't supposed to be a custom compatible Git implementation, but rather a simplified Git-like implementation for teaching Git concepts. So even if ugit supported packfiles, it still won't be able to read a real Git repo.

Sure, thanks for doing it! I added a license to the original code.

A while ago I made a bouncing DVD logo that would actually hit the corner every few bounces with high probability:

https://nikital.github.io/screensaver

(But then it would troll you just before hitting it)

I think it's important to distinguish between the concept of the init process vs specific implementations of the init process.

The article talks about the init process in general (the process that runs as PID 1 and picks orphaned processes). There are different implementations of init (such as SysV-style, systemd, Upstart etc) but it doesn't make a difference for this article.

xkcd has a self-enumerating comic: https://xkcd.com/688/

Cool, I made this toy some years ago :) Thanks for the additions, merged your code into the original.

No, you can't call syscalls from restartable sequences

A restartable sequence is defined by a start and an end offset. If I write a restarable sequence in C I can't be absolutely sure that it's contiguous and I can't know where the commit instruction is...

Does it mean that I have to write it in assembly to make sure that I know where the sequence starts and where it ends?

The module takes an extra reference count to itself upon initialization and never decrements it, so rmmod will fail because the module will be "in use".

I used the kernel module for a few days and didn't notice any problems on a laptop running Fedora.

The kernel module is less that 100 lines long, hopefully it's simple enough to not cause trouble...

According to the article, the self-mapping PTE is randomized in the latest Windows 10.

I would sometimes open the Messages buffer and then repeatedly use M-x quick-calc to evaluate a few expressions. Each result is written to the Messages so I have a log. Dirty but works :)

I have Kobo Aura ONE[1] and it has automatic orange backlight. I'm relatively happy with it even though the lighting is slightly uneven and has barely visible greenish hues at the corners...

[1] https://us.kobobooks.com/products/kobo-aura-one

> The only downside is no access from my phone.

On Android, I use Password Store to sync my `pass` directory and use it from the phone. It a very high quality app, I had no issues after years of usage.

https://github.com/zeapo/Android-Password-Store

A pain I have with rebase workflow is that it creates untested commits (because diffs were blindly applied to a new version of the code). If I rebase 100 commits, some of the commits will be subtly broken.

How do you deal with that?

A lot of people in the comments recommend getting a personal domain, but doesn't that just move the single point of failure to the registrar? For example, quoting NameCheap's TOS: "In the event of termination [..], You agree [..] that Namecheap may take control of any domain name associated with the terminated Services." (https://www.namecheap.com/legal/universal/universal-tos.aspx)

A single company can still wipe your online identity. Is there any solution for that? Maybe getting a domain directly from ICANN somehow?