CodeIsGo.com

At Microsoft Core Services and Engineering (CSEO), Microsoft used Azure governance to create a solution that enables enterprise-scale governance and compliance enforcement for our entire Azure environment. Article by Microsoft.

At Azure they use Management Groups to create a logical hierarchy within the Azure governance environment. Azure Management groups can be nested, so they use the nesting behavior to replicate the relevant business and engineering structure for the groups and organizations that support each subscription.

The article goes on and covers:

• Adopting a cloud-centric architecture at Microsoft
• Adopting Azure governance
• Building an effective framework in Azure governance
• Best practices

Azure governance has enabled CSEO to create an Azure-native, enterprise-scale governance solution that will provide decentralized management of our Azure environment and its governance needs. With Azure governance, our environment is more compliant with our organizational policies and, as a result, more efficient, robust, and effective.

The cloud governance hierarchy and few more schemas included. Nice one!

An article by Kevin Casey explaining what is the difference between Robotic Process Automation (RPA) and AI. The expanding universe of artificial intelligence includes many terms and technologies.

While just about everyone agrees that machine learning is an AI discipline, that same consensus doesn’t exist with RPA and AI.

One reason for this is lack of consensus is that RPA technologies and use cases to this point haven’t been all that “intelligent.” RPA can do a great job of handling repetitive, rules-based tasks that would previously have required human effort, but it doesn’t learn as it goes like, say, a deep neural network. If something changes in the automated task -– a field in a web form moves, for example –- the RPA bot typically won’t be able to figure that out on its own.

The article then describes:

• What is the difference between AI and RPA?
• How RPA and AI work together
• What is intelligent automation?
• RPA and AI use cases
• RPA vs. automation: Plenty of room for humans

The pairing of RPA and AI may bring significant moves forward toward some of the loftier predictions about automation and the future of work.

An article from the pen of Paul Cavallaro about system programming. It is an overview of some common optimization techniques and neat tricks for doing “systems programming” -– whatever that means today.

It provides some tools for improving performance in your own applications, or at least make it easier to understand why performance sensitive code is doing what it’s doing.

The article discusses in depth:

• Cache lines & false sharing
• The magic power of 2: division is slowaloo
• Repurposing top bits
• Lock striping

False sharing problem has been written about fairly extensively, but the basic idea is that physical memory on a machine isn’t infinitely granular, i.e. you can’t just read a byte.1 Instead, when you want to read a single byte of memory, the processor will pull in and cache not just that byte, but the surrounding data as well, on the assumption that it will likely be used too. This unit of data that gets read and cached is called a “cache line”, and is essentially the smallest piece of memory that can be accessed.

While this is nowhere near an exhaustive list of the most common systems programming tricks, hopefully it whets your appetite to learn more.

All of the examples we went over over are also on github at paulcavallaro/systems-programming. Written in C++. Good read!

Short explanation focusing on gRPC and it’s implementation in Akka (Scala). gRPC is a transport mechanism for request / response and (non-persistent) streaming use cases. Akka gRPC is Open Source and available under the Apache 2 License.

It is a schema-first RPC framework, where your protocol is declared in a protobuf service descriptor, and requests and responses will be streamed over an HTTP/2 connection.

It has several advantages, including Schema-first design favors well-defined and decoupled service interfaces over brittle ad-hoc solutions; Protobuf-based wire protocol is efficient, well-known, and allows compatible schema evolution; Based on HTTP/2 which allows multiplexing several data streams over a single connection.

It is great for:

• Connections between internal services
• Connecting to external services that expose a gRPC API (even ones written in other languages)
• Serving data to web or mobile front-ends

To get more information how it compares to REST, SOAP, Message Bus and Akka Remoting follow the link to original source. Easy!

Open Banking (aka PSD2) forces the biggest UK banks to open up their precious data, which could mean big changes for the way we use money. By Rowland Manthorpe. This is older article, but explains topic well.

Banking in the UK has some big problems. Some of them: “People are paying too much for their overdrafts; money is sat in current accounts not earning interest; there’s not enough switching.”

Not much changes in banking in the UK. Sure, there are occasional new ideas -– ATMs, apps, contactless payments –- but decade after decade the fundamentals remain the same.

So what does Open Banking -– or PSD2 (Second Payment Services Directive), as it’s sometimes known -– mean in everyday terms?

The article then explains:

• What is Open Banking exactly?
• Why was Open Banking introduced?
  • Money management
  • Lending
  • Payments
• Is it safe?

Like the internet itself, open banking benefits aren’t immediately obvious. The key thing to remember: anyone using an Open Banking service will not need to share their banking login or password with anyone but the bank. Good read!

An article by Ganeshmani P about implementation of worker threads in Node.js. After the release of Node.js V10.5.0, Worker Threads are available in the Node.js module.

Javascript is a single threaded programming language. The single thread is one thread which does all the operations of your code. JavaScript engine will run as a single thread and all the operating system IO will happen in parallel. When it returns the results to JavaScript code, it will be operated in a single thread.

Under some circumstances a single thread doesn’t perform well. One of them is CPU Intensive Task. CPU Intensive tasks are the one that blocks the main thread.

The article then discusses solutions:

• Child process
• Worker threads

You will get example of implementation of both with explanation of advantages and disadvantages. The JavaScript code provided in the article. Nice!

An article by Mike ‘MJ’ Johnson about getting your hands on Rancher. With the power and flexibility of Kubernetes, you also get a massive amount of complexity. Rancher was founded in 2014 with a company focus on creating software to help manage Docker containers. Rancher 2 can help you more easily deploy, manage and maintain your Kubernetes clusters across multiple environments, both on premise and in the cloud.

The article explains:

• Rancher installation
• Quick look around admin interface
• How to setup monitoring
• How to setup alerting
• How to catalog Kubernetes deployments

You can use a CI / CD or GitOps approach to ensure having clear documentation for any apps you deploy or modify, but Rancher gives you an easy way to test deployments for either built in apps, stable / experimental Helm charts, or even provide access to your own custom Helm chart repo. Rancher even gives you access to the YAML in case you are just looking for a starting place to write your own custom deployment files. Nice one!

CEO of RisingSTack Tamas Kadlecsik wrote this guide for Node.js developers interested in learning Go. Throughout a tutorial series, we’ll cover the basics of getting started with the Go language, while building an app and exposing it through a REST, GraphQL and GRPC API.

Go is becoming the new enterprise language besides Java and C# and for a good reason.

Go also features very nice concurrency primitives and provides excellent speed if used right. However, the number of libraries compared to other platforms is small, and they tend to be young.

The first installment covers:

• Golang Setup
• Variables and Constants in Go
• Net / http with Go
• Encoding / json
• Dependency management
• Build tooling

You can find the final version of the source code for this blog post on GitHub. Nice work!

An article by Vladimir Fomene about creating modern web applications. You will create a GraphQL API using schemas, queries, mutations, and entities stored in a H2 database engine.

Before you start building your API, you need to have a basic understanding of GraphQL. According to the official website, “GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data”.

The article the covers following:

• How to build your GraphQL API
• How to add routing and enhance your frontend’s UI
• How to update routes with Vue-Router
• Improving State Management and consuming the API with Vue.js
• How to manage app refresh through silent authentication

Detailed explanation and you will get GitHub repository with all the code. Good call!

Conventional wisdom has it that using too many functional abstractions in Scala is detrimental to overall program performance. Yet, these abstractions are an immense help if you want to write clean and abstract code. in depth article by Marcin Rzeźnicki.

The gut feeling every Scala developer has is that all the fancy monadic transformers add a lot of non-optimizable indirection (at the bytecode level) that throws JIT off and is slower than what your Java colleagues might have written. But how bad is it?

The article is divided into:

• Devising an Experiment
• EitherT vs Either
• Quirks
• The Use of Inliner
• Either vs Exceptions
• IO
• Either vs Exceptions vs Bifunctor
• Results and Analysis

Very detailed reading with loads of code and detailed analysis of the results for each run. Forget about exceptions. They do not seem to have any performance advantages (but they can have disadvantages if you throw them a lot. And unless you’re building a library, compile with inliner enabled. Great article!