Jayesh Bhoot's Ghost Town – All Posts

My understanding of SBI Max Gain loan account

2026-03-10T02:53:56.000Z

Note: This is my rudimentary, superficial, not-yet-verified understanding of SBI Max Gain account. Please verify with a qualified person (like an SBI branch manager) before making a financial decision.

Some banks in India offer a loan overdraft facility, where your loan account is also an overdraft account. You can park extra funds in it, which, while earning zero interest, would reduce the principal of the loan during interest calculation.

SBI Max Gain account is such a facility from State Bank of India. I have this account for my home loan.

After getting stumped for a long time by a mismatch between my finance sheet and the available balance shown in my Max Gain account, I sat down to understand it. In the process, I noticed a nuance, which when discovered, seemed like a given.

The basic rule is this: For a Max Gain account, any reduction effected in the principal amount of the loan, apart from the one effected according to the amortised schedule, is temporary and withdrawable.

Let's see how this plays out in different scenarios.

EMI payments

Keeping in mind the unpredictability of the floating interest rate, I have set up my monthly payments to be higher than the scheduled EMIs.

In a normal loan, such a payment would be split into: pre-calculated interest of that month; pre-calculated principal amount for that month; and excess goes to principal payment. The third component reduces the total principal amount faster than the amortized schedule would.

In SBI Max Gain, the treatment is similar, but with a slight twist: the excess goes to the overdraft account, where it reduces the principal amount of the loan for the time it sits there, and is also withdrawable.

Part payments or pre-payments

Another way to reduce principal amount is to make explicit part payments. There is a general tendency to pay back a loan as fast as affordable. Part payment is the main tool for it, where you repeatedly, as and when convenient, pay back the principal amount ahead of the amortised schedule.

In a normal loan, while a part-payment permanently reduces the principal amount by that amount, you also part with that amount permanently.

In Max Gain, a part-payment is just depositing whatever lumpsum you have in the overdraft account. The principal amount of the loan is reduced only for the time it sits there. There is no permanent reduction of the principal amount other than what the amortised schedule effects. But that amount also remains available to you.

Now imagine that over the years, for a normal loan of 50 lakhs, the part payments have amounted to 30 lakhs. In Max Gain, those 30 lakhs basically sit in the overdraft account, still usable for other purposes.

One might think it an idiocy to just let 30 lakhs stew in a zero-interest earning bank account. Why not invest them? First, disposable income would already be responsibly and proportionately split between investments and part payments, thus taking care of investments beforehand. Second, in case of the normal loan, the part payment amount is permanently gone. At least its still available in case of Max Gain.

There is a catch

My bank branch told me that there is a cap on the amount that would reduce the principal of the loan. So if the principal is 50 lakhs, then that cap could be around 30 lakhs. Overdraft balance beyond 30 lakhs don't reduce the loan principal. Its best to inquire with the branch manager.

Foreclosing a loan

While I haven't yet verified it with the bank, I imagine I would accummulate the part-payments in the overdraft account until its equal to the outstanding principal amount, then just hand over the overdraft funds to the bank for foreclosure.

In closing

I believe I have made good use of the account so far. I keep a few of my funds parked there - emergency fund; periodic expenses (non-monthly) fund; one-off expenses (large expense, vacation, etc.) fund.

I have only just wrapped my head around the nature of part-payments in Max Gain. Once I become comfortable with the idea, I might even employ it.

A primer on car insurance (in India)

2025-12-27T20:58:56.000Z

The concept of car insurance

Suppose a mishap occurs that involves your car and someone else. One or more of the following unfortunate outcomes can happen:

Someone's property is damaged.
Someone is harmed, physically or lethally.
Your car is damaged, reparably or not.
You or your passengers are harmed, physically or lethally.

The concept of car insurance aims to alleviate the first three outcomes. For the fourth, a proper health and life insurance should be in place.

Damage to someone or their property

The someone involved in the mishap could seek compensation for damages caused to them or their property. A third-party policy (TP) covers this damage. A TP is a legal requirement in India so that when someone raises a claim, this policy automatically kicks in.

Damage to own car

An own damage policy covers damage to your own car. Fixing a car is an expensive affair. While this coverage is not legally mandated, it makes financial sense to purchase one.

Much of the insurancebabble orbits the own damage policy.

There are several ways to get your car damaged - accident resulting in partial damage; accident resulting in irreparable damage, also called total loss; theft; natural disasters like flood, storm, earthquake, etc.

A basic own damage policy usually covers the above clauses.

One can choose to buy add-ons to a basic own damage policy, which provides extra layers of coverage, but also increase the premium. These add-ons are usually offered only for the first 3 to 5 years of a car's life.

Zero depreciation

A car is a depreciating asset. The insurer takes this into account, and by default, only pays out at a depreciated rate of the repaired or replaced parts. A zero depreciation add-on ensures that the insurer pays out at the full rate.

Return to Invoice

Depreciation also comes in play in theft or total loss, when the car has been irreparably damaged. In such an event, the insurer pays out the current market value of the car, i.e., manufacturer price minus cumulative yearly depreciation. This maximum sum set by insurer is called Insured Declared Value (IDV). So, a claim of theft or total loss is capped at IDV. Insurers provide a Return to Invoice add-on to set the maximum assured value at the original invoice value, including registration cost and road tax.

Engine cover

A basic own damage policy also does not cover engine damage caused by water or oil leakage. An Engine Protect add-on is required to cover this type of damage. I am still confused about whether a basic own damage policy would cover any engine damage caused by a flood since it covers damage caused by natural disasters.

No Claims Bonus

If you didn't make use of your own damage policy in a year, you become eligible for a 20-25% deducation on the premium at the time of policy renewal. This is essentially the No Claims Bonus.

Comprehensive policy

You may choose to buy third-party and own damage policies separately, from different insurers. Or you can choose to buy a comprehensive policy from an insurer, which includes both of them.

How I renewed my own damage policy

My car (Honda Elevate) came with a comprehensive policy issued through the dealership. It was comprised of a 3-year third-party policy and a 1-year own damage policy with the same insurer (Royal Sundaram).

When time came to renew the own damage policy, I gathered quotes from the dealership for those insurers with which they had a cashless tie-up at their garages. Then I generated quotes for the same parameters from these insurers' official websites, to gauge the commission the dealership would receive.

To my surprise, the quotes generated from the official website were on par with or even pricier than the quotes from the dealership. So I went back to the dealership, negotiated the premium down a bit further, and purchased a policy from them.

In closing

There are two types of car insurance policies - third-party policy to cover damage caused to someone else, and own damage policy to cover damage caused to your own car. The rest are add-ons.

When you encounter the term zero dep insurance, keep in mind that zero dep insurance = own damage policy + zero depreciation add-on.

Also, comprehensive policy = own damage policy (with or without add-ons) + third-party policy.

Improved font rendering in Guix

2025-11-20T18:43:21.000Z

There is a neat trick to make fonts on Linux look thicker and smoother and sharper. Set the following variable in /etc/environment:

FREETYPE_PROPERTIES="cff:no-stem-darkening=0 cff:darkening-parameters=500,400,1000,350,1500,325,2000,300 autofitter:no-stem-darkening=0 autofitter:darkening-parameters=500,400,1000,350,1500,325,2000,300"

FREETYPE_PROPERTIES is set in /etc/environment so that it sticks as a global configuration. You can see the effect in the following screenshots stitched together from before and after applying the configuration:

Left-hand side - fonts in browser before applying the configuration. Right-hand side - fonts after applying the configuration look thicker and sharper.

Left-hand side - fonts in terminal before applying the configuration. Right-hand side - fonts after applying the configuration look thicker and sharper.

I was able to set FREETYPE_PROPERTIES in Guix with the help of a great tip from Lo Peter on how to set a global environment variable in a Guix system.

Here is the final configuration, to be put in the Guix system's configuration file (I call it os.scm).

(operating-system
 (services
  (cons*
   (simple-service
    'global-environment-variables
    session-environment-service-type
    '(("FREETYPE_PROPERTIES" . "cff:no-stem-darkening=0 cff:darkening-parameters=500,400,1000,350,1500,325,2000,300 autofitter:no-stem-darkening=0 autofitter:darkening-parameters=500,400,1000,350,1500,325,2000,300"))))))

`git stage` over `git add`

2025-07-01T05:57:08.000Z

I've come to prefer git stage to git add. The former is a synonym of latter, but makes the intent clearer.

man git-add says:

Add file contents to the index

man git-stage says:

Add file contents to the staging area

For all purpose, index in git parlance means staging area (as far as I know), but the latter language feels more in sync with how git talks about staging/unstaging in git status.

But it might just be because I grew up on the staging parlance.

As usual, feel free to shine a light on any ignorance on my part.

On Stephen Baxter's Manifold books

2025-06-20T09:57:32.000Z

So I finished Stephen Baxter's World Engines duology yesterday. I have some thoughts.

Setting aside its excruciatingly slow pace, it neatly ties back to Baxter's another series — the Manifold trilogy.

The 3 books of the trilogy are not sequential, but only thematically connected.

Each book attempts to resolve Fermi's paradox — we live around one septillion (24 zeroes after 1) stars. So its highly likely that the intelligent alien life somewhere. Then why haven't we come across some evidence for it?

The first book — Manifold: Time — concludes that we are truly alone. Humanity and its creations live on until the death of the universe, but never finds other intelligent lifeforms. Life on Earth is a rarest of the rare exception (which, by the way, we seem to be squandering instead of cherishing). Pretty dour end.

The second book — Manifold: Space — hypothesises that intelligent life is actually everywhere, but regular cosmic—level catastrophes wipes a civilisation out before they get to live long enough to come across another celestial civilisation.

The third book — Manifold: Origin — digs deep into the term Manifold, and veers into multiverse. It suggests that humans and their creations are indeed the only intelligent lifeforms, but we are segregated across different universes, so can't find each other without divine intervention from our advanced future selves.

Apparently not content with the conclusion, Baxter wrote the World Engines duology, where he extrapolates the first and third books, Time and Origin. Our descendants, close to the death of the universe, are determined to do something about us being the only intelligent lifeforms in the universe. They reach back through time to reshape the universe into a multiverse, thus allowing creation of several Earths. Then they seed these Earths with the original Earth's life, thus allowing life to evolve on diverse paths.

Such a grand concept, muted by weak characters and uninteresting and slow writing.

I think its time for me to take a break from Baxter. I cherish his Flood, Ark, Landfall trilogy. I think his Evolution should be a part of our school curriculum. But I cannot, for the life of me, slog through his recent novels anymore.

Tip for my future self: If Emacs throws an arcane error — `project--read-file-name: Wrong type argument: stringp, nil` — while trying to find a file in a git project (`C-x p f`), then one likely reason is that the git project is empty.

2025-05-15T07:26:35.000Z

Tip for my future self: If Emacs throws an arcane error — project--read-file-name: Wrong type argument: stringp, nil — while trying to find a file in a git project (C-x p f), then one likely reason is that the git project is empty.

Solution? Make sure you have something inside the git project. Even a staged file is enough.

How I configured OS-specific fonts in Emacs

2025-04-22T19:40:38.000Z

Here is the Elisp snippet:

(let ((font-value (cond
                   ((eq system-type 'gnu/linux)
                    "Source Code Pro-12:weight=medium")
                   ((eq system-type 'darwin)
                    "Source Code Pro-17:weight=medium"))))
  (add-to-list 'default-frame-alist `(font . ,font-value)))

Things I learned while creating this snippet:

system-type variable in Elisp identifies the operating system.
A quote ' does not evaluate the entire quoted expression, but a backquote ` allows evaluation of sub-expressions marked with a comma ,, inside the quoted expression. Hence, `(font . ,font-value), where font-value is evaluated to the font value it got in its let binding, before the parent expression is quoted.
The syntax to configure font properties. When I last tried Emacs more than 5 years ago (or more), I was stumped by a plethora of solutions on the internet to specify font properties, none of which had worked. Part of why I had abandoned Emacs back then. This time, I was able to figure it out, thanks to the official doc that describes the syntax to specify a font.

I am sure there is a better way, but I have only recently started tinkering with Emacs and ELisp. I mean I still nest a sexp by manually adding parentheses before and after the sexp, like a caveman!

A case of unsoundness in TypeScript

2025-03-26T10:08:33.000Z

TypeScript provides a construct called a call signature to annotate a callable object with properties in JavaScript. For example, think of a function identity, i.e., a callable object, with a property whoAmI:

function identity(arg) {
  return arg;
}
identity.whoAmI = "I am Identity Man";

Note that the above callable construct requires two statements to construct itself. Now, let's use TypeScript's call signature feature to annotate it:

interface IIdentity {
  (arg: number) : number
  whoAmI: string
}

const i : IIdentity = (arg) => arg;
// GOOD: compilation error until the following line is added.
i.whoAmI = "I am Identity!";

So far, so good. However, the following code also type-checks without any compilation errors:

interface IIdentity {
  (arg: number) : number
  whoAmI: string
}

const i : IIdentity = (arg) => arg;
// BAD: the following line compiles even if the callable's construction isn't finished yet.
console.log(i.whoAmI.toLowerCase());
i.whoAmI = "I am Identity!";

The above code of course throws a runtime error: i.whoAmI is undefined.

I don't see a reason why TypeScript cannot ensure that any reference to the non-existent components of a half-constructed callable is illegal until the callable is fully constructed...except for performance reasons. Performance is also why TypeScript does not infer paramter types of a function automatically even though it lets you infer their types, individually, on-demand, through IDE tooling.

Link to the conversation thread that led to this post.

Understanding various syntaxes to annotate a function's type in TypeScript

2025-03-21T10:34:21.000Z

The underlying principles

I was able to boil it all down to the following:

Either individually annotate the function parameters and its return value with their respective types; or
annotate the variable that holds a function with the function's type.

Detour - ways to define a function in JavaScript

Here is a probably non-exhaustive list.

Function declaration

This form requires that a name be given to the function.

function identity(v) {
  return v;
}

Function expression

This form resolves to a function value which must then be bound to a variable, or must be used immediately, for example, as a callback.

// as a callback
[1, 2, 3].map(function (v) {
  return v;
});

// assigned to a variable
const identity = function(v) {
  return v;
}

An anonymous (or orphan(?)) function expression - without being used as a callback or assigned to a variable - is illegal at the top level, because it cannot be distinguished from a function declaration. So the following form is illegal at the top level:

>> function (v) {
  return v;
}
Uncaught SyntaxError: function statement requires a name

A function expression can be named too.

const identity = function id(v) {
  return v;
}

Arrow function expression

Unlike its function expression counterpart, an anonymous arrow function expression is legal, but useless, at the top level.

>> (v) => {
  return v;
}
// Console output:
function (v)
  length: 1
  name: ""
  // ...

An anonymous arrow function expression is best used as a callback.

[1, 2, 3].map((v) => {
  return v;
});

An arrow function expression can be assigned to a variable.

const identity = v => v

Syntax #1 - annotate the function parameters and its return value

Most straightforward. All of the function forms can be annotated with this approach. But a function declaration can be annotated only through this approach.

Remembering the position of type annotations of the parameters is easy enough. But the return value type is placed between the parameter list and the body of the function.

For a function declaration and function expression, this means that the return type is placed between the parameter list and the opening brace { of the function body. For an arrow function, it is placed between the parameter list and the arrow =>.

// function declaration
function identity (v: number): number {
  return v;
}

// function expression
[1, 2, 3].map(function (v: number): number {
  return v;
});

// arrow function expression
const identity = (v: number): number => {
  return v;
}

// arrow function expression as a callback
[1, 2, 3].map((v: number): number => {
  return v;
});

Syntax #2 - Annotate the variable that holds a function expression

In this approach, simply annotate the variable name just like any other variable. Only that you have to annotate it with the type of the function expression.

This format is called function type expression, because they are used to type a function expression (and not a function declaration).

The format of a function type expression is confusingly similar to that of an arrow function expression: (param: type) => return_type.

Unintuitively, in a function type expression, parameter names are necessary, but not their types - any type is assigned by default.

For a JavaScript function expression:

const identity = v => v

// or
const identity = function(v) {
  return v;
}

annotate it by simply sticking the type expression between the variable name identity and the = preceding the function body:

const identity: (v: number) => number = v => v

// or
const identity: (v: number) => number = function(v) {
  return v;
}

As I said before, a function type expression worsens readability because it is confusingly similar to an arrow function expression. We can separate the function type expression by defining it as a type:

type identityFn = (v: number) => number;

const identity: identityFn = v => v;

// or
const identity: identityFn = function(v) {
  return v;
}

Now, this looks similar to any other variable annotation: const a: [string, number] = ["hello", 1].

Syntax #3 - annotate a function expression as an object type

More of an edge case, but worth distinguishing it from the rest.

A function is an object and can have properties. If you want to type a function as an object type, then you have to type the callable function with a format called call signature inside the object type. This format is similar to how you would annotate a function declaration's parameters and its return type.

type IIdentity = {
  // call signature
  (v: number): number,
  // other properties, if any
  whoAmI: "I am identity man"
}

// or
interface IIdentity {
  // call signature
  (v: number): number,
  // other properties, if any
  whoAmI: "I am identity man"
}

const identity: IIdentity = v => v;
identity.whoAmI = "I am identity man";

This syntax leaves room to create an unsound use case, as explained in a later post.

JavaScript function declaration v/s arrow function in a browser console

2025-03-20T13:33:12.000Z

I often like to develop and test small JavaScript code directly in a browser console.

In this environment, a function declaration has an advantage over an arrow function – I can re-define & re-run a function declaration repeatedly in a browser's console.

>> function strIdentity(v) {
  return v.toUpperCase();
}
undefined

>> function strIdentity(v) {
  return v.toLowerCase();
}
undefined

>> strIdentity("HELLO");
"hello"

On the other hand, re-running an arrow function, which have to be assigned to a variable to be usable at the top level, would throw a re-declaration error, because the same variable cannot be re-declared again.

>> const strIdentity = v => v.toLowerCase();
undefined

>> // editing the above script

>> const strIdentity = v => v.toUpperCase();
Uncaught SyntaxError: redeclaration of const strIdentity

Someone's high hopes- to dash or not to dash

2025-03-06T12:13:15.000Z

Someone close to you is brimming with optimism – that something they are anticipating is going to transpire in their favour. They have rationalised all related events to point to their success. Be it a test, an interview, a pregnancy test, or whatever.

You, having witnessed several such cycles of hope and disappointment by now, feel an urge – an urge as high as their high hopes – to temper this optimism. What do you do?

A matrix of emotions

Let's try to chart the state of their emotions in different scenarios.

	How do you handle their high hopes?	Their emotional state before the event	Event transpires	Their emotional state after the event
1	You try to temper their hopes	They are clouded with doubt, feel unsupported	They succeed	They feel joyful, content
3	You stay hopeful too	They feel hopeful and optimistic	They succeed	They feel joyful, content
2	You try to temper their hopes	They are clouded with doubt, feel unsupported	They fail	They are disappointed, potentially resentful due to perceived lack of support
4	You stay hopeful too	They feel hopeful and optimistic	They fail	They are disappointed

The point here is that, in the cases where they fail, the intensity of their disappointment would probably remain the same, whether or not you had tried to temper their hopes. So why not let them have their positive state of mind for a longer period?

The catch is that you can't just look hopeful for the sake of it. You have to feel it. Otherwise, having had to hide your true feelings, you run the risk of feeling frustrated yourself!

Of course, the worst case is that you are overcome with the sentiment of I told you so.

Copying all files of a directory, including hidden ones, with `cp`

2025-02-20T17:15:58.000Z

There are two directories - a non-empty src and an empty dest. My aim is to copy all the files in src inside dest, including hidden files.

$ ls -a src
.  ..  .hidden  unhidden

$ ls -a dest
. ..

src dir contains a normal file named unhidden and a hidden file called .hidden

Solution - `cp -R src/. dest`

I want to cut to the chase, so here is the command: cp -R src/. dest.

$ cp -R src/. dest

$ ls -a dest
. .. .hidden unhidden

The src/. construct performs the magic.

I was more interested in figuring out why src/. makes this happen. It felt counter-intuitive to me – src/. simply refers to the . entry in the src directory, i.e., it refers to src itself. A command like cp -R src dest should have copied the entire src directory inside dest, ending up with a structure like dest/src/{.hidden,unhidden} instead of dest/{.hidden,unhidden}.

Why does it work?

After some faffing about, I found the algorithm used by cp as documented in POSIX. Below is the relevant portion of the algorithm.

cp -R source_file target
If target exists and names an existing directory, the name of the corresponding destination path for each file in the file hierarchy rooted in each source_file shall be the concatenation of target, a single >slash< character if target did not end in a >slash<, and the pathname of the file relative to the directory containing source_file. [Emphasis added]

I tried to understand the algorithm by building path for src/.hidden file. According to the algorithm, the path of a target file is a concatenation of:

target (dest in our case) +
/ if needed (which we do) +
relative pathname of the target file, starting from the directory that contains the source_file. I am interpreting heavily now – in our case of src/., the directory containing . is src. So the pathname for the file .hidden , relative from src, would become: ./.hidden.

Thus, the built path for the hidden file .hidden becomes: dest/./.hidden, which is equal to dest/.hidden.

Similarly, for the normal file unhidden, the built path becomes dest/./unhidden, which is equal to dest/unhidden.

Proximity of an error in static and dynamic languages

2025-02-19T14:09:43.000Z

A thread on Hacker news got me thinking today. The debate was around type validation. I wrote the following there.

...point is that a bad payload will fail right at the serialisation boundary in case of .NET. We know the problem right there. Now we only need to fix the bad payload.

For TypeScript with only types and without validation, a bad payload gets through, and there is no telling where in the workflow it will explode. This could waste more time and developer resources in debugging.

In software development, I feel that a runtime error could be judged by two aspects.

How far away is the error thrown from the actual problem?
If the error is thrown right at the actual problem, or as close as possible to it, then how good the error is at explaining the problem?

In my experience, dynamically-typed languages do worse in the first test. Whenever that is a case, the second test becomes moot.

Statically-typed languages, of course, do relatively better than dynamic languages in the first test. They often fail in the second test though. Newer crop of statically-typed languages like Elm and Rust are trying to improve.

An example - a web service

Think of a web API. An API endpoint written in a static language would not just define the type of an incoming payload, but would also have to perform a mandatory serialisation. In fact, in most cases, the framework/library being used does the serialisation automatically (through reflection and such).

In contrast, for an API endpoint written in a dynamic language, not only the type of the incoming payload is absent, but the serialisation is also user's responsibility. A bolted-on type system like TypeScript can help define the type and the subsequent access of the payload in the code, but it cannot help with the serialisation aspect. A bad payload is a runtime problem, and TypeScript types are long gone by then.

Consider a web service with two endpoints.

/GET /increment/:number, which returns :number + 1.

/POST /change-case, which accepts a JSON payload of the following format.

# Payload Structure
{
  "operation": "string",
  "operand": "string"
}

# Sample 1
{ "operation": "upper", "operand": "Hello"}
# => should return upper-cased "HELLO"

# Sample 2
{ "operation": "lower", "operand": "woRLD"}
# => should return lower-cased "world"

# Sample 3
{ "operation": "invalid", "operand": "woRLD"}
# => should return the original string "woRLD"

Now let's build this service in a statically-typed language. I chose Scala.

Scala service

I used the tiniest HTTP framework I could find in Scala - Cask.

//> using dep com.lihaoyi::cask:0.10.2

enum Op:
  case Lower, Upper

object MinimalApplication extends cask.MainRoutes {
  @cask.get("/increment/:num")
  def getArticle(num: Int) = {
    num + 1
  }

  @cask.postJson("/change-case")
  def changeCase(operation: String, operand: String) = {
    operation match
      case "lower" => operand.toLowerCase()
      case "upper" => operand.toUpperCase()
      case _ => operand
  }

  initialize()
}

Let's test the endpoints with bad payloads.

# POST /change-case
# Bad payload 1: "operand" is missing.
$ curl -X POST http://localhost:8080/change-case --data '{ "operation": "lower"}'

# Response is an error
Missing argument: (operand: String)
Arguments provided did not match expected signature:
changeCase
  operation  String
  operand  String

# GET /increment/:num
# Bad payload: string instead of an integer
$ curl -X GET http://localhost:8080/increment/yo

The following argument failed to parse:

num: Int = "List(yo)" failed to parse with java.lang.NumberFormatException: For input string: "yo"
java.lang.NumberFormatException: For input string: "yo"
        at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
        at java.base/java.lang.Integer.parseInt(Integer.java:662)
        at java.base/java.lang.Integer.parseInt(Integer.java:778)
        at scala.collection.StringOps$.toInt$extension(StringOps.scala:910)
        at cask.endpoints.QueryParamReader$.IntParam$$superArg$1$$anonfun$1(WebEndpoints.scala:69)
        at cask.endpoints.QueryParamReader$SimpleParam.read(WebEndpoints.scala:62)
        at cask.endpoints.QueryParamReader$SimpleParam.read(WebEndpoints.scala:62)
        at cask.router.Runtime$.makeReadCall$$anonfun$7(Runtime.scala:45)
        at cask.router.Runtime$.tryEither(Runtime.scala:6)
        at cask.router.Runtime$.makeReadCall(Runtime.scala:45)
        at MinimalApplication$.$anonfun$4$$anonfun$1(main.scala:20)
        at scala.collection.immutable.List.map(List.scala:247)
        at scala.collection.immutable.List.map(List.scala:79)
        at MinimalApplication$.$anonfun$4(main.scala:20)
        at scala.collection.LazyZip3$$anon$9$$anon$10.next(LazyZipOps.scala:171)
        at scala.collection.immutable.List.prependedAll(List.scala:153)
        at scala.collection.immutable.List$.from(List.scala:685)
        at scala.collection.immutable.List$.from(List.scala:682)
        at scala.collection.BuildFromLowPriority2$$anon$11.fromSpecific(BuildFrom.scala:115)
        at scala.collection.BuildFromLowPriority2$$anon$11.fromSpecific(BuildFrom.scala:112)
        at scala.collection.LazyZip3.map(LazyZipOps.scala:165)
        at MinimalApplication$.$anonfun$3(main.scala:20)
        at cask.router.EntryPoint.invoke(EntryPoint.scala:47)
        at cask.router.Decorator$.invoke$$anonfun$2(Decorators.scala:59)
        at cask.endpoints.WebEndpoint.wrapFunction(WebEndpoints.scala:14)
        at cask.endpoints.WebEndpoint.wrapFunction$(WebEndpoints.scala:10)
        at cask.endpoints.get.wrapFunction(WebEndpoints.scala:31)
        at cask.router.Decorator$.invoke(Decorators.scala:52)
        at cask.main.Main$DefaultHandler.handleRequest(Main.scala:123)
        at io.undertow.server.Connectors.executeRootHandler(Connectors.java:395)
        at io.undertow.server.HttpServerExchange$1.run(HttpServerExchange.java:861)
        at org.jboss.threads.ContextHandler$1.runWith(ContextHandler.java:18)
        at org.jboss.threads.EnhancedQueueExecutor$Task.run(EnhancedQueueExecutor.java:2513)
        at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.run(EnhancedQueueExecutor.java:1538)
        at org.xnio.XnioWorker$WorkerThreadFactory$1$1.run(XnioWorker.java:1282)
        at java.base/java.lang.Thread.run(Thread.java:1583)

expected signature:

getArticle
  num  Int

In the examples above, the error points to the actual problem, passing the first test. Of course, the presentation probably fails the second test.

Now let's build the same service using TypeScript.

TypeScript service

I used the framework most familiar to me - Fastify.

import Fastify from 'fastify'

type Params = {
  num: number;
}

const fastify = Fastify({
  logger: true
})

fastify.get<{ Params: Params }>('/increment/:num', async function handler(request, _reply) {
  const params = request.params;
  return params.num + 1;
});

type Op = {
  operation: string;
  operand: string;
}

fastify.post<{ Body: Op }>('/change-case', async function handler(request, _reply) {
  const body = request.body;
  switch (body.operation) {
    case 'upper':
      return body.operand.toUpperCase();

    case 'lower':
      return body.operand.toLowerCase();

    default:
      return body.operand;
  }
});

try {
  await fastify.listen({ port: 3000 })
} catch (err) {
  fastify.log.error(err)
  process.exit(1)
}

Here, the TypeScript types Params and Op certainly aid in writing the code, but let's see how the service deals with bad payloads.

# POST /change-case
# Bad payload: "operand" is missing.
$ curl -X POST \
-H 'Content-Type: application/json' \
  http://localhost:3000/change-case \
  --data '{"operation": "lower"}'

# Response error
{
  "statusCode":500,
  "error":"Internal Server Error",
  "message":"Cannot read properties of undefined (reading 'toLowerCase')"
}

The error we see above is quite removed from the actual problem, i.e., missing operand.

GET /increment/:num doesn't even throw an error, but returns an incorrect value.

# GET /increment/:num
# Bad payload: string instead of an integer
$ curl -X GET http://localhost:3000/increment/hello

# Incorrect response, no error
hello1

Now, I know that the TypeScript service is missing the serialisation-cum-validation portion. Even Fastify docs recommend serialisation. But that's the point - its a recommendation, its optional. Also, its quite explicit and verbose as seen in the above link.

In closing

I should note that this post is more a thought vomit than a claim of what is better or worse. When I started writing, I only had the first section - the two tests of an error - in mind. I am neither glorifying Scala, not bashing TypeScript or JavaScript. I recognise that having to explicitly add serialisation is probably not a dealbreaker. I also recognise that all statically-typed langauges may not even support implicit serialisation (but probably do mandate serialisation).

That's all.

Design Rework #1 - reworking my university hoarding

2025-02-17T10:14:23.000Z

Original hoarding

I found this hoarding while passing by my university - VNSGU.

The hoarding, on the left hand side of the university gate, lays out a vertically laid-out slogan I am in VNSGU, and also sports the VNSGU logo, cradled by the vertical slogan.

Problems in the original

No alignment between anything. Even the starting letters of each word of the vertically written slogan are misaligned.
Lack of focal point. The word am is needlessly highlighted with a colour.
Abysmal contrast between text and background

Rework

Find a strong alignment - between words of the vertically laid-out slogan, as well as between the slogan and the logo.
Find a focal point. Repeat the colour of the logo in this word to highlight the two most important elements - logo and the word VNSGU
Use a good contrast of colour between the text and the background.

I ended up with two variants - the first uses a complementary colour set, where the colour of the logo complements the background colour.

The other uses a monochromatic colour set, where the background colour is set to a tint of the logo colour.

Figma resources

You can find alternate final designs in my Figma file linked below.

In closing

Even though the design looks like an improvement to my eyes, both the complementary and the monochromatic colour schemes score a terrible contrast level in the Accessible Colour Palette Tester. I am at a loss about how to resolve it.What I do understand now is that a complementary colour relationship between background and foreground colour doesn't automatically provide a good contrast.

Making tanstack docs more accessible with Stylus

2025-02-17T05:57:43.000Z

This post adds another Stylus fix to the list written by wezm.

My mouse/trackpad is configured to auto-click on rest/hover. Over time, I"ve developed a habit of resting the cursor on any white space of a webpage.

Tanstack.com hosts a collection of headless web widgets to develop web applications. Now, in the tanstack docs, each heading is a clickable anchor, but the clickable area also spans the whole width of the content area. When I subconsciously rest my cursor on the white space besides a heading, the heading and contents are suddenly yanked to the top.

Here is the Stylus fix:

a.anchor-heading {
    display: inline;
}

Now, the heading still remains an anchor, but the white space besides the heading text stays out of the clickable area.

Update: 19 Feb 2025

Tanner Linsley, the founder of the tanstack ecosystem, saw this post on Bluesky, and prompted me to submit a PR to fix this problem. The PR is now merged.

Use cases for `<form method="dialog">`

2025-01-15T10:52:16.000Z

I've started using a relatively less known value of the <form> element's method attribute, called dialog, for the following scenarios:

when a form is submitted via AJAX.
when a form is a multi-step wizard, where each step is a form in itself, and I have to accummulate values from each step.

But what about MDN using it in a `<dialog>` element?

MDN reference defines method="dialog" as:

When the form is inside a <dialog>, closes the dialog and causes a submit event to be fired on submission, without submitting data or clearing the form.

But the HTML spec, having been written in officialese and being the more authoritative source than MDN, provides a nice escape hatch.

The spec defines method="dialog" as follows (emphasis mine):

Indicates the form is intended to close the dialog box in which the form finds itself, if any, and otherwise not submit.

My interpretation is that method="dialog" has two jobs:

If a <form> using method="dialog" is located inside a <dialog> element, then its submission causes the dialog to close.
method="dialog" also does not really submit the form, i.e., it fires the submit event, but leaves the actual submission to further programming, like AJAX. As a nice side-effect, I don't have to fire an explicit ev.preventDefault().

Am I wrong? May be. Please let me know in the comments.

Name your SQL constraints

2024-12-09T07:05:18.000Z

I learnt the hard way, while trying to amend the structure of a database instantiated at more than one place, that its best to explicitly name the SQL constraints like a foreign key.

Trying to adjust a foreign key constraint by referring it to its implicit name felt like holding on to a falling person just with their shoe. I could never be sure that the implicit name would be identical across different instances of the database.

Also, in MySQl at least, there was no foolproof way to dynamically query for the implicit name.

Connecting to MySQL running on NixOS on local network

2024-12-07T08:27:23.000Z

The big picture

This setup aims to allow connections to a MySQL database hosted on my NixOS workstation, only on local network.

I needed to configure MySQL to listen to connections on network interfaces. I also needed a MySQL user who is authorised to connect from a host on local network. Then, I needed to configure NixOS to open up the port used by MySQL.

Configure MySQL to listen to remote connections

NixOS features a service to configure MySQL, including the ability to configure MySQL's my.cnf. So it took only a few lines to get MySQL up and running.

# in /etc/nixos/configuration.nix
services.mysql = {
  enable = true;

  package = pkgs.mysql84;

  configFile = pkgs.writeText "my.cnf" ''
  [mysqld]
  skip-networking=OFF

  # listen for connections on all network interfaces, though
  # only one interface at firewall level will be opened up.
  bind-address=0.0.0.0
  '';
};

Configure a remote-enabled MySQL user

I wanted to allow only connections from local network.

A default command CREATE USER 'bhoot'; would create a user which could connect from any remote host.

MySQL follows a username@hostname convention for user accounts, where hostname can use a host_ip/netmask syntax to allow connections only from the local network.


# as root MySQL user
mysql> CREATE USER 'bhoot'@'192.168.100.0/255.255.255.0' IDENTIFIED BY 'my_password';
mysql> GRANT ALL ON my_schema.* to 'bhoot'@'192.168.100.0/255.255.255.0';

Configure NixOS to open up MySQL port

NixOS enables a firewall by default.

I was under the (borrowed) impression that NixOS automatically opens up the ports for enabled services. But that wasn't the case, at least for MySQL.

Opening up the MySQL port was a matter of a single line:

# in /etc/nixos/configuration.nix
networking.firewall.enable = true;
# Open MySQL port, only on the wireless network interface.
networking.firewall.interfaces.wlp0s20f3.allowedTCPPorts = [ 3306 ];

Then, rebuild NixOS.

$ sudo nixos-rebuild switch --flake .

Flossing - do orthodon't. There is no try.

2024-11-19T05:36:29.000Z

Flossing - do orthodon't. There is no try.

Being chill

2024-11-10T04:40:57.000Z

One guiding principle to be a chill person is pretty clear to most people: Let go of what you can't control.

But, to me, another principle is more important, which also gets overlooked: Don't ignore what you can control. Get it done.

The anxiety, the stress and the guilt that piles up from ignoring the latter is more formidable and insidious than not being able to practise the former.

Not doing anything about which you can do something can make you more anxious than not being able to do something about which you can't do anything.

Update on13th December 2024: I thin k that the virtues of patience and perseverance fit somewhere within the get-it-done component. Patience probably also fits in the let-it-go component.

Personal experience

Procrastinators among the readers of this post, which is me, must have felt hard about the second principle.

My wife is an avid 'get-it-done' person, but frets about stuff out of her control, or which lie in the past or the future.

On the other hand, I am an avid 'will-get-it-done' person, but don't give a shit about what I can't control.

Truly, a pair made in heaven!

When I ensure that I get done what I can control, then that sense of accomplishment also helps me put myself at ease about what I can't control.

In closing

Being chill is a lot of work! There are days I just prefer to scream and flail around.

A mental model for Linux file, hard and soft links

2024-11-09T10:36:59.000Z

What makes a file in Linux?

At the storage level, a file is a block of data. There is more to it than just that, but I won't delve deep into it.

At the filesystem level, this block of data is represented as a an abstraction called inode. Think of inode as a data structure that stores metadata about the underlying data block.

A pathname makes this pair of (inode, data block) accessible and usable for humans.

Think of the whole this way - the data block of a file lies in a lower level of abstraction than the pathname (which lives at the filesystem level). inode acts as a bridge - a representative to the data block at the filesystem level.

Components of a file. From bottom up, data block, inode, and pathname

Roughly, file = pathname + inode + data block.

So, when you talk about a file, you may be referring to any or all of these components.

Hard links

Now, if we think of pathnames as labels slapped on an (inode, data block) pair, then we can refer to the same inode with different labels.

Two pathnames /tmp/filename1 and /home/bhoot/filename2 point to the same inode, thus representing two hard links.

In the above figure, /tmp/filename1 and /home/bhoot/filename2 point to the same inode. These two are hard links. A hard link connects a pathname to an inode.

The above figure can be interpreted in several ways:

The pathnames point to the inode, not the other way round. Thus, a pathname is aware of the inode, but the inode is not aware of the pathname.

How is a hard link connection stored?

Its stored in the directory that contains the filename. A directory file is essentially a "table", where each "row" registers a file contained in the directory. Each row is composed of pathname and a pointer to the inode that it points to. That's how a pathname is aware of the inode, but not the other way round.
At this level of abstraction, is it possible to tell which one of the two pathnames originally created the file? I think not. Hard links are supposed to be equal in status to each other.
As a corollary to the above point, there is always at least one hard link attached to a file. When you create a file, say, with touch /a/pathname, you create a hard link between /a/pathname and the file's inode.

Deleting a hard link

Refer to the figure above. If you do rm /tmp/filename1, what should happen from a sane perspective?

Should the command remove the entire /tmp/filename1 + inode + data block combo? Then what happens to the other pathname /home/bhoot/filename2 that points to the same inode?

The right way would be to preserve the integrity of the other pathname /home/bhoot/filename2 while deleting only the targeted pathname /tmp/filename1.

That's what happens when you delete a file - the (hard) link between the specified pathname and the inode is removed.

Similarly, mv f1 f2 creates a new hard link f2 & deletes the old hard link f1.

Representation of one of the two hard links, linked to the same inode, being removed. Only the affected pathname is removed. The inode and underlying data block stay in tact.

What happens when all the hard links to a file are deleted? Now, there are no pathnames in the filesystem that refer to that data block anymore. Thus, the inode is marked for deletion, and the associated data block is orphaned.

When all the hard links to an inode are removed, the entire file, along with its content, is removed from the filesystem.

Soft links

Take a look at the following figure.

A regular file identified by the pathname /home/bhoot/filename2 on the left-hand side. A soft link file identified by the pathname filename3 on the right-hand side. The link file points to the regular file. Both the regular and link files have their own inode and their own data block.

The above figure shows a soft link in blue colour (its blue, right?) pointing from the link file filename3 to the target file /home/bhoot/filename2. A soft link or a symbolic link points a soft link file to a target file..

Thus, a soft link links a link file to a target file. This is in contrast to a hard link, which links a pathname to an inode.

A soft link is a file

As we saw in the What is a file in Linux? section, a pathname is always linked to an inode + data block. This is true in case of a soft link, too. In the above figure, the soft link file filename3, which points to /home/bhoot/filename2, also has its own inode & a data block.

You can check the inode number associated with a pathname with ls -i command. Two hard link files pointing to the same inode will print the same inode number, while a soft link file and its target file will print different inode numbers.

# create a regular file
$ echo "HELLO WORLD HOW ARE YOU?" > file.txt

# create a hard link
$ ln file.txt hardlink.txt

# both hard links refer to the same inode
$ ls -i file.txt hardlink.txt 
17751620 file.txt  17751620 hardlink.txt

# create a soft link
$ ln -s file.txt softlink.txt

# inode of soft link file is different from the target file
$ ls -i file.txt softlink.txt 
17751620 file.txt  17751663 softlink.txt

Contents of a soft link file

How is a soft link relationship stored? In the data block of the soft link file. The content of a soft link is the pathname of the target file it points to.

There are 2 ways to verify this:

readlink filename3 prints the content of the soft link filename3, which is the name of the target pathname.
```
$ readlink filename3
/home/bhoot/filename2
```
stat --format="%s" filename3 prints the size of filename3, which is equal to the number of characters in the name of /home/bhoot/filename2.
```
$ stat --format="%s" filename3
21
```

I/O operations on a soft link file

Copying a soft link file

What happens when you copy a soft link file? ~~Same thing as when a regular file is copied.~~ Or so I thought.

# create a regular file
$ echo "HELLO WORLD HOW ARE YOU?" > file.txt

# check the content size of target file
$ stat --format="%s" file.txt
25

# create a soft link
$ ln -s file.txt softlink.txt

# check the size of the soft link file
$ stat --format="%s" softlink.txt
8

# copy the soft link file
$ cp softlink.txt softlink2.txt

# check the size of the new soft link file, which should be equal to the soft link file
$ stat --format="%s" softlink2.txt
25 # WAT?

What happened there? The cp command simply copied the target file instead of the link file.

My guess is that when those I/O operations, which involve acting on the data block of a file, are ran on a soft link file, they are actually executed on the target file that the soft link file is pointed to.

Thus, cp softlink.txt softlink2.txt would actually copy the target file. Similarly, cat softlink.txt would print the content of the target file. But, mv, which does not need to act on the underlying data block of a file, would just operate on the soft link file itself.

NOTE: When I wrote the couple of struck-out paragraphs above, the purpose was only to have a convenient logic of memorising how I/O operations work on soft links by default. Memorising techniques need not be technically accurate. However, I have struck it out because the logic is also blatantly inaccurate and has been rightly called out by others. By default, cp sure works as described above, but cp -P copies the soft link itself, i.e., the soft link's inode and data block.

Moving a soft link file

What happens when you move a soft link file? This is more predictable. Thankfully, the same as what happens when a regular file is moved - the new pathname entry is created, while the old pathname entry is removed. Because the new pathname still points to the same old inode + data block, it also points to the same target file.

Moving a soft link file replaces the old soft link's pathname with a new one. The new pathname keeps pointing to the same target file.

Moving the target file

A more interesting question worth pondering: what happens when the target file is moved or deleted? Let's go with a case of severe deletion.

Moving or deleting a target file is a more disruptive operation

A soft link file depends on its content to determine which file it points to. Even when the target file is deleted, the content of soft link file doesn't change, i.e., it still keeps pointing to the now deleted target file. With its purpose existing no more, the soft link thus becomes a dangling, dead link.

In closing

In my mind, the terms hard link and soft link are a bit confusing in that they sound like different tools used for a similar purpose. But, a hard link exists as a directory entry that links a pathname to an inode, while a soft link exists as a file that links its own pathname to another pathname.

So, from the perspective of structural existence, hard links actually look softer than soft links.

Also, I'm cursing my 8-hours old self for thinking that I could wrap up this post and get it out in 3 to 4 hours.

The Trumping Joke

2024-11-08T16:00:40.000Z

I was always skeptical about how the Joker takes over the Mob in The Dark Knight.

The Mob looked too powerful, too entrenched for that to happen.

But they bent over.

Then, in the real world, Trump came along, took control of the GOP, and then of the whole country. Twice.

The old guard of the GOP looked too powerful, too entrenched for that to happen.

But they bent over.

Both of them whisked away enough followers from the old guard, converted them into fanatics, loyal to their tall claims.

For every piece of ridiculous fiction, there is a reality out there that outmatches it.

Different kinds of simple

2024-10-01T07:22:39.000Z

This post is syndicated from my response to a Lobste.rs story titled How 1 Software Engineer Outperforms 138 - Lichess Case Study.

The video author talked about simple in terms of fewer lines of code, as in "fewer the features, fewer the lines of code, simpler the codebase". Recently, I chose another kind of simple that increased the lines of code and duplication.

There was a segment implemented in a complex workflow, which contained enough conditionals that I could identify four sub-workflows, which merged back into one at the end of the segment.

When time came to add more conditionals to the workflow, I had a choice to keep going with a single flow, handling conditionals as and when a branch reared its head. This would keep the lines of code to a minimum. But it would also have made the code difficult to follow to someone who was introduced to it for the first time, or even to someone who revisited it after some time.

Or I could split that segment into distinct sub-workflows, at the cost of some duplication. More lines of code, but easier to follow. Later on, once I identify the duplicate (i.e., common) components in those sub-workflows, I could extract some of them to reduce the duplication.

I chose the latter approach. The segment ended up being split into eight distinct sub-workflows. One clear benefit was that the number of bugs in the existing implementation reduced, because logic unique to each sub-workflow got isolated. For the same reason, the code became easy to follow. I hope this choice remains the right choice further down the line. I feel this approach would be easier to follow to a later re-visitor or to a new person.

An unaffiliated side-note: the above re-factoring became possible due to the statically typed language the code was implemented in – ReScript, which has an ML-like type system. It gave me a high degree of confidence in making a fearless re-factoring.

Ki modal editor - first impressions

2024-09-20T12:31:21.000Z

Copy-pasting my comment in a converstion on lobste.rs titled Wonderful vi:

I will put another one in the ring: Ki

Ki is similar to vim in that it uses modal editing.

Its similar to helix in that:

It selects first, then acts on the selection.
It has first-class multi-cursor support
It aims to be low-config
It has built-in LSP support. Adding a new language is a matter of declaring it. (I added 2 on my own yesterday, within 2 hours of using Ki. I could never have dared do this with vim/neovim).

Its different from both vim and Helix in that it splits the mental model into:

selection mode;
movement;
action

such that:

A selection mode sets the current unit - column/character, word, line, syntax node, the latter two of which are semantic units derived from tree-sitter grammar.
Because selection unit is already configured, movements are reduced to hjkl.
Actions, like helix, then act on the current selection.

I think I made the explanation more complicated than the actual execution.

I’ve only been exploring it for a day. Navigation through syntax nodes is impressive, but also heavily reliant on the language’s tree-sitter grammar being decent. Also, I’m not sure how much of a leg up it is against helix’s LSP jump to symbol. But helix’s operations on syntax nodes surely feels like a second thought, when compared to Ki’s.

There are other goodies:

Everything is a buffer. So, same key-bindings are used everywhere.
It has a built-in file-tree explorer (using yaml!), which can be fuzzy-searched too.
Thought-out keybindings. For example, choosing between editor and system clipboard is a matter of \ key. y or p copies or pastes to editor clipboard, while \y or \p copies or pastes to the system clipboard.

How I use `:has()` selector to add table of contents

2024-09-20T11:31:21.000Z

Copy-pasting my comment in a converstion on lobste.rs titled The Undeniable Utility Of CSS :has:

My most recent favourite use of :has was to target insertion of a table of contents (TOC) on pages of my website.

Assuming the following configuration for the static site generator I use (soupault):

[widgets.table-of-contents]
selector = "hgroup:has(h1)"
action = "insert_after"

the :has selector instructs soupault to only insert TOC in those pages which have an h1 heading, and to insert it right after the first hgroup of the page, so that the TOC is located right after the heading + subtitle + timestamp + tags combo.

:has is a selector best used judiciously though due to performance concerns. Firefox (and presumably other browsers) help by displaying a tortoise symbol to flag an unconstrained :has selector.

Forgotten lesson remembered after staring 5 minutes at the screen: `innerHTML` cannot contain a `<script>` tag.

2024-09-12T11:31:21.000Z

Forgotten lesson remembered after staring 5 minutes at the screen: innerHTML cannot contain a <script> tag.

Cool ways to generate a UUID

2024-09-07T11:31:21.000Z

OK, may be not cool enough for Linux veterans, but cool enough for me!

There are two ways, in the order of coolness:

On Linux only: cat /proc/sys/kernel/random/uuid

$ cat /proc/sys/kernel/random/uuid
fa199476-f6f3-4a32-ab89-91d81d9cc319

On Linux and macOS: uuidgen

$ uuidgen
6180fa98-ddd7-4777-a40d-b548db1f3444

On macOS, uuidgen gives a UUID in uppercase. You can pipe it to tr command to translate it to lowercase.

# On macOS
$ uuidgen
58D8D68C-B64D-4E1E-AC0F-B00AFAC1E895

$ uuidgen | tr "[:upper:]" "[:lower:]"
919ae848-df9c-41fa-b59f-de4b933c927c

Choosing curious over judgmental

2024-09-07T10:31:21.000Z

Be curious, not judgmental. I don't know who said it, but I heard it in the TV Show Ted Lasso. And boy, is it cathartic in its own way!

Just being non-judgmental hasn't really worked for me in the past. I needed to replace it with something. Curiosity is a good replacement.

As a pleasant side effect, this approach freed me from the pressure of being right or the fear of being wrong. If you are judging something or someone, you better be right about it. No such stress anymore!

Scripting with Scala

2024-08-24T11:31:21.000Z

Scala 3.5's CLI now makes scripting with scala seamless! Just a single-file script setup!

For example, due to the single-file scripting nature imparted by Scala 3.5 CLI, I was able to embed a Scala script in a node.js project to analyse parsing of a geometric Point stored in MySQL 8. The script is hosted on GitHub.

With Scala 3.5, plus a built-in watcher, and a large scala/jvm ecosystem, Scala has become a good alternative for scripting.

Task failed successfully - Linux edition

2024-08-20T11:00:00.000Z

Written by Jayesh Bhoot

British v/s American comedy dramas

2024-07-07T11:31:21.000Z

They always felt different from each other, but I could never quite put a finger on the difference.

Then it hit me today, while I was watching a British series called Trying.

In American shows, the script feels quite...scripted. Every other dialogue in a conversation is written to be a punchline or a one-liner.

British dramas feel more organic – a conversation goes on with (wry, dry) humour sprinkled here and there.

Stubborn pop-up on Mutual Fund Utilities (MFU) website

2024-06-23T11:31:21.000Z

Table of contents
The problem
The solution

Tip for Mutual Fund Utilities (MFU) users:

While transacting for a new folio, if you are stuck at "Nominee Verify" pop-up even after verifying the nominee(s), then check that:

Whether there are multiple holders of that CAN
Whether *all* of the holders have verified the nominee(s)

The problem

I forgot to take screenshots, but here is a close enough description.

If none of the holders have verified the nominee details, then MFU's interface in this section provides a "Verify nominee" button *only* for the primary holder.

Once a primary holder has verified the nominee details, the interface looks like the verification is already complete. But New Folio transaction will still ask you to Verify Nominee. Very frustrating.

The solution

In order for any holders to verify nominee details, use this link: https://mfuonline.com/CNOMV

Effective Scala, part 8 - OO concepts

2024-05-14T11:31:21.000Z

Flip the perspective on tools like interfaces and traits. Don't see them as a way for objects to share an interface, but as an abstraction over implementations.

So, not: DatabaseAccess -> (InMemoryDatabase, PhysicalDatabase)

but: DatabaseAccess <- (InMemoryDatabase, PhysicalDatabase)

An interface is more usefully seen as:

- DatabaseAccess creates an abstraction barrier so we can ignore which database is used underneath

than as:

- DatabaseAccess allows various databases to share the interface.

The former encourages the view/use of interface as an abstraction over implementation.

Series - Effective Programming in Scala

2024-05-08T11:31:21.000Z

This is a series of articles I wrote while going through the Coursera Course Effective Programming in Scala.

Effective Scala, part 7 - entry point of a project

2024-05-07T11:31:21.000Z

While a scala worksheet are evaluated from top to bottom, a scala project needs an entry point.

Only two requirements:

It needs to be a top-level method or an object-level method, but not a class-level method
It needs to be annotated with @main

Otherwise

It can be named anything.
It can be put in an arbitrary source file.

A source file in a project cannot contain top-level statements (e.g., println), only top-level definitions (def, val, var, trait, object, class definitions) .

Effective Scala, part 6 - Scala Build Tool (SBT)

2024-05-06T11:31:21.000Z

Table of contents
Configurations in build.sbt
Scoping a Setting

src/project dir contains configuration about SBT - build.properties to specify sbt version, plugins.sbt to specify sbt plugins, and so on.

src/build.sbt contains the configuration to build the project itself.

̄An sbt build (build.sbt) is composed of - settings and tasks. A setting parametrises the build, and consists of a key value pair. A task may also by parametrised by settings.

Configurations in `build.sbt`

Compile (default configuration where sbt looks first)
Test
Zero (no specified config, where fallback values live)

Scoping a Setting

Different values can be applied to a single setting by scoped its key.

A key can be scoped along any of the 3 axes:

Configuration. e.g., Compile / sourceDirectory, Test / sourceDirectory
Task. e.g., includeFilter, unmanagedSources / includeFilter where the latter includeFilter is scoped by unmanagedSources task.
Sub-project. e.g., mainProject / scalaVersion, subProject / scalaVersion

Axes can be combined too: subProject / Compile / unmanagedSources / includeFilter. I think the order is: project / configuration / task / key.

Effective Scala, part 5 - collections

2024-04-24T11:31:21.000Z

Table of contents
Infix construct operators
1. Immutable operators
2. Mutable operators
List
Option

Operations on collections can be classified into:

construct ops (::, +:, :+, +, ++);
query ops (size, empty, head, tail, find, filter); and
transform ops (map, fold)

Infix construct operators

There are a shitload of them, most of them with low recall value to a beginner.

Immutable operators

:: to prepend to a List. 1 :: List.empty
+: to prepend to a Sequence collection, including List. 1 +: mutable.ArrayBuffer(2, 3)
:+ to append to a Sequence collection
+ to add a (key, value) tuple to a Map
++ constructs a new collection out of two collections. Map((1, "1"), (2, "2")) ++ Map((4, "4"))

Mutable operators

+=: to prepend to a Sequence collection
+= to append to a Sequence collection
++= concatenates two collections, mutates the first one.

List

A list is constructed from right to left:

1 :: 2 :: 3 :: Nil

Option

Option is actually a collection of zero or one element.

This explains why Option type has a map or filter operations even in OCaml.

No indexed access (opt(0)) though, understandably.

Effective Scala, part 4 - function v/s method

2024-04-21T11:31:21.000Z

A function is a value in Scala, while a method is not. So the former can be passed as a parameter of a function or a method, and can be returned as a value. Method cannot do any of those.

A function is a value in Scala. All values are objects in Scala. An object can have methods. So a function in Scala can have methods.

Any function in Scala has a default apply method. inc(1) is a shorthand for inc.apply(1).

Effective Scala, part 3 - compatibility roulette

2024-04-19T11:31:21.000Z

Table of contents
Problem
Attempt 1
Attempt 2
TL;DR
Conclusion

I am going through the course Effective Programming in Scala on Coursera, and ran into build import errors in the very first assignment (fireworks).

Problem

While importing the fireworks project in VSCode-with-Metals, I encountered an error that started with:

[..]bad constant pool index: [..]

Looks like an error right out of a database connection pool library!

Attempt 1

One of the suggested solutions on Discord was to ensure that the versions of java, scala, and sbt exposed in the PATH are compatible with each other.

Check the compatibility tables.

But these were already compatible in my case.

Attempt 2

I roughly knew that *.sbt files describe the build of a project. Because the name bore relevance to build process, I also counted in a file I noticed in early debugging: build.properties.

So my first small scala project, and I am staring at the following list of *.sbt:

zsh | ~/Downloads
$ tree -a -P "*.sbt" -P "*.properties" fireworks
fireworks
├── assignment.sbt
├── build.sbt
├── project
│   ├── build.properties
│   ├── buildSettings.sbt
│   └── plugins.sbt
└── src

And all of them were staring back at me, daring me to find which one of them is hiding the cause of the error.

Anyway, enough drama.

On a hunch, I decided to match the versions of sbt and scala mentioned in these .sbt files with the ones exposed in the PATH.

The mismatch turned out to be in build.properties.

zsh | ~/projects/effective-scala/week-1/fireworks
$ sbt -V
sbt version in this project: 1.9.9
sbt script version: 1.9.9

$ cat project/build.properties
sbt.version=1.8.2

I matched the versions to be 1.9.9, and re-ran the import. It worked.

TL;DR

Ensure that the versions of java, scala, and sbt exposed in the PATH are compatible with each other. Use the official compatibility tables.
Ensure that the versions of sbt and scala exposed in the PATH match with the versions mentioned in the build files (like built.sbt, build.properties). Best make them identical.

Conclusion

I hope this was the correct solution.

As people who make tools to make people's lives easier, we sure love to torture ourselves with our own tools.

Effective Scala, part 2 - domain modelling

2024-04-16T11:31:21.000Z

Finding the right level of abstraction is more important than the best level of abstraction.

For example, in a problem involving doors and windows and facades, if the domain is constrained to only deal with surface area, then modelling the doors and windows and facade in terms of Rectangle is the right level of abstraction instead of modelling them as Door, Window, and Facade respectively.

Effective Scala, part 1 - elements of a program

2024-04-15T16:31:21.000Z

Table of contents
Value (or Data in this context)
Literal
(Data) Type
Expression
Program
Another perspective on Type

Value (or Data in this context)

A value is the representation of some entity that can be manipulated by a program.

Value is the most abstract definition here, but it is made concrete by subsequent definitions.

Literal

A literal is a text representation of a value in source code.

1 is an integer literal
"1" is a string literal
(x) => x * x is a function literal aka anonymous function in JavaScript
{id: 1, (x) => x * x} is an object literal in JavaScript, etc.

(Data) Type

A data type (or simply type) is a collection of data values.

A type is usually specified by a set of possible values, and a set of allowed operations on these values.

The members of a type are the values of that type.

Expression

An expression is a syntactic entity that can evaluate to a value.

An expression combines literals, constants, variables, and expressions, by applying operations (functions, operators, methods) on them.

1 is an integer literal that is also a simple expression that evaluates to value 1. Value 1 belongs to type Integer.
"Alice" + " Wonderland" is an expression that combines two string literals by applying the operation + on them. Literal "Alice" represents the value Alice. The value Alice belongs to type String. The operation + is an operator/method defined on type String and can be applied on literals, constants, variables that represent a value of type String.
("Alice" + " Wonderland").toUpperCase is an expression in which operation toUpperCase is applied on the expression "Alice" + " Wonderland". The expression "Alice" + " Wonderland" evaluates to a value Alice Wonderland of type String. The operation toUpperCase is a method defined on type String and can be applied on literals, constants, variables that represent a value of type String.

Program

A program expresses a computation. (A computation is any type of arithmetic or non-arithmetic calculation that is well-defined).

A program is a sequence of expressions (and/or statements too, but let's keep it simple here).

1 + 1 is an expression, but also a program which expresses the computation of adding 1 to 1.

Another perspective on Type

Types define the rules for combining expressions. The types define how the expressions can be combined, by applying operations to them. For this reason, operations are also called members of types.

For instance, the && operation (and) is available on the type Boolean, and it expects another Boolean value on its right-hand side. We say that the type Boolean has a member named && (and), which takes another Boolean value as a parameter.

If you try to apply an operation to an expression, whose type does not provide such an operation, it's an error.

An overview of OCaml editor tooling

2024-04-15T11:31:21.000Z

Relevant background

Package and build tooling

Over time, the OCaml community has converged on:

opam as a package manager and a project environment handler
dune as a build system
ocamlformat as a code formatter

Other tools in these spaces exist, but the above two are officially recommended, and relatively more popular.

Editor service - Merlin

Merlin is a "headless" tool which provides modern IDE features for OCaml/ReasonML code.

Supporting OCaml in an editor/IDE is essentially a matter of talking to Merlin.

Editor service - LSP

With the advent of VS Code and Language Server Protocol, ocaml-lsp was built as an LSP wrapper on top of Merlin.

How everything comes together

A glue package integrates the editor service (merlin or ocaml-lsp) with an editor.

The glue package assumes that the editor service is available in the user environment. The recommended approach is to have opam create a project-specific environment (called a opam local switch), and install merlin or ocaml-lsp in that env.

merlin v/s ocaml-lsp

Feature parity

In terms of features, both ocaml-lsp and merlin are pretty much on par with each other.

ocaml-lsp lacks one feature though: determining the type of a selected block of code. Its a pretty nifty feature thanks to OCaml's strong typing system and merlin.

Quoting Marek Kubica from OCaml forums:

The only thing I’ve used with Merlin directly that I don’t have at the moment is determining the type of a selection.

Dependency on dune

ocaml-lsp depends on dune to generate type information. Merlin does not need it. Legacy projects predating dune have found this to be a hurdle in transitioning to ocaml-lsp.

Speed

ocaml-lsp, despite being an abstraction on top of merlin, feel faster than the direct merlin because ocaml-lsp operates asynchronously.

Quoting Rudi Grinberg from OCaml forums:

In my experience the editor frontends that come with merlin perform poorly compared to their LSP counterparts. In Emacs for example, I recall that switching to eglot to ocamllsp gave me a very noticeable boost in completion performance and error checking performance.

In a (significantly) large codebase, the editing experience in vim/emacs+merlin has reported to become less responsive and more laggy.

Editing setups

I will list a few editing setups I have seen in use.

Official, popular setups

These are official in the sense that setup instructions are available on the official website.

merlin + emacs
merlin + vim
ocaml-lsp + vscode

Unofficial, popular setups

Thanks to ocaml-lsp, alternatives have emerged:

ocaml-lsp + neovim
ocaml-lsp + emacs

Worthy outliers

IntelliJ with ReasonML plugin by Herve Giraud. The only one that does not use merlin underneath, rather takes advantage of IntelliJ's IDE infrastructure.
ocaml-lsp + helix
Anything else that can work with LSP protocol, like KDE's Kate editor
Thanks to a strong static typing with a very fast compiler and a built tool with watch mode, some ditch tooling altogether and go with plain vim or emacs or even nano

My excursions

I care a lot about vim-like modal editing.

The other thing I care about: less hassle to set up.

Now, let's see how some of these have fared for me.

merlin + emacs

The glue packages in this case are tuareg and user-setup.

Unfortunately, official instructions didn't work for me. Instructions from Real World OCaml did:

$ opam install user-setup tuareg ocamlformat merlin
$ opam user-setup install

There is another alternative to tuareg - caml-mode, but I haven't tried it.

Tuareg also provides a Send to REPL for evaluation action, which provides a quick way to test and design code on-the-fly.

This setup works (type inference, error detection, etc.), but is very barebones. I realised I had to do a lot more on Emacs side - install and configure packages like flycheck, eldoc, merlin-eldoc, and what not - to modernise the editing experience. I stopped here.

merlin + vim

The glue package is user-setup.

However, this setup did not work due to the following error:

"src/soup.ml" 1326L, 39757B
Error detected while processing BufRead Autocommands for "*.ml"..FileType Autocommands for "*"..function <SNR>4_LoadFTPlugin[18]..script /Users/jb/projects/lambdasoup/_opam
/share/merlin/vim/ftplugin/ocaml.vim[2]../Users/jb/projects/lambdasoup/_opam/share/merlin/vim/autoload/merlin.vim:
line    9:
Error: Required vim compiled with +python or +python3
Error detected while processing BufRead Autocommands for "*.ml"..FileType Autocommands for "*"..function <SNR>4_LoadFTPlugin[18]..script /Users/jb/projects/lambdasoup/_opam
/share/merlin/vim/ftplugin/ocaml.vim:
line    2:
E117: Unknown function: merlin#Register
Press ENTER or type command to continue

I get the issue of course: my vim is not compiled with python. But it also means that now I have to look for a vim that is compiled with python. And I tried out two vims: macOS's default vim, and the vim in nixpkgs.

So I moved on.

ocaml-lsp + vscode

The glue package is VSCode OCaml Platform, which, besides integrating ocaml-lsp, also brings together ocamlformat, opam environment sandbox selection tool, etc., under a single VS Code extension.

Despite that fact that there is one more abstraction to deal with - ocaml-lsp built on top of merlin - this setup has been one of the most seamless.

It is also the top official recommendation now, thanks to a lot of effort put in by OCaml tooling developers.

The extension also provides a "Send to REPL for evaluation" action, much popular with the Emacs crowd.

The experience hasn't been 100% flawless though. Once, when I opened VS Code with an OCaml project, the editor didn't show any type hints at all. No errors were thrown either. After a long debugging session, it turned out that the OCaml LSP did throw an error saying that VS Code needs to be updated, but it was buried in Output Pane's OCaml LSP tab. I wish that the Output window had popped up on its own to highlight the error, instead of having to look for the problem myself. I have seen this happen in some other language project.

This is VS Code specific, but I also miss a good modal editing experience. I also keep getting bugged by a weird problem caused due to my MacBook's virtual Fn bar and while executing a specific keychord sequence, in which a slight touch from one of my raised fingers triggers the find window in VS Code. Very annoying!

ocaml-lsp + neovim

The glue package is nvim-lspconfig.

This setup has often broken down, though the fault lied with the constant churn in neovim and neovim's LSP ecosystem more than with OCaml tooling.

There are a lot of other helper neovim packages to reckon with, like, the configurations of which I copy-paste and then pray for them to keep working.

When everything works, this is the most elegant setup for me. However, once in a while, when I load an OCaml project in neovim, some setup-related error would pop up.

Debugging a broken neovim configuration is a nightmare I wouldn't wish upon my enemy.

ocaml-lsp + helix

There is no glue package. This has been the only zero-config setup for me.

Only Helix has worked immediately and flawlessly for me.

Conclusion

At this point, I would consider the merlin-based setups appropriate only for veterans and advanced users. They are worth it only if you care about having every fringe feature available under merlin and don't mind going through some pain of setting things up.

merlin-based setup might also be the only sane option if a project does not use dune as its build tool. But don't quote me on this.

A beginner should absolutely choose VS Code OCaml Platform. When there is a whole new ecosystem to reckon with, you don't want to be scared away by the editing experience.

Only Helix provides a similar seamless experience. So VS Code dodgers can choose helix (at the cost of the baggage of a non-vim modal editing).

To vim lovers, I recommend the ocaml-lsp + neovim route.

To emacs lovers, I recommend the ocaml-lsp + emacs route.

Memorising branch order in git rebase

2024-03-05T11:31:21.000Z

In a git rebase x command, is x being rebased on the current branch, or vice versa?

I mentally always read rebase as rebase on top of.

So, git rebase master reads as git, rebase on top of master, i.e., rebase the current branch on top of master.

But what about the alternate version of the command: git rebase master feat/x ?

Well, git always rebases the current branch.

So git rebase master feat/x is actually git checkout feat/x && git rebase master . So the reading git rebase on top of master still applies.

A bit clunky, but good enough for me.

I switched to fish shell Nope. Back to bash.

2024-02-06T11:31:21.000Z

Table of contents
Update: 5 May 2024
Original article

Update: 5 May 2024

I have come crawling back to bash. Why?

My interest in system, infrastructure, and developer tooling is growing. I don't see much place for a non-bash shell in that space.
I have time for only one niche ecosystem in my life. I have already chosen OCaml as it.
fish is too syntax-incompatible with bash, right down to inline declaration of env vars before executing a command. If I have to recall the fish syntax for every little thing, then it's just not worth it.

Original article

Here, I am putting down my reasons to choose fish shell for my future self.

All I want is a shell that is

a first-class citizen on macOS and Linux
low maintenance, which means
out-of-the-box or low-configuration autocompletion and fuzzy history search
adequately supported by third-party tools

I don't use shell much beyond that.

I also don't care much about scripting compabilities as I have never had to share scripts with others. Also, I prefer to write my scripts in typed, FP languages like Scala.

fish checks all those boxes.

bash is anything but first-class on macOS now.

zsh is powerful, and comes with a lot of bells and whistles, most of them do not come out-of-the-box. I need to lug around a few packages (like zsh-completions) and a lot of configuration. I also need to maintain configuration for fzf for fuzzy search.

At the very least, I will stop worrying and wasting time in maintaining parity between bash and zsh configs.

Make an opam local switch and `dune init project` work together

2023-12-03T11:31:22.000Z

Table of contents
Local switch in opam
dune init project
The problem
What next?

In the OCaml ecosystem, opam is the most popular package management tool, while dune is the foremost build tool.

Both have evolved independently. While they manage to work in tandem, there are a lot of irregularities to trip on where they meet.

Local switch in opam

opam's local switch feature can set up and isolate development environment and dependencies per project.

opam switch create creates a local switch if it is given the path to a directory. If the specified directory does not exist, then its is created.

opam switch create ./path/to/existing/dir

The above command creates an _opam directory inside the given path, inside which all of the opam-related artifacts for this project are stored.

A cool side-effect is that when a directory containing a local opam switch is visited, that switch is activated automatically. No need to opam switch set the switch explicitly.

dune init project

dune init project is the recommended way to bootstrap an OCaml project.

dune init project prj_name

The above command creates a directory named prj_name in the current directory, and populates it with project artifacts.

I found that dune cannot bootstrap a project in the current directory itself. So dune init project . fails to work.

The problem

I prefer to use opam's local switch feature to ensure the isolatation of all dependencies and tools related to an OCaml project. This means I also prefer to install dune per-project. So

I want to use dune to bootstrap a project
dune is installed through opam
opam needs a local switch for per-project installation
A local switch needs an existing empty project directory
dune cannot bootstrap a project in a current directory

The chicken and egg problem looks easy now, huh?

I started guessing a solution.

Attempt 1

Execute opam and dune commands from parent directory

I planned the following idealised sequence of commands:

# create an empty project dir
~/projects $ mkdir my_prj

# create a local switch
~/projects $ opam switch create ./my_prj

# install dune in our local switch
~/projects $ opam install dune

# bootstrap project
~/projects $ dune init project my_prj

I didn't make it past the 3rd command of installing dune because of the following (reasonable) error:

$ opam install dune
[ERROR] No switch is currently set. Please use 'opam switch'
to set or install a switch.

Ok, then. I tried to set the switch after creating it.

~/projects $ mkdir my_prj
~/projects $ opam switch create ./my_prj
~/projects $ opam switch set ./my_prj
[ERROR] Can not set external switch '/Users/jb/projects/my_prj' globally. To set
it in the current shell use:
eval $(opam env --switch=/Users/jb/projects/my_prj --set-switch)

The advice felt like a long-winded solution to me. I wanted a simpler solution.

So may be, first, I should enter the empty project directory to set up the project.

Attempt 2

Execute opam and dune commands from project directory

I carried out the following sequence of commands:

~/projects $ mkdir my_prj
~/projects $ cd my_prj 
~/projects/my_prj $ opam switch create . 
~/projects/my_prj $ opam install dune
~/projects/my_prj $ dune init project my_prj

The above sequence creates a my_prj/my_prj/ directory tree. That's not what I wanted.

Now what?

Solution

exploit opam's auto-activation of local switch

Now, consider the following sequence of commands:

# create an empty project dir
~/projects $ mkdir my_prj

~/projects $ cd my_prj 

# create a local switch, which is auto-activated after a successful creation
# because the switch is created in the current directory itself.
~/projects/my_prj $ opam switch create . 

~/projects/my_prj $ opam install dune

# go back to parent, with opam still pointing to the local switch env
# until the current session ends or until another switch is activated
~/projects $ cd .. 

# bootstrap our project
~/projects/my_prj $ dune init project my_prj

Note the 3rd command opam switch create .. After the command finishes execution, the switch is auto-activated because the local switch lives in the current directory . itself.

opam also sets an env var OPAM_SWITCH_PREFIX to the path of this activated switch.

$ echo $OPAM_SWITCH_PREFIX 
/Users/jb/projects/my_prj/_opam

This env var probably lives on until the current shell session ends even if the directory changes, or until another switch is activated.

That means that when the above command sequence goes one directory up to execute dune init project, opam is still pointing to the right local switch env.

Also dune does not mind if the directory my_prj already exists.

Case solved!

I can imagine a variation of the above sequence:

# create an empty project dir
~/projects $ mkdir my_prj

# create our local switch
~/projects $ opam switch create ./my_prj 

# activate our local switch
~/projects $ cd my_prj 

# go back to parent, with opam still pointing to the local switch env
# until the current session ends or until another switch is activated
~/projects/my_prj $ cd .. 

# install dune in our local switch
~/projects $ opam install dune

# bootstrap our project
~/projects $ dune init project my_prj

What next?

There is work under progress to wrap dune around opam, thus making dune as the unifying package management and build solution.

Spoonfeeding machine architecture to OCaml toolchain on Apple Silicon

2023-12-01T11:31:22.000Z

Table of contents
Problem
Hacky solution
Update (23 Feb 2024) : Better solution

Problem

OCaml compiler failed to build on my M1 Macbook with Apple's Silicon architecture.

$ opam switch create . 4.14.1 -y --deps-only

<><> Installing new switch packages <><><><><><><><><><><><><><><><><><><><>  🐫 
Switch invariant: ["ocaml-base-compiler" {= "4.14.1"} | "ocaml-system" {= "4.14.1"}]
[NOTE] External dependency handling not supported for OS family 'macos'.
        You can disable this check using 'opam option --global depext=false'

<><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><>  🐫 
∗ installed base-bigarray.base
∗ installed base-threads.base
∗ installed base-unix.base
∗ installed ocaml-options-vanilla.1
⬇ retrieved ocaml-base-compiler.4.14.1  (cached)
[ERROR] The compilation of ocaml-base-compiler.4.14.1 failed at
        "make -j7".

#=== ERROR while compiling ocaml-base-compiler.4.14.1 ===========#
# context     2.1.5 | macos/arm64 |  | https://opam.ocaml.org#bc52affc
# path        ~/projects/aoc-2023/ocaml/_opam/.opam-switch/build/ocaml-base-compiler.4.14.1
# command     ~/.opam/opam-init/hooks/sandbox.sh build make -j7
# exit-code   2
# env-file    ~/.opam/log/ocaml-base-compiler-11985-7b627b.env
# output-file ~/.opam/log/ocaml-base-compiler-11985-7b627b.out
### output ###
# [...]
# signals_nat.c:221:5: error: no member named '__pc' in 'struct __darwin_x86_thread_state64'
#     CONTEXT_PC = (context_reg) &caml_stack_overflow;
#     ^~~~~~~~~~
# ./signals_osdep.h:182:37: note: expanded from macro 'CONTEXT_PC'
#   #define CONTEXT_PC (CONTEXT_STATE.__pc)
#                       ~~~~~~~~~~~~~ ^
# 4 errors generated.
# make[3]: *** [signals_nat.n.o] Error 1
# make[3]: *** Waiting for unfinished jobs....
# make[2]: *** [makeruntimeopt] Error 2
# make[1]: *** [opt.opt] Error 2
# make: *** [world.opt] Error 2



<><> Error report <><><><><><><><><><><><><><><><><><><><><><>  🐫 
┌─ The following actions failed
│ λ build ocaml-base-compiler 4.14.1
└─ 
┌─ The following changes have been performed (the rest was aborted)
│ ∗ install base-bigarray         base
│ ∗ install base-threads          base
│ ∗ install base-unix             base
│ ∗ install ocaml-options-vanilla 1
└─ 

<><> ocaml-base-compiler.4.14.1 troubleshooting <><><><><><><>  🐫 
=> A failure in the middle of the build may be caused by build
    parallelism
        (enabled by default).
        Please file a bug report at
    https://github.com/ocaml/opam-repository/issues
=> You can try installing again including --jobs=1
        to force a sequential build instead.
Switch initialisation failed: clean up? ('n' will leave the
switch partially installed) [Y/n] y

Hacky solution

If you have the same issue, then try specifying the architecture explicitly.

$ arch -arm64 opam switch create . 4.14.1 -y --deps-only

Apply the same approach to install packages too.

$ arch -arm64 opam install dune

There has to be a better way though.

P.S.: Even dune does not work without it!

$ arch -arm64 dune exec bin/main.exe

Update (23 Feb 2024) : Better solution

JM from OCaml discord helped me to discover the underlying issue - my Terminal.app was running in Rosetta mode. I had configured it to run on Rosetta during the initial Silicon-Rosetta churn, but forgotten all about it.

So, opam, which uses uname -a to find the underlying architecture, always got x86_64.

Once I unchecked the Open using Rosetta option, arch -arm64 was no longer needed.

From what I understand, if any tool or binary across a toolchain is configured to run through Rosetta - be it the Terminal.app, or the shell, or a helper binary like uname - then the program using this toolchain could end up using the wrong architecture.

List of movies better than their book counterparts

2023-10-09T11:31:22.000Z

This list will likely (hopefully) remain short.

Dune series. I felt that words in Dune (Book 1 of the series) didn't convey its strongest moments well. Presently, I am struggling to get into Dune Messiah (Book 2 of the series).
Bullet train (at least when compared to the translated-to-English version of the book)

An elegant triplet of fonts

2023-06-12T11:31:22.000Z

I use the following set of fonts.

An elegant triplet of fonts that go together
Type	Font
Sans Serif	PT Sans
Serif	Gentium Book Plus
Monospace	PT Mono; or Latin Modern Mono; or Courier; or Courier Screenplay; or Courier Prime; or Monaco

Sans-serif I v/s l

Many sans serif fonts fail to distinguish between uppercase I and lowercase l. Twitter's new font is an example of this.

On top of that, Twitter started dishing out blue ticks on subscriptions.

These two features combine to form deceptive Twitter usernames, as demonstrated in this tweet by Adrian Roselli.

Some famous fonts like Helvetica and Roboto fail at it.

Helvetica has identical looking uppercase I and lowercase l.

Roboto has identical looking uppercase I and lowercase l.

But PT Sans passes this AppleTVPlus test.

PT Sans distinguishes between uppercase I and lowercase l by putting a tail on l.

How to mark up a code snippet in HTML

2022-10-06T11:31:21.000Z

Suppose, we want to mark up the following multi-line snippet of JavaScript code:

function hello(name) {
  return "Hello, " + name;
}

A JavaScript function that greets a user Joe with "Hello, Joe!"

Out of habit, let's start by wrapping it in a pre tag.

<pre>
  function hello(name) {
    return "Hello, " + name;
  }
</pre>

Mark up a code snippet with pre tag only. Looks good enough, but not conveyed good enough.

However, the HTML spec defines pre as

The pre tag represents a block of preformatted text, in which structure is represented by typographic conventions rather than by elements.

So, a pre tag can contain anything which conveys its semantic meaning at least partly through how its text is formatted, like a code snippet, a poem, or an ascii art.

Clearly, pre tag is not enough to represent a code snippet. How do we distinguish a code snippet from other pre-formatted content? By marking up the snippet with code, and then wrapping it in a pre tag.

<pre>
  <code>
    function hello(name) {
      return "Hello, " + name;
    }
  </code>
</pre>

Mark up a multi-line code snippet with code tag, and then wrap that code tag in a pre tag

Now, how do we convey that the language of the code snippet is JavaScript?

HTML spec has an answer to that too:

There is no formal way to indicate the language of computer code being marked up. Authors who wish to mark code elements with the language used, e.g. so that syntax highlighting scripts can use the right rules, can use the class attribute, e.g. by adding a class prefixed with "language-" to the element.

In short, assign to the code tag a class named language-name of the programming language.

<pre>
  <code class="language-javascript">
    function hello(name) {
      return "Hello, " + name;
    }
  </code>
</pre>

A code tag containing a JavaScript snippet should be given a class named language-javascript.

There is still one improvement left, which applies to pre tag in general.

Conveying formatting of a text can be difficult to a visually-challenged user, just like conveying an image is.

In order to assist such a user with an alternate description, wrap such semi-accessible content in a figure tag, and put the alternate description in a figcaption tag.

<figure>
  <pre>
    <code class="language-javascript">
      function hello(name) {
        return "Hello, " + name;
      }
    </code>
  </pre>
  <figcaption>
      A code tag containing a JavaScript snippet
      should be given a class named language-javascript.
  </figcaption>
</figure>

Wrap a pre tag in a figure tag, and put a figcaption tag inside the figure tag that provides an alternate description to the contents of the pre tag.

Location of emacs config

2022-09-24T11:31:21.000Z

I prefer to keep user configuration inside the standard XDG_CONFIG_HOME, which typically points to ~/.config/. Emacs also supports XDG_CONFIG_HOME, but as the last entry in its list of preferred locations, where it looks for init.el.

The list goes in the order: ~/.emacs.el, ~/.emacs, or ~/.emacs.d/init.el, and then ~/.config/emacs/init.el.

Emacs manual also says the following:

Note also that if neither the XDG location nor ~/.emacs.d exist, then Emacs will create ~/.emacs.d (and therefore use it during subsequent invocations).

Now, the XDG location, i.e., ~/.config/emacs/ wouldn't typically exist in a system by default. So emacs would always end up defaulting to ~/.emacs.d/. In order to make it read the XDG location, I always had to manually delete ~/.emacs.d/ first.

So much hassle on every new system or after a fresh emacs installation. So I now just stow my emacs dotfiles to ~/.emacs.d.

What `box-sizing` does

2022-09-17T11:31:21.000Z

box-sizing specifies the part of an element's CSS box, to which the properties width, min-width, max-width, height, min-height, max-height apply.


p {
    height: 3rem; 
    box-sizing: content-box;
}

Result: brown content box is 3rem tall


p {
    height: 3rem; 
    box-sizing: border-box;
}

Result: black border box is 3rem tall

Fake SHA256 in a Nix derivation

2022-09-09T11:31:21.000Z

Discovering the SHA256 hash for a derivation is a chore.

One approach is to fake the hash with zeroes.

sha256 = "0000000000000000000000000000000000000000000000000000";

This induces nix-build to throw an error containing the correct hash.

However, even the fake hash has to be correct, i.e., needs to have the right number of zeroes in it. Otherwise, nix-build throws an error about the hash being invalid instead of being incorrect. This error does not contain the correct hash.

Thankfully, Nix already binds the fake hash value to a variable lib.fakeSha256.

sha256 = lib.fakeSha256;

Thanks to paulyoung for this tip.

I found a more memorable variable lib.fakeHash.

How to use Hover Click without animation in GNOME

2020-07-05T11:31:22.000Z

Desktop systems usually provide an accessibility feature, with which a user only has to hover the cursor over where he wants to click. The click goes off automatically. In GNOME, this feature is called Hover Click.

Not having to press the mouse button makes for a much more pleasurable and efficient experience. Coupled with Sticky Keys, Hover Click has also helped me recover from a hand injury.

The click goes off a few configurable milliseconds after the user positions the cursor. GNOME represents this buffer with an animating circle, which looks pretty but gets in the way, especially if you are trying to course-correct the cursor position.

The option to disable this animation is simple but not straightforward. You need to disable all the animations entirely from Gnome Tweaks:

Open Gnome Tweaks tool
Open General Tab
Turn Animations off

Hover Click feature in GNOME, with and without animation

How to write a Firefox add-on in ClojureScript

2020-07-04T11:31:22.000Z

Table of contents
Project Layout
ClojureScript to JavaScript
Live reload

You can find a sample add-on on my GitHub. I won't go through the code here, but will lay out the quirky development process. I will mostly focus on the plumbing - how ClojureScript hands over the compiled JavaScript code to the add-on.

The sample add-on tries to mirror the functionality of the one found in the official tutorial - wrap a border around the pages at mozilla.org.

The demo add-on puts a purple border around the current webpage

Project Layout

Figuring out a clean project layout took some effort. I am satisfied with the following structure:

project-root
|-- addon  // root for the Firefox add-on
|   |--- manifest.json
|   |--- // add-on artefacts like icons
|   |--- // JS file compiled and placed here by ClojureScript compiler
|-- src  // ClojureScript code
|-- compile-opts.edn  // compilation options provided to ClojureScript compiler
|-- deps.edn

The goal is to isolate the artefacts of the add-on from the ClojureScript code. The add-on gets only its JavaScript from ClojureScript. So, isolating the rest of its artefacts - icons, manifest, etc. - into its own directory works out well. ClojureScript dominates the rest of the project layout.

The only time the ClojureScript compiler touches the addon folder is to put the compiled JavaScript in it.

ClojureScript to JavaScript

The compilation process by default uses :optimizations :none, which produces a set of JavaScript files, with the main file pointing at the others. This does not work here as the add-on does not seem to pick up the secondary files from the main file.

The rest of the :optimizations options - :whitespace, :simple, :advanced - produce a single standalone JavaScript file, which the add-on happily accepts.

However, :optimizations :none is the default because it compiles the fastest, lending a speedy development process. I went with the second fastest - :whitespace - for development purpose, and :advanced to compile a production build.

Two other compilation options helps keep the plumbing short and clean: :target diverts the temporary files produced during compilation to a tmp folder, while :target-to puts the standalone compile JavaScript file directly into the addon folder.

To summarise, we tweak the default compilation process with the following three options to keep life simple:

{:optimizations :whitespace
 :output-dir    "tmp"
 :output-to     "addon/main.js"}

Live reload

Basically, we instruct the ClojureScript compiler to watch over the ClojureScript files and recompile them into JavaScript on change.

# in project-root
clj --main cljs.main \
    --watch "src" \
    --compile-opts "compile-opts.edn" \
    --compile demo.core

In turn, Mozilla's web-ext tool by default watches over the add-on folder and reloads the add-on on detecting a change.

# in addon folder
web-ext run --start-url https://www.mozilla.org/en-US/

Jayesh Bhoot's Ghost Town – All Posts

My understanding of SBI Max Gain loan account

EMI payments

Part payments or pre-payments

There is a catch

Foreclosing a loan

In closing

A primer on car insurance (in India)

The concept of car insurance

Damage to someone or their property

Damage to own car

Zero depreciation

Return to Invoice

Engine cover

No Claims Bonus

Comprehensive policy

How I renewed my own damage policy

In closing

Improved font rendering in Guix

git stage over git add

On Stephen Baxter's Manifold books

Tip for my future self: If Emacs throws an arcane error — project--read-file-name: Wrong type argument: stringp, nil — while trying to find a file in a git project (C-x p f), then one likely reason is that the git project is empty.

How I configured OS-specific fonts in Emacs

A case of unsoundness in TypeScript

Understanding various syntaxes to annotate a function's type in TypeScript

The underlying principles

Detour - ways to define a function in JavaScript

Function declaration

Function expression

Arrow function expression

Syntax #1 - annotate the function parameters and its return value

Syntax #2 - Annotate the variable that holds a function expression

Syntax #3 - annotate a function expression as an object type

JavaScript function declaration v/s arrow function in a browser console

Someone's high hopes- to dash or not to dash

A matrix of emotions

Copying all files of a directory, including hidden ones, with cp

Solution - cp -R src/. dest

Why does it work?

Proximity of an error in static and dynamic languages

An example - a web service

Scala service

TypeScript service

In closing

Design Rework #1 - reworking my university hoarding

Original hoarding

Problems in the original

Rework

Figma resources

In closing

Making tanstack docs more accessible with Stylus

Update: 19 Feb 2025

Use cases for <form method="dialog">

But what about MDN using it in a <dialog> element?

Name your SQL constraints

Connecting to MySQL running on NixOS on local network

The big picture

Configure MySQL to listen to remote connections

Configure a remote-enabled MySQL user

Configure NixOS to open up MySQL port

Flossing - do orthodon't. There is no try.

Being chill

Personal experience

In closing

A mental model for Linux file, hard and soft links

What makes a file in Linux?

Hard links

Deleting a hard link

Soft links

A soft link is a file

Contents of a soft link file

I/O operations on a soft link file

Copying a soft link file

Moving a soft link file

Moving the target file

In closing

Further reading

The Trumping Joke

Different kinds of simple

Ki modal editor - first impressions

`git stage` over `git add`

Tip for my future self: If Emacs throws an arcane error — `project--read-file-name: Wrong type argument: stringp, nil` — while trying to find a file in a git project (`C-x p f`), then one likely reason is that the git project is empty.

Copying all files of a directory, including hidden ones, with `cp`

Solution - `cp -R src/. dest`

Use cases for `<form method="dialog">`

But what about MDN using it in a `<dialog>` element?

How I use `:has()` selector to add table of contents

Forgotten lesson remembered after staring 5 minutes at the screen: `innerHTML` cannot contain a `<script>` tag.

Configurations in `build.sbt`