Codelitt is a software development firm helping corporations build new products and solve their most pressing problems with the speed, technology, and innovation of a startup

Codelitt

codelitt

ForkJoinPool is a special-purpose ExecutorService in Java designed for parallelizing divide-and-conquer algorithms. It is part of the java.util.concurrent package introduced in Java 7. The main idea behind ForkJoinPool is to efficiently utilize available CPU cores by recursively splitting tasks into smaller subtasks and executing them in parallel. The common pool of ForkJoinPool threads are implicitly used in Java applications whenever ForkJoinTasks are submitted for execution without explicitly specifying a custom ForkJoinPool instance. Here are some scenarios in which the common pool threads are implicitly utilized: Parallel Stream Operations: When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream(), the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example:
javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();




RecursiveTask and RecursiveAction: If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example:
javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task);




Task Execution by ForkJoinPool: Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke(), submit(), or execute() without specifying a custom pool instance will be executed using the common pool threads.


Parallel Array Operations: Operations on parallel arrays using Arrays.parallelSetAll(), Arrays.parallelSort(), etc., may utilize the common pool threads for parallel processing.


CompletableFuture: Operations on CompletableFuture, especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync(), may leverage the common pool threads for execution. In all these scenarios, the common pool threads are implicitly used by the Java runtime to execute tasks in parallel, taking advantage of multi-core processors and maximizing CPU utilization. Generally, it’s not advisable to use ForkJoinPool threads directly in the methods of CompletableFuture. Here's why: Reasons to Avoid Direct Usage: Conflicting Execution Models: CompletableFuture uses its own asynchronous execution mechanism, often relying on a cached thread pool or a custom executor you provide. Bypassing this mechanism and introducing ForkJoinPool threads can lead to unexpected behavior and potential thread pool management issues.
Limited Control: Using thenAsync allows CompletableFuture to manage thread pool utilization based on the workload. Direct ForkJoinPool usage might not align with this management strategy.
Blocking: ForkJoinPool is optimized for CPU-bound tasks with coarse-grained parallelism. Blocking operations within thenAsync tasks can hinder the pool's efficiency. Recommended Approach: Leverage the internal asynchronous execution mechanism of CompletableFuture. You can configure a custom executor for CompletableFuture if you have specific thread pool requirements, but it's usually not necessary for basic asynchronous tasks.
If you have CPU-bound tasks suitable for ForkJoinPool, consider processing them before using CompletableFuture. Utilize CompletableFuture for the asynchronous chaining of these pre-processed results. In summary, exercise caution while using CompletableFuture methods without passing custom executor service as it might create some unexpected behavior. ForkJoinPool is a special-purpose ExecutorService in Java designed for parallelizing divide-and-conquer algorithms. It is part of the java.util.concurrent package introduced in Java 7 . The main idea behind ForkJoinPool is to efficiently utilize available CPU cores by recursively splitting tasks into smaller subtasks and executing them in parallel. ForkJoinPool ExecutorService java.util.concurrent Java 7 ForkJoinPool The common pool of ForkJoinPool threads are implicitly used in Java applications whenever ForkJoinTasks are submitted for execution without explicitly specifying a custom ForkJoinPool instance. Here are some scenarios in which the common pool threads are implicitly utilized: ForkJoinPool ForkJoinPool Parallel Stream Operations: When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream(), the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example:
javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); RecursiveTask and RecursiveAction: If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example:
javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); Task Execution by ForkJoinPool: Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke(), submit(), or execute() without specifying a custom pool instance will be executed using the common pool threads. Parallel Array Operations: Operations on parallel arrays using Arrays.parallelSetAll(), Arrays.parallelSort(), etc., may utilize the common pool threads for parallel processing. CompletableFuture: Operations on CompletableFuture, especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync(), may leverage the common pool threads for execution. Parallel Stream Operations: When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream(), the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example: javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); Parallel Stream Operations : When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream() , the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example: Parallel Stream Operations parallel() parallelStream() javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); RecursiveTask and RecursiveAction: If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example: javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); RecursiveTask and RecursiveAction : If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example: RecursiveTask and RecursiveAction RecursiveTask RecursiveAction fork() join() javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); Task Execution by ForkJoinPool: Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke(), submit(), or execute() without specifying a custom pool instance will be executed using the common pool threads. Task Execution by ForkJoinPool : Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke() , submit() , or execute() without specifying a custom pool instance will be executed using the common pool threads. Task Execution by ForkJoinPool ForkJoinPool invoke() submit() execute() Parallel Array Operations: Operations on parallel arrays using Arrays.parallelSetAll(), Arrays.parallelSort(), etc., may utilize the common pool threads for parallel processing. Parallel Array Operations : Operations on parallel arrays using Arrays.parallelSetAll() , Arrays.parallelSort() , etc., may utilize the common pool threads for parallel processing. Parallel Array Operations Arrays.parallelSetAll() Arrays.parallelSort() CompletableFuture: Operations on CompletableFuture, especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync(), may leverage the common pool threads for execution. CompletableFuture : Operations on CompletableFuture , especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync() , may leverage the common pool threads for execution. CompletableFuture CompletableFuture thenCombine() thenApplyAsync() In all these scenarios, the common pool threads are implicitly used by the Java runtime to execute tasks in parallel, taking advantage of multi-core processors and maximizing CPU utilization. Generally, it’s not advisable to use ForkJoinPool threads directly in the methods of CompletableFuture . Here's why: ForkJoinPool CompletableFuture Reasons to Avoid Direct Usage: Reasons to Avoid Direct Usage: Conflicting Execution Models: CompletableFuture uses its own asynchronous execution mechanism, often relying on a cached thread pool or a custom executor you provide. Bypassing this mechanism and introducing ForkJoinPool threads can lead to unexpected behavior and potential thread pool management issues. Limited Control: Using thenAsync allows CompletableFuture to manage thread pool utilization based on the workload. Direct ForkJoinPool usage might not align with this management strategy. Blocking: ForkJoinPool is optimized for CPU-bound tasks with coarse-grained parallelism. Blocking operations within thenAsync tasks can hinder the pool's efficiency. Conflicting Execution Models: CompletableFuture uses its own asynchronous execution mechanism, often relying on a cached thread pool or a custom executor you provide. Bypassing this mechanism and introducing ForkJoinPool threads can lead to unexpected behavior and potential thread pool management issues. Conflicting Execution Models: CompletableFuture ForkJoinPool Limited Control: Using thenAsync allows CompletableFuture to manage thread pool utilization based on the workload. Direct ForkJoinPool usage might not align with this management strategy. Limited Control: thenAsync CompletableFuture ForkJoinPool Blocking: ForkJoinPool is optimized for CPU-bound tasks with coarse-grained parallelism. Blocking operations within thenAsync tasks can hinder the pool's efficiency. Blocking: ForkJoinPool thenAsync Recommended Approach: Recommended Approach: Leverage the internal asynchronous execution mechanism of CompletableFuture. You can configure a custom executor for CompletableFuture if you have specific thread pool requirements, but it's usually not necessary for basic asynchronous tasks. If you have CPU-bound tasks suitable for ForkJoinPool, consider processing them before using CompletableFuture. Utilize CompletableFuture for the asynchronous chaining of these pre-processed results. Leverage the internal asynchronous execution mechanism of CompletableFuture . You can configure a custom executor for CompletableFuture if you have specific thread pool requirements, but it's usually not necessary for basic asynchronous tasks. CompletableFuture CompletableFuture If you have CPU-bound tasks suitable for ForkJoinPool , consider processing them before using CompletableFuture . Utilize CompletableFuture for the asynchronous chaining of these pre-processed results. ForkJoinPool CompletableFuture CompletableFuture In summary, exercise caution while using CompletableFuture methods without passing custom executor service as it might create some unexpected behavior.

When is Common ForkJoinPool Used Internally by JVM?

is a high-performance, general-purpose programming language. C++ (C with Classes) This language’s value is evident in building some of the fastest and most critical computer programs. Throughout its 35+ years in the market, the language has been used to create web applications, robotics applications, industrial applications, and other complex engineering systems. C++ is valued in the job market, and developers who have mastered the language are sought after. The first and most vital step while developing projects with C++ is to choose an . IDE (Integrated Development Environment) IDEs are applications that allow programmers to develop software in human-understandable language. The IDE is an environment in which the program is implemented, executed, compiled, and debugged. Several companies provide IDEs for C++. They all have their strengths and weaknesses. Below, I have listed the . Top 6 IDEs for C++ in 2021 1. Embarcadero C++Builder: , owned by Embarcadero, allows developers to build native applications that deliver performance. C++Builder The developer can use the cross-platform IDE to build a desktop (Windows and macOS) and mobile (iOS and Android) software. It is also written in C++ and Object Pascal. C++Builder has features like debugger, graphical user interface builder, integrated toolchain, and autocomplete. Other highlights of the application are intuitive interface frameworks with beautiful design. With fast development, it allows native connectivity to more than 20 databases, like Oracle, SQL Server, and MySQL. The developer can also use the tool to build IoT applications with easy connectivity to sensors and devices. Released in 1997, C++Builder is at version 10.4.2 and grants users a free 30-day trial. 2. Eclipse IDE: The is a simple IDE initially released in 2001 by IBM. It is now open-source and managed by a public foundation. Eclipse IDE The IDE was written in Java and used to build Java applications. However, the program can now build applications in C/C++, JavaScript/TypeScript, and PHP. Among the pros of using Eclipse are the extensible tools for the IDE. It has a marketplace with customizations and extensions. The downside of using Eclipse is that it is not stable and has outdated UI elements. 3. Microsoft Visual Code: is a code editor released by Microsoft in 2015. It stands out for being able to run lightly with power. Visual Studio Code The software allows programming in Java, JavaScript, Go, Node.js, Python, and C++. The IDE attracts attention from the development community for allowing the extension of features. It is proprietary freeware. Visual Studio Code is difficult to use for beginning developers. Older equipment may have slow performance. 4. Apache NetBeans: The Apache Software Foundation developed . Modularity is the main feature of this software. NetBeans The open-source IDE was designed in 1996 for an academic project in Java but later expanded to support other programming languages such as C++, PHP, HTML, CSS, and JavaScript. One of its essential features is its ability to lighten code semantically and syntactically. It has a simple UI. NetBeans may require much memory to run without slow performance. 5. Code::Blocks: is an IDE that has all the features a developer needs with a consistent look and feel. It is a free, open-source, cross-platform environment. Code::Blocks The application was created with C++ in 2005 by a team of developers. It presents a fast and intuitive interface. The software supports multiple compilers. With drag and play, the programmer can arrange components. Code::Blocks has some UI elements that need updating. It also has problems implementing extensions. 6. CodeLite: It supports all major C++ compilers, has efficient PHP, and runs Node.js. These are IDE credentials. CodeLite The IDE is open-source distributed as GNU and runs several programming languages. The software appeared in 2006 as a library of builds. The interface is simple. Conclusion There are other options that  C++ developers can make use of in 2021. C++ enables programmers to create robust projects that ensure efficient execution. Several factors need to be considered when choosing an IDE. It is advisable to test each of them before settling on one. Every project has a particular development environment that suits it best.

Top 6 IDEs for Developers to Compile C++ Programs in 2021

There’s a ton of articles about this , and a lot of useful info around , but i wanted to write a little about this. I’ve been rather annoyed at osx later , the whole permission to install from un-trusted sources , homebrew path change etc etc , for a while I’ve used OSX because it gets me “there” quicker , as in , i don’t need to do any configuration (wifi / multiple screens / fan control / thermald / etc / and I’m a bit OCD about this) . I’ve decided to give arch a go last week , i have a macbook 11,1 , it’s a late 2013 with retina. I have a some experience using linux on laptops i knew this wasn’t going to be easy , but i hoped for the best and gave it a go. https://wiki.archlinux.org/index.php/MacBookPro11,x I didn’t partition , I’ve decided to use the full drive for Arch so no EFI magic , I’ve used Arch purely and merely for AUR as I’m too lazy to clone from git sometimes and it’s the best to be cutting edge (which I was sure i was going to need for broadcom chispsets) Anyways this is the list of problems i’ve faced: Retina (xfce needs a custom theme to be usable) [use xfce hidpi themes] Vtty Fonts too small [ vconsole.conf ] broadcom wl 4360 , random disconnections [yaourt] hibernate/suspend to ram works! trackpad …mtrack does a decent job … not comparable with osx [yaourt] battery life (im starting to accept i won’t get 9 hours , i get 5 with tlp powertop mbpfancontrol and others) this can be my ocd again but on idle is 10 degrees hotter than osx [:S] Before i started all this i knew there will be some sacrifices to make , as we all know some things don’t work as well when drivers have to be reversed engineered (4360) etc , but overall im happy with it. It looks amazing and the things i need work pretty much out of the box (multi screens , wifi , suspend) These articles helped me _What to do to kick start it and teach it super powers_medium.com Arch Linux running on my MacBook _The MacBook Pro 11,x consists of models with Retina display shipped by Apple In Late 2013 and Mid 2014. Like its…_wiki.archlinux.org MacBookPro11,x - ArchWiki _Version française 2015-12-08 - gummiboot has been integrated to systemd 2015-11-06 - section about fan control 2015-03…_loicpefferkorn.net Arch Linux on MacBook Pro Retina 2014 with DM-Crypt, LVM and suspend to disk _The installation process of Arch Linux on a Macbook Pro has quite a few caveats, but it is about the slickest machine I…_codylittlewood.com Dual boot Arch Linux on MacBook Pro Installation _Perhaps in another post where I have more room and time I will get into all the reasons for installing GNU/Linux on my…_mchladek.me Installing Arch Linux on a MacBook Pro · Michael Chladek and finally _In the style of Michael Chladek, I thought it would be useful to my future-self and others, if I wrote up a summary of…_visual-assault.org Installing (encrypted) Arch Linux on an Apple MacBook Pro Sorry about the images :) Overall I’m excited to have full control of my laptop again and I am surprised how many things didn’t fail and work out of the box , you should give it a go .

Arch on Macbook Pro

Introduction has an underrated, in my opinion, possibility to share a project using the plugin. This plugin can be very useful for: Android Studio CodeWithMe Pair programming. Teaching. Working together to solve problems in a project. Connecting via Marketplace To start using it, go to . Then go to the tab and enter “code with me**”**. But this is the ideal case. As you know, life is not perfect. File -> Settings -> Plugins Marketplace When I tried to do this, I was immediately met with installation problems: As you can see from the screenshot, entering a search query did not find anything. Then I tried to enter the query without spaces, but also to no avail: In trying to solve this problem, I came across a variety of issues on and questions on . There were a total of 3 problems with connecting the plugin via : YouTrack StackOverflow https://youtrack.jetbrains.com/issue/IDEA-269919/Code-With-Me-plugin-unavailable-for-latest-build https://youtrack.jetbrains.com/issue/CWM-3933 https://stackoverflow.com/questions/30617408/how-to-install-plugin-in-android-studio Marketplace bugs in itself; Android Studio incompatible versions of Android Studio and the plugin; difficulties with connecting paid plugins in Android Studio. By the way - the plugin is paid. However, Android Studio does not offer to buy it, it just does not show it in the list. In general, to connect the plugin through I failed. If anyone knows the solution, then write in the comments. Marketplace Manual connection As you know, for such cases offers a workaround - to connect manually. To do this, you need to follow the same path: . Then click on the gear icon and select . Android Studio File -> Settings -> Plugins Install Plugin from Disk Naturally, it is necessary to download the plugin on the in advance. marketplace site And then - select the necessary file on the disk: However, there was a surprise waiting for me here, too - the latest version of the plugin turned out to be incompatible with : Android Studio Perhaps that was the answer as to why it wasn't in the . This got me thinking that I needed to update my version of since I didn't have the latest one: Marketplace Android Studio I upgraded to the latest: This did not solve the problem. But it gave me the idea that I need to find a compatible version with . By the way, I tried installing it in , the same problems arise there. Android Studio Intellij Idea After some time I managed to find the necessary version, for this on the you need to put the following settings: marketplace site Only the installation of this version of the plugin went: By the way, only the trial version of the plugin is installed. Will the full version be available for ? I still haven't found an answer. Android Studio Setting up the Connection After installing the plugin, the following items will appear. An icon near the start button and in the menu: Tools And also an item in the settings: They are how the control takes place. To start working, it is necessary to give permission. To do this, click on the icon next to the start button: A window will appear with a choice of actions: Select the first option: . Then there will be a window with the rules that you need to agree with. Then you will see a window where you can select the connection options: Enable Access and Copy Invitation Link Despite the scary red message, select and click . Edit files Enable Access After that, you will be given access to edit the project and you can work on it together anywhere in the world. But you can also work on the current computer. This is what we will try to do. Click again on the icon and select Join Another IDE as a Participant and paste the copied link: To copy the link, you need to click on the first item on this . Copy Invitation Link sheet The same project opens: Note that after you have done this, a green dot appears near the icon, indicating that the status is active: Also at the bottom of the studio appeared data on the speed of data transmission: Using the plugin The plugin supports the same functions as working in a normal studio. For example, if you highlight text in a project, it will also be highlighted in your colleague. And vice versa: https://youtu.be/dhNUpxCFBuI Works n as in a normal project: code completio https://youtu.be/UgfKLwfHZI0 However, you can feel the slowdown. You can see it in the video. If you want to stop access, you have to select : Turn Access Off and Disconnect All https://youtu.be/Ns2XXmHP9DY It is worth noting the limited capabilities of the participants connected to the project. For example, compare the tab in the main project and : File CodeWithMe The additional features of are well described in these resources: CodeWithMe https://www.jetbrains.com/code-with-me/ https://blog.jetbrains.com/blog/2022/09/09/code-with-me-kotlin/ Getting started with Code With Me | IntelliJ IDEA https://plugins.jetbrains.com/plugin/14896-code-with-me/versions In particular, you can connect audio and video communication there. Conclusion seems to me to be a rather useful plugin. Of course, it is not for daily use, but it is needed in rare cases of development. It should be considered as a substitute for Zoom and Skype, where you can share the screen, or Teams, where you can control the cursor. Or as a cut version of TeamViewer for the needs of development. In some situations, it can make communication much easier. CodeWithMe If you notice any bugs or know how to solve problems with the connection through the , then write in the comments. Marketplace

Using the CodeWithMe Plugin in Android Projects and Troubleshooting Connectivity Issues

Developing good is hard. software You’re on a development team, the backlog’s a mile long, team members are overloaded and you’re left making best guesses on how to work with the codebase. At we’re aiming to change all that. Codelingo Our purpose is for our tools to free developers from solving problems within their code so they can instead spend time solving the problems of the world. Great software is the product of a team that holds themselves accountable. Linters and peer reviews are the standard tools for this job, yet there are problems. Off the shelf linters only catch some issues generic to the language. Peer reviews are time consuming and easily miss issues. We need a generalised linter and workflow automator — a light-touch way to encode knowledge and practices so they can be shared and easily updated at scale … enter . Codelingo By quickly capturing both knowledge and practices, Codelingo unlocks the ability to automate dev workflows such as code reviews with project specific patterns, quickly and easily. It’s three steps to get started: 1. Install the 2. Commit a codelingo.yaml file to your repository3. to safeguard your codebase. github app Add or Write Tenets Every new pull request will be checked against the Tenets of your team. Use the to write your own Tenets quickly and easily or from the community. Download the to analyse any Git repository on your local machine. online playground import Tenet bundles lingo CLI tool Take back charge of your development, automate the stuff no one likes doing and get back to the creative development you and your team love. What Next Expect us to get a lot more noisy in the near future. In the meantime, follow us on twitter and get started with the . Lot’s more coming soon! @codelingoapp github app This post was originally published at . codelingo.io/blog/launch

Codelingo: Making Software Development Fun Again

Recently I came across a . I found it interesting enough to post here. Codility demo task At first, I wanted to use a , tracking the minimum positive integer . Take the following array: [1, 3, 6, 4, 1, 2]. Let’s iterate it. The first number is 1. So the minimum integer that is not in this array so far is 2. Then there is 3. So the minimum integer that is not in this array so far is still 2. Everything’s great until I finally encounter 2 in the end of this array. So how am I supposed to come up with an answer — 5 — with this approach? Well, I’m afraid it simply doesn’t work here. So it became obvious that I need to remember somehow all the encountered numbers. greedy algorithm so far What is the best way to spot them? The approach that comes to mind first is to have some pattern array, kinda sieve, the one that contains all the positive integers within a given interval. And it would be very handy if its keys would coincide with values. So with every integer I encounter in input array I find a corresponding key in a pattern array, and mark its value as, say, null: $pattern = (0, 100000); range ($a $value) {$pattern[$value] = ;} foreach as null After that all I need is to iterate it and find the first key with a non-null value. But before that I want to make sure that I won’t get 0 as an answer since it’s not a positive integer. So I unset the first element in my pattern array. And there is an edge case. What happens if I get all the integers within a given interval, [1, 100000]? The answer should be 100001. So I create a pattern array with the equals to 100001: supremum solution( $a) {$pattern = (0, 100001); function array range **foreach** ($a **as** $value) {  
    $pattern\[$value\] = **null**;  
}  

**unset**($pattern\[0\]);  

**for** ($i = 1; $i <= _count_($pattern); $i++) {  
    **if** (!_is\_null_($pattern\[$i\])) {  
        **return** $i;  
    }  
} } Voilà!

Codility Demo Test Solution

Solución de prueba de demostración de Codility

The content of the blog you are reading right now is stored in a Git repository. Every time I create an article, I create a new Git Branch to isolate the changes. To generate the skeleton of the articles, I use the command line (well, I generally use ); in particular, given that I’m using both Windows 10 and Windows 11 - depending on the laptop I’m working on - I use the , which allows you to define the style, the fonts, and so on of every terminal configured in the settings. PowerShell Integrated Terminal The : no info is shown except for the current path - I want to customize the appearance. default profile is pretty basic I want to show the status of the repository, including: Git repository name branch name outgoing commits There are lots of articles that teach how to use OhMyPosh with Cascadia Code. Unfortunately, I couldn’t make them work. In this article, I teach you . It’s a I wrote while installing it on my local machine. I hope it works for you as well! how I fixed it on my local machine step-by-step guide Step 1: Create the $PROFILE file if it does not exist In PowerShell, you can customize the current execution by updating the file. $PROFILE Clearly, you first have to . check if the profile file exists Open the PowerShell and type: $PROFILE # You can also use $profile lowercase - it's the same! This command shows you the . The file, if it exists, is stored in that location. expected path of this file In this case, the file should be available under the folder . In my case, it does not exist, though! $Profile C:\Users\d.bellone\Documents\WindowsPowerShell Therefore, you must create it manually: head to that folder and . create a file named Microsoft.PowerShell_profile.ps1 Note: it might happen that not even the folder exists. If it’s missing, well, create it! WindowsPowerShell Step 2: Install OhMyPosh using Winget, Scoop, or PowerShell To use , we have to - of course - install it. OhMyPosh As explained , there are , depending on the tool you prefer. in the official documentation three ways to install OhMyPosh If you use , just run: Winget winget install JanDeDobbeleer.OhMyPosh -s winget If you prefer , the command is: Scoop scoop install https://github.com/JanDeDobbeleer/oh-my-posh/releases/latest/download/oh-my-posh.json And, if you like working with , execute: PowerShell Set-ExecutionPolicy Bypass -Scope Process -Force; Invoke-Expression ((New-Object System.Net.WebClient).DownloadString('https://ohmyposh.dev/install.ps1')) I used , and you can see the installation process here: Winget Now, to apply these changes, you have to . restart the PowerShell Step 3: Add OhMyPosh to the PowerShell profile Open the file and add the following line: Microsoft.PowerShell_profile.ps1 oh-my-posh init pwsh | Invoke-Expression This command is executed every time you open the PowerShell with the default profile, and it initializes OhMyPosh to have it available during the current session. Now, you can save and close the file. . Hint: you can open the profile file with Notepad by running notepad $PROFILE Step 4: Set the Execution Policy to RemoteSigned Restart the terminal. In all probability, you will see an error like this: The error message The file is not digitally signed. You cannot run this script on the current system <path>\Microsoft.PowerShell_profile.ps1 means that PowerShell does not trust the script it’s trying to load. To see which Execution Policy is currently active, run: Get-ExecutionPolicy You’ll probably see that the value is . AllSigned To enable the execution of scripts created on your local machine, you have to , using this command by : set the Execution Policy value to RemoteSigned running the PowerShell in administrator mode Set-ExecutionPolicy RemoteSigned Let’s see the definition of the Execution policy as per : RemoteSigned SQLShack’s article This is also a . This policy dictates that any script that was not created on the system that the script is running on, should be signed. Therefore, . safe PowerShell Execution policy to set in an enterprise environment this will allow you to write your own script and execute it So, yeah, feel free to proceed and set the new Execution policy to have your PowerShell profile loaded correctly every time you open a new PowerShell instance. Now, OhMyPosh can run in the current profile. Head to a and notice that… It’s not working!🤬 Or, well, we have the Git information, but we are missing some icons and glyphs. Git repository Step 5: Use CaskaydiaCove, not Cascadia Code, as a font We still have to . install the correct font with the missing icons We will install it using , a package manager available for Windows 11. Chocolatey To check if you have it installed, run: choco -v Now, to install the correct font family, and run: open a PowerShell with administration privileges choco install cascadia-code-nerd-font Once the installation is complete, you must tell Integrated Terminal to use the correct font by following these steps: Open the page (by hitting ) Settings CTRL + , select the profile you want to update (in my case, I’ll update the default profile) open the section Appearance under Font face, select CaskaydiaCove Nerd Font Now close the Integrated Terminal to apply the changes. Open it again, navigate to a Git repository, and admire the result. Further readings The first time I read about OhMyPosh, it was on Scott Hanselman’s blog. I couldn’t make his solution work - and that’s the reason I wrote this article. However, in his article, he shows how he customized his own Terminal with more glyphs and icons, so you should give it a read. 🔗 My Ultimate PowerShell prompt with Oh My Posh and the Windows Terminal | Scott Hanselman’s blog We customized our PowerShell profile with just one simple configuration. However, you can do a lot more. You can read Ruud’s in-depth article about PowerShell profiles. 🔗 How to Create a PowerShell Profile – Step-by-Step | Lazyadmin One of the core parts of this article is that we have to use as a font instead of the (in)famous . But why? CaskaydiaCove Cascadia Code 🔗 Why CaskaydiaCove and not Cascadia Code? | GitHub This article first appeared on Code4IT 🐧 Finally, as I said at the beginning of this article, I use Git and Git Branches to handle the creation and management of my blog articles. That’s just the tip of the iceberg! 🏔️ If you want to steal my (previous) workflow, have a look at the behind-the-scenes of my blogging process (note: in the meanwhile, a lot of things have changed, but these steps can still be helpful for you) 🔗 From idea to publishing, and beyond: how I automated my blogging workflow with GitHub, PowerShell, and Azure | Code4IT Wrapping up In this article, we learned how to install OhMyPosh in PowerShell and overcome all the errors you (well, I) don’t see described in other articles. I wrote this step-by-step article alongside installing these tools on my local machine, so . I’m confident the solution will work Did this solution work for you? Let me know! 📨 I hope you enjoyed this article! Let’s keep in touch on or ! 🤜🤛 Twitter LinkedIn Happy coding! 🐧 Also published . here

Using OhMyPosh and CascadiaCode: Elevating PowerShell and Integrating with Git in Windows

Model validation is fundamental to any project: it brings and acting as a first shield against an invalid state. security robustness You should then add Unit Tests focused on model validation. In fact, when defining the input model, you should always consider both the valid and, even more, the invalid models, . making sure that all the invalid models are rejected is a good approach for this scenario, and you can use to implement it gradually. BDD TDD Okay, but how can you validate that the models and model attributes you defined are correct? Let’s define a simple model: public class User
{
    [Required]
    [MinLength(3)]
    public string FirstName { get; set; }

    [Required]
    [MinLength(3)]
    public string LastName { get; set; }

    [Range(18, 100)]
    public int Age { get; set; }
} Have we defined our model correctly? A well-written Unit Test suite is our best friend here! Are we covering all the edge cases? We have two choices: we can write Integration Tests to send requests to our system, which is running an in-memory server, and check the response we receive. Or we can class, the one used by ASP.NET to validate input models, to create slim and fast Unit Tests. Let’s use the second approach. use the internal Validator Here’s a utility method we can use in our tests: public static IList<ValidationResult> ValidateModel(object model)
{
    var results = new List<ValidationResult>();

    var validationContext = new ValidationContext(model, null, null);

    Validator.TryValidateObject(model, validationContext, results, true);

    if (model is IValidatableObject validatableModel)
       results.AddRange(validatableModel.Validate(validationContext));

    return results;
} In short, we create a without any external dependency, focused only on the input model: . validation context new ValidationContext(model, null, null) Next, we by calling and store the validation results in a list, . validate each field TryValidateObject result Finally, if the Model implements the interface, which exposes the method, we call that method and store the returned validation errors in the final list created before. IValidatableObject Validate Validate() result As you can see, we can handle both validations coming from attributes on the fields, such as , and custom validation defined in the model class’s method. [Required] Validate() Now, we can use this method to verify whether the validation passes and, in case it fails, which errors are returned: [Test]
public void User_ShouldPassValidation_WhenModelIsValid()
{
    var model = new User { FirstName = "Davide", LastName = "Bellone", Age = 32 };
    var validationResult = ModelValidationHelper.ValidateModel(mode);
    Assert.That(validationResult, Is.Empty);
}

[Test]
public void User_ShouldNotPassValidation_WhenLastNameIsEmpty()
{
    var model = new User { FirstName = "Davide", LastName = null, Age = 32 };
    var validationResult = ModelValidationHelper.ValidateModel(mode);
    Assert.That(validationResult, Is.Not.Empty);
}


[Test]
public void User_ShouldNotPassValidation_WhenAgeIsLessThan18()
{
    var model = new User { FirstName = "Davide", LastName = "Bellone", Age = 10 };
    var validationResult = ModelValidationHelper.ValidateModel(mode);
    Assert.That(validationResult, Is.Not.Empty);
} Further readings Model Validation allows you to create robust APIs. To improve robustness, you can follow : more Postel’s law 🔗 Postel’s law for API Robustness | Code4IT This article first appeared on Code4IT 🐧 Model validation, in my opinion, is one of the cases where Unit Tests are way better than Integration Tests. This is a perfect example of , the best (in most cases) way to structure a test suite: Testing Diamond 🔗 Testing Pyramid vs Testing Diamond (and how they affect Code Coverage) | Code4IT If you still prefer writing Integration Tests for this kind of operation, you can rely on the class and use it in your NUnit tests: WebApplicationFactory 🔗 Advanced Integration Tests for .NET 7 API with WebApplicationFactory and NUnit | Code4IT Wrapping up Model validation is crucial. Testing the correctness of model validation can make or break your application. Please don’t skip it! I hope you enjoyed this article! Let’s keep in touch on or ! 🤜🤛 Twitter LinkedIn Happy coding! 🐧 Also published . here

Model Validation in C#: Unit Testing

If you need to run operations before completing a Git commit, you can rely on Git Hooks. Git hooks are scripts that run automatically whenever a particular event occurs in a Git repository. They let you customize Git’s internal behaviour and trigger customizable actions at key points in the development life cycle. Extending Git hooks allows you to plug in to the regular Git flow, such as Git , , etc. custom functionalities message validation code formatting I’ve already described how to use , but here I’m gonna use , the version of Husky created for .NET-based applications. Husky with NPM Husky.NET Git hooks: a way to extend Git operations As we said, Git hooks are actions that run during specific phases of Git operations. Git hooks fall into : 4 categories : they execute when you run on your local repository; client-side hooks related to the committing workflow git commit : they are executed when running , which is a command that allows you to integrate mails and Git repositories (I’ve never used it. If you are interested in this functionality, ); client-side hooks related to the email workflow git am here’s the official documentation : these hooks run on your local repository when performing operations like ; client-side hooks related to other operations git rebase : they run after a commit is received on the remote repository, and they can reject a operation. server-side hooks git push Let’s focus on the client-side hooks that run when you commit changes using . git commit How to install Husky.NET and its dependencies in a .NET Application Husky.NET must be installed in the of the solution. root folder You first have to by running: create a file in the root folder tool-manifest dotnet new tool-manifest This command creates a file named under the folder: here, you can see the list of external tools used by dotnet. dotnet-tools.json .config After running the command, you will see that the file contains this element: dotnet-tools.json {
  "version": 1,
  "isRoot": true,
  "tools": {}
} Now you can by running: add Husky as a dotnet tool dotnet tool install Husky After running the command, the file will contain something like this: {
  "version": 1,
  "isRoot": true,
  "tools": {
    "husky": {
      "version": "0.6.2",
      "commands": ["husky"]
    }
  }
} Now that we have added it to our dependencies, we can by running: add Husky to an existing .NET application dotnet husky install If you open the root folder, you should be able to see these 3 folders: , which contains the info about the Git repository; .git that contains the description of the tools, such as ; .config dotnet-tools that contains the files we are going to use to define our Git hooks. .husky Finally, you can by running, for example, add a new hook dotnet husky add pre-commit -c "echo 'Hello world!'"
git add .husky/pre-commit This command creates a new file, (without file extension), under the folder. By default, it appears like this: pre-commit .husky #!/bin/sh
. "$(dirname "$0")/_/husky.sh"

## husky task runner examples -------------------
## Note : for local installation use 'dotnet' prefix. e.g. 'dotnet husky'

## run all tasks
#husky run

### run all tasks with group: 'group-name'
#husky run --group group-name

## run task with name: 'task-name'
#husky run --name task-name

## pass hook arguments to task
#husky run --args "$1" "$2"

## or put your custom commands -------------------
#echo 'Husky.Net is awesome!'

echo 'Hello world!' The default content is pretty useless; it’s time to customize that hook. Notice that the latest command has also generated a file; we will use it later. task-runner.json Your first pre-commit hook To customize the script, . open the file located at .husky/pre-commit Here, you can add whatever you want. In the example below, I run commands that compile the code, format the text (using with the rules defined in the .editorconfig file), and then run all the tests. dotnet format #!/bin/sh
. "$(dirname "$0")/_/husky.sh"

echo 'Building code'
dotnet build

echo 'Formatting code'
dotnet format

echo 'Running tests'
dotnet test Then, add it to Git, and you are ready to go. 🚀 But wait… 3 ways to manage dotnet format with Husky.NET There is a problem with the approach in the example above. Let’s simulate a usage flow: you modify a C# class; you run ; git commit -m "message" the pre-commit hook runs ; dotnet build the pre-commit hook runs ; dotnet format the pre-commit hook runs ; dotnet test after the hooks, the commit is created. What is the final result? Since modifies the source files, and given that the snapshot has already been created before executing the hook, all ! dotnet format the modified files will not be part of the final commit Also, executes linting on every file in the solution, not only those that are part of the current snapshot. The operation might then take a lot of time, depending on the size of the repository, and most of the time, it will not update any file (because you’ve already formatted everything in a previous run). dotnet format We have to work out a way to fix this issue. I’ll suggest three approaches. Include all the changes using Git add The first approach is quite simple: after . run git add . dotnet format So, the flow becomes: you modify a C# class; you run ; git commit -m "message" the pre-commit hook runs ; dotnet build the pre-commit hook runs ; dotnet format the pre-commit hook runs ; git add . the pre-commit hook runs ; dotnet test Git creates the commit. This is the most straightforward approach, but it has some downsides: is executed on every file in the solution. The more your project grows, the slower your commits become; dotnet format adds to the current snapshot all the files modified, even those you did not add to this commit on purpose (maybe because you have updated many files and want to create two distinct commits). git add . So, it works, but we can do better. Execute a dry run of dotnet-format You can to the command: this flag returns an error if at least one file needs to be updated because of a formatting rule. add the --verify-no-changes dotnet format Let’s see how the flow changes if one file needs to be formatted. you modify a C# class; you run ; git commit -m "message" the pre-commit hook runs ; dotnet build the pre-commit hook runs ; dotnet format --verify-no-changes the pre-commit hook returns an error and aborts the operation; run on the whole solution to fix all the formatting issues; you dotnet format you run ; git add . you run ; git commit -m "message" the pre-commit hook runs ; dotnet build the pre-commit hook runs . Now, there is nothing to format, and we can proceed; dotnet format --verify-no-changes the pre-commit hook runs ; dotnet test Git creates the commit. Notice that, this way, if there is something to format, the whole commit is aborted. You will then have to run on the entire solution, fix the errors, add the changes to the snapshot, and restart the flow. dotnet format It’s a longer process, but it allows you to have complete control over the formatted files. Also, you won’t risk including in the snapshot the files you want to keep staged in order to add them to a subsequent commit. Run dotnet-format only on the staged files using Husky.NET Task Runner The third approach is the most complex but with the best result. If you recall, during the initialization, Husky added two files in the folder: and . .husky pre-commit task-runner.json The key to this solution is the file. This file allows you to . task-runner.json create custom scripts with a name, a group, the command to be executed, and its related parameters By default, you will see this content: {
  "tasks": [
    {
      "name": "welcome-message-example",
      "command": "bash",
      "args": ["-c", "echo Husky.Net is awesome!"],
      "windows": {
        "command": "cmd",
        "args": ["/c", "echo Husky.Net is awesome!"]
      }
    }
  ]
} To make sure that runs only on the staged files, you must like this: dotnet format create a new task {
  "name": "dotnet-format-staged-files",
  "group": "pre-commit-operations",
  "command": "dotnet",
  "args": ["format", "--include", "${staged}"],
  "include": ["**/*.cs"]
} Here, we have specified a name, , the command to run, , with some parameters listed in the array. Notice that parameter, which is populated by Husky.NET. dotnet-format-staged-files dotnet args we can filter the list of files to be formatted by using the ${staged} We have also added this task to a named that we can use to reference a list of tasks to be executed together. group pre-commit-operations If you want to run a specific task, you can use . In our example, the command would be . dotnet husky run --name taskname dotnet husky run --name dotnet-format-staged-files If you want to run a set of tasks belonging to the same group, you can run . In our example, the command would be . dotnet husky run --group groupname dotnet husky run --group pre-commit-operations The last step is to call these tasks from within our file. So, replace the old command with one of the above commands. pre-commit dotnet format Final result and optimizations of the pre-commit hook Now that everything is in place, we can improve the script to make it faster. Let’s see which parts we can optimize. The first step is the . For sure, we have to run to see if the project builds correctly. You can consider adding the flag to skip the step before building. build phase dotnet build --no-restore restore Then we have the : we can avoid formatting every file using one of the steps defined before. I’ll replace the plain with the execution of the script defined in the Task Runner (it’s the third approach we saw). format phase dotnet format Then, we have the . We can add both the and the flag to the command since we have already built everything before. ! The format phase updated the content of our files, so we still have to build the whole solution. Unless we swap the and the phases. test phase --no-restore --no-build But wait build format So, here we have the final file: pre-commit #!/bin/sh
. "$(dirname "$0")/_/husky.sh"

echo 'Ready to commit changes!'

echo 'Format'

dotnet husky run --name dotnet-format-staged-files

echo 'Build'

dotnet build --no-restore

echo 'Test'

dotnet test --no-restore

echo 'Completed pre-commit changes' Yes, I know that when you run the command, you also build the solution, but I prefer having two separate steps just for clarity! dotnet test Ah, and at the beginning of the script! don’t remove the #!/bin/sh How to skip Git hooks To trigger the hook, just run . completing the commit, the hook will run all the commands. . git commit -m "message" Before If one of them fails, the whole commit operation is aborted There are cases when you have to . For example, if you have integration tests that rely on an external source currently offline. In that case, some tests will fail, and you will be able to commit your code only once the external system gets working again. skip the validation You can skip the commit validation by adding the flag: --no-verify git commit -m "my message" --no-verify Further readings Husky.NET is a porting of the Husky tool we already used in a previous article, using it as an NPM dependency. In that article, we also learned how to customize Conventional Commits using Git hooks. 🔗 How to customize Conventional Commits in a .NET application using GitHooks | Code4IT As we learned, there are many more Git hooks that we can use. You can see the complete list on the Git documentation: 🔗 Customizing Git - Git Hooks | Git docs Of course, if you want to get the best out of Husky.NET, I suggest you have a look at the official documentation: 🔗 Husky.Net documentation One last thing: we installed Husky.NET using dotnet tools. If you want to learn more about this topic, I found an excellent article online that you might want to read: 🔗 Using dotnet tools | Gustav Ehrenborg Wrapping up In this article, we learned how to create a Git hook and validate all our changes before committing them to our Git repository. pre-commit We also focused on the formatting of our code: how can we format only the files we have changed without impacting the whole solution? I hope you enjoyed this article! Let’s keep in touch on or ! 🤜🤛 Twitter LinkedIn Happy coding! 🐧 Also published . here

Optimizing .NET Development Workflow with Git Hooks and Husky.NET

Especially when talking about , many articles and videos focus on an architectural element that, in their opinion, is absolutely necessary for building such kinds of applications: . microservices API Gateways Yes, they are actually useful, but they are not the solution to every architectural problem. In this article, we will learn what API Gateways are, their pros and cons, why you should distinguish them from Load Balancers, and more. What is an API Gateway? Imagine that your application is made of several web services and APIs. Each of them will be deployed on a separate host, therefore having a different URL. While it can be helpful for internal development - you have a clear separation of operations available in your system - it can become cumbersome for the developers who have to integrate all those endpoints in their application. That’s where API Gateways come into play: they to uniform the access to your system. add a sort of in front of your set of APIs façade Say that you’ve built a Hotel booking system that is made of 3 services: , deployed at BookingAPI https://bookings.mycompany.org/api , deployed at SearchAPI https://mycompany.org/search/api , deployed at (notice the ) DiscountAPI https://discounts.mycompany.org/v1/api v1 By adding an API Gateway, you can hide these APIs behind a single host, like , mapping the route path to the original services’ URLs. https://api.mycompany.org/ As with everything in the world, there are advantages and disadvantages. Let’s learn! 🔥 Advantages of an API Gateway API Gateways have lots of advantages. It’s not a coincidence that they are being used in many architectures. Let’s see some of the best characteristics of an API Gateway. Internal API security Since your internal APIs are hidden behind an API Gateway, you make them discoverable by intruders who might want to access your systems and data. less Let’s go back to the Hotel Booking system in our example. External users will only see the host without knowing the structure of the internal API services. This . api.mycompany.com reduces the attack surface You can also by adding them to the API Gateway and have them applied to all the APIs behind the Gateway. centralize Access Control Policies Finally, you can and analyze the traffic to spot unusual behavior in a single place. monitor all the incoming requests Reduced complexity Some concerns are common to all the APIs within the same system, such as , , and . rate limiting throttling access control With API Gateways, you can for such common concerns in a single point. For example, once you have defined some rate limiting policies on your Gateway, you can have the same settings automatically applied to every internal API endpoint (well, not “physically” applied to the internal APIs, but since the Gateway blocks some incoming requests, they will not reach the internal systems as well). centralize the settings API Gateways also help with : since you have all the internal services listed in the API Gateway, just by looking at its configurations, you can see the list of the deployed APIs and their hostname. service documentation Flexibility Since API Gateways act as a façade in front of other services, you can integrate services that work with . different protocols or formats For example, you can have one service that exposes GraphQL APIs, another one that works with GRPC, and have them all exposed as REST APIs using the API Gateway as a wrapper/converter to and from such formats. Hiding the actual API endpoints behind a Gateway also allows you to , which is a technique that will enable you to aggregate the results from different internal API calls and return the caller only the final result (as opposed as making the client call each single service and compose the result afterwards). implement API Composition Enhanced performance Depending on the vendor, you can have different tools to improve the overall performance. For example, you can to get quicker response times, or you can apply uniformed . cache responses data compressions Some vendors allow you to have multiple instances of the same service available behind the API Gateway, acting as a sort of Load Balancer. Another powerful technique you can implement is . In a simple architecture, if you have to communicate securely with three systems to aggregate the result, you have to validate the SSL connection three times. With , you can move these operations on the API Gateway component and avoid doing that in all the other services, making the application more performant. SSL Termination SSL Termination Disadvantages Single point of failure Since we placed an API Gateway in front of all the other API applications, all the external communication passes through the API Gateway. This means that , even though the single APIs are still up and running. if the API Gateway is unavailable, the whole system becomes unavailable as well So, when using an API Gateway: : an error in the configurations can have consequences on the whole system; Beware of the settings Ensure that the Gateway is capable of handling the incoming load of requests: if the API Gateway cannot cope with the number of incoming requests, it may become unavailable and make the whole system offline. Ensure that you have some (see the previous point). protection against DDoS attacks Increased latency An API Gateway is an in the API processing: when a client wants to call an API application, all requests must first pass through the API Gateway, which, in turn, will call the internal API. additional hop This processing, this routing, adds some network latency. Maybe it’s not noticeable, but it depends on the Gateway you choose, the underlying infrastructure, and the processing done by the Gateway. Vendor Lock-in Once you have deployed and configured an API Gateway, moving to another vendor might be difficult. You risk vendor lock-in, with all the consequences: if the price goes up or if they remove some functionalities that you need, you will have to come up with a solution to migrate that specific part of your infrastructure to another vendor. It might not be so easy - some straightforward ways to mitigate the risk are to and to that validate the routing and the functionalities. make your systems platform agnostic create e2e tests API Gateway VS Load Balancer Some people I know and the authors of some articles I read use API Gateway and Load Balancer as synonyms. Let me get it straight: they are not the same! Yes, they both are components that work with incoming requests. But they serve two totally different purposes. While Load Balancers “just” spread incoming requests across multiple instances of the same service, API Gateways act as a façade in front of different types of services. They are two totally different components of an architecture. Some vendors provide both functionalities, while others don’t. So, keep the two meanings distinct, and try to use the correct wording. API Gateway vendors comparison Here is a list of some API Gateway vendors’ prices, pros, and cons. Notice: . The info in this list comes primarily from their official documentation and, in some cases, from other resources that compare such products. I have yet to try all these vendors : it’s an Open Source product that provides features such as authentication, rate limiting, logging, caching, and more. It is written in Lua and runs on top of Nginx. Kong Price: Kong offers free community and paid enterprise editions. Pros: Kong is easy to install and configure, supports many plugins and integrations, and has a large and active community. Cons: Kong may have performance issues when handling large volumes of traffic, requires Nginx as a dependency, and has limited support for GraphQL, which is available only for the enterprise edition. : it’s a lightweight API Gateway written in Go. It offers API analytics, a developer portal, a dashboard, security, and other features. It can be deployed on-premises, in the cloud, or as a hybrid. Tyk Price: Tyk offers a 5-week free trial and four payment tiers. The Starter edition costs $600 per month for up to 10 million API calls. Pros: Tyk is fast, scalable, and flexible and has a rich set of features and plugins. Cons: Even though Tyk is open source, it has no free tier. : an API Gateway that is based on Express.js. It provides a single package with dynamic routing, access control, and API management. It is written in JavaScript. Express Gateway Price: Express Gateway is free and open source. Pros: Express Gateway is simple to use and customize, supports the Node.js ecosystem and middleware, and can be easily extended with plugins. Cons: Express Gateway may not be suitable for complex scenarios, as it lacks some advanced features such as caching (which is in the Medium Term roadmap). : an open-source API Gateway that is part of the Netflix OSS stack. It provides dynamic routing, resiliency, security, and monitoring for microservices. It is written in Java and can be integrated with other Netflix components. Zuul Price: Zuul is free and open source. Pros: Zuul is robust, reliable, and battle-tested by Netflix and supports filters for request processing. Cons: Zuul has limited documentation. : it offers features such as a developer portal, Gateway, policies, throttling, caching, and more. Azure API Management Price: Azure API Management offers a free tier and several paid tiers. The paid tiers start from $0.07 per hour for the Developer tier and go up to $3.83 per hour for the Premium tier. Pros: Azure API Management is easy to integrate with other Azure services, supports multiple protocols and formats, and has a rich set of features and policies. Cons: Azure API Management may have a complex pricing model, and it requires Azure Active Directory for authentication. : It provides complete lifecycle API management, from design and development to security and analytics. Amazon API Gateway Price: Amazon API Gateway offers a free tier and a pay-as-you-go model. The pay-as-you-go model charges per million API calls received, plus data transfer and caching fees. Pros: Amazon API Gateway is scalable, reliable, and secure; it supports serverless architectures and WebSocket APIs. Cons: Amazon API Gateway may have a steep learning curve for beginners, requires AWS Lambda for custom logic, and has limited documentation and support. It has a complex pricing tier. : It supports OpenAPI Specification v2 and gRPC APIs. Google Cloud API Gateway Price: Google Cloud API Gateway offers tiers based on the number of API calls. From 0 to 2 million calls, the service is free. From 2 million to 1 billion calls, you pay $3.00 per million API calls, while from 1 billion on, you pay $1.5 per million API calls. Pros: Google Cloud API Gateway is easy to use and deploy, supports multiple authentication methods and protocols, and integrates well with other Google Cloud services. Cons: It has limited plugins and integrations. Further readings It’s not the first time we talked about API Gateways in this blog: in fact, there’s an old article where I shared some things I learned about API Gateways the first time I heard about them: 🔗 API Gateways - an overview | Code4IT We also learned how to use Azure API Management to integrate the API Gateways product provided by Azure to organize some .NET APIs. 🔗 How to create an API Gateway using Azure API Management | Code4IT This article taught us that API Gateways are different from Load Balancers. Do you know what are some types of Load Balancers and why you should care? 🔗 Davide’s Code and Architecture Notes - L4 vs L7 Load Balancer | Code4IT Wrapping up Beware those who say that API Gateways are «the best thing to add to a microservice architecture»! As we learned, there are some downsides, too. Always make sure that the products and the components you choose fit your necessities and that you learn when something is for you. not I hope you enjoyed this article! Let’s keep in touch on or ! 🤜🤛 Twitter LinkedIn Happy coding! 🐧 Also published . here

A Guide to API Gateways: Unveiling Advantages, Disadvantages, and Vendor Comparisons

If you need to handle lots of incoming requests, you should manage the incoming traffic by balancing the load across different servers. You should consider adding a Load Balancer: it’s a layer of abstraction that handles requests, availability, and security in a centralized place. When handling a massive amount of requests, a system generally needs to balance the incoming load to avoid overloading a single server. To do that, we typically use a Load Balancer in front of our applications to handle all the incoming traffic. In this article, we will learn what a Load Balancer is and what problems it solves, and we will delve into the main categories of Load Balancing: L7 and L4. What is a Load Balancer? and, through a specific process, forwards each request to a specific node of the “internal” architecture. A Load Balancer is a piece of the network architecture that deals with incoming requests It can be a distinct piece of hardware, as well as a software component already part of the network architecture. Despite the name, a Load Balancer does not only balance the load; some of its core functionalities are: : of course, it has a way to determine which server will handle a specific request; Load Balancing : to understand where to redirect requests, a Load Balancer needs to keep track of the available resources and their addresses; Service Discovery : clients will not know the real address of the destination servers; they will only know the address of the Load Balancer; Abstraction : a destination server must not only exist, but it must also be in a healthy state. Unhealthy servers are excluded from the possible destination servers. Health Checking Health checking is one of the vital parts of a Load Balancer, and how to handle unhealthy services is a complex topic. Suppose you have two servers, Server1 and Server2 that can handle 50 requests per second each. Suddenly, Server1 becomes unhealthy, and the Load Balancer removes it from the list of available servers. The same 100 users keep accessing the service, but now, since Server1 is unavailable, Server2 will have to handle 100 requests/sec. If it’s not able to handle that spike, the whole application will be offline, and none of the users will be able to access the system. So, just , and you must think of a more complex mechanism. moving all the traffic to a single instance should be avoided Depending on the type of Load Balancer (L4 vs L7), you can also have more functionalities, such as and . Authentication Observability The OSI Model Before moving to L4 and L7, we need to have a look at the OSI model. . It’s composed of 7 different (L1 to L7), each with its specific responsibilities, protocols, and behaviors. The OSI Model is the definition of the abstractions used in networking layers : is the entry point of the stack and is the one accessed by computers; it works with HTTP, FTP, and more; L7 - Application layer : validates data format, applies encryption, and applies data compression; it encrypts data when using SSL and validates data formats like JPEG or TXT; L6 - Presentation layer : maintains the connection to the destination port; operates via network sockets; L5 - Session layer : transmits data using a transmission protocol (namely, TCP and UDP), guaranteeing connection reliability and handling transmission errors; L4 - Transport layer : working on packets of data, this layer defines which physical path data will take; works with IPs and ICMP; L3 - Network layer : it defines the format of the data on the network, dividing the source of data into smaller chunks ( ); L2 - Data Link layer frames : this layer transmits the raw stream of bits over a physical medium (such as a wire); L1 - Physical layer When a client tries to access a host, every request passes through all seven layers. A Load Balancer that works on a specific layer can perform different operations because it “knows” different metadata of the same connection. L7 Load Balancer: handle requests by looking at the content . Since it works at this layer, the Load Balancer can balance requests based on the whole payload of the request. An L7 Load Balancer acts on the Application layer For instance, an L7 Load Balancer can handle: : since it knows the full URL, it can redirect the request to a specific server. For instance, if the path is , the Load Balancer can send the request to a server dedicated to images; Routing /images/avatar.png : encryption and decryption are resource-expensive operations. You can free up some resources on the destination servers by , making your applications able to handle more requests (because they no longer need to encrypt and decrypt data); SSL Termination delegating encryption and decryption to the Load Balancer : given that an L7 Load Balancer has access to all the metadata related to a request, such as HTTP Headers, it can work as an authentication layer that returns 401 - Unauthorized in case, for example, a specific HTTP Header is missing. Authentication : an L7 Load Balancer can be used to apply observability to a resource by tracing the incoming requests, the response time, and more; Observability : an L7 Load Balancer can protect your application from DDoS attacks ; Security You can find a lot of Load Balancers that work at the Application layer, such as: Azure Application Gateway AWS Classic/Application Load Balancer Traefik (Open Source) NGINX (Open Source) L4 Load Balancer: handles requests by looking at connections and IPs : it does not have access to the request Body or its HTTP Headers, so it cannot perform smart decisions based on the actual content of the request. An L4 Load Balancer acts at the TCP/UDP level Even though it’s not as smart as an L7 Load Balancer, it still has some advantages: Since it works at the transport layer and does not perform any check on the request payload, it’s way than an L7 Load balancer; faster It’s unaware of the type of data it is receiving: bytes can come from an HTTP request as well as from a MongoDB connection; Can choose the destination server based on the IP address; As you can imagine, many teams prefer an L7 Load Balancer over an L4 Load Balancer. However, you can find some good L4 Load Balancers on the web: Azure Load Balancer AWS Network/Gateway/Classing Load Balancer HAProxy Technologies VMWare Further readings We’ve just scratched the surface of the topic. For sure, to understand better the differences between L7 and L4, have a look at the definition and the structure of the OSI Model: 🔗 OSI Model | Wikipedia Then, an amazing article about all the possible functionalities of a Load Balancer, as well as the different types (Edge, Sidecar, Middle): 🔗 Introduction to modern network load balancing and proxying | Matt Klein This article first appeared on Code4IT 🐧 Finally, a short but valuable article about L4 and L7 Load Balancers, with a demo created using Docker and Envoy: 🔗 L4 vs L7 Load Balancing | Mohak Puri Wrapping up In this article, we’ve learned how L7 and L4 Load Balancers differ, and what are the functionalities provided by both types. Here’s a short table to sum up the differences. L4 Load Balancing L7 Load Balancing Works at the transport layer Works at the application layer Uses TCP and UDP protocols Uses HTTP and SMTP protocols Makes routing decisions based on simple algorithms and network information such as ports and protocols Makes routing decisions based on content information such as headers, message content, URL type, and cookie data Does not inspect or decrypt messages Terminates, inspects, and decrypts messages Fast, efficient, and secure Complex, informed, and application-aware Deals with individual connection flows Deals with individual requests Cannot do smart load balancing or content optimization based on the media type, localization rules, etc. Can do smart load balancing and content optimization based on the media type, localization rules, etc. I hope you enjoyed this article! Let’s keep in touch on or ! 🤜🤛 Twitter LinkedIn Happy coding! 🐧 Also published . here

Understanding L4 and L7 Load Balancers for Efficient Traffic Management

Feature Flags let you remotely control the activation of features without code changes. They help you to test, release, and manage features safely and quickly by driving changes using centralized configurations. In a previous article, we learned . Also, a while ago, we learned . how to integrate Feature Flags in ASP.NET Core applications how to integrate Azure App Configuration in an ASP.NET Core application In this article, we are going to join the two streams in a single article: in fact, we will learn how to manage Feature Flags using Azure App Configuration to centralize our configurations. It’s a sort of evolution from the previous article. Instead of changing the static configurations and redeploying the whole application, we are going to move the Feature Flags to Azure so that you can enable or disable those flags in . just one click A recap of Feature Flags read from the appsettings file Let’s reuse the example shown in the previous article. We have an ASP.NET Core application (in that case, we were building a Razor application, but it’s not important for the sake of this article) with some configurations defined in the file under the key: appsettings Feature {
  "FeatureManagement": {
    "Header": true,
    "Footer": true,
    "PrivacyPage": false,
    "ShowPicture": {
      "EnabledFor": [
        {
          "Name": "Percentage",
          "Parameters": { "Value": 60 }
        }
      ]
    }
  }
} We have already dove deep into Feature Flags in an ASP.NET Core application in . However, let me summarize it. the previous article First of all, you have to using the structure we saw before. define your flags in the file appsettings.json To use Feature Flags in ASP.NET Core, you have to install the NuGet package. Microsoft.FeatureManagement.AspNetCore Then, you have to by calling: tell ASP.NET to use Feature Flags builder.Services.AddFeatureManagement(); Finally, you are able to : consume those flags in three ways inject the interface and call or ; IFeatureManager IsEnabled IsEnabledAsync use the attribute on a Controller class or a Razor model; FeatureGate use the tag in a Razor page to show or hide a portion of HTML <feature> How to create Feature Flags on Azure App Configuration We are ready to move our Feature Flags to Azure App Configuration. Needless to say, you need an Azure subscription 😉 Log in to the Azure Portal, head to “Create a resource”, and create a new App Configuration: I’m going to reuse the same instance I created in the previous article - you can see the full details in the section. How to create an Azure App Configuration instance Now we have to configure the same keys defined in the appsettings file: , , and . Header Footer PrivacyPage Open the App Configuration instance and in the left panel. This is the central place for creating, removing, and managing your Feature Flags. Here, you can see that I have already added the and , and you can see their current state: “Footer” is enabled, while “Header” is not. locate the “Feature Manager” menu item Header Footer How can I add the flag? It’s elementary: click the “Create” button and fill in the fields. PrivacyPage You have to (they can also be different), and if you want, you can add a Label and a Description. You can also define whether the flag should be active by checking the “Enable feature flag” checkbox. define a Name and a Key Read Feature Flags from Azure App Configuration in an ASP.NET Core application It’s time to integrate Azure App Configuration with our ASP.NET Core application. Before moving to the code, we have to and store it somewhere. locate the connection string Head back to the App Configuration resource and locate the “Access keys” menu item under the “Settings” section. From here, copy the connection string ( ) and store it somewhere. I suggest that you use the Read-only Keys Before proceeding, you have to install the NuGet package. Microsoft.Azure.AppConfiguration.AspNetCore Now, we can by connecting to the connection string and by declaring that we are going to use Feature Flags: add Azure App Configuration as a source for our configurations builder.Configuration.AddAzureAppConfiguration(options =>
    options.Connect(connectionString).UseFeatureFlags()
); That’s not enough. We need to by adding such functionalities to the property. tell ASP.NET that we are going to these configurations consume Services builder.Services.AddAzureAppConfiguration();

builder.Services.AddFeatureManagement(); Finally, once we have built our application with the usual , we have to : builder.Build() add the Azure App Configuration middleware app.UseAzureAppConfiguration(); To try it out, run the application and validate that the flags are being applied. You can enable or disable those flags on Azure, the application, and check that the changes to the flags are being applied. Otherwise, you can and see the changes applied to your application. restart wait 30 seconds to have the flag values refreshed Using the Percentage filter on Azure App Configuration Suppose you want to enable a functionality only to a percentage of sessions ( ). In that case, you can use the Percentage filter. sessions, not users! The previous article had a specific section dedicated to the , so you might want to check it out. PercentageFilter As a recap, we defined the flag as: {
  "ShowPicture": {
    "EnabledFor": [
      {
        "Name": "Percentage",
        "Parameters": {
          "Value": 60
        }
      }
    ]
  }
} And added the filter to ASP.NET with: PercentageFilter builder.Services.AddFeatureManagement()
    .AddFeatureFilter<PercentageFilter>(); Clearly, we can define such flags on Azure as well. Head back to the Azure Portal and add a new Feature Flag. This time, you have to to any existing flag. add a new Feature Filter Even though the PercentageFilter is out-of-the-box in the FeatureManagement NuGet package, it is not available on the Azure portal. You have to define the filter with the following values: must be “Custom”; Filter Type must be “Percentage” Custom filter name You must add a new key, “Value,” and set its value to “60”. The configuration we just added reflects the JSON value we previously had in the file: 60% of the requests will activate the flag, while the remaining 40% will not. appsettings Define the cache expiration interval for Feature Flags By default, . Feature Flags are stored in an internal cache for 30 seconds Sometimes, it’s not the best choice for your project; you may prefer a longer duration to avoid additional calls to the App Configuration platform; other times, you’d like to have the changes immediately available. You can then define the cache expiration interval you need by configuring the options for the Feature Flags: builder.Configuration.AddAzureAppConfiguration(options =>
    options.Connect(connectionString).UseFeatureFlags(featureFlagOptions =>
    {
        featureFlagOptions.CacheExpirationInterval = TimeSpan.FromSeconds(10);
    })
); This way, Feature Flag values are stored in the internal cache for 10 seconds. Then, when you reload the page, the configurations are reread from Azure App Configuration, and the flags are applied with the new values. Further readings I built during these months to explore how to use configurations in ASP.NET Core. This is the final article of a path We started by learning how to set configuration values in an ASP.NET Core application, as explained here: 🔗 3 (and more) ways to set configuration values in ASP.NET Core Then, we learned how to read and use them with the family: IOptions 🔗 Understanding IOptions, IOptionsMonitor, and IOptionsSnapshot in ASP.NET Core From here, we learned how to read the same configurations from Azure App Configuration, to centralize our settings: 🔗 Azure App Configuration and ASP.NET Core API: a smart and secure way to manage configurations | Code4IT Then, we configured our applications to automatically refresh the configurations using a Sentinel value: 🔗 How to automatically refresh configurations with Azure App Configuration in ASP.NET Core Finally, we introduced Feature Flags in our apps: 🔗 Feature Flags 101: A Guide for ASP.NET Core Developers | Code4IT And then we got to this article! This article first appeared on Code4IT 🐧 Wrapping up In this article, we have configured an ASP.NET Core application to read the Feature Flags stored on Azure App Configuration. Here’s the minimal code you need to add Feature Flags for ASP.NET Core API Controllers: var builder = WebApplication.CreateBuilder(args);

string connectionString = "my connection string";

builder.Services.AddControllers();

builder.Configuration.AddAzureAppConfiguration(options =>
    options.Connect(connectionString)
    .UseFeatureFlags(featureFlagOptions =>
        {
            featureFlagOptions.CacheExpirationInterval = TimeSpan.FromSeconds(10);
        }
    )
);

builder.Services.AddAzureAppConfiguration();

builder.Services.AddFeatureManagement()
    .AddFeatureFilter<PercentageFilter>();

var app = builder.Build();

app.UseRouting();
app.UseAzureAppConfiguration();
app.MapControllers();
app.Run(); I hope you enjoyed this article! Let’s keep in touch on or ! 🤜🤛 Twitter LinkedIn Happy coding! 🐧 Also published . here

Azure App Configuration for Advanced Feature Flag Management in ASP.NET Core

Content Delivery Networks (CDNs) are commonly used with AEM to improve website performance by and from edge locations closer to users. However, when AEM content changes it can lead to in the . Manual cache invalidation is complex and error-prone. caching serving content outdated copies CDN cache Though CDNs improved performance, our authors’ new changes weren’t reflected until caches expired. post-publish did not scale. Clearing the cache manually I could not find an existing out-of-the-box solution for this problem. So I developed an that and selective cache based on . open-source AEM library listens to publishing events automatically triggers invalidation configurable rules The library AEM replication events or resource changes and then runs to invalidate cached CDN content related to the published updates. allow various CDNs while enable customization. reacts to asynchronous background jobs Flexible APIs integration with extension points The Problem CDNs cache website content like pages, images, and JS/CSS assets. This avoids repeatedly serving from the AEM publish tier which . The CDN only re-fetches assets when they from the after a . static content improves response times expire cache TTL (Time to Live) However, updated AEM content can get lingering in the CDN after publishing. Some examples: outdated copies a new content page is not immediately to users. The older version remains cached. Publishing visible a product image in DAM does not show until the CDN cache expires. Updating Depending on the business context, any of these situations can be a really that needs to be addressed urgently. But sadly, on every publish is and : sensitive issue clearing the cache manually operationally complex time-consuming Identifying related URLs is manual and repetitive Tedious cache tagging schemes to coordinate flushing An automated solution is needed… one that selectively and intelligently invalidates cache only for published updates. Automated Cache Invalidation Library “Automatic CDN Cache Invalidator for AEM” listens to publish events and resource changes, then triggers background cache invalidation per configurable rules. Flexible APIs allow integration with various CDNs. https://github.com/realgpp/aem-cdn-cache-invalidator?embedable=true Key Capabilities : Reacts to AEM replication events for publishing updates Automatic triggering Invalidates cache only for specific published paths rather than mass flush Selective invalidation: Uses queue-based jobs framework to offload CDN calls Async processing: Flush cache by URL, tag or custom criteria Configurable rules: Detailed logging for tracking Logs: Akamai Purge API is integrated Akamai support built-in: Easily extendable for other CDNs via APIs Flexible CDN integrations: Hooks to personalize behavior Extension APIs: It solves manual cache management challenges allowing authors to focus on content while optimizing end-user experience. Let’s walk through the flow… How it Works The application has configurable OSGi services and listeners for cache invalidation triggered by AEM events. : Replication or resource change events signify content updates. Event listening An OSGi listener consumes events filtering to specific trees. It creates asynchronous jobs with updated paths. Selective listener: A separate job thread processes paths to extract cache-related metadata like URLs, tags etc. Background job: The job makes the API call to invalidate the cache for the computed metadata. CDN API call: The CDN receives the API request and flushes related cached content. Cache flush: The async approach avoids publish request performance impact. The CDN calls happen out-of-band without blocking AEM. The entire flow is configurable via OSGi including supported events, cache criteria, URLs, or logic. Out-of-the-box integrations make it easy to get started while extension points allow customization. Let’s explore common configuration options… Purging content with Akamai API The project includes reusable services, listeners, and jobs supporting caching scenarios like: Invalidating pages or assets by URL Website sections by or tag code The following are the Akamai Purge APIs supported out of the box: and by Tag invalidation deletion and by CP Code invalidation deletion and by URL invalidation deletion The following block, which you can find in the ui.config.example maven module, shows how to configure the Akamai service that comes with the library. // file com.baglio.autocdninvalidator.core.service.impl.AkamaiInvalidationServiceImpl.cfg.json
{
  "isEnabled": true,
  "configurationID": "cdn-akamai",
  "hostname": "localhost:8443",
  "getAkamaiClientToken": "placeholder_akamai_client_token",
  "getAkamaiAccessToken": "placeholder_akamai_access_token",
  "getAkamaiClientSecret": "placeholder_akamai_client_secret",
  "httpClientConfigurationID": "http-client-akamai",
  "purgeType": "invalidate"
} This service lets you choose how to purge content from the CDN: you can either invalidate or delete it. As you can see, you need to replace placeholders with your Akamai values. You also need a dedicated HTTP Client Configuration to work with the Akamai APIs. After that, your service can be used by other sling jobs that handle content-change events. Now let’s explore other configuration options that let you customize the library without coding… Configuration Areas The library offers a variety of configuration options to customize its functionality without code customizations. You can adjust these settings to suit your specific needs and preferences. I want to keep this introduction brief and engaging but don’t worry if you have questions about the details. You can find more information in the README.md file of the project or in the Javadoc comments if you like to explore the code. Key aspects to configure are: Replication topics or resource change events that trigger the invalidation jobs. Observed events: // file com.baglio.autocdninvalidator.core.listeners.ReplicationEventListener-website-generic.cfg.json
{
  "isEnabled": true,
  "resource.paths": [
    "/content/we-retail",
    "/content/wknd"
  ],
  "job.topic": "com/baglio/autocdninvalidator/akamai/generic",
  "filter.regex": "^/content/(we-retail|wknd)(?!.*products)(?!.*adventures).*$"
} // file com.baglio.autocdninvalidator.core.listeners.DynamicResourceChangeListener-website-generic.cfg.json
{
  "isEnabled": false,
  "resource.change.types": [
    "CHANGED"
  ],
  "resource.paths": [
    "/content/we-retail",
    "/content/wknd"
  ],
  "job.topic": "com/baglio/autocdninvalidator/akamai/generic",
  "filter.regex": "^/content/(we-retail|wknd)(?!.*products)(?!.*adventures).*$"
} API credentials and settings for your provider. CDN credentials: // file com.baglio.autocdninvalidator.core.service.impl.AkamaiInvalidationServiceImpl.cfg.json
{
  "isEnabled": true,
  "configurationID": "cdn-akamai",
  "getAkamaiClientToken": "placeholder_akamai_client_token",
  "hostname": "localhost:8443",
  "getAkamaiAccessToken": "placeholder_akamai_access_token",
  "getAkamaiClientSecret": "placeholder_akamai_client_secret",
  "httpClientConfigurationID": "http-client-akamai"
} Filtering rules and cache flush criteria for each job consumer. Invalidation rules: // file com.baglio.autocdninvalidator.core.jobs.EditorialAssetInvalidationJobConsumer.cfg.json
{
  "isEnabled": true,
  "job.topics": [
    "com/baglio/autocdninvalidator/akamai/generic"
  ],
  "cdnConfigurationID": "cdn-akamai",
  "invalidation.type": "tag",
  "tagCodeMappings": [
    "/content/we-retail/(..)(/.*)*=tag-dev-$1",
    "/content/we-retail/(..)/.*/experience/.*=tag-dev-$1-experience",
    "/content/wknd/(..)(/.*)*=tag-dev-$1",
    "/content/wknd/(..)/.*/adventures/.*=tag-dev-$1-adventures"
  ]
} Throttling and parallelization configs for each job topic. Please have a look at the section Custom Job Queue Configuration of project README file. Job topic tuning: These configurations determine how the library responds to AEM events, how many cache jobs run concurrently, and how the service communicates with your CDN provider to purge the cache. Now that we have learned the basics, let’s move on to the fun part where we show you how to make the invalidation work on the AEM instance… Enabling Akamai CDN Integration If you want to use this library right away, you don’t need to write any code. Just follow these simple steps: : Install the ui.config.example module or create the manually. The ui.config.example module is a sample configuration that provides a working example for . You can install it from the package manager or create the OSGi config manually through the web console. Step 1 OSGi config Akamai integration : Enter your Akamai and in the . You must provide your Akamai hostname, client token, access token, and client secret in the AkamaiInvalidationServiceImpl config file. You can find these values in your Akamai portal. Step 2 credentials settings AkamaiInvalidationServiceImpl config file : Choose to AEM events on Author or Publish.Depending on your setup, you can choose to listen for AEM events on Author or Publish. If you choose Author, the module will detect and the accordingly. If you choose Publish, the module will detect and the accordingly. Step 3 listen for publish events invalidate cache content updates purge cache Now let’s walk through adding support for a new custom CDN provider… Implementing a Custom CDN Provider Now that we’ve explored utilizing the library without coding, what if you encounter the need for a CDN provider that isn’t currently supported? The library is designed for to support new CDN providers. You can easily extend it by following these steps: extension Create a Java class the . This interface defines the methods for the . implementing CdnInvalidationService interface purging CDN cache Implement the logic for your CDN’s in your implementation class. calling purge API Create an for your class with the necessary and property values. Make sure to give it a so that it can be identified by the invalidation job. OSGi configuration credentials unique configuration ID Use the configuration ID mentioned above when you create configurations. invalidation job The library provides the invalidation logic when using the built-in Akamai integration. If you need to the or , the class exposes you can without having to reimplement the full Akamai handling. flexibility to customize tweak preprocessing postprocessing AbstractInvalidationJob hook methods override With the procedure shown in the above image, you get the benefits of leveraging the existing Akamai capabilities while adapting things like: - The and methods allow transforming the content paths and invalidation values before and after generating them. preprocessInvalidationValues postprocessInvalidationValues - The and methods allow updating the public URLs before and after resolving them. preprocessPublicUrls postprocessPublicUrls - The and methods enable logic before and after making the CDN purge call. beforeInvalidation afterInvalidation By selectively overriding these hooks, you can adapt the data and flows to your needs while reusing the bulk of the Akamai integration code. This makes the library very extensible without having to start from scratch. Wrap Up And that’s a wrap! We’ve covered everything from to with this CDN invalidator library. I hope you found it an interesting read! out-of-the-box setup fully custom integrations Did any part leave you scratching your head? Or maybe this library has already helped you invalidate caches more easily? Either way, I’d love to hear your thoughts! Let me know what worked, what didn’t, or what other guides would help improve your CDN workflows. Even better — I welcome if you have , tweaks, or new snippets that can this library and tutorial! pull requests code changes enhance I greatly appreciate you taking the time to provide and . Your will help this project and craft content that empowers fellow developers to their . feedback contributions real-world experiences evolve master CDN footprints Also published . here

How to Automate CDN Cache Invalidation in Adobe Experience Manager

In my , I have shown a way to unify the implementation of the most well-known graph-traversal algorithms. Now, let's make it more visually appealing and look into the performance differences. last post The story behind A few years ago, Yandex organized a contest called with an enticing prize: a ticket to a . The contest resembled a game, with participants tasked with finding optimal routes on a map and optimizing delivery using robotic couriers. Robots Couriers closed self-driving conference for professionals As I delved into the topic, I discovered that despite route finding being a solved problem, it continued to interest the professional game development community. Between 2010 and 2020, engineers , particularly beneficial for AAA games with massive maps. Reading on these optimizations was an exciting experience. made significant optimizations to the A* algorithm articles and research papers Furthermore, the contest requirements were designed to enable easy assessment of program outputs by the contest’s testing system. As a result, there was little emphasis on visualization. I found exploring this field intriguing and developing a small application that uses well-known graph algorithms to find routes on a grid map. To visualize my findings, I employed the SFML graphics library. Goal This project builds upon one of , where I demonstrated that four well-known path-finding algorithms (BFS, DFS, Dijkstra's, and A*) are not fundamentally different and can be implemented in a universal way. However, it was challenging to showcase significant performance differences among these algorithms in that project. my previous endeavors In this article, I aim to use improved test data and design something visually exciting. While the Yandex Contest task mentioned earlier aligns well with my goals, I will not solve their specific problem here since it heavily relies on their test system, which is currently unavailable. Instead, I will extract general ideas for input parameters from that contest and create my own implementation. Imaginary world Imagine a technically advanced and innovative city where the future has arrived long ago. In this city, the majority of orders are delivered by courier robots, and it has become a rarity for a person to deliver an order from a cafe. In this task, we invite you to participate in finding optimal routes to deliver orders efficiently. Let's envision the city as an N × N map. For simplicity, we assume that each robot occupies exactly one cell, and each cell can either be passable or not for the robots. In one step, a robot can move in any of the four cardinal directions (up, down, left, or right) if the target cell is free. And I'm of the original task: ignoring the rest At the beginning of the test, you need to output the number of robots you want to use to deliver orders and their initial coordinates. The construction of each robot will cost Costc rubles. Next, T iterations of the simulation will be performed. One iteration represents one virtual minute and consists of 60 seconds. At each iteration, your program will be given the number of new orders, and in response, the program should tell you what actions each robot performs (60 actions per robot). For each successfully delivered order, you will receive max(0, MaxTips - DeliveryTime) dollars in tips, where MaxTips is the maximum number of tips for one order, and DeliveryTime is the time from the moment the order appeared to its delivery in seconds. The total number of points that you earn in one test is calculated by the formula TotalTips - R × Costc, where TotalTips is the total number of tips earned, R is the number of robots used, Costc is the cost of building one robot. The Costc and MaxTips values are set in each test. If you earned less tips than you spent on making robots, your total points will be 0. You will also receive 0 points for the test if you perform any incorrect action. Input The program uses standard input to read the parameters. This approach allows us to specify test data of various complexities using input files. The first line of input contains three natural numbers: N (the size of the city map), MaxTips (the maximum number of tips per order), and Costc (the cost of building one robot). I ignored both MaxTips and Costc parameters for my first implementation and maybe will consider that in the future. Following that, each of the next N lines contains N characters representing the city map. Each string can consist of two types of characters: '#' - indicates a cell occupied by an obstacle. '.' - indicates a free space. Next, you will be provided with two natural numbers: T and D (T ≤ 100,000, D ≤ 10,000,000). T represents the number of interaction iterations, and D represents the total number of orders. Output Your task is to visualize the map and the optimal routes using the SFML graphics library. Modelling the maps I'm fond of maps represented as a grid of cells. Thus, I prefer to render all the results and map them as a grid on cell by cell basis. There is also the option to execute path search right on the grid without using any additional data structure (and I have implemented this as well for learning purposes: see in code). But because of a grid, it is easy to represent a map as a graph in one way or another. I prefer to use an adjacency list of cells for most of the algorithms like BFS, Dijkstra's, and A-Star. For algorithms like Bellman-Ford, it may make sense to use an Edges List instead of an Adjacency List. That's why if you explore the codebase, then you will find all of it, and they all are working examples. To split the logic and responsibility, I have a entity that is responsible for executing path finding according to the orders and tasks configuration that is specified via the file and related map files. Navigator App Config looks like this: App Config {
    "font": "../../data/arial.ttf",
    "map": "../../data/maps/test_29_yandex_weighten_real_map",
    "shadow": false,
    "map_": "../../data/maps/test_08_low_res_simple_map",
    "map__": "../../data/maps/test_10",
    "map___": "../../data/maps/test_07_partially_blocked_map",
    ... Note that "map_” "map__" etc. are not really configuration properties. They are ignored during the application run. Since there is no way to comment on the part of the JSON file, I use underlining in the property name so it can stay in the config file but not be used. looks like this: The map file 25 50 150
#########################
#########################
#########################
###.......#####.......###
###.......#####.......###
###.......#####.......###
###...................###
###.......#####.......###
###.......#####.......###
###...................###
######.###########.######
######.###########.######
######.###########.######
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
######.###########.######
#########################
#########################
#########################
#########################
2 4
2
6 6 4 20 This is one of the simplest examples that contain either blocked or not blocked cells. I have prepared a lot of various examples of input parameters and test data. Starting from very small parts that let you debug and learn the code, finishing with a huge piece of map (from the real existing city) that allows us to measure the performance of a Graph algorithm. How do we draw such maps? When a map contains only cells with binary state (either blocked or non-blocked), this basically means that any edge of a graph either exists or not. To find a path in the graph, we have to represent it efficiently. Like in my previous post, I have used an with the relationship as Vector[NodeId]->points to->Vector[Neighbour Nodes]: adjacency list typedef std::vector<std::vector<std::shared_ptr<Cell>>> Graph; When we exploring grids it's not really necessary to use graphs at all. We are capable to traverse grid using BFS/DFS algorithms cell by cell without thinking about edges. See method for example. _GetPathByBFSOnGrid First, the initialization code reads the file and converts it into row by row and column by column: the grid bool RectangularMap::LoadMap(const std::string& filepath, bool shadow)
{
...
  // Fill the grid.
  _verticesNumber = 0;
  for (int row = 0; row < _height; row++)
  {
    ...
    for (int col = 0; col < _width; col++)
    {
      int x = col;
      int y = row;
      if (line[col] == BLOCK_CELL)
      {
        // Create a shared pointer here to safely pass pointers between the classes.
        _grid[row][col] = std::make_shared<Cell>(x, y, line[col], blockColor, shadow, _scaleFactor);
      }
      else
      {
        ...
      }
    }
  }

  // Make a graph
  InitialiseGraph();
...
} Then, it creates an actual graph as : an adjacency list void RectangularMap::InitialiseGraph()
{
  MapBase::InitialiseGraph();
  ...
  unordered_set<int> visited;

  for (int rr = 0; rr < _grid.size(); rr++)
  {
    for (int cc = 0; cc < _grid[rr].size(); cc++)
    {
      if (_grid[rr][cc]->GetId() > -1)
      {
        for (int i = 0; i < 4; i++)
        {
          int r = rr + dr[i];
          int c = cc + dc[i];

          if (r >= 0 && c >= 0 && r < _width && c < _height &&
              _grid[r][c]->GetId() > -1)
          {
            if (_isNegativeWeighten)
            {
              ...
            }
            else
            {
              _adjacencyList[_grid[rr][cc]->GetId()].push_back(_grid[r][c]);
            }
          }
        }
      }
    }
  }
} Grid representation is useful to draw on the screen using the SFML library. We can draw (this is exactly what I do for small maps): by creating a geometric object ...
for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    _grid[j][i]->Draw(_window, _scaleFactor);
  }
}
...
sf::RectangleShape tile;
tile.setSize(sf::Vector2f(_cellSize - 5, _cellSize - 5));
tile.setPosition(sf::Vector2f(_x * _cellSize, _y * _cellSize));
tile.setFillColor(_color);
window.draw(tile); Or we can do it for larger maps: efficiently pixel by pixel sf::Uint8* pixels = new sf::Uint8[_width * _height * 4];

for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    int index = (_grid[j][i]->GetY() * _width + _grid[j][i]->GetX());

    sf::Color color = _grid[j][i]->GetColor();
    pixels[index * 4] = color.r;
    pixels[index * 4 + 1] = color.g;
    pixels[index * 4 + 2] = color.b;
    pixels[index * 4 + 3] = color.a;
  }
}

sf::Texture texture;
texture.create(_width, _height);
texture.update(pixels);
sf::Sprite sprite;
sprite.setTexture(texture);
sprite.setScale(cellSize, cellSize);
_window.draw(sprite); Finally, let's see what a map defined by file would look like. Originally, the file defined this: test_25_xmax ..............C.................
..............#.................
.............###................
............#####...............
...........#######..............
..........##1###2##.............
.........###########............
........##3######4###...........
.......###############..........
......#################.........
.....###################........
....#####################.......
.............###................
.............###................
.............###................ And a map renderred with SFML looks like this: Because I wanted all of that to be controlled by the user with the keyboard, I left all the user-behavior logic in the . I like to call it “Controller” logic. main.cpp SFML library makes it very easy to handle keyboard events: while (window.isOpen())
{
  Event event;
  while (window.pollEvent(event))
  {
    if (event.type == Event::Closed)
      window.close();

    if (event.type == Event::KeyPressed && event.key.code == Keyboard::Space)
    {
      ... Do what you need here
    }
  }
} The main idea is for user triggers (press of a SPACE button) to read the map file and rendering the map, and then by a second trigger (second press of a SPACE button) to load the routing task and calculate the shortest path between two points on the map: ...
if (navigator->IsReady())
{
  navigator->Navigate(); // Finding route between two points
}
else
{
  if (map->IsReady()) // Second SPACE press runs the routing
  {
    skipReRendering = true;
    if (navigator->LoadTasks(filepath))
    {
      navigator->SetMap(map);
    }
  }
  else // Load and draw map
  {
    drawLoading(window, font);
    if (!map->LoadMap(filepath, shadowed))
    {
      return 0;
    }
    drawProcessing(window, font);
  }
}
... We need to go deeper I wanted to play with more Graph algorithms, and they all have their limitations, so I decided to implement multi-color maps that can be represented by multi-weighted graphs. Every cell is colored, and the color means that the edge not only exists but also applies some weight (or fee, or fine, you name it). So, the edge might be blocked, half blocked, not blocked, ... you got the idea. Thus, I have implemented multi-color maps that look more joyful and look like a game-ready (example from file ): test_31_multi_weight_graph_map Some of the configuration files contain more complex maps from really existing cities, like : test_29_yandex_weighten_real_map As a challenge, now we should handle maps with very flexible configuration. essentially contains a lot of logic inside, including all the graph algorithms and even more than needed (because I like to play with things, even if it's not particularly useful for now). RectangularMap.cpp I have implemented , , , algorithms, and a number of additional "utility" algorithms like Topological Sort, Single Source Path, that are not useful for the current application state (because they work on Directly Acyclic Graphs, which are not type of Graphs I currently use), but I have some ideas to use it in future improvements. BFS#Line 598 Dijkstra#Line 299 A-Star#Line 356 Bellman-Ford#Line 428 I didn't polish all the code and didn't get it ideal enough, but it allows me (and, I hope, will allow you) to play with the code and compare performance metrics. Sorry about some commented lines here and there, maybe some dirty code...it's all way of learning :). To grasp an idea of what's inside, I recommend you review the . RectangularMap.h There are also some fun features, like a Focus feature that allows one to render only a particular part of a map. It changes focus by re-rendering the necessary part using the when the user presses the PgDown or PgUp buttons. It is pretty easy to improve this feature and implement "Zoom" functionality. Take it as a homework, if you like it. Observer pattern Focus feature with map file in work: test_29_yandex_weighten_real_map Classes diagram looks like this: Run and play I believe the most joyful part is just running this little application is playing with variations of its configuration and algorithms. You can do a lot of experiments by using various map files as input parameters with different test data as well as change the logic in the code. After starting, you need to press SPACE an application will render a map according to the configuration file, and it makes a lot of sense to start exploring from the simplest test cases and moving forward to the most complex ones. Pressing SPACE one more time executes the routing algorithms and finds the path between the start and the nearest order. BTW, It's not yet done, but it is easy to implement reading all the rest of the orders available in map configuration files and execute pathfinding to all of them. Here is the route found on the map defined by file : test_18_yandex_super_high_res It is also capable of finding routes in the maps that simulate existing cities, like : test_29_yandex_weighten_real_map Finding efficient paths between two coordinates becomes challenging for algorithms like BFS but can be easily done by A-star. Based on the cells found in the map configuration files, the application will treat the map as a weighted or non-weighted graph and will select the right algorithm for it (and you can easily change this as well). It's easy to see the difference between BFS and A-Star performance: Final words With this, I want to leave you alone and let you play with these code examples. I hope you will find it fascinating and will learn a lot from it. Stay tuned! Links JPS+: Over 100x Faster than A* by Steve Rabin A* Optimizations and Improvements by Lucho Suaya https://hackernoon.com/bfs-dfs-dijkstra-and-a-star-are-basically-the-same-algorithm-ill-show-you-why My blog https://antonyarkov.substack.com/ Also published . here

Graph Traversal Algorithms: Visualizing Performance Variations in Route Finding Algorithms

Build a Decentralized Freelancer Marketplace With React, Solidity, and CometChat

Build a Decentralized Voting Dapp with Next.js, TypeScript, Tailwind CSS, and CometChat

Building a Web3 Play-To-Earn Money Dapp with React, Solidity, and CometChat

Earlier this morning I was looking for inspiration to work on my personal website. I stumbled upon another web developer's blog and scrolled through until I saw something that struck me as.. strange. I was hooked immediately. At the bottom of their About page, there was a small component that held a list of names that linked to other blogs, with "PREVIOUS" and "NEXT" buttons at the top. It was titled "The Claw Webring". Webrings were online communities designed to amplify a blog's SEO and shout out the author's friends and colleagues. Read more here I clicked "JOIN". It led me . here Mostly empty GitHub repo. Not a lot of detail. Okay, now I'm curious. I went back and scrolled through the list and clicked a random name off the list, curious to see what was on the other side. It led me to the personal website belonging to the author and developer that created , which I had no idea existed until now. https://codewithrockstar.com/ It's a coding language that also functions as a heavy metal song. Designed specifically to confuse recruiters who aren't familiar with the term "rockstar-dev". From their website, FizzBuzz written in Rockstar: Midnight takes your heart and your soul
While your heart is as high as your soul
Put your heart without your soul into your heart

Give back your heart


Desire is a lovestruck ladykiller
My world is nothing 
Fire is ice
Hate is water
Until my world is Desire,
Build my world up
If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing
Shout "FizzBuzz!"
Take it to the top

If Midnight taking my world, Fire is nothing
Shout "Fizz!"
Take it to the top

If Midnight taking my world, Hate is nothing
Say "Buzz!"
Take it to the top

Whisper my world Esoteric are very interesting. Someone had to sit down and create these tools, out of labors of love. Everyone knows about , a language designed to be almost completely human-unreadable, but it's cool to see new examples pop up. programming languages Brainf**k As interesting as Rockstar is, the point of this story, as is the case with most journeys, is not where I ended up or what I found, but rather the journey itself. I saw an interesting component. It had a list of links. I clicked a link. I was curious to see what existed out there. I found something cool. This curiosity->exploration->discovery->share feedback loop doesn't seem to happen often on the internet anymore. But I stumbled across it today and I was very pleased to have found it. I felt like I got a glimpse into the lives of some interesting people. It was certainly more satisfying than clicking through people's Twitter or LinkedIn profiles. Internet communities and fandoms were one of the most beautiful aspects of early Internet culture. They may have dated roots in SEO and closed-off internet communities, but I think we should bring webrings back. Let me know what you think. Thanks for reading -Austin The lead image for this article was generated by HackerNoon's via the prompt "the internet". AI Image Generator

Stories, News & Mentions about CODELITT

Codelitt’s Stories on HackerNoon