CodeIsGo.com

Recently, NGINX announced the release of the Ansible collection for NGINX Controller. The collection contains a set of Ansible Roles that make it easy to incorporate NGINX Controller into your workflows. You can automate routine tasks such as generating ephemeral API tokens, managing certificate lifecycles, and configuring Controller objects (Gateways, Applications, and Components). By Brian Ehlert.

The article then describes some of the roles in the collection support day-to-day activities such as:

• Creating NGINX Plus instances (nginx)
• Registering NGINX Plus instances with NGINX Controller, by installing the NGINX Controller agent on the NGINX Plus host (nginx_controller_agent)
• Deploying and configuring NGINX Plus instances as gateways for routing and protecting incoming traffic (nginx_controller_gateway)
• Managing application workspaces (nginx_controller_application)
• Configuring components to intelligently and securely distribute traffic to your backend workloads (nginx_controller_component)
• Managing certificates that are distributed by NGINX Controller to the NGINX Plus instances where they are needed (nginx_controller_certificate)
• Retrieving an ephemeral API token for the NGINX Controller API (nginx_controller_generate_token)

You will also get video tutorial which explains how to get started with the collection. Good read!

People who’ve been in crypto for a long time view the space as evolving in cycles, alternating between periods of high activity and “crypto winters.” There have been three cycles so far. The first peaked in 2011, the second in 2013, and the third in 2017. By Chris Dixon and Eddy Lazzarin on Andreessen Horowitz.

Source: https://a16z.com/2020/05/15/the-crypto-price-innovation-cycle/

These cycles appear chaotic but have an underlying order, roughly characterized as:

• The price of Bitcoin and other crypto assets goes up
• Leading to new interest and social media activity
• Leading to more people getting involved, contributing new ideas and code
• Leading to projects and startups getting created
• Leading to product launches that inspire more people, eventually culminating in the next cycle

The first crypto cycle peaked in 2011. Before this, even enthusiasts thought of Bitcoin as an interesting experiment that was unlikely to have practical value. Afterwards, entrepreneurs realized you could create businesses in crypto. This was when many of today’s largest exchanges, miners, and wallets were founded. Follow the link to the full article to learn more about history of cryptocurrencies. Excellent!

Developers are usually encouraged to do dependency injection with interfaces. Some developers don’t know that they can do dependency injection with delegates, and there are good reasons to do this. By Christian Findlay.

Moreover, developers can use delegates with modern IoC containers like ASP.NET Core’s IoC container, mock delegates, and verify calls. It is good practice and should be encouraged. Let’s have a look at why.

Firstly, let’s focus on the interface segregation principle. It’s one of the SOLID principles. It essentially means that you should minimize the number of members on an interface. It sometimes leads to an interesting situation where interfaces end up with only one method.

The article then dives into:

• Why use Delegates instead of Interfaces?
• Dependency Injection with Delegates
• Mocking Delegates with Moq
• Delegates with IoC Containers
• What if the delegate code needs extra dependencies?
• Drawbacks Of Delegates

At their heart, IoC containers are collections keyed by type. We normally key the collection by interface types, but delegates are also types, and we can key the collection with delegates instead of interfaces.

All source code for this article can be found in GitHub repository. But, be careful of scenarios with generic types. You shouldn’t alter the fundamental design of your code to fit delegates. Rather delegates should be a compliment to your existing code design. Nice one!

Amit Shekhar put together this interesting tutorial in which you are going to learn about the MVVM architecture in Android and then you will build a project with MVVM architecture. MVVM architecture is a Model-View-ViewModel architecture that removes the tight coupling between each component.

Source: https://blog.mindorks.com

The tutorial covers the following topics:

• What is MVVM architecture?
• Set up a new project with Kotlin and other dependencies required.
• Project Structure.
• Set up the utils package.
• Set up the data layer.
• Set up UI layer, build and run the project.
• Project Source Code and What Next?

Importantly, in MVVM architecture, the children don’t have the direct reference to the parent, they only have the reference by observables. The author will walk you through explanation based on a new project written in Kotlin. You will also get project code in GitHub repository so you can follow tutorial. Good read!

The World Economic Forum finalized a “blockchain bill of rights.” ConsenSys, Andreessen Horowitz, and Colombia have already signed on. By Jeff Benson. The World Economic Forum is an international organization committed to creating public-private partnerships. Its Global Blockchain Council has been developing this voluntary framework since it first convened in 2019.

“This highly opinionated group came together and agreed that the blockchain community needed the foundational principles we are presenting today,” said Sheila Warren, WEF’s head of blockchain and data policy. “Agreement from across Council members, despite their divergent perspectives, indicates the critical need for a values-based document like this in order to ensure that the technology remains true to its roots as the application layer starts to scale.”

The article describes following:

• The WEF’s Global Blockchain Council developed a voluntary framework for protecting blockchain users
• Fifteen institutional signatories have signed the Presidio Principles, including governments, international aid groups, and blockchain-based businesses
• The next step is to create guidelines for translating the principles into action

The group placed a draft version on GitHub for public comment from April 10 through May 5 before releasing the finalized document on May 22, 2020. The next step is to issue guidelines for different industries on how to incorporate the principles. Good news!

This document explains the architecture of the healthcare analytics platform—a set of tools on Google Cloud that helps you process clinical and operational healthcare data—to researchers, data scientists, IT teams, and business analysts. By cloud.google.com.

Healthcare organizations often exist in a siloed data world that includes multiple systems, data types, and modalities. You can modernize your infrastructure by moving healthcare data from multiple on-premises sources into an analytics platform on Google Cloud, which lets you harmonize data, monitor data pipelines, run analytics, and create visualizations for provider insights and data-driven decision-making.

This document is the first part of a series about building and deploying your healthcare analytics platform on Google Cloud:

• Architecture: HIPAA-aligned Cloud Healthcare
• Ingesting clinical and operational data with Cloud Data Fusion
• Transforming and harmonizing healthcare data for BigQuery
• Storing healthcare data in BigQuery
• Analyzing FHIR data in BigQuery
• Tracking provenance and lineage metadata for healthcare data
• Managing healthcare data access in BigQuery

Highly informative reference Google. Please bookmark for later reference!

Ever since Python was created, users have been looking for ways to achieve multiprocessing with threads, which the Python global interpreter lock (GIL) prevents.By Jeff Layton.

One common approach to getting around the GIL is to run computationally intensive code outside of Python with tools such as Cython and ctypes. You can even use F2PY with compiled C functions.

All of the previously mentioned tools “bypass” Python and rely on a compiled language to provide threaded multiprocessing elements with an interface to Python. What is really needed is either a way to perform threaded processing or a form of multiprocessing in Python itself. A very interesting tool for this purpose is Pymp, a Python-based method of providing OpenMP-like functionality.

OpenMP employs a few principles in its programming model. The first is that everything takes place in threads. The second is the fork-join model, which comprises parallel regions in which one or more threads can be used (Figure 1).

Because the goal of Pymp is to bring OpenMP-like functionality to Python, Pymp and Python should naturally share some concepts. A single master thread forks into multiple threads, sharing data and then synchronizing (joining) and destroying the threads. Read the rest to learn more about parallelism in Python.

Visual design is quite important for an app. The quality of apps has been steadily increased over the years, and the aesthetic part is the area with the biggest improvement in my opinion. By Bevan Steele.

Lottie is a multi-platform open-source library, initially made by Airbnb, for quickly and easily showing smooth animations. These animations are made in Adobe After Effects and they are vector-based (i.e. they can scale without pixelating). But you don’t need to worry about this and you don’t need to make them because there are plenty of such short and cute animations all over the internet (e.g. LordIcons, LottieFiles).

Source: https://www.rockandnull.com/lottie-android/

The actual animation is a JSON file that describes the path, color, etc. After acquiring that file, you would need to place it in the Assets directory of your Android project. This is a different directory from your Resources directory where drawables are placed. You would probably need to create it, by right-clicking in the Project Explorer in Android Studio, New -> Folder -> Assets Folder. Place your JSON file in the /app/assets/ folder that has been created.

To get the rest of instructions please read article in full. Cute!

Query parameters can sometimes store useful pieces of information in our URLs, but they can cause problems in our Google Analytics data. Query parameters can break apart our pages and make them hard to analyze in our All Pages report. By Amanda Geisler.

An important note before we get started: Personally Identifiable Information (PII) can not be removed with View Settings or filters. Data is collected at the property level, so the View Settings and filters do not stop the data from being collected and violates Google’s Terms of Service.

Query parameter removal with App + Web is a bit different because of the automatic pageview tracking. If you need to remove parameters from your page paths, you can use the page_location field in your Configuration tag in GTM.

– Amanda Geislerr

The article then discusses the following:

• View settings
• Filters
• Remove queries with Google Tag Manager
• App + Web properties from Google Analytics
• Better reporting on page performance

There are multiple ways to tackle query parameters in your URLs depending on your set up and implementation. If your queries do contain valuable information about your users or content, you may choose to store them as custom dimensions. Stripping query parameters from page paths can streamline reporting and help to mitigate (other) in your content reports. Nice one!

Eric Deandrea wrote this piece about one question that always comes up as organizations moving towards being cloud-native, twelve-factor, and stateless: How do you get an organization’s data to these new applications?

There are many different patterns out there, but one pattern we will look in this artticle is change data capture. This post is a simple how-to on how to build out a change data capture solution using Debezium within an OpenShift environment. Future posts will also add to this and add additional capabilities.

Change data capture (CDC) is a pattern that enables database changes to be monitored and propagated to downstream systems. It is an effective way of enabling reliable microservices integration and solving typical challenges, such as gradually extracting microservices from existing monoliths.

– Sadhana Nandakumar

The article main chapters:

• What is change data capture?
• What is Debezium?
• Application overview
• Setting up the database
• Create an OpenShift project
• Create the MySQL configuration
• Starting the application
• Deploy AMQ Streams
• Deploy Kafka Connect

… and more. This step by step detailed tutorial and if you want to automate the provisioning of everything, feel free to take a look at an Ansible Playbook that is capable of doing this. Excellent read!