Alachisoft’s Post

★ Understanding how caching works in GitHub Actions

Need a quick way to grab primary keys in Laravel? 🛠️ Check out how the `modelKeys()` method can clean up your code and boost efficiency in your projects. Perfect for bulk updates and caching!

In a concise Python-focused tutorial, Itay Bittan walks us through the entire workflow of combining your React application with the FastAPI web server.

The good folks at Cloudflare have open-sourced the Pingora library. This library enables a programmer to build reliable web servers like Nginx or Apache. It is a library for now, and they plan to release a fully executable web server in the future. Pingora has been shown to reduce computing and memory requirements by 2/3 compared to Nginx, and also reduce the number of HTTP connections by 1/3. But how and why? Nginx is designed with a multi-process architecture. When a HTTP request comes into Nginx, it is handled by a HTTP request handler process and copied and dispatched to a worker (of which there are many) and the worker manages the request until it is complete. Both the initial HTTP request handler and each worker run in their own process. The worker in turn copies the HTTP request and dispatches it to an application server if it is for a web application, or it digs into its files to serve the request. Each process must maintain a set of connections, its own memory, and copies of the HTTP request. That means that in a web application there could be 3 or more copies of the HTTP request in the system, and if a web application is using multiple workers to connect to the same application server, then each worker gets its own connection to the same application server. The multi-process architecture is good because it ensures memory safety between processes. i.e. The code in one process cannot write to the memory owned by another process. This is needed because most web servers, such as Apache and Nginx, are written in C or C++, which are not memory-safe. Pingora is written in the Rust programming language, which enforces memory safety in the Rust compiler. This means that code running in one Rust thread cannot write to the memory owned by another Rust thread in the same process. This, in turn means that a multi-process architecture is not required for memory safety, because a multi-threaded architecture is sufficient for memory safety if the program is written in Rust. If only a single process is required for a web server, then each thread can share the HTTP connections to web applications, thus allowing the number of connections to be reduced. Also, since the initial receiver of the HTTP request runs in the same process as the worker threads, the HTTP request does not have to be copied from the initial receiver thread to the worker thread (an expensive operation), but only a reference to the HTTP message and memory segment ownership must be transferred to the worker thread (a cheap operation). With a reduction of HTTP memory copies across processes, one can expect a reduction in CPU and memory usage overall. The numbers seem to bear this out. For folks seeking to reduce computing infrastructure costs, using technologies like Rust and Pingora will allow them to replace multi-process software architectures with multi-threaded architectures in some cases, and thus reduce CPU usage, memory usage, and possibly even communication bandwidth.

How to host, publish your FastAPI services and automatically deploy updates using GitHub Actions https://lnkd.in/dnPqkbnp

One pretty cool product is Codecrafters, which are a series of challenges where you recreate some famous pieces of software, like Redis, grep, Docker, SQLite, and BitTorrent in a wide variety of optional languages (I count seventeen). It's not too hands-on either. Typically after a few introductory stages, they will just say "Now implement this feature of the specification, with this expected output" and you have to figure it out for yourself. An examination of the forums shows many possible roads. And they keep on adding to it. I did the Redis challenge some months ago, and now I see there are several "Extensions" to the core work, implementing streams, RDB persistence, and replication. Here's my repo for the "Build your own HTTP server" challenge (I'll work on the Redis extension projects before showing that off!): https://lnkd.in/eckV5HgB CodeCrafters.io (YC S22)

Implementation of an Ingress Controller using NGINX #WorkSmartWithK8s #kubenernetes #ingresscontroller #nginx https://lnkd.in/e47SQYHb

In this tutorial, Matti Tahvonen shares five practical methods for returning values asynchronously from the browser to the server in #VaadinFlow. 👇 https://bit.ly/3uGxtYA

Need local S3 storage? Check out this cool guide using MinIO! 🤩 Learn how to set it up, connect with Laravel, and start managing your files easily.