Mrunaλ

| 🦁☕️ | Scala, Java | programming | all things backend | BTS V ♥️ | Haawww & Awwwww girl | Won’t F4F | 🤷🏻‍♀️

[Mrunaλ @leoamsbb]

It’s nice to be important but it’s important to be nice!

From 13 steps to bloody good luck 📖

@ashwinsanghi

[Orange Book 🍊📖 @orangebook]

You suddenly get luckier once you became the kind of person who helps others without second thought.

[Javarevisited @javarevisited]

Software Engineering is the only career where interviews are harder than actual Job

[Mrunaλ @leoamsbb]

@SumitM_X 8 🥲

[Mrunaλ @leoamsbb]

@simas_ch They haven't done enough code reviews!

[Arpit Bhayani @arpit_bhayani]

First, the cloud gave us abstractions that made it easier to forget failure. Infrastructure became someone else's problem, and many systems were designed around happy paths with reliability added later ... managed services remain up ...

Now, it is an AI speed-at-all-costs culture that is forcing us to ship code that just works 80% of the time, because it is okay if things fail 20% of the time, but we need to ship faster.

Software was supposed to be predictable. Somewhere along the way, we started treating reliability as a tradeoff, and it is now becoming the norm. I do hope we come back to building software that people can depend on and something we are proud of.

[Arpit Bhayani @arpit_bhayani]

It is good to be lucky, as long as you know it is luck and not skill.

[Arpit Bhayani @arpit_bhayani]

sunday 7 pm is when monday starts. ape sad.

[Simon Martinelli @simas_ch]

A small experiment with Claude Code:
Hotel room search, built twice.

1) Vaadin + Spring Boot + jOOQ + Testcontainers + PostgreSQL: 3 minutes.
2) Angular + Python + DynamoDB: about 5x longer.

Why the gap? One stack is one language, one runtime, and a clear data model. The other is two ecosystems, two languages, and design decisions that need to be made up front.

Choose your tech stack wisely.

[Gunnar Morling 🌍 @gunnarmorling]

A fool with an LLM is still a fool.

[Mrunaλ @leoamsbb]

@sivalabs I knowwwww, I feel very proud! 🎉 🙇‍♀️

[Mrunaλ @leoamsbb]

From Twitter to Local Dev!
@sivalabs 🥂

[Jakub Kozłowski @kubukoz]

When someone I don't know is better at something they've been doing all their life, than me who's been doing it for a few weeks

[Arpit Bhayani @arpit_bhayani]

Code is not cheap and never was. You either pay to write it well, or pay when it breaks.

[Gwen (Chen) Shapira @gwenshap]

To err is agentic.

[Mrunaλ @leoamsbb]

@Sharat_Chander Wish you the best Sharat!

[Mrunaλ @leoamsbb]

@arpit_bhayani OMG Wow!
Congratulations and wish you the best 🤩

[Arpit Bhayani @arpit_bhayani]

"Do fundamentals still matter?" The moral high ground says - they do, and I agree. But the motivation loop that made people great at fundamentals is broken.

Fundamentals were rewarding because we immediately applied them to solve problems better and, more importantly, gave us an edge over others. Say we write a wire protocol - then concepts like endianness come in handy when we serialize the data and solve our problem. That tight feedback loop is what drove curiosity.

But with AI handling the implementation, we skip from "I have a problem" straight to "it's solved," without the middle step where understanding actually forms. We can still force ourselves to study the output afterward, but reviewing someone else's (AI) solution is very different from building it ourselves.

Honestly, some fundamentals will be valuable to understand conceptually, but rarely practiced. Others will become even more critical because they are what you need to evaluate AI output and catch what it gets wrong.

The hard part is that we are living through the transition. Nobody knows which fundamentals will fade and which will become indispensable.

But until that becomes clear, I would still bet on building strong fundamental muscles for problem-solving.

[Simon Martinelli @simas_ch]

@bidhanxcode I’m not looking for a job at one of those companies

[Mrunaλ @leoamsbb]

I wish more and more people are this thoughtful in smallest of the stuff!

[Arpit Bhayani @arpit_bhayani]

Let me talk about something obvious but with a bit of quantification...

Theoretically, both arrays and linked lists take O(n) time to traverse, but here's what actually happens when you benchmark by summing 100k integers

- Array: 68,312 ns
- Linked List: 181,567 ns

Summing an array is ~3x faster than LinkedList. Same algorithm, same complexity, but wildly different performance.

The reason is cache behavior. When you access array[0], the CPU fetches an entire cache line (64 bytes), which includes array[0] through array[15]. The next 15 accesses are essentially free. Arrays hit the cache about 94% of the time.

Linked lists suffer from pointer chasing. Each node is allocated separately by malloc(), scattered randomly in memory. Each access likely requires a new cache line fetch, resulting in a 70% cache miss rate.

This is a good example of why Big O notation tells only part of the story. Spatial locality and cache-friendliness can make a 2-3x difference even when the theoretical complexity is identical.

I am sure you would have known this, but this crude benchmark quantifies just how fast cache-friendly algorithms can be.

Hope this helps.

[Mrunaλ @leoamsbb]

And they say developers are not creative 🫣

[Voytek Pituła 💙/💛/🖤 @Krever01]

We were trying to program in XML, then json, then yaml. Now we try with markdown.

[Mrunaλ @leoamsbb]

@sesigl @SumitM_X One of my colleague once said they don’t exist in Java! 😅