Understanding Engineering Code Updates

FHIR R6 is getting closer. The deadline for changes is November 1st - less than three weeks from now. If you’re currently invested in R4, how significant are the changes coming in R6? Here’s the current change log: https://lnkd.in/eCmkZDXC It’s a fantastic document, clearly outlining the changes to each resource and to each element. The color coding makes it easy to follow. - White for changes to elements - Green for new elements  - Blue for moved or renamed elements - Red for deleted elements and resources. What might these changes mean for your app or solution? - New elements (green) should not require much work. - Moved or renamed elements (blue) may require minor code changes.  - Deleted elements (red) will require bigger changes. Element changes (white) are easy to miss as their lack of color is suggestive of no change at all. But it’s in these elements that I feel the real work lies. Here’s a snapshot from the Encounter resource: https://lnkd.in/eJUwysuN Four codes were removed from Encounter status: arrived, triaged, onleave, finished. They’ve been replaced by four new codes with different meanings: on-hold, discharged, completed, discontinued. What does this mean for existing logic and data flows that depend on “triaged” or “arrived” statuses? Here’s another example. Encounter class’s cardinality was changed from 1..1 (mandatory) to 0..* (not mandatory and there can be more than one). If your app is relying on a single Encounter class always being there, then this is a big change that will require discussion with your consumers and data providers. It’s non-trivial. These changes are all being made for good reasons and after much debate, discussion and feedback. But this should not distract from the impact a migration from R4 to R6 will have on existing apps and solutions. Migrating will be more than just “updating code”.  Processes, data flows, logic, dependencies and expectations - all the way up and down the chain will have to change. It’s a very big deal. ~~~ I’ll be digging into this in more detail in my next Weekly FHIR Insights email: https://lnkd.in/eiXuewbp

🚀 "𝗖𝗮𝗻 𝘆𝗼𝘂 𝗷𝘂𝘀𝘁 𝗮𝗱𝗱 𝗼𝗻𝗲 𝗰𝗼𝗹𝘂𝗺𝗻?" Sounds simple... until you're the Data Engineer responsible for everything behind the scenes. 😄 The meme is funny because it reflects a real challenge in data engineering. Adding a single column isn't just a database change—it can impact the entire data ecosystem. Here's what experienced Data Engineers think about before making even a small schema update: 🔹 𝗦𝗰𝗵𝗲𝗺𝗮 𝗘𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 – Will the change remain backward compatible? 🔹 𝗘𝗧𝗟/𝗘𝗟𝗧 𝗣𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 – Will ingestion, transformation, or orchestration workflows break? 🔹 𝗗𝗼𝘄𝗻𝘀𝘁𝗿𝗲𝗮𝗺 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝗶𝗲𝘀 – Are reports, dashboards, ML models, or APIs consuming this data? 🔹 𝗗𝗮𝘁𝗮 𝗤𝘂𝗮𝗹𝗶𝘁𝘆 𝗖𝗵𝗲𝗰𝗸𝘀 – Do validation rules, constraints, or monitoring need updates? 🔹 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 – Will the new column affect query speed, storage, or partitioning? 🔹 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻 – Has the data catalog and schema documentation been updated? 🔹 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 – Has the change been validated across development, staging, and production? 💡 𝗙𝗼𝗿 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿𝘀: One of the biggest lessons in Data Engineering is that every data change has a ripple effect. Learning to think beyond the database table and understand the complete data pipeline will make you a far more effective engineer. 💼 𝗙𝗼𝗿 𝗪𝗼𝗿𝗸𝗶𝗻𝗴 𝗣𝗿𝗼𝗳𝗲𝘀𝘀𝗶𝗼𝗻𝗮𝗹𝘀: Building resilient, scalable pipelines isn't just about writing code—it's about designing systems that can evolve without disrupting business operations. A well-managed schema change today can save countless hours of troubleshooting tomorrow. 👉 What's the most unexpected issue you've encountered after a "small" schema change? Share your experience in the comments! 📩 Interested in building a career in 𝗗𝗮𝘁𝗮 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 or advancing your existing skills? 𝗙𝗲𝗲𝗹 𝗳𝗿𝗲𝗲 𝘁𝗼 𝗗𝗠 me for guidance on learning roadmaps, project ideas, interview preparation, cloud technologies, and career growth strategies. What technology or skill has been most valuable in your Data Engineering journey?

There is a critical realization that many software engineers overlook: the impact of data lineage on application code changes. This understanding is key for not only building robust applications but also ensuring that the data those applications handle remains trustworthy and reliable. Many SWEs are focused on ensuring their code runs efficiently and achieves its intended functionality. But here's the catch! As they implement changes or add new features, it’s essential to recognize that the underlying data can change as well. These shifts may not be immediately visible in the code, but they can significantly affect system performance and data quality for critical functions such as user management or payments. Here is a recent real-world example illustrating this. Remember when internet services had a massive outage last week due to a service within Cloudflare going down? These are the exact words from their subsequent RCA: "Workers KV is in the process of being transitioned to significantly more resilient infrastructure for its central store: regrettably, we had a gap in coverage which was exposed during this incident. Workers KV removed a storage provider as we worked to re-architect KV’s backend, including migrating it to Cloudflare R2, to prevent data consistency issues (caused by the original data syncing architecture), and to improve support for data residency requirements." The result was that "[during] the incident, Access failed 100% of identity-based logins for all application types, including Self-Hosted, SaaS, and Infrastructure." Think about the data your SWEs are indirectly handling via the code. Are they aware of how changes to data structures or formats might impact the way their application operates? If they're exclusively focused on code without considering the data it interacts with, they may inadvertently introduce bugs or inconsistencies that lead to significant downstream issues. When such applications struggle or break after implementing changes, it often stems from shifts in the underlying data that they weren't equipped to handle because they weren't monitoring lineage and how application code impacts such data. If the goal is to create resilient systems, then understanding and documenting how your application logic impacts data is crucial. Most data engineers are familiar with these challenges, but the conversation around data quality and lineage needs to be a two-way street. Software engineers must learn to engage with data considerations as part of their development process, as it's not just the responsibility of data teams. By incorporating the established practices of data lineage with the nuances of application code, SWEs can enhance the visibility of how changes affect both code and data. This includes establishing collaborative dialogues with data teams, running automated validations to detect data changes in advance, and being proactive about data quality. Good luck!

In a recent conversation with a telecom engineering team, they shared that their biggest pain point was not deploying new features. It was testing changes in a legacy billing system written in a mix of #COBOL and #ABAP. Every small update required weeks of regression testing because no one fully trusted the test coverage. Critical scenarios lived in production behavior, not in test suites. Teams relied on tribal knowledge and manual validation to avoid outages that could impact millions of customers. This challenge shows up across industries where systems have grown for decades under constant regulatory and commercial pressure. Automated testing struggles when the intent of the code is unclear. One learning we have seen at Adapts is that #AI can help teams reconstruct test intent from existing code paths and data flows. #Modernization becomes safer when testing is grounded in understanding, not guesswork. #LegacyCode #SoftwareMaintenance #SoftwareArchitecture #Code2Wiki #CodeKnowledge #SDLC

Google just released Code Wiki, and it turns any GitHub repository into living, auto-updating documentation. This feels like one of the first serious attempts at solving the problem of documentation constantly falling out of sync with code. What it does: -  Makes onboarding dramatically faster. A first commit on Day 1   becomes realistic. -  Saves hours of digging through large or unfamiliar repositories. -  Helps teams understand legacy systems without manually   reverse-engineering everything. How it works: -  Watches your repository and regenerates documentation automatically   on every commit. -  Uses a Gemini-powered chat agent that understands your entire   codebase contextually. -  Links every concept directly to the exact file, class, or function. -  Auto-generates architecture and sequence diagrams that stay synced   with the code. -  Works today for any public repository, with private repository   support coming via Gemini CLI. It is fully free during public preview. Link to Code Wiki: https://codewiki.google/ This feels like a major step toward instant codebase understanding, especially for teams managing complex or fast-moving systems. Share this with someone who works with large codebases. #AI #ArtificialIntelligence #LLMs #AIAgents #SoftwareEngineering #DeveloperTools #GitHub #Programming #TechInnovation #Startups

Don't ask a developer how many new lines of code they have written. Writing new code is easy-peasy...anyone can do it. But most code is rewritten soon enough anyway. In the real world, once you release code to production, it becomes gospel and you can't change it come what may. You have to always maintain backwards compatibility. You can't change the order of parameters. You can't change the parameter types. You can't change the outputs. In big companies, these codebases could run into tens of thousand of lines, very easily. Then you add on the complexity of such code over 10s of years, you now have hundreds of engineers who have come and gone, and have re-written the same piece of code over time so much that no documentation reflects that reality. This is truly the 99% of work that you would do as a engineer in most companies: understanding someone else's code and make it better and no documentation exists for that. Don't trivialize this work as code maintenance. It's much more than that. So, if you want to start showing your value as an engineer, show it in how quickly you are able to consume and understand someone else's code. Then modifying it and adapting it the future needs of the company. This is why companies pay big bucks for top engineers...because they can do what very few others can.

𝗧𝗵𝗲 𝗛𝗮𝗿𝘀𝗵 𝗧𝗿𝘂𝘁𝗵: 𝗗𝗲𝗹𝗶𝘃𝗲𝗿𝗮𝗯𝗹𝗲𝘀 𝗠𝗮𝘁𝘁𝗲𝗿, 𝗕𝘂𝘁 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗖𝗼𝗱𝗲 𝗠𝗮𝘁𝘁𝗲𝗿𝘀 𝗠𝗼𝗿𝗲 ⬇ As an intern in the world of software development, it's easy to fall into the trap of focusing solely on deliverables. With AI tools like Claude.ai, ChatGPT, and Gemini at our fingertips, completing coding tasks can seem deceptively simple. But there's a harsh truth we must face: while deliverables are important, they're not more valuable than truly understanding the code we're working with. 𝗧𝗵𝗲 𝗘𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 Last week, I was tasked with updating some existing code. It took me three hours, battling through errors, but I finally completed the update. I felt accomplished, but that feeling was short-lived. Yesterday, I received a similar task – updating code in different sections. As I dove in, I realized I needed to make changes to subsequent code as well. Unsure, I approached my colleague for guidance. As he started explaining the necessary changes, my mind went blank. I couldn't grasp what he was saying. His advice? "Please understand the code." That's when it hit me – I should have taken the time to truly comprehend the code when I first received the task last week. The realization was overwhelming, and I found myself in tears. 𝗧𝗵𝗲 𝗟𝗲𝘀𝘀𝗼𝗻 𝗟𝗲𝗮𝗿𝗻𝗲𝗱 This experience taught me a valuable lesson: When assigned a task, the first step should always be to understand the existing code thoroughly. Only then should we begin working on new features or modifications. Yes, it might take more time initially, but the benefits are immeasurable: 1. Increased confidence in your work 2. Simplified execution of subsequent tasks 3. Better communication with team members 4. Reduced likelihood of introducing bugs 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 𝗥𝗲𝗺𝗲𝗺𝗯𝗲𝗿: The fruits of understanding are truly fruitful. Here are some strategies to better comprehend code: - Read through documentation thoroughly - Use debugging tools to step through the code - Draw diagrams to visualize the code structure - Don't hesitate to ask for a code walkthrough from experienced colleagues 𝗬𝗼𝘂𝗿 𝗧𝘂𝗿𝗻 Have you been in a similar situation? Share your experience in the comments below. Let's learn from each other and grow as developers together! Can you resonate with this experience? How do you approach understanding complex code? Follow Jayanth Kothapalli for more insights into the world of coding and professional growth. #coding #understanding #ai #harshtruth #softwaredev #learningtocode