Abhishek G’s Post

When two systems communicate over the internet, they often use different programming languages. For example: Frontend → JavaScript Backend → Python / Go / Rust / Java But these languages all have different data structures and types. So how do they actually understand each other? The answer is serialization and deserialization. In this article, I explain this concept from first principles: • How clients and servers exchange data • Why systems need a common format • What serialization and deserialization actually mean • Why JSON became the standard format for APIs • Where serialization fits in the network communication flow If you're learning backend engineering or system design, this is one of those foundational concepts that makes many other things easier to understand. 📖 Read the article: Serialization & Deserialization https://lnkd.in/g4GXncHj I’m also documenting my learning journey in these playlists: Backend Engineering from First Principles https://lnkd.in/g7MJ6TnP System Design from First Principles (HLD + LLD) https://lnkd.in/gateH6Jz #BackendEngineering #SystemDesign #APIDesign #SoftwareEngineering #WebDevelopment

The biggest proof of your growth as an engineer is realizing your old code is an unreadable mess. When I first started writing C++ and Python, I thought the goal was to write the cleverest, most complex logic possible. Nested loops, obscure patterns, unreadable one-liners. Now, working entirely in React Native and managing a monorepo with strict CI/CD pipelines, my definition of "good code" has completely flipped. Good code is boring. Good code is readable at 2 AM when a deployment fails. Your priority as an engineer is not to show off how smart you are to the compiler. Your priority is to make sure the next developer in the codebase can actually understand what is happening without wanting to quit. Optimize for readability. Let the compiler handle the rest. What is a "clever" coding habit you had to unlearn as you got more experienced? #SoftwareEngineering #Programming #Developer

💡 Ever wondered how different programming languages actually work under the hood? This visual breaks down a fundamental concept every developer should understand — the journey from source code to execution. 🔹 C / C++ (Compiled Languages) Your code is directly compiled into machine code. ➡️ Fast execution ➡️ Close to hardware ➡️ Less abstraction, more control 🔹 Java (Hybrid Approach) Code is compiled into bytecode, then executed on a Virtual Machine (JVM). ➡️ Platform-independent ("Write Once, Run Anywhere") ➡️ Uses JIT (Just-In-Time) compilation for performance ➡️ Balance between speed and portability 🔹 Python / JavaScript / Ruby (Interpreted Languages) Code is executed line-by-line by an interpreter. ➡️ Faster development ➡️ More flexibility ➡️ Slightly slower execution compared to compiled languages 📊 Key Insight: Every language ultimately communicates with the system in machine code, but the path it takes defines its performance, portability, and use cases. 🚀 Whether you're building systems software, enterprise apps, or quick prototypes — understanding this flow helps you choose the right tool for the job. 💬 What’s your go-to language and why? Let’s discuss 👇 #Programming #SoftwareDevelopment #Coding #Java #Python #CPP #ComputerScience #Developers #TechLearning #CareerGrowth

🚀 I’m sharing a presentation I created about Object-Oriented Programming (OOP) This material was used in a professional setting and covers key concepts such as: ✔️ Abstraction ✔️ Encapsulation ✔️ Inheritance ✔️ Polymorphism I believe mastering these pillars is essential to writing scalable and maintainable code. 💻 Technologies: JavaScript / Object-Oriented Programming I’d love to hear your feedback! #programming #oop #webdevelopment #javascript #backend #frontend

🧠 One If-Else Question That Exposes Your Logic Skills Looks simple… but most developers get it wrong. Can you predict the output without running it? 👀 Test your fundamentals — because logic > syntax. #JavaScript #Angular #Programming #CodingChallenge #Developers #LogicBuilding #100DaysOfCode

Most developers are not slowed down by bad code. They are slowed down by bad thinking. Not syntax. Not framework choice. Not whether the project uses Java, Go, or Python. The real damage usually comes earlier: - no clear boundaries - too many dependencies in one request path - retries added without thinking - APIs designed around convenience instead of failure - teams optimizing for feature speed over system clarity That’s why some codebases feel heavy even before they get big. The problem is not always technical debt. Sometimes it’s decision debt. And that is much harder to fix. Debate: What does more long-term damage to software teams? A) bad code B) bad architecture C) bad product decisions D) bad debugging habits My vote: B first, C second. What’s yours? #Java #SoftwareArchitecture #Microservices #DistributedSystems #BackendEngineering

Python Async vs Threading (Truth) ⚡ Async or Threading… which one is better? 🤔 Most developers are confused here ❌ Content: Let’s break it simply 👇 ⚡ Threading → Multiple threads run at the same time → Good for I/O tasks (API calls, file read) → But limited by GIL in Python ⚡ Async (async/await) → Runs tasks without blocking → Best for high-concurrency apps → Used in FastAPI, modern backends 🚀 Simple difference: 👉 Threading = Multiple workers 👉 Async = One smart worker handling many tasks What beginners do: ❌ Use threading everywhere ❌ Don’t understand blocking What smart devs do: ✅ Use async for APIs ✅ Use threading for simple tasks ✅ Choose based on problem Why this matters: Right approach = better performance 💯 Reality: There is no “best”… Only what fits your use case Pro Tip: If you're building APIs → learn async first 🚀 CTA: Follow me for real backend knowledge 🚀 Save this post for revision 💾 Comment "ASYNC" or "THREAD" 👇 #Python #Async #Threading #Backend #Programming #Developer #FastAPI #Coding #SoftwareEngineer #Tech

I spent a few weeks migrating 5 microservices from C# + gRPC to F# + gRPC. Personal project, no deadlines, no pressure.... only fun!! I have a background in functional programming. But I had not touched anything in that paradigm for years. Day-to-day Python, C/C++, C# is imperative by default, and that default goes deep. The good part first: some things in F# are genuinely simpler. Discriminated unions for domain modeling, function composition with |>, pattern matching that covers every case and the compiler holds you accountable. Things that exist in C# too, but cost more code to express. The beginning was harder than I expected, precisely because of that background.... I knew what a pure function was. I knew what immutability meant. The problem is that knowing something conceptually does not mean your brain will reach for it first when a problem shows up. Years of writing loops and mutations build a reflex. My first instinct was still: create a variable, iterate, mutate. In F#, that path exists, but you are swimming against the current. The language pushes you to think about what the function receives, what it returns, how to compose that with the next step. It took me a while to stop mentally translating C# into F# and start formulating the problem in F# directly. Another real point: the compiler is strict, which is good, but error messages can be cryptic when you are still reactivating that way of thinking. You know something is wrong, but the message does not always point directly at it. In the end, it worked. The services are running, gRPC integrated without major surprises, and the code got leaner in several places. The most useful thing I learned was not technical. It was realizing that knowledge rusts when left untouched, and that years on the imperative autopilot leave a deeper mark than it seems. And on that note: AI is making this worse. Every time you let it write the code, debug the problem, or think through the design for you, you are not just saving time. You are letting your own knowledge rust a little more. It does not matter if it is functional programming, system design, algorithms, or anything else in tech. The muscle atrophies when it stops being used. #fsharp #dotnet #grpc #functionalprogramming

𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗶𝗻𝗴 𝗞𝗮𝗶𝗿𝗼! About a year and a half ago, my friends and I started building a programming language. We'd been writing systems-level code across C++, Rust, and lower-level tooling for long enough to have strong opinions about what was missing. C++ gives you performance and the richest library ecosystem in systems programming, but the language fights you at every turn undefined behavior, header hell, decades of accumulated complexity. Rust solves the safety problem but introduces real cognitive overhead and a syntax that trades readability for compiler appeasement. We wanted something that didn't force that tradeoff. So we built Kairo a statically typed systems programming language with bidirectional C++ interoperability, readability-first syntax, and a memory safety model that gives you both manual and automatic memory tracking without fighting a borrow checker. 𝗪𝗵𝗲𝗿𝗲 𝘄𝗲 𝗮𝗿𝗲 𝗻𝗼𝘄 The project has come a long way. We shipped a Stage 0 bootstrap compiler, then used it to build a Stage 1 self-hosted compiler; Kairo is being written in Kairo itself! The language, toolchain, and ecosystem are actively under development and roughly halfway to a production release. 𝗪𝗵𝗮𝘁 𝗺𝗮𝗸𝗲𝘀 𝗞𝗮𝗶𝗿𝗼 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 - Bidirectional C++ FFI call C++ from Kairo and Kairo from C++, no bindings layer required. - Readability-first design. Code should be readable by default, not after three months of pattern memorization. - BCIR/AMT memory safety model manual and automatic memory tracking with safety guarantees, without Rust's borrow checker annoyance. - Planned interop expansion to Python and Rust. - Full access to the existing C++ library ecosystem from day one. 𝗖𝗼𝗻𝘁𝗿𝗶𝗯𝘂𝘁𝗼𝗿𝘀 :Arnav Goyal , Dhruvan Kartik and Me 𝗟𝗶𝗻𝗸𝘀 - Website: https://www.kairolang.org - Github: https://lnkd.in/gZEdW2Gi We're a three-person team and the project has 360+ GitHub stars. If this interests you, a star, an issue report, or a contribution all help. #CompilerDev #Compiler #tech #buildinpublic #SystemsEngineering

“If you learn Assembly language before you start coding, you’re already ahead…” But wait—have you ever been deep inside a messy PHP or Java codebase and suddenly felt like writing: 👉 goto ... Yeah… same here. That moment says a lot. Learning low-level programming (like Assembly) gives you a strong mental model of how code actually flows: • You think in jumps, conditions, and execution paths • You understand what the machine is really doing • You become very aware of control flow So when you move to high-level languages like PHP or Java, something interesting happens… You start noticing when the structure breaks down. That urge to use goto usually appears when: • The logic is too tangled • There are too many nested conditions • The code lacks clear structure or abstraction In other words—it’s not that you should use goto… It’s that your brain is detecting bad design. 💡 Assembly doesn’t teach you to write messy code— it teaches you to recognize it. Instead of reaching for goto, you start asking: • Can this be refactored into smaller functions? • Should this be a state machine? • Is there a cleaner control flow? That’s the real advantage. Low-level knowledge doesn’t make you write lower-level code—it makes you write better high-level code. So next time you feel like typing goto… Pause. That’s your signal—not to jump—but to redesign. #Programming #SoftwareEngineering #CleanCode #Assembly #Java #PHP #DevThoughts #solobea.com