CodeIsGo.com

In recent years, lots of new programming paradigms have emerged – going from monolithic architectures towards microservices and now serverless functions. As a result, less code needs to be deployed, and updating an application becomes easier and faster as only a part has to be built and deployed. By Andreas Muttscheller.

If you want to stay independent of cloud providers, an open-source solution that can be deployed on your own infrastructure can be beneficial. Cut to OpenFaaS, an open source serverless framework that runs on Kubernetes or Docker Swarm.

In this blog post, we will focus on setting up a Raspberry Pi cluster, using Ansible for reproducible provisioning, k3s as a lightweight Kubernetes distribution, and OpenFaaS to run serverless functions.

The article then describes:

• Building the Raspberry Pi cluster (4x Raspberry Pi 3)
• Provisioning the cluster with Ansible
• Master node and network setup
• Bootstrap
• LCD display monitoring

All the code is provided with some solid explanation. Loads of links to further reading, including to printable rack for cluster. Nice one!

Janakiram MSV put together this tutorial about TensorFlow models. We will explore the idea of running TensorFlow models as microservices at the edge. Jetson Nano, a powerful edge computing device will run the K3s distribution from Rancher Labs. It can be a single node K3s cluster or join an existing K3s cluster just as an agent.

The Jetson platform from NVIDIA runs a flavor of Debian called L4T (Linux for Tegra) which is based on Ubuntu 18.04. The OS along with the CUDA-X drivers and SDKs is packaged into JetPack, a comprehensive software stack for the Jetson family of products such as Jetson Nano and Jetson Xavier.

Accessing the GPU from a K3s cluster through custom Docker runtime is a powerful mechanism to run AI at the edge in a cloud native environment. With TensorFlow running at the edge within Kubernetes, you can deploy deep learning models as microservices.

The tutorial is split into:

• Configure Docker runtime
• Install K3s on Jetson Nano

You will also get code examples and screen shots to guide you through tutorial. Well done!

Microsoft announced the first public release of Open Service Mesh (OSM) an open-source, lightweight, and extensible service mesh implementation, based on the Service Mesh Interface (SMI) specification. By Thorsten Hans.

A service mesh helps to manage service-to-service network communication in Kubernetes environments. Several features related to communication between individual application components are offloaded from the application code to the service mesh. Typically, service mesh implementations add those capabilities to an application by using Kubernetes’ sidecar-container pattern.

This article explains the core concepts of a service mesh, provides an Open Service Mesh introduction, and demonstrates some common service mesh use-cases.

It explains in great detail:

• What is a Service Mesh
• What is the Service Mesh Interface specification
• Should you consider using a Service Mesh
• Introducing Microsoft Open Service Mesh
• Traffic Access Control sor simple Applications
• Canary Deployments with Open Service Mesh
• The Open Service Mesh Dashboard

There is a lot to like about the simplicity and frictionless of Microsoft Open Service Mesh. Installing and onboarding applications is straight forward, and by relying on the SMI specification, fundamental tasks can be implemented quickly. You will also get example code in GutHub repository. Great article!

Changes in Spotlight Search on iOS and iPadOS 14 beta, a significant update to its Applebot support page, and an increase in crawling from AppleBot signify that Apple may be launching a search engine soon. By Jon Henshaw.

For several years, it’s been reported that Google pays billions of dollars to Apple to remain the default search engine on Safari for iOS, iPadOS, and macOS. The deal ensures that iPhone, iPad, and Mac users search with Google when they use Safari. That is unless they manually change the default search engine in Safari’s preferences.

The article then describes:

• Why Apple might be launching a search engine
• iOS and iPadOS 14 beta bypasses Google Search with Spotlight Search
• Apple recently updated its Applebot web crawler page
• Applebot has been busy crawling sites
• What Apple has to gain from launching a search engine
• What will this mean for SEO?

If Apple can capture enough market share, it will force SEOs to adapt and optimize for their search engine. In some ways, at least based on their Applebot documentation, tactics will remain the same. But SEOs can also expect to test and discover new opportunities that aren’t possible with Google or other modern search engines. Interesting!

Kubernetes is finding its way from the cloud to the edge via the data center. During the early days, Kubernetes was considered for hyperscale workloads running in the public cloud. It eventually became the consistent and unified infrastructure layer to run workloads in hybrid cloud and multicloud environments. By Janakiram MSV.

The rise of the Internet of Things and AI prompted the industry in moving the compute capabilities closer to the data which has become the edge computing layer.

The article is split into few sections:

• The building blocks of edge
• K3s – The Kubernetes distribution for the edge
• Portworx – The container-native storage layer
• Project Calico – Secure network for the edge

Project Calico brings fine-grained network policies to Kubernetes. While Kubernetes has extensive support for Role-Based Access Control (RBAC), the default networking stack available in the upstream Kubernetes distribution doesn’t support fine-grained network policies. Great read!

Graphtage is a command line utility and underlying library for semantically comparing and merging tree-like structures such as JSON, JSON5, XML, HTML, YAML, and TOML files. By Evan Sultanik.

Graphtage lets you see what’s different between two files quickly and easily, but it isn’t a standard line-oriented comparison tool like diff. Graphtage is semantically aware, which allows it to map differences across unordered structures like JSON dicts and XML element tags. You can even compare files that are in two different formats! And when paired with our PolyFile tool, you can semantically diff arbitrary file formats.

// original.json
{
    "foo": [1, 2, 3, 4],
    "bar": "testing"
}

// modified.json
{
    "foo": [2, 3, 4, 5],
    "zab": "testing",
    "woo": ["foobar"]
}

Source: https://blog.trailofbits.com/2020/08/28/graphtage/

Tree-like file formats are becoming increasingly common as a means for transmitting and storing data.Graphtage’s diffing algorithms operate on an intermediate representation rather than on the data structures of the original file format. This allows Graphtage to have generic comparison algorithms that can work on any input file type. Very interesting diff tool, please give it a go!

Scrum of Scrums is a technique used to scale Agile by dividing the groups into Agile teams of 5-10. Each daily scrum within a sub-team ends by designating one member as representative to participate in a daily meeting with ambassadors from other teams, called the Scrum of Scrums. This article provides some tips on how to succeed with Scrum of Scrums. By Sergio Fiorillo.

Everything is going swimmingly with Scrum and then one day, it is time to scale. Know here how to succeed when you start adding Scrum of Scrums meetings to the schedule. Understanding their purpose is the first step.

The article main focus is on:

• Make sure everyone agrees on the purpose of the Scrum of Scrums
• Avoid SoS mistakes by keeping an Agile mindset
• Make sure the right questions are being asked
• Choose your Scrum of Scrums representatives wisely

In an Agile environment, the Scrum of Scrums is one of the best scaling techniques that teams can adopt along with running scaled retrospectives. Good read!

The government is funding basic research in AI, too. When big technologies like mobile phones, 5G networks and e-commerce arrive, it’s important to get in on the ground floor. That’s why the US government is establishing 12 new research centers, funded with hundreds of millions of dollars, to boost artificial intelligence and quantum computing. By Stephen Shankland @cnet.com.

The Department of Energy’s five quantum computing centers, housed at US national laboratories, are funded by a five year, $625 million project bolstered by $340 million worth of help from companies including IBM, Microsoft, Intel, Applied Materials and Lockheed Martin. The funds came from the $1.2 billion allocated by the National Quantum Initiative Act, which President Donald Trump signed in 2018, but the private sector contributions add some new clout.

The article then deals with:

• Challenging US ‘adversaries’
• Private sector already eager
• Quantum sensors, networks and error correction

The idea is to link government, private and university research to accelerate key areas in the US. It’s the same recipe used for earlier US technology triumphs like the Manhattan Project to build the atomic bomb in World War II, the Apollo program to send humans to the moon and the military-funded effort to establish what became the internet. Interesting!

AI tools are shaping next-generation theorem provers, and with them the relationship between math and machine. By Stephen Ornes.

A proof is a step-by-step logical argument that verifies the truth of a conjecture, or a mathematical proposition. (Once it’s proved, a conjecture becomes a theorem.) It both establishes the validity of a statement and explains why it’s true. A proof is strange, though. It’s abstract and untethered to material experience.

Computers are useful for big calculations, but proofs require something different. Conjectures arise from inductive reasoning – a kind of intuition about an interesting problem – and proofs generally follow deductive, step-by-step logic.

Another gripe is that if they want to use theorem provers, mathematicians must first learn to code and then figure out how to express their problem in computer-friendly language.

Mathematicians, logicians and philosophers have long argued over what part of creating proofs is fundamentally human, and debates about mechanized mathematics continue today, especially in the deep valleys connecting computer science and pure mathematics.

“Computers have done amazing calculations for us, but they have never solved a hard problem on their own Until they do, mathematicians aren’t going to be buying into this stuff.”

– Kevin Buzzard, a mathematician at Imperial College London

Recently, Simon DeDeo together with Scott Viteri, a computer scientist now at Stanford University, reverse-engineered a handful of famous canonical proofs (including one from Euclid’s Elements) and dozens of machine-generated proofs, written using a theorem prover called Coq, to look for commonalities. Very interesting read!

Building micro-frontends to speed up and scale our web development process. By Jonathan Saring.

At Bit, we build tools for over 100,000 developers working with components. Our tools help developers build, reuse, and collaborate on independent components to speed up development and improve application quality.

Micro front-ends are a way to split the monolith front-end codebase into smaller, more manageable pieces. As a result, front-end teams can enjoy similar benefits to those of microservices: maintainable codebases, autonomous teams, independent releases, and incremental upgrades.

Source: https://martinfowler.com/articles/micro-frontends.html/

The articles then pays attention to:

• So what are micro front-ends, really?
• Our process
• Autonomous teams
• Simple, decoupled codebases
• Independent release pipelines
• More incremental upgrades
• Infinite component reuse and collaboration

Some say micro front-ends is nothing but a “good component model”. For their team, it was a good component model as much as it was a better way to build our own team, improve the way we work, build better modular software, and deliver it faster and more often.

In recent years, microservices allowed backend architectures to scale through loosely coupled codebases, each responsible for its own business logic and exposes an API, each independently deployable, and each owned and maintained by a different team.