Ali Sheidaei

In this new Engineering Blog, MongoDB Staff Research Engineer Will Schultz and Principal Research Scientist Murat Demirbas dig into MongoDB's support for distributed, multi-document transactions. They also discuss recent work on formal modeling and verification to examine transactions protocol in more depth. MongoDB employs TLA+ specifications to verify its distributed transaction protocol, prioritizing both correctness and permissiveness. By mathematically modeling system interactions, engineers ensured strict snapshot isolation while minimizing unnecessary transaction aborts. This approach ensures that the database maintains rigorous data integrity without sacrificing high-throughput performance. The key takeaway for developers: assuredness. https://lnkd.in/deXrRD2S

4

Coding agents make traditional READMEs obsolete. Not because documentation doesn’t matter. But because static summaries of dynamic systems don’t scale. READMEs today: • Go stale fast • Nobody wants to maintain them • Slowly turn into technical archaeology They’re snapshots of a moving target. Coding agents change the interface. Instead of reading a compressed summary, you can: • Analyze the codebase in real time • Trace git history for architectural intent • Ask “why is this like this?” and get contextual answers • Generate setup instructions dynamically No staleness. No maintenance burden. No drift from reality. So what happens to READMEs? Two paths: 1) They disappear. Onboarding becomes “ask the agent.” 2) They shrink. Documenting only what’s outside the repo (3rd-party configs, env variables, human processes). And even that may fade as agents integrate directly with external systems. The README’s original job was compression. Coding agents remove the need for compression. We’re moving from: “Here’s a summary of the system.” To: “Interrogate the system itself.”

20

28 Comments

I used to write Python code that worked… but over time it became messy and hard to manage. Adding one small feature would break something else. Reusing code was painful. Debugging took longer than writing the code itself. That’s when OOP started making sense to me. Not as a theory, but as a way to think: • group related things together • avoid repeating logic • make code easier to extend I wrote a simple blog explaining the core OOP concepts in Python in a way that I wish I had understood earlier. No heavy jargon, just practical understanding. Here’s the blog: https://lnkd.in/gbMgskjB If you’re in that phase where your code works but doesn’t scale well, this might help. Would love to hear how you approached learning OOP. #Python #OOP #SoftwareDevelopment #Coding #Developers #Learning

10

1 Comment

Holy war time. Personally, I am moderately against early `return`-s in code, including `break`-s and `continue`-s. I prefer my code to read linearly. So, for instance: ```rust // I tend to replace this: if a == 0 {  continue; } // ... use `a` ... ``` ```rust // By this: if a > 0 {  // ... use `a` ... } ``` And similarly: ```rust // I tend to replace this: let SomeSumType::DesiredCase(x) = x else {  continue; } // ... use `x` ... ``` ```rust // By this: if let SomeSumType::DesiredCase(x) = x {  // ... use `x` ... } ``` A major counter-argument is that the code may well get more "horizontal" this way. Well, yes. But my brain is permanently damaged by certain events, among which are the high school / university dude who made us all bold on structural programming [*], and the Google C++ Style Guide. So my rule of thumb consists of three heuristics: 1) The code that has _some_ indentation to the right is easier to read than "just" linear code, 2) If the indentation is too large, branch out a function, with a clear name and clear purpose, and 3) Use a reasonable maximum line length (120 is okay), and, drum rolls, two spaces indent. I would guess (1) and (2) are a matter of style that can be tolerated by most people one way or another. But the latter part of (3), about two spaces instead of four and instead of tabs, is what _might_ drive people nuts. So, seriously. Is it totally insane to use two spaces indent and "endorse" some three levels of indentation in a single logical code block? As in, do you think it's worth it for me to force-change my habits? Or are two spaces okay, and/or are the screens wide enough these days for ~150 characters lines instead of ~120 characters, so that a few levels of indentation are no big deal? Thanks in advance and enlighten me pls. PS: It goes without saying that on someone else's project I follow the existing coding convention. This is about my pet projects and/or about projects where I am present "at inception". PPS: No, I do not think `goto` is inherently bad. We just happened to converge to high-level programming languages where other constructs are admittedly more readable, and they optimize just fine in the vast majority of cases down the path to machine code.

8

5 Comments

See how Forward Deployed Engineers have helped close the gap on implementing AI agents leading to a 800% spike in FDE job postings between Jan. and Sep. 2025, according to Indeed and the Financial Times:

3

As an AI/ML researcher and technology leader, I notice the world of technology living with a certain sense of angst in the era of AI. Unless we are living under a rock, AI tools, coding agents, and LLMs are no longer technologies of the future. They are already part of the day-to-day workflow of many software engineers. 𝗬𝗲𝘁 𝗮𝘀 𝗹𝗲𝗮𝗱𝗲𝗿𝘀, 𝘄𝗵𝗮𝘁 𝗹𝗲𝗻𝘀 𝘀𝗵𝗼𝘂𝗹𝗱 𝘄𝗲 𝘂𝘀𝗲 𝘁𝗼 𝗲𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝗼𝘂𝗿 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝘀? If our investments must move the bottom line of the business, what guardrails should guide how we employ AI? In my view, every strategic conversation about AI should answer three questions: 𝟭. 𝗗𝗼𝗲𝘀 𝗺𝘆 𝗔𝗜 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆 𝗮𝗹𝗶𝗴𝗻 𝘄𝗶𝘁𝗵 𝗺𝘆 𝗰𝗼𝗿𝗲 𝗯𝘂𝘀𝗶𝗻𝗲𝘀𝘀? Not every business problem requires next-generation technology. While there is pressure, even with a fear of missing out to adopt AI quickly, 𝙡𝙚𝙖𝙙𝙚𝙧𝙨 𝙢𝙪𝙨𝙩 𝙚𝙣𝙨𝙪𝙧𝙚 𝙞𝙩 𝙩𝙧𝙪𝙡𝙮 𝙖𝙡𝙞𝙜𝙣𝙨 𝙬𝙞𝙩𝙝 𝙩𝙝𝙚 𝙫𝙖𝙡𝙪𝙚 𝙩𝙝𝙚 𝙗𝙪𝙨𝙞𝙣𝙚𝙨𝙨 𝙙𝙚𝙡𝙞𝙫𝙚𝙧𝙨. Building capability purely because it is the buzz of the moment can be worse than being slightly late on the adoption curve. 𝟮. 𝗗𝗼𝗲𝘀 𝘁𝗵𝗲 𝗰𝗼𝘀𝘁-𝗯𝗲𝗻𝗲𝗳𝗶𝘁 𝗼𝗳 𝗔𝗜 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗮𝗱𝗱 𝘃𝗮𝗹𝘂𝗲? Technology can be exciting, but leaders must ask: 𝙝𝙤𝙬 𝙬𝙞𝙡𝙡 𝙩𝙝𝙞𝙨 𝙧𝙚𝙛𝙡𝙚𝙘𝙩 𝙞𝙣 𝙩𝙝𝙚 𝙋&𝙇 𝙞𝙣 𝙩𝙝𝙚 𝙣𝙚𝙖𝙧 𝙖𝙣𝙙 𝙡𝙤𝙣𝙜 𝙩𝙚𝙧𝙢? 𝙒𝙞𝙡𝙡 𝙩𝙝𝙚 𝙞𝙣𝙫𝙚𝙨𝙩𝙢𝙚𝙣𝙩 𝙨𝙩𝙖𝙣𝙙 𝙩𝙝𝙚 𝙩𝙚𝙨𝙩 𝙤𝙛 𝙩𝙞𝙢𝙚 𝙖𝙣𝙙 𝙙𝙚𝙡𝙞𝙫𝙚𝙧 𝙙𝙪𝙧𝙖𝙗𝙡𝙚 𝙫𝙖𝙡𝙪𝙚? 𝟯. 𝗗𝗼 𝘄𝗲 𝗿𝗲𝗮𝗹𝗹𝘆 𝗻𝗲𝗲𝗱 𝗚𝗲𝗻𝗔𝗜 𝗼𝗿 𝗮𝗻 𝗮𝗴𝗲𝗻𝘁𝗶𝗰 𝘀𝘆𝘀𝘁𝗲𝗺 𝗵𝗲𝗿𝗲, 𝗼𝗿 𝗰𝗮𝗻 𝘁𝗿𝗮𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗱𝗼 𝘁𝗵𝗲 𝗷𝗼𝗯? Today, everyone wants to label their solution with GenAI, agents, or agentic systems to be noticed. That is understandable. 𝘽𝙪𝙩 𝙖𝙨 𝙡𝙚𝙖𝙙𝙚𝙧𝙨, 𝙬𝙚 𝙢𝙪𝙨𝙩 𝙣𝙤𝙩 𝙧𝙚𝙬𝙖𝙧𝙙 𝙩𝙝𝙚 𝙢𝙚𝙧𝙚 𝙥𝙧𝙚𝙨𝙚𝙣𝙘𝙚 𝙤𝙛 𝗚𝗲𝗻𝘼𝙄 𝙞𝙣 𝙖 𝙨𝙤𝙡𝙪𝙩𝙞𝙤𝙣. 𝙄𝙣𝙨𝙩𝙚𝙖𝙙, 𝙬𝙚 𝙨𝙝𝙤𝙪𝙡𝙙 𝙧𝙚𝙬𝙖𝙧𝙙 𝙨𝙤𝙪𝙣𝙙 𝙩𝙚𝙘𝙝𝙣𝙞𝙘𝙖𝙡 𝙟𝙪𝙙𝙜𝙢𝙚𝙣𝙩. Sometimes the right answer is: • Traditional ML is sufficient. • A deterministic system is better. • A rule-based SaaS solution is the right tool. And that is good engineering leadership. For many businesses, AI is ultimately an enabler, just as technology and data have always been. 𝗕𝘂𝘁 𝗶𝗳 𝗳𝗲𝗮𝗿 (𝗼𝗳 𝗺𝗶𝘀𝘀𝗶𝗻𝗴 𝗼𝘂𝘁) 𝗱𝗿𝗶𝘃𝗲𝘀 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆, 𝘄𝗲 𝗺𝗮𝘆 𝗲𝗻𝗱 𝘂𝗽 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝘁𝗲𝗰𝗵𝗻𝗼𝗹𝗼𝗴𝘆 𝗳𝗼𝗿 𝘁𝗵𝗲 𝘀𝗮𝗸𝗲 𝗼𝗳 𝘁𝗲𝗰𝗵𝗻𝗼𝗹𝗼𝗴𝘆 𝗿𝗮𝘁𝗵𝗲𝗿 𝘁𝗵𝗮𝗻 𝗳𝗼𝗿 𝗿𝗲𝗮𝗹 𝗶𝗺𝗽𝗮𝗰𝘁 𝙎𝙤 𝙗𝙮 𝙖𝙡𝙡 𝙢𝙚𝙖𝙣𝙨, 𝙜𝙤 𝙖𝙡𝙡 𝙞𝙣 𝙤𝙣 𝘼𝙄, 𝙗𝙪𝙩 𝙢𝙖𝙠𝙚 𝙨𝙪𝙧𝙚 𝙞𝙩 𝙥𝙖𝙨𝙨𝙚𝙨 𝙩𝙝𝙧𝙤𝙪𝙜𝙝 𝙩𝙝𝙚 𝙧𝙞𝙜𝙝𝙩 𝙡𝙚𝙣𝙨 𝙛𝙞𝙧𝙨𝙩. Agree or disagree? I’d love to hear how other leaders are thinking about this. #ArtificialIntelligence #GenAI #TechnologyLeadership #EngineeringLeadership #TechStrategy #AIAdoption #SoftwareEngineering #ProductStrategy #LeadershipPerspective #InnovationLeadership #AIinBusiness

18

3 Comments

If you have JSON data and need a schema for it, the new json2s command in Structurize can help. It analyzes your JSON files, figures out what types you’re working with, and produces a valid JSON Structure schema document — one that you can use for validation, code generation, or documentation. https://lnkd.in/ezz58Mye

45

5 Comments

Why the Amazon Layoffs are a Wake-up Call for Every Engineer The era of "pattern-match engineering" is closing. Recent reports show Amazon cutting thousands of corporate roles as part of a deeper pivot toward AI-augmented productivity. This isn't just about cost-cutting; it's a fundamental shift in what the industry values. Any work that relies on applying matured designs to new cases by following a set pattern is now within the territory of AI. If your value is purely in the execution of these patterns, that value is rapidly depreciating. To remain non-replaceable, we must shift our focus: From Execution to Architecture: Don't just follow the pattern; design the system that leverages it. From Bandwidth to Innovation: Use AI to handle the repetitive "heavy lifting" so you can reclaim your time for new, high-value innovation. From Coder to System Shaper: The most valuable engineers today aren't just writing code; they are directing AI to produce results and solving the complex problems AI can't yet touch. The goal isn't to compete with AI—it's to leverage it to expand your own impact. In an industry that is "right-sizing" through technology, those who use AI as a force multiplier will be the ones who lead the next wave. https://lnkd.in/g2RHA4zr

57

2 Comments

Does C# have a null problem? C# 14 is adding yet another null-condition bit of syntax sugar. I read about it in Ivan's article, but what really made me laugh is at the end his basically admits this can be a foot-gun feature. https://lnkd.in/g5-9uKCi C# has always been excited to add language syntax and it is useful because it gives lots of experience with if features are helpful or not. But their quest to never need to explicitly check for null continues to tickle me.

5

2 Comments