<p>Imagine a world overflowing with apps and services, all vying for your attention. You, the user, feel overwhelmed by endless options, each promising a solution but delivering frustration. You tap, you swipe, you sigh. There must be a better way.</p>

<p>Enter User-Centered Design (UCD), your trusty guide in this cluttered landscape.</p>

<p>UCD isn't about flashy features or empty promises. It's about understanding you, the hero of this story. Through research (think interviews and tests), UCD dives deep to uncover your needs, goals, and the villains – the pain points that make using other products such a chore.</p>

<p>With empathy as its weapon, UCD crafts an intuitive interface, your loyal companion on this journey. It's clear, concise, and easy to navigate, like a well-written map. No more confusing menus or dead ends. UCD prioritizes a smooth, efficient experience that feels delightful to use – a victory against frustration!</p>

<p>But the story doesn't end there. UCD is your constant companion, always seeking ways to improve. Just like a hero who gets stronger with each battle, UCD uses user feedback to refine your product, ensuring it stays relevant and user-friendly.</p>

<p>By embracing UCD, you, the user, become the hero of a success story. Here's what your happily-ever-after looks like:</p>

<ul>
    <li>Increased Satisfaction: You conquer challenges with ease, enjoying a product that anticipates your needs.</li>
    <li>Enhanced Brand Reputation: The product becomes a legend, praised for its user-friendliness, attracting new heroes to join the journey.</li>
    <li>Improved ROI: Just like a well-trained army, UCD saves resources by identifying and fixing problems early on.</li>
</ul>

<p>UCD isn't a fad; it's the key to crafting a legendary product.  Make your users the heroes of their own stories –  incorporate UCD and create a user experience that's truly unforgettable.  Ready to embark on this adventure?  Start your happily-ever-after with UCD today.</p>

How User-Centered Design Makes You the Hero of Your Users' Story

<p>Dave, a talented UX/frontend engineer, surveyed the new project with a sinking feeling. The deadline loomed, features overflowed like a toppling inbox, but the underlying codebase? A tangled web of cryptic names and sprawling functions. Every edit felt like hacking through a jungle.</p>

<p>"There has to be a better way," Dave muttered, staring at the indecipherable code. The frustration was palpable – wasn't clean code the foundation for a great user experience?</p>

<p>Dave knew speed was crucial, but cutting corners on code quality would only lead to bugs and delays down the line. He decided to take action.</p>

<p>Armed with his experience, Dave rallied the UX/frontend team. They championed established coding standards, the silent heroes of readability and maintainability. He led by example, crafting clean, well-documented code that felt like a well-maintained park – a joy to navigate. Finally, they approached the backend developers as allies in the quest for clean code.</p>

<p>Through open communication and collaboration, a new standard emerged. The codebase transformed – functions became modular, comments clear, and names descriptive. Editing code became a breeze, bugs became rarities, and the entire project hummed with newfound efficiency.</p>

<p>Dave watched with satisfaction as the user interface flourished on top of the clean code foundation. His motto – clean code for a great project – had become a reality. The tangled web was a distant memory, replaced by a symphony of collaboration and quality. The project not only met its deadline but set a new standard for future endeavors. Dave had conquered the code, not with brute force, but with the power of collaboration and clean code.</p>


A Clean Code's Tale

<p>You've poured your heart and soul into crafting the perfect feature for your new project. But a nagging worry persists - what if the user experience (UX) crumbles under the weight of your brilliant product?</p>

<p>Enter the hero: low-fidelity prototyping. It's the design equivalent of a quick sketch before a masterpiece. Basic, fast, and focused on function, it's like the childhood fort built from blankets and chairs - pure, unadulterated purpose.</p>

<p>Here's where low-fi prototyping transforms from a curious concept to your secret weapon:</p>

<ul>
    <li><strong>Fast and Frugal:</strong>  No need for weeks of development. Low-fi prototypes take mere hours, freeing you to test multiple ideas early and iterate without breaking the bank.</li>
    <li><strong>Core First:</strong> Forget fancy bells and whistles. Low-fi keeps the focus on core functionalities and user flows, ensuring a solid foundation for your dazzling copy.</li>
    <li><strong>Feedback Frenzy:</strong> The rough edges become an advantage. Users, unburdened by visual details, give honest feedback on what works and what flops in the overall user journey.</li>
    <li><strong>Flexibility is Freedom:</strong>  Low-fi prototypes are disposable heroes. Since they're not precious investments, bad ideas can be tossed aside, and new ones embraced based on user insights.</li>
</ul>


<p>What does this hero look like? Pen-and-paper sketches, wireframes built with basic shapes, even digital mockups with placeholder text. The key is to convey the core user journey without getting bogged down in visual details.</p>

<p>The kicker? Low-fi prototypes are universally applicable. Websites, apps, even physical products - they all benefit from this early user feedback loop.  Imagine the power: user buy-in secured, ensuring your final product is not just beautiful, but truly user-friendly - a product manager's dream come true.</p>

<p>So, the next time you're tempted to dive headfirst into high-fidelity design, remember the power of low-fidelity prototyping. It might just be the secret weapon that takes your project from good to great, with your perfectly crafted message shining through a user-centered experience.</p>


How Low-Fi Prototyping Saves the Day

<p>Excitement buzzed in the air at TetraTech Inc. Their latest product, the "Productivity Pulse" app, was about to launch a brand new feature – the "Focus Flame." This innovative tool used gamification to motivate users to stay on task. The developers were confident it would be a hit.</p>

<p>"This is going to change everything!" declared Mark, the lead developer, as he unveiled the Focus Flame at the team meeting. The room erupted in cheers. Visions of happy, productive users and soaring app ratings danced in their heads.</p>

<p>Weeks turned into months as the team meticulously crafted the Focus Flame. It was visually stunning, with animated flames that grew larger as users stayed focused. They even added motivational quotes and badges for extended focus streaks.</p>

<p>The "Focus Flame" update launched with a bang. Confetti rained down on the TetraTech office as they celebrated. But as the days passed, a chilling silence descended. No surge in user engagement, no ecstatic reviews, just...crickets.</p>

<p>Disheartened, the team decided to investigate. User interviews revealed a startling truth. The gamification felt childish, and the motivational quotes were cheesy.  The constant animation was distracting, and the app notifications urging them to "stoke the flame" were annoying.</p>

<p>This user feedback was a wake-up call. TetraTech embraced a user-centered approach.  They conducted surveys and usability tests, held focus groups, and analyzed user data.  What they discovered was that users craved a simpler, more streamlined experience that helped them  avoid distractions, not create them.</p>

<p>Back to the drawing board they went. This time, they focused on features like timeboxing tools, website blockers, and white noise generators – features users genuinely needed.  When the new update launched, it was a resounding success.  Users raved about the improved focus and productivity. TetraTech finally had a product their users loved.</p>

<p>This story highlights the importance of understanding user needs before development.  By prioritizing user-centered design, TetraTech transformed the "Productivity Pulse" from a feature flop into a beloved productivity tool.</p>

Avoiding the Feature Flop

<p>A familiar knot of dread twisted in John's gut as he saw his competitor's announcement. Three new features, each a perfect echo of their clients' frustrations. Panic gnawed at him. His team, talented and passionate, was falling behind in the startup race.</p>

<p>Back at the office, tension crackled. The sales team was swamped with calls from clients, all asking the same question: "When will I get the feature that you promised me?" In a team meeting, John's voice held a heavy weight. "I know everyone's giving their all," he said, "but we need to be smarter. We need to prioritize features that truly matter to our clients."</p>

<p>John, ever resourceful, remembered As One, that frontend-focused software house known for navigating startups through tech's ever-changing landscape. With a flicker of hope, he reached out, laying bare their challenges. As One swiftly assembled a team, focusing on three pillars:</p>

<ul>
    <li>User-driven choices: Through surveys and testing, they unearthed client needs, empowering John's team to make informed decisions.</li>
    <li>Faster development: As One introduced modular design, allowing them to break down complex features for quicker development and testing.</li>
    <li>Stronger collaboration: They emphasized open communication and collaboration, fostering a culture of shared ideas and building trust.</li>
</ul>

<p>John and his team crafted a clear roadmap. As the new features rolled out, John watched with a swelling sense of pride as his team's hard work paid off. Client satisfaction soared. The road ahead held challenges, but John knew his team, united with the right approach and the right people, was ready to face them.</p>

<p>Have you ever faced such a challenge? How did you tackle it?</p>

Client-Driven Innovation: A Startup's Path to Victory

<p>Let me share a story that left a lasting impact on me. I was at work, and the time for the quarterly feedback session with my team lead was approaching. Like most people, I prepared myself for the usual routine of hearing some praise followed by areas that needed improvement.</p>

<p>On the day of the session, my lead surprised me. Instead of immediately sharing his thoughts on my performance, he asked for my feedback first. It caught me off guard, as I didn't have any major concerns to raise. We had been having ongoing conversations, addressing any issues as they arose, rather than waiting until the end of the quarter. When he asked if I felt supported, I genuinely nodded. He had always been there for us.</p>

<p>Then it was his turn to provide feedback. The first point he made was a compliment, bringing a smile to my face. The second point was also positive. I waited for the expected "but," the criticism I assumed was coming. But to my surprise, it never came. "That's all," he said.</p>

<p>I felt a sense of lightness. Leaving the session, I wasn't just relieved, I was genuinely happy. This meeting turned out to be a game-changer for me. It shattered my belief that feedback always had to include negative points. I developed a new level of trust with my lead, which fueled my motivation to work even harder.</p>

<p>That day taught me an important lesson: negative feedback isn't everything. We tend to believe that feedback is solely about pushing people to grow by pointing out their flaws. But isn't it equally crucial to acknowledge their strengths and accomplishments? Sometimes, individuals may not even realize their own value. So, why not utilize feedback sessions to recognize and highlight their contributions as well?</p>

An Awesome Feedback Experience

<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>


Strategy Design Pattern

<p>This is the most commonly seen workflow:</p>

<ol>
    <li>Product managers talk to users, scope requirements, prioritize things to build, and manage the delivery of new features.</li>
    <li>Product designers also talk to users, and then mock up features, bringing requirements to life.</li>
    <li>Engineers build what’s defined in the requirements.</li>
</ol>

<p>I know this is a simplistic view, but many companies operate this way, in effect creating silos between the different groups, which leads to misalignment on what people are trying to accomplish.</p>
<p>Everything I described above is about outputs.</p>
<p>If you ask a developer, “What’s your job?” they might say, “To build what I’m told.” (I’m exaggerating to make a point.) That’s not their job. Their job—as is the case with everyone building stuff—is to solve problems and create value. Defining the specific tasks to get there is much harder, but the outcome is value creation, not lines of code, features, or anything else.</p>

<h2>Outcomes > Outputs</h2>

<p>If you can get your entire team aligned on outcomes over outputs — solving problems and creating value — instead of the details of the work they’re executing, you have a chance of creating something significant.</p>

Building Value

<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>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>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>Next.js is a web development framework that many developers use to build fast and responsive web applications. Every time a new release of Next.js is announced, people get excited to see what new features have been added.</p>
<p>The React ecosystem has been exploring various ideas around forms, managing form states, and caching and revalidating data. However, there has been no way to compose server mutations and data primitives. Recently, Vercel, the company behind Next.js, released a new version called Next.js 13.4, which includes a new feature called Server Actions. This allows you to mutate data on the server, without the need for an in-between API layer.</p>
<p>Server Actions are designed to help developers update data on the server more easily, reduce the amount of JavaScript needed on the client side, and provide more responsive and interactive forms. They are designed to deeply integrate with the rest of the data lifecycle, including the Next.js Cache, Incremental Static Regeneration (ISR), and the client router. Additionally, they are composable, meaning that anyone in the React community can build and publish Server Actions.</p>
<p>Revalidating data through new APIs revalidatePath and revalidateTag ensures that the correct data is displayed on the client, even if the upstream provider is slow. This means that mutating, re-rendering the page, or redirecting can happen in one network round trip. With features like Optimistic Updates and Progressive Improvement, users can see the effects of their actions without having to wait for the server to respond, leading to a more interactive and enjoyable experience. This is an exciting development for the React community, as it opens up new possibilities for server-side data mutations and form handling.</p>
<p>In conclusion, Server Actions are a game-changing addition to the Next.js ecosystem. They offer many benefits for both developers and users, including better performance, improved user experience, and a more streamlined development process. With Server Actions, web developers can build faster, more responsive, and more engaging web applications than ever before.</p>


Server Actions are the best new feature in Next.js

<p>So how do you spot fake accounts? In general, fake accounts have been recently created, with only a few friends or followers. They will sometimes send odd-sounding messages that include suspicious links, or there may be spelling errors in their account names, URLs, or messages.</p>

<p>Be vigilant when you’re online, and don’t share personal information or images when you accept new friend or follower requests. Never give money to someone who asks for it online, and leave any site that looks suspicious.</p>

<p>If you’re concerned that scammers might steal your identity, adjust your privacy settings so your profile isn’t public, and think carefully about any information you share in your profile updates. For example, personal information like your kids’ or pets’ names could be used to create a fake digital account under your name.</p>

<p>To look for hackers who may have stolen your digital identity, do a regular online search for your name and see what comes up. With a reverse image search, you can also upload a photo and see where that image is being used online.</p>

How to Protect Yourself Against Digital Impersonation

<p>A VPC endpoint lets you connect your VPC to AWS services privately, without needing an internet gateway, NAT device, VPN, or Direct Connect. Endpoints are virtual devices that are highly available and allow communication between instances in your VPC and services. This saves costs and reduces availability risks and bandwidth constraints.</p>

<p>There are three types of VPC endpoints: gateway load balancer, gateway, and interface endpoints.</p>

<p>Gateway load balancer endpoints route traffic to network or security services, while gateway endpoints provide access to S3 and DynamoDB, with granular access control via VPC endpoint policies.</p>

<p>The Gateway endpoint type lets you access Amazon S3 and DynamoDB, with granular control via VPC endpoint policies. These policies can restrict access to specific resources, allowing certain users or groups to access them through the VPC endpoint.

<p>Interface endpoint type lets you connect to services powered by AWS PrivateLink, including AWS and partner services, without relying on the public internet. Like Gateway endpoints, Interface endpoints can be secured with resource policies and security groups to restrict access.</p>

<p>VPC sharing enables multiple AWS accounts to create application resources within a centralized network, which can include EC2 instances, RDS databases, and Lambda functions. Establishing strict access controls is important for organizational security and compliance objectives, while also maintaining operational efficiency.</p>


Reduce Cost and Increase Security with Amazon VPC Endpoints

<p>Given an integer as input, can you round it to the next (meaning, "greater than or equal") multiple of 5?</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function roundToNext5(n: number): number {
  return n + (5 - n) % 5;
}

console.log(roundToNext5(100));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func roundToNext5(n int) int {
  return n + (5 - n % 5) % 5
}

func main() {
  fmt.Println(roundToNext5(100))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def round_to_next_5(n):
    return n + (5 - n) % 5

print(round_to_next_5(100))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function roundToNext5($n) {
  return $n + (5 - $n % 5) % 5;
}

echo roundToNext5(100);
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/55d1d6d5955ec6365400006d">Go to Kata</a>


Kata of the Day #22

<p>We need a simple function that determines if a plural is needed or not. It should take a number, and return true if a plural should be used with that number or false if not. This would be useful when printing out a string such as 5 minutes, 14 apples, or 1 sun.</p>

<p>You only need to worry about english grammar rules for this kata, where anything that isn't singular (one of something), it is plural (not one of something).</p>

<p>All values will be positive integers or floats, or zero.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function plural(n: number): boolean {
  return n !== 1;
}

console.log(plural(100));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
	"fmt"
)

func plural(n int) bool {
  return n != 1
}

func main() {
	fmt.Println(plural(100))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def plural(n):
    return n != 1

print(plural(100))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function plural($n) {
  return $n != 1;
}

echo print_r(plural(100));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/52ceafd1f235ce81aa00073a">Go to Kata</a>


Kata of the Day #21

<p>Your goal in this kata is to implement a difference function, which subtracts one list from another and returns the result.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function arrayDiff(a: number[], b: number[]): number[] {
    return a.filter(e => !b.includes(e));
}

console.log(arrayDiff([3, 4], [3]));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
	"fmt"
)

func arrayDiff(a []int, b []int) []int {
	diff := []int{}
	for _, e := range a {
		if !contains(b, e) {
			diff = append(diff, e)
		}
	}
	return diff
}

func contains(arr []int, val int) bool {
	for _, el := range arr {
		if el == val {
			return true
		}
	}
	return false
}

func main() {
	fmt.Println(arrayDiff([]int{3, 4}, []int{3}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def array_diff(a, b):
    return [e for e in a if e not in b]

print(array_diff([3, 4], [3]))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function arrayDiff($a, $b) {
    return array_filter($a, function($e) use ($b) {
        return !in_array($e, $b);
    });
}

echo print_r(arrayDiff([3, 4], [3]));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/523f5d21c841566fde000009">Go to Kata</a>

Kata of the Day #20

<p>DevOps methodologies were created to develop applications and services faster to meet user demands. However, earlier DevOps processes prioritized agility over security, leading to security flaws in applications.</p>

<p>DevOps teams often prioritize fast delivery over quality, but software quality, especially in terms of security, is crucial. Delaying security checks until the end of the software lifecycle can lead to significant delays and difficulties in resolving vulnerabilities. Using a DevSecOps framework and the right tools can help identify and remediate vulnerabilities early on and reduce software rollout delays.</p>

<p>Failing to use effective tools and training can lead to misidentified vulnerabilities and discouraged teams. Investing in DevOps security practices can benefit organizations in both technical and non-technical ways.</p>

<p>It's never too late to integrate necessary DevOps security checks into existing workflows and deliver better and safer code at the speed of business.</p>


Why do DevOps practices fail in security?

<p>Finish the solution so that it sorts the passed in array of numbers. If the function passes in an empty array or null/nil value then it should return an empty array.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function sortNumbers(nums: number[]): number[] {
    return nums.sort((a, b) => a - b);
}

console.log(sortNumbers([1, 10, 2]));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
    "fmt"
    "sort"
)

func sortNumbers(nums []int) []int {
    sort.Ints(nums)
    return nums
}

func main() {
    fmt.Println(sortNumbers([]int{1, 10, 2}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def sort_numbers(nums):
    return sorted(nums)

print(sort_numbers([1, 10, 2]))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function sortNumbers($nums) {
    sort($nums);
    return $nums;
}

print_r(sortNumbers([1, 10, 2]));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5174a4c0f2769dd8b1000003">Go to Kata</a>


Kata of the Day #19

<p>When provided with a letter, return its position in the alphabet.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function position(alphabet: string): string {
  const position = "abcdefghijklmnopqrstuvwxyz".split('').indexOf(alphabet) + 1;
  return `Position of alphabet: ${position}`;
}

console.log(position("c"));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
    "fmt"
    "strings"
)

func position(alphabet string) string {
    position := strings.Index("abcdefghijklmnopqrstuvwxyz", alphabet) + 1
    return fmt.Sprintf("Position of alphabet: %d", position)
}

func main() {
    fmt.Println(position("c"))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def position(alphabet):
    position = "abcdefghijklmnopqrstuvwxyz".index(alphabet) + 1
    return f"Position of alphabet: {position}"

print(position("c"))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function position($alphabet) {
    $position = strpos("abcdefghijklmnopqrstuvwxyz", $alphabet) + 1;
    return "Position of alphabet: $position";
}

echo position("c");
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5808e2006b65bff35500008f">Go to Kata</a>


Kata of the Day #18

<p>Complete the function which converts hex number (given as a string) to a decimal number.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function hexToDec(hexString: string):number{
    return parseInt(hexString, 16);
}

console.log(hexToDec("FF"));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
	"fmt"
	"strconv"
)

func hexToDec(hexString string) int64 {
	decimal, _ := strconv.ParseInt(hexString, 16, 32)
	return decimal
}

func main() {
	fmt.Println(hexToDec("FF"))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def hex_to_dec(hexString):
    return int(hexString, 16)

print(hex_to_dec("FF"))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function hexToDec($hexString) {
    return hexdec($hexString);
}

echo hexToDec("FF");
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57a4d500e298a7952100035d">Go to Kata</a>


Kata of the Day #17

<p>Complete the function that takes a non-negative integer n as input, and returns a list of all the powers of 2 with the exponent ranging from 0 to n ( inclusive ).</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function powersOfTwo(n: number): number[] {
    let acc: number[] = [];

    for (let i = 0; i <= n; i++) {
        acc.push(Math.pow(2, i));
    }

    return acc;
}

console.log(powersOfTwo(10));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func powersOfTwo(n int) []int {
    acc := make([]int, n+1)

    for i := 0; i <= n; i++ {
      acc[i] = int(math.Pow(2, float64(i)))
    }

    return acc
}

func main() {
	fmt.Println(powersOfTwo(10))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def powers_of_two(n):
    acc = []
    for i in range(n+1):
        acc.append(2**i)
    return acc

print(powers_of_two(10))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function powersOfTwo(int $n): array {
    $acc = [];

    for ($i = 0; $i <= $n; $i++) {
        $acc[] = pow(2, $i);
    }

    return $acc;
}

print_r(powersOfTwo(10));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57a083a57cb1f31db7000028">Go to Kata</a>



Kata of the Day #16

<p>Generative AI tools like ChatGPT and GitHub CoPilot have immense potential to transform the business landscape, similar to the internet, smartphones, and cloud computing. However, the rapid progress of AI technology has also increased the risks of cybercrime. Therefore, it is essential for organizations to reassess their risk management strategies and develop defensive and offensive measures to prevent cyberattacks.</p>

<p>Here are three key strategies that IT and security executives should consider when evaluating their cybersecurity posture in the age of AI.</p>

<h2>1. Fight AI with AI</h2>

<p>AI has the potential to enhance cybersecurity by improving the skills of defense teams and augmenting their abilities, as well as assisting entry-level analysts with routine duties and increasing the coding and scripting capabilities of security engineers.</p>

<h2>2. Safeguard Your Email</h2>

<p>Most cyberattacks start with fraudulent emails that use phishing and social engineering tactics to harvest credentials and gain access to organizations. Advances in AI are making these attacks more sophisticated and integrating AI-powered chatbots into social engineering toolkits will make them even more widespread.</p>

<h2>3. Defend the Data</h2>

<p>Organizations should move beyond traditional perimeter defenses and focus on securing data and controlling access. This can be achieved through a zero-trust architecture with a SASE solution and phishing-resistant MFA.</p>

<p>Internet-facing applications and APIs are vulnerable to various attacks, including those carried out by bots or other AI-driven attacks. Proper protections like encryption, WAF, input validation, and rate-limiting can help mitigate these risks.</p>

<p>Companies must also ensure users do not misuse or leak company data when using AI tools.</p>


Protecting your company in a ChatGPT World

<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>Write a function that takes a list of strings as an argument and returns a filtered list containing the same elements but with the 'geese' removed.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function gooseFilter (birds: string[]): string[] {
    const geese: string[] = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"];
    return birds.filter(bird => ! geese.includes(bird));
}

console.log(gooseFilter(['African', 'Not Geese']));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func gooseFilter(birds []string) []string {
	geese := []string{"African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"}

	filteredBirds := make([]string, 0)
	for _, bird := range birds {
		if !contains(geese, bird) {
			filteredBirds = append(filteredBirds, bird)
		}
	}

	return filteredBirds
}

func contains(sl []string, name string) bool {
	for _, value := range sl {
		if value == name {
			return true
		}
	}
	return false
}

func main() {
	fmt.Println(gooseFilter([]string{"African", "Not Geese"}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def goose_filter(birds):
    geese = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"]
    return [bird for bird in birds if bird not in geese]

print(goose_filter(['African', 'Not Geese']))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function goose_filter($birds) {
    $geese = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"];
    $filteredBirds = [];

    foreach ($birds as $bird) {
        if (!in_array($bird, $geese)) {
            $filteredBirds[] = $bird;
        }
    }

    return $filteredBirds;
}

print_r(goose_filter(['African', 'Not Geese']));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57cfdf34902f6ba3d300001e">Go to Kata</a>



Kata of the Day #15

<p>You will be given a list of strings. You must sort it alphabetically (case-sensitive, and based on the ASCII values of the chars) and then return the first value.</p>

<p>The returned value must be a string, and have "***" between each of its letters.</p>

<p>You should not remove or add elements from/to the array.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function twoSort(s: string[]): string {
    return s.sort()[0].split('').join('***');
}

console.log(twoSort(['banana','apple']));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
    "fmt"
    "sort"
    "strings"
)

func twoSort(s []string) string {
    sort.Strings(s)
    return strings.Join(strings.Split(s[0], ""), "***")
}

func main() {
    fmt.Println(twoSort([]string{"banana", "apple"}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def two_sort(array):
    return '***'.join(min(array))

print(two_sort(['banana','apple']))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function twoSort($s) {
    sort($s);
    return implode('***', str_split($s[0]));
}

echo twoSort(['banana','apple']);
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57cfdf34902f6ba3d300001e">Go to Kata</a>


Kata of the Day #14

<p>Given a random non-negative number, you have to return the digits of this number within an array in reverse order.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
const digitize = (n: number): number[] => {
    return String(n).split('').reverse().map(n => Number(n));
};

console.log(digitize(12345));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func digitize(n int) []int {
    var result []int

    for n > 0 {
        result = append(result, n % 10)
        n /= 10
    }

    return result
}

func main() {
    fmt.Println(digitize(12345))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def digitize(n):
    return [int(x) for x in str(n)[::-1]]

print(digitize(12345))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function digitize($n) {
    return array_map('intval', str_split(strrev((string)$n)));
}

print_r(digitize(12345));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5583090cbe83f4fd8c000051">Go to Kata</a>


Kata of the Day #13

<p>Given an array of integers, return a new array with each value doubled.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function maps(x: number[]): number[] {
    return x.map(y => y * 2);
}

console.log(maps([1,2]);
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func maps(x []int) []int {
	for i, v := range x {
		x[i] = v * 2
	}
	return x
}

func main() {
	var arr []int = []int{1, 2}
	fmt.Println(maps(arr))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def maps(x):
    return list(map(lambda y: y * 2, x))


print(maps([1,2]))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function maps($x) {
    return array_map(function($y) {
        return $y * 2;
    }, $x);
}

echo maps([1,2]);
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57f781872e3d8ca2a000007e">Go to Kata</a>


Kata of the Day #12

<p>Create a simple class on different programming languages.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
class MyClass {
  private message: string = '';

  public setMessage(message: string) {
    this.message = message;
  }

  public getMessage() {
    return this.message;
  }
}

const myClass = new MyClass();
myClass.setMessage("My message");

console.log(myClass.getMessage());
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

type MyClass struct {
    message string
}

func (c *MyClass) setMessage(message string) {
    c.message = message
}

func (c *MyClass) getMessage() string {
    return c.message
}

func main() {
    myClass := MyClass{}
    myClass.setMessage("My message")
    fmt.Println(myClass.getMessage())
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
class MyClass:
    def __init__(self):
        self.message = ''

    def set_message(self, message):
        self.message = message

    def get_message(self):
        return self.message

my_class = MyClass()
my_class.set_message("My message")

print(my_class.get_message())
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
class MyClass {
    private $message = '';

    public function setMessage($message) {
        $this->message = $message;
    }

    public function getMessage() {
        return $this->message;
    }
}

$my_class = new MyClass();
$my_class->setMessage("My message");

echo $my_class->getMessage();
</code>
</pre>

Kata of the Day #11

<p>Create a function that gives a personalized greeting. This function takes two parameters: name and owner.</p>

<p>Use conditionals to return the proper message:</p>
<ul>
    <li>name equals owner: 'Hello boss'</li>
    <li>otherwise: 'Hello guest'</li>
</ul>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function greet(name: string, owner: string): string {
    return name === owner ? "Hello boss" : "Hello guest"
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func greet(name string, owner string) string {
    if name == owner {
        return "Hello boss"
    }
    return "Hello guest"
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def greet(name, owner):
    return "Hello boss" if name == owner else "Hello guest"
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function greet($name, $owner) {
    return $name === $owner ? "Hello boss" : "Hello guest";
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5772da22b89313a4d50012f7">Go to Kata</a>


Kata of the Day #10

<p>Alex just got a new hula-hoop, he loves it but feels discouraged because his little brother is better than him.</p>

<p>Write a program where Alex can input (n) how many times the hoop goes round, and it will return him an encouraging message :)</p>

<ul>
    <li>If Alex gets 10 or more hoops, return the string "Great, now move on to tricks".</li>
    <li>If he doesn't get 10 hoops, return the string "Keep at it until you get it".</li>
</ul>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function hoopCount(n: number): string {
    return n >= 10 ? "Great, now move on to tricks" : "Keep at it until you get it";
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func hoopCount(n int) string {
    if n >= 10 {
        return "Great, now move on to tricks"
    } else {
        return "Keep at it until you get it"
    }
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def hoop_count(n):
    return "Great, now move on to tricks" if n >= 10 else "Keep at it until you get it"
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function hoopCount($n) {
    return $n >= 10 ? "Great, now move on to tricks" : "Keep at it until you get it";
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/55cb632c1a5d7b3ad0000145">Go to Kata</a>


Kata of the Day #9

<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>Write a function that takes an array of words and smashes them together into a sentence and returns the sentence. You can ignore any need to sanitize words or add punctuation, but you should add spaces between each word. Be careful, there shouldn't be a space at the beginning or the end of the sentence!</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function smash (words: string[]): string {
   return words.join(" ");
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func Smash(words []string) string {
   return strings.Join(words, " ")
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def smash(words):
      return ' '.join(words)
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function smash(array $words): string {
   return implode(' ', $words);
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/53dc23c68a0c93699800041d">Go to Kata</a>


Kata of the Day #8

<p>Write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid.</p>

<p>This Kata is similar to the Valid Parentheses Kata, but introduces new characters: brackets [], and curly braces {}. Thanks to @arnedag for the idea!</p>

<p>All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{}.
What is considered Valid?</p>

<p>A string of braces is considered valid if all braces are matched with the correct brace.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function countSheeps(arrayOfSheep: boolean[]): number {
  return arrayOfSheep.reduce((acc, val) => acc + (val === true ? 1 : 0), 0);
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package kata

func CountSheeps(arrayOfSheep []bool) int {
  count := 0
  for _, sheep := range arrayOfSheep {
    if sheep {
      count++
    }
  }
  return count
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def count_sheeps(array_of_sheep):
    count = 0
    for sheep in array_of_sheep:
        if sheep == True:
            count += 1
    return count
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function countSheeps($arrayOfSheep) {
    $count = 0;
    foreach ($arrayOfSheep as $sheep) {
        if ($sheep === true) {
            $count++;
        }
    }
    return $count;
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/54edbc7200b811e956000556">Go to Kata</a>


Kata of the Day #7

<p>Many people think that waterfall is the only way to work, and they don't understand what is agile.</p>

<p>In waterfall development, a business analyst gathered requirements well in advance, then they created a feature from those, adding detail after detail until they got something they could estimate.</p>

<p>They (or a manager) put them onto a Gantt chart, and threw them over the wall to the programmers, who build exactly what was presented to them, then threw it over the wall to QA. A team-level Project Manager kept them on schedule with regular reports and meetings.</p>

<p>How is that different from what many so-called "Agile" teams do, though they use Jira and a backlog instead of Gantt charts and pretend that the requirements are "stories"?</p>

<p>Agile is a radically different way of working that bears essentially no resemblance to what I've just described. If what you're doing looks like that, my suggestion is to look long and hard at how you work.</p>

Agile vs Waterfall

<p>Write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid.</p>

<p>This Kata is similar to the Valid Parentheses Kata, but introduces new characters: brackets [], and curly braces {}. Thanks to @arnedag for the idea!</p>

<p>All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{}.
What is considered Valid?</p>

<p>A string of braces is considered valid if all braces are matched with the correct brace.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function validBraces(braces: string): boolean {
  while(/|\[\]|\{\}/g.test(braces)){
    braces = braces.replace(/|\[\]|\{\}/g,"")
  }
  return !braces.length;
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
import re

def valid_braces(braces: str) -> bool:
    while re.search(r"|\[\]|\{\}", braces):
        braces = re.sub(r"|\[\]|\{\}", "", braces)
    return len(braces) == 0
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package kata

import "regexp"

func ValidBraces(braces string) bool {
  for {
    re := regexp.MustCompile(`|\[\]|\{\}`)
    if !re.MatchString(braces) {
      break
    }
    braces = re.ReplaceAllString(braces, "")
  }
  return len(braces) == 0
}
</code>
</pre>

<h2>Rust</h2>
<pre class="language-rust">
<code>
use regex::Regex;

fn valid_braces(braces: &str) -> bool {
    let mut s = String::from(braces);
    let re = Regex::new(r"|\[\]|\{\}").unwrap();
    
    while re.is_match(&s) {
        s = re.replace_all(&s, "").to_string();
    }
    
    s.len() == 0
}
</code>
</pre>

<h2>C++</h2>
<pre class="language-cplusplus">
<code>
#include <iostream>
#include <regex>
#include <string>

bool valid_braces(std::string braces) {
    std::regex re("\$\$|\\[\\]|\\{\\}");
    while (std::regex_search(braces, re)) {
        braces = std::regex_replace(braces, re, "");
    }
    return braces.empty();
}
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function validBraces($braces) {
  while (preg_match('/|\[\]|\{\}/', $braces)) {
    $braces = preg_replace('/|\[\]|\{\}/', '', $braces);
  }
  return empty($braces);
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5277c8a221e209d3f6000b56">Go to Kata</a>


Kata of the Day #6

<p>Complete the method that takes a boolean value and return a "Yes" string for true, or a "No" string for false.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export const boolToWord = (bool: boolean): string => {
  return bool ? "Yes" : "No";
};
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func BoolToWord(word bool) string {
  if word {
    return "Yes"
  } else {
    return "No"
  }
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/53369039d7ab3ac506000467">Go to Kata</a>


Kata of the Day #5

<p>Return if a number is a multiple of 3 and 5.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function multiple3And5(n: number): boolean {
  return n % 15 == 0;
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func Multiple3And5(n int) bool {
  return n % 15 == 0
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kumite/6402655b778fd01fda59562f">Go to Kata</a>


Kata of the Day #4

<p>You're writing code to control your town's traffic lights. You need a function to handle each change from green, to yellow, to red, and then to green again.</p>
   
<p>Complete the function that takes a string as an argument representing the current state of the light and returns a string representing the state the light should change to.</p>
   
<p>For example, when the input is green, output should be yellow.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function updateLight(current: string): string {
  return ({
    green: "yellow",
    yellow: "red",
    red: "green",
  })[current] as string;
};
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def update_light(current: str) -> str:
    return {
        "green": "yellow",
        "yellow": "red",
        "red": "green"
    }[current]
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/58649884a1659ed6cb000072">Go to Kata</a>


Kata of the Day #3

<p>Americans are odd people: in their buildings, the first floor is actually the ground floor and there is no 13th floor (due to superstition).</p>

<p>Write a function that given a floor in the american system returns the floor in the european system.</p>

<p>With the 1st floor being replaced by the ground floor and the 13th floor being removed, the numbers move down to take their place. In case of above 13, they move down by two because there are two omitted numbers below them.</p>

<p>Basements (negatives) stay the same as the universal level.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function getRealFloor(n: number): number {
  return (n >= 13) ? n - 2 : (n > 0) ? n - 1 : n;
}
</code>
</pre>

<h2>C++</h2>
<pre class="language-clike">
<code>
int getRealFloor(int n) {
  return (n >= 13) ? n - 2 : (n > 0) ? n - 1 : n;
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/574b3b1599d8f897470018f6">Go to Kata</a>


Kata of the Day #2

<p>Complete the function that takes two integers (a, b, where a < b) and return an array of all integers between the input parameters, including them.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export class Kata {
  static highAndLow(numbers: string): string {
    let arr: number[] = numbers.split(" ").map(Number);
    let max: number = Math.max(...arr);
    let min: number = Math.min(...arr);
    return `${max} ${min}`;
  }
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package kata

func Between(a, b int) []int {
  var arr []int
  
	for i := a; i <= b; i++ {
		arr = append(arr, a)
		a++
	}

  return arr
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/55ecd718f46fba02e5000029">Go to Kata</a>


Blog