CodeIsGo.com

What’s the best way to safely increase parallelism in a production Node service? What if your application is a bank integration service? That’s a question author’s team needed to answer a couple of months ago. By Evan Limanto.

We were running 4,000 Node containers (or “workers”) for our bank integration service. The service was originally designed such that each worker would process only a single request at a time. This design lessened the impact of integrations that accidentally blocked the event loop, and allowed us to ignore the variability in resource usage across different integrations. But since our total capacity was capped at 4,000 concurrent requests, the system did not gracefully scale. Most requests were network-bound, so we could improve our capacity and costs if we could just figure out how to increase parallelism safely.

This is in depth article, with all of these and more covered:

• Why they invested in parallelism
• How they rolled out changes reliably
• Deploy, investigate, repeat
• Results and learnings

Never underestimate the importance of having low-level metrics for a system. Being able to monitor GC and memory statistics during rollout was essential. Lengthy article but there is plenty of the value. Highly recommended!

In this article author goes through the details of how Beat managed to achieve lightning fast queries during the driver dispatching process; getting the nearest driver to a passenger. by Fotis Papadopoulos.

In a nutshell, spatial indexing refers to a rather broad set of techniques that enable fast and efficient indexing of spatial objects in software applications. Spatial objects can represent points on a plane, polygons of arbitrary shapes, lines and pretty much every geometry. It is supported by several mainstream databases, some of which offering very sophisticated and highly scalable APIs, such as PostgreSQL with PostGIS extension.

The article is split into:

• Spatial indexing
• The initial approach
• Boosting our queries
• Google S2 geometry framework
• Hashicorp’s Go MemDB
• Search example

… and much more. Go MemDB is a simple in-memory database, built on immutable radix trees (compact prefix trees). It provides Atomicity, Consistency and Isolation from the ACID set of database properties. Durability is not supported due to its in-memory nature, but you can always backup your data as frequently as you want. Nice one!

Omer Hanetz wrote this piece about his experiences with using EKS as the link between your cloud environment with all its computation power, storage, and security features, and your Kubernetes-based containerized environment with its micro-service and auto-scale capabilities.

Managing a containerized environment, especially when considering security and efficient use of resources, can be an impossible task. Using Kubernetes can help make this task possible, and using a Kubernetes environment managed by your cloud provider can make the integration with all the cloud provider services much easier.

The article covers in depth various aspects of installing, running and managing EKS, e.g.:

• Install eksctl, kubectl
• Setting up EKS cluster
• Setting Up the Kubernetes environment
• Creating the deployment
• Auto-Scaling the deployment
• Exposing an endpoint

… and all the commands plus links to repositories are included. You should also refer to this EKS online workshop provided by Amazon that can also help get you started and introduce you to all the EKS features. Excellent!

Penetration testing is vital, but are you doing it right? Here are some common mistakes and advice on how to avoid them. An article by Michelle Drolet.

One of the most effective ways to uncover flaws and weaknesses in your security posture is to have a third party carry out planned attacks on your system. Penetration testing is all about exposing gaps in your defenses so that they can be plugged before someone with malicious intent can take advantage. There are several different types of pen test designed to target different aspects of your organization.

The article then dives straight into mistakes, such as:

• Failure to prioritize risks
• Using the wrong tools
• Box-ticking mentality to pen testing
• Poor reporting
• Disrupting the business
• Using out of date techniques

… and more to be found in this interesting article. Nice one!

Observables are the essential elements of the Angular framework; you can’t do too many things without using them. An article by Gábor Soós.

While a Promise only emits the result once, Observables can emit multiple values over time.

The article is split into these sections:

• Promises
• Multiple results
• Synchronous execution
• Array methods

When learning Observables, the RxMarbles site can help to made them crystal clear. RxMarbles are graphical representations on a timeline describing the behavior of an Observable composition.

We liked: The subscriptions of an Observable will be executed synchronously after a value is passed in. Good read!

An article by Jakub Kapuscik about the visitor design pattern. The idea behind the visitor design pattern is to put parts of the code that have specific responsibilities outside of the class.

The most common use case for the pattern is reporting and exporting data to a given format. Those are very useful features that can easily get complex. They operate on data stored in an object but have very specific tasks to perform.

The single responsibility principle states that a class should have only one reason to change. If we want to add reporting or exporting on a structure of data, we will have at least two responsibilities.

Author work with example implementation in PHP. A visitor has the following elements:

• Visitor (Visitor) – Defines the interface of visitors
• Concrete Visitor (SickLeaveReport) – Concrete implementation of operations defined in the Visitor interface
• Element (Visitable) – Defines the “accept” operation interface, taking Visitor as an argument
• Concrete element (Student, University) – Concrete implementation of elements.

Source code is provided in GitHub repo. Good one!

Your guide to buying new telescope. Buying a telescope is a big step, especially if you’re not sure what all those terms – f/ratio, magnification, go-to – mean. So, to eliminate confusion and make sure you understand what you’re buying, here’s what to check out before you write the check out. Older, but very useful guide by Michael E. Bakich.

The 3 main types of telescopes use lenses, mirrors, or a combination of both.

Refracting telescopes use lenses – combining at least two, and as many as four, pieces of glass – as their objective (the primary light-gathering device).

Reflecting telescopes use mirrors to gather and focus light. In a Newtonian reflector – the most common type – light reflects from the primary mirror (whose surface is ground into a parabola so light comes to a common focus). The light strikes a smaller, flat secondary mirror near the top of the tube. The light then is bent 90° and enters the eyepiece through a small hole in the tube.

Catadioptric, or compound, telescopes incorporate a primary mirror coupled with a corrector lens placed at the front of the tube. The primary mirror’s curve is ground to a simple shape, usually a sphere. Ordinarily, a spherical mirror would introduce aberrations in the viewed image, but the corrector of a catadioptric scope “pre-bends” the light before it strikes the mirror. Two popular catadioptric telescopes are the Schmidt-Cassegrain and Maksutov-Cassegrain designs.

Further details in this interesting guide! Well worth your time!

With containers, you can create a clean, virtual environment to set up and train your neural networks in. Then, you can deploy the neural networks at scale with the exact same same environment. Article by Mo Haghighi.

This tutorial can help you understand how to deploy and manage a machine learning app on Minishift and Red Hat® OpenShift® on IBM Cloud™. When you complete the exercises, you will know how to do the following tasks:

• Recognize handwritten digits with Keras+, the MNIST dataset
• Build a neural network
• Deploy the neural network
• Deploy the app to Minishift
• Train the neural network

GitHub repository with the code is also available. Excellent!

An article by Tobias Mann about key things related to SD-WAN in 2019. SD-WAN reached an inflection point in 2019.

SD-WAN adoption is poised for liftoff, with IDC is predicting revenues in the space will exceed $5 billion by 2023, and the market’s meteoric growth has lead Avant Communications to declare SD-WAN the most disruptive technology of 2019.

With that in mind, here are the top five SD-WAN takeaways from 2019

• Room for growth
• SD-WAN is in, but MPLS is far from out
• Untapped markets
• Security remains a top concern
• Branch and SASE

Gartner predicts that there will be several SASE product announcements in 2020, and that at least one of the major cloud providers – Amazon Web Services (AWS), Microsoft, or Google – would enter the market before long. Good read!

Julio Manuel Merino Vidal wrote about his experiences about prototyping a bunch of web apps whose ideas had been floating in author’s mind for a long time. Author spent quite a bit of time learning about REST APIs and, as part of these exercises, implemented skeletons of REST servers in both Go and Rust.

The API let us manipulate a collection of tasks where each task contains a textual description and a bit to indicate whether it is done or not.

Some guiding principles used by Julio:

• Decouple the REST API manipulation from the business logic
• Using JSON for the requests and responses as the serialization format
• Storing state in-memory only
• Staying away from high-level do-it-all frameworks
• Error handling needn’t be very accurate

You will get implementation in both Rust and Go, with all the code explained. Nice one!