CodeIsGo.com

James Lim out together this piece about short explainer of event-driven servers, intended to help readers gain an intuitive understanding of event loops.

It could be useful when:

• Deciding between different MPMs for Apache HTTP Server
• Comparing Apache HTTP Server and NGINX
• Choosing concurrency models for gunicorn
• Troubleshooting an event loop

In the classic client-server architecture, a server accepts connections from clients, receives data on the new socket, forwards it to the application for processing, and then sends data back to the client on the same socket.

To achieve concurrency, the simplest multi-threaded implementation could create a new thread for each new connection. Once created, the thread is bound to the connection, processing all requests and responses on this connection sequentially. The thread is then destroyed and freed when the connection is closed.

Plenty of charts and terminal commands to help you with better understanding of the concept. Also links to further reading. Great!

DevOps brought the development community to the agile era where multiple teams can work in a collaborative environment sharing their skills, knowledge and development responsibilities. But for the same reason, making the DevOps process more productive became more important than ever before. By Atman Rathod.

In the DevOps development process, there are many stumbling blocks and challenges for productivity that developers need to address. From lack of coordination among the team members to the silos of the automation tools to the lack of visibility and poor performance testing and several other challenges, DevOps teams need to address several crucial challenges to ensure optimum productivity.

The article then focuses on the following:

• Choose the Right Projects
• Automation Silos
• Legacy Systems Not Optimized for DevOps
• Visibility Challenges
• Performance Testing
• Manpower Problem

… and more. DevOps will continue to shine as the most effective development approach for modern apps. But for companies to use their full potential, these productivity challenges must be met head-on. Insightful.

Using GraalVM’s Native Image tool to create native executables. Author describes the steps necessary to build a native executable from a simple http4s web service. There is also complete code accompanying this example. By Noel Welsh.

Before going into the details it’s worth going over a bit of background. GraalVM is a new Java virtual machine and associated tools that brings increased performance compared to the older Hotspot VM. Native Image is one of the most interesting tools that comes with GraalVM.

The main steps mentioned in the article are:

• Install GraalVM locally (this is optional, but it is faster to test this way)
• Writing code (the fun part!)
• One-off configuration so that GraalVM can handle uses of reflection and Unsafe
• Creating a Docker image to build the executable (optional if you are developing on the same platform you’re deploying to) and
• Creating a Docker image to deploy the executable (again, optional)

Creating an executable from Scala code using GraalVM Native Image is quite straightforward. One of the attractions of native executables is faster startup and reduced memory consumption compared to the standard JVM. Great!

Python-like, Java-compatible language aims to ease development of concurrent, distributed, and parallel systems. By Paul Krill.

The Java Virtual Machine is gaining a new language, called Concurnas, which is a free, open source, compiled programming language positioned for use in building high-performance, distributed systems.

Emphasizing concurrency and parallelism, Concurnas is statically typed and garbage-collected, and it uses type inference. Concurnas code is said to be often indistinguishable from Python while offering performance akin to Java.

Some features of Concurnas include:

• Object orientation, with advanced support for classes including abstract
• Support for GPU computing
• Reactive programming support
• Off-heap memory capabilities

In development for three years, Concurnas has a standalone compiler and a REPL (read-eval-print loop) shell. Nice read!

NodeJS was born in 2009 and it has gained massive popularity throughout the years because of one reason. It’s just JavaScript! Well, it’s a JavaScript runtime designed to write server-side applications, but the statement that “It’s just JavaScript” is not 100% true. By Deepal Jayasekara.

JavaScript is single-threaded, and it was not designed to run on the server-side where scalability was a critical requirement. With Google Chrome’s high-performance V8 JavaScript Engine, the super cool asynchronous I/O implementation of libuv, and with a few other spicy additions, Node JS was capable of bringing client-side JavaScript to the server-side enabling writing super-fast web servers in JavaScript that are capable of handling thousands of socket connections at a time.

The article is split into:

• EventEmitter and the Event Loop are related
• All callback-accepting functions are asynchronous
• All CPU-intensive functions are blocking the event loop
• All asynchronous operations are performed on the thread pool
• NodeJS should not be used to write CPU-intensive applications

Each topic si well explained. You will also get plenty of charts helping to explain the main points discussed in the article. Nice one!

Protecting the security and privacy of individuals is a central tenet of Mozilla’s mission, and so they constantly endeavor to make their users safer online. With a complex and highly-optimized system like Firefox, memory safety is one of the biggest security challenges. By Nathan Froyd.

Firefox is mostly written in C and C++. These languages are notoriously difficult to use safely, since any mistake can lead to complete compromise of the program. We work hard to find and eliminate memory hazards, but we’re also evolving the Firefox codebase to address these attack vectors at a deeper level.

The article’s main parts:

• A new approach – extensive use of both sandboxing and Rust
• Building a wasm sandbox
• Ahead-of-time compilation with Cranelift and friends
• Getting sandboxing correct
• Tainted data

With the core infrastructure for wasm sandboxing in place, Mozilla can focus on increasing its impact across the Firefox codebase – both by bringing it to all of their supported platforms, and by applying it to more components. Good read!

Deepu K Sasidharan put together this article for Go developers interested in functional programming. Do not worry, you don’t have to learn functional programming oriented languages like Haskell or Clojure(or even Scala or JavaScript though they are not pure functional programming languages) since Go has you covered and this post is for you.

Hence in functional programming, there are two very important rules:

No Data mutations: It means a data object should not be changed after it is created. No implicit state: Hidden/Implicit state should be avoided. In functional programming state is not eliminated, instead, its made visible and explicit.

The article then lists:

• First-class and higher-order functions
• Pure functions
• Recursio
• Lazy evaluation
• Type system
• Referential transparency
• Data structures

This is just an introduction for those who are trying to apply some functional programming techniques in Go. There are a lot more that can be done in Go and with the addition of generics in the next major version, this should be even easier. Nice one!

More than half a million calls go through the Talkdesk systems every day. For our clients, especially larger contact centers, it can be difficult to understand and monitor everything happening due to the amount of structured and unstructured data and the high pace at which they originate. Our main goal is to make their job easier by providing insightful dashboards about calls and the overall call center performance. By Henrique Carlos.

We started by building a prototype Machine Learning (ML) model based on Latent Dirichlet Allocation (LDA) algorithm to analyze sets of voice call transcriptions and capture which topics are being talked about. Building the model was a rewarding but challenging experience. Despite that, having the model sitting on our laptops was bringing no value to the organization. We had to take it to production so that our clients could benefit from it.

The article covers following:

• Topic extraction pipeline
• Integrations should be the priority
• The focus is on delivering

Deploying the machine learning model in production brought several unexpected challenges and the team was very proud of their achievement. Focusing on early end-to-end integration allowed them to iterate fast, and by using small and valuable increments we were able to overcome all issues. Good read!

Brian Rinaldi published this article in which he describes the strategies for migration to JAMstack from an existing CMS architecture.

First the bad news: migrations are painful. Not “can be”, they are. That doesn’t mean they aren’t worth it. They definitely can be, and the JAMstack offers some major benefits on things like cost, speed and security (to name a few) that can make it worth the effort.

The main parts of the article:

• Some things to consider
• Use the Wordpress REST API
• Export content to flat files
• Import Content to a Headless CMS

Each option is explained in detail and there is plenty of code examples included. You’ll likely want to explore how you can leverage serverless functions to handle some of the dynamic functionality that was once likely handled by some form of plugin. Now, nothing will stop your migration. Well done!

Since 2014, the serverless model has taken off, and every major cloud provider has introduced its flavor of an FaaS service: Azure Functions, Google Cloud Functions, and IBM Cloud Functions, to name a few.

Serverless compute brings unlimited scale and high availability to every company in the world, from small startups to multinational corporations. At least, that’s the vision of Amazon and Microsoft, today’s biggest cloud vendors.

The article then compares:

• Hosting p[lans
• Configurability
• Programming languages
• Concurrency and Isolation
• Cost
• Performance and scalability
• Orchestrations

… and much more. AWS Lambda and Azure Functions are similar services, but the devil is in the details—and virtually every angle shows some essential distinctions between the two. Good read!