<?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 Gareth Thomas on Medium]]></title>
        <description><![CDATA[Stories by Gareth Thomas on Medium]]></description>
        <link>https://medium.com/@garethdthomas?source=rss-1ead7d1e6aa5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*_w2394nhOGglBoz1clCX6Q.jpeg</url>
            <title>Stories by Gareth Thomas on Medium</title>
            <link>https://medium.com/@garethdthomas?source=rss-1ead7d1e6aa5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 02:33:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@garethdthomas/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[Tech Debt For Dummies]]></title>
            <link>https://garethdthomas.medium.com/tech-debt-for-dummies-c2fedff93016?source=rss-1ead7d1e6aa5------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2fedff93016</guid>
            <category><![CDATA[business-strategy]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[business-technology]]></category>
            <dc:creator><![CDATA[Gareth Thomas]]></dc:creator>
            <pubDate>Tue, 24 Sep 2024 09:21:14 GMT</pubDate>
            <atom:updated>2024-09-24T09:21:14.536Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gmXv1na5G1E964W9AgnJsA.jpeg" /></figure><p>In software engineering, &quot;tech debt&quot; is often misunderstood by both technical and non-technical people. After a recent discussion with a senior executive who lacked a technical background, I realized it’s important to clarify this concept specifically for non-technical leaders, as their understanding is crucial for managing long-term technical challenges effectively.</p><p>First a quick definition. What is tech debt?</p><p><em>“Tech debt [is] any problem in the codebase that affects programmers by making it harder to make necessary changes” — Lou Franco</em></p><p>Leaders who are not from a technical background often struggle to understand the true scope and impact of tech debt because they see technology primarily as a tool for delivering business objectives, rather than complex systems requiring continuous investment. They tend to focus on short-term goals — shipping features, meeting deadlines, or driving revenue — not recognizing that cutting corners on quality, architecture, or code refactoring* creates hidden costs. From their perspective, if the product works and users are satisfied, everything seems fine. However, these compromises accumulate as tech debt, slowing future development and increasing maintenance costs.</p><p>Another critical aspect that non-technical leaders may overlook is the <strong>compounding nature of tech debt</strong>. Unlike financial debt, which can be paid off in predictable installments, technical debt grows exponentially if left unaddressed. Poor code structure, inadequate documentation, and neglected infrastructure can lead to more bugs, greater security risk, and reduced performance. This can in turn result in slower product delivery times, higher maintenance costs, and a demotivated engineering team forced to work around hard to maintain codebases. To business leaders, the consequences of tech debt may not be immediately visible, but the long-term operational inefficiencies can impact innovation and the ability to scale the business efficiently.</p><p>Finally, there is often a gap in understanding the <strong>strategic importance of managing technical debt</strong>. For non-technical leaders, spending time and resources on refactoring or improving existing code might appear to distract from new feature development. However, maintaining a healthy codebase is essential for scalability, security, and agility in responding to market demands. If tech debt is not managed, it can cripple future growth by making systems difficult to adapt or expand, causing businesses to miss out on competitive opportunities. Communicating tech debt as an investment in future flexibility, rather than an unnecessary cost, can bridge this understanding gap.</p><h4>What are the takeaways?</h4><ol><li><strong>Understand Tech Debt’s Impact</strong>: It accumulates and slows down development, making future changes more costly and difficult</li><li><strong>Balance Remediation and Innovation</strong>: Prioritize fixing tech debt alongside delivering new features for long-term productivity</li><li><strong>Incorporate Tech Debt in Planning</strong>: Include it in product roadmaps to balance immediate business needs with long-term technical health</li><li><strong>Track and Measure</strong>: Use metrics to visualize tech debt’s effects on development speed and costs as an aid to better decision-making</li><li><strong>Highlight Long-term Risks</strong>: Emphasize that unchecked tech debt hinders future scalability and innovation</li></ol><p>*Code refactoring is the process of improving the internal structure of existing code without changing its external functionality, making it cleaner, easier to maintain, and often more efficient</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2fedff93016" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Will Eat Tech]]></title>
            <link>https://garethdthomas.medium.com/ai-will-eat-tech-18d8b359a45d?source=rss-1ead7d1e6aa5------2</link>
            <guid isPermaLink="false">https://medium.com/p/18d8b359a45d</guid>
            <category><![CDATA[systems-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Gareth Thomas]]></dc:creator>
            <pubDate>Thu, 05 Jan 2023 18:48:34 GMT</pubDate>
            <atom:updated>2023-01-05T22:45:05.660Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DzV4Zd5Gid_LPONFktIL9A.jpeg" /><figcaption>Image courtey Rawpixel</figcaption></figure><p>There is a famous saying that <a href="https://a16z.com/2011/08/20/why-software-is-eating-the-world/">software will eat the world</a>, but in this article, I will argue that AI will eat tech first. I am using the broad term of “tech” since this will cover not just coding but also the design, deployment, scalability and security of enterprise level systems. Now, some of you will still say that AI is software, but it actually isn’t, it is <a href="https://huggingface.co/blog/large-language-models">huge sets of data</a> that underpin the capabilities, often in ways that are not fully understood.</p><p>The article that encouraged me to write this is the <a href="https://cacm.acm.org/magazines/2023/1/267976-the-end-of-programming/fulltext">End of Computing</a> from CACM. Many people like me, who have been around long enough in the industry, saw this coming before GitHub released <a href="https://github.com/features/copilot">CodePilot</a>. But seeing the capabilities of <a href="https://openai.com/blog/chatgpt/">ChatGPT3</a> recently really emphasised that a big shift is coming a lot faster than many realise. The article does a really good job of articulating this.</p><p>But it started me thinking. Yes, of course, AI could be writing individual programs that will go into production with minimal supervision (perhaps another AI can review pull requests) as part of larger development efforts, and that will become widespread, I believe, within five to ten years. However, it’s one thing to write a program, but a whole other to design, build, test, deploy, scale and secure an enterprise system with a couple of sentences in a chatbot window. Is that in the future also? If it is, how far away might that be and what do the barriers look like?</p><p>If we start with the design stage, there are already low-code and no-code platforms that make the design and build of applications easier. Many companies today use Figma, and AWS in 2021 launched <a href="https://aws.amazon.com/amplify/studio/">Amplify Studio</a> that can create front-end ready code from Figma designs. There are now many others in this space, including <a href="https://zecoda.com/product">Zecoda</a> and <a href="https://teleporthq.io/">Teleport</a>. We have also seen that <a href="https://openai.com/dall-e-2/">AI can create art</a>, so it’s not unreasonable to anticipate that the design of interfaces based on descriptive sentences (of what sort of UI you want and what the inputs/outputs are) is not far away. It might even be here now and I’ve just <a href="https://teleporthq.io/blog/generating-low-fidelity-designs-by-talking-to-your-computer">not seen it yet</a>.</p><p>The build stage is where things are currently moving at pace. Assuming we’ve got designs and front-end code, it should be possible in the future to feed that into another service that builds the backend services that are needed to receive, process, respond and store data (Remember, in this example, we are exploring a pure AI solution, when in fact, Amplify Studio and a number of other services provide a full-stack service where users can “point and click” all the pieces together now). In this new world, the lines between build and deployment become blurred as it’s about designing the infrastructure appropriate to the environment. Here, the environments are going to be very simple: a staging one for humans to review what the AI is going to deploy and then production. But as we cross over into the realm of architecture and <a href="https://en.wikipedia.org/wiki/DevOps">DevOps</a>, we will encounter our first obstacle because there could be many different ways to architect those backend services and integrate glue services such as asynchronous queue and message passing.</p><p>Today, microservice and serverless technologies are common design patterns for many tech companies. An AI that can do this effectively would need to understand how other companies have built the same or similar solutions, as this is about designing and deploying infrastructure that can host the most suitable solution. In order to understand how to do that, we need a language we can train models on. The good news is that this has been a reality for at least fifteen years since the advent of Infrastructure As Code (IAC) tools like <a href="https://aws.amazon.com/cloudformation/">Cloudformation</a>, <a href="https://www.serverless.com/">Serverless</a> and <a href="https://www.terraform.io/">Terraform</a>. So it’s not unreasonable to expect a future where you can describe what you want to build and deploy in natural language, and your cloud provider will be instructed what to do via AI written IAC. DevOps won’t exist as its own discipline — it won’t be needed. There might well be distinct components of the AI that act as site reliability “engineers” to ensure the end product(s) meets the SLA level being paid for, but the underlying services being deployed to suit the environment will be mostly invisible to the human overseer.</p><p>Some of you might be thinking: Why did I put “test” in there? Surely, AI-written code will be bug free? The problem here is that, firstly, the AI writing the code may well incorporate bugs into the code it writes simply because the model itself has flaws. Having <a href="https://www.reversinglabs.com/blog/deepmind-alphacode-buggy-insecure-software-ahoy">included buggy code</a>, it could also incorporate bugs because it uses a library that was written by humans or partly by humans. There is also the problem of integration testing, that is ensuring the responses sent and returned between services are what is expected and that might change due to security patches, underlying service updates etc. There are already products like <a href="https://www.functionize.com/">functionize</a> that help to write end-to-end tests using AI and <a href="https://machinet.net/">Machinet</a> that writes unit tests, so AI being able to generate and run unattended test automation is reachable. The challenge with code has always been the mathematical impossibility of testing all possible paths when you have thousands of lines of code; however, AI might have the advantage of being able to cover a vastly larger percentage than was previously possible simply due to the underlying power of the cloud.</p><p>Scaling might well be the easier of these steps if we decide that the infrastructure we will build on will be Serverless as a basis (if you don’t know what Serverless is, you can read my <a href="https://medium.com/@garethdthomas/the-truth-about-serverless-bc8079ab2fa">primer</a> here). The promise here is that you don’t pay if you don’t use it and you have infinite scalability if you do need it, capacity planning is no longer a concern. Also I suspect that all the big cloud providers already use some AI services to predict and optimise processor and network capacity within and around datacenters.</p><p>Security is an interesting one. There are already tools that can spot suspicious behaviour and AI is very well suited for trawling large amounts of data to look for patterns. Since AI has built and deployed the system in our example, I am going to assume it will also be monitoring resources such as <a href="https://medium.com/@garethdthomas/the-library-problem-63dbdc796c9f">CVE and OWASP</a> to automatically and rapidly patch vulnerabilities, probably far faster than a human could. But there will be a darkside because AI will also allow bad guys to write tools to better aid them in searching for vulnerabilities and we will likely see a security AI arms race. To illustrate the complexity here, a report has come out as I write this showing that hybrid/human AI code <a href="https://www.theregister.com/2022/12/21/ai_assistants_bad_code/">is less secure</a>. Granted, in this article I am proposing little or no human oversight of the code produced, but still.</p><p>I believe, in the next ten years, each of these areas will advance significantly in the application of AI, some to a greater extent than others. But in this grand vision, what we REALLY want is to have one chat service where we can describe exactly what we want from a system and have it go away and do everything in one go:</p><p><em>“Build and launch an application for me like Twitter on the domain twatter.com. The application should be available in three languages including English, Mandarin and Spanish. It should be built to scale from thousands to millions of users per day with a peak of around 100k users per hour. Redundancy should be designed for three nines and if my budget for hosting exceeds $500/day it should warn me via SMS.”</em></p><p>For this to be reality, we need some kind of overarching model that understands how enterprise level systems are built and can learn from thousands of examples how the pieces all work together in different scenarios. Someone needs to provide the services described above together in one place and allow humans to bolt them together first. That will happen, and because of the scale and reach required it’s going to be one of the big cloud providers that does it. My prediction is that it is twenty years away.</p><p>In my career, there have been two paradigm shifts. The first was the Web and the second was cloud computing. There have been many other ground breaking changes but these two were seismic. I believe AI for tech will be the third and will eclipse even them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18d8b359a45d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Library Problem]]></title>
            <link>https://garethdthomas.medium.com/the-library-problem-63dbdc796c9f?source=rss-1ead7d1e6aa5------2</link>
            <guid isPermaLink="false">https://medium.com/p/63dbdc796c9f</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Gareth Thomas]]></dc:creator>
            <pubDate>Sat, 23 Jul 2022 10:04:37 GMT</pubDate>
            <atom:updated>2022-07-23T10:23:12.097Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*89bSx0Df7-rmEaRTM4hQeQ.jpeg" /><figcaption>Typical JavaScript libraries being used via Import</figcaption></figure><p>What do the <a href="https://www.riskiq.com/blog/labs/magecart-british-airways-breach/">British Airways hack of 2018</a>, the Twilio hacks of <a href="https://www.theregister.com/2020/07/21/twilio_javascript_sdk_code_injection/">2020</a> and<a href="https://www.techtarget.com/searchsecurity/news/252500289/Twilio-discloses-breach-caused-by-Codecov-supply-chain-hack"> 2021</a> and probably the worst of all, the SolarWinds breach of <a href="https://www.cisecurity.org/solarwinds">2020</a> have in common? In all cases, bad actors inserted malicious code into production systems in order to access user data or compromise systems in other ways.</p><p>This type of attack is called a <em>supply chain attack</em> (also known as a third-party attack, value-chain attack or backdoor breach) and it is a growing trend as a lucrative attack vector. According to a recent report by Argon Security, an Israeli cybersecurity firm specializing in protecting the software supply chain, attacks grew by over 300 percent in 2021 versus 2020. What makes it a huge problem is the growing complexity of modern software and the enormous reliance placed on third party libraries to provide core functionality, or at least, supporting elements of it. Many applications make use of tens or even hundreds of third party libraries, and it’s clearly not possible for engineers to check every single one for malicious code. Remember, the libraries themselves are often constantly being updated and new versions released.</p><p>To clarify, we are talking about two distinct problems. First, there are vulnerabilities that could be exploited by a knowledgeable bad actor, which makes up the largest component. But the smaller, potentially more effective (and growing) component amounts to deliberate code changes made into libraries to be exploited.</p><p>So how do we manage this?</p><p>The good news is that there exists a central clearing house of known vulnerabilities called Common Vulnerabilities and Exposures (CVEs). This service catalogues hundreds of thousands of software vulnerabilities; although, by nature, it cannot be all-encompassing and other vulnerabilities may exist. It’s also worth noting that, in the case where a problem is found, for myriad reasons, many packages are not fixed in a timely manner.</p><p>A good example is a flaw that was found in the gnu c library in 2015. A domain name lookup function contained a buffer overflow vulnerability that could have caused a system crash or allowed attackers to execute malicious code (<a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2015-7547">CVE-2015–7547</a>). This vulnerability was introduced in 2008 and not fixed until Feb 2016! This is a flaw that was inherent in Linux, which powers an enormous number of cloud and enterprise servers and a vast majority of internet “plumbing”.</p><p>CVE launched as an open source effort at the end of the nineties. It was joined in the mid-noughties by a US govt. effort called NVD, CVE <a href="https://cve.mitre.org/about/cve_and_nvd_relationship.html">feeds data to NVD</a>, providing additional detail around the problem that could prove useful in some situations. But, even with these resources, it is clearly not possible for any software engineering team to keep track of all the notifications, library updates etc. And remember, this is all supposed to happen in a world of agile development and frequent — sometimes multiple — daily build and release cycles.</p><p>An alternative solution is the OWASP <a href="https://owasp.org/www-project-dependency-check/">Dependency-Check</a>. It is a free, mature project, regularly updated and an excellent tool for gathering and reporting a list of dependencies with CVEs. Currently, all the major languages are covered (Ruby, C++, Python and JavaScript) and it can be run from the command line but it can be made even more useful using a key technology that enables frequent build, test and release: Continues Integration/Continuous Deployment (CI/CD).</p><p>It’s essential you are automating your build and test process with some form of CI/CD — not just on demand, but regularly - to truly take advantage of this in your delivery process. Here’s why: Assume your engineers are working on an important feature with the deadline fast approaching. The check identifies a vulnerability, but updating the vulnerable library has a risk of introducing a regression, compatibility issue and/or possibly a slew of other bugs. The only way to mitigate this is an automated test and daily build process, which gives the team time to react appropriately. One point to bear in mind, though, is that vulnerabilities can have different severity levels and impact. Some may have no impact for a project, so it’s worth noting that the dependency checker can report false-positives.</p><p>Common build tools, such as Maven and Jenkins, can be integrated with plugins. But if, like most modern tech companies, your infrastructure exists in the cloud, it is also possible to use the OWASP service as part of your build process, demonstrated for GCP nicely <a href="https://cloud.google.com/community/tutorials/deploy-dependency-track">here</a> or in a more complex reference example for AWS<a href="https://aws.amazon.com/blogs/devops/building-end-to-end-aws-devsecops-ci-cd-pipeline-with-open-source-sca-sast-and-dast-tools/"> here</a>. There are other options if you use a source control platform such as GitHub, which has a dedicated security page regarding <a href="https://docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/about-supply-chain-security">supply chain attacks</a>. It also provides tools such as Dependabot, which can scan your codebase and provide notifications through a number of channels, including Slack, directly to your Engineering team.</p><p>The decision to implement such processes needs to be measured against the actual risk of attack. It’s possible that some of your products or services have no access to sensitive customer data (e.g. credit card information). In these cases, it may not make sense, as the value has to be perceived to be high for a determined hacker to invest the time needed to be successful. However, it’s worth including this as part of any risk assessment that you should be already doing for your company.</p><p>The take-away from this is that you cannot just hire a security company to do a penetration test once a year and assume all is well. You need to embed security in your engineering culture and take advantage of state-of-the-art tooling to cover as many attack vectors as possible. Never rest on your laurels — the landscape is always changing, and remember, hubris always wins.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63dbdc796c9f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The truth about Serverless]]></title>
            <link>https://garethdthomas.medium.com/the-truth-about-serverless-bc8079ab2fa?source=rss-1ead7d1e6aa5------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc8079ab2fa</guid>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[aws-lambda]]></category>
            <dc:creator><![CDATA[Gareth Thomas]]></dc:creator>
            <pubDate>Mon, 06 Jul 2020 18:29:54 GMT</pubDate>
            <atom:updated>2021-02-04T21:40:13.764Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rg3P5bGQXjQWUJk4azo0ww.png" /><figcaption>Photo by <a href="https://unsplash.com/@tinaflour">Kristina Flour</a></figcaption></figure><p>If you are in technology or utilise technology for your business, you can’t help but be barraged by the benefits or pitfalls of serverless. Over the last twenty years, we’ve seen (almost on an annual basis) some new technology being touted as the next “big thing”. Techies generally love the latest and shiniest new thing, from client-server to cloud and now hybrid cloud, and from SaaS to PaaS and SQL to NoSQL and back again.</p><p>This article will look at whether the claims being made about serverless technology really stack up, and how a business might justify its use.</p><p><strong>What is Serverless?</strong></p><p>First a primer. Serverless is, in fact, an oxymoron; running applications “serverless” still means they are being run on physical servers somewhere in a data centre. Until the mid-noughties, if you wanted to launch a web application, you would use a physical server located in your office or data centre and install your application directly on that server. The server you owned might also be installed in someone else’s data centre called co-location, or it might be a server you rented from the hosting company, or even part of a server you shared with others. The point is, your application executed on what is now called “bare metal”.</p><p>Then, in 2006 Amazon set up a subsidiary called Amazon Web Services (AWS) and launched Elastic Compute Cloud (EC2). This utilised a technology called a <a href="https://www.sciencedirect.com/topics/computer-science/hypervisors">hypervisor</a> to provide a software layer (termed an abstraction layer) on top of the physical hardware . So now, when you “rented” a server, you got a virtual server configured via software to the specification required. This virtual server utilised custom resources that might span multiple physical servers. The Cloud was born.</p><p>The beauty of this model was a massively reduced cost (of both time and money) to get an idea up and running. No physical hardware to buy and set up, you only had to configure what you needed with no long-term contracts. The result was an explosion in tech startups.</p><p>The next big change to come was <a href="https://www.docker.com/resources/what-container">containerisation</a>. Popularised initially by Docker, this was an attempt to solve an issue with the deployment and configuration of servers, which added growing complexity by way of additional requirements needed to allow the application to run on a server. This also meant that a single virtual server could hold tens or even hundreds of mini-servers running as containers, talking to each other if needed. The rise of containers also coincided with the concept of <a href="https://en.wikipedia.org/wiki/Microservices">microservices</a>, which accelerated its popularity.</p><p>But there was still the issue of configuring and deploying servers and containers to install your application on. And for an engineer, a growing pain point is the “stack” of software required to run a typical application. Because modern web apps are highly complex beasts with many layers, the stack has become extensive. This has also led to the creation of <a href="https://en.wikipedia.org/wiki/DevOps">DevOps</a> as a discipline, which offloads this complexity to other specialists on the engineering team.</p><p><strong>Serverless to the rescue!</strong></p><p>The idea was to boil an application down to one of its simplest components: a function. Most applications consist of thousands of these that take values in and return results back. At a simple level, think of a calculator that takes in three values, two numbers and an operator, and returns an amount. Serverless allows us to build an application by simply defining the functions that encapsulate the required business logic. There’s more to it than that, but the biggest take away at this point should be that you only pay for precisely what you need: a small piece of code when it runs. There is no server configuration, no containers to define, no stacks to install and configure.</p><p>This is a big deal — a really big deal. Containerisation moved things forward a step but serverless is a paradigm shift, rather like the Cloud was back in 2006, and that’s no exaggeration.</p><p><strong>What are some of the perceived pros?</strong></p><ul><li><strong>Faster build to release</strong></li></ul><p>Engineers only need to focus on the application design and build. There is no need to worry about server provisioning and setup or backend configuration. This also makes it possible to quickly update, patch, fix or add new features. It is not necessary to make changes to the whole application; instead, engineers can update the application one function at a time.</p><p><em>Reality: Yes but a qualified yes. Certainly, removing a lot of deployment complexities and dependencies enables development to move faster. But it requires engineers to now be architects and not all are — or want to be. The skill set has fundamentally changed and the utilisation of technologies like CI/CD (continuous integration and continuous deployment) have now become essential to reap the benefits.</em></p><ul><li><strong>Reduced application costs</strong></li></ul><p>You are only charged for what you use. Code only runs when functions are needed by the application and it automatically scales as needed. Provisioning is dynamic, precise, and in real time. AWS, for instance, bills in 100-millisecond increments.</p><p><em>Reality: Yes but also a qualified yes. I’ve seen cost reductions of 15–20% but there are cases of </em><a href="https://aws.amazon.com/solutions/case-studies/financial-engines/"><em>reductions of as much as 90%</em></a><em>. It is absolutely the case that you are only charged for what you use, but depending on your business, how you need your application to work and the usage placed upon it, you might need to make design decisions that could significantly increase those costs. For instance, AWS Lambda can have a certain amount of latency — being slow to respond. However, this can be mitigated by keeping things “warm” or ready to execute more quickly. But there is a cost to that.</em></p><ul><li><strong>Increased application flexibility and scalability</strong></li></ul><p>Applications scale automatically with increasing users or usage. If functions need to run across multiple instances, the vendor infrastructure will manage them as required. As a result, an application will be able to process an unusually high number of requests just as well as a single request from a single user. A traditional application with a fixed amount of server resources can be overwhelmed by a sudden increase in usage.</p><p><em>Reality: Yes, in general, this is true. Using a platform as a service (PaaS) solution such as App Engine on Google Cloud or Elastic Beanstalk on AWS can handle sudden demand increases extremely well.</em></p><ul><li><strong>Reduced cost of management</strong></li></ul><p>Serverless architectures allow you to spend less money and time managing servers because most of the work is done for you by your cloud computing provider.</p><p><em>Reality: Yes, but there are caveats. First, the burden of systems architecture has now shifted to the application engineers, not all of whom are suited to this task (as mentioned above) and second, with cloud services constantly evolving and improving, changes that completely break an application are possible and could take a lot of time and money to resolve.</em></p><p><strong>What are some of the perceived cons?</strong></p><ul><li><strong>Vendor lock-in</strong></li></ul><p>By building your application so tightly into a big cloud service provider’s platform, you are clenched tightly to their bosom with no easy opportunity to move and will be subject to unannounced price hikes etc.</p><p><em>Reality: No. I could write a long answer to this one and my first riposte would be “opportunity cost” but this article nails it so well so please read it: </em><a href="https://lumigo.io/blog/you-are-wrong-about-serverless-vendor-lock-in/"><em>https://lumigo.io/blog/you-are-wrong-about-serverless-vendor-lock-in/</em></a></p><ul><li><strong>Systems architecture skills needed by application engineers</strong></li></ul><p>While serverless does boil an application down at its basic level to a function, there are still other supporting components and services that need a deep level of understanding and configuration.</p><p><em>Reality: Yes. Architecture must first be considered and planned; but not only that, launching an application now requires more than just knowing how to code a backend application and put it on a server.</em></p><ul><li><strong>Cost of experienced engineers</strong></li></ul><p>Finding engineers with experience in these new technologies is time consuming and expensive, especially as the demand for their skills increases. The existing engineering team will require upskilling and that will also take time and cost money.</p><p><em>Reality: Yes. But the result should be a reduced requirement to manage infrastructure, meaning less need for DevOps engineers (pricey in today’s market!). It might even be possible to eliminate DevOps and distribute that workload over the existing engineers. This is likely only to be something affecting much larger teams, but something to bear in mind if you are growing fast.</em></p><ul><li><strong>Application latency</strong></li></ul><p>Latency is how long it takes for an application to respond to a request. Generally serverless functions are extremely fast with the average time — depending on language used — of less than 20ms. However, an issue can occur with what is known as “cold start”. Because of how serverless works under the hood, its principle of stripping applications back to their smallest component means that how that function runs — if it’s not called that often — might mean it is much slower the first time it is used. Depending on your application, this could have significant ramifications.</p><p><em>Reality: Yes. However, AWS has made and is continuing to make significant improvements in this area as they understand it is a weakness. Also, there are ways to reduce the impact in your architecture, but it should always be considered in any design phase. Some tips are:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*apDoPdLezW9PMoM5" /></figure><p><em>From a great blog here: </em><a href="https://www.serverless.com/blog/when-why-not-use-serverless"><em>https://www.serverless.com/blog/when-why-not-use-serverless</em></a></p><ul><li><strong>Not suitable for long-running tasks</strong></li></ul><p>A function cannot run for longer than a few minutes and is therefore not suitable for many applications.</p><p><em>Reality: No. On AWS, they can run for upto fifteen minutes and on Azure, an hour with a premium plan. Only GCP imposes more reduced restrictions. I would argue though, that if this is a limitation for your application then serverless is not for you. There are other options between serverless and running your application on a virtual machine that can resolve this issue. One option is to design your application in such a way that longer running tasks can be handled separately.</em></p><p><strong>My business uses a mainframe/servers/regular cloud/PaaS etc. Should I change?</strong></p><p>Before you decide to throw away an application you already have and replace it with something new, serverless or not, this famous article from Joel Spolsky is always worth a read: <a href="https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/">https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/</a></p><p>Granted, that article is twenty years old and a vast amount has changed in terms of how software is built and tested, but many of its central points remain. Wholesale replacement should always be very, very carefully considered. There is a reason why many banking systems still run COBOL applications written in the ’70s (<a href="https://thenewstack.io/cobol-everywhere-will-maintain/">https://thenewstack.io/cobol-everywhere-will-maintain/</a>).</p><p>If you are starting from scratch, you should definitely evaluate a serverless approach. If you have an existing application, however, going serverless is going to be more complicated. The most important first consideration is how much test automation you have in the form of unit and integration testing. If the amount of test coverage you have is high, then you can have much more confidence in replacing it, perhaps in a piecemeal fashion. That way, the whole thing won’t break if there is a significant problem.</p><p>For much older applications, or those with no test coverage, the decision becomes even more complex. One option might be to build a proof of concept and use it to handle a small subset — if that can be identified and isolated — of customers or data to test it on.</p><p>If you are on a mainframe, that decision is going to be the hardest of all. The enormous raw processing power and bandwidth of mainframes is going to be hard to replicate in a cost-effective fashion by going serverless. However, there are examples of companies moving to the Cloud using containers and non-serverless stacks, which allow them to maintain languages unsupported by serverless, and therefore not have to deal with the risk of rewriting critical business logic: <a href="https://aws.amazon.com/blogs/apn/migrating-a-mainframe-to-aws-in-5-steps/">https://aws.amazon.com/blogs/apn/migrating-a-mainframe-to-aws-in-5-steps/</a></p><p>If you determine that serverless might well be the right approach, the next thing to do is perform a cost estimate. There are a lot of calculators out there for the various providers, so I won’t provide a link here (just make sure you pick an up-to-date one) However, to give you an idea of how this might look for AWS, this is a useful article: <a href="https://www.simform.com/aws-lambda-pricing/">https://www.simform.com/aws-lambda-pricing/</a>. One point to note, in the example they give, API requests are the biggest cost — <strong>not</strong> function execution time. Then, there are other studies such as this that show cost effectiveness compared to virtual servers declines significantly at much higher request levels: <a href="https://www.bbva.com/en/economics-of-serverless/">https://www.bbva.com/en/economics-of-serverless/</a>. The point to bear in mind though, is don’t just look at pure hosting costs. This is only one measure of the overall TCO.</p><p>To conclude, wherever you are in your application journey and whatever you decide to do, one thing is clear: it’s easier, quicker, and cheaper than ever to develop and test an idea using serverless technologies, and sometimes that’s all that’s needed to validate a direction of travel.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc8079ab2fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Top Ten Cybersecurity Tips]]></title>
            <link>https://garethdthomas.medium.com/my-top-ten-cybersecurity-tips-f89d2ce4e1c6?source=rss-1ead7d1e6aa5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f89d2ce4e1c6</guid>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Gareth Thomas]]></dc:creator>
            <pubDate>Thu, 25 Jun 2020 11:50:34 GMT</pubDate>
            <atom:updated>2020-07-21T14:53:16.587Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VmfxmbVQEbcx7XAyMiq6wQ.png" /></figure><p>I culled this list from the article below, which is useful but I thought it a shame the author didn’t think to write a condensed intro with a top ten list, so I decided to do it myself. Just be aware that with input from 45 people it is quite long:</p><p><a href="https://secureblitz.com/effective-cybersecurity-strategy-for-a-small-business/">https://secureblitz.com/effective-cybersecurity-strategy-for-a-small-business/</a></p><p>Here is my list based on the answers and my own thoughts (not in priority order as it might alter depending on your business):</p><ol><li>Be aware of outsider attacks — the British Airways hack from a few years ago is a perfect example. Code on the payment page was modified to grab card numbers (mine was one).</li><li>Focus on the core function of your business and let a vetted third-party provider take care of the rest — lots of companies will help to train your staff and manage your security. It’s a specialism and you don’t need to do it alone.</li><li>The weakest link in any organization is your staff. — you can never do enough repeated training and education, creating a Slack channel for everyone and using it to post details of current malware exploits and other tips can be useful.</li><li>Take regular backups — the most mentioned item other than I think the next. What no-one mentioned is something as important, which is regularly testing your backup. You should at least monthly test a restore and make sure it brings back the data you want and you know how to do it. Remember you might have perform this for real under great stress…</li><li>MFA — Always implement multi-factor authentication if its available, ideally using a dedicated app and not SMS,</li><li>Cyber insurance — think about how much the loss of data might cost you, not just from an operational perspective but also in terms of liability and time spent investigating and mitigating any attack.</li><li>Implement a 360-degree cybersecurity plan — this includes firewalls, antivirus software, a backup policy, network security and solutions to protect all connected devices.</li><li>Use a VPN for external network access — a lot more people these days are working from home. If they are connecting into your internal network it must be over a VPN.</li><li>Mobile device management — just about everyone uses a smartphone and a lot of us for business. If it’s stolen and it has access to company systems and data you might need to remove those applications and/or wipe the data.</li><li>Limit exposure generally — this is called the principle of least privilege. Only give users the bare minimum of permissions they need to perform their job.</li></ol><p>One last point is there are a couple of mentions of regular password change being enforced. Interestingly this is no longer accepted good practice and without going into all the reasons why, the best thing is a strong password of at least 14 characters and MFA. If you are interested in the reasons behind this change of recommended practice there is a great article<a href="https://www.sans.org/security-awareness-training/blog/time-password-expiration-die"> here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f89d2ce4e1c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[To Err is Human]]></title>
            <link>https://garethdthomas.medium.com/to-err-is-human-2704dc14fd25?source=rss-1ead7d1e6aa5------2</link>
            <guid isPermaLink="false">https://medium.com/p/2704dc14fd25</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Gareth Thomas]]></dc:creator>
            <pubDate>Thu, 25 Jun 2020 11:43:44 GMT</pubDate>
            <atom:updated>2020-06-25T11:43:44.798Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Brkao2RdHUHU4fpq6MpTbA.png" /></figure><p>I was going to write this as just a status post in LinkedIn but the more I thought about it, the more it annoyed me and the more detail I wanted to put into this rant, and it is a rant. In fact it’s a rant that has been a particular subject of annoyance to me throughout my career, although with the advent of public APIs and Cloud service integration, it’s become even more of a problem.</p><p>In a nutshell: Why does it seem to be so hard for some software engineers to write better error handling? I suspect in bigger companies such as Amazon this is partly the fault of product management but it’s also the fault of failing to understand how a customer will use your product and what might make using it especially hard, or not caring.</p><p>The perpetrator in this case is Amazon Web Services (AWS), which I will start off by saying I am huge fan of and have spent a lot of time using (back to when it launched with just S3). The service in question is API Gateway, which, for those not familiar provides a means to offer a public API that can integrate with a host of other AWS services.</p><p>In this scenario I was looking to write tests that would enable me to check that endpoints I was building to verify an architecture concept would work. The setup for this service is at a very high-level API Gateway&gt;State Machine&gt;Lambda, in addition this requires some custom permission roles in IAM to manage interaction between the components, and the reason I mention this is when it comes to debugging the error I am going to show you, it requires digging into all of these areas because the message does not describe the real problem.</p><p>Here is the message:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AGuuxFMzN2hwgMMHsWnwog.png" /></figure><p>The eagle-eyed amongst you will have noticed that the issue is the object property containing the ARN for the state machine is misspelled, but on first glance I did what many people would do and assumed something was incorrect at one of the levels of the integration with a needed value not being passed or some incorrect setting. After a bit of digging I knew the problem wasn’t in the state machine as it wasn’t even being called (no log entries were visible) so it was in the API Gateway or so I thought. Anyway, the point being I wasted probably 30 minutes trying to find this.</p><p>What I don’t understand is why API gateway doesn’t appear to parse the body to see if the properties are even valid and report those errors as a first level response? What I should see is an error message something like <em>“1 validation error detected: unknown property stateMarchineArn”</em> and bingo, one minute later I would’ve had it working.</p><p>If you were to add up the wasted hours software engineers spend trying to integrate APIs with poor error handling, it’s got to be costing companies tens of millions every year. But perhaps the problem here is there is no obvious “hero” if the engineer integrating it finds it all smooth sailing as it won’t lead to more sales because either he/she won’t tell anyone or no-one will care. Which is a shame as well as a missed opportunity.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2704dc14fd25" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>