the lingual odyssey: learning 25 programming languages in 25 days a journey through 25 programming languages in 25 days, exploring paradigms from imperative to functional, and the lessons learned along the way. programming languages functional programming learning software development advent of code programming languages polyglot programming functional programming advent of code learning programming ocaml assembly language paradigms > _the limit of my language means the limit of my world._ in reality, we often convey our thoughts through languages. each language has its own nuances, character set, grammar, and unique expression. but at the end of the day, all these languages share a singular purpose: to provide a means of communicating our thoughts and navigating the complexities of a system we call society. to provide us with a way to convey our thoughts, and to solve a very complex problem we call communication, in a very complex system we call society. computers aren't very different in that regard. though there might be a variety of programming languages out there, at the heart of it, they are all aimed at solving problems. they could be: - processualis (procedural) - कार्यात्मक (functional) - பொருள் நோக்கிய (object oriented)
but, at the end of the day, i'm pretty sure you could do `1 + 1` in all of them. or, better yet, write a multi-user concurrent transaction handling system. then, why are people chasing new languages (like **rust**) and talking about how javascript is "the next best thing since sliced bread"? but on a serious note, the real advantage of learning new languages isn't just to solve these real-world problems, but to gain a different perspective to think, a different understanding of the moving parts involved, and finally, an innate appreciation towards the problems themselves. "everything you write will eventually turn to 0s and 1s"; that's true, but the way you express it will not just run on your computers, but also on the minds of the people who see it. i set out on a journey, an adventure: [the adventure of code](https://adventofcode.com/). but i didn't want it to be like all the general coding challenges out there. so, to spice things up, i planned on using different languages per problem, and to top that i set a self-imposed condition that i will only use the languages that i don't already know!
> _talk is cheap. show me the code._ here you go [github:advent-of-code-2023](https://github.com/nishantjoshi00/advent-of-code-2023)!
the first thought on my mind as any programmer would have had was, "i want to code **assembly**!", and so i did!
## imperative programming how bad can it be to try and solve a complete problem in what i would call a purely imperative language? and believe me, it was hard. after finding a handful of instructions that would help me solve the problem and 4 hours of head-scratching and giving up a couple of times, i was finally able to solve the first part of the problem. but guess what? there was a second part to the problem that required me to do a string lookup. my frustrated soul couldn't handle implementing a hashmap for this, so i did the most imperative thing possible, and though ugly, it worked. ```asm check_numbers: call check_0 call check_1 call check_2 call check_3 call check_4 call check_5 call check_6 call check_7 call check_8 call check_9 ret ```
> _rule #1: good code is code that works._
by the time i had completed admiring the horrific beauty of my code, the next imperative language was **cobol**. i thought cobol would be easy, and looking back, it probably was. the whole code looked more or less like an essay, and of all the languages that i used, this had the most english in it. my guess is, it was used for documentation or offloading work to interns.
> _rule #2: a good code should be easier to read, regardless of the technical background._
while traveling the imperative path, there were a few languages that threw me for a loop (literally in zig's case). one of them was **zig**. maybe it was just me, but working with a language where any allocation had to be hand-wrung from an allocator object felt like walking a memory tightrope. and the worst of it all? i couldn't even build a bridge of coupled recursion with two fallible functions – zig wouldn't let me! this was completely unexpected, like facing a "no recursion allowed" sign after years of coding freedom. no other language had ever tried to clip my recursion wings – except maybe rust, but that's a story for another day. the second language that really threw me off was **r**. i've never been more frustrated than when wrestling with r's array constructions and concatenation. maybe it's just me, but the way everything fit together felt like trying to solve a rubik's cube blindfolded – it was frustrating...
> _rule #3: variable names are very important; we don't accept either `c` or `performarrayconcatwithvaryingdims`, both are equally bad._
there were a lot of good programming languages along the way: **lua** and **ruby** with their simplicity and relatability to preconceived notions of programming languages; fortran and go with their inherently supported concurrency and robust design; and the free-flowing syntax and maturity of python and julia. and then there was coffeescript... me trying to curse it would be an insult to the curse words themselves.
> _rule #4: the freedom of telling the computer exactly what to do, has its downsides. (it's like teaching a child, how to bake a cake). there are 3 outcomes (we get the cake, the house explodes, the child dies)_
as my imperative path reached its end, a new challenge awaited—it was finally time to cross the mountains of...
## object-oriented programming java was out of the question, that much was certain. i wanted to start pure. but was i truly ready? the challenge loomed before me, a daunting prospect for any introvert—**smalltalk**. or at least, so i thought until i realized it was just a programming language. a purely object-oriented programming language, to be precise. during my research, the concept of a language composed entirely of objects boggled my mind. then, as i delved into the programming itself, confusion mingled with intrigue as i grappled with the unorthodox dataflow (this sentence literally represents my thoughts from back then). yet, i was somehow excited. this was unlike anything i'd encountered before. imagine a language where even conditional statements operate through messages passed between objects like corrupt politicians slipping bribes under the table to get things done.
> _rule #5: having functions doesn't mean everything has to be functional._
as i scaled the steep mountains of object-oriented programming, i stumbled upon something i'd always dismissed as extremely ancient, weird, and unlikely to cross my path: **php**! i'd always envisioned php as a relic from the past, a realm of difficulty, gooiness, and utter chaos. but reality proved vastly different. the first php code i ever wrote turned out to be remarkably clear, concise, and fully embraced the power of oop. it was an experience worth remembering, a testament to the age-old wisdom of "not judging a book by its cover." it might also be the preconceived notion that php has a bad language design and will always stay that way. moreover, it also felt that the language has evolved to be more robust and easy to adapt to. to put it simply, i didn't feel like i was learning a new language, but just using the built-up experience.
> _rule #6: let's try to package data, with all the constituent information contained within them._
i'd planned to write some java, but i knew the next best thing—and the final object-oriented obstacle—scala. and for all the people out there screaming that it's a functional programming language, i have news for you: the first word i wrote when i started coding wasn't fn, fun, or def. it was object! scala presented an interesting language transition. with my experience in rust, java, and python at work, i thought it would be a cinch. but i'm not exactly proud of the code i produced. still, compared to a few other languages where i'd had to implement preliminary functionality, scala felt quite comfortable.
> _rule #7: awry commented code is worse than bad code. (it's similar to gossip, it poisons the mind of both the writer and the reader)._
here we are, folks—the final path in this grand journey. it's time to dive into the river of...
## functional programming and what better way to start than pure? it's time to pull out the big guns: **haskell**. i'd envisioned writing my dream functional code, but dreams are just dreams. i ended up with a dijkstra algorithm sporting some of the ugliest functions i've ever crafted in any functional language. it was more like functional vomit. but hey, that vomit functions.
> _rule #8: let's face it, "with great power comes great responsibility"._
but to a larger extent, these languages were very well-built, and i was finally getting some much-needed help from my editor. in nearly all of the previous languages, either there wasn't an lsp or it was quite time-consuming to set one up. in this challenge, out of all the functional programming languages i used, i found **ocaml** to be truly exceptional at fulfilling its purpose. - [x] being functional - [x] solve my problems - [x] maximize reusability
and before you start saying every language is reusable, sure, "if you can read assembly, everything is open source," but who has time for that? i crave languages that embrace reusability from the start. ocaml delivered in a big way. don't believe me? witness the magic...

was able to solve day-9 part-2 of advent of code with just one-line change to part-1. (in ocaml)

functional programming definitely has its perks!!

if you are curious you can check the code out here.https://t.co/4itedcrs7q #ocaml #functional #programming pic.twitter.com/dlkagpd6gn
— nishant (@nishantjosh) december 17, 2023

> _rule #9: code should improve re-usability and facilitate easy refactoring for future code modifications._
after wrestling with both **erlang** and ocaml, **elixir** felt like their love child, inheriting function definitions from erlang and operators from ocaml. my journey stretched across countless languages, but these were some of the most captivating detours. while this is just a sliver of the learning i gleaned, it was worth every hurdle and relentless duckduckgo-ing session. in the end, the true hero of this odyssey wasn't the procedural forest, the object-oriented mountains, or the functional river, but markdown! it's the narrator, unlike the nanosecond warriors – markdown's the language this very blog breathes in. > _rule #10: no code, is good code._
this was the journey, or at least a glimpse of it, littered with countless obstacles and daunting challenges. yet, at the end, the sweetness of satisfaction and the fruit of unwavering determination were beyond compare. the real challenge wasn't solving all those problems; but rather, being consistent and not giving up on the principles that i set for myself. (well! i did solve the last problem in python, but in my defense, finding eigenvectors for laplacian matrix would've been hella difficult in **brainfuck**.)
if you are interested in scrutinizing my code, or wish to talk smack about it. feel free to check it out here: - [nishantjoshi00/advent-of-code](https://github.com/nishantjoshi00/advent-of-code-2023) if you feel like following me or sharing your own ideas around the advent of code, here are some of my social media handles: - github.com/[@nishantjoshi00](https://github.com/nishantjoshi00) - x.com/[@nishantjosh](https://twitter.com/nishantjosh) if you have reached this far, it was valiant enough just to read through this whole mess. but remember what kakashi said, "in society, those who don't have many abilities tend to complain more."