Nikesh Chithambaram

𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵 𝗶𝘀𝗻’𝘁 𝗮𝗯𝗼𝘂𝘁 𝗮𝗿𝗿𝗮𝘆𝘀.𝗜𝘁’𝘀 𝗮𝗯𝗼𝘂𝘁 𝗰𝘂𝘁𝘁𝗶𝗻𝗴 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝘀𝗽𝗮𝗰𝗲. ⠀ Most engineers learn binary search as: “Find target in sorted array.” Cool. Then they forget it exists outside DSA interviews 🚨 Years later, they brute-force performance bugs, capacity limits, timeout configs… When they could’ve just binary searched the answer ⚙️ ⠀ 𝗖𝗼𝗿𝗲 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 Binary search is a thinking pattern 💡 Not an algorithm. If the answer lies in a monotonic space (low → high, false → true, fail → pass) You can divide it. ⠀ 𝗧𝗵𝗲 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 👉 Identify a search space (time, capacity, threshold, index) 👉 Prove monotonicity (once true, always true OR once fail, always fail) 👉 Shrink with mid = low + (high-low)/2 👉 Eliminate half the possibilities each iteration That’s it 🧠 ⠀ 𝗪𝗵𝗲𝗿𝗲 𝗦𝗲𝗻𝗶𝗼𝗿𝘀 𝗨𝘀𝗲 𝗜𝘁 ✅ Finding max QPS before system breaks ✅ Tuning JVM heap for optimal latency ✅ Detecting first bad deploy in CI/CD ✅ Finding minimal timeout that avoids retries ✅ Capacity planning under load This is systems thinking. Not LeetCode thinking 🔥 ⠀ 𝗦𝗲𝗻𝗶𝗼𝗿 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 Whenever you're guessing… Stop. Ask: “Is this problem monotonic?” If yes — you don’t need intuition. You need binary search 📉 ⠀ Next time you hit a scaling wall… Will you brute force it? Or cut the problem space in half?

3

The End of the Coder, The Birth of the Architect: CSE in 2030 ​The "software engineer" of the 2010s is becoming a relic. By 2030, the job description for Computer Science Engineering (CSE) won't just be about writing code—it will be about orchestrating intelligence. ​If you are still focusing solely on syntax, you are preparing for a world that is already disappearing. Here is the 2030 roadmap for the industry: ​1. From Implementation to Orchestration ​By 2030, manual coding will be 90% automated. AI agents won't just suggest snippets; they will manage entire repositories. ​The Shift: Your value moves from "How to code" to "What to build." * New Role: You become a System Architect, defining the constraints and logic while AI handles the boilerplate. ​2. The Rise of "Physical AI" and Edge Computing ​The cloud is no longer the final frontier. We are moving toward Edge Intelligence—processing data directly on billions of smart devices. ​The Skill: Mastery of hardware-software co-design. ​The Impact: CSE will merge with robotics and IoT, requiring engineers to build low-latency, power-efficient systems that interact with the physical world. 3. The Quantum-Classical Hybrid We are entering the "Quantum Utility" era. You won't need a quantum computer on your desk, but you will need to write Hybrid Algorithms. Standard logic will stay on CPUs, but complex optimizations (cryptography, logistics, AI training) will be offloaded to Quantum Processing Units (QPUs) via the cloud. 4. Security as a Self-Healing Layer Cybersecurity is shifting from reactive to preemptive. DevSecOps 2.0: AI agents will "Red Team" code 24/7, finding and patching vulnerabilities before they reach production. The Role: Engineers will act as Ethics and Security Auditors, ensuring autonomous systems remain unbiased and unhackable. 5. The "T-Shaped" Engineer The 2030 winner isn't just a tech expert. They are cross-disciplinary. The most successful engineers will combine CS with Biology, Finance, or Green Energy. Soft skills are the new hard skills: Creativity, leadership, and ethical judgment are the only things AI cannot replicate. The Bottom Line 2030 isn't about the "death" of the engineer—it's about the evolution of the engineer. We are moving away from the grind of syntax and toward the art of high-level creation. Are you building the skills to be an Architect, or are you still just a Coder? #ComputerScience #SoftwareEngineering #AI #FutureOfTech #2030Trends #TechLeadership

6

We released 𝘅𝗥𝗼𝘂𝘁𝗲𝗿-𝟳𝗕 by Salesforce AI Research & UIUC. The router keeps optimal LLM performance while reducing inference cost 𝗯𝘆 𝘂𝗽 𝘁𝗼 𝟴𝟬%! 🔍 𝗪𝗵𝗮𝘁’𝘀 𝗻𝗲𝘄?  1. 𝗖𝗼𝘀𝘁-𝗔𝘄𝗮𝗿𝗲 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻: RL-trained model routing policies minimize costs while maintaining quality  2. 𝗔𝗱𝗮𝗽𝘁𝗶𝘃𝗲 𝗥𝗼𝘂𝘁𝗶𝗻𝗴: Dynamic model selection based on query complexity - routes simple queries to budget models, complex ones to premium models  3. 𝗧𝗼𝗼𝗹-𝗖𝗮𝗹𝗹𝗶𝗻𝗴 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: Learns to effectively invoke 20+ models (GPT-5, o3/o4, DeepSeek R1, Qwen3, Kimi K2, etc.) and select best responses  4. 𝗠𝘂𝗹𝘁𝗶-𝗠𝗼𝗱𝗲𝗹 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻: Coordinates responses from multiple LLMs for complex reasoning tasks  5. 𝗟𝗲𝗮𝗿𝗻𝗲𝗱 𝗣𝗿𝗼𝗺𝗽𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴: Automatically generates optimized system prompts for target models 📦 𝗧𝗿𝘆 𝗶𝘁 𝗼𝘂𝘁 If you’re building systems with multi-model pools (or thinking about cost vs performance trade-offs) this is worth experimenting in your system.  • 𝗛𝘂𝗴𝗴𝗶𝗻𝗴 𝗙𝗮𝗰𝗲 🤗 – 𝗦𝗮𝗹𝗲𝘀𝗳𝗼𝗿𝗰𝗲/𝘅𝗥𝗼𝘂𝘁𝗲𝗿: https://lnkd.in/gZS9Amz6  • 𝗚𝗶𝘁𝗵𝘂𝗯 🤖: https://lnkd.in/gbTujUTK Any questions, let us know 🥰

96

7 Comments

If my google/GPT history got leaked my SWE Title would be questioned immediately “Why this is not working please make it work” “How to exit vim” “Best model for error free coding” “Difference between rebase and merge” “Act like you are explaining this code to 5 year old…….” Sometimes it feels embarrassing looking at my own search history like I should already know this. But those “basic” questions are exactly why I’ve grown and built a strong foundation for myself.Development isn’t about memorizing everything; it’s about navigating through bugs/confusion quickly and it gets better gradually. Over time eventually you search less, remember more, and build real confidence but it all starts with being okay not knowing. What’s the most basic things you’ve searched recently ? #coding #swe #humour #development #software #technology #projects #ai

20

4 Comments

In this Spring break, I built a Scalable Ticket Booking System using Microservices Architecture. I have used Spring Boot, focusing on real-world backend architecture patterns like event-driven communication, caching, and observability. Domain: Inventory Management (Distributed Systems) Tech Stack: Java, Spring Boot, Spring Cloud Gateway, Kafka, Redis, MySQL, Keycloak, Resilience4j, Docker, Actuator, Swagger Key Features • Event-Driven Architecture (Kafka) Booking Service publishes events → Order Service consumes them → Inventory updates asynchronously • Circuit Breaker (Resilience4j) Implemented at the API Gateway to handle downstream failures and return fallback responses • Redis Caching Used in Inventory Service to reduce database load and improve read performance • Authentication & Security (Keycloak) OAuth2/JWT-based authentication with role-based access control • Monitoring (Actuator) Exposed endpoints like /actuator/health and /metrics for runtime observability • API Documentation (Swagger UI) Interactive API documentation for testing endpoints • Containerization (Docker) All services and dependencies are containerized for easy setup and consistency • Designed a normalized database schema (3NF) with clear entity relationships GitHub Repository: https://lnkd.in/ezsqp2Mq #Java #SpringBoot #Microservices #Kafka #Redis #Docker #SystemDesign #BackendDevelopment #APIGateway #SDE #SoftwareDeveloper #NewGrad #JavaDeveloper #DistributedSystems

61

5 Comments

How can we implement singleton for multiple classes in a simple way? - CRTP (Curiously Recurring Template Pattern) which is an idiom in C++. A template based class inheritance. - By using base class as template for creating singleton, we can use several creation of singleton. Example: - Created a base class template BaseSingleton for creating singleton for various class types. - Logger class has inherited by BaseSingleton<Logger>. - The Instance for the Logger is created inside the base class. In order to access the private constructor and destructor of Logger from base class, make class BaseSingleton<Logger> as friend to Logger. - By Inheriting base class BaseSingleton, we can create several classes as singleton. #Cplusplus #DesignPatterns #SingletonPattern #CRTP #Learning

24

3 Comments

After you've read about system design,* how can you get hands-on *practice* building large-scale distributed systems? Learning programming is pretty easy to do on your own, with almost no resources—just get access to any ol' computer. So how can a beginner get experience with, say, CDN bottlenecks or active-passive failover? *As in this wonderful collection of links to info about system design topics by Tannika Majumder: https://lnkd.in/gpdSbQv8. #SystemDesign

3

Model Context Protocols (MCPs) are the microservices of the AI era. Like microservices broke apps into modular, API-driven units, MCPs standardize how AI agents discover, call, and combine external tools using semantic intent—not just syntax. Why MCPs Matter: Modularity: Orchestrate AI workflows with specialized "AI microservices." Interoperability: Standardize LLM-service integration, cutting manual work. Scalability: Break monolithic models into efficient, trainable modules. MCPs unlock value for AI hosts and specialized domains but may disrupt manual integration businesses. Ready to swap microservices for MCPs? Let’s talk! 🚀 #AI #MCPs #Microservices #GenAI

13

2 Comments

You become a good software engineer by writing enough code (with feedback) during your college days. In fact, just like a pilot is measured by their flying hours (how many hours they have spent in the air), a software engineer should track their coding hours. (Of course, 'coding hours' is a proxy and includes all the focused work required to get the code done successfully, design, reading to learn more, talking to customers, etc.) What kind of code? I believe there are 4 levels of code-writing that students do in their four years of undergraduate CS education (BTech, BCA, or BSc.): * Level 1: Code to learn programs syntax and semantics: conditional, loop, class, APIs, etc. The goal is to master the syntax and semantics of programming constructs * Level 2: Code to learn algorithm implementation: sorting, searching, graph traversals, dynamic programming, all the way to task scheduling (OS), consensus algorithms (Distributed), etc. Goal is to be able to implement an algorithm represented in some form into code that works. * Level 3: Code to learn system building: CRUD app, library management system, chat app, face detection system, twitter feed analysis, etc. Goal is to build a system that does some well-known function and has known requirements. * Level 4: Code to learn creating value for users: solve apartment complex's sprawling book donations, large button dialer for your grandparents, app to sell artwork for your cousin, etc. The goal is to start from a customer need and then build a system iteratively that addresses their need (and hopefully delights them too!) - working end to end, playing multiple roles, and delivering value and not code. I feel a fresh graduate should have 1000-2000 coding hours. But my guess is that for a lot of graduating students, this is barely three digits. They also need to have good distribution of hours across levels. Hours spent in coding at Level 4 are significantly more important for their future success for most industry roles compared to Levels 1, 2 and 3, since that has the most learning impact. Level 3 is good too (and much more significant than Levels 1 and 2), but given the age of AI agents and automation, Level 3 hours may have considerably less learning impact. I think the following ratio works well for a product-minded student: L1: 15% L2: 25% L3: 25% L4: 35% Move some hours from L4 to L3 if you are less product-minded, and move L4+L3 hours to L1+L2 if you are less development-oriented (you should still know your programming and algorithms). My experience is that most of the graduates have very few hours at Level 4 and it is concerning. If you are a student in your second year or later, consider picking a Level 4 problem today and plan to work on it this semester iteratively and make your customer happy.

12

2 Comments

I’ve sat in interviews at 3 MAANGM companies (Google, Microsoft, Amazon) …and here are 3 things you NEED to know before your next interview 👇 (Esp. if you’re preparing for mid-to-senior-level SDE roles at top PBCs, here’s what I’ve learned along the way ✅) 💡 TIP #1: Give Data Structures & Algorithms (DSA) fundamentals PRIORITY. → Most tech giants, esp. Google, expect you to be strong in Arrays, Strings, Trees, Graphs, and DP. → Don’t just solve random problems. Instead, focus on mastering core patterns, Sliding Window, Binary Search, DFS/BFS, Trie, DP state transitions. 💡 TIP #2: Don’t think Behavioral Rounds are “OPTIONAL” At PBCs like Amazon, your real contributions and leadership will matter. So always quantify your impact → “Led a team of 4 engineers to reduce API latency by 30%” is far better than “Worked on APIs”. 💡 TIP #3: System Design will become UNAVOIDABLE (even mid-level) Interviewers will expect you to design scalable, reliable systems, and explain tradeoffs clearly, especially at Microsoft. Practice structuring your thought process ⬇️ → Start with requirements → High-level architecture → Data modeling → API contracts → Scalability challenges. These actionable tips can help you switch to MAANG-level PBCs, so if you’re working a 9-5 and struggling to prep for your next big role… I highly recommend giving Bosscoder Academy a try. 🔗 Explore their programs here: https://bit.ly/4gq7uIp They’ve already helped 2,200+ engineers land roles in top PBCs with structured prep in DSA, System Design, and Full Stack, 1:1 mentorship, mock interviews, resume support, and 100% job switch guidance. #sdeprep #systemdesign #interviewtips #tech #jobswitch #maang #pbcs #collab #interviews #jobs #dsa #resume

982

32 Comments

One of the most common questions in ML and LLM interviews is not: “Have you used Transformers?” It’s this: “Do you actually understand how a Transformer works at a core level?” Because using a Transformer is easy. Designing systems around one requires real depth. At its heart, the Transformer is built on a simple but powerful idea: attention replaces recurrence and convolution. Every token learns how much to focus on every other token — in parallel — enabling both speed and long-range dependency modeling. But strong interviews go beyond that sentence. They test whether you truly understand: • Why self-attention scales as O(n²) and why that matters • How positional encodings inject order into a permutation-invariant architecture • What role residual connections and layer normalization play in stable training • Why multi-head attention is about representation diversity, not just parallelism • How encoder-decoder attention enables grounding in translation and generation tasks Another question that reveals depth is this: “If attention is all you need, why do Transformers still fail?” And the answer lives in context limits, compute cost, data bias, and alignment—not in architecture alone. Today’s LLMs, vision models, speech systems, and agents all trace their intelligence back to this single design. The Transformer is no longer just a research architecture — it is the foundation layer of modern AI systems. If you can clearly explain the math, the intuition, and the engineering trade-offs of the Transformer in an interview, you are not just showing that you use AI — you are showing that you understand how it is built.

244