khaledh

I figured that it would be something like that. But it's been so frequent that I expect the leadership to act decisively towards a long-term reliability plan. Unfortunately they have near monopoly in this space, so I guess there's not enough incentive to fix the situation.

GitHub has been shit lately. What the fuck is going on?

I believe we (humankind) have been transitioning to a phase of what I call "time compression." Everything is happening too fast compared to say 40-50 years ago. You can attribute it to many things (tech in particular), but primarily it's the fact that everyone has a terminal in their hands where they can access information, people, news, etc. at a whim. It's affecting both our mental health and our collective social fabric. I think humans were not meant to be overwhelmed this way; our mental capacity hasn't increased, but the stimuli have increased by orders of magnitude.

I don't have a solution to this problem. But one thing I've been trying is to immerse myself in a hobby I enjoy, and ignore most of the noise around me. I closed most of my social network accounts 9 years ago, and it has improved my mental health significantly. I still read the news, but I skim the headlines and go back to what I was doing. Yes, it does affect me, but I try to minimize its impact and focus on things that compensate their effect.

There's no silver bullet. Just know that you're not alone. Unfortunately time compression is here to stay (and it will probably get worse), and those of us who fight it back will hopefully stay sane.

Several years ago we had a data processing framework that allowed teams to process data incrementally, since most datasets were in the range of terabytes/day. The drawback is that it's append-only; i.e. you can't update previously processed output; you can only append to it. One team had a pipeline that needed to update older records, and there was a long discussion of proposals and convoluted solutions. I took a look at the total size of the input dataset and it was in the range of a few gigabytes only. I dropped into the discussion and said "This dataset is only a few gigabytes, why don't you just read it in full and overwrite the output every time?" Suddenly the discussion went quiet for a minute, and someone said "That's brilliant!". They only needed to change a few lines of code to make it happen.

<sarcasm>Let's also abandon disk storage's linear block addressing and go back to CHS addressing</sarcasm>

It was down if you tried to access it while authenticated (i.e. you have a cookie). It was loading fine for unauthenticated sessions (e.g. incognito).

I'm no expert myself, but is this the same as Russell's type hierarchy theory? This is from a quick Google AI search answer:

    Bertrand Russell developed type theory to avoid the paradoxes, like his own, that arose from naive set theory, which arose from the unrestricted use of predicates and collections. His solution, outlined in the 1908 article "Mathematical logic as based on the theory of types" and later expanded in Principia Mathematica (1910–1913), created a hierarchy of types to prevent self-referential paradoxes by ensuring that an entity could not be defined in terms of itself. He proposed a system where variables have specific types, and entities of a given type can only be built from entities of a lower type.

Markdown won. Simplicity always wins. Markdown is now the de facto documentation format, for better or for worse.

One of the best rotoscoped games I've ever played was Flashback[1] (1992). I was also wowed by Prince of Persia[2] (1989); it was ahead of its time in that period.

[1] https://store.steampowered.com/app/961620/Flashback

[2] https://en.wikipedia.org/wiki/Prince_of_Persia_(1989_video_g...

The problem with macro-laden C is that your code becomes foreign and opaque to others. You're building a new mini-language layer on top of the base language that only your codebase uses. This has been my experience with many large C projects: I see tons of macros used all over the place and I have no idea what they do unless I hunt down and understand each one of them.

I built something similar a while ago (although not as featureful): https://github.com/khaledh/pagemagic

> A note on interpreters: If the executable file starts with a shebang (#!), the kernel will use the shebang-specified interpreter to run the program. For example, #!/usr/bin/python3 will run the program using the Python interpreter, #!/bin/bash will run the program using the Bash shell, etc.

This caused me a lot of pain while trying to debug a 3rd party Java application that was trying to launch an executable script, and throwing an IO error "java.io.IOException: error=2, No such file or directory." I was puzzled because I know the script is right there (using its full path) and it had the executable bit set. It turns out that the shebang in the script was wrong, so the OS was complaining (actual error from a shell would be "The file specified the interpreter '/foo/bar', which is not an executable command."), but the Java error was completely misleading :|

Note: If you wonder why I didn't see this error by running the script myself: I did, and it ran fine locally. But the application was running on a remote host that had a different path for the interpreter.

The more you try to solve a problem at a large scale, the less empathetic to humans it becomes. This has been happening for a long while now, and IMO has caused society to become "disconnected" from each other and more "connected" to devices. AI is just a new catalyst to this process. My fear is that a time will come where interacting with humans becomes the exception, not the norm.

Needs "(2020)" in the title.

Same with Vale: https://vale.dev

Agreed. The methodology needed here is something like an A/B test, with quantifiable metrics that demonstrate the effectiveness of the tool. And to do it not just once, but many times under different scenarios so that it demonstrates statistical significance.

The most challenging part when working with coding agents is that they seem to do well initially on a small code base with low complexity. Once the codebase gets bigger with lots of non-trivial connections and patterns, they almost always experience tunnel vision when asked to do anything non-trivial, leading to increased tech debt.

Product managers live in a bubble of their own.

This is why every language needs a good standard library, which unfortunately JavaScript never had.

This is something that needs to be baked into the operating system, which is not supported by major OSs today. The next best thing is to rely on a "secure environment" where applications can be installed and run, similar to phone apps or browser extensions. This environment would probably use application manifests to list entitlements (aka capabilities), like disk access, network access, etc. But until then, we're stuck with the ambient security model.

He is also the creator of Odin :)

It goes way before that. It starts with IDS (Integrated Data Store) from GE (1964), which was a network database system. Next was IBM's hierarchical database system IMS (Information Management System, 1966), still in use today. Then the CODASYL model (late 1960s), which was an effort to standardize the network model. And then Codd came up with the relational model in the early 70s, upon which an explosion of database systems were built (first is IBM System R, SQL, Oracle, DB2, Ingres). Then came the PC-based database systems you mentioned.

I'd like to see a comparison of IDE market share over the past decade or so. My assumption is that VS Code has gained market share exponentially, eating at both Visual Studio's and JetBrains' share significantly, leading JetBrains to start offering their products for free personal use to try to recoup some of that lost user base.

I could be wrong, but that's my observation based on the extreme popularity of VS Code and the abundance of extensions for virtually every language and framework out there.

That is also true. Occasionally I would go in and clean up the docs and refocus them, but in the end I realized that I'm baby sitting the agent rather than relying on it to help me.

It might even get further. I imagine a day where AI would generate an executable neural network that models (and is optimized for) a specific problem; i.e. kind of a model that runs on a neural network runtime or VM. Who cares what the NN is doing as long as it's doing its job correctly. The big catch, though, is the keyword "correctly" and I would add "deterministically" to it, in order for users to trust it.

I'm an experienced software engineer (20+ years experience). I really liked the agentic coding capabilities, especially Claude Code. In addition to using it at work (data engineering), I used it for a hobby project (that I intended to contribute as open source). It was a new systems programming language built from scratch, including the backend. It was not fully fledged, but it had the core pieces: a static type system, algebraic data types, pattern matching with destructuring, type checker, ownership (pointer capabilities), dynamic scope region-based memory management, lowering to SSA-based IR (including fast dominance analysis), graph coloring register allocator with liveness interference, and x86-64 assembly generation. I did this in two weeks, something I couldn't do by myself in 6 months.

As I did this, I was keeping everything documented using a memory bank approach[1], so that I can fire up Claude Code and get it up to speed without explaining everything from scratch. Even with this disciplined approach, the code base got to a point where Claude would "forget" the big picture and start trying to optimize locally, hurting the global optimum. Eventually, I got burnt out by having to keep it in check every time it tried to do something stupid. I found myself always needing to remind it to check other modules to see how things fit together. I guess the memory bank got big with many concepts and relationships that Claude "got lost" in it.

Also, I realized that I missed the opportunity to learn deeply all those topics. so now I'm back to coding things myself, with little help from Cursor Tab, that's it. Will see how that goes.

[1] https://docs.cline.bot/prompting/cline-memory-bank

This is of course subjective, but I still find JetBrains Mono to be much more pleasant to read (when it comes to code) than any other mono font out there.

This is my experience too. I usually use Gemini 2.5 Pro through AI Studio for big design ideas that need to be validated and refined. Then take the refined requirements to Claude Code which does an excellent job most of the time in coding them properly. Recently I tried Gemini CLI, and it's not even close to Claude Code's sharp coding skills. It often makes syntax mistakes, and get stuck trying to get itself out of a rut; its output is so verbose (and fast) that it's hard to follow what it's trying to do. Claude Code has a much better debugging capability.

Another contender in the "big idea" reasoning camp: DeepSeek R1. It's much slower, but most of the time it can analyze problems and get to the correct solution in one shot.

Not much tbh. I'm using markdown files as a memory bank[1] for my projects and it works well without the need to structure them in a schema/graph. But I guess one benefit of this particular memory graph implementation is its temporal aspect: searchable facts can evolve over time; i.e. what is true now and how it got here.

[1] https://docs.cline.bot/prompting/cline-memory-bank

I love how we have come full circle. Anybody remembers the "semantic web" (RDF-based knowledge graph)? It didn't take off because building and maintaining such a graph requires extensive knowledge engineering work and tools. Fast forward a couple of decades and we have LLMs, which is basically auto-complete on steroids based on general knowledge, with the downside that it doesn't "remember" any facts unless you spoon-feed it with the right context. We're now back to: "let's encode context knowledge as a graph and plug it into LLMs". Fun times :)

One feature that is still exclusive to Cursor is the Cursor Tab feature. It almost always accurately predicts your next edit with high accuracy, based on your recent edits and cursor navigation.

But from an agent perspective, Claude Code is much more tuned to understanding the task, breaking it down into small steps, and executing those steps with precision.

Overall, IMO agentic coding is great for well defined tasks, especially when they're backed by tests. It still lacks though in deep technical discussions and being opinionated about architectural decisions, unless specifically nudged in a certain direction. This is an area where Gemini Pro excels at, but it sucks at as a coding agent. So I use both: Gemini Pro for high-level picture design, and Claude Code for executing the plan by giving it clear requirements. All while making some edits myself using Cursor Tab.