<?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[Cloud Journey Optimization - Medium]]></title>
        <description><![CDATA[Large organizations continue to leverage more and more cloud technology. This publication contains articles related to application modernization, operating model, and cloud platforms with emphasis on things that evolve from present state as the cloud journey continues. - Medium]]></description>
        <link>https://medium.com/cloud-journey-optimization?source=rss----5d3dba44a6b4---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Cloud Journey Optimization - Medium</title>
            <link>https://medium.com/cloud-journey-optimization?source=rss----5d3dba44a6b4---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 02:46:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/cloud-journey-optimization" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Can I get Rid of my Enterprise Service Bus?]]></title>
            <link>https://medium.com/cloud-journey-optimization/can-i-get-rid-of-my-enterprise-service-bus-f40b90008b4a?source=rss----5d3dba44a6b4---4</link>
            <guid isPermaLink="false">https://medium.com/p/f40b90008b4a</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[integration-architecture]]></category>
            <category><![CDATA[application-modernization]]></category>
            <category><![CDATA[enterprise-service-bus]]></category>
            <dc:creator><![CDATA[Eric Herness]]></dc:creator>
            <pubDate>Tue, 04 Feb 2025 22:22:18 GMT</pubDate>
            <atom:updated>2025-02-04T22:22:18.689Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Target audience: Application modernization executives and enterprise architects who find themselves with a large portfolio of custom applications that include and leverage ESBs and other middleware.</em></p><p>As application modernization programs and techniques evolve, and experiences in the industry grow, the discussion related to modernizing applications appropriately gets deeper into understanding the underlying middleware being consumed by the applications. Middleware accelerated development of many applications and contributed essential elements to the overall solutions. One middleware domain with a particular role that needs more in-depth study is that of Enterprise Service Buses.</p><p>Enterprise Services Buses (ESBs) were all the rage in 2005 and remain an integral part of many architectures that are supporting business processes in large organizations. My personal history leaves me most knowledgeable about those ESBs with IBM DNA such as WebSphere Enterprise Service Bus, IBM Integration Bus which evolved into IBM App Connect Enterprise, and WebSphere DataPower. That said, it was an era with many strong offerings that provided a lot of value to those that wished to consume them for the things that they were good at. The basic pattern of these ESBs was that of connecting consumers of services with providers of services and ultimately performing actions ‘in the middle’. These actions allowed for easier reuse and consumption of disparate services by mediating differences between that of the service consumers and the service providers as shown in figure 1.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/1*4vyIyvBSOog9_dXjL-i0ng.png" /><figcaption>Figure 1 — Remembering the Basic ESB Architecture</figcaption></figure><p>This blog will go over some things to evaluate and think about as you contemplate how to disposition your ESB. My first message is that the more you can understand what the in-use ESBs are doing, the more likely you will properly decide your path forward.</p><h3>How we got here</h3><p>The <strong>role of the ESB</strong> was supposed to be that of making it easier to connect disparate systems together. This need was acute back in the day, because new front ends were being create that needed to connect to what was commonly many different backend systems. The front ends spoke one set of technologies and the backends spoke another. ESBs were supposed to deal with the various communications protocols and transports, data representation techniques, security handshakes and more. For example, the HTTP/HTTPS protocols were prevalent in the web applications serving the front ends while SOAP, RMI/IIOP, CTG, MQ and others were used to connect to application servers doing middle-tier business transactions as well as connecting mainframes that had the super necessary back-office business logic. For data representation, the front ends liked either XML (earlier) or JSON (later) while backends dealt with COBOL, SQL or native Java datatype representations. Web Services and WSDL, when they came along, provided a polyglot interface model with XML as the data representation. You get the idea.</p><p>ESBs got extended to do even more than protocol, data and security. There was service location and routing, which often connected to service registries and allowed a dynamic routing approach. There was also caching and light-weight orchestration. That was okay and quite valuable, up to a point. In my experience, ESBs that tried to go beyond these basics and wanted to be transaction managers and hold business logic got out of their sweet spot. While I stood by the thesis of using ESBs to separate business logic from integration and connectivity logic, implementations were often not nearly so clean, and often by necessity.</p><p>To summarize, it was very common to see an ESB mediation deal with:</p><p>1. Single Sign-On (SSO) — such as mediating from modern tokens such as OpenID Connect (OIDC) or OAuth2 to an older token such as LTPA.</p><p>2. Mapping from one protocol and/or transport to another</p><p>3. Interface and data transformation and augmentation (think XSLT for the data)</p><p>It was also reasonably common to see ESBs enlisted to do things like:</p><p>· Results caching</p><p>·Basic service lookups and routing as well as content-based routing</p><p>· Service orchestration (think fan-out, fan-in to start)</p><p>I can assure you that some sophisticated capabilities existed in ESB middleware to make all this work and more. Context propagation across protocols, including transaction context and security context is complex. Then there’s the mixing and matching of various asynchronous and synchronous protocols to make it even a bit more exciting. All of this was done with interceptors, headers and done by code that service providers and consumers didn’t have to write.</p><p>The role of the ESB also then implicated where it would run. Which firewalls was it behind? This got interesting. Some organizations mandated that all calls to the mainframe would go through the ESB. Others mandated that all calls to any backend coming in from all Business-to-Consumer (B2C) channels would go through the ESB.</p><p><strong>Challenges</strong> emerged as the ESB approach was implemented by large organizations. Most of these challenges dealt with reliability and scalability. ESBs were a new tier in the architecture. That was initially fine and was made to scale using typical HA techniques. But like application server farms that hosted 100’s of applications, ESBs that had 1000’s of mediations running in them had all sorts of noisy neighbor problems. Too much ‘shared’ stuff, if we look back now.</p><p>A couple of other challenges need mentioning as well. To manage an ESB as a corporate shared service, you had a large control plane, a large organization to support that, and an operating model that often got in the way. I can tell you too many stories about projects that decided to bypass the ESB and go directly to the mainframe, because they couldn’t wait for the ESB developers to provide a new mediation, or they couldn’t afford the extra hop on the way to the business service they wanted from that backend system.</p><p>The final thing I will mention is around standardization. ESBs just didn’t have a single accepted, complete standard form for specifying a mediation or as some would say, a service model. Sure, WSDL interfaces were commonplace, but the framework to transfer context between them was not unless everything was SOAP/HTTP. That was never the case. There was also no standard for mediation flows. Some attempts were made to fix these challenges back the day but never reached enough market presence. Long live Service Component Architecture (SCA). Vendor specific creativity and the related lock-in ruled.</p><h3>Looking Forward</h3><p>Get rid of that ESB, sure, let’s do it. But here are the things to pay attention too and some guidance to consider.</p><p>1. <strong>Know exactly what your ESB is being used for.</strong> Watch out for those ‘custom’ nodes in ESB flows that are written in Java, ESQL, C, C++ and other languages that allow all kinds of things to be done. Assess this code just like you assess application code. These custom nodes are like stored procedures in databases, you never know what you might find, but it is seldom something that makes modernization easier.</p><p>2. <strong>Make your API manager your friend</strong> — What do we mean by this? API Managers can generally do some of the core things that an ESB did.</p><p>a. Choose one that does protocol/transport transformation, security tasks and data transformation and does so in a way that doesn’t take a lot of programming. Shoot for ‘configure’ versus writing custom code.</p><p>b. Don’t over-commit your API manager and expect to take on complex tasks like transaction context propagation, interaction style impedance matching or workflow management.</p><p>c. Run your API manager either as a cloud-provider managed service (preferred) or in a container (in Kubernetes). You don’t want another control plane. That said, cloud provider-based API managers are not likely to have as many features as those API managers that come from 3rd parties that have long histories in this domain. In many ways, the cloud provider API managers are optimized to net new cloud native microservices based applications.</p><p>d. Modern APIs use keys. API managers can help to provide interface to consumers and deal with some of the legacy issues, such as SSO mediation.</p><p>3. <strong>Don’t undertake an infrastructure-led project to remove your ESB.</strong> Make this evolution part of your application modernization approach. The applications probably are going to have to change to remove your ESB. The only way that happens is if the application owners are funding some modernization activities that have positive business impact. Remember, the ESB let the developers of applications write less code, so those developers must be a part of the modernization away from a traditional ESB.</p><p>a. If an application is tagged for a “re-imagine” or “refactor” then removing the ESB dependency is likely the right move.</p><p>b. If the application modernization technique is “containerize”, then keep your ESB but consider a containerized version of that as well.</p><p>c. If you really want or need to modernize your ESB, possibly reducing cost, without a lot of application involvement, then containerization is another option.</p><p>To finish this section, let’s organize the things ESBs were used for and how we “replace” them in a world without a formal traditional ESB.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*8dua96y__xpIZHiPt_0vMg.png" /><figcaption>Figure 2 — From ESB to the Cloud</figcaption></figure><p>There are a few themes and recommendations to be taken from this figure. First, given that I’ve recommended that the ESB question be answered in conjunction with other application modernization efforts, we assume that a modernization effort will leverage Kubernetes with a service mesh and possibly serverless as well as cloud provider managed services as needed.</p><p>Given that assumption, it is recommended to prefer those built-in managed capabilities from your cloud provider. If your organization is focused on a multi-cloud (and I mean multi-public cloud here) strategy, and/or already has a 3rd Party API manager, that’s good to use as well.</p><p>Try not to drag in special new frameworks, but if there are frameworks being used already in conjunction with any net new microservices projects going on in your organization, they might offer some relief for modernization of some of these old ESB usages.</p><p>“Other” from the figure is where the assessment will help. Some of these other things will be covered in a declarative way, with API managers, service meshes and other frameworks. Lean in that direction and use ‘custom code’, which likely means a special purpose microservice, sparingly. Think hard as you go through these “other” situations to make the solution as <a href="https://medium.com/cloud-journey-optimization/what-is-a-future-proof-information-technology-architecture-an-application-centric-view-3c99301e0e3a">future-proofed</a> and standardized as possible. Keep that business logic separate from any connectivity and integration logic you find that needs modernizing. Think about what might change over time and how you can make that happen easily, using configuration approaches wherever possible rather than hard coded conditionals.</p><h3>What can be gained?</h3><p>The advantages of getting rid of that ESB are as follows:</p><p>1. <strong>No separate control plane to manage</strong> — These capabilities still need to be observed, tuned and configured, but this will now be done with via using capabilities provided by the cloud provider managed services and the underlying public cloud capabilities or via a Kubernetes model.</p><p>2. <strong>No separate infrastructure to scale</strong> — Again, cloud provider managed services and Kubernetes both have well established models for scaling and availability.</p><p>3. <strong>Similar or better future development velocity</strong> — Developers will leverage concepts they are already familiar with when doing microservices development (containers, Kubernetes, API managers) and are in a world of DevOps automation, both of which contribute to improve development velocity.</p><p>4. <strong>Improved configuration and observability </strong>— Using a cloud-provider managed service for your API management needs enables easy (no code) configuration of things like rate limiting and result caching, and enables improved observability by feeding logs, metrics and other telemetry to the cloud-provider monitoring platform such as CloudWatch or Azure Monitor.</p><p>The advantages above are focused on technical and operational elements as well as the alignment of overall technical architecture. There are financial benefits to consider covering both operational costs as well as software licensing cost. This can be significant, again, depending on how much kit is in place to support the current ESB.</p><h3>Conclusion</h3><p>ESBs are used for a lot of things, many of which have been elaborated upon and discussed in this article. The capabilities provided by ESBs can be replaced, usually by similar capabilities available in modern cloud-based environments. Do this replacement as part of an overall application modernization effort if your modernization approach allows for this. Assess your ESB mediations as you would any application source code. Leverage cloud-provider managed services, container-based integration and connectivity capabilities as well as the declarative model to replace those things the ESB was doing. In the end, the overall architecture and operational complexity should be reduced. This should leave your organization with a more <strong>future-proofed environment</strong>.</p><p>Thanks to <a href="https://medium.com/u/a8700b2ca6a4">John Alcorn</a> and <a href="https://medium.com/u/7c11350cf2b6">Ryan Claussen</a> for their review and contributions to this article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f40b90008b4a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/cloud-journey-optimization/can-i-get-rid-of-my-enterprise-service-bus-f40b90008b4a">Can I get Rid of my Enterprise Service Bus?</a> was originally published in <a href="https://medium.com/cloud-journey-optimization">Cloud Journey Optimization</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bridging the chasm between Cloud-Native and the Mainframe]]></title>
            <link>https://medium.com/cloud-journey-optimization/bridging-the-chasm-between-cloud-native-and-the-mainframe-b87a2ed77742?source=rss----5d3dba44a6b4---4</link>
            <guid isPermaLink="false">https://medium.com/p/b87a2ed77742</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[mainframe-modernization]]></category>
            <dc:creator><![CDATA[John Alcorn]]></dc:creator>
            <pubDate>Mon, 25 Mar 2024 02:57:05 GMT</pubDate>
            <atom:updated>2025-02-02T17:23:44.658Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bridging the chasm between Cloud-Native and the Mainframe, Part 1</h3><p><strong>Introduction</strong></p><p>The Cloud Journey Optimization Team spent much of 2023, and the first quarter of 2024, increasing our hands-on work with and deepening our focus on mainframe modernization. To expand upon our <a href="https://medium.com/cloud-journey-optimization/mainframe-modernization-an-application-centric-approach-754ab1358605">inaugural post</a>, sometimes that means “modernize on” (remaining on the mainframe, but using modern devOps, recompiling to get various optimizations, and cost savings such as leveraging ZIIP processors where possible, among other things), sometimes it is an “integrate with” play (doing some work in the cloud, but calling back to the mainframe for the “crown jewels” routines), and sometimes a full “move off” (evacuating the mainframe, including migrating COBOL and other legacy languages to Java or other modern languages). In this series of articles, we’ll focus on the “integrate with” approach, using our Stock Trader application in Azure with some business logic that lives on the mainframe.</p><p>As some background, we had previously (in 2022) done some simple work with Kyndryl’s <a href="https://www.kyndryl.com/gb/en/services/core-enterprise-zcloud"><em>Core Enterprise and zCloud Services</em></a><em> </em>team to test out having Stock Trader running in Azure, but delegating to their mainframe in zCloud as its System of Record (SOR). Specifically, that meant getting a VPN setup so that our Portfolio microservice could make JDBC calls to <em>IBM Db2 for z/OS</em> as its relational database. We’ll talk more about that networking setup in a future article in this series. This figure shows the basics of what we’d gotten working in 2022:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2aey5WOyj2TUgaqOI1eDHw.png" /><figcaption>Stock Trader with its System of Record on the Mainframe</figcaption></figure><p>Another thing we did in 2023 was creating a new Spring-based microservice for Stock Trader called Cash Account (at <a href="https://github.com/IBMStockTrader/cash-account">https://github.com/IBMStockTrader/cash-account</a>). Our intern <a href="https://medium.com/u/d38fbd21d19e">Celina Chen</a> wrote it, and I wired up my Broker microservice to debit it for the total cost of any stock bought, and to credit it for the total cost of any stock sold. It uses JDBC to store the cash account balance (like to <em>PostgreSQL</em>), and keeps track of your local currency type, and does conversions to and from US Dollars (and keeps the exchange rate cached in <em>Azure Cache</em>). Celina wrote an <a href="https://medium.com/@celina.chen/integrating-a-currency-exchange-api-into-your-cloud-native-application-c95a47f9e24">article</a> about it before her internship ended.</p><p>Moving forward to more recent work, we worked with the <em>Core Enterprise and zCloud Services </em>team to create a <em>CICS</em>/<em>COBOL</em> implementation of Cash Account (at <a href="https://github.com/IBMStockTrader/cash-account-cobol">https://github.com/IBMStockTrader/cash-account-cobol</a>), that uses <em>DB2 for z/OS</em> and <em>VSAM</em>. It exposes a REST interface (the exact same <a href="https://github.com/IBMStockTrader/cash-account/blob/main/src/main/resources/api-docs.yaml">interface</a> as Celina’s Java Spring implementation) via <em>z/OS Connect</em> that is made available to the <em>Azure Kubernetes Service</em> (AKS)-based Stock Trader application via <em>Azure API Management</em>. We also set up security, which we’ll discuss in detail in a future article in this series, so that login would occur against the <em>IBM Resource Access Control Facility</em> (RACF<em>)</em> user registry on the mainframe. The following figure shows Stock Trader in Azure integrating with this COBOL-based business logic and the user registry on the mainframe:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oRFHhbvmfz44CWmS9kWVYw.png" /><figcaption>Stock Trader integrating with COBOL business logic on the mainframe</figcaption></figure><p>Of course, having the application on the cloud, but its system of record on the mainframe can have performance implications. Therefore, our next intern, Jaylon McShan, did considerable work doing <a href="https://github.com/rtclauss/loopr">Gatling-based stress testing of Stock Trader</a> in various configurations. Each test simulated 100 concurrent users for 1 hour. The tests included having our Portfolio microservice use various databases, including <em>PostgreSQL</em> or <em>Microsoft SQL Server</em> in Azure, as well as <em>IBM Db2 for z/OS</em> on the mainframe, and with the mainframe-based <em>CICS</em>/<em>COBOL</em>/<em>DB2/VSAM</em> flavor of Cash Account added in. Of course, we saw longer response times once we included trips from Azure <em>us-east</em> to the mainframe in <em>zCloud</em> (the physical location is in Brazil — round trip ping time averages about <strong>125 ms</strong>):</p><figure><img alt="Response time across various databases" src="https://cdn-images-1.medium.com/max/1024/1*8apn1niiH6SmWp0UnYgy8g.png" /><figcaption>Response times across various options for the System of Record</figcaption></figure><p>We were pleased that, even the most sophisticated “integrate with” scenario, including <em>IBM z/OS Connect</em> and <em>CICS</em>/<em>COBOL</em>, resulted in sub-second response times. That said, it is still significant that mean response times roughly tripled, so in a future article in this series we will explore the idea of keeping a replica of the data in the cloud, kept current with the “source of truth” on the mainframe via change-data-capture.</p><p>Another reason we did this work to make a CICS/COBOL version of Cash Account was so that we could run it through the various COBOL to Java mainframe modernization tools and compare the results across tools, and to our hand-written Spring version of Cash Account. Our team has invested considerable time becoming skilled in, and in some cases certified for, tools like AWS’s <em>BluAge</em>, Google’s <em>G4</em>, <em>Astadia</em>, <em>Heirloom Computing</em>, and Base100’s <em>Caravel</em>. We will explore this in further details in a future article in this series.</p><p>Note that while we did most of our work in Azure, we did also set this up in AWS as well, using its <em>Elastic Kubernetes Service</em> (EKS), <em>Relational Database Service</em> (RDS), <em>ElastiCache</em>, <em>Lambda</em>, and a VPN connection to the same mainframe in zCloud, with the appropriate firewall setup, etc. All worked well running the same tests, including use of <em>IBM DB2 for z/OS</em> and <em>IBM z/OS Connect</em> to talk to the <em>CICS</em>/<em>COBOL</em> version of Cash Account, from AWS.</p><p>To summarize, we spent much of 2023, in between customer engagements, teaching ourselves about mainframe modernization. While much of this involved learning about tools from our various partners, it also meant expanding our cloud-native application to integrate with resources on a mainframe maintained by our <em>Core Enterprise and zCloud Services </em>colleagues. We’ve gained considerable experience “integrating with” an SOR on the mainframe, have learned about exposing COBOL-based business logic to be called from a microservices-based application on the cloud, and have done security integration. We will discuss these topics further in future articles in this series.</p><p>As always, we stand ready to work with anyone interested in embarking on such a mainframe modernization journey, informed by what we have learned over the past year. Thanks for your time, and feel free to leave comments on what you’d like to see next in future articles in this series!</p><p>Thanks to <a href="https://medium.com/u/d9a26fc6328f">Eric Herness</a> for his review of this article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b87a2ed77742" width="1" height="1" alt=""><hr><p><a href="https://medium.com/cloud-journey-optimization/bridging-the-chasm-between-cloud-native-and-the-mainframe-b87a2ed77742">Bridging the chasm between Cloud-Native and the Mainframe</a> was originally published in <a href="https://medium.com/cloud-journey-optimization">Cloud Journey Optimization</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is a Future Proof Information Technology Architecture? An Application-Centric View]]></title>
            <link>https://medium.com/cloud-journey-optimization/what-is-a-future-proof-information-technology-architecture-an-application-centric-view-3c99301e0e3a?source=rss----5d3dba44a6b4---4</link>
            <guid isPermaLink="false">https://medium.com/p/3c99301e0e3a</guid>
            <category><![CDATA[solution-architecture]]></category>
            <category><![CDATA[application-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[application-modernization]]></category>
            <dc:creator><![CDATA[Eric Herness]]></dc:creator>
            <pubDate>Fri, 23 Feb 2024 23:16:22 GMT</pubDate>
            <atom:updated>2024-02-23T23:16:22.778Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CDdgx-DqRMxgI7WrIH5Pqw.png" /></figure><h3>Introduction</h3><p>I get asked a lot these days about what it means to create a ‘future proof’ architecture. This occurs for several reasons, not the least of which is that business and information technology (IT) executives are looking for ways to get more innovation and business value from their IT spend, versus the constant pay out required on things like maintenance and modernization. We obviously spend a lot of time in IT these days on the topic of modernization, which might be fancy words for paying off technical debt. While I like modernization, especially application modernization, I agree that putting more money on innovation that creates business value is top of mind in the C-suite. It should be. And it doesn’t matter what it is called.</p><p>This blog will cover some of my perspective on future proof architectures. Frankly, this is a bit more of a stream of thought than it is something I’ve researched and thought through completely. For the most part, I’m letting my 35+ years of experience in the IT industry be bedrock for my treatise on future proof architecture.</p><p>The first section asks the somewhat obvious question of why we need future proof architectures. Next, some broad principles are outlined and described. This is followed by introducing some<a href="#_msocom_2">[ENH2]</a> meatier and more technically backed topics. Then, there’s a quick reality check with some cost considerations. Future proof architectures are not free. This blog entry then ends by cross checking the guidance given against the reasons to consider this topic in general.</p><h3>Why Future Proof IT Architectures?</h3><p>Beyond the obvious stated in the introduction, we need future proof architectures so that applications:</p><p>1. can be quickly and safely enhanced to respond to <strong>new functional business requirements</strong>.</p><p>2. can be quickly repurposed or reprovisioned to <strong>serve new markets</strong> that have limited or different available building blocks.</p><p>3. can easily integrate and <strong>leverage new technologies</strong> and services that arise and present opportunity to further accelerate delivery of business value.</p><p>4. can <strong>scale, up and down</strong>, as market demand evolves.</p><p>5. can easily embrace and support <strong>new compliance and security requirements</strong> presented by evolving markets or different markets that are to be served.</p><p>If we look at the above list differently, it turns into the list of requirements a future proof architecture must meet. These are only some of the requirements. The playing field and thus requirements are constantly changing. New technology and new business requirements together, both influence the future proof architecture story.</p><h3>Applications are the Starting Point</h3><p>Yes, this is about enabling applications to be future proof. Applications need to respond quickly to the requirements laid out in the prior section. Thus, this isn’t necessarily about making infrastructure platforms generically future proof. That is the job of the cloud providers and others who intend to be IaaS/PaaS providers. If you work for a cloud provider or other platform provider, I will assert the future proofing task is harder. For everyone else, start with the applications. This notion onto itself might be a bit controversial in some circles, but that is my position.</p><p>Historically, there are applications out there that have run on multiple different bare metal operating systems, then on VMs and now in Kubernetes-based containers both on-premises and on various public clouds. In my decades working on WebSphere, I saw java and open standards-based application frameworks enable this future proof quality. Some of those old hardware platforms are long gone, while the applications chug away. Sure, there was technical debt to pay off as java and those frameworks evolved, but for the most part, it was a great way to get early access to new capabilities and more scalable architectures while minimizing the technical debt.</p><p>There is enough here to contemplate when taking this application-centric view. In some ways, the IaaS and the PaaS become highly reliable commodity components, that are necessary but not sufficient to declare that you have a future proof architecture. The discussion becomes more about how the applications leverage those components. Maybe I should have named this discussion something more linked to future proof applications guidelines? Maybe there is another blog entry on future proofing a PaaS/IaaS platform? But do not despair, the following sections will get quite precise on some PaaS topics, and we can argue later about whether they are application future proofing guidance or apply to PaaS services.</p><p>A first note on custom applications versus packaged applications — If you work directly with or for a large organization that has the classical set of applications that support the business, you are probably dealing with some combination of application types. Some are custom-built applications while the rest are either packaged applications, SaaS based business capabilities, or a blend of both packaged applications and SaaS based business capabilities. Most of what is described in this blog entry is targeted at those building custom applications. However, some of the topics do apply equally well to software architectures underpinning packaged applications or SaaS based business services.</p><p>To get this core topic properly addressed, the next section lays out some principles to follow when constructing a future proof architecture, while the section after that more prescriptively lays out some next level technical topics that ultimately meet the requirements of future proof architectures laid out above.</p><h3>Principles</h3><p>Principles, in this context are guiding lights and directions, more so than specific technical elements. In fact, as you will see some of these are even a bit distant from the technical. The foundational principles are:</p><p>1. Agile development</p><p>2. Culture of Automation and Self-Service</p><p>3. Open Source (community, supported distribution)</p><p>4. Buy versus Build</p><p>5. Conservation of Moving Parts</p><p>6. Evolution towards “Shared Nothing”</p><p>7. SRE and XLA Philosophy</p><h3>Agile development</h3><p>Embracing agile development is part of future proofing. For the most part, make this a principle that helps with future proofing. There is autonomy and a can-do perspective that comes with this approach. This approach helps promote a culture of automation as well.</p><p>One might also concede that this approach offers too much autonomy to developers and might risk individual teams making decisions that increase technical debt in the long-term in the spirit of getting a new feature delivered. That is something to watch for. However, a good agile approach will have platform teams or enabling teams that should be helping provide services and explore new capabilities.</p><h3>Culture of Automation and Self-Service</h3><p>A culture of automation encourages developers to consume capabilities which are easily provisioned and de-provisioned. The act of automating will question special configuration settings and just won’t tolerate extra manual configurations. A platform team that is assisting or advising on automation will be the gearbox to adjudicate differences and ensure the valid nuances are truly warranted. Automation also makes testing easier and thus enables and encourages more testing, which leads to better software quality.</p><p>The most valuable automations are those consumed in a self-service persona sensitive way. Other automations might be automatically triggered when needed. Don’t think of an automation as something you always need to have someone else run for you.</p><p>Another angle on future proofing that comes in here is that of currency and technical debt. With the right automation philosophy and tools to make it real, this can enable more constant updating of various elements of the architecture. Fewer changes per update and more updates keeps technical debt paid down. Underneath of this means automation that includes blue/green testing, rollback, and a strong suite of automated testcases.</p><p>The leading edge of this is immutability, of the application components and the infrastructure services upon which they depend.</p><h3>Open Source</h3><p>Leverage open source. Leverage open-source APIs and frameworks that have multiple committers and large, vibrant communities as well as supported distributions. Think ahead to where a given open-source project might be in 5 years. Java enjoyed and still enjoys innovation, investment, and community as well as supported distributions. Kubernetes has similar excitement and activity. We all know of projects that died out as well.</p><p>Open Source and using the right open source also will bring with it a set of available skills. Look for open-source technologies that have multiple active distributions. Look for those that appear on university and technical school curricula.</p><h3>Buy versus Build</h3><p>Buy application runtimes, buy middleware, and buy databases. Buy them ‘as a service’ whenever possible. If you do this and you then allow the service provider to curate the evolution, this is normally goodness. If you are building your own Kubernetes stack, your own database stack, by starting with the open source, that’s a future-proofing anti-pattern. This RYO stuff will become a source of technical debt. I’ve had IT folks tell me over the years why they should build their own CORBA ORBs, application servers, ESBs and workflow engines. All of them built up debt and later found it very challenging to do innovative things because of the operating costs they were incurring. The applications teams often then went shadow IT and there was no more future proofing going on.</p><p>Buy applications and buy them as SaaS properties especially for those capabilities that are necessary, but not differentiating for your business. While that sounds right, make those buy decisions in the context of how future-proof ready those SaaS properties are. Are they configured with standards-based mechanisms. Are they able to plug into your logging, monitoring, events, and other platform services, in standard ways. If yes, you’re ensuring some level of future proofing.</p><p>Think ahead to a world where there is a larger portion of the application portfolio that is packaged versus custom. If you see silos emerging in that future look, then keep reading and update the criteria and context used to do the buying. Don’t resist the buy, do it right.</p><h3>Conservation of Moving Parts</h3><p>If you are leveraging a java-based runtime, select just one or two for good reasons. Do something similar with databases capabilities and other integration capabilities. Too many moving parts and too many choices within the same categories increases the surface area of your overall architecture. Again, choice is good, but within reason. How many relational database services do you really need in the cloud? Pick a couple, put usage guidance in place and hurry onto NoSQL databases, document databases, in-memory caches and the other things that are needed in the data services space.</p><h3>Evolution towards “Shared Nothing”</h3><p>Build new custom applications with the right amount of architecture for scaling. The cloud affords almost unlimited scaling if ‘shared nothing’ architecture is pursued. Realize that this will require a bit more programming, but sans some maintainability challenges due to code complexity, architectures that minimize locking, leverage nearly consistent semantics when practical and publish changes for others to consume will be the best way to future proof an application for scaling.</p><p>Pulling this off does require some prescriptive guidance in the form of programming patterns (event driven, orchestration, choreography, etc..), starter projects and other aids which keep the complexity to a minimum.</p><h3>SRE and XLA Philosophy</h3><p>An SRE model is essential to ensure that applications start and remain available, resilient, and performant throughout their life cycle. Among the many values of an SRE philosophy is that of ensuring encountered problems do not occur again. This means ongoing curation by SREs. Make sure the SRE remit includes remediation that is built right into the application. While runbooks are fine for some things, having applications that themselves are more resilient should be pursued in many cases. I’ve never been a fan of runbooks that reboot or recycle runtimes while never really addressing root causes. I guess that comes from my many years working in operating systems and middleware development. You must get the gremlins out or they will come back later when the stakes are higher.</p><p>XLAs bring another important dimension to an overall philosophy. This isn’t necessarily an architectural principle for future proofing, but it is a way of measuring success that will drive changes into the applications. Those changes are for the better and will allow an application to contribute to the business for longer time periods.</p><h3>A Few More Technical Topics</h3><p>Maybe you are now wondering if this article will get deep enough to make a difference. In some ways, what has preceded this section is the setup. Now, onto the next level of detail for a couple of topics. Again, I’m seeing more blogs in the future here. For now, let’s start with some important themes that influence futureproofing.</p><h3>Microservices, Containers and Serverless</h3><p>Choose a microservices and serverless based approach for your business logic. Future proofing business logic is all about getting it in consumable chunks. Error on the side of granularity to begin with, and back off from that as you look at performance and places where looser coupling is just a dream. Future proofing means thinking not only about loose coupling from a code perspective, but also from a management and scaling perspective. Monoliths are not cheap to scale.</p><p>A microservices approach also lets us talk about polyglot in a realistic way. We had this back in the CORBA days. In the java stampede, we gave that up, and for a while didn’t miss it much. In today’s world, there are too many good languages that do a certain class of work well. This means you can not only switch languages, but you can try different distributions of application runtimes in the same language. I think we’ve used 6 or 7 versions of java application runtimes over the years in our <a href="https://www.oreilly.com/library/view/practical-cloud-native-java/9781801078801/B17377_03_Final_SB_epub.xhtml">Stock Trader</a> example.</p><p>A future proof architecture will also need an underlying Kubernetes environment that is ready to handle the applications. This is done by judiciously leveraging service meshes and other custom resources (CRDs) to help those microservices have the purest business logic in the source code as possible. Leave routing, encryption, and many other things to occur as part of the platform. Further, have the microservices specify declarative metadata (YAML) that allows the platform to practically do things like scaling, scheduling, and other management tasks.</p><h3>Application Portability</h3><p>This is where things start to get a bit trickier. We’ve outlined principles related to ‘Open Source’, ‘Conversation of Moving Parts’ and ‘Buy versus Build’, not to mention ending up with a lot of automation to support it call because of the ‘Culture of Automation’ Principle. Now ask yourself if you want your application to be truly portable across public cloud providers.</p><p>I get reactions to this question that are all over the map. Some say that they are only on one cloud, so why does portability matter. I can tell you that cloud providers do compete, so I don’t need to say more on that one.</p><p>Others tell me that they want portability. That’s usually before we get too deep into the weeds of reality. Some elements of portability are cheap to achieve and come via principles and selections of services. Avoiding container-platform-specific capabilities and sticking to the open-source principle described earlier is obvious. This makes the source code portable, as well as the YAML that goes with it. Other elements take on more interesting notes. Data services and serverless come to mind. With databases, preferring services that are available on all cloud-providers is a good plan. Dealing with those you need that are not widely available in with the right qualities of service is going to be costly. However, even for those you need to do special things to support, stick to those that are open-source based, have large communities and commercial distributions.</p><p>This topic deserves more blog entries, some of which we’ve got on the drawing board.</p><h3>API Based Business Services and Exposing Data</h3><p>I would be remiss to not mention building API based services when it comes to future proofing. Equally important is an architecture that allows for addition of APIs as an application evolves. It is okay to have a lot of APIs, if there is a good underlying data architecture. This should be one that has exposed data which is not dependent on or directly reflective of the storage approach for that data.</p><p>APIs are not just REST, either, in this modern world. Remember our discussion earlier about loosely coupled. This means that events are part of the API. This means that topics of published events become part of the API as well.</p><h3>Cost Considerations</h3><p>Most of the principles and some of the more technical topics are not costly to embrace. Others have implications. For example, how far you go towards an event driven or a CQRS type of application architecture comes with a cost. Programming asynchronously is going to mean more code, more complex code and thus the need for a richer skill mix of developers.</p><p>Application portability sounds good. Leveraging Kubernetes and leveraging a set of databases that are available on all public clouds and in private clouds is obviously a good idea. In other cases, having to purchase, and manage software that might not be in one or more of the cloud provider’s catalogs places a financial (licenses) and operational burden that likely exceeds that of leveraging a cloud provider managed service. In some cases, a particular cloud provider might have a superior and unique service. Leveraging that can make developers more productive but reduces application portability. Think all this through before deciding exactly how portable you want your applications. Mandates of 100% portability might be too extreme in a few cases.</p><p>Availability is another interesting topic when thinking about future proofing which has a direct bearing on cost. Applications, for the most part, should be able to run successfully, supporting practical SLAs and XLAs in a variety of configurations. If the minimum footprint is too high, that application might not be as future proofed as you think. It is perhaps subtle but is important. For example, don’t build applications that depend on out of region DR via automated replication. Make sure there’s a less aggressive backup capability that can be configured.</p><h3>Wrapping Up</h3><p>With the principles now laid out and some more technical elements specified, let’s look at how this all can come together check our work. If we take some of the typical requirement’s categories outlined earlier and see how the principles might apply, this will at least validate some of the suggestions and topics we have covered.</p><p>Anytime there are <strong>new functional requirements</strong>, the effectiveness of an automation capability for provisioning environments that facilitate development and test, quickly is pressure tested. Getting a CI/CD pipeline executed quickly, without letting any specific checks and balances slip through the cracks is also important. Then, having the ability to leverage the right technology to best address that new business requirement and deploy it into a tested, scalable, and secure platform puts developers in the right place to meet those new requirements.</p><p><strong>New markets to be served</strong> via channels or geographic expansion is the next need to be considered. Here, one expects near seamless provisioning into new instances for development, test, and production. Count on cloud provider portability to enable the applications to easily land on whatever platforms are available.</p><p><strong>New technologies</strong> should be able to be bolted into a solution quickly and safely. This is in part to leveraging an API Manager. Expect these new technologies to independently scale and be quickly leveraged using the buy versus build principle. The automation platform must enable provisioning new capabilities.</p><p>Market dynamics and consumer behaviors require a strong <strong>scale up, scale down</strong> capability. This must be granular down to individual consumed services and steps in business processes. Proper automation and leveraging of containers and cloud provider based managed services are the dimensions to count on here.</p><p>Finally, a <strong>change in security and compliance posture</strong> necessitates that the principles and dimensions laid out above pay off in many forms. Automation in the form of CI/CD enables quick changes to application scanning and the rules applied. Conservation of moving parts is a principle that reduces the surface area which must be addressed. A microservices model can isolate some of the required changes and limit impact.</p><p>Take some of your business requirements and pressure test the above principles and technical topics that I think are important from a future proofing perspective. I am sure you will come up with some more things that should go into these lists. Leverage my list as a seed.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c99301e0e3a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/cloud-journey-optimization/what-is-a-future-proof-information-technology-architecture-an-application-centric-view-3c99301e0e3a">What is a Future Proof Information Technology Architecture? An Application-Centric View</a> was originally published in <a href="https://medium.com/cloud-journey-optimization">Cloud Journey Optimization</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mainframe Modernization, An Application-Centric Approach]]></title>
            <link>https://medium.com/cloud-journey-optimization/mainframe-modernization-an-application-centric-approach-754ab1358605?source=rss----5d3dba44a6b4---4</link>
            <guid isPermaLink="false">https://medium.com/p/754ab1358605</guid>
            <category><![CDATA[application-architecture]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[application-modernization]]></category>
            <category><![CDATA[cloud-operations]]></category>
            <category><![CDATA[mainframe-modernization]]></category>
            <dc:creator><![CDATA[Eric Herness]]></dc:creator>
            <pubDate>Tue, 18 Jul 2023 19:20:46 GMT</pubDate>
            <atom:updated>2023-07-18T19:20:46.670Z</atom:updated>
            <content:encoded><![CDATA[<p>In <a href="https://medium.com/hybrid-cloud-engineering/an-update-on-application-modernization-d798d81603e3">past blog articles</a> I have focused on application modernization. This was always done in a way relatively independent of the underlying platform (operating system and often specialized middleware as well as hardware architecture) upon which the applications being modernized run today. As we build out a broader set of application modernization guidance based on experiences, a set of ideas, principles and refined techniques emerge that are specialized to or invented because of the underlying platform. This blog article will frame up the topic of mainframe modernization and be a setup for additional articles that dive more deeply into some of the topics introduced here.</p><p>To get started, there are two things to get out of the way immediately.</p><p>1. Technically, the mainframe hardware, operating systems, and supported middleware, namely the IBM Z and the ecosystem of things that run there are very modern and under continued evolution by IBM and related software providers. It is generally the applications and sometimes the operating models that leverage IBM Z which need modernizing.</p><p>2. An application-centric focus, as with application modernization in general, is the theme that we want to capture under this term mainframe modernization. The difference is that mainframe modernization has specific guidance and procedure related to the mainframe platform. While definitions of mainframe modernization are plentiful, we will use this application-centric definition for this blog and others to come.</p><p>With that preface, the rest of this blog entry will introduce and provide some thoughts that address:</p><p>A. Mainframe Modernization — Why Now?</p><p>B. Mainframe modernization and generic application modernization similarities and differences</p><p>C. Taxonomies and approaches that can help organize mainframe modernization activities.</p><p>D. A starter list of guidance and best practices</p><h3>Mainframe Modernization — Why Now?</h3><p>Moving away from the mainframe has been a topic of discussion and many failed predictions for most of my career. It would be naïve to say that this time around, the conditions are radically different. You can decide for yourself. A few things around timing are certainly noteworthy.</p><p>One can argue that the first few steps of digital transformation are often focused on user experience, proper channels along with safe and secure access from those digital channels. Much of this can be done without a lot of mainframe application modernization. Getting access to mainframe-based data and transactions via APIs will go a long way in the early days of digital transformation. However, companies going through a digital transformation are now reaching the point where the mainframe-based applications must be changed, often significantly.</p><p>This next step and perhaps the most important one is to truly become digital and have business processes that are built for and optimized to the digital experience. Things like a single view of the customer in the digital experience come to mind. Most of those existing applications on the mainframe must do more than expose APIs and democratize data in this phase of digital transformation. At the extreme, these applications need to be re-imagined while at a minimum some refactoring is required. This is intrusive, by definition, to the actual business logic and organization of business services.</p><p>With that in mind, where is the right place to do this reimagining and refactoring? The supporting story for why now often helps us with the answer.</p><p>1. <strong>Skills</strong> — It isn’t a stretch to say that skills at all levels are in short supply as it relates to the mainframe. Existing teams are aging. I regularly speak with some brilliant applications developers that are looking forward to retirement, like now. COBOL programmers are not coming out of academia in large numbers. Having language skills is just part of it, having knowledge of the aged applications and how they really work is an even more acute problem.</p><p>2. <strong>Investment</strong> — Large companies have for the most part reduced their level of investment in the applications that are on the mainframe. New capabilities are being built on the cloud which results in mainframe applications getting less attention and building up various amounts of technical debt.</p><p>3. <strong>Development velocity</strong> isn’t near that of what is going on in the cloud and in the modern world of microservices, Kubernetes, serverless and managed data services. Yes, modern DevOps is possible technically on the mainframe, but less pervasive. This is due in part to the existing operating models and years of muscle memory.</p><p>4. <strong>Economics — </strong>In addition to the technical reasons motivating mainframe modernization, there are a set of changes occurring around pricing of both software and hardware which are raising a bunch of red flags.</p><p>Why now? This confluence of these factors makes mainframe modernization not only water cooler talk, but also makes the focus list for CIOs and even CEOs.</p><h3>Mainframe Modernization and Generic Application Modernization Similarities and Differences</h3><p>While it is the case that mainframe modernization, by our definition described earlier, is a special case of application modernization, there are indeed more similarities than differences when we look at the next level of detail.</p><p>General application modernization advice and knowledge almost always applies. Things that need to be considered, tasks that need to be undertaken and the mindset in general is similar. The details, however, can vary a bit. Four things to consider are outlined in the figure below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*St4CC5wIKCTiQ8j9cU9mNw.png" /></figure><p>1. <strong>Shape and Size of Applications — </strong>What’s an application?<strong> </strong>Just as in the broader world, defining and counting applications on the mainframe is not a standardized conversation. Tools usually impart some reality about what to call an application. Realize that the application count might be influenced by the role the mainframe logic and data play. Mainframes can host entire applications, or they can host pieces of applications depending on the perspective taken. More and more, our experience shows that an outside in view that looks at the business transaction that a consumer or customer of the application is using will provide the right context. So while the tools impart some structure remember to think end-to-end when looking at SLAs and overall experience.</p><p><strong>2.</strong> <strong>Application architectures </strong>are a good way to look at groups of applications. With mainframe applications or the mainframe portions of applications, the following are generally true:</p><p>a. More batch architectures than you find on other platforms and lots of built in support in the platform for making this work at high-volume.</p><p>b. A larger proportion of mainframe applications are going to be the backends, the systems of record, than in most other situations. The mainframe is the 3rd tier in a 3-tier architecture or the 2nd tier in older client-server architectures. This means access patterns or inbound requests are really important. Mainframe based applications do make calls out, but probably less so than distributed applications.</p><p>c. Less likely to see BFF (backend for front end), but probably see online application with green screen user interfaces. While many of these have been screen scraped or replaced, some of them are still out there. Mostly the remaining green screens are the long-tail applications which might be super important to a small but specialized set of users, leveraged only occasionally,</p><p>d. Application architectures on the mainframe are often built for scale, which can mean they are more loosely coupled. At the same time, being built for scale might mean that they depend on features like the coupling facility. There is more of a shared data mentality, so you’ll find that applications aren’t operating on copies of the data, they are operating on the actual system of record data at its source.</p><p>e. Finally, from a database perspective you will find a number of technologies and approaches including IMS, VSAM, IDMS and DB2. A lot of these architectures for data have many consumers, meaning that applications are not necessarily encapsulating their own data. This means applications often have a lot of dependencies on different tables and databases.</p><p>3. Armed<strong> </strong>with some appreciation for what makes up an application and what architectures might be encountered, <strong>application assessments</strong> are necessary to make solid technical and financial decisions about what and how to modernize. Assessments that are tool-based are the only viable ones in this day and age if you want my opinion. Sometimes the tools used, such as CAST Highlight, are the same as those used on the distributed platforms and this is a good thing. What might be different are the programming languages and middleware being used by the applications being scanned. Look for more COBOL, or PL/1. Look for CICS, IMS and VSAM. Don’t get me wrong, you can also find things like WebSphere, IBM MQ as well as lots of DB2 when scanning a mainframe application estate, but expect a lot of older languages and platform specific middleware as well.</p><p>4. <strong>Techniques to apply to an application</strong> for modernization presents a new set of conversations when the mainframe is involved. Let me enumerate a few things that we are seeing regularly.</p><p>a. <strong>Replatforming </strong>comes in the form of recompiling COBOL to run on x86 architectures. This is a viable option, providing a minimum change approach as far as the business logic goes. Various providers have tools and methods. Each has varying levels of support for languages and for various middleware which are inherently burned into the applications. Most of the time, it isn’t just COBOL, it is CICS COBOL or COBOL with other middleware involved.</p><p>b. <strong>Refactoring or a more aggressive Replatform, depending on how to want to state it, is also a much more common</strong> when it come to the mainframe applications. Here, the usual example is COBOL to Java. Again, there are several tools providers with varying degrees of support. Here, I will list a few points that are relevant to refactoring and come back to this in the future:</p><p>· These conversion tools and methods have matured a lot in the last couple of years. I am much more impressed and less skeptical here.</p><p>· That said, make sure your java programmers inspect the generated code before you buy. They must be able to maintain this without too much difficulty. Make sure you factor in the cost of having proper CI/CD pipelines as well, to support these converted applications.</p><p>· Ensure that you are carefully mapping the NFRs from the mainframe to that of the cloud. This is tricky to say the least, especially if the original COBOL application takes advantage of specific mainframe features such as the coupling facility in a sysplex, then you must clearly test and inspect the results, under normal and maximum load conditions.</p><p>· Think long and hard about the runtime execution environment in which these converted applications run. Some cloud providers are providing managed services to run converted applications. Maybe you should run these in Kubernetes, alongside the front ends and middle tiers that also may have been modernized in the direction of Kubernetes? Is this a well-trodden path?</p><p>c. <strong>Containerization</strong> as a direct technique is less common. There is less directly containerizable stuff on the mainframe at this point in time. Sure, if there is java, it can most certainly be containerized. But the path to containers often goes through replatforming for refactoring versus the more direct approaches which we are able to leverage on the distributed platform.</p><h3>Taxonomies and Approaches for Mainframe Modernization Activities</h3><p>In <a href="https://medium.com/hybrid-cloud-engineering/an-update-on-application-modernization-d798d81603e3">previous articles,</a> we used an evolved version of the 7Rs to talk about what techniques to apply to applications and components of applications to effectively modernize them. The most common patterns leveraged in mainframe modernization cases, are shown in the following figure:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*K_yq7eTff9MaNLDerNqGtg.png" /></figure><p>Each of the shaded boxes can be a subject of an entire blog. For now, at least we have the list here and will endeavor to build on it. It should also be noted that another common modernization action that affects the applications is DevOps Modernization. This is occurring in the context of applications that are staying on the mainframe and is all but mandatory for applications that are moving off the mainframe and going through one or the paths outlined in the figure.</p><p>Sometimes, the taxonomy above and how it is applied is influenced by a company’s overall <strong><em>platform strategy</em></strong> as it relates to the mainframe. At Kyndryl, we have been working with clients that have such strategies and with others to help them formulate this platform strategy. Typically, there are platform strategies to invest, maintain or move off the mainframe platform. These strategies are not exclusive, meaning you can choose to leverage more than one of them, which is why we recommend an application-centric and holistic approach to figuring all this out. This provides insights as to the level of investment in an application makes sense and which approaches are more appropriate.</p><p>Armed with the bigger picture and some of the organizing principles, the final section shared some best practices and experiences.</p><h3>A Starter List of Guidance and Best Practices</h3><p>We have accumulated a lot of knowledge in the past few years by engaging and working with large and small customers on application modernization. A similar story is unfolding around mainframe modernization. This final section enumerates a few things that might pique interest or resonate with your mainframe modernization initiative.</p><p>1. <strong>Remember the operating model</strong> — Often times, we get caught up in all the technical realities of mainframe modernization. If the same processes and procedures for development, provisioning, testing, and operations are brought forward to the new world, the investment in modernization will not pay off. Automation that has meetings and human interactions between every step won’t improve development velocity no matter how modern the source code is and how easy it is to iterate upon. Most of the application modernization techniques are trending towards more cloud native applications. Make sure your operating model is doing the same. Agile and product-centric companies (not just IT) come right into the middle of this operating model discussion. Check out what else is happening in your organization already. There are likely groups that are agile, are cloud native and have much of this figured out. Borrow their experiences.</p><p>2. <strong>Leverage </strong><a href="https://www.kyndryl.com/us/en/services/core-enterprise-zcloud"><strong>zCloud</strong></a><strong> </strong>— Sometimes, there are pieces that cannot easily move off, but they work. If you need to get out of your data center or off your current mainframe, but want to maintain portions of the mainframe estate, this option works very well technically and can makes a lot of sense from an ROI perspective.</p><p>3. <strong>Inspect all the moving parts on the mainframe</strong> — There are a lot of things happening on the mainframe — Our experience is that in addition to the applications themselves, there are other technical components on that mainframe that are essential to the way a business process is running. Things like scripts or JCL that glue together applications come to mind. What about printing? Remember that when the mainframe was the general-purpose compute, everything was done there. Stay application-centric but figure out what the rest of the story is and ensure that the need for all this glue and these utilities either goes away, gets converted to appropriate modern language source code or gets replaced by a cloud provider-based service.</p><p>4. <strong>Networking (the end-to-end path)</strong> — If mainframe applications are moving to the cloud, what is the networking path that an end consumer’s request might follow. We have seen cases where entry is at the mobile application (hosted in a public cloud) which then goes to an SOA layer (hosted in a private cloud) which then goes to a public cloud where the mainframe application has been replatformed to. How this gets resolved is a longer conversation? Should the middle-tier be modernized to the cloud also? (hint: probably).</p><p>5. <strong>Networking (latency and capacity)</strong> — If we use the same example from above, what is the change in latency? If an application on the SOA tier demanded low latency (aka. It’s conversation with the mainframe was chatty and synchronous) can that be maintained? Where is that cloud data center in relation to your data center? Even if the mainframe and the middle-tier go to the cloud, is there good latency and capacity plumbed into your cloud provider landing zone?</p><p>6. <strong>Security </strong>— This is a big topic. There is only room for a couple of examples here. How much encryption in motion and encryption at rest is happening in the current application architecture. When the application ends up on the public cloud, this now becomes necessary and again can affect performance and should take you right back to Network capacity. This is another reason why assessing the integrations that mainframe applications have, at the protocol level and at the volume level is really important to getting this right. In a different area of the security domain, we see it is important to understand the authorization schemes in place and how those are realized by the capabilities offered in public clouds. Getting there can usually be done, but not without some careful planning and mapping.</p><p>7. <strong>Find some simpler applications to start the move off journey with</strong> — On many mainframes there are super-complex custom-built applications, packaged applications, and the rest. I think of the rest as applications that were put onto the mainframe because it was the general-purpose compute platform. I wrote applications like this in the late 1980’s. They didn’t stress out the mainframe, but where else would one put a CRUD app in those days. Starting with an application in this latter category can be insightful, but perhaps not indicative of what it will take for the super-complex applications. Try them anyway. Moving them might help reduce consumption and will provide lessons learned to use when the big applications are tackled.</p><p>8. <strong>Testing and big bang versus incremental with Coexistence </strong>— When modernizing these mission critical applications, lots of testing, including side-by-side is necessary. Big bang means moving an entire set of applications at once. Incremental with Coexistence means moving applications one at a time or a few at a time. Both approaches are tricky, both are possible, and each has a set of heuristics to follow. Explore all the risks, both at a business and technical level. Think this through. Don’t be over influenced by the rate and pace at which the return on investment comes through. Choose the option that you can make happen. The return on investment will catch up either way if you can get the application modernized and stay there.</p><p>This section is one that can probably be refined and improved every day as we do this work with customers and as we encounter an improving and maturing ecosystem which is enabling mainframe modernization. Look for more of this kind of material in the future. At Kyndryl, our goal is to help you through all of this, no matter what your platform strategy is and no matter at what rate and pace that the journey will proceed.</p><h3>Conclusion</h3><p>Application Modernization continues to dominate a lot of conversions. It is increasingly being fueled by digital transformation activities. As individual organizations get further into their journeys on digital transformation, the application modernization work increasingly focuses on core business processes. Those processes, in many industries, are running in part or whole on mainframes. Like all applications being modernized, these core business processes require careful assessment. There are techniques leveraged when mainframes are involved that should be understood and leveraged when building an overall modernization, including the business case.</p><p>This article has outlined a framework and started on topics that can and should be further described and detailed.</p><p>Meanwhile, while the mainframe modernization topic heats up, the definition of what good looks like for modernized applications is also maturing. This is true for the constituent parts of an overall technical architecture and the operating model. We are going to be talking about application modernization for the foreseeable future including the specializations related to mainframe modernization. Stay tuned, because in my view, we are just now getting to the really good stuff and the really hard stuff, depending on your perspective. I’ll update this blog with pointers to other topics as we roll them out.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=754ab1358605" width="1" height="1" alt=""><hr><p><a href="https://medium.com/cloud-journey-optimization/mainframe-modernization-an-application-centric-approach-754ab1358605">Mainframe Modernization, An Application-Centric Approach</a> was originally published in <a href="https://medium.com/cloud-journey-optimization">Cloud Journey Optimization</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction to Cloud Journey Optimization Team Blog]]></title>
            <link>https://medium.com/cloud-journey-optimization/introduction-to-cloud-journey-optimization-team-blog-20a0a2693c80?source=rss----5d3dba44a6b4---4</link>
            <guid isPermaLink="false">https://medium.com/p/20a0a2693c80</guid>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cloud-operations]]></category>
            <category><![CDATA[cloud-native]]></category>
            <dc:creator><![CDATA[Eric Herness]]></dc:creator>
            <pubDate>Tue, 18 Jul 2023 18:14:07 GMT</pubDate>
            <atom:updated>2023-07-18T18:14:07.821Z</atom:updated>
            <content:encoded><![CDATA[<p>Welcome to the Cloud Journey Optimization Team Blog. The Cloud Journey Optimization Team is part of <a href="https://www.kyndryl.com/us/en">Kyndryl</a>. Our team of senior engineers works with companies on transformation journeys.</p><p>This blog will continue the tradition started in our former roles at IBM, of providing technical and business-related insights and information that we think might be of interest to those going through a journey to cloud. If you are working on digital transformation, you might think that is different from a cloud journey. However, that is often merely a different lens on the journey to cloud for many large organizations.</p><p>Most of our insights and experience come directly from working with our customers and from the hands-on experiments we are constantly running. All our future articles will be inspired by and informed by these ongoing activities.</p><p>Thanks</p><p>Eric Herness</p><p>Kyndryl Fellow</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20a0a2693c80" width="1" height="1" alt=""><hr><p><a href="https://medium.com/cloud-journey-optimization/introduction-to-cloud-journey-optimization-team-blog-20a0a2693c80">Introduction to Cloud Journey Optimization Team Blog</a> was originally published in <a href="https://medium.com/cloud-journey-optimization">Cloud Journey Optimization</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>