<p>A great software architect is an invaluable partner!</p>

<p>A software architect is a professional who is responsible for designing and planning the software systems that a business uses. They work with software developers, project managers, and other stakeholders to create a plan for the software system that meets the needs of the business.</p>

<p>A good software architect can help ensure that the software system is designed to be efficient, reliable, and scalable. They can also help the business stay on top of the latest trends in technology and make informed decisions about which tools and technologies to use.</p>

<p>Its main responsibilities are:</p>

<ul>
<li>Converts functional requirements to technical architecture</li>
<li>Carefully balances patterns, requirements, elegance, and concepts</li>
<li>Researches key technologies</li>
<li>Has deep understanding of design patterns</li>
<li>Motivates and guides the development team</li>
<li>Ensures that the Tech Lead is successful</li>
</ul>

<p>Additionally, a software architect can help a business reduce costs by identifying areas where technology can be used to streamline operations and automate processes. This can lead to increased productivity and efficiency, which can ultimately lead to greater profits.</p>

The Software Architect

<p>Cost optimization is important when developing solutions, including serverless applications on AWS Lambda.</p>

<p>To achieve this, it is advised to write efficient code, consider downstream services when making architectural decisions, continuously improve optimization, and prioritize changes that have the greatest impact.</p>

<p>Lambda pricing is calculated as a combination of:</p>

<ul>
    <li>Total number of requests</li>
    <li>Total duration of invocations</li>
    <li>Configured memory allocated</li>
</ul>

<h2>Right-Sizing</h2>

<p>Starting with right-sizing is an effective way to optimize costs without compromising performance or changing the code of an application. In AWS Lambda, right-sizing involves adjusting the memory configuration of a function, which ranges from 128 MB to 10 GB. This adjustment also impacts the amount of vCPU available during execution, allowing for improved performance and a reduced invocation duration.</p>

<h2>Performance efficiency</h2>

<p>The duration of a Lambda invocation is an important factor in its pricing. If the function takes longer to run, it will cost more and result in higher latency in the application.</p>

<h2>AWS Graviton2</h2>

<p>As of September 2021, Arm-based AWS Graviton2 processors can be used to power Lambda functions. Graviton2 functions offer improved performance and cost-efficiency compared to x86, with up to 19% better performance at 20% lower cost. Using Graviton2 processors can also lead to a reduction in function duration due to the improved CPU performance, resulting in even lower costs.</p>

<h2>Provisioned concurrency</h2>

<p>To reduce Lambda function cold starts or avoid burst throttling, provisioned concurrency provides pre-ready execution environments for invocation. It can also lower Lambda costs when there is a steady volume of traffic, as the pricing model for provisioned concurrency offers a lower total price when fully used.</p>

<h2>AWS Savings plans</h2>

<p>AWS Savings Plans is a pricing model that offers lower prices than on-demand pricing for a one- or three-year period, in exchange for a specific usage commitment measured in $/hour. Compute Savings Plans provide a discounted rate of up to 17% for Lambda usage in duration and provisioned concurrency over a 1- or 3-year term.</p>


AWS Lambda Cost Optimization

<p>What is simple is not always easy.</p>

<p>Rich Hickey's presentation, "Simple Made Easy”, explores the idea that simplicity is not always synonymous with easiness. He emphasizes the importance of deliberate choices in seeking simplicity. The term "simple" is derived from the notion of being singular or unified, and he urges us to apply this concept to programming.

<p>Consider visualizing something that possesses a single instance of an element, such as a solitary role, task, concept, or dimension. By doing so, that particular element becomes concentrated and unambiguous in its purpose, benefitting from its singularity.
<p></p>
<a class="btn" href="https://www.infoq.com/presentations/Simple-Made-Easy/" target="_blank">Watch Presentation</a>

Simple made easy

<p>The concept of middleware in software development often follows the Chain of Responsibility design pattern.</p>

<p>Middleware is a common pattern used in various types of software systems, such as web applications or message processing systems. It acts as a pipeline for processing requests or events, where each middleware component in the pipeline can either handle the request or pass it to the next component in the chain.</p>

<p>In the Chain of Responsibility pattern, a request is passed through a chain of potential handlers until one of them handles it. Similarly, in a middleware architecture, a request or event is passed through a series of middleware components, and each component has the opportunity to process or modify the request before passing it along to the next middleware component.</p>

Chained Middleware

<p>Loose coupling in programming promotes modularity, flexibility, and maintainability. It involves minimizing dependencies between software components, allowing them to function independently. Here are the main advantages of loose coupling techniques.</p>

<ul>
    <li>
        <strong>Modularity and Reusability:</strong>
        Loose coupling enables the creation of self-contained modules that can be easily understood, tested, and modified. It encourages code reuse, saving time and effort. Independent components also facilitate collaboration and streamline development.
    </li>
    <li>
        <strong>Flexibility and Adaptability:</strong>
        Loose coupling allows for changes in one module without affecting others, providing flexibility. It simplifies integrating third-party libraries or services, making applications adaptable and future-proof.
    </li>
    <li>
        <strong>Testability and Debugging:</strong>
        Independent modules are easier to test and debug, as they can be isolated. Unit testing becomes more effective, and troubleshooting is faster due to smaller and well-defined modules.
    </li>
    <li>
        <strong>Scalability and Maintainability:</strong>
        Loose coupling supports system growth by enabling the addition of new modules without disrupting existing components. It promotes concurrent development and simplifies maintenance, reducing errors.
    </li>
    <li>
        <strong>Future-proofing and Extensibility:</strong>
        Loose coupling facilitates extending or replacing modules without extensive modifications. It enhances adaptability to emerging technologies and simplifies integration with external systems or APIs.
    </li>
</ul>

<p>Loose coupling enhances code quality, scalability, and maintainability. Its benefits include modularity, flexibility, and adaptability. By promoting independent components, loose coupling enables efficient testing, debugging, collaboration, and future-proofing of software systems.</p>

Loose Coupling

<p>Design patterns are an invaluable asset when building applications in a clean, easy-to-maintain, and easy-to-debug manner. One pattern that I hold in high regard is the Strategy Pattern. If you’re familiar with Dependency Injection, you might find that the Strategy Pattern operates on a somewhat similar principle, albeit with its own distinct use cases.</p>

<p>With this article, my goal is to elucidate how the Strategy Pattern can be seamlessly integrated into your application. By the time you reach the end of this article, I am confident that you will have grasped the fundamental concept behind the Strategy Pattern.</p>

<p>Let’s dive in by establishing a definition. What exactly is the Strategy Pattern?</p>

<h2>Demystifying the Strategy Pattern</h2>

<p>The Strategy Pattern is a design pattern that enables you to switch out algorithms or strategies at runtime, without altering the code that uses them. Essentially, it involves defining a family of algorithms, encapsulating each one, and making them interchangeable. This brings flexibility and promotes cleaner, more decoupled code by segregating the behavior (algorithm/strategy) from the context (class) that uses it.</p>

<h2>A Real-Life Example</h2>

<p>Imagine you’re on a trip and need to navigate to various places. Your smartphone is like an application using the Strategy Pattern. The navigation app is the toolbox, and the different modes of transportation, such as driving, walking, or cycling, are the strategies. You can easily switch between these modes depending on your needs, without changing the navigation app itself. Similarly, the Strategy Pattern lets your code switch between different algorithms or behaviors effortlessly.</p>

<h2>Code Example with TypeScript: Payment System</h2>

<p>Now, let’s translate this into code with a TypeScript example. Imagine you’re building an online store that supports different payment methods like PayPal, Credit Card, or Bitcoin. Using the Strategy Pattern, we can easily switch between these payment methods. The Strategy Pattern is perfect for this scenario.</p>

<p>First, define an interface representing the payment strategy:</p>

<pre class="language-javascript">
<code>
interface PaymentStrategy {
    processPayment(amount: number): void;
}
</code>
</pre>

<p>Now, implement concrete payment strategies:</p>

<pre class="language-javascript">
<code>
class PayPalStrategy implements PaymentStrategy {
    processPayment(amount: number): void {
        console.log(`Paid ${amount} using PayPal.`);
    }
}

class CreditCardStrategy implements PaymentStrategy {
    processPayment(amount: number): void {
        console.log(`Paid ${amount} using Credit Card.`);
    }
}

class BitcoinStrategy implements PaymentStrategy {
    processPayment(amount: number): void {
        console.log(`Paid ${amount} using Bitcoin.`);
    }
}
</code>
</pre>

<p>Create a context class, OnlineStore, to use these payment strategies:</p>

<pre class="language-javascript">
<code>
class OnlineStore {
    private paymentStrategy: PaymentStrategy;
    
    constructor(paymentStrategy: PaymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    
    checkout(amount: number): void {
        this.paymentStrategy.processPayment(amount);
    }
}
</code>
</pre>

<p>Finally, let’s see the Strategy Pattern in action by making payments using different methods:</p>

<pre class="language-javascript">
<code>
const paypal = new PayPalStrategy();
const storeWithPayPal = new OnlineStore(paypal);
storeWithPayPal.checkout(100); // Outputs: "Paid 100 using PayPal."

const creditCard = new CreditCardStrategy();
const storeWithCreditCard = new OnlineStore(creditCard);
storeWithCreditCard.checkout(200); // Outputs: "Paid 200 using Credit Card."

const bitcoin = new BitcoinStrategy();
const storeWithBitcoin = new OnlineStore(bitcoin);
storeWithBitcoin.checkout(300); // Outputs: "Paid 300 using Bitcoin."
</code>
</pre>

<p>Just like changing navigation modes, here you can easily swap out payment options without modifying the OnlineStore class itself.</p>

<h2>Visualizing the Payment System</h2>

<p>Before we conclude, let’s visualize the payment example with a drawing. In the illustration below, you’ll observe the `PaymentStrategy` interface on the right side. This interface plays a crucial role in mandating that the `processPayment()` method is implemented by the different payment strategy options. In our example, PayPal, Credit Card, and Bitcoin are the concrete strategies that implement this interface, thus each is required to define how the `processPayment()` method works.</p>

<img src="/blog/strategy-design-pattern-diagram.jpg" alt="Strategy Design Pattern" />

<p>On the left side of the drawing is the `OnlineStore`, which utilizes these payment strategies without any knowledge of their internal workings. This encapsulation is one of the beauties of the Strategy Pattern — regardless of the payment option, the interaction remains consistent and seamless for the `OnlineStore`. This consistency is achieved because all payment strategies adhere to the same contract defined by the `PaymentStrategy` interface.</p>

<h2>Strategize Your Coding Journey</h2>

<p>In summary, we’ve introduced different payment options and made them effortlessly switchable without having to worry about compatibility across all payment strategies. The interface ensures that all payment methods adhere to a common blueprint, guaranteeing smooth integration.</p>

<p>If I were to rename the Strategy Pattern, I might call it the ‘Option Pattern.’ This is because it essentially allows you to switch between options effortlessly. Of course, the pattern encompasses more than just this, but the name captures the essence of its flexibility and the ease with which it allows changes.</p>

<p>Understanding and implementing the Strategy Pattern can greatly enhance the adaptability and maintainability of your code, especially in scenarios where behaviors or algorithms are subject to change or extension.</p>

<p>Happy coding, and may the Strategy Pattern empower your programming toolkit!</p>


Architecture

The Software Architect

AWS Lambda Cost Optimization

Simple made easy

Chained Middleware

Loose Coupling

Strategy Design Pattern

Need some help?

Services

Products

Cases

Blog

Contact