And its not a stretch to call chrome an OS. By lines of code, chrome is about the same size as the linux kernel. […] On MacOS it even contains a userland USB driver for xbox360 controllers. (I know its there because I wrote it. Sorry.)

Does slack contain my code to use xbox controllers? Does the slack team know? Does anyone know?

Until one day I realized that the question if Electron contains an Xbox driver is 100% answerable. Let’s take Obsidian as an example:

$ cd "/Applications/Obsidian.app/Contents/Frameworks/Electron Framework.framework/Versions/Current"
$ strings "Electron Framework" | grep "Error listening for Xbox controller add events:"
Error listening for Xbox controller add events:
Error listening for Xbox controller add events:

This message appears in the source code for Chromium in xbox_data_fetcher_mac.cc. The same binary also contains the name of the source file:

$ strings "Electron Framework" | grep xbox_data_fetcher_mac.cc
../../device/gamepad/xbox_data_fetcher_mac.cc
../../device/gamepad/xbox_data_fetcher_mac.cc

Which means Electron does contain an Xbox controller driver. Case closed. Figuring out how to make use of it is a rabbit hole for another day.

P.S. Someone please make an extension for VS Code to add controller support. 😛

After looking at both the old and the new PCBs I’ve spotted something: on the new board pull-up and series resistors seem to have been misplaced.

Left side is the old PCB, right side is the new broken one. The slight differences in values are not important here (1.2 kOhm vs 820 Ohm), the important thing is that the two outside resistors are pull-up resistors, and the two middle ones are series resistors that connect the output pins of the encoder to the microcontroller.

On the old board, the pull-up resistors are both 4.7 kOhm, and the series resistors are 1.2 kOhm. On the new board one channel doesn’t look right: the pull-up resistor is 820 Ohm, and the series resistor is 4.7 kOhm.

Here’s a crude schematic overlaid on top of the photo:

Doesn’t look intentional to me, must have been a mistake :) This put some doubt in my mind that if they could mess up resistors in this revision, perhaps they also messed up debounce. The microcontroller is different on the new board, availability issues might have been the reason for the new revision.

The bottom two resistors need to be switched around.

Adding an RC filter

What’s missing for the debounce filter is a capacitor, and the existing series resistors should work great for the RC filter. Fortunately, to the right of the series resistors there is a huge ground plane that we could solder to. I ordered some 0603 capacitors, ended up using 220 nF ones.

Here’s an in-progress photo:

I soldered the two capacitors to the right side of the series resistors, then scraped away the solder mask right next to the new capacitors, then soldered them to the ground plane.

Very happy with the final result, looks great :) This is the first time I repaired something not just by replacing a broken part, but by fixing a design issue.

After seeing how clean the web can be without ads I just… never stopped blocking them. Installing uBlock Origin is one of the first steps I take when setting up a new computer.

If at first my main concern was computer performance, my concerns have since shifted towards resisting manipulation (in a broad sense) by advertisers, and not letting some big tech company collect data about me. Ad tech and tracking users go hand in hand: the more information they have, the better they can target the users and the pricier the ad spots get.

One more thing! Do you have friends or relatives that run into computer problems often? Installing some malware off of the internet? Asking you if they can trust this no-name online store that seems to sell tech gadgets suspiciously cheap? They probably found the scam website through ads! Install an ad blocker for them, and they’ll magically have fewer computer problems. I sometimes jokingly refer to ad blockers as the best antivirus.

I recommend uBlock Origin on Firefox. There’s also an extension called SponsorBlock that uses a crowdsourced database of sponsored segments on YouTube and skips them. On iOS, I use Safari with Wipr 2 and SponsorBlock extensions. Both of these extensions are paid though, but are well worth the money.

It even supports USB 3.0 at 5 Gbps.

I have a Das Keyboard 4 with a volume knob that sometimes registers multiple times when rotating the knob, sometimes in the wrong direction. This indicates a bad rotary encoder.

Let’s see what encoder the keyboard has. Pop off the volume knob by pulling it straight up. It may need some force if you’ve never done this before, but nothing excessive. There we can find a rotary encoder with “CTS” marked on its side. After spending a bit of time, I was able to find the closest match on their website: CTS Series 290 rotary encoder.

Reproducing and visualizing the problem

According to the data sheet, the middle pin is the ground, and the other two pins are output pins. The rotary encoder shorts these two pins to ground (middle pin) to generate the signal. Let’s connect a cheap logic analyzer to see what’s going on with the signal. I’ve used PulseView to record the signal.

We can see here that the rotary encoder is too chatty. According to the data sheet, contact chatter should last up to 3 ms, but here we can see contacts bouncing for around 15 ms, which is way out of spec.

Finding a replacement part

The datasheet has no variant with such a short shaft like the one we have here. This means the part we’re dealing with is custom made for Das Keyboard and isn’t available off-the-shelf.

This is where I got stuck for a while. I even considered options to buy the version with the shortest shaft and cut or grind it down to be even shorter, however, that would still have made it too tall compared to the original.

The closest match is 290VAA5F201A2. All the specs are the same except for the shaft length.

Turns out the rotary encoder itself is modular, so it’s possible to reuse the shaft from the old encoder and put it into the new one. Fortunately, the shaft is not the part that causes excessive chatter, so by combining the new and the old parts together we can get a fully working rotary encoder with the correct shaft length.

I ordered mine from DigiKey, but Mouser also stocks it. I’ve also found them on eBay, but they seem to be overpriced for the number you get.

Disassembly

Getting into the keyboard is quite straightforward if you have the right bit for your screwdriver - Hex 2.5 mm. Desoldering the old part without destroying it turned out to be the most painful part of the process. Some parts of the encoder are made of plastic, so you can’t just blast it with hot air.

Another problem is that the mounting pins are pressed tightly against the holes in the PCB, creating enough friction that the part is held in place even if there were no solder left. I can see why they did this: any slack in the mounting position would introduce too much variability and the volume knob would not be placed correctly against the metal cutout for the knob.

There’s black tape / spacer on top of the encoder that you need to remove before desoldering. We’ll put it back on the new one once it’s soldered.

Desolder the old part. Good luck :)

Combining the old and new parts

Step 1: removing the custom shaft from the old encoder

• Pull the mounting legs away from each other. The metal is soft enough this can be done with your bare hands.
• Bend it just enough to pull metal cover off.
• Pull away the plastic parts from the metal shaft. They are held together with 4 cylindrical plastic pins. Be super careful here because the contact pins that brush against the encoder ring are exposed, and bending them would likely make the encoder not work properly!
• Pull the plastic encoder ring and then also the little retention pin out.
• Take the metal shaft and put it away - we’ll use it later. The rest can be thrown away.

Step 2: disassemble the new encoder and combine parts

Follow the same process from Step 1 with the new encoder. Once you get to the last step, we’ll do the opposite: we’ll use everything BUT the shaft from the new encoder.

• Take the shaft from the older encoder.
• Put the retention pin into the old shaft.
• Put the encoder ring into the old shaft.
• Put the combined shaft onto the plastic parts from the new encoder.
• Put the metal cover over that and bend back the metal to take its normal shape.

That’s it, you’ve made the custom part that the keyboard needs!

Step 3: verification

This is not what I’ve done originally, but in hindsight that would have saved me a lot of time. Once you rebuild the new part, use the logic analyzer to verify if the new part is working properly. I’ve soldered the new encoder only to realize it’s also just as chatty as the old one. Had to redo this multiple times.

Some random tips

• Verify if the new encoder is clicky. Some encoders that I got (brand new!) were not clicky for some reason. Only after soldering I’ve realized they’re super dull and not fun to use.
• Be super careful with flux - don’t let it get inside the encoder!
• Isopropanol causes the encoder to become squeaky. At first I didn’t realize that it was isopropanol that I used for cleaning flux that was causing this and wasted a bunch of time resoldering new encoders.
• The encoder seems to be quite heat sensitive. If you melt the plastic parts inside, it’s game over.

On macOS, the shortcut to delete a word is Alt-Backspace. When you press it on a Linux computer with Kinto installed, it correctly remaps that to Ctrl-Backspace. This works well in almost all applications, except for Electron apps. Electron apps activate the main menu when you release Alt.

Apparently, this is a feature that comes from the way most applications on Windows work: if you press Alt without pressing anything else, it will focus the first menu item. This is not a common behavior on Linux however – neither GTK nor Qt apps do this.

Even though this can be worked around in Kinto with varying levels of success, the real fix needs to happen in the Electron framework. With this in mind, I’ve set out to dig into this issue.

Looking into Electron’s source code

After going through the pull request that introduced this, I realized there doesn’t seem to be a way to disable this behavior. The culprit is this piece of code. Since a proper fix won’t come anytime soon, let’s binary patch compiled executables ✨.

Analyzing the binary

First, we need to find where the binary is. Let’s run Signal and list running processes:

$ ps aux | grep signal
[...]
user      211853  2.5  0.8 6837048 267392 ?      SLl  01:08   0:02 /opt/Signal/signal-desktop --no-sandbox
user      211865  0.0  0.1 208664 45708 ?        S    01:08   0:00 /opt/Signal/signal-desktop --type=zygote --no-zygote-sandbox --no-sandbox
user      211866  0.0  0.1 208664 45932 ?        S    01:08   0:00 /opt/Signal/signal-desktop --type=zygote --no-sandbox
[...]

There it is! Let’s open /opt/Signal/signal-desktop in IDA Pro. There’s a free version that will do just fine for our needs. Signal binary is huge (~130 MB), so the analysis takes a looong time.

After the analysis is finished, our main goal is to find where that piece of code is in the binary. Sadly, the executable doesn’t have any debugging symbols, so we can’t just search for the function by its name. Without compiling Electron ourselves (which I guess takes like half a day), we need to find something unique about this piece of code. String literals work best, however, there seem to be no string literals around.

I then found the following function:

const int kMenuBarHeight = 25;
// ...
int RootView::GetMenuBarHeight() const {
  return kMenuBarHeight;
}

While not perfect, we can search for this value in IDA Pro by pressing Alt-I. Enter 25, press Enter. 32265 results. Oof. Let’s try to narrow them down.

If we reference the standard calling conventions we should expect the function to store the constant into the rax/eax/ax/al register. So let’s press Ctrl-F and enter

mov     eax, 19h

57 results. That’s better. Let’s go through all of them and find a really short function. To my surprise, the function I needed was the first in the list. Let’s rename it to GetMenuBarHeight:

.text:0000000001A5FAA0 GetMenuBarHeight proc near
.text:0000000001A5FAA0     push    rbp
.text:0000000001A5FAA1     mov     rbp, rsp
.text:0000000001A5FAA4     mov     eax, 19h
.text:0000000001A5FAA9     pop     rbp
.text:0000000001A5FAAA     retn
.text:0000000001A5FAAA GetMenuBarHeight endp

This function by itself is not very important, but if we go through adjacent functions, we’ll realize the compiled binary follows the source code pretty closely. I figured out the next functions were: SetAutoHideMenuBar, IsMenuBarAutoHide, IsMenuBarVisible and then HandleKeyEvent, the one we need to patch!

Patch idea

If we pretend that the Alt key press never happened, the menu will not be activated. We need to make a patch as if this line was

    menu_bar_alt_pressed_ = false;

Analyzing HandleKeyEvent function

If we look at the source code again, the function has an early return which ensures that menu_bar_ is set:

void RootView::HandleKeyEvent(const content::NativeWebKeyboardEvent& event) {
  if (!menu_bar_)
    return;
  // ...
}

Before we go further, I need to mention that methods in C++ have an implicit first parameter which is a pointer to the object (this), so the method above actually has two (RootView *this, NativeWebKeyboardEvent &event). This is what the method looks like in the disassembly:

HandleKeyEvent proc near
push    rbp                 ; init stack frame, save register values, etc.
mov     rbp, rsp
push    r14
push    rbx
mov     r14, rdi            ; rdi stores the first argument (`this` keyword)
                            ; it is then copied to r14

mov     rdi, [rdi+288h]     ; rdi = this->menu_bar_;
test    rdi, rdi            ; if (!rdi)
jz      loc_1A5FBE7         ;     return;

This gives us some important information:

• r14 stores the pointer to the RootView object.
• 288h is the offset in the object for menu_bar_ variable.

Now, if we now look at the header file, we can find the offset for menu_bar_alt_pressed_:

class RootView : public views::View {
 public:
  // ...
  // Menu bar.
  std::unique_ptr<MenuBar> menu_bar_;   // r14+288h
  bool menu_bar_autohide_ = false;      // r14+288h+8   (8 is sizeof(std::unique_ptr<MenuBar>)
  bool menu_bar_visible_ = false;       // r14+288h+8+1 (1 is sizeof(bool))
  bool menu_bar_alt_pressed_ = false;   // r14+288h+8+1+1 = r14+292h

Now we need to look for [r14+292h] in the disassembly. There are 4 matches:

.text:0000000001A5FB39    mov   byte ptr [r14+292h], 1   ; set to true
.text:0000000001A5FB50    cmp   byte ptr [r14+292h], 0   ; compare to 0
.text:0000000001A5FB5E    mov   byte ptr [r14+292h], 0   ; set to false
.text:0000000001A5FBDF    mov   byte ptr [r14+292h], 0   ; set to false

The first one is exactly what we were looking for. If you now go to the mov byte ptr [r14+292h], 1 line, IDA Pro will tell you the offset where the instruction in the input file is. In my case, it was 01A5EB39.

Digging into the instruction

If you open the hex view in IDA Pro while the instruction is selected, it will highlight instruction’s machine code:

41 C6 86 92 02 00 00 01    mov   byte ptr [r14+292h], 1

Using x86-64 opcode reference we can figure out what each byte means:

41               register extension prefix (REX.B), allows access to r14
C6               instruction: mov r/m8, imm8
86               ModR/M byte which corresponds to [R14/R14D]+disp32
92 02 00 00      disp32 value: 0x292 (encoded as little endian)
01               imm8 value (0x01)

The last byte is the one we need to patch.

Patching

We’re very close now! Let’s open this file in GHex:

$ sudo ghex /opt/Signal/signal-desktop

Press Ctrl-J and type the offset. At offset 0x01A5EB40, there is the value 1 that corresponds to true. Change it to 00 (false) and save.

Run Signal, press and release Alt, and there it is, the menu no longer gets activated! 🎉🎉🎉

Next steps

The biggest issue is that this patch needs to be reapplied after each update. The other obvious issue is that each Electron app needs to be patched.

Hang on until the next blog post where I’ll show you how to write a generic patcher that works with any Electron version and any Electron app – until developers make changes to that part of the code, of course.

The problem with mouse acceleration

Mouse acceleration makes it harder to develop muscle memory to hit far away targets accurately. You need to be precise not only in the distance you move the mouse but also the speed, which is harder to do consistently. The other issue is that acceleration curves are different on each operating system, so you’ll have to get used to each one.

Solution: flat pointer acceleration curve (aka no acceleration)

Flat acceleration curve ignores mouse velocity completely and only applies some constant factor to the distance and direction the mouse moves. What is more, it’s completely the same on all operating systems, which is a great thing for people who regularly use different operating systems.

Setting it up

macOS

defaults write -g com.apple.mouse.scaling -integer -1

Linux (GNOME)

gsettings set org.gnome.desktop.peripherals.mouse accel-profile flat

Windows

Open the “Mouse Properties” control panel dialog, uncheck “Enhance pointer precision” in the “Pointer Options” tab.

I’ve been using Sublime Text for over 5 years now primarily for Ruby on Rails development. I want to go over the configuration and plugins I’ve used that have served me well during all those years.

This isn’t a beginner’s guide though. If you’re unsure how to install plugins or how to edit configuration, look up a guide on the internet and then go back to this post.

Plugins

• AdvancedNewFile

  Allows creating new files relative to the current file easily. Instead of choosing the name and location of the file in a native save dialog, you can instead press Alt+Cmd+N, type in :foo/bar.rb and it’ll create a folder named foo and a file bar.rb relative to current file. Without the : it’ll create the file relative to the project root.

• ApplySyntax

  In Ruby, you’ll have files that need different syntax highlighting schemes even though they’re all have the same .rb extension. For example, a file might be a regular Ruby source file, the other might be an RSpec file. This plugin has a list of rules to apply the right syntax.

• Git

  Git integration. The only function I use it for is to show git diff. Since I don’t need it very often, I don’t have a shortcut bound for it, I use the command palette.

• GitGutter

  Shows which lines were added or removed next to line numbers. It’s very convenient because it allows you to concentrate on the changed areas.

• All Autocomplete

  Suggests words from other open files.

• ChangeQuotes

  Toggles single/double quotes. Depending on your code style, you might need to switch between single and double quotes quite often. This plugin doesn’t ship with default keybindings, I’ve bound the primary function to Cmd+’

• MarkdownPreview

  Renders a markdown file into HTML and shows it in the browser. Something I didn’t realize straight away is that you don’t need to run this command over and over after a change, the plugin will rerender the file for you, it’s enough to refresh the page in the browser.

• SublimeLinter, SublimeLinter-rubocop, SublimeLinter-shellcheck

  A linter framework with linter plugins for RuboCop and Shellcheck. They provide feedback on your code while you’re typing.

• TestRSpec

  Allows you to switch between code and spec, create the spec if it doesn’t exist, and run specs in Sublime.

• Theme - SoDaReloaded (Dark)

  The theme I’ve used for a while, try it out!

Settings

{
  "font_face": "Source Code Pro",
  "font_size": 10
}

I’ve been using Source Code Pro as my primary coding font.

{
  "tab_size": 2,
  "translate_tabs_to_spaces": true,
  "trim_trailing_white_space_on_save": true,
  "ensure_newline_at_eof_on_save": true
}

Use 2 spaces for indentation, remove trailing newline on save, add a newline at the end of file if it’s missing.

{
  "word_separators": "./\\()\"'-:,.;<>~@#$%^&*|+=[]{}`~"
}

It’s the default list with ! and ? removed, since they can be a part of the method name in Ruby.

{
  "file_exclude_patterns": [
    ".DS_Store"
  ],
  "folder_exclude_patterns": [
    "log",
    ".git",
    "node_modules",
    "tmp",
    "__pycache__",
    ".vscode",
    ".idea"
  ],
  "index_exclude_patterns": [
    "*/log/*",
    "*/node_modules/*",
    "*/tmp/*"
  ]
}

Rules to exclude irrelevant files and folders.

{
  "rulers": [99]
}

Adds a vertical line at 99 columns to let you know if you’re under line length limit. Adjust to match your project’s conventions.

#!/bin/sh

# Watch kernel logs for the word `corrupt`
dmesg -w | grep --color -i corrupt &

echo "Starting stress test in 5 seconds..."
sleep 5

# Stress test by repeatedly putting computer to sleep for 10s
for i in $(seq 100); do
  echo "Iteration #$i..."
  rtcwake -m mem -s 10
  sleep 10
done

Save the file as stress-test-suspend.sh, then run:

$ chmod +x stress-test-suspend.sh
$ sudo ./stress-test-suspend.sh

The idea comes from the page Best practice to debug Linux* suspend/hibernate issues.

New hardware is unproven hardware

If you buy a new piece of hardware the day it comes out, you’re more likely to encounter issues with both hardware and software. We’ve bought a couple of RTX 2080 Ti GPUs, and we’ve had problems with failing hardware and misbehaving drivers.

Memory

When choosing RAM, look for RAM confirmed to work with your motherboard. Motherboard manufacturers usually publish Memory and CPU compatibility lists called QVL on their websites. Buy the exact model specified.

Extreme Memory Profile (XMP)

Even though DDR4 RAM is branded as having speeds such as 3200 MHz, usually it will only run at 2133 MHz out of the box. You’ll have to enable XMP in your BIOS to unlock the full speed.

XMP is marketed as stable manufacturer-approved settings for your RAM. However, I’ve had multiple cases where XMP caused system instability. Treat XMP as overclock. If you’re experiencing random reboots, crashes, computer not waking up from sleep, monitor not turning on, this could all be caused by XMP. Run at stock speed for a while and see if the problem goes away.

If XMP didn’t work, you can try overclocking RAM yourself. The process is quite complicated, though, as there are a lot of other settings besides clock speed.

RAM slots

I’ve recently learned that it might also matter which of the two slots of the same channel you use. For the last computer I’ve built, I’ve had to use A2 and B2 slots instead of A1 and B1 to make RAM work at full speed.

Refer to motherboard’s manual for what manufacturer recommends. Here’s an example from the manual for ASUS TUF GAMING X570-PLUS:

Run a benchmark

It’s not enough to order the parts and put them together. You also want to make sure your computer performs as expected, and that’s what benchmarks are for.

I recommend Geekbench. It’s free if you don’t mind publishing your benchmark results on the internet. If your scores are significantly lower than the typical result for your CPU, you have a problem somewhere.

Run a stress test

Benchmarks can show that your computer is fast, but is it stable? I usually run Prime95 in stress test mode for up to a day.

How to debug stability issues

After a crash caused by instability, you are unlikely to find any relevant logs after a reboot. However, logs are extremely useful when trying to figure out what went wrong. To access kernel logs, you need to send logs to another computer using netconsole.

If you’re having issues with suspend, there’s a great guide on how to debug suspend issues.