Lewis Hamilton has said he would like to work alongside Adrian Newey at Ferrari if the British designer was to join the Scuderia

Lewis Hamilton: it would be a privilege to work with Adrian Newey at Ferrari | Lewis Hamilton | The Guardian

Fernando Alonso responds to speculation that Adrian Newey could join Aston Martin in 2025.

Fernando Alonso reacts to Adrian Newey rumours: 'I always wanted to work with him' | F1 | Crash

The fast food franchise was fined more than $26,000 by the U.S Department of Labor.

Alabama Checkers’ managers clocked teen staff out, altered timecards to cut wages, agency says - al.com

A $4.4 million federal grant will provide free job skills training for people in West Alabama.People can sign up for the training by going to Career Centers in

Free job training available for people in West Alabama | WBMA

The Mid-Alabama Coalition for the Homeless is calling for Montgomery-area residents to help with the annual Point-in-Time count · After working for nearly 20 years as an educator, Chrissy McClendon retired, only to return to the classroom a year later · At Gray, our journalists report, write, ...

National Career Coach day with Central Alabama Works

Revive I-5 work, already underway weeknights in south Seattle, will soon expand to include about 13 weekends of lane reductions and ramp closures. The

Revive I-5 work in south Seattle begins weekend-long lane reductions Jan. 12-15 | MLTnews.com

For all the celebratory claims of a "soft landing" for the U.S. economy, the job market in Seattle, as elsewhere, is still marred by sluggish growth and strikingly uneven outcomes. ...

For many job seekers, WA job market still far from a pre-pandemic norm | The Seattle Times

In most cases, a positive cannabis test can no longer cost you a job.

Washington state now bans most pre-employment marijuana testing - Axios Seattle

The former Mersey ferry will soon be towed to Cammell Laird where it will be converted before returning to Liverpool as a “world class” drinking and dining destination.

Work to start on £2.5m Daffodil transformation - Place North West

What you need to know about Pennsylvania lawmakers’ salaries, the history of the increase, and why changes are unlikely.

Pa. lawmakers’ base salary now tops $106K after automatic pay raise - LebTown

Everything You Need to Know About Testcontainers-Based Load Testing Bench

টেস্ট কনটেইনার-ভিত্তিক লোড টেস্টিং বেঞ্চ সম্পর্কে আপনার যা কিছু জানা দরকার

Alles, was Sie über den Lasttest-Bench auf Basis von Testcontainern wissen müssen

Todo lo que necesita saber sobre el banco de pruebas de carga basado en contenedores de prueba

Tout ce que vous devez savoir sur le banc de test de charge basé sur des conteneurs de test

टेस्टकंटेनर-आधारित लोड परीक्षण बेंच के बारे में आपको जो कुछ भी जानना चाहिए

テストコンテナベースの負荷テストベンチについて知っておくべきことすべて

테스트 컨테이너 기반 부하 테스트 벤치에 대해 알아야 할 모든 것

Tudo o que você precisa saber sobre o banco de testes de carga baseado em Testcontainers

Все, что вам нужно знать о стенде нагрузочного тестирования на основе тест-контейнеров

Test Konteyner Tabanlı Yük Test Cihazı Hakkında Bilmeniz Gereken Her Şey

Mọi điều bạn cần biết về Bàn thử nghiệm tải dựa trên Testcontainers

您需要了解的有关基于 Testcontainers 的负载测试平台的一切

Apache bench This is our step 1 , but keep in mind that this is single threaded. Think of ab like sanity testing for performance. tool For step 1, you can use a single machine, with a good amount of RAM and CPU. Run loads for up to 15–30 mins to check nothing obvious is going wrong. wrk wrk is our step 2 tool for , it is similar to ab, but this will puts proper load (concurrent). In step 2, we would use a big machine (think 64 GB ram, 8–16 cores). This gives a good understanding of the system before moving on to the next phase. load testing We are still testing on a single machine in this phase though. Run loads for about 30–60 mins. Up until 1 and 2, we are probably testing single end points of the application. This is easy to setup and get the results. But things are not complete until we do distributed load testing + complete application flows (scenarios where multiple API are called before the flow is completed). Distributed load testing will take both longer to setup, and more expensive then 1 and 2. Distributed load testing Our goto tool here is jmeter. Jmeter might sound specific to java but it is not so. It has been a good investment of time to pick up jmeter. Plus since jmeter is a very old tool, its very easy to find a lot of helpful guides and setups. The goal of 3 would be to get a (do take note of the machine specs). Once you have this number, . Also helps to decide how much vertical/horizontal scaling you will need. good estimate of Requests per second per machine you can project your requirements based on expected traffic/peak traffic For vertical scaling Choice of language Once you have identified the main flows you need to focus for performance, you can rewrite those pieces is a compiled language (this is almost always a low hanging fruit to get performance boost). But this is only when your app is performing a lot of stuff and not just a middle layer to talk to the database. Architecture You are already at a good stage where the setup is across a few services instead of one huge service. Try to not get too many services either. You want to take into account each network call (this will add a minimum of 10ms for every call). Sometimes coupling two services will give you the gains. Going into memory usage It might be harder to get these numbers for nodejs, but on a code level, there can be certain low hanging fruits as well. Identify hotspots for gc or in many cases the algorithm and data structure itself will matter as well. For horizontal scaling Load balancing checkout the arrangement of your http calls. How many routers is the service going thru after entering your network. How do plan to evenly distribute the load. A round-robin approach is okay for the start, but as you will move on, identify which calls are heavy, which ones are not and configure the router accordingly. Caching If the system is non-transactional/non-payment system, where 99% accuracy is as good as 100%, then caching helps a lot. Be aware of all the edge cases for caching though. Performance comes only second to the actual business. **A bad caching configuration can go really bad, including lower performance and maybe wrong results.**Also be aware of caches which are already present (a lot of frameworks/orms lately include hidden caching) You can apply caching at all levels: database level, functional level, controller level, api level. Database to increase through-put (this sort of falls under caching, although its a different type). Also make sure you account for what happens when a replica goes down. for a majority-read/minor-writes system, you can leverage database slaves - If the case is opposite, major-write/minor-reads, you will want to check what database you are using (having multiple master is helpful) - Also how you are storing data in that particular db. . How much data needs to be written to disk for each DB transaction Above is a brief summary of approach. For each point above, you should also consider the downsides what if one machine goes down what if 5 go down what if network latency increases for some reason what if io speed goes down for some reason Some general points for above: Make note of all the calls going out of your system (to a third party) If a third party cannot guarantee their RPS/QPS, you might want to shift to async flows (queues) Keep note of which of your services are IO heavy, vs CPU heavy vs Network heavy (many times you can couple two of these in a single service) Try to minimise mocks when load testing.

To start thinking about load testing

Startups of The Year 2023 Winners: North America 

AsyncIO in Arduino For those people who are familiar with microcontroller , you may have asked yourself this question. programming Can multiple processes be executed at the same time on Arduino? And the answer is, indeed, possible. Although we cannot run multiple processes in parallel as a PC would. Yes, we can execute multiple processes asynchronously. Asynchronous, you said? What is that? In programming, asynchronous processing is a programming model in which tasks can run in the background without blocking the execution of the main program. In this model, tasks are added to a process queue and then are executed, one by one, when there are available resources. In this article, I will show you how to create a coroutine step by step on Arduino UNO. What is a coroutine? Well, a coroutine is a function that has the ability to pause and resume itself. This means that with coroutines, we can execute parts of a function instead of executing it completely as usual. To achieve this, we will use a design pattern called . This design pattern will allow us to split the function into states and then execute them individually. Take a look at the next example: State Machines #include <cstdlib>
#include <cstdio>

int coroutine() {
    static int state = 0; 
    switch( state ){
        case 0: printf(":>A\n"); state++; return 1; break;
        case 1: printf(":>B\n"); state++; return 1; break;
        case 2: printf(":>C\n"); state++; return 1; break;
        case 3: printf(":>D\n"); state++; return 1; break;
        case 4: printf(":>E\n"); state++; return 1; break;
    }   return -1;
}

int main() {
    while( coroutine()>0 ){}
} In this example, we have made a basic coroutine using a static variable and a switch conditional, which together compose a simple state machine that, depending on the state variable, executes one part or another of the function. But now, imagine coding complex coroutines using this method will cause you a headache. It's not easy to use nor efficient to write, right? To improve this, we will use macros to be able to reduce the complexity of coroutines. Take a look at the next example: #define _Yield(VALUE) do { _state_ = VALUE; return  1; case VALUE:; } while (0)
#define _Start static int _state_ = 0; { switch(_state_) { case 0:;
#define _Goto(VALUE) do { _state_ = VALUE; return  1; } while (0)
#define _Stop } _state_ = 0; return -1; }

#include <cstdlib>
#include <cstdio>

int coroutine() {
    static int x = 10;
    _Start
    while( x-->0 ){
        printf(":>%d\n",x); _Yield(1);
    }
    _Stop
}

int main() {
    while( coroutine()>0 ){}
} So now, coroutines looks better. With this method, we can create more complex coroutines that are easy to use and more efficient to write. Once we have a good understanding of coroutines and how to implement them in C++, we can apply this knowledge to create a program on the Arduino UNO that enables us to execute multiple processes simultaneously using coroutines. To demonstrate this, let's consider a simple example where we create two coroutines, each responsible for turning on and off an LED, with different frequencies and completely independent of each other. Take a look at the next example: #define _Yield(VALUE) do { _state_ = VALUE; return  1; case VALUE:; } while (0)
#define _Start static int _state_ = 0; { switch(_state_) { case 0:;
#define _Goto(VALUE) do { _state_ = VALUE; return  1; } while (0)
#define _Stop } _state_ = 0; return -1; }

/*─────────────────────────────────────────────────────────────*/

using ulong = unsigned long int;

int OUT[] = { 12, 11 };

/*─────────────────────────────────────────────────────────────*/

template < class T >
int wrk1( const T& function, const ulong& time ){ //firts we create a worker
    static ulong stamp = millis() + time;         //then we define a time stamp as static
    _Start                                        //Begin of the coroutine

    while( millis() < stamp ){ _Yield(1); }       //Async waiting a period of time
    stamp = millis() + time;                      //we redefine the time stamp
    function();                                   //now we are able to execute the function
    _Goto(0);                                     //and then set the state machine as 0  

    _Stop                                         //End of the coroutine
}

template < class T >
int wrk2( const T& function, const ulong& time ){
    static ulong stamp = millis() + time;
    _Start

    while( millis() < stamp ){ _Yield(1); }
    stamp = millis() + time;
    function(); _Goto(0);

    _Stop
}

/*─────────────────────────────────────────────────────────────*/

void setup(){
    for( auto x : OUT ) pinMode( x, OUTPUT );     //Setting up Output pins
}

void loop(){

    wrk1([](){                                    //Worker 1
        static bool b=0; b=!b;                    //Simple Boolean Oscilator
        digitalWrite( 12, b );                    //setting up Output based on oscilations
    },1000);                                      //NOTE: 1000 represent time in ms

    wrk2([](){
        static bool b=0; b=!b;
        digitalWrite( 11, b );
    },500);

} Conclusion: Creating asynchronous functions in C++ and Arduino is just the beginning. Stay tuned for the next part of this article, where we'll dive deeper into this topic. If you found this article helpful, show your support by sharing it with your friends and leaving a comment with this emoji 🤙 to let us know you're excited about the second part!

AsyncIO in Arduino: Introduction to Asynchronous Processing Part 1

'Have you developed or are you in the process of creating an API Server that will be used on a production or cloud environment? In this 4th instalment of my series, I show you how to test the availability of your API Server, so that you can understand how many requests per second it can handle whilst performing heavy duty tasks. Node JS Performance Optimizations This is a very important measure, especially for production environments, because the last thing you want is to have incoming requests queued as a result of your API Server peaking and not freeing up resources often enough. A Quick Note While I’ll be referencing in this article, most of the theory and principles mentioned can apply to any platform and environment. NodeJS Watch The Video On YouTube Which Benchmark Testing Tool To Use The tool I’ll be using for my tests is called . It’s written entirely in and is very similar to , , , , etc. This is good news because you are not forced to use AutoCannon to follow along with this article. If your benchmark testing tool can perform load tests against HTTP requests and can determine the average requests per second, you’re good to go. AutoCannon NodeJS Apache Benchmark Artillery K6 Wrk That being said, should you wish to make use of AutoCannon, it’s as easy as installing it globally as an NPM Module: npm i -g autocannon How To Test The Availability Of Your API Server Firstly, there is an online that you can reference should you wish to run these examples on your local environment. All you will need is NodeJS installed. Source Code Repo The snippet of code below gets you pretty much 99% to where you want to be, with the exception of setting up your package.json, setting the NODE_ENV to Production and PORT to 6000 (reference sample code in provided Source Code Repo and embedded video should you struggle). Add the following to an file. app.js ( ).config() Express = ( ) App = Express() HTTP = ( ) BCrypt = ( ) App.get( , (req, res) => {
  res.send( )
})

App.get( , (req, res) => { hash = BCrypt.hash( , )
  res.send(hash)
}) port = process.env.PORT server = HTTP.createServer(App)

server.listen(port, () => { .log( , port)
}) 'use strict' require 'dotenv' const require 'express' const const require 'http' const require 'bcryptjs' // Router Setup '/pulse' '' '/stress' async const await 'this is a long password' 8 // Server Setup const const console 'NodeJS Performance Optimizations listening on: ' This is a very simple Express Server that exposes 2 Routes: /pulse /stress The endpoint represents a very lightweight API that contains no business logic and returns an empty string as a response. There should be no reason for any delays when processing this endpoint. /pulse The endpoint, on the other hand, uses to salt and hash a password. This is quite a heavy process and because it’s completely written in JavaScript, it will land up blocking the Event Loop quite badly. /stress BcryptJS For our first test, we’re going to use AutoCannon to run a load test against the endpoint, to see how many requests per second the API Server can handle when it’s running idle. The process is as follows: /pulse 1. Start up the Express Server node app 2. Run the AutoCannon test autocannon http://127.0.0.1:6000/pulse 3. This is a simple load test that runs 10 concurrent connections for 10 seconds After the test run, you should receive a report that includes an average requests per second. Depending on the speed of your machine, it should vary between 15 000 and 25 000 requests: Now that we have our baseline measurement, let’s see what happens when the API Server is performing heavy duty tasks: 1. Make sure the Express server is running node app 2. Open 2 Terminal windows for the tests to be performed 3. In window 1, run AutoCannon against the endpoint for a duration of seconds /stress 30 autocannon -d 30 http://127.0.0.1:6000/stress 4. In window 2, while the test is running, run AutoCannon against the endpoint, same as before /stress /pulse autocannon http://127.0.0.1:6000/pulse Make sure the test runs to completion whilst the test is running /pulse /stress After this test run, you should see a significant drop in the requests per second for the test. /pulse As you can imagine, this is a frightening result…one that needs to be handled sooner rather than later. What Does This Mean In The Real World While this example won’t make too much sense in the real world, it forms a template for the kind of tests you should be running on your environment. You need to identify when your API Server is running at peak, and then hit it with load testing against lightweight APIs that belong to your server. You need to determine if they can be processed without much delay, or if they get blocked because your code might not be managing the Event Loop well enough. How do I fix the problem? Well, I have good news: As mentioned at the start, I am busy with a series on “ “. Having already used examples from content I’ve published and content to come, I managed to increase the requests per second for the test from to over . Node JS Performance Optimizations /pulse 117 4 000 What you want to do is to my YouTube Channel, as I publish everything there first and almost on a weekly basis. There are already 4 videos for this series, an important one which is “ “. subscribe Bleeding Code Managing The Event Loop Phases I hope this article proved valuable. Stay tuned for more to come Cheers Previously published at http://bleedingcode.com/how-to-test-availability-of-your-api-server/

How To Monitor Your API Server

A Fairytale Search for the Sweet spot of Centralised/Decentralised Once upon a time, there was an enterprise named Goldilocks. She visited a house in the woods in search of the perfect blockchain porridge- one that was both fast, affordable and scaleable, decentralised enough to ensure an uncorruptible, trustless, immutable record. and And while she already loved Bitcoin porridge, she dreamed of a blockchain that was rich enough for all the applications she could dream of… First, she tasted the Ethereal blockchain porridge: “Mmmmmm… this blockchain is so delicious with decentralisation” she said. “If only it was faster. And who exactly are the development team? I want some customized support and special Goldilocks features.” Next, she tasted the Hyperledgereal blockchain porridge: “Oh goody”, said Goldilocks. “These people cooked my blockchain especially for me! They make updates whenever I want and it’s so fast. But hang on, who’s blockchain is it anyway? This doesn’t seem very decentralised at all- so why exactly am I using a blockchain again?” So, poor Goldilocks was left hungry. Although there were plenty of options on the menu, no single blockchain porridge could satisfy her. “I feel caught between a block & a hard place”, she said. “Is it so much to ask- to have my Proof-Of-Stake & Sweeten it too?” Poor puns aside, where is the ‘Goldilocks’ of centralised/decentralised? Well, here are three projects that strive to take the best aspects of both extremes: Short-form social media hub on the blockchain. .This project combines the rapid development of a centralised company with the uncensorable nature of posting to a blockchain. The project is partnered with Steemit, which offers a complementary platform for long-form content. SoMee offers users ownership over their data, rewards them for engagement, and acts as a hub for multiple social media platforms. SoMee “Social Media Redefined” A blockchain of blockchains. .This project offers enterprises/governments the reliable speed and cost of running a permissioned network (a ‘WRKChain’), while demonstrating these have not been tampered with by committing the header of each block to a public ‘MainChain’. Use cases being built out range from Insurance Providers to Electronic Healthcare Records, Smart City Management to Governmental Stablecoins. Unification “Ethereum for Enterprise” Virtual Reality music, sports, learning and arts, powered by the blockchain. .While the central company films and provides experiences in dedicated VR studios, the distributed network of connected powerful computers (MasterNodes) relay near-instant streams to all audiences to ensure high quality content delivery. This architecture ensures reliable delivery of resource intensive content that is secure, protected, censorship resistant and throttle-proof. Ceek VR “Your Ultimate Front Row Experience” I’d love to introduce Goldilocks to each of these projects to help her with her dilemma. While I know these three well as I have some involvement with each of them, there are certainly more out there that attempt to bridge the best of both worlds- the centralised and the decentralised. May the two be married, and live happily ever after… Which other projects do you know that are walking this tightrope?

Goldilocks and the Three Blockchains

At RMTWRK we are building the world’s to help match companies hiring remote or distributed teams with people who are looking for a more flexible work environment. As a result our rails app has two user types, Company Users, people doing the hiring and Individual Users, people wanting to be hired and we wanted to have separate confirmation emails for each user type. Additionally we wanted to use ’s API for sending emails rather than through SMTP (more on this later), and lastly we wanted to use the amazing gem to inline the CSS styles in our emails before sending. largest remote only jobs board Mailgun Premailer is one of the long standing and best written ruby/rails libraries around and one of the easiest to customize, workaround, and override. It does so much though that it can sometimes be hard to know where to start. Devise We are going to go over the 3 methods (or degrees, if you will) of customizing Devise’s emails. Simple customization of Devise’s default emails Customizing the “layout” and “templates” used by Devise for sending emails Overriding how Devise sends emails to use an API (Mailgun) instead of SMTP Method 1: Method 2: Method 3: I’ll briefly touch on and link to other resources for the first 2 methods Method 1: Simple customization of Devise’s default emails If you only want to modify a few simple things about the layout of something like the email or email then this is the method for you. First run the following in your terminal and then you can edit the views for the emails you are interested in inside of email confirmation password reset views/devise/mailer rails generate devise:views For further details, the best place to look would be the on GitHub. Devise Readme Customizing the “layout” and “templates” used by Devise for sending emails Method 2: If you want to go a bit further and customize the layout that each email template is rendered into then you can do so by creating your own Mailer class that subclasses . Devise also has a great Readme on how to do this here: . **Devise::Mailer** How To: Create custom layouts There are a couple of potential gotchas to be aware of with this method. If you have two resource types, like say and (the names of our actual models), the simplest way to have two separate mailers is to use the method in each .rb model file (simplified example below). If you plan to move the location of the mailer templates, be sure to delete the existing templates in “devise/mailer” as they will override your other views. User Individual **devise_mailer** resource This is an example of a simple customized Devise Mailer: class RmtwrkDeviseMailer < Devise::Mailerhelper  :application include Devise::Controllers::UrlHelpers _# eg. `confirmation_url`_  default template_path: 'rmtwrk/devise/mailer  default from: 'RMTWRK 'default reply_to: 'RMTWRK 'layout  'mailer_rmtwrk'end # helpers defined within `application_helper` rmtwrk@wrkhq.com rmtwrk@wrkhq.com And you can tell your model to use this mailer using the method like this: Individual devise_mailer class Individual < ApplicationRecorddevise :database_autenticatable,..., :confirmable def devise_mailerRmtwrkDeviseMailerendend But what if you wanted to do some other things to the email before sending it? That’s where method 3 comes in. Overriding how Devise sends emails to use an API instead of SMTP Method 3: Our constraints: Sending email vis an API rather than SMTP. Most email providers recommend using their API rather than SMTP for a variety of reasons. Here are and reasons as examples. Sendrid’s Mailgun’s Two models; and , using Devise. resource User Individual Separate branding, i.e. files per model. layout Inlining our CSS using Premailer. In order to accomplish this the essential piece of the puzzle is overriding the method(s) you are interested in. For this example we will only focus on the email confirmation email. This is handled by the method by default, which uses and SMTP by default. Devise::Mailer confirmation_instructions ActionMailer Here is what our final custom Devise Mailer will look like: I hope that this has been helpful! Please leave comments or questions and I’d be happy to respond, but let’s be honest the most likely person to stumble on this in 10 months or so looking for an example of how to do this is probably me, hi future me! Best — Andrew Gertig

How to override and customize Devise Mailers with Rails

The Inspiration I always liked the emotion of 1x1 online voting duels like Big Brother Brasil and The Voice Battle. The way how it reaches millions of people is incredible. So, I decided to do a simple poll application able to deal with 1 day of voting, in a large country like Brazil and USA. With a challenge: I wanted do that, from scratch, in 2 hours, with some cents. As goal, I imagined a country of 300 million people, where 70% of population will vote. That is 210 million votes in one day, 8.75 million in one hour and approximately 2500 req/sec. The way To do that, I chose the simple and powerful combination of Golang and Redis (with AOF persistence). Running in a simple Digital Ocean droplet with Ubuntu, without any SO fine tunning. I didn’t worry about auth, crawlers and rate limiting in this project. For this goal, I created a project with 3 files: , and . ( ) docker-compose.yml Dockerfile main.go https://github.com/danhenriquesc/go-poll The and files basically builds up a redis server and a Golang 1.11 API. Running on localhost:8000. I just need to run a simple command: docker-compose.yml Dockerfile docker-compose up The is a file of 96 lines that creates an API with 2 endpoints: main.go to vote in one of the candidates and return the current status of poll, POST /vote/{candidate:[1|2]} to get the current status of poll. GET /vote Two Golang packages were used in this API: to facilitate HTTP router, github.com/gorilla/mux to facilitate Redis access_._ github.com/go-redis/redis The HTTP Benchmarking execution After creating that project, I decided to check how many requests it could handle, with . So I tested in a cheap and realistic way, with . wrk tool Digital Ocean droplets I choosed 3 Standard Droplets options to test: $5/month droplet: 1GB RAM, 1 vCPU 1.8GHz $15/month droplet: 1GB RAM, 3vCPU 1.8GHz $80/month droplet: 16GB RAM, 6vCPU 1.8GHz The three running Ubuntu 16.04.4 x64, without any fine tuning. You can see the benchmark sets below: $5/month droplet Execution 1 root@ubuntu-s-1vcpu-1gb-nyc1–01:~# wrk -t 1000 -c 10000 -d 1m -s ./post.lua Running 1m test @ 1000 threads and 10000 connectionsThread Stats Avg Stdev Max +/- StdevLatency 607.99ms 157.48ms 1.99s 82.22%Req/Sec 24.63 22.40 292.00 75.02% Transfer/sec: 0.88MB http://68.183.137.138:8000/vote/2 http://68.183.137.138:8000/vote/2 345301 requests in 1.00m, 52.72MB read Requests/sec: 5755.02 Execution 2 root@ubuntu-s-1vcpu-1gb-nyc1–01:~# wrk -t 1000 -c 20000 -d 1m -s ./post.lua http://68.183.137.138:8000/vote/2Running 1m test @ http://68.183.137.138:8000/vote/21000 threads and 20000 connectionsThread Stats Avg Stdev Max +/- StdevLatency 860.65ms 296.29ms 2.00s 65.63%Req/Sec 39.72 45.10 686.00 83.99% Transfer/sec: 0.91MB 358947 requests in 1.00m, 54.94MB read Requests/sec: 5982.46 $15/month droplet Execution 1 root@ubuntu-s-3vcpu-1gb-nyc1-01:~# wrk -t 7500 -c 10000 -d 1m -s ./post.lua Running 1m test @ 7500 threads and 10000 connectionsThread Stats   Avg      Stdev     Max   +/- StdevLatency   631.39ms  107.29ms 798.00ms   91.50%Req/Sec     1.25      2.28   272.00     97.79% Transfer/sec:      1.85MB http://204.48.20.138:8000/vote/2 http://204.48.20.138:8000/vote/2 735058 requests in 1.01m, 112.16MB read Requests/sec:  12091.66 Execution 2 root@ubuntu-s-3vcpu-1gb-nyc1-01:~# wrk -t 1000 -c 13000 -d 1m -s ./post.lua Running 1m test @ 1000 threads and 13000 connectionsThread Stats   Avg      Stdev     Max   +/- StdevLatency     1.08s    89.31ms   1.91s    80.95%Req/Sec    22.67     29.20   650.00     87.31% Transfer/sec:      1.88MB http://204.48.20.138:8000/vote/1 http://204.48.20.138:8000/vote/1 714698 requests in 1.00m, 113.13MB readRequests/sec:  11884.94 Execution 3 root@ubuntu-s-3vcpu-1gb-nyc1-01:~# wrk -t 1000 -c 15000 -d 1m -s ./post.lua Running 1m test @ 1000 threads and 15000 connectionsThread Stats   Avg      Stdev     Max   +/- StdevLatency     1.32s   128.68ms   1.99s    77.60%Req/Sec    24.45     33.76     1.09k    85.97% Transfer/sec:      1.71MB http://204.48.20.138:8000/vote/1 http://204.48.20.138:8000/vote/1 671964 requests in 1.00m, 102.71MB readRequests/sec:  11199.40 $80/month droplet Execution 1 root@ubuntu-s-6vcpu-16gb-nyc1-01:~# wrk -t 1000 -c 70000 -d 1m -s ./post.lua Running 1m test @ 1000 threads and 70000 connectionsThread Stats   Avg      Stdev     Max   +/- StdevLatency   902.54ms  103.71ms   2.00s    78.21%Req/Sec    79.04     71.04     3.75k    84.72% Transfer/sec:     10.54MB http://204.48.20.138:8000/vote/1 http://204.48.20.138:8000/vote/1 4117831 requests in 1.01m, 637.73MB readRequests/sec:  68630.52 Execution 2 root@ubuntu-s-6vcpu-16gb-nyc1-01:~# wrk -t 1000 -c 30000 -d 1m -s ./post.lua Running 1m test @ 1000 threads and 30000 connectionsThread Stats   Avg      Stdev     Max   +/- StdevLatency   942.14ms  127.26ms   2.00s    85.55%Req/Sec    47.32     55.14     1.33k    88.25% Transfer/sec:      4.68MB http://204.48.20.138:8000/vote/1 http://204.48.20.138:8000/vote/1 1830829 requests in 1.00m, 281.99MB readRequests/sec:  30513.82 Execution 3 root@ubuntu-s-6vcpu-16gb-nyc1-01:~# wrk -t 1000 -c 20000 -d 1m -s ./post.lua Running 1m test @ 1000 threads and 20000 connectionsThread Stats   Avg      Stdev     Max   +/- StdevLatency   656.35ms   89.49ms   1.61s    84.31%Req/Sec    40.59     41.40     1.13k    87.53% Transfer/sec:      4.85MB http://204.48.20.138:8000/vote/2 http://204.48.20.138:8000/vote/2 1828994 requests in 1.00m, 292.16MB readRequests/sec:  30483.21 The analysis of Benchmarking $5/month droplet Firstly, I tested with the cheapest droplet of Digital Ocean, that costs $5/month. As I want to deal with 1 day of voting, so, I had the 1-day cost of approximately $0.16. In this droplet, we had something about 5800 req/sec, that can handle: 348,000 votes per minute 20,880,000 votes in an hour with $0.007 501,120,000 votes in a day with $0.16 In this droplet, I can easily achieve the initial goal of handle 210 million votes in one day, with $0.16. $15/month droplet So, with the mission completed, why not stress a more powerful droplet? So, I changed for the $15/month droplet, that costs $0.02/hr and $0.53/day. In this droplet, we got approximately 12,000 req/sec, basically twice of $5/mo droplet. It wasn’t good because paying three times more didn’t give me three times the performance. $80/month droplet Jumping to a new level, I decided to try the $40/mo server. But, because of a missclick, I selected the $80/mo server, and there I went: A big surprise. This droplet costs of and $2.85/day, and reached about 68,000 req/sec. $0.12/hr With this ratio, we can handle: 4,080,000 votes per minute 244,800,000 votes in an hour with $0.12 5,875,200,000 votes in a day with $2.85 The Conclusion With this benchmark, we can get some interesting insights: We can handle 501,120,000 votes, scattered throughout the day, with $0.16. That is the almost the sum of population of USA and Indonesia, the 3rd and 4th biggest populations of the world. We can handle 244,800,000 votes, in a single hour, with $0.12. That is more than the population of Brazil, the 5th biggest population of the world. We can handle 5,875,200,000 votes, scattered throughout the day, with $2.856. That is more than 4x the population of China, the biggest population of the world. With that number, we can realize that some applications appear to be harder and more expensive than in fact are. Even though some business rules were despised, the cost would remain low for any small business. Besides that, other architectures like serverless functions in AWS or GCP can provide better performance and scalability with low cost. It gives a lot of opportunities for new business have high-scalable applications. The possibilities are there, just try it!

Making a web voting app handling 245 million votes with $0.12

M any PHP developers are green with envy when thinking about their colleagues who use Node. Asynchronous Node systems are sharing the codebase between protocols and serving them right out of the code. This really makes one wonder about switching to Node. Well, actually something resembling Node in PHP has been added as an extension. And it’s called Swoole. Node in PHP? What is that Swoole thing? Well, let me copy-paste the definition straight from the : documentation “Production-Grade Async programming Framework for PHP Enable PHP developers to write high-performance, scalable, concurrent TCP, UDP, Unix socket, HTTP, Websocket services in PHP programming language without too much knowledge about non-blocking I/O programming and low-level Linux kernel”. Swoole works as an extension to PHP and it’s written in C. Sounds promising, right? Hosting HTTP server with PHP? Websockets in PHP itself? Many other possibilities, some looking exotic? And all this with keeping high performance. Let’s check it out! How to get it running? Installation methods on native platforms vary. For Linux it boils down to one pecl command: pecl install swoole For MacOS, brew can be used: brew install swoolebrew install homebrew/php/php72-swoole And on Windows, native installation is not possible, but we should use Docker anyway. Dockerizing Swoole Of course, the best idea to run the PHP and Swoole is the Docker container. Let’s see how to create a container which will allow us to use Swoole. First, we need a Dockerfile. FROM php:latestRUN pecl install swooleADD php.ini /usr/local/etc/phpRUN usermod -u 1000 www-data That was pretty straightforward. After extending the official PHP Docker image, installing Swoole with pecl, and copying php.ini — we got it. The last line is a standard Docker fix for MacOS. When it comes to php.ini config file which is copied, it’s even simpler — requires only one line: extension=swoole.so What does it offer? Swoole has variety of functionalities. Most of them are asynchronous. Here are some of the most interesting ones (other can be found at Swoole ): documentation TCP/UDP server and client, HTTP server and client, Websocket server and client, Redis protocol server and client, MySQL client, Atomics, Filesystem. Let’s see how to use three of them: HTTP server, Websocket server and Filesystem. These are the most important ones in my opinion. HTTP Server using Swoole Swoole allows us to run a simple HTTP server which works asynchronously. Here’s the simple code that will also use asynchronous filesystem access to respond with index.html file to every request it handles. As we can see, it looks a bit like Node. First, we create the object that resembles the HTTP server. Then, we bind two anonymous functions for two events: one for , which will be executed when the server is started, and another for , which will be executed for every request. It takes a request and responses objects as parameters**.** swoole_http_server start request contains all the data related to the request itself: requested path, headers, and so on. On the other hand, it’s used to provide output, set headers etc. It’s worth mentioning that these two objects are not PSR conformant, but rather they are custom Swoole objects. Request object In the , asynchronous file system is used to load the data from a file. Once the data is available, a callback is fired with the content loaded. Then, this content is used to fill the response object and close the response. This sends the data back to the browser effectively. request event That looks neat and most of all — works. But what about the performance? HTTP Server benchmark To test the performance of HTTP server using Swoole, I’ve created an app in Node — which can do exactly the same thing as the one in Swoole — and also a NGINX server which serves index.html as a static file. All dockerized in 3 separate containers. Then, I used tool to hit these containers hard. Results were astounding. wrk Swoole results were way better than expected! That came as a surprise. I didn’t expect Swoole to overtake NGINX, but it actually did! Node was outdistanced. Raw power of this extension is really impressive, but it fades away with more work being done in the request. Unfortunately, Swoole has two little drawbacks that make these raw benchmarks irrelevant. We will get to them later. Websocket Server using Swoole As mentioned before, Swoole offers a method to create websocket server. It works asynchronously, follows the same methodology as HTTP and other Swoole functionalities. In my opinion, it’s one of the most important Swoole parts. Come on, websockets in PHP? I’m in. Let’s see how it looks. Looks similar to HTTP server example. First, we create the object which resembles the websocket server. Then, we bind 4 anonymous functions to 4 events. One to event, which will work just like start event from HTTP server. Another to event which will be executed once a new websocket connects. Yet another to event which will be executed when a websocket sends a message to the server. And finally — to event which runs when a websocket disconnects. swoole_websocket_server start open message close Websockets connected to the server are identified by the unique ID that increments with each of the new websockets. Problems encountered whilst using Swoole It all worked well so far, but there were two problems I’ve encountered during the tests of some solutions using Swoole. These were: no real HTTPS support in HTTP server, no support for global variables in scripts. First one is easy to mitigate. We just need to set up a reverse proxy using NGINX or any load balancer and it’s done. But by doing that, we lose extreme performance boost that Swoole offers. Second one is more tricky. Swoole spawns worker processes for handling requests which means that if we create a global variable, its value is independent between threads and it can’t work. Here’s an example showing this behaviour. One would expect the response would return 0, then 1, 2, 3 and so on, but instead it always returns 0. I reached to the Swoole authors to check if it’s a bug, but it isn’t. In order to get the behaviour we expect, we can set in configuration, but this decreases the performance. worker_num = 1 Conclusion Swoole, as everything, has its bright sides and dark corners. I think it’s still a good idea to bring asynchronous programming to PHP. It can be used in various cases, ranging from fast prototyping, by concise single responsibility microservices, low-latency game servers and ending with being a backend server for big frameworks. Promising indeed. The article was written by Adrian Chlubek and was first published on The Software House Blog . Visit the blog for more articles on best development practices and software outsourcing tips.

Swoole: Is it Node in PHP or am I wrong?

Quart as a upgrade to Flask Python has evolved since was first released around 8 years ago, particularly with the introduction of asyncio. Asyncio has allowed for the development of libraries such as and that are reported ( , and ) to improve performance far beyond what was previously possible. Sadly Flask is not easily combined with asyncio or these libraries. However the Flask-API can be used with asyncio via the framework. Flask uvloop asyncpg here here Quart Quart provides the easiest transition for Flask apps to use asyncio as it shares the Flask-API. This means that existing Flask apps can evolve with very little effort into Quart apps and then use these new libraries to take advantage of performance improvements not possible with Flask. This document details the transition from Flask to Quart for a typical production app and shows the performance improvements for a typical production deployment. CRUD tl;dr Upgrading Flask-pyscopg2 app to a Quart-asyncpg app gives a performance speedup of 3x without requiring a major rewrite or adjustment of the code, . Summarised results, this full diff Route           | Flask | Quart | Ratio| Req/s | Req/s | (Quart/Flask)-----------------------------------------------GET /films/995/ |   330 |  1160 |          3.5GET /films/     |    99 |   195 |          2.0POST /reviews/  |   325 |  1114 |          3.4 The App For this comparison I’m going to consider a simple app that simply provides a RESTful interface to a database. This is a common use case in a microservices architecture and provides for a very simple codebase to compare. The app has two consisting of three routes in total. These routes are meant to represent typical CRUD usage i.e. a single resource, all resources, and a new resource . blueprints GET /films/<int:id>/ GET /films/ POST /reviews/ The source code is available at note that there are two commits, a Flask version and a Quart version. https://github.com/pgjones/faster_than_flask_article Evolution from Flask to Quart Evolution from Flask to Quart is meant to be easy and require the minimal set of changes, specifically imports from flask are changed to be from quart and functions become async. An example from the full is, diff def add_review():data = request.get_json()... which becomes, async def add_review():data = await request.get_json()... Evolution from psycopg2 to asyncpg Evolving the psycopg2 code to use asyncpg is a little more involved as the two have differing usages. To simplify the diff a is used in the Flask app to give a context managed psycopg2 connection with the same API as asyncpg i.e. . This allows asyncpg to be used by changing the to . PoolWrapper with pool.acquire() as connection: with async with Aside from the connection, Asyncpg and psycopg2 also differ on cursor usage, transactions, execution arguments and query formatting. These are mostly differing conventions and the details are best considered in the . diff Deployment Exposing a Flask app directly to production traffic is unlikely to scale and doesn’t really represent a typical production environment. This is because Flask itself can only handle a single request at a time. Instead a WSGI server is typically used in combination with some kind of asynchronous worker, for example with . Gunicorn eventlet Quart is also best deployed with Gunicorn, which allows the same command to be used to run both the Flask and Quart apps, $ gunicorn --config gunicorn.py 'run:create_app()' with the config file only in terms of which worker is used (eventlet for Flask and the Quart-UVLoop worker for Quart). differing The performance measurements were performed with both the Flask and Quart apps running behind Gunicorn. Database The Postgresql is used to give the apps something to act against in a CRUD manner. It is unchanged save for the addition of a simple review table, sample database CREATE TABLE review (film_id INTEGER REFERENCES film(film_id),rating INTEGER); Performance Measurement To measure the performance of the apps is used. It is configured to use 20 connections to match the database connection pool size (this should ensure the highest throughput, and 20 is a typical value I’ve used). To measure the GET requests the command is, wrk $ wrk --connections 20 --duration 5m http://localhost:5000/${PATH}/ whereas for POST requests the command is, $ wrk --connections 20 --duration 5m --script post.lua http://localhost:5000/${PATH}/ with the post.lua file defined . here Test system The database Postgres (9.5.10), wrk (4.0.0) and apps Python (3.6.3) with requirements asyncpg (0.13.0), Flask (0.12.2), Gunicorn (19.7.1), psycopg2 (2.7.3.2), Quart (0.3.1) are all running on a single AWS c4.large machine. Results The full results are shown in the table below, Route           | Requests per second | Average Latency [ms]  ||   Flask  |   Quart  |   Flask   |   Quart   |---------------------------------------------------------------GET /films/995/ |   330.22 |  1160.27 |     60.55 |     17.23 |GET /films/     |    99.39 |   194.58 |    201.14 |    102.76 |POST /reviews/  |   324.49 |  1113.81 |     61.60 |     18.22 | note that Quart servers between 2 to 3.5 times more requests per second with a corresponding 2 to 3.5 times reduction in the average latency. Conclusion The evolution of a Flask app to a Quart app is quite easy as the shared API mostly means the effort is writing & in the correct places. The evolution from psycopg2 to asyncpg is however more involved and likely troublesome if SQLAlchemy (or other ORMs) are used. async await The performance of the app is noticeably improved. This improvement is mostly due to the usage of asyncpg and uvloop which Quart enables. Quart alone is to offer a more modest 1.5 times speedup. estimated In conclusion the transition from a Flask-psycopg2 app to a Quart-asyncpg app is fairly low effort and gives a very reasonable performance improvement. This is likely to extend for any of the other asyncio based libraries, meaning that Quart enables the minimal effort transition for Flask apps to the asyncio ecosystem.

Stories, News & Mentions about WRK

Wrk’s Stories on HackerNoon

Wrk's News & Mentions