CodeIsGo.com

Machine learning (ML), while it doesn’t exactly simulate systems in nature, has the ability to learn a model of a system and predict the system’s behavior. Over the past few years, classical ML models have shown promise in tackling challenging scientific issues, leading to advancements in image processing for cancer detection, forecasting earthquake aftershocks, predicting extreme weather patterns, and detecting new exoplanets. Posted by Alan Ho, Product Lead and Masoud Mohseni, Technical Lead, Google Research.

Google in collaboration with the University of Waterloo, X, and Volkswagen, announced the release of TensorFlow Quantum (TFQ), open-source library for the rapid prototyping of quantum ML models.

A quantum model has the ability to represent and generalize data with a quantum mechanical origin. However, to understand quantum models, two concepts must be introduced – quantum data and hybrid quantum-classical models.

TFQ allows researchers to construct quantum datasets, quantum models, and classical control parameters as tensors in a single computational graph. The outcome of quantum measurements, leading to classical probabilistic events, is obtained by TensorFlow Ops. Training can be done using standard Keras functions.

For all the details read original article. Super exciting!

CSS is an easy language to learn (and to implement) for creating a beautiful website. However, when it comes to implementing CSS at scale, it’s not that simple. For large scale websites and applications, CSS becomes really hard to write in. By Thoriq Firdaus in Coding.

CSS specificity is crippling up, and so, using !important is often inevitable and eventually adds up to the CSS file size.

Well, the good news is that web developers have come up with several methodologies to help write and organize CSS better, such as BEM, OOCSS, SMACSS, and ITCSS.

The article makes a good explanation how utility-first CSS works. It also makes a brief introduction to Tailwind CSS and optimising file size. Changing the way we write CSS is not always easy. It means that we have to unlearn what we are already used to. Well done!

Anna Monus wrote this piece about variable fonts. Variable fonts are popular for two reasons: they expand design possibilities and improve website performance. While the former statement is definitely true since variable fonts do provide infinite typographical choices, the latter only holds under certain conditions.

In this tutorial, author conducts a performance test on a live server to better understand the performance trade-off of variable fonts.

The article dives in:

• What are variable fonts?
• How variable fonts impact performance
• The challenge of testing variable fonts
• The test cases

… and much more. Comprehensive charts and speed measurements are also provided. Whether using variable fonts is worth it performance-wise depends on how the decrease in HTTP requests and the increase in total page size balance each other out. Nice read!

An article about how author has recently helped a client migrate a set of complex Ruby on Rails applications to AWS, deploying across multiple environments and regions. By Jake Morrison.

The big driver for improvement, however, was the need to separate customer data by country/region. GDPR compliance is easier if they keep European data hosted in Europe. Customers in China were also complaining about poor network performance crossing the “Great Firewall”.

One of the most important design considerations was handling all their apps and environments with a common framework. If there are too many special cases, the system becomes unmanageable. It’s a false economy to optimize one environment with custom code, but increase the cost of managing the overall system. It is better to have a standard template with configuration options. On the other hand, we can’t have too much configurability, it must be “opinionated”.

The article then goes over solution:

• Architecture
  • Multiple AWS accounts
  • Sharing resources between accounts
  • Structure
  • Meeting legacy apps half way
  • Deploying with CodeDeploy and Capistrano
  • Encryption

… and more. Very detailed article with all the code and a complete example of deploying an app to AWS. Good read!

In this article by Lawrence E Hecht we look at review of industry studies of the service mesh. They indicate that Istio has an early lead as a preferred control plane.

However, service meshes usually also have a data plane component as well as other value-added functionality. The mix-and-matching of these often open-source components into bundled solutions is an ongoing process and may impact the eventual winners and losers in this space.

A recent report by StackRox shows that adoption of Istio in production doubled over the last year, but usage is still minuscule; Only 4% of the respondents say their organizations have it in production environments.

It is noteworthy that 86% of respondents in both the late 2018 and the December 2019 surveys said their organizations are using Kubernetes as one way to orchestrate containers and microservices.

Read article in whole to get full picture, charts and a bonus. Nice one!

The Server Query Cache (QC) is a well-known feature of MariaDB Server–it caches SQL statements and the corresponding result sets. Today we have faster, solid-state disks and more RAM, so the Query Cache is less important. Reducing reliance on cache alleviates its negative effects, such as mutex blocking. By Anders Karlsson.

A mutual exclusion object (mutex) is a programming object that allows multiple program threads to share a resource (such as a folder) but not simultaneously. Mutex is set to unlock when the data is no longer needed or when a routine is finished. Mutex creates a bottleneck effect. The blocking means only one query can look at the Query Cache at a time and other queries must wait. A query that must wait to look in the cache only to find it isn’t in the cache will be slowed instead of being accelerated.

The article then in some detail describes:

• Query Cache Flags
• Query Cache Concerns
• The MaxScale Query Filter
• Mutex Work Around
• Fixing the Query Cache

… and more. Everything is demonstrated in provided code examples. Plus instructions how to test. Good read!

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!