XMonad has been my window manager since 2011. Once I got used to the workspaces and automatic assignment of windows to workspaces, I was happy. I learnt a smattering on Haskell in 2013 which also helped in understanding the incantations in xmonad.hs.

Since Covid, my workplace moved to Webex for chat and Webex does not like Xmonad. Everytime you try to reply to a thread, you get black overlay covering the text box. The usual XMonad tricks with finding window name and window class with xprop do not work. Both the text box and the overlay have the same properties.

I switched to KDE. KDE with Plasma 6 is amazing but my brain was hardwired to XMonad workspace management. I kept trying to make KDE into XMonad. I also tried using XMonad as the window manager for KDE but ran into the same Webex issue.

I finally tried i3 and was able to customize it into the “XMonad”. i3 has the tiling, multi-monitor support, workspace management and window assignment to workspaces. Webex threaded replies work with i3.

I only had to customize the workspace switch feature to behave the same as XMonad. In XMonad, you can bring any workspace to the monitor you are on. In I3, the workspaces are tied to any monitor. I wrote a quick wrapper to do workspace reassignment to current monitor and switching to the workspace and I am all set for now.

#!/usr/bin/env bash
WS_NUM="$1"
ACTIVE_OUTPUT=$(i3-msg -t get_workspaces \
    | jq '.[] | select(.focused==true).output')
i3-msg workspace number "$WS_NUM"
i3-msg move workspace to output "$ACTIVE_OUTPUT"
i3-msg focus output "$ACTIVE_OUTPUT"

Commands 

Initialize 

$ jj git init --colocate

Garbage Collection 

To garbage collect a jujutsu repo, use

$ jj util gc

or

$ jj util gc --expire now

Remove jj from a git repo 

$ rm -rf .jj
$ git for-each-ref -- 'refs/jj/keep/*'
$ git for-each-ref  --format='%(refname)' -- 'refs/jj/keep/*' | xargs -l1 git update-ref -d

Push a new branch 

$ jj bookmark set new_branch_name
$ jj git push --allow-new

Push an update to an existing branch 

If you have a tracking branch already

$ jj bookmark set old_branch_name
$ jj git push

If you dont have a tracking branch already

$ jj bookmark track old_branch_name@origin
$ jj bookmark set old_branch_name
$ jj git push

References 

• JJ Git Command Equivalence Table - https://jj-vcs.github.io/jj/latest/git-comparison/#command-equivalence-table

NOTE: These are my notes as I learn Rust. Accuracy is on par with a hallucinating LLM.

Build System 

Organization 

Package vs Crate vs Module vs Workspace

https://doc.rust-lang.org/book/ch07-01-packages-and-crates.html

• A crate is the equivalent of a library.
• A binary crate is the equivalent of an executable.
• A package is a bundle of one or more crates.
  • Package should have atleast 1 crate.
  • Package can have atmost 1 library crate.
  • Package can have multiple binary crates.
• By conventions, entry point for compilation of a
  • library crate is src/lib.rs
  • binary crate is src/main.rs
  The entry point is referred to as crate root.
• Crate root can define modules. Module source can be at src/mod_name.rs.
• A module can define submodules. Submodules are found at src/mod_name/submod_name.rs.
• There is no makefile equivalent for a crate. The files to be compiled are inferred from the crate root.
• A workspace is a cargo supported way to develop multiple closely related packages together.

At a high level,

• Workspace has multiple packages.
• One package has 1 library crate plus some related application.
• Each crate can define some modules and submodules.

KConfig 

Preprocessor 

Conditional compilation 

void handle_version()
{
#if (CONFIG_VER==1)
    handle_v1();
#elif (CONFIG_VER==2)
    handle_v2();
#else
    handle_other_versions();
#endif
}

Rust equivalent is using the cfg-if crate.

fn handle_version() 
{
    if #[cfg(unix)] {
        handle_v1();
    } else if #[cfg(target_pointer_width = "32")] {
        handle-v2();
    } else {
        handle_others();
    }
}

Links 

1. https://doc.rust-lang.org/book/appendix-04-useful-development-tools.html

When I was young, I used to hang out in my dads office. They had a recreation room with indoor games, news papers and magazines. One fine day, my dad taught me chinese checkers. He won the first game and I won the second game. Thats how I spent years thinking I was a prodigy at chinese checkers. Thanks Dad.

Finally I found the gap at work to move my work laptop to ubuntu 22.04.

• I started with the ubuntu server iso instead of the desktop iso to keep unwanted features out. I had the laptop on ethernet as I was not sure if the wireless driver would be part of the iso.
• I went with Plasma Desktop/KDE as the window manager instead of my usual xmonad. Webex Teams is to blame.
• Using Nixpkgs + home-manager along with dotfiles made it very easy to get the user space programs back.

Detours 

sddm 

I installed nixpkgs in daemon mode. This creates a bunch of build users. I was looking for a way to hide the users in SDDM login screen. None of the options in the SDDM config file seemed to take effect. Starting the sddm greeter in test mode seemed to use the configuration correctly.

> sddm-greeter --test-mode

Reading the source did not help much either. Eventually I stumbled upon the solution that sddm configuration files need to be files and not symbolic links to files. I could not figure this out from the source but this restriction makes sense for a component that controls the login screen.

The other irritation was sddm starting with a on-screen keyboard by default. I had to configure the InputMethod option to disable it.

[Users]
HideShells=/sbin/nologin
MaximumUid=20000
MinimumUid=1000

[X11]
EnableHiDPI=true
MinimumVT=7

[General]

# Input method module
InputMethod=

home-manager 

The change in configuration file location and format since 2021 led to a bit of head scratching. The config file location changed from ~/.config/nixpkgs/home.nix to ~/.config/home-manager/home.nix. I also had a mismatch between the nixpkgs channel and the home-manager channel. nixpkgs channel was set to master and I had to use the corresponding home-manager channel. Once the channels matched, the package installation was smooth.

Nix 

I am experimenting using Nix for installing fonts as well. This requires running fc-cache with the installation path as argument.

> nix-env -iA nixpkgs.jetbrains-mono
> fc-cache -v $HOME/.nix-profile/share/fonts/

dmesg 

dmesg not being accessible to normal user was surprise coming from 18.04. Apparently the change was introduced in ubuntu 20.10. I had to set kernel.dmesg_restrict = 0 in /etc/sysctl.d/10-kernel-hardening.conf to allow non-root users access to dmesg.

https://unix.stackexchange.com/questions/390184/dmesg-read-kernel-buffer-failed-permission-denied#390187

Ever since coming across the Atkinson Hyperlegible font https://brailleinstitute.org/freefont, I wanted to experiment on the blog with it. Switching the font in bulma was just following the documentation and using the right url for fonts from google fonts.

1. Bulma documentation - https://bulma.io/documentation/customize/with-sass-cli/#6-add-your-own-bulma-styles
2. Sass file to update the font - https://github.com/vmandela/bulma/blob/d897152b9b153e697de2151725c0216ada59c111/bulma-atkinson.sass
3. Resulting CSS - https://github.com/vmandela/bulma/blob/d897152b9b153e697de2151725c0216ada59c111/bulma-atkinson.css

The blog looks good even though I say so myself.:-)

This blog is built with Hakyll. Hakyll uses Pandoc for markdown to html conversion. The blog breaks approximately once an year with a change to the underlying pandoc-types.

One of the past breaking changes was the conversion basic text data type from [Char] to Data.Text. The change broke some of the filters I used in the blog. One of the filters was a function to strip the initial / from any resources used in the blog. Hakyll uses URLs with slash at the beginning ‘/’ for local images/resources. I used this filter to fixup the link to images to relative links before converting them into Word document or PDF format.

stripSlash :: String -> String
stripSlash (x:xs)
  | '/' == x = xs
  | otherwise = [x] ++ xs
stripSlash _ = []

I was looking for a way to modify the stripSlash function to support both [Char] and Data.Text data type. Thats how I discovered Haskells ad-hoc polymorphism. This required defining a typeclass and creating an instance of it for each data type I needed to support.

{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE InstanceSigs #-}
import qualified Data.Text as T

class StringUtils a where
  stripSlash :: a -> a

instance StringUtils String where
  stripSlash :: String -> String
  stripSlash (x:xs)
    | '/' == x = xs
    | otherwise = [x] ++ xs
  stripSlash _ = []

instance StringUtils T.Text where
  stripSlash :: T.Text -> T.Text
  stripSlash x = T.pack (stripSlash $ T.unpack x)

Here are a couple of links that helped me.

1. https://stackoverflow.com/questions/12430660/creating-polymorphic-functions-in-haskell
2. https://en.wikibooks.org/wiki/Haskell/Polymorphism#Ad-hoc_polymorphism

I am one of todays lucky 10000. :-)

After years of using nixpkgs on ubuntu and nixos in virtual machine, I finally made the switch to using nixos as the primary OS on the home laptop. As the home laptop is shared, I used a dual boot configuration with Windows10 along side NixOS. Each OS is installed to a separate hard disk. The installation process was pleasantly uneventful.

1. The WiFi card was autodetected. WiFi configuration was easy once I discovered nmcli.

   # /etc/nixos/configuration.nix
   networking.networkmanager.enable = true; # Enable network manager

   $ nmcli d wifi connect vmandela --ask

2. With grub os prober enabled, windows 10 showed up automatically in the bootloader menu.

   # /etc/nixos/configuration.nix
   # Use the systemd-boot EFI boot loader.
   boot.loader = {
           systemd-boot.enable = true;
           efi.canTouchEfiVariables = true;
           grub = {
                   enable = true;
                   devices = [ "nodev" ];
                   efiSupport = true;
                   useOSProber = true;
           };
   };

3. Windows 10 and NixOS treat the hardware clock differently. Windows 10 treats the hardware clock as local time while NixOS treats it as UTC. To resolve this difference, I had to switch NixOS to treat hardware clock as local time.

   # /etc/nixos/configuration.nix
   # Set your time zone.
   time.timeZone = "Asia/Kolkata";
   # Use hardware clock in local time instead of UTC
   # This is required for compatibility with windows
   time.hardwareClockInLocalTime = true;

4. Steam worked out of the box following the instructions in the Nixpkgs Manual.

   # /etc/nixos/configuration.nix
   # Required for steam
   hardware.pulseaudio.support32Bit = true;
   hardware.opengl.driSupport32Bit = true;

5. Setting up NGINX required a little document hunting. I use NGINX for checking out my blog locally before pushing it to github. My usecase fell into the so simple it is undocumented category.

   # /etc/nixos/configuration.nix
   # Enable NGINX
   services.nginx = {
       enable = true;
       virtualHosts."localhost" = {
           root = "/home/vmandela/code/gh-blog/_site";
       };
   };

6. Power management and monitoring is done using tlp and upower.

   # For thinkpad
   services.tlp.enable = true;
   
   # Battery power management
   services.upower.enable = true;

7. Getting the user environment setup was done by reusing dotfiles from the previous machine and using Nix Home Manager

Setting log level dynamically 

If you want to change the log level for one iteration of a loop or one call of a function, it can be done by calling setLevel on the current logger instance.

import logging

logging.error("This statement will be shown")

logging.debug("This will not be shown")

logging.getLogger().setLevel("DEBUG")

logging.debug("This debug statement will be shown")

logging.getLogger().setLevel("ERROR")

logging.debug("This debug statement will be hidden")

This results in

ERROR:root:This statement will be shown
DEBUG:root:This debug statement will be shown

Related reading 

1. Logging module documentation - https://docs.python.org/3.8/library/logging.html
2. Logging HOWTO - https://docs.python.org/3.8/howto/logging.html

This is a collection of notes I have accumulated while working with make. The make manual is a good place to start looking for answers.

https://www.gnu.org/software/make/manual/make.html

Debugging makefiles 

gmake info command 

The info command can be used to dump information from makefile.

https://www.gnu.org/software/make/manual/make.html#Make-Control-Functions

$(info CFLAGS=$(CFLAGS))

Similarly one can use the error and warning commands can be used for debugging.

Remake 

Remake http://bashdb.sourceforge.net/remake/ is a enhanced version of GNUMake with enhanced tracing and a builtin debugger. I have been using remake as a replacement for make on my development machine and am yet to run into any issues.

alias make=remake

Now you can use

make --trace

to get better information on why a target is being built/rebuilt.

The -B option of remake triggers an unconditional rebuild of a specified target.

Related reading 

1. Debugging makefiles with remake - https://www.usenix.org/legacy/events/lisa11/tech/full_papers/Bernstein.pdf
2. Remake home page - http://bashdb.sourceforge.net/remake/
3. Remake GitHub repository - https://github.com/rocky/remake

Parallelizing recursive make 

To ensure the -j N flag is used when doing recursive make, use $(MAKE) when invoking the submake. This ensures that the gmake jobserver is used correctly. Otherwise you might see warnings such as

make[1]: warning: jobserver unavailable: using -j1.  Add '+' to parent make rule.

Related reading 

1. How the make variable works - https://www.gnu.org/software/make/manual/make.html#MAKE-Variable
2. GNUMake Jobserver Implementation - http://make.mad-scientist.net/papers/jobserver-implementation/
3. Recursive make considered harmful - http://aegis.sourceforge.net/auug97.pdf

Miscellaneous 

Handling symbolic links 

When one of the dependencies is a symbolic link, make checks the modification time of the file referenced by the link. This is sensible behaviour and probably the reason it is not called out in the gnu make manual.

There is also the “-L” option which causes make to consider the modification time of the symlink as well. This is option is useful when one wants to “touch symlink” and run make.

`-L'
`--check-symlink-times'

    On systems that support symbolic links, this option causes make to consider the timestamps
    on any symbolic links in addition to the timestamp on the file referenced by those links.
    When this option is provided, the most recent timestamp among the file and the symbolic
    links is taken as the modification time for this target file.