<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[The Software Engineer’s Path - Medium]]></title>
        <description><![CDATA[From Waterfall to Agile, DevOps, and Platform Engineering — this publication traces how software methodologies evolved and what still works. Expect clear histories, annotated case studies, failure post-mortems, and practical checklists you can apply today. Our goal: help engineer - Medium]]></description>
        <link>https://medium.com/the-software-engineers-path?source=rss----f75ff23c6ffa---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>The Software Engineer’s Path - Medium</title>
            <link>https://medium.com/the-software-engineers-path?source=rss----f75ff23c6ffa---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 10:51:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/the-software-engineers-path" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your rules engine is a liability]]></title>
            <link>https://medium.com/the-software-engineers-path/your-rules-engine-is-a-liability-ade1e3eb24c5?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/ade1e3eb24c5</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 22:51:00 GMT</pubDate>
            <atom:updated>2026-04-21T22:51:00.515Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zA7ka1TMo2xP6760SFsbog.png" /></figure><p>I have spent over a decade building systems that try to be perfect. In the world of high-scale data ingestion, we often trick ourselves into thinking that more code equals more reliability. We write thousands of lines of validation logic, regex patterns, and nested if-statements to handle every possible edge case in a CSV file or a legacy database.</p><p>The problem is not the logic itself, but the maintenance debt it creates. Every time a client changes a column header or a third party API tweaks a response format, the system breaks. You end up spending sixty percent of your week acting as a glorified translator for data that should have been handled by the machine.</p><p>Read the full, technical deep-dive on my blog here: <a href="https://www.gperrucci.com/blog/ai/the-day-i-stopped-coding-rules-and-started-teaching-machines">https://www.gperrucci.com/blog/ai/the-day-i-stopped-coding-rules-and-started-teaching-machines</a></p><h3>The maintenance trap</h3><p>When I was leading the modernization of a large insurance platform, we faced a massive bottleneck. We were ingesting thousands of disparate datasets from different brokers, and each one had its own dialect. Our solution at the time was a massive rules engine. It felt responsible. It was easy to unit test. But it was also brittle. Whenever a new data source appeared, an engineer had to spend hours mapping fields.</p><p>This is the certainty trap. We were so afraid of a machine making a mistake that we forced humans to do a machine’s job. The total cost of ownership for a rules engine is staggering. You are not just paying for the initial development. You are paying for every future hour spent debugging why a string was not trimmed or why a date format was unexpected. The code grows until it is unmanageable, and the engineering team becomes a support desk for data quality issues.</p><h3>AI as the semantic glue</h3><p>Instead of writing rules, we started teaching the system to understand intent. By using Large Language Models (LLMs) as an abstraction layer for data mapping, we removed the need for hardcoded heuristics. The machine does not need me to tell it that “DOB” and “Date of Birth” are the same thing. It already knows.</p><p>This shift changed my role from a coder to a teacher. I stopped writing logic and started writing constraints. In a recent project involving an AI-driven data mapping engine, we replaced a thousand lines of manual configuration with a single prompt and a few examples. The user onboarding friction dropped significantly because the system could handle messy, real-world data without human intervention. We stopped worrying about the specific syntax of the input and focused on the semantic meaning of the output.</p><h3>The sandwich architecture</h3><p><strong>AI is not a silver bullet</strong>. You cannot use a probabilistic model for financial calculations or security permissions. I have seen teams fall into the trap of using AI where a simple boolean check would suffice. This increases latency and introduces unnecessary risk.</p><p>The goal is to use AI for the fuzzy parts of the system, such as mapping and intent, and keep the core business logic deterministic. I call this the sandwich architecture. You have a deterministic bread layer for safety, but the meat of the processing is handled by the intelligence of the model. This balance allows you to maintain accuracy while still being flexible enough to handle the chaos of external data.</p><ol><li>Focus on the cost of maintenance rather than the cost of tokens.</li><li>Abstract the semantic layer to translate external chaos into internal order.</li><li>Build systems that learn from user corrections.</li><li>If you are writing a tenth case for a switch statement, move it to a model.</li><li>Prioritize developer experience by removing boring mapping code.</li></ol><p>I break down the full strategy with code examples and architectural diagrams on my personal blog. Click here to read the full article: <a href="https://www.gperrucci.com/blog/ai/the-day-i-stopped-coding-rules-and-started-teaching-machines">https://www.gperrucci.com/blog/ai/the-day-i-stopped-coding-rules-and-started-teaching-machines</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ade1e3eb24c5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/your-rules-engine-is-a-liability-ade1e3eb24c5">Your rules engine is a liability</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The false dichotomy of functions and objects]]></title>
            <link>https://medium.com/the-software-engineers-path/the-false-dichotomy-of-functions-and-objects-f47d9176290a?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/f47d9176290a</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[pure-function]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[oop-concepts]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Sun, 22 Mar 2026 17:46:51 GMT</pubDate>
            <atom:updated>2026-03-22T17:46:52.663Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*IbItr5TPEBrqhDhzYdxp2A.png" /></figure><p>It is common to see high-traffic content delivery pipelines collapse for hours because of a supposedly simple refactor. These failures rarely stem from complex algorithms or hardware glitches. Instead, they often arise from a fundamental misunderstanding of state. A frequent mistake involves wrapping a stateless utility function inside a heavy object that caches data it does not own. When the upstream data changes, the object remains stubborn and stale, serving outdated information to millions of users.</p><p>This failure illustrates the actual stakes of the <strong>“Function vs. Object”</strong> debate. It is rarely about syntax or which paradigm is superior in a vacuum. It is about managing complexity and understanding the hidden costs of where you put your data and how you touch it.</p><p>👉 <strong>Original article:</strong> <a href="https://www.gperrucci.com/blog/engineering/false-dichotomy-of-functions-and-objects">https://www.gperrucci.com/blog/engineering/false-dichotomy-of-functions-and-objects</a></p><h3>The modular mandate: Functions as the atomic unit</h3><p>Functions are the consequence of wanting to sleep at night. Modular programming encourages us to separate a program into components where each performs one specific task. In my twelve years of building systems for banks and gaming giants, I have found that the most resilient codebases treat functions as pure, predictable pipes.</p><p>A function takes data, processes it, and returns a result. It is a standalone, reusable piece of logic. Whether your language calls them subroutines, methods, or procedures, the goal remains the same: take a complex program and divide it into manageable pieces.</p><p>Standard library functions like print() are our baseline, but the real engineering happens when we define our own. We give them a unique name, define the body, and invoke them when needed. In languages like C or C++, we even have to declare them ahead of time to help the compiler manage memory and scope.</p><p>But there is a trap here. People often think that because a function is “reusable,” it is “decoupled.” That is a dangerous assumption.</p><p><em>Every parameter you pass into a function is a point of coupling. If a function needs six arguments to do its job, it is not a modular component; it is a hidden dependency nightmare.</em></p><h3>Objects: Packaging state and behavior</h3><p>While functions focus on the action, object-oriented programming (OOP) focuses on the entity. Understanding objects is the key to understanding modern system architecture.</p><p>In a procedural world, you have data structures on one side and functions on the other. You pass the data into the function, and the function modifies it. In OOP, we package them together. An object contains both data (properties or attributes) and the code that operates on that data (methods).</p><p>Think about a car. It has states: is the engine on? What gear is it in? How much fuel is left? It also has behaviors: accelerate, brake, turn. In programming, a software object is conceptually the same. It can represent a user account in a fintech app, a system folder, or a database table.</p><p>The beauty of the object is encapsulation. The object operates on its own data structure. This should, in theory, prevent other parts of the system from messing with internal state. However, this is where most junior to mid-level architectures fail. They create “God Objects” that try to maintain too many states and perform too many behaviors.</p><p><em>When was the last time you looked at a class and realized it was actually three different concepts masquerading as one?</em></p><h3>Socratic trade-offs</h3><p>Before you commit to a paradigm for your next feature, ask yourself these questions:</p><ul><li>Does this logic need to remember anything from the last time it was called? If the answer is no, why are you using an object?</li><li>If this object dies, does the data it holds survive somewhere else? If the data is stored in a database, your object is just a temporary wrapper. Is that wrapper adding value or just latency?</li><li>How hard is it to test this in isolation? Pure functions are trivial to test. Objects with internal state require “mocking” and “setup,” which are often indicators of architectural friction.</li><li>Are you using inheritance because it is “clean,” or because the languages’ type system forced you into a corner?</li></ul><h3>Engineering trade-offs: Performance vs. DX vs. Maintenance</h3><p>The <strong>Total Cost of Ownership (TCO)</strong> of an abstraction is measured in how many hours it takes a new engineer to understand it six months from now.</p><h3>The cost of pure functions</h3><p>Functions offer the best Developer Experience (DX) for unit testing and debugging. Since they are stateless, you do not have to worry about the “hidden context.” However, in high-scale environments, passing large data structures through deep chains of functions can lead to memory overhead if the language does not support efficient pass-by-reference or structural sharing.</p><h3>The cost of objects</h3><p>Objects provide excellent mental models for complex business logic. Mapping a “Bank Account” to an object is intuitive. But the maintenance cost is high. Objects encourage “mutable state,” and mutable state is the root of almost all concurrency bugs I have ever encountered. If two threads try to change the balance property of the same object at the same time, you are in for a long weekend of debugging.</p><h3>The Decision Heuristic: If X, then Y</h3><p>Use this rule of thumb for your daily PR reviews:</p><ul><li><strong>Use Functions (Functional Programming) when:</strong> You are transforming data, performing calculations, or writing utility logic that does not need to persist. If you can describe the task as “Take A and turn it into B,” write a function.</li><li><strong>Use Objects (OOP) when:</strong> You are modeling a long-lived entity with a complex lifecycle. If you need to track the “status” of something over time (like a user session or a hardware connection), an object is the right tool.</li></ul><h3>Production-ready implementation</h3><p>Here is how I approach this in a modern TypeScript environment, blending the best of both worlds. Note the use of interfaces for state and pure functions for logic, wrapped in a thin object layer only when necessary.</p><pre>// Define the state as a plain data structure<br>interface AccountState {<br>  readonly id: string;<br>  readonly balance: number;<br>  readonly status: &#39;active&#39; | &#39;frozen&#39;;<br>}<br> <br>// Logic is kept as pure functions for testability<br>const calculateInterest = (balance: number, rate: number): number =&gt; {<br>  if (rate &lt; 0) throw new Error(&quot;Rate cannot be negative&quot;);<br>  return balance * rate;<br>};<br> <br>// The Object serves as a controlled interface to the state<br>class BankAccount {<br>  private state: AccountState;<br> <br>  constructor(initialState: AccountState) {<br>    this.state = initialState;<br>  }<br> <br>  // Method acts as a gateway, using the pure logic internally<br>  public applyMonthlyInterest(rate: number): void {<br>    if (this.state.status === &#39;frozen&#39;) {<br>      return; // Early exit is better than nested ifs<br>    }<br> <br>    try {<br>      const interest = calculateInterest(this.state.balance, rate);<br>      this.state = {<br>        ...this.state,<br>        balance: this.state.balance + interest<br>      };<br>    } catch (error) {<br>      // Production-grade error handling<br>      console.error(`Failed to apply interest to account ${this.state.id}:`, error);<br>    }<br>  }<br> <br>  public getBalance(): number {<br>    return this.state.balance;<br>  }<br>}</pre><p>In this example, the logic for interest calculation is a pure function. It does not care about “BankAccounts” or “Status.” It just does math. This makes it incredibly easy to test. The BankAccount class manages the lifecycle and ensures that we do not apply interest to frozen accounts. This is how you build for the long term. You use objects to guard the state and functions to do the work.</p><p>👉 <strong>Original article:</strong> <a href="https://www.gperrucci.com/blog/engineering/false-dichotomy-of-functions-and-objects">https://www.gperrucci.com/blog/engineering/false-dichotomy-of-functions-and-objects</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f47d9176290a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/the-false-dichotomy-of-functions-and-objects-f47d9176290a">The false dichotomy of functions and objects</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Confusing Libraries with Frameworks (It’s Ruining Your Architecture)]]></title>
            <link>https://medium.com/the-software-engineers-path/stop-confusing-libraries-with-frameworks-its-ruining-your-architecture-2a072025ca06?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/2a072025ca06</guid>
            <category><![CDATA[libraries]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[framework]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 11:22:37 GMT</pubDate>
            <atom:updated>2025-12-16T11:22:37.296Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_yKZnD4LDIuFf0N9dsLgA.png" /><figcaption>Library vs Framework</figcaption></figure><p>Spaghetti code often isn’t the result of bad coding skills, it’s the result of bad architectural definitions.</p><p>In my years auditing codebases, I’ve noticed a recurring pattern: developers treating <strong>libraries</strong> like frameworks (resulting in a lack of structure) or treating <strong>frameworks</strong> like libraries (resulting in a constant fight against the tool).</p><blockquote>Original post on my personal blog. <a href="https://www.gperrucci.com/en/blog/engineering/library-vs-framework-decision-matrix">Click here to read the full article</a></blockquote><p>The distinction isn’t about file size, popularity, or complexity. It comes down to a single, non-negotiable principle.</p><p>Here is the heuristic I use to make the decision:</p><p><strong>The Litmus Test is “Inversion of Control”:</strong></p><ul><li><strong>Library:</strong> You call the code. You are the director. You decide when to render, when to fetch data, and when to route.</li><li><strong>Framework:</strong> The code calls you. The framework provides the stage and the script; you just fill in your lines at the right time (e.g., ngOnInit).</li></ul><p><strong>The Hollywood Principle:</strong></p><p>I tell junior engineers to think of frameworks as the Hollywood agent:</p><blockquote>“Don’t call us, we’ll call you.”</blockquote><p>If you are manually stitching together the entry point and execution flow, you are likely using a library. If you are writing classes that get magically instantiated by a scanner, you are in a frmework.</p><p><strong>Trade-Offs over Hype:</strong></p><ul><li><strong>Choose a Library</strong> when you need <strong>granular control</strong> (e.g., a complex data visualization tool) or when your problem is highly specific.</li><li><strong>Choose a Framework</strong> when you need <strong>velocity and consistency</strong> across a large team. You trade architectural freedom for the ability to onboard new developers instantly.</li></ul><p><strong>The Modern Confusion (React vs. Next.js):</strong></p><p>React is a library , it only cares about views. Next.js is a framework , it dictates your routing, file structure, and data fetching. If you try to force Next.js to behave like a loose collection of libraries, you will lose.</p><p>Original post on my personal blog. <a href="https://www.gperrucci.com/en/blog/engineering/library-vs-framework-decision-matrix">Click here to read the full article</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a072025ca06" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/stop-confusing-libraries-with-frameworks-its-ruining-your-architecture-2a072025ca06">Stop Confusing Libraries with Frameworks (It’s Ruining Your Architecture)</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Wasting Time: The 3 Pairing Styles That Actually Ship Better Code]]></title>
            <link>https://medium.com/the-software-engineers-path/stop-wasting-time-the-3-pairing-styles-that-actually-ship-better-code-5556fdcd047e?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/5556fdcd047e</guid>
            <category><![CDATA[driver-navigator]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[pair-programming]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 08:19:56 GMT</pubDate>
            <atom:updated>2025-12-16T08:19:56.757Z</atom:updated>
            <content:encoded><![CDATA[<p>Let’s be honest. Most people hate pair programming.</p><p>Why? Because they do it wrong.</p><p>They sit together and one person types while the other person checks email. That’s not collaboration. That’s a highly paid spectator sport.</p><p>I’ve spent 12 years building software, and I can tell you this: <strong>Pairing is the single best investment you can make in code quality and team knowledge transfer</strong>. But you need structure.</p><p>If you jump into pairing without a defined style, you are going to waste time. Here are the three non-negotiable patterns you must use to make collaboration a productivity engine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jXnzDf6Qssf8Mhi57DjKZQ.png" /></figure><h3>1. Driver/Navigator: The Essential Starter Kit</h3><p>This is the baseline structure. It’s what you use 80% of the time, especially when tackling features that require focused execution.</p><ul><li><strong>The Driver</strong> types. Their focus is 100% on the moment: translating the idea into working syntax.</li><li><strong>The Navigator</strong> guides. They look ahead, check for mistakes, and ensure the team is aligned with the overall design.</li></ul><p><strong>The Key Rule:</strong> <strong>You must swap roles every 10–15 minutes.</strong> If you don’t enforce this rotation, one person quickly becomes the passive observer. Ownership needs to be actively shared.</p><h3>2. Ping-Pong: The Code Quality Enforcer</h3><p>Do you practice Test-Driven Development (TDD)? Then you should be doing Ping-Pong.</p><p>This style forces a rapid, focused rhythm that ties implementation directly to testing. It is a brilliant way to ensure high code coverage.</p><ul><li><strong>Developer A</strong> (Ping) writes a failing test.</li><li><strong>Developer B</strong> (Pong) writes the minimal code to make that test pass.</li><li><strong>Developer A</strong> then either writes the next failing test or refactors the existing code.</li></ul><p>This pattern is a continuous loop of testing, coding, and quality assurance. <strong>If your project goal is to be highly testable, this is your style.</strong></p><h3>3. Strong Style: The Mentorship Accelerator</h3><p>This is my favorite trick for senior-to-junior knowledge transfer.</p><p>In Strong Style, the person with the solution (usually the senior engineer) <strong>cannot touch the keyboard.</strong> They are the Navigator.</p><p>The junior engineer is the Driver. They are the only one who types.</p><p>This forces the senior engineer to articulate their thoughts clearly, and it forces the junior engineer to internalize the logic by typing every keystroke. <strong>For an idea to enter the computer, it must pass through the other person’s hands.</strong></p><p>It might feel slower at first, but it accelerates ramp-up time for new team members exponentially.</p><h3>When To Just Code Alone</h3><p>Pairing is an investment, but not every task deserves two developers:</p><ul><li><strong>Boilerplate tasks:</strong> Simple file creation, repetitive configuration, or non-complex refactoring.</li><li><strong>Deep, uninterrupted focus:</strong> Debugging a highly intermittent, specific bug deep in a legacy system.</li><li><strong>Personality clashes:</strong> If the two engineers are not compatible or unwilling to communicate, it’s a net negative.</li></ul><p>Use these three structures to make your pairing sessions focused, intentional, and high-value. Stop screen-sharing and start collaborating.</p><p>Original post on my personal blog. <a href="https://www.gperrucci.com/en/blog/engineering/pair-programming-styles">Click here to read the full article</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5556fdcd047e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/stop-wasting-time-the-3-pairing-styles-that-actually-ship-better-code-5556fdcd047e">Stop Wasting Time: The 3 Pairing Styles That Actually Ship Better Code</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Teamwork in Software Engineering]]></title>
            <link>https://medium.com/the-software-engineers-path/teamwork-in-software-engineering-c06fb86404b3?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/c06fb86404b3</guid>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Wed, 03 Dec 2025 22:02:25 GMT</pubDate>
            <atom:updated>2025-12-03T22:02:14.222Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iHqWvx7NdXznQWFKMa6rVg.png" /></figure><p>This is an adapted, shorter version of my original article on my blog:<br> <strong>“</strong><a href="https://www.gperrucci.com/en/blog/engineering/teamwork-in-software-engineering"><strong>Teamwork in Software Engineering: More Than Just ‘Working Together’</strong></a><strong>”</strong>.</p><p>In modern software projects, teamwork is not a “nice to have” — it is the only realistic way to ship and maintain real systems.</p><p>Most products today involve multiple platforms, distributed services, tight deadlines, and constant change. <strong>No single engineer can design, build, test, deploy</strong>, and operate all of that alone without paying a huge price in quality or speed. Teams exist because the work is too complex for individuals.</p><p>The interesting part is not that we need teams. It is <em>how</em> those teams work when things are going well (and when they are not).</p><h3>Why Teams Matter (Beyond the Buzzword)</h3><p>The sports analogy is still useful: a football team where everyone plays striker is a losing team. Roles are different, but the goal is shared.</p><p>Software teams are similar:</p><ul><li>One engineer focuses on backend APIs and data models.</li><li>Another lives in the UI, caring about accessibility, UX, and performance.</li><li>Someone else builds test suites and automation.</li><li>A designer shapes flows and visual consistency.</li><li>A product person aligns the work with real user needs.</li></ul><p>The value comes from <em>coordination of these differences</em>, not from everyone doing the same thing. When this coordination works, teams ship better software, faster, with fewer surprises.</p><h3>A Simple Scenario: Building a Mobile App as a Team</h3><p>Imagine we are building a new mobile app from scratch. A reasonably healthy process could look like this.</p><h3>1. Kick-off: Aligning on the Problem</h3><p>We sit down as a team and answer a few basic questions:</p><ul><li>What problem does this app solve?</li><li>Who is going to use it?</li><li>Which features matter first, and which can wait?</li></ul><p>This sounds obvious, but many teams skip the real conversation and jump straight into solutions. A good kick-off is where we reduce the risk of building the wrong thing. Teamwork here means listening, asking questions, and challenging assumptions <em>before</em> code exists.</p><h3>2. Role Assignment: Using Strengths (Without Creating Silos)</h3><p>After alignment, we split responsibilities based on strengths:</p><ul><li>Backend: authentication, APIs, database schema.</li><li>Frontend/mobile: navigation, screens, interactions.</li><li>QA: test strategy, automation, regression checks.</li><li>Design: user flows, visuals, interaction details.</li></ul><p>This is not about building walls. It is about giving ownership while keeping collaboration open. People can help outside their area, but there is clarity about who drives what.</p><h3>3. Collaboration While Building</h3><p>During implementation, good teamwork shows up in daily habits:</p><ul><li><strong>Code reviews</strong> to share knowledge and catch issues early.</li><li><strong>Pair programming</strong> when something is complex or risky.</li><li><strong>Short stand-ups</strong> to surface blockers and keep direction aligned.</li><li><strong>Shared documentation</strong> for APIs, architecture, and important decisions.</li></ul><p>When this works, we avoid duplicated efforts, hidden decisions, and “surprises” during integration.</p><h3>4. Testing and Integration as a Shared Responsibility</h3><p>Once the main features are in place, the team validates the app together:</p><ul><li>Testers report clear issues; developers fix them quickly.</li><li>Designers verify that the UX is actually what was intended.</li><li>The team runs usability tests, observes real user behavior, and adjusts.</li></ul><p>Here, quality is not “QA’s job” or “the tester’s problem”. It is a shared outcome of how the team works.</p><h3>The Real Benefits of Teamwork in Software</h3><p>When collaboration is intentional (not accidental), several benefits appear.</p><p><strong>Better problem-solving.</strong><br> Different backgrounds mean different angles on the same problem. One person spots performance risks, another sees UX pitfalls, another offers a simpler architecture. The result is typically more robust than any single engineer’s first idea.</p><p><strong>Faster delivery — when organized.</strong><br> With clear ownership and communication, people can work in parallel instead of blocking each other. Without that clarity, “more people” just means “more time spent reworking and clarifying”.</p><p><strong>Knowledge sharing and resilience.</strong><br> Through reviews, pairing, and documentation, knowledge spreads. The team becomes less fragile because the system is not trapped in one person’s head.</p><p><strong>Higher quality and fewer regressions.</strong><br> More eyes on requirements, design, and code usually means more issues found early, when they are cheap to fix.</p><h3>Common Failure Modes (And How to Reduce Them)</h3><p>Teamwork is not automatically good. There are patterns that silently damage collaboration.</p><h3>1. Miscommunication</h3><p>Symptoms:</p><ul><li>Different people have different mental models of the same feature.</li><li>Stakeholders expect one thing; the team builds another.</li></ul><p>Mitigations:</p><ul><li>Write things down: goals, constraints, decisions.</li><li>Keep requirements and decisions in a place everyone uses.</li><li>Use short, focused meetings instead of vague, long ones.</li></ul><h3>2. Unclear Responsibilities</h3><p>Symptoms:</p><ul><li>Two people implement the same thing in parallel.</li><li>Nobody feels responsible for a critical area (“I thought they owned it…”).</li></ul><p>Mitigations:</p><ul><li>Make ownership explicit (components, domains, services).</li><li>Use simple tools like a responsibility matrix or a clear “owner” per area.</li></ul><h3>3. Conflict and Ego</h3><p>Symptoms:</p><ul><li>Technical discussions turn into personal battles.</li><li>People defend their ideas even when evidence points the other way.</li></ul><p>Mitigations:</p><ul><li>Focus on the problem, not the person.</li><li>Use data: experiments, benchmarks, proofs of concept.</li><li>Normalize changing your mind when new information appears.</li></ul><h3>4. “Hero Culture”</h3><p>Symptoms:</p><ul><li>One person is the only one who understands a critical part of the system.</li><li>Releases or production incidents depend on a single engineer being online.</li></ul><p>Mitigations:</p><ul><li>Spread knowledge intentionally: pair programming, rotations, documentation.</li><li>Avoid designing systems that <em>require</em> a specific person to be present.</li></ul><h3>What Makes Teamwork Actually Work?</h3><p>From a practical point of view, a few principles make the difference:</p><ul><li><strong>Shared purpose.</strong><br> Everyone understands why the project exists and who it serves, beyond ticket titles.</li><li><strong>Clear roles, flexible collaboration.</strong><br> People know their main responsibilities but help outside their “box” when needed.</li><li><strong>Open communication.</strong><br> Team members feel safe to ask questions, raise risks, and say “I don’t know”.</li><li><strong>Continuous improvement.</strong><br> The team regularly asks: “What is not working in how we collaborate?” and adjusts.</li></ul><p>These principles are simple, but applying them consistently is rare. That is where good engineering leadership and team habits matter.</p><h3>Closing Thoughts</h3><p>Teamwork in software engineering is not just “multiple people in the same repo”. It is a deliberate way of combining different skills, perspectives, and responsibilities to build something that no individual could deliver alone.</p><p>When it works, teams:</p><ul><li>Understand the problem clearly.</li><li>Use people’s strengths without creating silos.</li><li>Share knowledge instead of hoarding it.</li><li>Handle conflicts with data and respect.</li></ul><blockquote>You still have bugs, incidents, and surprises — that is normal. But a strong team has the tools to handle them, learn, and move faster over time.</blockquote><p>If you want a more detailed and structured version of this topic, you can read the original post on my blog:</p><p>👉 <a href="https://www.gperrucci.com/en/blog/engineering/teamwork-in-software-engineering"><strong>Teamwork in Software Engineering: More Than Just “Working Together”</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c06fb86404b3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/teamwork-in-software-engineering-c06fb86404b3">Teamwork in Software Engineering</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Back-End Development Is Where Products Live or Die]]></title>
            <link>https://medium.com/the-software-engineers-path/why-back-end-development-is-where-products-live-or-die-002df702d71b?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/002df702d71b</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Sat, 22 Nov 2025 08:35:10 GMT</pubDate>
            <atom:updated>2025-11-22T08:35:10.508Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Invisible Half of Your App: Why Back-End Development Is Where Products Live or Die</h3><p><em>This article is a condensed version of my full piece, “</em><a href="https://www.gperrucci.com/en/blog/engineering/why-back-end-development-matters-more-than-most-people-think"><em>Why Back-End Development Matters More Than Most People Think</em></a><em>”, published on my personal site.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8UzA0k05BOfkIQXSNZBwgQ.png" /></figure><p><strong>Most people judge a product by its interface: the layout, the animations, the smoothness of the interactions. But every time a user logs in, checks their balance, or completes a payment, they’re trusting something they cannot see: the back end.</strong></p><p>If the back end fails, the product fails — no matter how good the UI looks.</p><p>In this article, we’ll look at back-end development not as “the place where we write APIs” but as the <strong>core of how a product behaves</strong>: how requests are processed, how data is handled, how security and reliability are enforced, and how teams collaborate around it.</p><h3>Back-End Development: More Than “Just APIs”</h3><p>When someone clicks <em>“Log in”</em> or <em>“Pay now”</em>, the obvious thing happening is a UI change. Under the surface, a lot more is going on:</p><ol><li>The client sends a request with data and context.</li><li>The back end validates that data and applies business rules.</li><li>It reads and writes to databases or other services.</li><li>It returns a structured response the client can understand.</li></ol><p>That full path — from intention in the UI to a correct, safe result in the system — is where back-end development lives.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ADutd89f8iuR_cNujggOpA.png" /></figure><p>A back-end developer is responsible for:</p><ul><li><strong>Defining the behaviour</strong>: what exactly should happen for each operation, and in which order.</li><li><strong>Enforcing rules and constraints</strong>: what is allowed, what is rejected, what is logged.</li><li><strong>Connecting systems</strong>: databases, queues, third-party services, internal microservices.</li></ul><p>Seen this way, APIs are just the <em>interface</em> to something more important: the business logic and data flows that make the product actually useful and trustworthy.</p><h3>Requests, Routes, and the API as a Contract</h3><p>Three core concepts underpin almost every back-end:</p><ul><li><strong>Requests</strong> carry what the user wants to do, plus all the context (headers, tokens, parameters).</li><li><strong>Routes/endpoints</strong> map those requests to specific operations: “this combination of URL + method triggers this piece of logic”.</li><li><strong>APIs</strong> define the <em>contract</em> between client and server: which operations exist, what they expect, what they return, and how they fail.</li></ul><p>A good back-end API behaves like a promise:</p><h3>“If you send me valid data in this shape, I will either perform the operation or fail in a predictable, documented way.”</h3><p>This has a few important implications:</p><ul><li>Error formats should be consistent, not random.</li><li>Status codes should mean something, not just “200 if it worked, 500 if it didn’t”.</li><li>Changes should be explicit and versioned instead of silently breaking existing clients.</li></ul><p>When teams ignore the idea of an API as a contract, they pay for it later in regressions, broken integrations, and endless “what changed?” debugging between front-end and back-end.</p><h3>Data Is the Product: Databases, SQL, and ORMs</h3><blockquote>Most products are, at their core, <strong>data plus rules</strong>. Back-end developers are the people who decide how that data is structured, stored, and protected.</blockquote><p>This includes:</p><ul><li>Choosing between <strong>relational</strong> and <strong>non-relational</strong> databases.</li><li>Designing schemas that reflect real business concepts instead of leaking implementation details.</li><li>Using <strong>SQL</strong> and query design to ensure operations are correct and fast.</li><li>Leveraging <strong>ORMs</strong> or similar tools for productivity, without losing sight of what actually runs in the database.</li></ul><p>The trade-off is subtle:</p><ul><li>If you rely only on low-level SQL, you may ship slowly and duplicate logic.</li><li>If you rely only on high-level abstractions, you may create performance problems and not notice until production.</li></ul><p>A strong back-end mindset is to treat data as an asset: <em>model it carefully, access it deliberately, and never assume “the ORM will handle it” without understanding how.</em></p><h3>Security as a Daily Concern, Not a Checklist</h3><p>Back-end systems handle credentials, tokens, payments, personal data — exactly the things attackers care about. Security is not a “nice to have” you add at the end; it fundamentally shapes how you design and implement back-end logic.</p><p>At a conceptual level, secure back-end development means:</p><ul><li><strong>Separating authentication and authorization</strong> clearly. Knowing <em>who</em> the user is is different from knowing <em>what</em> they are allowed to do.</li><li><strong>Never trusting client input</strong>, even if it comes from your own front-end.</li><li><strong>Protecting data in transit and at rest</strong>, using encryption, hashing, and proper storage strategies.</li><li><strong>Designing for least privilege</strong>, so that a compromised token or service cannot access everything.</li></ul><p>Importantly, this is not about adding one security library and considering the job done. It is about building habits: validating inputs, using safe defaults, reviewing access rules, and logging suspicious behaviour by default.</p><h3>Reliability, Performance, and Observability</h3><p>A back end that works in local development with one user is easy. A back end that keeps working under real load, partial outages, and evolving requirements is where engineering really starts.</p><p>Three pillars matter here:</p><p><strong>Reliability.</strong><br> Designing for the expectation that things will fail: databases will slow down, network calls will time out, third-party APIs will respond incorrectly. Back-end developers need strategies like retries, timeouts, circuit breakers, and idempotent operations.</p><p><strong>Performance and scalability.</strong><br> Understanding where time and resources are spent: is the bottleneck CPU, I/O, database, network? Should we cache, batch, paginate, or move some work to background jobs? These decisions have a direct impact on user experience.</p><p><strong>Observability.</strong><br> You cannot fix what you cannot see. Metrics, logs, and traces are not optional extras; they are how teams answer “What is happening?” under pressure. A good back end is instrumented in a way that makes it possible to debug production issues without guessing.</p><p>Without these three, even a “correct” back end becomes fragile and expensive to maintain.</p><h3>Back-End as a Team Sport, Not a Hero Role</h3><p>Back-end decisions affect everyone:</p><ul><li>Front-end developers need <strong>clear contracts and predictable behaviour</strong>.</li><li>UX and product teams need <strong>feasible flows and understandable error states</strong>.</li><li>QA needs <strong>testable boundaries</strong> and well-defined scenarios.</li><li>DevOps/SRE needs <strong>deployable, observable services</strong> that behave well in production.</li></ul><p>The most effective back-end developers tend to:</p><ul><li>Share API designs early instead of surprising others with finished implementations.</li><li>Break work into <strong>small, deployable increments</strong> rather than massive rewrites.</li><li>Communicate trade-offs explicitly (“we can ship faster, but this has these constraints”).</li><li>Document routes, behaviours, and assumptions so the rest of the team can reason about the system.</li></ul><p>From this perspective, back-end development is as much about <strong>communication and alignment</strong> as it is about code.</p><h3>How to Think About Your Back End</h3><p>When you step back from frameworks and languages, a few guiding questions help you design better back ends:</p><ul><li><em>What real-world concepts do we need to model, and how should they relate in data?</em></li><li><em>What guarantees do we owe the user and the business? Consistency, availability, auditability?</em></li><li><em>What can safely fail, and what absolutely cannot?</em></li><li><em>Which parts of the system need to be real-time, and which can be asynchronous?</em></li><li><em>How will we know when things are going wrong, and how quickly can we respond?</em></li></ul><p>The answers to these questions shape your architecture more than any choice between Node.js vs Python, or REST vs GraphQL. The technology is important, but it is in service of the design.</p><p>If you want a deeper, more detailed exploration of these ideas, including more structured breakdowns of APIs, data, security, and reliability, you can read the full article on my site:</p><p><strong>👉 </strong><a href="https://www.gperrucci.com/en/blog/engineering/why-back-end-development-matters-more-than-most-people-think"><strong>Why Back-End Development Matters More Than Most People Think</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=002df702d71b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/why-back-end-development-is-where-products-live-or-die-002df702d71b">Why Back-End Development Is Where Products Live or Die</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Modern Web Apps Work: From Browser to Cloud]]></title>
            <link>https://medium.com/the-software-engineers-path/how-modern-web-apps-work-from-browser-to-cloud-292d803e4091?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/292d803e4091</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cloud-application]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Fri, 14 Nov 2025 07:20:47 GMT</pubDate>
            <atom:updated>2025-11-14T07:23:53.585Z</atom:updated>
            <content:encoded><![CDATA[<p>Every time you open a website, your browser is talking to remote servers. Understanding that conversation is the foundation of web and cloud development.</p><p><strong>Read the Full Version:</strong> 👉<strong> </strong><a href="https://www.gperrucci.com/en/blog/engineering/from-browser-to-cloud-how-modern-web-apps-actually-work">https://www.gperrucci.com/en/blog/engineering/from-browser-to-cloud-how-modern-web-apps-actually-work</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z2QeJCwNmaU_EnuiAGpL6w.png" /><figcaption>From Browser to Cloud</figcaption></figure><h3>Client–Server Basics</h3><p>Your browser is the <strong>client</strong>. It sends an <strong>HTTP request</strong> to a <strong>server</strong> asking for a resource such as / or /dashboard. The server responds with:</p><ul><li><strong>HTML</strong> for structure</li><li><strong>CSS</strong> for presentation</li><li><strong>JavaScript</strong> for interactivity</li></ul><p>Some of this content is <strong>static</strong>, like a cached CSS file. Some is <strong>dynamic</strong>, generated for that specific request, such as your personalized dashboard.</p><p>A small TypeScript snippet shows the pattern:</p><pre>async function loadGreeting() {<br>  const res = await fetch(&quot;http://localhost:5000/api/greeting&quot;);<br>  const data = await res.json();<br>  const el = document.getElementById(&quot;greeting&quot;);<br>  if (el) el.textContent = data.message;<br>}<br>document.addEventListener(&quot;DOMContentLoaded&quot;, loadGreeting);</pre><p>The key idea: modern pages keep calling the server throughout the session, not just once on page load.</p><h3>Web Apps vs Cloud Apps</h3><p>A <strong>web application</strong> is any interactive software accessed through a browser. It might run on a single machine, on-premises, or in a small VPS.</p><p>A <strong>cloud application</strong> is designed for cloud infrastructure from day one. It relies on managed databases, auto-scaling, serverless functions, and global CDNs.</p><p>Cloud apps gain scalability and resilience but introduce complexity and potential vendor lock-in. Architecturally, though, the pattern is the same: the browser talks to APIs that live somewhere else.</p><h3>Front-End, Back-End, and Full-Stack Roles</h3><p><strong>Front-end developers</strong> focus on the user experience: layout, responsive design, accessibility, and client-side logic using JavaScript or TypeScript.</p><p><strong>Back-end developers</strong> design and implement APIs, business logic, and data storage, using stacks like Python + Flask or Node.js + TypeScript.</p><p>For example, this minimal Python back-end can serve the previous TypeScript client:</p><pre>from datetime import datetime<br>from flask import Flask, jsonify<br>app = Flask(__name__)<br>@app.get(&quot;/api/greeting&quot;)<br>def greeting():<br>    return jsonify({<br>        &quot;message&quot;: &quot;Hello from the server!&quot;,<br>        &quot;time&quot;: datetime.utcnow().isoformat() + &quot;Z&quot;,<br>    })<br>if __name__ == &quot;__main__&quot;:<br>    app.run(debug=True)</pre><p><strong>Full-stack developers</strong> are comfortable in both worlds. Their strength is seeing how UI decisions affect API design, performance, and data models — and vice versa.</p><h3>Tools That Make You Effective</h3><p>You can technically write everything in a barebones editor, but you will move faster with modern tools.</p><ul><li><strong>Editors like VS Code or Sublime Text</strong>: light, extensible, great for JavaScript, TypeScript, and Python.</li><li><strong>IDEs like Eclipse or IntelliJ-based tools</strong>: heavier but powerful for large back-end codebases and complex refactoring.</li></ul><p>A practical setup for most web developers:</p><ul><li><strong>VS Code</strong> as your main editor</li><li>TypeScript and Python extensions for type checks and linting</li><li>Git integration and a terminal built in</li></ul><p>The goal is not to install every plugin, but to choose a small set of tools that help you write clear, maintainable code.</p><h3>Putting It Together</h3><p>From a user’s point of view, web and cloud apps “just work” in the browser. From a developer’s perspective, you should see:</p><ul><li>The <strong>browser</strong> sending HTTP requests</li><li>The <strong>server</strong> applying business logic and accessing data</li><li>The <strong>network</strong> connecting everything, sometimes through complex cloud infrastructure</li><li>Your <strong>tools</strong> helping you reason about and debug each layer</li></ul><p>If you can follow the path from <strong>URL in the address bar</strong> to <strong>rendered, interactive UI</strong>, you are already thinking like a modern web or cloud engineer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=292d803e4091" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/how-modern-web-apps-work-from-browser-to-cloud-292d803e4091">How Modern Web Apps Work: From Browser to Cloud</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who Does What? Understanding Roles in a Software Engineering Team]]></title>
            <link>https://medium.com/the-software-engineers-path/who-does-what-understanding-roles-in-a-software-engineering-team-1535aeb37019?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/1535aeb37019</guid>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[roles]]></category>
            <category><![CDATA[sdlc-process]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Thu, 13 Nov 2025 21:00:51 GMT</pubDate>
            <atom:updated>2025-11-13T21:00:37.639Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iqdjaBu7SiofYR35N0hjjA.png" /><figcaption>Roles in a Software Engineering</figcaption></figure><h3><strong><em>Who actually owns this?</em></strong></h3><p>If you’ve ever joined a new software project and thought, <strong><em>“Who actually owns this?”</em></strong> you’re not alone. Modern software engineering depends on a mix of roles that overlap just enough to collaborate, but are distinct enough to create confusion when you first encounter them.</p><p><strong>Read the Full Version:</strong> 👉<strong> </strong><a href="https://www.gperrucci.com/en/blog/engineering/roles-in-software-engineering-projects"><strong>https://www.gperrucci.com/en/blog/engineering/roles-in-software-engineering-projects</strong></a></p><p>Different companies use different titles. <strong>Agile teams talk about <em>Scrum Masters</em> and <em>Product Owners</em>, while traditional environments still lean on <em>Project Managers</em> and <em>Business Stakeholders</em>.</strong> But underneath the naming differences, the same core responsibilities keep showing up.</p><p>Let’s walk through the key roles you’ll find on most software projects and what they are <em>actually</em> responsible for.</p><h3>Project Manager vs. Scrum Master</h3><p>In a traditional SDLC, the <strong>Project Manager</strong> is the person keeping the entire machine running. They plan, schedule, track budgets, allocate people and resources, and make sure everyone knows what’s happening and when. Their focus is on the <em>plan</em> and the <em>execution</em> of that plan.</p><p>On Agile teams, the equivalent role is the <strong>Scrum Master</strong>, but the mindset is different. Instead of controlling the plan, the Scrum Master focuses on enabling the team. They facilitate ceremonies, remove blockers, protect the team from distractions, and promote collaboration. Where the Project Manager thinks in terms of milestones and timelines, the Scrum Master thinks in terms of iteration, feedback, and continuous improvement.</p><p>Both roles have one thing in common: they make it easier for everyone else to do their best work.</p><h3>Stakeholders: The People We’re Building For</h3><p><strong>Stakeholders</strong> are the people who care deeply about the outcome of the project because it affects their goals, their teams, or their customers.</p><p>They can be:</p><ul><li>Customers who purchase the product</li><li>End-users who interact with it daily</li><li>Decision-makers who fund it</li><li>System administrators who maintain it</li></ul><p>Stakeholders define requirements, clarify priorities, and give feedback when something isn’t quite right. They may be involved in <strong>beta testing</strong> or <strong>acceptance testing</strong> before release. When they’re engaged early and often, teams ship products that matter. When they’re ignored, teams ship features that nobody uses.</p><h3>System / Software Architect: Designing the Skeleton</h3><p>The <strong>System or Software Architect</strong> is responsible for the structure beneath the surface. They define how components fit together, how data flows, and which technologies should be used. Their job is not just to draw diagrams — it’s to make decisions that balance constraints like scalability, reliability, performance, and cost.</p><p>They support the team across the SDLC, ensuring the implementation stays aligned with the designed architecture. When done well, architecture gives the team clarity and guardrails. When absent or weak, everything becomes harder: changes are risky, debugging is painful, and scaling feels like a constant fight.</p><h3>UX Designer: Making Software Understandable</h3><p>The <strong>UX Designer</strong> works at the intersection of user needs and product capability. Their responsibility is to make the software <em>behave</em> in a way that feels natural and understandable.</p><p>They define:</p><ul><li>How users navigate</li><li>How the system communicates state and feedback</li><li>What flows users follow to complete tasks</li></ul><p>They don’t just draw screens; they shape the experience. Good UX design reduces friction and confusion. Great UX design lets users focus on their goals instead of the interface.</p><h3>Software Developer: Turning Ideas into Code</h3><p>The <strong>Software Developer</strong> is the one who converts requirements, architecture, and UX design into a working system.</p><p>They:</p><ul><li>Implement features based on the software requirements</li><li>Follow architectural guidelines</li><li>Integrate UX decisions into real components and APIs</li><li>Debug, refactor, and improve the codebase over time</li></ul><p>Developers are at the center of execution. When they have clear requirements, solid architecture, and a healthy feedback loop, they can move fast. When these inputs are weak, developers end up guessing, redoing work, and fighting unexpected edge cases.</p><h3>Tester / QA Engineer: Protecting Quality</h3><p>The <strong>Tester</strong> or <strong>QA Engineer</strong> focuses on one thing: <em>does this actually work as intended?</em></p><p>They:</p><ul><li>Design and execute test cases</li><li>Validate that requirements are met</li><li>Find defects and report them clearly</li><li>Verify that fixes don’t break existing behavior</li></ul><p>Their work is not just about “finding bugs.” It’s about building confidence that the software is stable enough to release. Without QA, teams are essentially guessing how risky each deployment is.</p><h3>Site Reliability Engineer (SRE) / Ops Engineer: Keeping It Running</h3><p>Once software is deployed, the <strong>Site Reliability Engineer (SRE)</strong> or <strong>Ops Engineer</strong> makes sure it keeps running reliably.</p><p>They:</p><ul><li>Track incidents and lead incident response</li><li>Monitor performance and uptime</li><li>Automate deployments, scaling, and routine operations</li><li>Improve observability so teams can understand what’s happening in production</li></ul><p>SREs live where software meets reality: networks, traffic spikes, failures, and unpredictable user behavior. Their job is to ensure that the system is not only working today, but can also handle tomorrow’s load without falling apart.</p><h3>Product Manager / Product Owner: Owning the Vision</h3><p>The <strong>Product Manager</strong> (or <strong>Product Owner</strong> in Agile) is responsible for <strong>what</strong> gets built and <strong>why</strong>.</p><p>They:</p><ul><li>Understand the needs of stakeholders and end-users</li><li>Translate those needs into a roadmap and backlog</li><li>Prioritize features based on value and constraints</li><li>Ensure the team is always working on the most important thing</li></ul><p>They’re the connector between business goals and the engineering team. When this role is strong, the team has clear direction and can say “no” to distractions. When it’s weak, priorities fluctuate and the roadmap becomes a random collection of requests.</p><h3>Technical Writer / Information Developer: Making Knowledge Accessible</h3><p>Finally, the <strong>Technical Writer</strong> or <strong>Information Developer</strong> ensures that the product is understandable <em>beyond the code</em>.</p><p>They create:</p><ul><li>User guides and manuals</li><li>Online help and knowledge bases</li><li>Reports, white papers, and other technical documents</li></ul><p>They translate complex technical behavior into language that non-technical people can use. Good documentation reduces support load, speeds up onboarding, and helps stakeholders give better feedback.</p><h3>Bringing It All Together</h3><p>A successful software project isn’t just “developers writing code.” It’s a coordinated effort across roles that define the vision, design the structure, implement, validate, operate, and explain the system.</p><p>You don’t need every role on every project, and sometimes one person wears multiple hats. But understanding these roles makes collaboration clearer and reduces the classic confusion of “who is responsible for what?”</p><p><strong>Read the Full Version: 👉 </strong><a href="https://www.gperrucci.com/en/blog/engineering/roles-in-software-engineering-projects"><strong>https://www.gperrucci.com/en/blog/engineering/roles-in-software-engineering-projects</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1535aeb37019" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/who-does-what-understanding-roles-in-a-software-engineering-team-1535aeb37019">Who Does What? Understanding Roles in a Software Engineering Team</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Every Engineer Should Know About Software Documentation]]></title>
            <link>https://medium.com/the-software-engineers-path/what-every-engineer-should-know-about-software-documentation-99fa4f434760?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/99fa4f434760</guid>
            <category><![CDATA[software-documentation]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Thu, 13 Nov 2025 17:23:58 GMT</pubDate>
            <atom:updated>2025-11-13T17:23:49.209Z</atom:updated>
            <content:encoded><![CDATA[<p>Software documentation isn’t just paperwork — it’s the memory of your system. It explains what your product is, how it works, and how to use or maintain it. Whether you’re writing code, testing, or deploying, documentation connects every phase of the <a href="https://medium.com/the-software-engineers-path/the-six-phases-of-the-sdlc-a-fast-practical-guide-d98fd6d80fbb">SDLC</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hcyPPlSYwxDIaoD_6O-HXw.png" /></figure><p>There are three main formats: <strong>written, video, and graphical</strong>. Each helps a different audience — from developers to end users — understand the product better.</p><p>👉 <strong>Read the full in-depth version here:</strong><br> <a href="https://www.gperrucci.com/en/blog/engineering/software-documentation-explained">https://www.gperrucci.com/en/blog/engineering/software-documentation-explained</a></p><p>We usually classify documentation into <strong>two big categories</strong>:</p><ul><li><strong>Product documentation</strong> tells you what the software does.</li><li><strong>Process documentation</strong> shows how to get things done, like deploying code or reviewing pull requests.</li></ul><p>Within product documentation, you’ll find five key types:</p><ol><li><strong>Requirements documentation</strong> — describes what the software must do.</li><li><strong>Design documentation</strong> — shows how the system will achieve those goals.</li><li><strong>Technical documentation</strong> — includes code comments, architecture notes, and developer guides.</li><li><strong>Quality assurance docs</strong> — cover testing plans, cases, and traceability matrices.</li><li><strong>User documentation</strong> — guides end users with tutorials, FAQs, and manuals.</li></ol><p>Then there are <strong>SOPs (Standard Operating Procedures)</strong> — the step-by-step guides that make internal processes repeatable.</p><p>Think of them as a company’s playbook for common but complex tasks, such as merging branches or deploying new builds.</p><p>Keeping documentation <strong>up-to-date</strong> is essential. When software evolves, outdated docs cause confusion, failed onboarding, and poor user experience.</p><p>That’s why documentation reviews and updates are part of the <strong>maintenance phase</strong> of any healthy <a href="https://medium.com/the-software-engineers-path/the-six-phases-of-the-sdlc-a-fast-practical-guide-d98fd6d80fbb">SDLC</a>.</p><blockquote>In short: documentation isn’t overhead — it’s operational clarity. It keeps teams aligned, systems maintainable, and users empowered.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99fa4f434760" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/what-every-engineer-should-know-about-software-documentation-99fa4f434760">What Every Engineer Should Know About Software Documentation</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Practical Software Versioning (3-minute read): what ^, ~, x, and comparators really do]]></title>
            <link>https://medium.com/the-software-engineers-path/practical-software-versioning-3-minute-read-what-x-and-comparators-really-do-8469288501c1?source=rss----f75ff23c6ffa---4</link>
            <guid isPermaLink="false">https://medium.com/p/8469288501c1</guid>
            <category><![CDATA[software]]></category>
            <category><![CDATA[semver]]></category>
            <category><![CDATA[calver]]></category>
            <category><![CDATA[version-control]]></category>
            <dc:creator><![CDATA[Gerardo Perrucci]]></dc:creator>
            <pubDate>Wed, 12 Nov 2025 11:29:55 GMT</pubDate>
            <atom:updated>2025-11-12T11:29:53.868Z</atom:updated>
            <content:encoded><![CDATA[<p>Shipping software is mostly about managing change. Version numbers encode <em>how much</em> changed; range syntax in package.json encodes <em>how far</em> your app is allowed to drift when you run npm install. Here’s a tight, example-first guide you can use today.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qxK8tUq0jj8kJm7BDQPhrA.png" /></figure><p><strong>Read the full deep-dive:</strong><br> <a href="https://www.gperrucci.com/en/blog/engineering/practical-software-versioning-package-json-ranges">Practical Software Versioning — and exactly how </a><a href="https://www.gperrucci.com/en/blog/engineering/practical-software-versioning-package-json-ranges">package.json ranges work</a></p><h3>The schemes you’ll actually meet</h3><p><strong>Semantic Versioning (SemVer)</strong> uses MAJOR.MINOR.PATCH[-pre].</p><ul><li><strong>MAJOR</strong>: breaking API.</li><li><strong>MINOR</strong>: new features, backward-compatible.</li><li><strong>PATCH</strong>: fixes, backward-compatible.</li><li><strong>Pre-release</strong>: -alpha, -beta, -rc.1 for unstable builds.</li><li><strong>Special rule:</strong> before 1.0, <strong>any</strong> bump can break (0.x is unstable).</li></ul><p><strong>Calendar Versioning (CalVer)</strong> encodes time (e.g., 24.10). It’s great for platforms and CLIs where <em>freshness/cadence</em> is the main promise—not API stability.</p><p><strong>Which to use?</strong> Libraries that promise an API should prefer SemVer. Products with time-based trains can choose CalVer or fast majors.</p><h3>What package.json ranges actually allow</h3><p>npm, pnpm, and Yarn all rely on node-semver. Think in intervals:</p><ul><li><strong>Exact pin</strong> — &quot;react&quot;: &quot;18.2.0&quot; → only 18.2.0.</li><li><strong>Caret </strong><strong>^</strong> — &quot;react&quot;: &quot;^18.2.0&quot; → &gt;=18.2.0 &lt;19.0.0. Safe within a major.</li><li><strong>Pre-1.0 nuance:</strong> ^0.2.3 → &gt;=0.2.3 &lt;0.3.0; ^0.0.3 → &lt;0.0.4.</li><li><strong>Tilde </strong><strong>~</strong> — &quot;axios&quot;: &quot;~1.7.2&quot; → &gt;=1.7.2 &lt;1.8.0. Patch-only.</li><li><strong>Wildcards</strong> — &quot;vite&quot;: &quot;5.x&quot; → &gt;=5.0.0 &lt;6.0.0; &quot;1.2.x&quot; → &lt;1.3.0; &quot;*&quot; → anything (don’t).</li><li><strong>Comparators</strong> — &quot;&gt;=1.2.3 &lt;2.0.0&quot; is explicit and readable.</li><li><strong>Hyphen ranges</strong> — &quot;1.2.3 - 1.4.5&quot; → &gt;=1.2.3 &lt;=1.4.5.</li><li><strong>Pre-releases</strong> — excluded unless your range <em>mentions</em> one. ^1.2.3 won’t pick 1.3.0-rc.1.</li></ul><p><strong>Lockfiles matter:</strong> package-lock.json / pnpm-lock.yaml / yarn.lock pin the <em>actual</em> tree. Use npm ci in CI to install exactly what’s locked.</p><h3>Minimal package.json you can reason about</h3><pre>{<br>  &quot;private&quot;: true,<br>  &quot;engines&quot;: { &quot;node&quot;: &quot;&gt;=18.17&quot; },<br>  &quot;dependencies&quot;: {<br>    &quot;react&quot;: &quot;^18.2.0&quot;,        // &gt;=18.2.0 &lt;19<br>    &quot;axios&quot;: &quot;~1.7.2&quot;,         // &gt;=1.7.2 &lt;1.8<br>    &quot;zod&quot;: &quot;3.23.8&quot;,           // exact<br>    &quot;vite&quot;: &quot;5.x&quot;,             // &gt;=5 &lt;6<br>    &quot;some-lib&quot;: &quot;&gt;=2.4 &lt;3&quot;     // explicit comparators<br>  },<br>  &quot;devDependencies&quot;: {<br>    &quot;typescript&quot;: &quot;^5.6.3&quot;,<br>    &quot;@types/node&quot;: &quot;20.11.x&quot;<br>  },<br>  &quot;overrides&quot;: {<br>    &quot;left-pad&quot;: &quot;1.3.0&quot;        // force a transitive<br>  }<br>}</pre><p><strong>Rules of thumb:</strong> apps use ^ plus a lockfile; sensitive deps use ~ or exact; libraries set <em>broad</em> peerDependencies (e.g., react: &quot;&gt;=18 &lt;20&quot;) and bump <strong>MAJOR</strong> on breaking changes.</p><h3>Common traps (and how to avoid them)</h3><ul><li><strong>Thinking </strong><strong>^0.x behaves like </strong><strong>^1.x</strong> — it doesn’t; it’s much tighter.</li><li><strong>Letting transitives break you</strong> — rely on the lockfile and use overrides/resolutions when needed.</li><li><strong>Expecting RCs to auto-install</strong> — they won’t unless you include a pre-release in the range.</li><li><strong>Forgetting peers</strong> — framework plugins should declare peers so the host app controls versions.</li></ul><h3>Monday-morning policy you can adopt</h3><ol><li><strong>Apps:</strong> default to ^, pin via lockfile, run npm ci in CI, and schedule weekly Renovate/Dependabot PRs.</li><li><strong>Sensitive deps (auth, crypto, build):</strong> use ~ or exact and upgrade deliberately.</li><li><strong>Libraries:</strong> broad peerDependencies, narrow direct deps, and semantic releases with clear changelogs.</li></ol><p><strong>Want the full playbook with more edge cases and guidance?</strong><br> ➡️ Read the full article:<br> <a href="https://www.gperrucci.com/en/blog/engineering/practical-software-versioning-package-json-ranges">https://www.gperrucci.com/en/blog/engineering/practical-software-versioning-package-json-ranges</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8469288501c1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-software-engineers-path/practical-software-versioning-3-minute-read-what-x-and-comparators-really-do-8469288501c1">Practical Software Versioning (3-minute read): what ^, ~, x, and comparators really do</a> was originally published in <a href="https://medium.com/the-software-engineers-path">The Software Engineer’s Path</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>