<?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[Stories by Mehmet KAYNAK on Medium]]></title>
        <description><![CDATA[Stories by Mehmet KAYNAK on Medium]]></description>
        <link>https://medium.com/@kaynakmehmet?source=rss-c32eae79acb5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Z0dXFuRce39_kz2Aj8vh-g.jpeg</url>
            <title>Stories by Mehmet KAYNAK on Medium</title>
            <link>https://medium.com/@kaynakmehmet?source=rss-c32eae79acb5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 23:00:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kaynakmehmet/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Entropy in IT Systems]]></title>
            <link>https://medium.com/@kaynakmehmet/entropy-in-it-systems-d8bddf22f8ab?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8bddf22f8ab</guid>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[itentropy]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[it-governance]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 21:53:23 GMT</pubDate>
            <atom:updated>2026-08-14T21:53:23.340Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://en.wikipedia.org/wiki/Entropy">Entropy</a> is the tendency of a system to progress from order to disorder over time in physics. In information world, it appears as a measure of uncertainty and complexity. In the IT world, entropy has a similar meaning: increasing complexity, inconsistency, and inefficiency over time in software, infrastructure, data, processes and organizational structure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q4_TwRcqFQH_IpXuARgmuA.png" /></figure><p><strong>Sources of Digital Entropy: Every Role Contributes</strong></p><p>Entropy is not the result of a single team or decision. It accumulates gradually in our daily ways of working, in the small compromises we make under the name of “quick fixes,” and in the changes we fail to document.</p><p><strong>Software Development Teams</strong></p><ul><li>Rushed development and releases under time pressure, incomplete testing and skipped code reviews.</li><li>Without coding standards and continuously deferred refactoring efforts.</li><li>Legacy modules that grow under a “it works, don’t touch it” mentality, understood by no one.</li></ul><p>Result: Software entropy. The system is still running, but every change becomes riskier, more expensive and slower.</p><p><strong>Network and Infrastructure Specialists</strong></p><ul><li>Undocumented firewall rules, “temporarily” opened ports, and access lists that never get closed.</li><li>Non-standard configurations and manual interventions without automation.</li><li>Emergency solutions becoming permanent, with questions like “who added this rule and why?” left unanswered.</li></ul><p>Result: Infrastructure entropy. Network topologies and configurations gradually turn into an unmapped labyrinth.</p><p><strong>Data and Database Specialists</strong></p><ul><li>Data models evolving without a plan with non-standard field additions.</li><li>Absence or non-enforcement of data quality guidelines.</li><li>Duplicate and inconsistent data sets with the same information defined differently across systems.</li><li><a href="https://medium.com/@murat_97687/backup-al%C4%B1yoruz-peki-geri-d%C3%B6nebiliyor-muyuz-2b215dde5f77">A backup is being created, but can we restore it?</a> Is it enough?</li></ul><p>Result: Data entropy. Inconsistent data. Reports no longer align, AI models produce unreliable results and regulatory reporting becomes risky.</p><p><strong>Test and QA Teams</strong></p><ul><li>Test strategies limited to functional testing with weak regression coverage.</li><li>Test automation left unmaintained; “the script doesn’t run,” but no one has time to fix it.</li><li>Test scenarios not synchronized with business processes, failing to capture real risks.</li></ul><p>Result: Erosion of quality assurance. Defects surface in production and costs multiply.</p><p><strong>Cybersecurity Teams</strong></p><ul><li>Rules opened with a “temporarily allow all” mentality becoming permanent.</li><li>Weak exception management and continuously stretched security policies.</li><li>Irregular patching and vulnerability scan results not turning into action.</li><li>Shadow IT and uncontrolled systems remaining outside security scope.</li></ul><p>Result: Security entropy. The attack surface grows, and eventually the weakest link in the chain breaks.</p><p><strong>Regulatory and Risk Management</strong></p><ul><li>Unclear process ownership with “who is responsible for this rule?” left unanswered.</li><li>Incorrect or incomplete logging and weak audit trails.</li><li>Data classification and retention policies remaining on paper, unimplemented in practice.</li></ul><p>Result: Compliance entropy. Audits produce findings, and fines and reputational damage become inevitable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NYa3MF7tY5OTxas5ztk0Kw.png" /></figure><p><strong>The Hidden Costs of Entropy</strong></p><p>Entropy accumulates silently, but its bill arrives loudly.</p><ul><li><strong>Operational costs:</strong> Incident counts rise, mean time to resolution increases. Dependency on super specialists grows. Teams spend all their time fighting fires, with no capacity for strategic work.</li><li><strong>Change costs:</strong> Adding new features becomes increasingly difficult. Even simple tasks require multiple systems and manual steps. The need for refactoring grows but is continuously deferred due to “no time.”</li><li><strong>Security and regulatory risks:</strong> Accumulated vulnerabilities, incorrect permissions, and missing logs turn into major crises during an incident. “No evidence” in audits means direct findings and penalties.</li><li><strong>Human factor:</strong> Team motivation declines. The “no one wants to touch this system” syndrome spreads. Critical systems become dependent on a single person; when they are on leave or leave the company, the organization is paralyzed.</li></ul><p>Consider a small example: In an e-commerce system, “small” integrations, manual batch jobs, and exception rules accumulate over the years. One day, a payment provider changes their API. Since no one fully understands all these dependencies, a simple change brings the entire order flow to a halt. The incident is resolved, but the real cost (loss of trust, operational burden, opportunity cost) is far greater.</p><p><strong>Through the Lens of Enterprise Architecture: System Entropy</strong></p><p>Enterprise Architecture (EA) is the discipline of ensuring alignment and consistency across strategy, business, application, and infrastructure layers. From an EA perspective, entropy is the uncontrolled evolution of these layers.</p><ul><li>Multiple systems for the same business capability, with similar but incompatible processes.</li><li>Fragmented integration topologies: each project “quickly” solves its own integration, with no standard patterns applied.</li><li>Overlapping competencies and responsibilities: it becomes unclear who decides what.</li><li>“Small” systems excluded from scope becoming critical over the years, yet never entering the architecture inventory.</li></ul><p>We can call this architectural entropy: uncontrolled evolution in business, application, and infrastructure layers, deviations from reference architectures, and inconsistent application of patterns. As a result, the gap between strategy and reality widens; IT investments stop supporting business goals and instead feed existing complexity.</p><p><strong>The Relationship Between Technical Debt and Entropy</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wj2cBkc9LvqjXWn4Q9NbsQ.png" /></figure><p>Technical debt is the accumulated result of short-term technical compromises, taken either consciously or unconsciously. Entropy is the potential of these compromises to create disorder in the system.</p><ul><li><strong>Conscious technical debt</strong>: Decisions like “let’s ship this feature quickly and fix it later.”</li><li><strong>Unconscious technical debt</strong>: Issues accumulated unknowingly, such as lack of standards, insufficient testing, and poor design.</li><li><strong>Software entropy (code rot, bit rot):</strong> Even without active development, systems degrade over time due to small patches, dependency updates, and environment changes.</li></ul><p>Technical debt and entropy reinforce each other: excessive debt increases disorder and unpredictability in the system; as entropy rises, paying down debt becomes more costly. The critical message for EA is that technical debt management is not just a development team issue — it is a core concern of corporate architecture and portfolio management.</p><p><strong>Control Points: Practices to Reduce Entropy</strong></p><p>Eliminating entropy entirely is impossible, but keeping it at a manageable level is achievable. Here are some practical control points for each area.</p><p><strong>Consistency and Standards in Architecture</strong></p><ul><li>Define reference architectures, reusable patterns, and technology/integration standards.</li><li>Make Architecture Review Board (ARB) and design review processes mandatory; reviews skipped for “fast-track projects” are the seeds of tomorrow’s major incidents.</li><li>Establish an exception management process: every deviation from standards must have a documented rationale, duration, and owner.</li></ul><p><strong>Software Development and QA Practices</strong></p><ul><li>Make code reviews part of your culture; use shared coding standards and automated quality metrics (static analysis, code coverage).</li><li>Keep CI/CD pipelines robust; no change should reach production without passing automated tests.</li><li>Manage regression tests strategically; treat test automation as a living asset that requires regular maintenance, not a “write once, done” task.</li></ul><p><strong>Infrastructure and Network</strong></p><ul><li>Use Infrastructure as Code (IaC) and standardized configuration templates; minimize manual configurations.</li><li>Implement automated configuration checks to detect non-standard changes early.</li><li>Take change management seriously; every change should have a rationale, risk analysis, and rollback plan.</li></ul><p><strong>Entropy Control in Data and AI Ecosystems</strong></p><ul><li>Establish a data governance framework: data ownership, quality rules, and metadata management.</li><li>Use standard patterns in data integrations; adopt the single source of truth principle.</li><li>In AI projects, manage data quality and model observability as entropy risks.</li></ul><p><strong>Security and Compliance</strong></p><ul><li>Apply security architecture principles, “secure-by-design,” and “privacy-by-design” from the start of projects.</li><li>Embed regulatory requirements into processes through continuous compliance and automated policy checks.</li><li>Take log and evidence management seriously: “No logs means no compliance; no compliance means penalties.”</li></ul><p><strong>Measuring Entropy: Metrics and Signals</strong></p><p>To manage entropy, you must first make it visible. Here are some practical metrics and signals:</p><ul><li><strong>Software and architecture:</strong></li><li>Mean time to resolution, defect rate per change.</li><li>Number of services and dependency graph density (how complex is the topology?).</li><li>Technical debt measurements, refactoring-to-feature ratio, documentation coverage.</li><li><strong>Data and processes:</strong></li><li>Data quality errors, duplicate record counts.</li><li>Percentage of processes requiring manual intervention, automation rate.</li><li><strong>Organizational signals:</strong></li><li>The same issues repeatedly causing incidents.</li><li>Critical areas dependent on a single person (“Only Ahmet knows this system.”).</li><li>Frequent use of phrases like “I don’t want to touch this system” within the team.</li></ul><p>As entropy increases, most of these metrics deteriorate. Creating an “entropy radar heatmap” that regularly tracks these indicators can be one of EA’s most powerful tools.</p><p><strong>The Cultural and Organizational Dimension</strong></p><p>Entropy is not only technical; it is also a cultural outcome.</p><ul><li><strong>Management entropy</strong>: Unclear goals, role and responsibility confusion, silo mentality, and short-term thinking all feed entropy.</li><li><strong>Product and project management</strong>: If refactoring, maintenance, and documentation items are not visible and planned in the backlog, entropy naturally increases.</li><li><strong>Reward systems:</strong> If only new features are rewarded while stability and quality remain invisible, teams are driven toward entropy-generating behaviors.</li></ul><p>Reducing entropy through tools and processes alone, without cultural change, is difficult. The value of “quality and sustainable systems” must be integrated into performance evaluations and reward mechanisms.</p><p><strong>An Action Framework for Enterprise Architects</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnPcAfjTR4mE8Tm6a8JDvQ.png" /></figure><p>Concrete roles for EA in combating entropy may include:</p><ul><li><strong>Entropy radar heatmap:</strong></li><li>Create an “entropy heatmap” for the application portfolio, integrations, data, security, and processes.</li><li>Visualize and communicate to management and teams which areas have reached critical entropy levels.</li><li><strong>Roadmap:</strong></li><li>Plan architectural initiatives that reduce fires in the short term and decrease complexity while increasing standardization in the medium to long term.</li><li>Prioritize technical debt reduction programs at the portfolio level by linking them to business value.</li><li><strong>Governance:</strong></li><li>Clarify architectural principles and establish an exception management process.</li><li>Communicate across the organization that architecture is not “paperwork” but a “decision-making mechanism.”</li></ul><p><strong>References</strong></p><p>· [1] Wikipedia. ‘Software rot.’ Available at: <a href="https://en.wikipedia.org/wiki/Software_rot">https://en.wikipedia.org/wiki/Software_rot</a></p><p>· [2] SonarSource. ‘Bit Rot: the silent killer.’ 2020. Available at: <a href="https://www.sonarsource.com/blog/bit-rot-the-silent-killer/">https://www.sonarsource.com/blog/bit-rot-the-silent-killer/</a></p><p>· [3] DX. ‘Code rot and productivity: When moving fast starts to cost more.’ 2025. Available at: <a href="https://getdx.com/blog/code-rot/">https://getdx.com/blog/code-rot/</a></p><p>· [4] IT Next. ‘Entropy — Why Code Rots And Technical Debt Grows.’ 2024. Available at: <a href="https://itnext.io/entropy-in-software-development-77ed9110ef28">https://itnext.io/entropy-in-software-development-77ed9110ef28</a></p><p>· [5] Boost. ‘Technical debt and entropy: what the laws of physics teach us about refactoring code.’ 2017. Available at: <a href="https://www.boost.co.nz/blog/2017/10/technical-debt-entropy-refactoring-code/">https://www.boost.co.nz/blog/2017/10/technical-debt-entropy-refactoring-code/</a></p><p>· [6] Geovation. ‘Technical debt and software entropy.’ 2024. Available at: <a href="https://geovation.uk/insights/technical-debt-and-software-entropy/">https://geovation.uk/insights/technical-debt-and-software-entropy/</a></p><p>· [7] Towards Data Science. ‘Why and How Software Systems decay.’ 2025. Available at: <a href="https://towardsdatascience.com/why-and-how-software-systems-decay-fa7ec83c4ff3/">https://towardsdatascience.com/why-and-how-software-systems-decay-fa7ec83c4ff3/</a></p><p>· [8] Rohan Gupta. ‘Technical Debt is Entropy In Software.’ 2024. Available at: <a href="https://grohan.co/2024/12/27/entropy/">https://grohan.co/2024/12/27/entropy/</a></p><p>· [9] Cloutier, R. ‘System Architecture Entropy.’ INCOSE, 2009. Available at: <a href="https://web.mst.edu/lib-circ/files/special%20collections/INCOSE/System%20Architecture%20Entropy.pdf">https://web.mst.edu/lib-circ/files/special%20collections/INCOSE/System%20Architecture%20Entropy.pdf</a></p><p>· [10] Simon Greig. ‘Architecture Entropy — IMHO.’ 2015. Available at: <a href="http://ibm.simongreig.com/2015/11/architecture-entropy.html">http://ibm.simongreig.com/2015/11/architecture-entropy.html</a></p><p>· [11] Schutz, A., Widjaja, A. ‘Complexity In Enterprise Architectures.’ Semantic Scholar. Available at: <a href="https://www.seman/">https://www.seman</a> ticscholar.org/paper/Complexity-In-Enterprise-Architectures-And-Of-A-A-Sch%C3%BCtz-Widjaja/23e69737b801c5586 3a18dd21d60c02a99a8d1c5</p><p>· [12] Ardoq. ‘Reducing IT Costs and Complexity With Enterprise Architecture.’ 2025. Available at: <a href="https://www.ardoq.com/business-outcomes/reducing-it-costs-complexity">https://www.ardoq.com/business-outcomes/reducing-it-costs-complexity</a></p><p>· [13] EAPJ. ‘Enterprise Architecture and Complexity.’ 2025. Available at: <a href="https://eapj.org/enterprise-architecture-and-complexity/">https://eapj.org/enterprise-architecture-and-complexity/</a></p><p>· [14] LinkedIn. ‘The Entropy of Automation: The Calculus of Predictability in Enterprise Architecture.’ 2026. Available at: <a href="https://www.linkedin.com/pulse/entropy-automation-calculus-predictability-enterprise-syed-faisal-ryxhf">https://www.linkedin.com/pulse/entropy-automation-calculus-predictability-enterprise-syed-faisal-ryxhf</a></p><p>[15] Yildiz, M. ‘Backup Aliyoruz, Peki Geri Donebiliyor Muyuz?’ Medium. Available at: <a href="https://medium.com/@murat_97687/backup-al%C4%B1yoruz-peki-geri-d%C3%B6nebiliyor-muyuz-2b215dde5f77">https://medium.com/@murat_97687/backup-al%C4%B1yoruz-peki-geri-d%C3%B6nebiliyor-muyuz-2b215dde5f77</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8bddf22f8ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Modernization Strategies]]></title>
            <link>https://medium.com/@kaynakmehmet/software-modernization-strategies-753ee72637e9?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/753ee72637e9</guid>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[strangler-fig-pattern]]></category>
            <category><![CDATA[legacy-modernization]]></category>
            <category><![CDATA[migration-strategies]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Sat, 22 Nov 2025 20:05:44 GMT</pubDate>
            <atom:updated>2025-11-28T18:35:54.240Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the key steps an organization takes in refreshing their technology in efforts to remain competitive is by modernizing old software to the cloud. The article discusses how to modernize outdated software for the cloud, the main risks involved, strategies for managing those risks, and various methods of migration.</p><p><strong>The Importance of Software Modernization and Cloud</strong> <br>Cloud computing offers flexible, scalable, and cost-effective infrastructures that enable organizations to easily adapt old software to fit the needs of modern business. With modernization, applications can be built more rapidly, be more secure, and need fewer resources for maintenance. Updates on cloud platforms often happen automatically, with high uptime and virtually unlimited storage.</p><figure><img alt="Software Modernization" src="https://cdn-images-1.medium.com/max/1024/1*OCnbjfAqUmOyDklIjT9ycA.png" /><figcaption>Ref : <a href="https://www.rinf.tech/legacy-app-migration-to-cloud-best-practices-and-considerations/">https://www.rinf.tech/legacy-app-migration-to-cloud-best-practices-and-considerations/</a></figcaption></figure><p><strong>Modernization Approaches</strong> <br>When moving software to the cloud, most organizations take one of three approaches:</p><p><strong>Rehosting (Lift and Shift):</strong> It involves transferring the application directly to the cloud. Quick but might not utilize complete cloud features.</p><p><strong>Replatforming:</strong> It means moving the application with some changes and optimization to the infrastructure. The effort required is moderate.</p><p><strong>Refactoring: </strong>This cloud-level technique calls for rewriting the code and architecture from scratch. It is the most expensive and labor-intensive option, but it provides the most value.</p><p><strong>Modernization Risks and Management </strong><br>Key risks associated with software modernization projects involve issues in data migration, security vulnerabilities, budget and timeline overruns, user adaptation challenges, and operational disruptions. In mitigating these risks, organizations should focus on thorough analysis, phased modernization, ongoing testing and monitoring, prepared rollback plans, extensive user training, and strong security measures.</p><p>Modernizing legacy applications for the cloud yields multiple benefits. Choosing the appropriate strategy and mitigating risk will help to drive project success. In most use cases, a phased migration method would be more flexible and contain less risk. Success will depend upon several critical factors during modernization: thorough analysis, careful planning, rigorous testing, and user training.</p><p>Best practices and steps for the migration of traditional systems to the modern cloud ecosystem to help organizations make their technology infrastructure sustainable and competitive include the following:</p><p><strong>* Full Assessment:</strong> Assess legacy systems in place, their interdependencies, how they align with cloud platforms, and what their operational requirements are. List possible risks, issues of data migration, and resources required to integrate.</p><p><strong>* Progressive Modernization:</strong> Plan a gradual migration by focusing on the most critical or easily separable components. This minimizes operational disruptions and lowers risks</p><p><strong>* APIfication and Wrappers:</strong> Provide communication between the legacy and cloud environments by wrapping up the features of the legacy system as APIs or using wrappers, adapters, and middleware. This decouples the systems so that they can work together without major changes inside.</p><p><strong>* ImplementIntegration Platforms:</strong> Make use of ESBs, iPaaS, or any other latest tool to integrate legacy systems with cloud systems to support seamless data and process flow.</p><p><strong>* Security and Compliance:</strong> Implement robust encryption, access control, and security models based on Zero Trust, while remaining compliant with all relevant data protection legislation.</p><p><strong>* Data Migration Planning:</strong> Provide detailed plans for data migration, covering secure data transfers, backups, and validation plans. Aim to minimize downtime and maintain data integrity throughout.</p><p><strong>* Testing and Validation:</strong> Test and validate the systems and integrations migrated in incremental fashion to reduce problems that may arise.</p><p><strong>* Observability and Monitoring:</strong> Leverage cloud-native monitoring solutions to keep track of performance, security, and reliability of both legacy and cloud components for continuous operational insights.</p><p><strong>* Resource Lifecycle Management:</strong> Optimize the utilization of resources through automation, including decommissioning when not utilized and scaling up or down depending on demand.</p><p><strong>* Training and Change Management:</strong> A well-prepared and educated team and stakeholders are capable of adapting to new processes, tools, and environments. It ensures business continuity and adoption with success.</p><p><strong>* Sustainability Strategy:</strong> Add sustainability to the plan by using green data centers, renewable energy, efficient virtualization/containerization, and tracking the improvement in carbon footprint as part of the cloud strategy.</p><p><strong>Migration Strategies: Phased vs. Big Bang </strong><br>Cloud migration essentially begins with the strategy that shall be used to shift applications from the legacy environment. There are two major approaches: Phased Migration and Big Bang Migration.</p><figure><img alt="Phased Migration" src="https://cdn-images-1.medium.com/max/1024/1*ZhcDxVgbbGnc2uk3o_S1_A.png" /><figcaption>Ref : <a href="https://slides.com/johann-peterhartmann/strangler-fig-pattern#/0/3">https://slides.com/johann-peterhartmann/strangler-fig-pattern#/0/3</a></figcaption></figure><p><strong>Phased Migration</strong> <br>In phased migration, the movement of applications, components, or data is done in distinct stages or modules. This gradual transition allows parts of the system to function in both the legacy and cloud environments at the same time.</p><p><strong>Pros</strong> <br><strong>* Lower risk:</strong> Problems can be identified early and resolved without affecting the entire system.</p><p><strong>* Easier Rollback:</strong> If a phase fails, only the migrated portion needs restoration.</p><p><strong>* Better business continuity:</strong> Core functions keep running during a time when parts of it are modernized.</p><p><strong>* Improved user adaptation:</strong> Gradual change allows employees to learn and adapt to new systems.</p><p><strong>Cons</strong> <br><strong>* Longer duration:</strong> The duration is longer, as the full migration can take months, or even years, needing continuous effort.</p><p><strong>* Added complexity:</strong> Integration with cloud and legacy systems increases the operational complexity.</p><p><strong>* Costs may rise:</strong> It may be expensive to run a parallel system for extensive periods of time.</p><p><strong>Big Bang Migration</strong> <br>Big bang migration means the entire system is shifted into the cloud in one go. The legacy platform is retired on a single cutover date, and all users make a switch to the new environment.</p><p><strong>Pros</strong> <br><strong>* Faster time to value:</strong> Enables everything to move quickly to the cloud for immediate access to its benefits.</p><p><strong>* Reduced parallel costs:</strong> Mean that older infrastructure can be shut down relatively quickly to reduce ongoing expenses.</p><p><strong>* Simpler planning:</strong> one-time transition, instead of complex multi-phase timelines.</p><p><strong>Cons</strong> <br>* <strong>Higher risk of failure:</strong> Problems can spread to the entire organization since there are large scales involved.</p><p><strong>* Difficult rollback:</strong> In case something goes terribly wrong, it may become difficult to rollback an entire legacy setup.</p><p><strong>* Greater resource demand:</strong> This kind of approach requires great preparation, testing, and support for successful transition.</p><p>The choice of strategy depends on system size, business importance, resource availability, risk tolerance, and company culture. For mission-critical or complex environments, phase migrations are often better. Big bang works rather for small and simple systems, or when quick changes are manageable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=753ee72637e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Value Of Application]]></title>
            <link>https://medium.com/@kaynakmehmet/value-of-application-20bb0a85c6c9?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/20bb0a85c6c9</guid>
            <category><![CDATA[enterprise-strategy]]></category>
            <category><![CDATA[assets]]></category>
            <category><![CDATA[cost]]></category>
            <category><![CDATA[application-value]]></category>
            <category><![CDATA[sync-with-business]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Fri, 06 Sep 2024 20:00:38 GMT</pubDate>
            <atom:updated>2024-09-06T20:00:38.923Z</atom:updated>
            <content:encoded><![CDATA[<p>Companies use applications written by IT or buy from anywhere or rent as a service to achieve their goal. How to check if an application is valuable or not? Measuring is important. Which items should be referenced to understand the level of value?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*nT2ALNycrr-qqh7QyyKoZA.jpeg" /></figure><p><strong>Compliant with Enterprise Strategy</strong></p><p>Companies expect to adapt applications with IT strategy. This strategy includes application development languages, environments, servers, databases, security standards, network rules, layers, some standards, etc. IT standards are compliant with company strategy. Applications which comply with IT standards are valuable assets. These standards are made up of easily manageable applications and go to company target.</p><p><strong>Cost</strong></p><p>An application should be run for company. It must earn income or serve in some service of a foundation. App resources should not be used more than necessary while running for the target of enterprise. Optimizing the development team process, writing efficient code, making proper configuration, managing efficient database connections, etc. are important.</p><p><strong>Eror Rate</strong></p><p>An application that runs for a company’s target must have a minimum rate of error. All possible problems such as program bugs, downtime of servers, not access to external systems, etc. should be considered. The structure must have a fault tolerance mechanism like a circuit breaker.</p><p><strong>Response Time</strong></p><p>The application must be finished with what it needs to do in an acceptable time. Slow service is one of the most important things which causes loss of customers in high competition.</p><p><strong>Maintainability</strong></p><p>Functions that exist should be changed fast and easily. Software architecture must be designed with flexibility.</p><p><strong>Being Synced with Business and IT</strong></p><p>One of the most important issues to be considered in large and old institutions is the sharing of information between business units and IT. In today’s world, where staff are changing rapidly, after a while even IT employees may not know how the application works. Or even if the IT side knows, the business unit side may be far from the subject. Defining Bounded Context, Domain Driven Design, brainstorming with IT and business together, courses understand each other and think the same thing. This subject should not be left to IT alone, the relevant business unit should also have a good grasp of the subject. Otherwise, unsuccessful communication, different worlds make it difficult to adapt, and inefficient organizations and processes emerge.</p><p><strong>Resolving Technical Debt Rate</strong></p><p>Fast developments always lead to new technical debt. Sometimes conditions arise so quickly that there is no escape. Tracking technical debts and cleaning them regularly will make the application more stable.</p><p><strong>Compliance with Regulators</strong></p><p>Every sector has to work with one or more regulatory institutions. Applications developed without taking into account frequently changing regulatory rules may cause more harm than good, as they may also result in sanctions.</p><p><strong>Security</strong></p><p>It is a must-have issue. A security vulnerability in an application does not only remain with that application, it can damage the reputation of your institution and cause major financial losses.</p><p><strong>Resiliency &amp; Reliability</strong></p><p>In case of a problem, it is very important for the customer experience that it is detected immediately and that there is no data loss. Minimum downtime (planned or not) is important.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20bb0a85c6c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Common Function Strategies at Microservices Architecture]]></title>
            <link>https://medium.com/@kaynakmehmet/common-function-strategies-at-microservices-architecture-0e1550c2b6a0?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/0e1550c2b6a0</guid>
            <category><![CDATA[polyrepo]]></category>
            <category><![CDATA[microservices-pattern]]></category>
            <category><![CDATA[common-functions]]></category>
            <category><![CDATA[sidecar-pattern]]></category>
            <category><![CDATA[microservice-strategies]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Sat, 06 Jan 2024 20:50:20 GMT</pubDate>
            <atom:updated>2024-01-06T20:50:20.055Z</atom:updated>
            <content:encoded><![CDATA[<p>Every architecture has its own character. When you adopt an architecture, doing it partially and not doing it justice may cause more harm than good. If you don’t do it well, it is possible to miss one of the biggest benefits granted by the related architecture. The result can be weird mix of parts, like Frankenstein’s monster. This is the case in every architecture, even in microservice architecture.</p><p>Microservice architectures have many advantages but also some disadvantages. Just like every coin has its reverse side. One of these disadvantages is where and how the common functions will be located.</p><p>While it is very simple and problem-free to write it somewhere in a monolithic structure and use it by others, it is a problem that needs to be managed in the microservice world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JGNPY8LdVTxlrd7Xk70LNw.jpeg" /></figure><p>There are same different approaches to solve this problem.</p><p><strong>Monorepo / Polyrepo / Git Submodules</strong></p><p>The structures that can host many projects connected to different code repositories in the development environment. Commonly used functions can be placed in separate projects and used by other projects. In this case, ide of developer has been integrated more than one code repositories.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*_wKaRNpdK1aY-craaoI1Qw.jpeg" /></figure><p>Common code can be used as a separate submodule. In this way, both the project being worked on and the module added as a sub-module can be downloaded locally and both can be changed at the same time. This solution allows the common project to be debugged locally. Possible problems can be examined locally, especially when the common code is changed.</p><p>What needs to be considered in this approach is managing the change of common codes. Transferring the changed code to the used structures is a process that requires great care, and if something is overlooked, untested scenarios may appear in the production environment. Common code is the easiest way to use and the most difficult to change management.</p><p><strong>Avoid Sharing Code</strong></p><p>It is undoubtedly the best choice if you can. In order to do this, the codes and responsibilities must be able to separate appropriately. If situation is that, common function problem is avoided.</p><p><strong>Manual Sharing (Code Duplicate)</strong></p><p>May not be when it was first written, but code duplicate is a difficult issue to manage in the long term. When a change is needed, it is necessary to change everywhere. The change in one project may not be simultaneous with the other. Moreover, the duplicated code may be forgotten after a while. It is not a recommended this method because it increases the maintenance cost too much. It can be considered as long as it is a very small piece of code and bears the maintenance cost.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/341/1*iOGg79pi2JP-lmET3XOTlA.jpeg" /></figure><p><strong>Package Manager Reusable Code as a Library</strong></p><p>Common code can be added to the project as a library like any open source jar, purchased jar or nuget package. Perhaps the most popular method for code sharing. The code to be shared is placed in a different project and the functions are made available in the project with package managers (npm, pip, maven, gradle,…).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/1*-h843wwUtJEFN6G_hZIXVg.jpeg" /></figure><p>What is critical here is the management of code library change. Any team should be responsible for this module, notify the teams using it when critical changes are required, and provide these teams with the opportunity to test. Prod transitions must be coordinated. Well-designed and automated tests will be of great benefit.</p><p><strong>Dynamic Code Injection at Runtime</strong></p><p>It can be used for frontends such as web components, it is practical. The embedded micro frontend can be compiled with dynamic code injection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*iAbtuUrUnfyj5omXRmjHNw.jpeg" /></figure><ul><li>The component must be managed in a backwards compatible.</li><li>Changes to components need to be tested through integration.</li><li>Communication should be standard between all components.</li><li>The advantage of this approach is that it does not require worrying about the internal properties of shared components.</li><li>New versions are easily available without requiring any additional effort during the build phase.</li><li>Related team should be responsible for this shared component for management.</li></ul><p><strong>Sharing Code as a Microservice</strong></p><p>There are situations where reusing code in libraries and components becomes difficult. Packaging a business logic particle with a high probability of change or extensive processes as a library or component will increase the difficulties of the change process.</p><p>A solution that can be considered when you have a business code that you cannot separate. When you use this solution, the most important thing to pay attention to is that the code runs and returns quickly. Because in this method, it is used the network to access the service. Applying different cache solutions can speed response up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*cZhKCp3z8FZ6LwWEtSmmjQ.jpeg" /></figure><ul><li>Common Function Service and consumer application could be written with different programming language. Because of the microservice runs as API, any consumer can use it without programming language limitations. Applications communicates over http.</li><li>It is easy to manage and there is no need to inform consumers unless there are significant changes.</li><li>Implementing complex business transaction services with persistent data is challenge. It is important to make service easier for consumer. Especially adaptable for Saga pattern and rollback services are critical.</li><li>It is easier to use for business logic that includes read operations.</li><li>Since service calls come via http, network problems that may occur should never be forgotten.</li><li>The responsible team have to consider the management of resources and optimize accordingly.</li><li>Each service can be written with different programming language.</li></ul><p><strong>Share Code with Sidecar Pattern</strong></p><p>If a cloud environment is used, there is another way to provide the common code as a service, the sidecar pattern. Applications reside in pods, and pods contain containers. There can be more than one container in a pod. The container that is added next to the main container in the pod is called a sidecar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/361/1*W8tiwHAcNd87LFzTstm8JA.jpeg" /></figure><ul><li>The advantage of presenting common methods that have been converted to microservices as sidecar containers is that the network cost is reduced because they are in the same container.</li><li>Using different programming language or technology for each component. This is especially true if the language is particularly strong in a required area (e.g. Python for Machine Learning or Go for too much IO works) or if an open source solution.</li><li>Ability to isolate fault situations in cases where transition from monolithic application to microservice is difficult</li><li>Fast, cheap and easy interactions between components or service calls between microservices, similar to those provided by libraries.</li><li>Since Sidecar resides in the same rendering environment , albeit usually in a separate container, it has lower latency than traditional service calls to “other” services.</li><li>It allows for ownership of service by individual teams and organizational scalability of a larger team.</li><li>It allows various shared-use components as a API to be published independently by teams.</li><li>If compare communication speed with calling method through memory , latency will increase. most applications use service call via interface (127.0.0.1)</li><li>Containerization leads to multiple copies of similar libraries and increased memory utilization for comparable operations relative to the use of libraries.</li></ul><p>Can be checked implementation of sidecar for aws and kubernetes from there :</p><p>Aws : <a href="https://aws.github.io/copilot-cli/docs/developing/sidecars/">https://aws.github.io/copilot-cli/docs/developing/sidecars/</a></p><p>Kubernetes : <a href="https://kubernetes.io/blog/2023/08/25/native-sidecar-containers/">https://kubernetes.io/blog/2023/08/25/native-sidecar-containers/</a></p><p>Although there are alternative solutions, common functions are a problem in the microservice world and there is no magic key to its solution. Every solution has pros and cons. The best solution is not to use it at all, but we all know that such a world does not exist. Since the main problem is that changes in common functions are reflected in the applications that use them, communizing the codes that will not change frequently can facilitate the change process. Most important thing while common function change managing version ( api or package). Using <a href="https://semver.org/">semantic versioning</a> is usefully and suggested.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e1550c2b6a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Events vs Message Queue]]></title>
            <link>https://medium.com/@kaynakmehmet/events-vs-message-queue-4a43d568f3d0?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a43d568f3d0</guid>
            <category><![CDATA[event-management]]></category>
            <category><![CDATA[events]]></category>
            <category><![CDATA[message-queue]]></category>
            <category><![CDATA[event-planning]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Fri, 21 Jul 2023 19:32:20 GMT</pubDate>
            <atom:updated>2023-07-24T06:10:51.544Z</atom:updated>
            <content:encoded><![CDATA[<p>Decide of something is difficult sometimes. Seesaw between two opinions make us hesitant like as a decide of using events or message queue.</p><p>It is possible to find easy that what is event bus or what is message queue on the net. Let’s focus what are differences.</p><h4>Events targeted general But Message Queue targeted Specific</h4><p>Events emitted from producer and than not interest consumers format. Fire and forget. But message for queue, format have to be same with queue expected. Similar to call any service which have to be known payload.</p><h4>Events has no recipient but Message Queue has a clear, addressable recipient</h4><p>Event is just put in some place but message for queue put to known address.</p><p>Saying something to your friend is message queue.</p><figure><img alt="Message Queue" src="https://cdn-images-1.medium.com/max/900/1*L_qM7tcEFI47CtMW5zsTXw.jpeg" /><figcaption>Message Queue</figcaption></figure><p>Making an announcement is event.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*VUWqFgqmeSzDvygrHMxOyw.jpeg" /><figcaption>Event</figcaption></figure><h4>Event is about something happened but message queue is about do something</h4><p>Event is a pure statement that something happened, but message queue is about do something with these parameters like as send Mail.</p><h4>Event has less data than Message Queue</h4><p>Event has a few data about something happened. These data for identify. Consumer can call other APIs to get detail if require. Message queue run with message parameters which all data included generally.</p><h4>Event is about state change but message is full data</h4><p>Event is ony about state change of something but message has a lots of data about something</p><h4>Event has multiple consumers but message queue is one</h4><p>Event is interested only emitted or not. It is possible one or many consumer. It is possible to multiple producer which put data to message queue but only one consumer read queue and do something.</p><h4>Event is decoupled but Message Queue is coupled</h4><p>Event isn’t know which consumers system read by. Thats why is decoupled. If using message queue is decided, message type have to be known and same.</p><h4>It is possible to miss event but Message Queue is guaranteed</h4><p>Every event has a same expire time. If consumer down while event live, it is possible to miss event. Message queue systems have a delivery guaranteed</p><h4>Event structure is more comlex than message queue</h4><p>Designing event structure is require work with complex system. Putting some event to same topic. Reading other system as a consumer. Deciding event types,… may be used event streams. Message queue system is basic. Define type. Put from anywhere to queue and read from queue. Not complex as event systems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a43d568f3d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Should Be Used Anti Corruption Layer]]></title>
            <link>https://medium.com/@kaynakmehmet/why-should-we-use-anti-corruption-layer-37ab38d19d89?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/37ab38d19d89</guid>
            <category><![CDATA[anti-corruption-layer]]></category>
            <category><![CDATA[service-design]]></category>
            <category><![CDATA[integration-services]]></category>
            <category><![CDATA[dependencies]]></category>
            <category><![CDATA[webapi]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Sat, 11 Mar 2023 21:00:38 GMT</pubDate>
            <atom:updated>2023-03-13T03:32:26.624Z</atom:updated>
            <content:encoded><![CDATA[<p>When a service integration is to be build, the first thing that the developer does on the caller side is to create the classes used in the service to be exactly the same, on the side to be called. Usually go to the swagger page of the relevant service and copy the model classes. The service to be called may be a rest service, soap service or another.</p><p>Creating exactly the same classes on the consumer side is actually connecting to this service from the hub. In this case, you not only bind yourself, but also create a dependency on that service.</p><p>You are directly affected when any parameter change in the called service. It can be said that the solution is to make the change at the same time with the relevant service. But it might not be easy to match it. The probability of deploy at the same time is not high.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*nm0H3eWlgNerugPiZXLjSQ.jpeg" /></figure><p>In fact, service integrations are like puzzles. They are unique, they only receive or return a particular payload. If you design an upstream, you know that there will be a lot of consumers, and you design accordingly. However, if you are on the downstream, connecting from the hub within your application means that you will have possible problems on future. A few parameter changes in the service you call may cause your application to crash. Therefore, it is necessary to do something to minimize dependency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*r-ndOrvrb1469eM7AH-Uig.jpeg" /></figure><p>The anti corruption layer protects your application from these changes, keeping you safe. What you need to do is to read the necessary data for yourself instead of creating the model classes from the upstream service.</p><p>The following snippet will cause you to connect from the hub. It is an example of a vulnerable situation in changes on the upstream side.</p><blockquote>Person p = restTemplate.getForObject(“http://localhost:8080/person&quot;, Person.class);</blockquote><p>The following piece of code is an example of a situation that keeps you safe and less affected by changes made on the upstream side.</p><blockquote>String p = restTemplate.getForObject(“http://localhost:8080/person&quot;, String.class);</blockquote><blockquote>final JsonNode node = objectMapper.readTree(p);</blockquote><blockquote>final String birthPlace = node.get(“birthPlace”).asText();</blockquote><p>It is not required to be build complex Anti-Corruption structures. The structure that protects the consumer from irrelevant field changes in the upstream service is sufficient.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37ab38d19d89" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Idempotent Long Term Applications]]></title>
            <link>https://medium.com/@kaynakmehmet/idempotent-long-term-applications-ec5292bdebe?source=rss-c32eae79acb5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec5292bdebe</guid>
            <category><![CDATA[idempotency]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[batching]]></category>
            <category><![CDATA[long-term-application]]></category>
            <category><![CDATA[software-design]]></category>
            <dc:creator><![CDATA[Mehmet KAYNAK]]></dc:creator>
            <pubDate>Wed, 19 Oct 2022 14:07:47 GMT</pubDate>
            <atom:updated>2022-10-19T14:16:58.645Z</atom:updated>
            <content:encoded><![CDATA[<p>Batch operations are data-intensive and sequential operations. Processes are made for thousands, millions of records. It is generally preferred at night because there is intense transaction and load resource consumption.</p><p>Batch applications with many records — although system usage is less at night — can cause problems because they consume a lot of resources. It can be prevent or delay the making of new deployments. It can also be an obstacle for situations such as hardware change, operating system update.</p><p>For batch operations, the first thing to consider should be whether it is really batch. There is no solution other than night for those who must be run after the date change. If it is possible to do it during the day, designing it to work during the day will lighten the burden of the night. Even asynchronous structures can be designed if the process takes a long time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/548/1*hdoWjRFAGrPM26N2QrGrhw.png" /></figure><p>Generally first think came to mind is speed when was talked about batch applications. However, the concept of data integrity and <a href="https://en.wikipedia.org/wiki/Idempotence">idempotence</a> is also very important. All records should be processed as necessary. None of them should be passed without any action, or vice versa, the same action should not be performed multiple times.</p><p>Idempotence is the property of certain operations in mathematics and computer science whereby they can be applied multiple times without changing the result beyond the initial application. In computing science, an idempotent is one that has no additional effect if it is called multiple time with the same input parameters. If it is thought about batch application, it should be assumed possibility trying more than one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*ciPvC6P6H-Tnhw4SewqTOA.png" /></figure><p>There may be technical difficulties due to network, server, database, etc. while running batches. In this case, the unfinished batches are run again. If structure designed without considering the concept of idempotence, the same text message or email sending, credit card payments, daily fund accumulation may occur several times. Doing the same payment multiple time will not be welcomed by your customer. This may damage the reputation of the institution.</p><p>Testing processes are much more critical in batch development. Successful, rerun and failure scenarios must exist and must be run before each deployment. Such tests are usually done more carefully when the application is new and the batch is transferred to the prod environment for the first time. Because the eyes of the whole team are on the application that will work. However, as time passes, some details are forgotten, developers change, application ownership changes. Sometimes it is a small change doing in the application or sometimes it is deployed again because of changing any dependency. In this case, when the test of the rerun and fail scenarios is forgotten, the application is taken to the prod environment as a bomb ready to explode.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*5VdeHFJmx5ixrHvgXkrLaQ.png" /></figure><p>Reference : <a href="https://en.wikipedia.org/wiki/Idempotence">https://en.wikipedia.org/wiki/Idempotence</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec5292bdebe" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>