What to learn, of computers, of agents?

Here's basically how I would learn, or rather, teach a newcomer in computer science (or anyone) about the subject/domain. The trends and tides have shifted massively, and I think a new paradigm shift is a big enough reason for *teachers *to rethink education. Now that we are moving towards a future where agents ~= compute, and natural language dominates how we interact with our modes of computation, we must design education differently.

Before we begin, a few things:

1. Syntax really is dead, but underlying paradigms are not. Would I use Javascript for making an application which deals with very high data volume? Or Rust for a website? Probably not. (Or maybe? Sure, but at least not if you actually care about your end goal). Hence, *knowing *your language, not syntax-wise, but how it works is still really useful!
2. The above point, but generalized to concepts. Would I use Postgres to store high volume monetary transactions? Would I use it for storing graphical connections? Why or why not? These questions are really basic, but need to be answered correctly, or at least by deeply considering what your end goal is. Even choosing between AWS, Cloudflare or Digital Ocean can really affect your end goal, or what you can do with your projects.
3. There's always more things to learn. A new technology not only just wipes out an older domain, but also births newer ones. Identify them, and adapt! Identifying what to learn comes with the added, rather solemn but obvious-in-hindsight perspective that computation was always a tool to achieve some other goal. The fact that it took us ~60 years to go from the first computers to agents only meant that during that time, there existed an entire profession that specialized in an aspect of the field which may no longer be needed. Before, it happened to an aspect of the field, and now, we have seen probably one of the biggest impacts yet.

But still, a lot of questions remain:

-> Will the average person care about writing/making applications? Dealing with code, databases, security vs simply using the software for other means? => Well ... yes and no. The current generation may not want to deal with this new shiny technology, or treat it with caution. But the next generation will grow up with AI at the back of their hands. They'll know how to truly leverage it, use it and extend it. That being said, there's always two sides: a consumer and a producer. I believe in the long run, one always had to choose one or the other, because a person focusing on both will be out-produced and out-consumed.

-> Will we even require people who know what different frameworks do, who understand the underlying components of a software? Will we need producers even, given agents can already pseudo-autonomously produce software? => In short: I think yes. Just the requirements would be for a new kind of software, or just basically highly advanced versions of the current, existing ones. I personally am already experimenting with software where I feel anything less than the current frontier models wouldn't suffice. Humans always match the demand and if the pace of improvements slows down, we outmatch it even.

-> And, rather simply, what'll be the nature of work itself, given a new kind of digital revolution? => There's no answer, only predictions, and most of them would probably turn out to be wrong. Hence, I would rather localize to what I know now, make smaller predictions and try to keep up based on that.

Well, and with that, we can finally move forward to the actual crux, or the topics that I think I'd want to learn in this age of agents. There's three parts to this, as far as I can see:

• The data science part: Or basically learning the internals of LLMs and somewhat about agents. This in itself may not be necessary/required commercially as much, unless one is into research, but it's still extremely useful if one needs a good understanding and grasp of the tools we are using.
• The computation part: On the easier level, there's data structures and algorithms, databases and cloud micro-services and what they offer, server setups and optimizations and such. On the more difficult part, we can delve into more niche concepts like domain languages, compilers, distributed systems and formal languages.
• The other domain part: Most common here would be business, but also any adjacent STEM fields or Humanities, where we can utilize the above mentioned knowledge. Robotics maybe a very close up and coming example. Another very common one is finance. These are the domains where before, they relied heavily on engineers, and now can benefit vastly from agents. Now that no one field offers a set advantage, we must learn to adapt ourselves and newcomers to be well-versed in all three (any other domain for the third part) and a bit more.

Exponential Ideas

Now that the agents are here, and thousands of lines of good code can be written, what's the most we can think of? Given a powerful tool, how can we explore the boundaries of software, about how we can leverage it, where we can leverage it, and how much to leverage?

There are different levels to this, and I'd like to explore each one here. Let's first begin with:

• Agents, as in, a software which understands language, and can make things happen on your computer, basically openAI's Dot or SpaceXI's GrokBot. What are the possibilities now? Most UI/UX will change, as people wouldn't use them ... as much, at least business-wise. Businesses wouldn't need UI/UX now, they'll need to satisfy agents. Which also mean any digital tasks, if can be done by agents (tasks like managing massive databases, excel sheets, CRMs, etc ...), we are looking at a complete overhaul of how we interact with software! A firm which would effectively be a hybrid of both, leveraging agents and humans wherever they can, would find itself in a very nice position (there are a lot of real-life frictions, especially around legal stuff). Once again, this seems like a good trajectory for how software might evolve, but we cannot make any meaningful predictions of the economy.
• Coding agents, are the most impactful of them all. We can now write thousands of lines of code within days. Given that ... what can we do ? There are axes here: vertical and horizontal. The horizontal axis basically concerns itself with pure volume. Now that we can easily write hundred thousand lines cheaply, what becomes possible? One thing, as DHH mentions, is simple make and maintain native apps throughout. Have a codebase for Mac, one for Windows and one for mobile and tablet! Volume does not matter, we have agents. When volume isn't a cost, we can spread farther, without being thinner. Although I am not sure about the pros and cons here.
• The vertical axis ... trying out more complex projects. Trying to solve more and more complex problems, building things that we do not understand fully (but overall, architecturally), and exploring what's possible, what actually works and what doesn't! All the way from hardware to the highest level of abstractions, we can really explore the bounds of software, and other research directions (anything computational is within reach!). I think a good differentiating factor would be focus and grit: given everyone has agents, where are they dircting their powers to? How effectively are they doing it? And for how long? Let the frontier tackle open problems (if they want to), while everyone willing can leverage any agents available to them.

One other thing, that I had mentioned in a previous post, was that just because everyone can code, doesn't mean:

1. They'll sit down and write/make software, when the agents can just do things for them
2. They'll think computationally, and try to leverage the power of computation however and wherever they can.
3. Consistently pour their resources in trying to solve open-ish problems and make genuinely complex software.

The nature of software, in the sense that what we can do with it, how we design it and how we write it are changing. Change is ... hard to digest, but in retrospect, may end up being a net good.

Learn

A humble view, in this age of LLMs, where they can seemingly solve our hardest (but verifiable) problems, like the millennium problems, would be to not stop learning.

I personally never thought that I could ever solve any open math problems, or even theoretical computer science ones. My whole motive was to keep learning for the sake of it, and pursue my curiosity to the ends of math, theoretical physics, theoretical computer science, Chemistry, Biology, economics, history, psychology and such. The first few, it seems may fall to LLMs, as they can provide solutions to many of our problems. A paradox thus appears: should we continue learning the field in question ? My answer is yes.

I believe even if LLMs can solve any math problem we throw at them, we still need:

• People who know what problem to throw
• People who can formulate the correct problems
• People who can educate, explore and pass on the results of LLMs. One may argue that none of these are necessary, once the LLMs become "good enough". I do doubt that however, since:
• No one is particularly training them to be good communicators right now (there's some mention of orthogonality between communication skill and problem solving skills)
• It becomes particularly harder since we cannot truly/formally verify anything (which is the whole reason of the current progress)

This comes from a pure learning perspective. I've aggressively increased the number of concepts I try to understand, and actively try to find different mediums to learn myself. Learning was always the goal for me, and in that process, if I can contribute and produce something of value, that was always a happy by-product !

Research

Current AI agents have enabled a latent skill that was perhaps dormant in many a curios people, but might've awakened when computational power became leveragable via natural language (a.k.a ambiguous thoughts). This prototyping and quick POCs, have given rise to a lot of fun and truly creative ideations, which previously were too far away from a generalist.

NOTE : One simple lesson I learned that even though I can explore various avenues, without at least some domain knowledge, I get pretty lost in these POCs/Prototypes/research ideas soon after entering them. Jargon words are thrown by LLMs, deciphering which takes more tokens than nought. Although the model can suggest and test ideas on it's own, I cannot back them and waste precious tokens on ideas I am mostly unfamiliar with. Given this, below I'll both list the ideas I thought of exploring, my inspirations and the main bottleneck (learning more about the domain) that made me pause, and deliberately choose my next step forward.

There's a central skill here that I'll develop nonetheless, and would like to apply it in various places (can the LLMs do it better then me ? I think they already are. But it still pays to be a domain-whisperer, in a world where LLMs already are domain-wizards). That central skill is proof engineering. This is very close to what ProofCraft offers, but at a very lower level, as I am but a novice. So with that out of the way:

• Provide formal methods and verification to business workflows. I have been toying with this idea ever since I learnt of Dependant types, where we perform very strict type checking, to the point of mathematical guarantees on certain business workflows. This may have some practical implications, as certain business (especially the ones dealing with critical systems) can really benefit from faultless systems and workflows. This seems like the closest one for me to implement at least a prototype for (although still a non-trivial task) (This is already being done, in cases like the various cases of TLA+ usage, MicroSoft's Project Everest or other Static Analyzers for aviation). This process has traditionally been very expensive and tedious, which is the problem being solved by the agents. Although deciding and constructing a proof might still require some knowledge, which I believe people need not spend decades on learning, the rest can be handled by the agents.

• Mostly realized by AlphAxiv's Autoresearch, but performing small research has never been easier and more accessible. Though once again domain knowledge is required, a person with enough curiosity and an agent can implement and explore various "paths", alongside implementing and graphing them. This has become a very interesting way to quickly mix and match certain ideas, try methodologies on certain concepts vs others etc ... Various ideas may pop-up in our heads during reading about certain research, and we no longer have to wait to explore most of our ideas (which can sooner get us to the realization that good ideas are extremely rare :)). Some examples that I love are: this author who explored how to improve models without training them, this person who realized programs can be SQLite databases and the high profile undertakings of bun re-write in Rust. Larger re-writes and faster prototypes are now possible and may lead to great software (given the agents are actually paired with curious, clear headed and driven individuals ;)

• Cross domain offerings. This, for me seems to be the most interesting application, as it involves both the programmers and the domain-experts to learn and grow using the new tool in town. A world where simply writing code is not valuable anymore, we must alternatives. Thankfully, since SWE jobs (except for very entry-level jobs) was never about just typing code, we may survive for a bit more, the beginning of a "computational generalist" is here. The idea of computation can be applied to various other domains, which I have either tried to explore or stumbled upon. Here is where I felt that simply knowing the computational side of it all wasn't enough, as LLMs, in all their convincing arguments, could not stop me from feeling uneasy stepping into unknown territory, we must learn and adapt. Syntax never mattered, what mattered was understanding the idea of computation and in modern times, learning how to leverage it. One example is Proposogrphy where we leverage graph theory and probably graph DBs to History or this example of how any data can be peeked into by outsiders (non-domain experts), and taken advantage of.

Curiosity is innately human. The need to learn and explore is what makes us feel human, be it in the form of art, writing or research. Agents as we know them are a giant step towards innovative research, and it'll be a waste if we do not see it as such. Stay curios, and leverage !

Agents, and what I've done with them

It has become apparent that coding agents are able to do things good enough that we must use them, and move up a layer of abstraction. Tools like Agentation, Pi or openclaw are already proving to be the next generation of tools that the "programmer" must use.

Tools seem to be the next step in the LLM's journey to become more intelligent. Every noticeable achievement of the modern LLMs has come from them benefitting and leveraging powerful tools like bash/grep etc ... (for coding agents) or Lean4 (for mathematical proofs). Some might even wonder that harness refinement may just take us to the next step of intelligence explosion.

Anyways, I wanted to list some projects that I've undertaken, which wouldn't be possible without our modern tools that are LLMs:

• Created a small financial DSL, and a pipeline to create, backtest and deploy a financial algorithmic strategy

• Start writing lean4 kernel for a deep learning theory I found intriguing, and wanted to formalize

And that's it ! I myself expected this list to be longer, but these are the coolest ones I can imagine. I'll keep expanding this list for sure !

Things to hand-code in this era

This is a small list of exercises, interesting and learning centric things I'd do to continue to enjoy programming, the way I learnt before 2022. These aren't strictly supposed to be "useful", but they are satisfactory in another sense.

• Toy implementation of any concept you find interesting. Always fun to do, and is really the essence of the programming/cs philosophy. Learning to convert intent to code by hand has to be fun. It need not be fast, efficient or even useful. Write it because it's an art.

• Write small compilers/transpilers in order to get my hands on with language theory and DSLs. These are rather useful tools and something (the last i tried) LLMs aren't great at. DSLs are laden with human intent on every step, something which becomes troubling to encode using agents. The recent project, Vera, which is a language meant to be generated by LLMs, is a good example. Reading it's Why/FAQ section, it really shows how much thought it goes into creating a language, and clear human intent.

• Games. Coding up games was a huge reason for people to get into programming, and it's probably the least affected by coding agents. Games are purely made for humans, and cannot be easily replicated (what's the distribution for "fun" ?) and game programming still seems like a cool and complex skill to develop. Creating small scripting games in python, to using Unity/Unreal, it's still the best genre within programming right now.

• Templates for new, weird ideas. The fuzzy ideas, though they can be implemented easily by LLMs, cannot be made without the LLMs making a lot of assumptions, or writing tests or writing code in a manner which is unnecessary for the small/weird idea you'll have. Write it by hand, and maybe after continue using the agent. Basically when it comes to niche ideas (or concepts new to use) we should flip the scripts: instead of agents writing the boiler plate code and tweaking later, we should hand write the template and use the agents later.

• And lastly, a very oddly specific thing: learning to write dependently typed languages, or higher languages. Even though LLMs are now spitting Lean4 as if it's python, it's still beneficial to understand the language, and prepare to learn higher level languages, as it's a very interesting application of programming, and really worth exploring. There are a lot of other niche languages, and it'll be fun to sit and learn these, while the agents write js and py for us.

Using AI

These are some points/ways that I've observed to work well in case of using AI in certain projects of mine. These are in regards to using AI in certain contexts.

• The best way for letting an llm perform actions, is by limiting what they can do in the first place. This is essentially what MCPs are, but since I dislike using confusing terms, it's basically giving the model a JSON schema specification, and letting a platform interpret that schema, transforming it into some action. JSON schemas, in certain cases, may not be feasible: they are nested and long, something that eats up token usage. This is where I (in a personal use case), decided to go for a small DSL. A simple transpiler to interpret it and emit python code or error messages. A much better and effective approach then asking it to generate raw python.

• Being detail oriented. This is hard to do, as it takes.a significant amount of our energy, but is crucial. Every button's alignment, every component's behaviour and how it writes code itself should be done in your way. Dictate everything, every library, every folder structure and every design pattern. Ambiguity is for unserious projects, wherein you do not care much and/or simply want to explore stuff, but as soon as you put your mind to completing it, our opinion and decision should be sprinkled about the codebase.

• This is a classic but, higher quality input gives you high quality output. This applies to how you prompt (like simply asking it to write a types file, or use Zod everytime, etc ...), what files/images you give it and, in case of RAG, how you structure your data (whatever can be put into relational/no-sql DBs should be there, and the rest in graph DB. This is obviously not for one-off use cases). This is also where serious usage of CLAUDE.md or AGENTS.md file comes in, and creating the scaffolding for a project itself also goes a long way to tell the model how you want your project to be structured.

Agent Usage

"The Most versatile substance on the planet and they used it to make a Frisbee" - Ultron

Agents have highly democratized the ability to code. This has enabled various levels of programmers and non-programmers the ability to write easy and complex code. Alas, the agents still need to be told what to code, which is why despite the democratization, there's a flood of CRUD apps and other non-imaginative software. People are given the power to wield agents as good as Codex or Claude Code, and yet cannot fathom softwares beyond simple CRUD apps, implementing yet another Uber, Excel, n8n or ironically, an agent.

There's a caveat to the point above: iterative refinement of old software is always beneficial in the long run: after all, Swiggy entered the market years after Zomato did, Rapido/Ola after Uber, and yet are competing in the markets! It is Ok to compete. This was, however, before the agents era, and in order to build the software which could compete with giants in their own domains, one had to climb the mountain of programming the app by-hand, something which was both costly and time-consuming.

Now ? Writing software is neither time-consuming nor costly. Refinement of older software was earned through experience and business insights, which is no longer a hurdle to be climbed: software is cheaper then ever to make. This has inevitably led to an acceleration of a trend which has been ongoing since probably post-COVID: abundance of "mediocre" software, which is not a comment on it's objective correctness, but rather it's business and technical need: no one cares about CRUD apps or it's-uber-but-for-... apps anymore, but people are making it nonetheless.

To not be overly critical : "useless" or "mediocre" software was probably an absolute necessity in order to both learn programming and understand how software fits into various businesses. This created a right of passage for early developers to learn and grow their ability to understand and implement software. It could still be the case: non-programmers now can quickly prototype their business ideas, programmes can try pushing the boundaries of what kind of software they can build, and build a repertoire of meta-understanding about programming.

One question still remains: how ? If software can be easily built, how can one discover the edge of one's abilities, and expand on them ?

This is an open question as of my understanding. In these uncertain yet exciting times, my personal bias tends to favour the act of reading. Reading deeper into computer science, reading deeper into business, and formulating stronger frameworks which can in-turn facilitate better orchestration capabilities regarding agent usage. Nothing stops us from simply asking the LLMs anything we want, so why not tackle harder problems ?

We have a tool with seemingly infinite patience, the knowledge of the entire internet and most importantly, a means to break down walls standing between us and deep knowledge.

Blogs

A lot of fun blogs I read, my own entertainment-through-mobile, are what I'd categorize as insight porn or mental models, and they mostly oscillate from being about computer science/programming, business or everyday psychology.

These blogs are ego-boosting at worst, and actually insightful at best. On one hand, it might make one wonder as if one has read something profound, and thus possess unique/important insights about a particular concept, and on the other hand, a fog lifts, things get demystified, and we get better perspectives about the world at large.

Starting on this path I personally was a victim of the former (but this was a personal problem, not because the blogs branded themselves as imparting important knowledge/insights) and it took time for me to realize my internal biases, and learn from them as well. The reasons were simple amalgamation of the ego that comes from having an inherent interest in STEM fields and reading, finding tech twitter during the ai boom and other things as well.

Although now, a few months and mistakes down the line, I find reading these blogs more satisfactory and pleasant than before. There's less of looking-for-something intent, and more of casual consumption.

Recently I read a good take on experimental history, which was exciting. Another on botany, and yet another on business/startups. They are pleasant, casual and, in my personal opinion, a great way to pass ones time.

Simulations, Rule Designs and Games

Game programming maybe, perhaps, the most tedious yet rewarding sub-domain of programming: it involves complex graphics, conditional logic, distributed systems problems (multi-player) and much more, but in turn we get pure dopamine hits, satisfaction and lasting memories. In this piece, I'd like to focus on my favourite genre of games: simulations (the last point of one of my previous posts).

First things first: there are a lot of games which are technically simulations ... but aren't. Let's take an example, Clash of Clans. We select an army, arrange our bases in certain strategical ways, deploy troops and watch them loot other player's bases. While it is a simulation, we do not get to re-write the rules themselves. The player is constrained. This applies for almost all the games we generally play, since constraints limit the cognitive load the player has to endure, leaving them with pure enjoyment. (Not always though, it really depends on the goal and the constraints of the game. A good example would be Chess).

What about open-world games ? Surprisingly, they can be quite limited. Think about it: what actions do they allow us to take, and how bizarre are the consequences ? (GTA V maybe an exception here, more on that later). Some titles like Elden Ring, while pushing the boundaries of open-world games, still follow a somewhat rigid storyline. We cannot re-write the story, but simply play through it. So what exactly do I mean, when I say simulations ? The short answer is: emergent behaviour .When every system in a game doesn't just run, but instead interacts and reacts with other systems, we get emergent systems. Unexpected and unique narratives play out, not only making the game more engaging, but also personal.

Many games do manage to incorporate en ecosystem of inter-connected systems which give rise to emergent behaviours, like Far Cry 3, Legend of Zelda, GTA V (biggest title here), and a lot of modern games including Battlefield, CoD and other titles. Games being simulations is an old concept, and as we get more compute power and sophisticated algorithms and AI, we are rapidly moving towards more interactive and emergent games.

That being said, the games which inspired me to write about this topic aim to go beyond, and push the boundaries of simulations. One would feel like literal programmers while playing these games (one can even argue that there is an isomorphism between these games and programming). I am talking about titles like Eve Online, SpaceChem, RimWorld, Oxygen Not Inlcuded, Factorio, Infinifactory and finally, Dwarf Fortress. These games are literal programs we have to write and execute, and watch in anticipation how our solutions work in the "real" world. In some cases, simple rules give rise to complex behaviours (SpaceChem/Infinifactory) while in others, complex systems interact with each other, giving rise to emergent behaviours (RimWorld, Dwarf Fortress).

The games I mentioned above aren't meant for playing, they are made to be experienced . While it may not be everyone's cup of tea to sit through hours just to solve puzzles or start enjoying the game, the niche gamers who play these games can never go back.

EDIT: (Forgot to mention Football Manager, which is a one-to-one excel sheet management "game". For those interested in finding more complex games like the ones I mentioned, here's a video on the same.)

EDIT 2: Recently, this video gave a proper name to the genre I mentioned for the latter games: spreadsheet simulators. It does seem to be pretty accurate, these games have that one commonality, they simulate a spreadsheet!

A path forward

I do not remember where exactly I read it among the many resources I've consumed related to large language models starting early 2023, but among a few other things, the skills required for programming, which were implicit, started being more explicit, beginning with the ubiquitous question: if LLMs can code, what would SWEs do ?

This essentially proved to be the wedge that separated those who saw LLMs replacing them, and those who saw them as tools to realise their dream projects. Alas, reality set-in eventually, and the former could not be replaced completely, who now use them to write more or less sloppy code, and the latter only got boilerplates to start their projects with.

But as we slowly converge towards LLMs being (not AI), rather efficient congnizant machines which are great at converting intent to code, we are left with a question: if learning to code is becoming irrelevant, what do we learn ?

The answer lies in recognising the overall meta-trend of technology (for a lack of a better word. I basically mean, a sub-trend or sorts?), which is the explicitization of more abstract ideas into tangile code. This trend shows up in technology and AI research, but then again, the holy grail of tech (or computers but whatever) is AI. This trend shows itself when we look at the evolution of programming languages and the history of computation, alongside strides made in AI research. More precisely: Our initial goals always evolve from problem solving to optimizing tool efficiency, which in turn helps us solve more complex/abstract problems, and so on.

(A quick example: modern front-end is hard to imagine without frameworks like React, wherein modern developers might feel writing vanila html/css/js almost alien. This might seem atrocious to developers a few years ago, and the level of abstractions go deep. Browser engineering, Operating systems, hardware engineering etc ... A problem in React would be intractable to even conceive at the browser level. More abstracted tools help us solve more abstract problems.)

(Another side note: it's generally a saying that to be a good developer is to be familiar with one level up an abstraction as well as one level down)

Now getting to the main point: it is more advantageous than ever to understand the abstractions which are being explored on the very theoretical limits of computer science (or rather all the sciences). (See my other piece on explicitization of theories), wherein the goal should be to acquire an ability to dictate intent such that we can either extend said theoretical limits or be able to make the LLMs emit tangible code to express abstract concepts and as a consequence be able to solve more abstract problems, with real world impact.

Implementation and Explicitization of theories

Recently while exploring a certain topic through chatGPT, one of it's lines mentioned the explicitization of certain theory(ies), which caught my attention, and made me psuedo-realize (half-realize ? basically transferred a thought from my sub-conscious to conscious) that the entire branch of computer science has mostly been about the implementation and explicitization of various academic theories we have come up with over the years.

Thus, as per my love of making lists, here we are, trying to list down all the theoretical fields or theories which computer science has helped implement/explicitize:

• Mathematics. Most obvious, in fact, the entire field of computer science is the real life realization of math or mathematical concepts. Computation happens when we can express certain logic and transitions in our real world. Computing devices existed a long time before modern computers came into being. On a more abstract level, the type system makes mathematical proofs explicit.

• Economics. At first, we might think that certain simulations could be considered as the explicitization of economical theories, but it's not what prompted me to write this piece. Through programmable money is how we can make theories about economics more explicit, hence: crypto currency. I am not sure if cryptocurrency is a viable solution of the question that is money, but I do agree with the llms on this point: if we decide to create a global crypto-currency (especially with smart contracts), we thus could explicitize/codify various theories or ideas, and directly influence human behaviour (to a certain extent).

• Morality/Ethics. With the advance of certain areas of AI and robotics, we must decide on a universal code of ethics, since it may turn out to be necessary in real life scenarios: the trolly problem posed to a self-driving car. With the advent of large language models, this has become even more important. The LLMs must be able to tell apart moral actions from immoral ones, and must have an internal moral compass, lest it falls into the wrong hands. Another example would be AI psychosis.

• Law. Now this is a mere attempt, and no where near real-life usage, but rather just an experiment: This paper explores how high-level programming could make policies/laws more explicit through converting laws into code. Though this is still limited, as it requires a lawyer and a programmer both, to clarify ambiguities, which means any bias or error in the initial interpretation of the law would get implementation into a unambiguous and explicit form, code, and stay like that until corrected or challenged.

• Simulations. This seems like an overall implementation to either check or implement various theories, from economics, evolution to civilizations. Physics engines, chemical reactions are also some other examples of simulation. Though this is a legitimate way computers have helped us implement certain theories, this doesn't feel like explicitization, but rather the setting up of initial conditions, and letting computation perform it's magic.

Don't Think

... unless needed

Re-inventing the wheel helps no one, so one should experience first, and only take a jab creativity when we reach the edge, the edge of known knowledge.

Agency

Lately, a lot of resources I've been reading seem to mention this seemingly new term: agency. In simplest terms, it seems to be something related to free will, but ... more abstract ? Freedom. Probably

• In this piece, the author talks about difference between agency and ambition, which seems to make sense.

• In this piece, Aella talks about treating children like humans, like adults, which resonated with me. I believe this is required to maximize agency among the next generation.

• "Intelligence is Agency", had garnered quite a discourse this past few years, following the advent of LLMs, when once again the question of what intelligence is came to the limelight, and seems like LLMs lack it ... but so do some humans ?

Levels of using LLMs for programming

• 0 : Whatever people used to do pre-2021/22
• 1 : Replacement of stackoverflow with GPT, especially the copy-pasting of error messages and user-specific queries
• 2 : Copy-pasting specific, modular code (like a single .tsx page, or a function given it's purpose and type signatures)
• 3 : Usage of codex/claude code/gemini-CLI/cursor. Within terminal programming.
• 4 : Agent mode, specific tasks or to-do list
• 5 : Vibe coding. Pure english, no exposure to the codebase, either through the terminal-llms, bolt, replit, lovable etc ..

Art reconsidered

"Programming" in this LLM era has been surreal. From learning it the old-fashioned way, of stack over flows, github issues and going through npm error traces to copy-pasting chats, it has left me both excited and a bit sad at times.

Whence the types came The code expressed itself Whence the inference ran The code compiled itself Whence we saw, We understood.

Personal Manifesto for conducting research

Often I see a lack of research as a major bottleneck in any project undertaken by people. This is often prevalent in projects that attract a lot of grifters, i.e, hyped areas, where a most common example is technology.

This has led to a degradation of overall quality of research. For clarification, I do not mean research as in academic research, but more of the action that we perform in our everyday work. LLMs and the advent of it's deep research capabilities have added fuel to the fire, where people seem to have truly offloaded their cognitive thinking to them, leading to further degradation.

For no particular reason (maybe to send this post to anyone whom I think may fall prey to the above trap) I decided that I will list some ways I would approach research, on a topic that I know little about. These points are for beginners, not experts.

Our main sources often are:

• People. The first and foremost way is to simply interact with people who know about the concept, and gather as much information as possible. If in-person exposure is unlikely, we have social media sites (like reddit, twitter, instagram, linkedln). The ideal person is someone who has the exact knowledge that you seek, but in cases where this is not possible (either due to the concept being niche, or the domain being ill-structured), we must extrapolate.

• PAEBB. Reading and collecting material in the form of papers, articles, essays, blogs and books. The content that we consume from these sources would be different, and often denser then if we talk to people. Reading material is often a better way to expose oneself to radically new perspectives, and grasp more in less time (as compared to talking to people). There is also the added benefit that reading material (at least the long-form ones) are more well thought out, and can provide valuable insights that otherwise would've been missed while talking.

Information gathering must be limited. Avoidance of rabbit holes, unnecessary jargons, unsolicited opinions and misguided perspectives is imperative. Especially the opinions. We must learn to distinguish between opinions and facts, and to be honest, most of the research out there is based on opinions, even to a large extent, within STEM.

That being said, how would I go about learning the basics of a new domain ?

• Read a bit of history. It gives us the origin of the said domain. This helps a LOT, wherein we understand why the domain came into existence, how it's evolved and what are it's current paradigms.

• Create a mental scaffolding of the modern paradigms and current best practices that are being done by experts. This could come from PAEBBs or even news. This gives us a bird's eye view of the domain, which is often necessary for ...

• Identification of which sub-domain concerns you directly. More often then not, most domains are vast, and we can easily overload our brains with information that we do not need in this age of internet and LLMs.

• Recursively perform the above procedures, till you get to your problem/use case/application. The next step is to actively look for solutions, which directly and immediately solve your problem/use case/application. This step maybe different if one's aim is to learn, but initially it helps to look at solutions, before "testing ourselves".

These above points assume you've time and patience to get an in-depth understanding of the domain before you tackle any problems. And in case you don't have time, hire a professional. It often better to do that instead of acting based on partially known information, but of course there can be other trade-offs involved.

The Vibe

Programming includes two tasks: thinking/planning and typing. Vibe coding is when LLMs are doing both of the above mentioned tasks for us. It is not vibe-coding if it only performs the second task.

Decentralization

EDIT: After reading this essay, I learned the difference between decentralized and distributed networks. I have used the two terms as if they are inter-changeable below. I chose not to edit, since it doesn't change the overall theme of this piece.

Pondering on the concept of decentralization, as it has come up in diverse concepts during my reading recently.

Decentralization at its core is the distribution of the central to the masses, in a manner of speaking. The study of decentralized properties of certain concepts has permeated almost all fields of academia, and seems to be a very fundamental aspect of a lot of systems.

Without further ado, I'll try my best to list down some cases below:

• Distributed systems in computer science. There are major sub-branches within this one, as dist sys is itself a generalized concept. To list a few:

  • Distributed databases. Modern databases are almost always distributed, as the need for storage and speed has exceeded the limits of what a single machine can handle. Taken to the global extreme, we get Blockchain (which is essentially a globally immutable append-only distributed database).

  • Distributed training for large language models. The current paradigm of AI is backed by an equally fascinating training procedure to train these internet scale models, with complex distributed learning algorithms making it feasible.

  • The internet. The prime example of a distributed system is the internet itself, where every machine that connects to it becomes a part of the whole, and contributes to it.

• The price systems. One aspect of economics is how we deal with vast information asymmetries, and how the market responds to actions taken by people with incomplete information, and how we can mitigate this problem. One thought is that we already do have such a system: the pricing system. Prices incorporate relevant information, and given a person's immediate context, provides just the right amount of information that they can make rational decisions. This is also a prime example of a distributed system, where the prices of goods are inter-dependent in extremely non-trivial ways, but provide a decent view of the current market sentiments for an asset.

• A recent view that I read on psychiatric disorders put forth an ontology for the same: that of a dynamical system with attractor basins for stable states. The dynamical system, or rather a network of inter connected nodes (the definition of node being certain behaviours) is an example of a distributed system with emergent properties, where the emergent phenomenon are psychiatric disorders. This also suggests a decentralized view of looking at our behaviour, something that has been neglected in the field of psychology in favour of a centralized worldview.

• Democracy is more or less a decentralized way of making decisions, and has been thus far the most successful one. Although there are opposing views which claim that democracy has downfalls, it is still the lesser of many evils.

Reasons for scarcity of abstract pattern recognition in modern systems and data (by people)

Brains are an excellent and efficient pattern recognition machine, which can find patterns in seemingly random data as well (with certain conditions, more on this below).

Given this, I found it peculiar that the vast majority of people (around me, but from reading blogs online, seems like a majority of today's population) frequently abstain from indulging or developing deliberate thought patterns which facilitate general pattern recognition. This seems peculiar because:

• The above mentioned reason: brains are apparently good at it.

• It is beneficial, in terms of almost every aspect of life.

• Our education system should teach us to do it, from an early age.

To be very clear, we do do it, in abundance, in our social aspects of life. Our societal structure, our cultures and relationships are intertwined and complex, and yet our brain does a decent job at navigating through the mess by identifying workable models (models ~ general principles), which help us be a part of society (with certain obvious cases of failures).

The fields where we specifically lack this pattern recognition ability are in numbers, or in other words, data. Numerical data provides us with a symbolic representation of reality, something we are not comfortable recognising patterns in.

But it's not just numerical data, it's also economic/financial analysis, STEM fields, computer sciences and the post-industrial societal structure.

A few reasons why this may be the case:

• The most obvious reason: these concepts are very new compared to the existence of modern humans. Brains haven't evolved to optimize on recognising patterns on excel sheets and social media.

• The lack of culture around honing our skills explicitly for recognising patterns in never-before-seen data. Now I can't vouch for a lack of culture for anything around the world, but as far as I've seen, it's hard to find good articles/ blogs/ essays/papers/ books that take into account general trends related to a concept and explore from that perspective. Not that they aren't there, but they aren't prevalent enough to be considered a part of the "culture".

• Not enough direct economic incentive to do so. Honing this by itself means getting into the classic trade off between developing a skill which leads to growth in the future, but not so much now. Add this to the fact that this trade off isn't directly vouched by many people (lack of culture), and hence many young adults are either unaware or do not spend adequate time thinking about the pros and cons. Kind of like opening a business vs getting a job, but there are no direct examples of successful businesses, so you see no pros at all.

• It could be the case that we needed to observe enough specific instances of a particular phenomenon for some experts to piece together a general principle, and that the concepts mentioned above have taken their time showing us these specific instances, leading to a slow but steady growth towards the development of a general theory of the said concept. This could mean my assumption that people do not do this is false, or rather misconceived. They are doing it, but due to the recency of the modern age, it's happening at a slow and steady pace, and thus is harder to perceive.

Overall, it seems like I had a lot to say about this, (which wasn't obvious to me when I started writing this :), especially the many examples that came to my mind which I chose not to include in order to continue my flow of thought.

I'll write a follow up post probably to go a little in-depth, but with examples.

Product vs Process

There's more value in a finished painting, as compared to a finished source code of a project. This question arose in my mind from the debate about whether model trainers should compensate artists, and the lack of it in case of programmers, who seem to embrace LLMs coding.

A couple reasons I could think of:

• The location of value. The essential ingredient being abstract (theory or implementation details) makes the raw written text much less valuable in case of programming, since the moat is in the idea itself. Obviously not the case for painting.

• More economic value for the process of programming vs the process of painting. The average programmer can get easily paid, as compared to a painter painting. Hence, the only thing of value the painter has for their efforts is the final product.

• Democratization of code and lower barrier to entry. It's a lot easier to get started as a programmer, learn fast and get paid, as opposed to doing the same as a painter. It's harder to paint good, requires longer hours and more concentrated efforts, with much less monetary reward.

• The culture of boilerplate code and shared solutions. Programming derives it's value from problem solving, hence solutions that are shared among problems are desired, which lead to faster solutions and require minimal time. Whereas each painting derives it's value from being unique, and looses it's value if it isn't.

• Verifiability. Code is almost instantly verifiable (at least in the short term), and can easily be objectively judged (hence easier to compensate for or place monetary value upon). Whereas paintings are almost entirely judged subjectively, which takes pricing to the extremes (some might place zero value and others might place it in millions, on the same painting).

LLMs doing exactly what they are told is ironic and funny in the sense that we now have come a full circle, where programmers need, yet again, to be aware of better ways of doing things, keeping up with useful libraries and really knowing their sub-domain in order to avoid common pitfalls cause ... the LLMs (can) do exactly what they are told.

There is a difference here, where we simply can ask the LLM to do better, be more efficient or find better solutions. This yet again points to the "old" ways of googling, stackoverflow and other ways one has to optimize one's code, but this time, much easier (in certain domains, and sometimes with the context of your entire project).

This whole paradigm points to the old pattern of a new tool making our life much easier, with possible long-term trade-offs we don't really care about now.

Personal Observation: Beliefs that live at the extreme are most probably false.

In retrospect, this seems like an obvious fact, until one introspects and finds that one of our own beliefs is extreme, and hence has a higher chance of it being false. Now we have a bit of cognitive dissonance, which needs resolving.

I came to this conclusion (that extreme beliefs are generally false) from very simple observations: people, experts, sometimes have opposing views on their own fields. The divide became more apparent in "softer" sciences than in STEM.

I myself found I hold some extreme beliefs, and it's hard to do the resolving. In the end, I settled to go with the more logical choice (in my opinion), that any and all extreme beliefs are probably false.

Much to my surprise, while reading this article, I came upon a proof of the above statement (under some weak assumptions). That the stronger a belief is, the weaker it's probability.

Let me phrase the statement (in my words):

The stronger the assumption, the weaker its chances of being true.

As given in the article above:

The stronger a statement is, the greater the risk of falsehood.

As I said above, this statement has a proof! In theory, it's known as the Theorem of Conjunction of Costs Probability. In the formal language of probability, one can write it as:

p(A) > p(A ^ B)

Or the probability of A being true, will always be greater then the probability of A and B being true. The only exception, is when adding B has no effect on A, in which case we get:

p(A) = p(A ^ B)

Stronger, more extreme statements are the product of multiple underlying assumptions, and as we get more extreme, the number of underlying assumptions only increases. This, according to the above theorem tends to only make the extreme statement more and more unlikely, or increases it's risk of falsehood.

The proof follows from a simple rule of probability:

p(A) = p(A ^ ~B) + p(A ^ B)

Hence, if p(A ^ ~B) > 0, p(A) will always be greater, otherwise it'll be equal to p(A ^ B).

Failed Projects

A Whatsapp bot to handle advertisements on the app, with automatic billing for group members for a selected time period Reason : WhatsApp API was too troublesome to set up + costly for an MVP

Automatic trading strategy generation from natural language to python code through a DSL. Reason : A lot of it could just be a simple n8n workflow, and a DSL was overkill. Although I think a simple injection of generated code (the strategy) into a ready-made framework can work pretty well.

Monetary tracking of AI workflows per project (An AI project manager ?) Reason : Infeasible to create my own AI workflow generator, especially since n8n has hundreds of integrations. Could add custom tracking over n8n, but that requires deeper changes in n8n, and only on custom machines (not commercial).

Mock data generator for drizzle schemas Reason : Did not know that drizzle-seed exists (basically just started the project, didn't bother for similar projects lol).

Get manga cut-outs, and animate them (basically manga animations). Reason : Requires multiple deep learning models, may have been above my then programming and hardware level. (Though I think it can be feasible now).

CSV files data interpretation pipeline Reason : Ingest a CSV file, get an LLM to pick necessary columns needed for training classical ML models, train them, interpret the models using libraries, feed the results back into an LLM, and ask it for a meaningful interpretation. This does sound like a good "AutoML" system, only the idea was a little pre-mature, and was made before the models got better.

Background Consumption

Kinda related to the idea of dry pleasure that I have written here, this type of consumption of information is "in the background" (not unconscious though, mind you)

I have some examples, but they are very much personal, as background consumption may be very different, depending on the activity and the person, but as far as information consumption is concerned, it's just reading.

Personally I like to read a lot of blogs/papers (very common among the programming community I feel) and this activity, when I am not doing it for the sake of a project, feels like background consumption.

Blogs of opinions, methodologies, frameworks and life experiences influence my thinking in ever so subtle ways, and before I knew it, I would start writing, and start writing like them (I apologise if this seems derogatory, it's not. I want to write like them).

It influences how I think, how I write code or how I choose to deal with other people/situations. Of course it's impact is technically immeasurable, since we cannot (yet) run a counterfactual experiment where I never read any blogs or papers. But to the extent that it's relevant, I feel it has influenced my approach to work and programming in a lot of ways (good/bad ? Who knows) .

Proposition

Any and all codebases should start from a types file.

Helps in blueprinting the code, and more or less adheres to the practice of defining your functions, all of them, before writing out any of them. Kind of like a bird's eye view of it.

Possible limitations are web related or asynchronous code. (tRPC/gRPC ? I'm not well versed here). There's also something called session types, which might help express async code, or add a temporal aspect in its type system (experimental).

Overall seems to be great practice (hell, let the LLMs fill in the gaps).

Also fun with new, more expressive type systems.

Abstractions and Generalizations

I.

The generalizations of modern theoretical physics are astounding, but then again, a model that explains the nature of reality itself would be far from trivial (not to mention it isn't even the "truth", there are important things to explore).

II.

RAM was a mystery to me. A little demystification followed after playing this wonderful game (though I did not complete it). But the jump from NAND gates to RAM, with memory management was something that still puzzled me, until this video pulled back the veil. Building things up from nand gates to games was quite the journey for computer scientists.

III.

Theories for human behaviour at large has received a lot of attention in the last decades. I speak with someone who has very little exposure to this field (not naming any fields, since it feels like this can be anywhere between philosophy and psychology). Nonetheless, I was quite interested in Ken Wilber's theory, explored in this youtube video. All I'll say is this seems like a good philosophy of ... knowledge ? I don't know.

Good dog Bad dog

Recently my life was graced by a puppy I found lurking in my front yard. The only reason I was allowed to keep her in the house was the presence of other, hostile, puppies in our yard, which were coincidentally birthed there a month or two prior.

One thing led to another, and she became a part of our household, an "indoor" dog as they say, while three of them stay outside the house, inside our yard. Protests, remarks and complaints followed, since of the three outside, two got into the habit of jumping onto bikes. We had to restrain them (keep them in the yard, or tie them up)

Annie, the indoor dog, instantly became a dear to me and my mother, which was a given, since we were dog lovers and she was beautiful. But the protests followed, as she had learned to play and bother with any and all humans, a consequence of me coddling her. She was deemed a "bad" dog, who was supposed to be tied up so she could "behave".

It pains me to see her tied up (any of them actually). To live is to be free. Running around, breaking things, snatching clothes are behaviours that indicate she's alive and well, happy to be where she is.

This little rant comes after almost every adult I met expressed the need for a dog to be tied up, which I vehemently disagree with, but my culture frowns upon the young who disagree with the old, hence this piece. They may get a say now, but I tend to give my dogs the freedom that was meant to be theirs.

Most problems in programming seems to be approximate on various levels, rather then analytic. Often, through decades of research or trail and error, we do stumble upon a very good solution, but given the general open-endedness of the problems programming aims to solve, the solution most probably is an approximate one, rather then analytic.

To define what "analytic" means, in my mind it should be a "proven" result, which means there's some fundamental truth to that solution, which makes it one of the or the only correct solution to that problem, for ever (there won't be, or rather can't be, a better solution).

By that above definition, a lot of people would hesitate to call any solution an analytic one, since most solutions in programming are slowly improved upon, and no solution feels like it's a fundamental truth about our reality (mostly cause the problem also seems very artificial, like "what's is the best data structure to store this data").

In the above paragraph, the artificiality that I mentioned could just be abstraction in disguise.

Levels to Programming

Putting things in this hierarchy seems to be too ambiguous, since there are too many overlaps within concepts, algorithms and sub fields in programming.

Nonetheless, let's start with some measures/indicators:

• distributed vs non-distributed, the former being harder of course.

• Estimated Kolmogorov Complexity.

• Where it (program/concept/data structure/ algorithm) lies on the abstraction spectrum. At one end, we have the lowest level machine code, and at the highest level of abstraction, in my opinion, are advanced typed languages like mathematical theorem provers. Both ends are harder than concepts that lie in the middle of the spectrum.

• Number of collaborators ? Higher is obviously better

(Lines of code included indirectly in KC)

Seems about it. LLMs provide some more, but all of those can be derived from the above points.

Dry Pleasure

The act of squeezing out any remnant pleasure from an activity, as a part of one's daily routine feels like something I would call "dry" pleasure. The activity can be mundane (is mundane according to the rest of the population) yet feels "right at home".

Drinking water is extremely pleasure at best, and "I don't mind" at worst. Reading a book/article/essay, for the sake of completion/habit, some form of work and other things can be seen as dry pleasure depending on what one's preferences are.

Though an exception (not strictly definitionally) would be reel doomscrolling. It has an instant feedback mechanism that isn't "dry" enough, and while some pleasure is derived, it feels or is more like an addiction.

A tale on Types

My fondness for programming can be boiled down to numerous reasons, be it it's logical or problem solving nature, or the visualization of mathematical objects or simply that we can create games with it. These reasons are often given by the vast majority of programmers out there (except those who code for money, but I don't consider them programmers), me included. Recently, however, I discovered a bridge between computer science and mathematics which was a common ground to deepen my knowledge about both of these fields. Types or the Type System is the core component of this bridge.

My first encounter with the type system was while writing C, but it went unnoticed for a long time. It was only when I switched to Python and then to Typescript that I really understood what I was missing. To be honest, initially, types seemed like a hindrance (especially coming from Javascript) which forced me to reason about the nature of my code and it's behavior before running it, something I wasn't used to. It felt like a burden, an overhead that can be easily dealt with by simply running the program and observing it's output. The turning point, however, wasn't necessity (where I was forced to used types due to some reason), but my desire to learn the best practices while writing complex code. Before long, I was hooked. I have fun writing interfaces and structs (not class ... (BaseModel) though, yet) with their associated variables and functions. It felt like I was designing code, rather then simply writing it. This feeling was artistic, rather then mechanical. Thus I stumbled into a whole new paradigm of programming.

The type system, or types in general, couldn't be much simpler to understand: they simply represent data, and all we have to do is express in our code that we know what the nature of a specific data point (variable) is, at any given part of our program. This forces us to reason about our program in advance, and write much more complex code more robustly. Types have lots of advantages, but they are just a part of what makes them appealing. My interest in type system didn't peak when I was learning the advantages, it peaked when I was learning the extend of type systems. (It's internals and implementation are also close contenders). Since I have only recently discovered my passion for types, and lack the necessary knowledge and experience to make meaningful comments on this topic, I would rather like to list various features or topics that I find fascinating about a type/type system here.

• The blueprint nature. Types essentially are blueprints to the entirety of our code, and much can be said about our codebase by just looking at the types file (be it types.ts, models.py or header files).

• Types essentially allow generalization of concepts in ways that closely resemble the generalization of mathematical objects. One easy-to-see example is generics, but that is just the tip of the iceberg.

• The Dependent Type Theory (DTT) framework. The main component of this "bridge", which is theorem-provers or proof assistants. These essentially help mathematicians verify their proofs, while assist them by filling in some gaps.

I have recently started going deeper into DTT, and it is as complex as it is fascinating. When I first read the definition of what it means, it seemed as simple as "a type that depends on it's values", but upon looking at an example, I realised why DTT isn't implemented in general-purpose programming languages, even those with an expressive type system: it is highly non-trivial. For reference, here's a snippet. This code defines a tuple, whose second value depends on it's first.

universe u v

def f (α : Type u) (β : α → Type v) (a : α) (b : β a) (a : α) × β a 
:= ⟨a, b⟩

def h1 (x : Nat) : Nat := (f Type (fun α => α) Nat x).2

#eval h1 5 -- 5

From someone coming from using only mainstream programming languages, this was initially hard to reason about (due to it's functional nature as well, similar to Haskell). This, however, allows the language to express and work with abstract mathematical concepts, and reason about them (use them in proofs). This above consequence, that a type system can express a mathematical object, comes from the Curry-Howard Isomorphism, which states that any mathematical proof can be expressed in a computable program, also called propositions-as-types (second chapter in this excellent book).

This correspondence is an excellent way for one to dabble with both programming (through languages like Idris, Agda, Coq or Lean4) and mathematics, by expressing proofs in them. One could argue that this represents less of mathematics and more of computer science, but I personally think this could be a modern approach to practicing mathematical proofs and building upon them, instead of the traditional method of writing them down on boards and papers.

On Nature of Computing

The nature of mathematics is a well explored and talked about question (1) while being a profoundly deep one. On the pathway to answer it, we have created entire sub-branches of fields and areas of study.

As intriguing and fascinating as this question is, I find myself leaning in towards a particular sub-branch, which is the pragmatic realization of mathematics in our physical world: computer science, and how this recent branch of mathematics might help us speculate an answer for the ancient question.

My approach in discussing this topic in the essay is to simply draw parallels to ideas I have encountered in two papers: On proof and progress in mathematics and The Age of stochasticity. These papers are, coincidently, both written in the previous century (1994 and 1999 respectively), and it really shows the deep insights of the authors in predicting the nature of modern technology, through speaking about the nature of mathematics.

We shall start things off with the first paper, written by the fields medalist mathematician, William Thurston. In this non-technical paper, Thurston talks about his personal experience in learning, contributing and teaching mathematics. He expresses the the idea that the goal of mathematical proofs, and the very reason people study them, is to understand them. The communication of mathematical ideas must be focused upon, where although obscure formulae and derivations are important, the transfer of ideas is more crucial still. Thurston's point that the reason we humans do not want the answers and proofs to certain questions, but want to understand them, is universal, and brings us to my first parallel: programming as a means of communicating ideas.

Now anyone who knows programming would find the above statement confusing, and some might even claim it to be completely false, since, the very act of programming involves communicating with a computer, with almost always no other human in-between. This is true, but not just for computer science, but for any field out there. The literal act of studying a particular subject is different then what W. Thurston is talking about: the purpose is to explore the very nature of mathematics/computers, and collaborative research is the only way to move forward. We need to communicate ideas to other people in order to build something new and expand the very boundaries of a field. Programming as a medium of communication with fellow developers is an idea seldom talked about explicitly, but is very well known by experienced programmers implicitly. Collective effort has given us the gift of modern mathematics and modern computer science .

The second paper is a rather interesting one. D. Mumford talks about the underlying thought process of mathematics and challenges the assumptions and the way we have approached them for the past two millennia. Logic and formalism have dominated not only mathematics, but also our own thought processes, and was viewed as a dominant approach to accurately approximate and model the reality around us. Rigour being ingrained in how we approach mathematics can be traced back to Euclid's postulates, and building up from there, to eventual reconsiderations and reformations. However, logic and mathematics still seemed to be intertwined until the end of the previous century, when alternative ideas and ways of thinking won over the mathematical community, including people like our author, D. Mumford.

So what is the alternative ? The above excerpt might be a bit misleading, and make it seem that the alternative idea is some poorly explored, extremely niche topic. On the contrary, it is a well known and one of the most prominent fields of study today: Probability and Statistics. More precisely, it's the probabilistic view of our mathematical structures and models that out-performed classical methods in practical use cases and applications that led us to finally challenge the dogma that logical reasoning, with precise formulae and riguor would help us model reality better, when it was a probabilistic view of the world that succeeded. While the evidence can be found in the triumph of probability and statistics in almost every field, we shall explore narrow our focus on one particular field: computer science.

The computational model, famously proposed first by Alan Turing, and which came to be known as a Turing Machine, initially relies heavily on logic. Even the real-life implementation of actual computers chips relies solely on what we call logic gates. These formal models of computing, paired with the real-life implications of systems build upon them point to a clear winner, logic: formal, precise and deterministic.

A more probabilistic model of computing is recent, and quite heavily researched today: Quantum Computing. The point of speculation, that Quantum Computers can better simulate real life particle interactions then classical computers, due to the fundamental reality of our world being quantum is a good indicator of a very basic fact about the nature of mathematics, one emphasized by Mumford in the above paper: to better model reality, a probabilistic view of the world is a necessity (2)

The above papers, in their exploration of the very nature and purpose of mathematics, helped us shed some light on the nature and purpose of computing. Computing or programming as a medium of communication and it's underlying nature being probabilistic are two schools of thought that emerged since the dawn of computers, benefiting from the two millennia of mathematical research in a few decades, and quickly dominated the research and corporate communities.

---

1: Is God is a mathematician ?

2: Another good example is our current leading theory (and implementation) of intelligence: large language models. These model's underlying assumption of the nature of intelligence is that it's probabilistic, and which has clearly outperformed any other method of achieving "Artificial Intelligence" upto this point.

Moments I felt the AI

Since 2020, there were only a few moments I was really fascinated by AI, and I thought about jotting them down here.

• When chatGPT (3.5) came out, I was intrigued by it (obviously), but more as a certain piece of software I needed to know the internals off, rather than it feeling like "AI". Nonetheless, it kick started my mild obsession of going through books and courses to understand the how.

• While travelling in a train, my friend mentioned the newly released GPT-4V, with vision capabilities. He then went on to click a picture of the floor and ask gpt-4 to describe it. That moment was a fuel for me to continue learning about these models (though I didn't really aim to be a model trainer or anything as such: just pure curiosity).

• YouTube was my go-to entertainment site, and here I came upon Gothamchess' AlphaZero vs Stockfish analysis. The match was thrilling (credits to Gothamchess' extremely entertaining commentary) and really excited me about the paradigm of Reinforcement learning, even though both RL and AlphaZero where old at that point (came out in 2017). Before that, I had bought a book on the chess engine, but it failed to awestruck me the way Levy did (the book heavily focuses on chess, rather than AI).

• I had been well into the lore of deep learning, LLMs and the AI paradigm, whence I came upon a blog which explores the entirety of llm training process, from the ground up. Now this blog does it simply through tracking the process of a new player in the AI league: DeepSeek. Simply reading this blog, and reading about the (then) 16 papers released by DeepSeek, I was hooked. It wasn't just transformers, it was distributed training, creative data preprocessing and many other things (as evident by their recent opensource week tweets) that set them apart, not to mention everything is open source. Probably my favourite blog on LLMs till date.

Types of codebases/software

In my little time of learning and loving programming, I have come about to view it as a tool. There are people who love and cherish their tool, there are those who simply use them to get work done, there those that want to master the tool, automate the tool's job, etc, etc.. This tool has given rise to enormous amounts of economic value, entertainment and livelihoods. This tool has led us to built projects, from big ones to small, from simple to complex. Here, I am writing about certain types of projects one might encounter on Github. Of course not every project will fit into these categories that I present, but I implicitly tend to categorise projects I encounter into some category, hence I might as well write about them here.

Small scale business applications, most programmers when starting on their journey to become an SWE would start here. These often serve a simple and small business need, and include a simple CRUD app with a db (all the various stacks). Note that it is not the stack, but the scale that determines that these projects are albeit easy to get into, and serve a real life need. Could be your To-Do lists or smaller scale e-commerce sites.

Small libraries, not a lot of programmers would venture out to build libraries, but still a lot actually do. These libraries generally serve a single purpose and do it well. They are generally written by some person(s) who came across a unique problem, and being the great programmer that they are, implement a solution and gift it to the world. Some good examples are MiniSearch, an in-memory text search library in Javascript, or HNSW in Go, which implements the HNSW vector index in Golang. Small, elegant yet powerful.

Large scale applications, one normally gets here by simply scaling up the above mentioned business applications, and eventually run into unique and hard problems. These problems are worked on and solved by some of the best programmers in the world, and often have a user base in the millions. Usual examples (at least the ones which are open-source), are Telegram, Tiaga and one of my favourite, Tldraw. (Is Tldraw a legit business application ? Don't know, but love the repository).

Large/Complex libraries, probably contains some of the best (if not THE best) code written by us. Larger libraries and business applications differ in their goal and how they plan on achieving it: one is profit oriented, while the other is more or less scientific. I am not sure if this distinction holds in some examples I am about to give, but nonetheless, these massive libraries are all open sourced, and hence provide for some excellent codebases to read through. Some favourites: Postgres, Linux, Torchlib, Glasgow Haskell Compiler, LLVM, React, Numpy, FFmpeg, SQLite, V8 and finally GCC.

Why more examples of larger libraries ? Because they more or less drive the software world ahead and have stood the test of time, with relentless innovations and selfless contributions from the open source community.

Through the Lens of Now: How Presentism Shapes Language Models

This meme is a good reminisce of the concept of historical myopia/Presentism, where we humans have a skewed/biased view towards our current times. Once being reminded of this, it also becomes clear that our exploration of technology is also largely based on how we view the said technology, and how we draw analogies to our surroundings/nature.

I am sure there maybe many more examples, especially after the age of computers, but here I would like to trace out our latest innovation: large language models. Since this seems to be our latest belief, we can even see how each time we climb a level of abstraction to borrow ideas from. (We went from taking inspiration about how the brain functions, anatomically, to taking inspiration to how it thinks).

Initially the research seemed to be more "computational", in the sense that we had to move away from how our brain functions to take into account statistics and data science to dish out what empirically worked: model training at scale. An analogy here is we are simulating millions of years of human brain evolution, by training a massive model on most of today's human knowledge (called the Internet). The next paradigm, which is recent (post 2021), also called Supervised Fine-tuning, is about further training the model to behave in ways expected by users/consumers. The analogy is easy: after birth, we are trained till 18-21 years of age to behave, while societal and cultural values are indoctrinated in our young minds.

The analogies may seem a bit far-fetched, but once viewed this way, they do make sense (humans love analogies after all). The next paradigm is even more obviously drawing it's inspiration from how humans think: spend more compute power on harder problems, called Test-Time Scaling. It is as simple as that: keep the model "thinking" and "reasoning" so it can solve harder problems.

At this point, further research tries to draw on more inspiration to how humans think, perceive and reason. Another research tries to make the reasoning process implicit, similar to how humans sometimes perform well versed reasoning task without explicitly thinking about it, also called System 1 vs System 2 thinking.

These analogies help us see not only how our current technology closely resembles us in more and more abstract sense, but how we try to mimic our own thinking processes to nurture said technologies to their absolute potential.

Software Design

Throughout my experience of reading about software (yes, reading and not writing :) ), I have come about to really like and admire the design decisions that take place, that eventually get implemented and either make or break entire codebases, especially when writing libraries and/or complex tools. This aspect of writing software not only comes from someone with experience, but also from someone with a purpose, and hence a vision they want to accomplish: which is fairly uncommon nowadays due to the career-driven nature and popularity of software engineering jobs.

Such decision processes and "philosophies" are prevalent in almost every widely used software product out there. No piece of software, used by millions, is mediocre. This provides for an extremely interesting and valuable source of information in order to learn from such examples. I am personally fascinated to read about the thought processes and design decisions taken by the architects of large codebases and software products utilised by generations of developers.

One subtle aspect of trying to read through these essays/blogs/walkthroughs is, it is not important to understand the technicalities and the inner workings of such massive projects, even professionals would take years! The best lesson, at least for me, is to look at the what, why and how of a particular decision and understand how similar situations and problems can arrive when I myself venture out to writing designing a project. The architects (most of the times) explain how they came about a problem, why they implemented (or didn't) a particular feature and other semantic decisions, which provide for a rich source of context and rationale behind the system's design.

All that being said, I think personally I am too inexperienced in order to learn a substantial amount from some of the blogs I have read, but nonetheless, it is often exhilarating to find common design patterns in unexpected places. Apart from that, it is often inspiring to read about certain codebases which are decades old. Others ? They offer valuable and quite intriguing examples of how/what problems certain developers faced, and how they came about the solutions. There are many other examples that are good, but due to being highly technical and niche, aren't pragmatic for the average developer. I nonetheless read through these blogs to at least understand their problem solving approaches (though to actually solve problems of that calibre, one needs to be an expert in the field).

I believe the want of designing any software comes from having a deep passion and appreciation of code, both as a tool to solve real life problems and an art. I personally tend to be more on the artistic side, but lately, I am trying to design some real life problem solutions as well.

Reading Levels

Often as a reader, when being approached by a non-reader (however one might define a non-reader, or novice), I am forced to think about reading in levels, and give it a type of hierarchy. One expects a reader of a certain level to find it "easy" to read material on their own level and below, while "difficult" or "draining" to read above.

It is tough to give such a ranking to various types of material, but easier to put forth an opinion on the same (and fun). One obvious thing to exclude is material meant for kids: I am only considering adults here. (As mentioned above, this ranking is entirely based on my opinion)

Coming up with titles for said ranking is tough (very subjective), nonetheless I shall give levels of reading material as:

Self-help

I didn't dwell on this level much, but I did start by reading some famous ones like Think and grow rich, Rich Dad Poor Dad, The man who sold his ferrari. Books meant more for the general audience and, of course, self-help. A person who claims to be a reader but has only read up-to this level should stop doing so.

Commercial

This level is mostly about novels and magazines, so more focused on entertainment. There are certain sub-levels, but overall this material here has easier language and provides the reader motivation to read further, hence is easier to get through as well. Some novels are mainstream (Harry Potter, A song of ice and fire, 1984) and easy, while others are harder to get through (Lord of the Rings, Sherlock Holmes and even Pride and Predujice. These aren't harder per say, but have an older language, same as any works of Shakespeare). Overall to be at this level is to be a consistent reader, and being passionate about reading novels. (Also I think I should mention the Discworld series here as well, just for the sake of it)

Introductions

Here we leave the realm of fiction and enter reality. Books here are generally considered for obtaining useful and often interesting information on various topics/concepts/fields . Books that I have read on this level are Guns, Germs and Steel, Sapiens, Poor Economics, Freakonomics, Deep Work and many more. These seem like a good introduction to a certain field when read for the first time, while being easy to read as well, though one has to be determined enough to get through it all.

Specializations

As the name suggests already, here we have entered the realm of academics. Most frequently read by graduate (pre/post) students and above, material here is generally not touched by the normal populace. Though a majority of students do read such material, it is only when one does it consistently and with enough passion that they can be considered a reader at this level. Ounce a person reaches here, they would hardly ever go back to the ones above. (Even if they do, it'll not be below the Introductory ones). Being a reader at this level is not about reading books/papers in a field as an assignment or in order to gain a degree, but reading them just for the sake of obtaining that knowledge.

Expert

One would usually find authors here, people who research and write often. They are either novelists, researchers or in some cases just passionate readers/writers. Years need to be spend in the level above in order to get to this level of reading. By this time one has read so much, one feels compelled to pour out all the words out into the world. (Not all authors are extremely into reading of course, but I think every "expert" level reader would eventually want to pen down their thoughts). I would love to be at this level someday.

This list is not meant to be accurate or rigorous, but somehow roughly maps my own reading levels through the years. I have put a list of everything I have read here, if anyone is interested.

The Computational Complexity Paradigm of Machine Learning

The bitter truth is by now well known amongst all those who wish to consume the knowledge behind anything Artificial Intelligence/Deep Learning. The lesson was simple: no matter how we structure our algorithms to mimic human capacity, it will always be outperformed by simple scaled architectures with massive amounts of data and parameters.

This lesson is quite reminiscent of the computational paradigm that Stephen Wolfram claimed to have started back in the 1980s, wherein the traditional mathematical thinking was left behind for the sake of exploration of a new way of thinking: from simplicity to complexity, through the power of computation. This would seem quite familiar to a form of Chaos theory, wherein simple initial conditions give rise to complex phenomena.

It was only then that I realised that the scaling law is but another beautiful aspect of computational paradigm, where in simple architectures (say embeddings + transformers) give rise to quite complex phenomena (whatever LLMs are capable of), and thus modern deep learning is a wonderful example for what we can elongate and call computational ML, or computational NLP.

This plays in tandem of the new era of computation that we can explore, where we need not abandon the older mathematical style of thinking, but rather complement it with the compute power it needs in order to show us rather astonishing breakthroughs. Simple linear algebra coupled with optimization algorithms turned out to mimic language quite well, and even learned to perform human-like reasoning. Such breakthroughs urge us to turn our attention to this new computational style of thinking, and explore further.

(In quite a fascinating way, mechanistic interpretability maybe one of this "holes" that Wolfram talks about, where the complex system that is the LLMs may not be computationally irreducible, but can indeed be reduced to it's simpler forms. This could ultimately not be true as well, and we may hit the truth that LLMs maybe computationally irreducible, but current research has been promising).

Finding useful connections from Wolfram's work into this field of ML was quite interesting, and indeed made sense. The mathematical foundations which were all discovered independent of the computational way of thinking turned out to pave the way to really great results when paired with computation and the complexity it brings with it. This also makes me wonder what would Ruliology + ML would look like, wherein we find simple "models" (not to be confused with ML models) which can lead to complex systems down the line (induction heads?).

While we explore more of this computational landscape, various new interesting modes would show up, and I would be just as excited to read (and hopefully contribute) to such paradigms.

Doctrines don't scale

The reason we have intra-species conflict is because doctrines do not scale effectively

Each individual person has, as is common knowledge, a mental model of the world. This mental model, as is given, is flawed. It's almost certain that any one person cannot truly grasp the reasons behind the what, why, and how of our world. These differences in flawed mental models are what primarily cause conflicts, and have been the primary reason since the dawn of Homo sapiens.

One could see this and come to a conclusion: since these mental models lose their malleability as we grow older, it'd be in vain to do anything about changing them, and thus more effort must be put into conflict resolution and cooperation.

Here we come upon another realization (at least I did) that we have been doing conflict resolution and cooperation on an unprecedented scale since the start of the agricultural revolution, in the form of cities, kingdoms, empires, and nations. It was finally religion that eventually captured the most number of people, and today is the main driver behind cooperation across thousands of kilometers.

But for human conflict to be truly gone, we need one single belief, shared by the entire human species. As of this moment, I cannot think of one. (There are people who do not even believe in the Earth being round, so...) Even the most widespread doctrines cannot capture the entirety of the human population, not to mention effectively capture their minds (how many Christians are actually devoted?)

This means that as of now, our primary tool of communication, language (and humans), has yet to come up with a doctrine that can scale to nearly eight billion minds. We do not yet have one nation, one religion, nor one language.

I think the reason is the difference in evolution of the hardware (the anatomy of our body/brain) and the software (our mental models). Our minds developed complicated theories much faster than our primate brains could evolve, hence we still live like the forager bands roaming in the savannah: just that our bands have gotten bigger and intermingled.

In the future, I am optimistic that at least one such belief would spread, leading to a true unification (one could argue that the fear of nuclear weapons is one such thing, but you never know) of the human species.

Unfeeling emotions

One of the things that I've heard most in my life is my lack of emotions, or rather my lack of empathy.

This results in most people viewing me as your average "logical", "rational" or "critical" minded person, wherein every conversation or debate seems like a formal proceeding in a court of law: no emotions, just facts.

Though in fact I had an almost opposite view of of my own self, shocking as that may seem. Overly emotional and unable to control them, going from short-bursts of anger to being over affectionate (puppies ofc) and sometimes, or I would say most of the times, overwhelming people around me.

This may seem contradicting, and any mention of this by me would lead people to think that either of those views of my self is wrong. (Either people are, or I am), and I would disagree

Both of those views are correct. While my internal self and external self may seem conflicting, I would actually put it under the umbrella of having intense emotions and living at the opposite ends of the spectrum, going from seeming overly emotional to seeming completely emotionless.

Is this an advantage ? The obvious answer is that it's impossible to decide which personality traits are advantageous in our modern society, as that would require us to define what having an advantage even looks like, but if it's genuine happiness, I guess I have it :)

Alternatives To Religious doctrine: why to live

• Homo Mathematicus. Going personal with this one, but it could truly be the "language of the gods" or the code that underlies mother nature. From higher dimensional spaces that we reside in, to quantum consciousness explaining our deepest mysteries, we revel in the idea of formalism and creative thinking. The glory of studying math being only bestowed upon the chosen few, we must spend a lifetime trying to find the answers to the mystery of the universe.

• Homo Economicus. The economic rational mind, always logical, always critical. Here we discuss the impact of marxism, socialism and Capitalism. The becoming of a society, the formation of culture. Thinkers and rationalists of this genre have put forth theories that continue to influence the thinking of large fraction of our populace. From financial institutions to the wealth of nations, this doctrine is as fascinating as it is vast.

• Homo Philosophicus. From the western influence to the eastern, this doctrine spans thousands of years and is the mother of all disciplines. A form of thinking itself, nihilism, absurdism, modernism and post modernism are a few areas were countless intellectuals have tried to find answers to the question that is the Human. Modernism and Post-modern would try to amalgamate with modern epistemology to make behavioural models, while other forms reject everything. This doctrine is a rabbit hole of paradoxes and logic, history and well ... philosophy.

---

1. Is God is a mathematician

2. Economics Library

3. PostModernism/Rationality

The Spiritual Mutiny of Intellectual Subsistence

History has been the best story-teller, teacher and guide that humans have encountered. Recording the thoughts, laws and events of the past has been one of the best decisions humans have ever taken.

This leads us down an adventurous path, where we follow the Human across time, finding various reasons to live, while being burdened with knowledge and an excellent prefrontal cortex . We stumble upon mythologies, religions and belief systems spread across lands, the cause of miracles and wars, life and death.

These belief systems are drivers of the human will, an invisible hand forcing the human brain to act a certain way, while directing entire societies, regimes and cultures, and have been doing so since the dawn of time.

Philosophy would be an introduction to the study of belief systems. Though I personally have not delved deep, my personal belief systems have evolved throughout my childhood, and I am currently exploring the vast forest that we call the Internet. Deep within the net, we find some interesting thoughts, while other places, such as youtube, offer some different ones.

My intellectual journey will continue till I die, but I hope to enjoy exploring the depths of thought, language and reality as I go on. That will be by mutiny to the intellectual subsistence of the modern times.

Language Entropy

While on my daily crusade of reading research papers, I found myself being fond of a very particular feature that they have: more information in less amount of words. This made them information dense. I begin to wonder on the complexity of concepts, their measurement and precisely their measurement through the tool we call language. Formalism somehow seems to be tied to these, so let me define a few interesting words, before we continue.

I will discuss some key intuitions below, which come from various concepts spread across computer science and statistics, though the required knowledge is just surface level.

Abstractness: The measure of how far the definition of a word is from a tangible object.

Abstractness of a word can be thought of as the depth at which it appears in a Tree with ∞-children, where each node is a word, and the root nodes are all tangible, real and physical objects (articles, names and other words), and their children are other words derived from them, but with more abstraction. As we climb down the tree, the words grow more abstract, as they are in-turn dependant on less abstract words, all the way to the root, the tangible words. Hence the depth at which these words occur is the "Abstractness" of the word.

Entropy: The measure of randomness, uncertainty and disorder.

Entropy = 1/Abstractness. More abstract words have lesser entropy, which means a sentence with more abstractness contains a lot of information in less amounts of words, and hence are more efficient, a form of compression where the knowledge is not provided by the writer, but is assumed to be known by the reader. Hence sentences, paragraphs or any other piece of text has a total entropy which is the product of all the entropies of each individual words (the reason for a multiplicative model over an additive one is to wipe out the effect of the root words, which have entropy = abstractness = 1).

Understanding: The measure of how much of a new piece of information is known prior to the revelation.

Understanding of a concept, word or any information can be interpreted as the amount of times we have encountered it before. Every time we are exposed to the same piece of information, we understand it a little better (deliberate or non-deliberately), and hence our understanding increases. More abstraction means more levels to climb before we reach the root node (which we have a perfect understanding of since we can directly observe it), and hence more complex the piece of text.

Complexity of any written text is dependant on it's total abstraction or it's entropy. A sentence or paragraph with more root words than abstract ones has more entropy, and so the information is "spread out" among many simpler words. As we compress the words into more abstract ones, the entropy decreases, while the complexity increases. The increase in complexity can be attributed to the fact that we need to go higher up the tree to reach a root node, while the connections between each parent and child node must also be strengthened in order to develop a strong intuition of the piece of text.

This can also be viewed as a simple function that maps a word to a scalar value.

f(word) -> R

R in this case can either be the abstractness or the entropy of that word. Which means the entropy of a sentence of a piece of text is:

Abstractness(Text) = Mult(Sum(f(words of Text))) Entropy = 1/Abstractness(Text)

Now with the advent of word embeddings, we can perform some more interesting operations. Let suppose a word is represented by an N-dimensional vector. Let the vector be called V. We can substitute the above given equation like so:

f(Rⁿ) -> R

Abstractness(M) = Mult(Sum(f(V)))

Entropy = 1/Abstractness(M)

Where M is a bunch of such word vectors put together, hence a matrix. The function simply maps the matrix to a scalar value (entropy or abstractness), which is an indicator of complexity. Here, we cannot ignore the fact that complexity itself is relative, and must factor it in as well. The complexity of a piece of text highly depends on the knowledge base of the person reading the text (A simple sentence in Chinese is extremely difficult for me to understand, as I would have to construct a new language-tree from the root up to even begin understanding it).

Let suppose the knowledge base of a person is represented by the amount of words he/she is familiar with, including the nodes, their children and the weightage assigned to their connection, and call it K. This knowledge base, being made up of nodes as well, has it's own entropy, Entropy(K). This should, logically, be subtracted from our initial overall complexity (the product of all entropies of a piece of text) to get to the final "Complexity" of a sentence.

C = Mult(Sum(f(words of Text))) - Entropy(K)

C = 1/Abstractness(M) - Entropy(K)

This is a mere play of words, a mixture of thoughts and the written expression of the same. Formalism to express realism has always fascinated me, and hence I write this small piece.

High(er) Dimensions

Dimensionality is an important concept in essentially every STEM field, and much more. The concept of dimensions and what they are, where they are useful and ultimately what they represent was multi-faceted and thus I was intrigued enough to write a note/essay or this particular topic.

What are dimensions? In a word: features. A dimension is just a feature or an attribute of another object, be it an inanimate object or a living organism. The dimensions we are most familiar with are the three dimensions of space: length, breadth and height. But wait....aren't there more ? Fourth could be time, and as far as theoretical physicists are concerned, there are a lot more. How can scientists even claim that there are more dimensions when it's impossible for us to even imagine a fourth one ? It's hidden in representations.

We represent our reality through numbers. They are a crude, but sometimes fairly accurate representations of our reality. Equations that scientists have created in a closed laboratory or a classroom have come to predict the movement of stars and other celestial bodies, so yeah, we trust our numbers to model the universe around us. Knowing this, we represent our dimension with a list of numbers, say [1, 2]. But we have three dimensions, so we put three numbers: [1, 2, 3]. These three numbers are fairly good representations of space in various mathematical equations. That is, a certain feature of space is being represented by a vector.

But what's stopping us from putting in more numbers in our vector like so : [1, 2, 3, 4, 5, ... ] ? An obvious answer would be reality itself. There's no point, no physical counterpart to a vector of more than 3 numbers in it (just like the word unicorn has no physical representation in our real world). This was true, until during the pursuit of solving various equations, physicists were forced to expand the dimensions in order to solve (or formulate) the equations. Our theories forced us to go beyond our own senses and come up with more and more "dimensions" or features that represent space itself. (Whether it is true or not is out of my ability to grasp)

The language that we speak was modelled to a great extent my large language models (LLMs) in recent times. Their response not only makes syntactic sense, but also semantic. This worked because we were able to model our language, using a crude approximation, or in other words: vectors. Each word has N dimensions, or in other words, N features which give the LLMs power to use the word in different construction settings, or in more human words: they understand what the word means!

Understanding being analogous to "being able to see multiple attributes of an object" was something I had never thought before. It's only when our mental models construct multi-dimensional vectors of certain concepts or words do we truly understand the said concept or word.

Finding analogies between mathematical concepts and real life is fun and in a way enlightening. Modelling our reality with such approximations means whenever we are right, we are gifted with the greatest reward: understanding ourselves.

Judicial and Political Correctness

In a recent discussion with a friend of mine, I found myself explaining my lack of opinions on political matters and the lack of interest in judicial ones as well. The former has been (and probably will be) criticised as ignorant behaviour and irresponsible . With the general populace yearning to discuss political matters, my disinterest stems from a number of reasons, which I shall mention here.

Any opinion, be it political, personal or moral, is believed to be the absolute truth by the individual. You have opinions because it is your belief that they reflect the objective reality around you. That is the sole reason you even have them: having a mental map (however approximate) helps us navigate through the world and "make sense" of it . But it's almost always the case that our opinions do not reflect the objective reality, in some cases, not at all. Our opinions are the amalgamation of our cultural thinking , personal opinions of people we grew up with and our own personality traits . None of these factors force our opinions to reflect the objective reality, hell, none of these factors even force us to rationally analysis the facts and come to a logical conclusion.

A personality trait of mine is I like objectivity (you could guess where I am going with this). Opinions on any matter aren't mostly objective at all, hence I find no meaning in having them. Whenever we believe in something with all of our heart (and rational brains), we should also have the courage to call them facts. If you are hesitant in calling a certain thing as a fact and more comfortable with the term "opinion", you know somewhere you aren't exactly right . The problem this creates, is that our opinions drive reality: in Judicial matters. Judicial laws are largely made on opinions of the time it was written in, which makes them highly susceptible to change and ridicule by future generations. I would refrain from talking further as this could spiral into a long essay.

Social responsibility isn't having political opinions. It's not that I don't care what's happening in the world by not bothering to read on it, it's that no matter how much I read, I'll never have a grasp on the actual objective reality of the situation and would thus always carry a bias with me. The bias would depend on where I grew up, who I talk to and what my own personality is. And as long as the reality is unknown to me, my opinion will always be wrong (that's a personal belief).

So what should we do ? Not learn anything of the outside world ? Live in our own little bubble ? I think we should acknowledge the facts, agree that no one individual can grasp the entire situation and take action towards betterment of everyone around us.

AI and God-Man

AGI = Artificial General Intelligence
ASI = Artificial Super Intelligence

Learning is the slope of gathering information in a way that can be utilised later (let's call it L). With that being said, the rate of rate of learning is an interesting concept: it's the second derivative of gathering information or how fast can we learn to learn new things (let's call it R). The distribution of L, or what my rate of learning things is, follows a left skewed distribution where our L peaks at childhood/adolescence and starts to deteriorate as we get older. What about R ? I think that's completely upto the individual's effort and willingness to exponentiate their ability to learn things, but most people do not bother to climb down the next derivative .

What if something else did ? What if we build a system that focuses on learning to learn better and faster ? It'll result in exponential growth of everything we know. Knowledge and by extension technology growing at an exponential rate is, in our current state, unfathomable. We'd be left in the dust, scrambling to look ahead while the vehicle zooms past us. That's AGI, on it's way to be ASI. It's not a what if anymore: we are trying to build one, and maybe are getting closer.

A controversial theory for consciousness was written by Julian Jaynes in his Origin of Consciousness, where he suggests that we evolved consciousness only 3000 years ago, which means our ancestors where pretty much unconscious before that time. That claim has deeper implications, and the one I'm focusing on here is: it suggests we humans have evolved our brains, without changing its biological anatomy and it resulted in progress on such a scale. Consciousness was a necessary step in evolution. And of course the most probing question is : can we do it again ? If yes what'll it even look like ?

My initial thoughts were ASI outcompeting and destroying us if we get there, but if ASI was to provide humans with adversities that we've never before seen (for at least 3000 years (?)), is another human evolution possible ? Mark Hamilton argues in his book that such an evolution will happen, and it'll be our last. We will evolve ounce more, to become what he calls a God-Man . This sounds exactly how it is: we become literal gods. I do not know if this theory is even legit, but if I had to guess, our next evolution could be the ability to drastically improve R and to keep doing it throughout our lives (something we expect ASI to do easily) . A human who can do that would be to us what we are to chimpanzees. This same analogy is used to compare an ASI and us. We are the chimpanzees.

So what'll happen ? ASI vs Humans ? That's doomsday for us. ASI vs God Man ? That depends on whether Julian Jaynes theory is even legit, and even if it is, will Mark Hamilton's claim of it happening again is legit and under what conditions.

This may sound very highly speculative and based on unproven theories, but that's the fun part of not knowing the future: trying to imagine it.