CodeIsGo.com

Learn about AI ethics, a framework that guides data scientists and researchers to build AI systems in an ethical manner to benefit society as a whole. By @IBM.

Ethics is a set of moral principles which help us discern between right and wrong. AI ethics is a set of guidelines that advise on the design and outcomes of artificial intelligence. Human beings come with all sorts of cognitive biases, such as recency and confirmation bias, and those inherent biases are exhibited in our behaviors and subsequently, our data. Since data is the foundation for all machine learning algorithms, it’s important for us to structure experiments and algorithms with this in mind as artificial intelligence has the potential to amplify and scale these human biases at an unprecedented rate.

This article aims to provide a comprehensive market view of AI ethics in the industry today and provides following information on the subject:

• What are AI ethics?
• Establishing principles for AI ethics
• Primary concerns of AI today
• How to establish AI ethics
• Ethical AI organizations
• IBM’s point of view on AI Ethics
• AI ethics and IBM

Since ethical standards are not the primary concern of data engineers and data scientists in the private sector, a number of organizations have emerged to promote ethical conduct in the field of artificial intelligence. Good read!

Elixir is quite a flexible language, and it is possible to carry over many infrastructural patterns from other platforms like Ruby. However, by leaning on Erlang tooling, which predates many of the external infrastructural services that have become de-facto standards in modern web applications, we have the potential to boost performance and cut costs at the same time. By Eric Newbury.

Multi core concurrency platforms like the Erlang VM embrace an entirely different paradigm. The runtime boots up once on the host OS and reserves a pool of OS processes. It might not use all of them all the time—enabling the OS to prioritize other processes—but they are available to the Erlang VM whenever it needs to execute a parallel workload. From there, your application code can set up long-living BEAM processes (super lightweight abstractions that the BEAM can dynamically assign to its pool of OS processes to do work). With this paradigm, it is now feasible to run background work simultaneously with high throughput HTTP request handling.

The blog post goes on to elaborate on some of the common use cases of Redis in a tech stack and how we can use built-in services to do the same. In practice though, author has found one of the biggest barriers to letting go of Redis is the need for some kind of global state store so that your application code can horizontally scale up the number of nodes. Good read!

In this walkthrough, we are going to look at some of the Apache APISIX API Gateway built-in plugins for securing your Spring Boot REST APIs and demonstrate how to effectively use them. By Bobur Umurzokov.

APISIX API Gateway provides rich traffic management features such as load balancing, dynamic upstream, canary release, circuit breaking, authentication, observability, and more.

The article reads about:

• Overview of API Security
• The API Gateway as a gatekeeper
• How does an APISIX gateway secure your APIs
• Clone the demo repository apisix-security-java-spring from GitHub
• Understand the structure of the project and docker-compose.yaml file
• Build a multi-container APISIX via Docker CLI
• Allow only whitelisted IP address access your API with IP restriction plugin in action
• Block direct access to some API resources with Uri-blocker plugin
• Make sure that only allowed users can request your API with Consumer restriction plugin

Blog post contains also conceptual knowledge about API Security, the important role of the API gateway in handling cross-cutting concerns, and how Apache APISIX can help you to simplify and accelerate the task of securing APIs. Code examples for containers is also included. Excellent read!

There are many different ways to provide styling for React components, such as importing plain CSS, using styled components, JS-in-CSS or CSS Modules. These all have various advantages and disadvantages. In this article I go through some considerations when using CSS Modules. Specifically I am interested in looking at this in a framework agnostic way. By Max Rohde.

To me, it seems CSS Modules provide the best solution overall for beginner to intermediate use. We can use the standard CSS syntax, which allows for effective copy and paste programming, and we can be assured of good client-side performance.

The article main parts:

• CSS modules basics
• CSS modules intelliSense
• Compile CSS modules
• CSS modules for server-side rendering (Node.js)
• CSS modules for client-side bundling

The easiest way to use CSS modules is to make us of the support provided in frameworks, such as Next.js or Create React App. However, there is a lot of implicit complexity in CSS modules that can lead to unexpected behaviour and bugs. Author tried to demonstrate that we can achieve anything we need with relatively few lines of code. The three libraries I provide are all very simple and consist of a single, short source file: node-css-require, esbuild-css-modules-server-plugin, esbuild-css-modules-client-plugin. Good read!

With the boom in cloud computing, new types of security threats have emerged. Confidential computing is a solution to the added IT security issues of working with the cloud. By Daniele Buono, James Bottomley, Hubertus Franke, Robert Senger.

With Confidential computing, a third type of data needs to be protected, called data in use. This means offering mechanisms to protect the physical memory (such as RAM) being used by a customer, so that no other tenants on that cloud have any way to access it. This is generally done by hardware mechanisms that provide protection to virtual machines (VMs). It can be done either by partitioning, where the CPU places hardware checks on the memory allocated to each VM and ensures these boundaries are not crossed, or with memory encryption, where the CPU automatically encrypts VM memory with different keys for different VMs. Some operations, like IBM Z Secure Execution, offer both.

Over the last decade, cloud computing has revolutionized the way the world computes. Many companies and organizations have moved from dedicated managed servers at properties they own to flexible solutions that can scale up or down based on the amount of power and storage they need at any given moment.

It’s our belief that confidential computing will become a ubiquitously adopted mechanism to strengthen security boundaries and enable increasingly sensitive workloads to be effectively deployed on public clouds. There are, however, considerable technology gaps that need to be addressed to get there. Some of the main questions that are still unanswered are things like figuring out how to attest to the trustworthiness of components inside secure enclaves, as well as the components that manage them. Good read!

As an adept at Functional Programming (FP), I feel at ease with expressing my data manipulation logic by chaining high order functions like map, filter, and sort operating on arrays and maps. Ballerina, being designed as a Data-Oriented programming language, supports this FP style of coding. By Yehonathan Sharvit.

The main points from the article:

• Ballerina has been designed as a Data-Oriented programming language and supports a functional programming coding style
• Expressing data manipulation logic with functions can be powerful
• Using arrow functions with type inference can make code compact and clear
• Ballerina query language is similar to SQL in the sense that a query expression is made up of clauses. Data manipulation expressed with Ballerina query language is easier to read in comparison with other functional programming expressions
• Ballerina “Table” data structure can be more effective than maps in representing indexed data collections

Ballerina query language is similar to SQL in the sense that a query expression is made up of clauses, like select, from, where, order by, join, etc… But, unlike in SQL, we are not limited to SQL operators to express our custom business logic: we are allowed to use any function inside our queries. Moreover, the Ballerina query language syntax makes it very convenient to manipulate data as it deals with records. Good read!

Resiliency of applications surpasses everything else in building customer trust. Because of this, it cannot be an afterthought. Instead of simply reacting to a failure, why not be proactive?. By Piyali Kamra, Aish Gopalan, Isael Pimentel, and Aditi Sharma.

Source: https://aws.amazon.com/blogs/architecture/a-multi-dimensional-approach-helps-you-proactively-prepare-for-failures-part-1-application-layer/

As your system expands, you’ll likely encounter issues that can hinder your ability to scale, like security and cost. So, it’s necessary to think about the correct architectural patterns beforehand to minimize your chances of enduring a failure without a recovery plan.

The inetresting parts in the article:

• Example use case
• Pattern 1: Microservices
• Pattern 2: Saga pattern
• Pattern 3: Event-driven architecture
• Pattern 4: Cache pattern
• Improving application resiliency with bounded contexts

Distributed systems can use all of these patterns, which helps improve resiliency at the application layer. Applying these patterns, along with the Infrastructure and Operations improvements will provide frameworks for resilient applications. Nice one!

The moment we introduce strong coupling between our services, we lose the potential advantages of a microservice architecture. This article addresses the challenge by introducing the concept of a Change Coupling analysis. Change Coupling is a behavioral code analysis technique that uncovers logical dependencies across services and team boundaries. Let’s see it in action. By Adam Tornhill.

Source: https://codescene.com/blog/visualize-microservice-dependencies-in-team-context/

The main concepts discussed:

• Prioritize dependencies that cross team boundaries
• Introducing change coupling: uncover logical dependencies
• Automated change coupling discovery
• Adding the team dimension

Microservices is a high-discipline architecture where loose dependencies are key. Failing that, we’ll face a situation where it gets hard for a team to operate in an autonomous way. Just like we expect alerts from our production environment, we really should monitor the key architectural properties so that we can act upon dependencies early. Nice one!

In this article, we will introduce you to the big data ecosystem and the role of Apache Spark in Big data. We will also cover the Distributed database system, the backbone of big data. In today’s world, data is the fuel. Almost every electronic device collects data that is used for business purposes. By Abhishek Jaiswal.

The article also discusses Resilient Distributed Dataset (RDD) and Transformations and actions:

• What is Apache Spark?
• Apache Spark Architecture
• Spark RDDs can’t be modified only can be replaced
• Spark RDDs are lazy evaluated, which helps in data integrity and doesn’t let data corrupt
• Spark Supports distributed SQL that is built on top of RDDs
• Spark Supports various machine learning models, including CNN as well as NLPs

Spark Architecture contains a driver node, context reader, and node manager. Spark works in a distributed manner, the same as Hadoop, but alike Hadoop, it uses In-memory computation instead of disk. Good read!

Distributed systems must balance their needs for high availability and low latency with consistency guarantees; providing a mostly hit happy path for requests enables these systems to push the boundaries of this tradeoff. By Audrey Cheng.

At scale, there are three particular concerns a distributed system must address when providing a mostly hit happy path:

• Performance isolation by ensuring that clients do not affect each other
• Hotspot tolerance so that hot keys do not affect availability
• Bounding the worst-case since tail latency can slow overall user interaction. We provide examples below on how the three systems tackle these issues

Given challenging, real-world workloads, any performance degradation resulting from enforcing stronger consistency guarantees for one client should not affect others. Insulating performance effects is also crucial to protecting against misbehaving users.

Ultimately, finding the right balance between availability / latency and consistency depends on application needs. To push the limits of what can be achieved in this tradeoff, distributed systems should identify and leverage local information to provide a mostly hit happy path for requests. This approach can be especially impactful at global scale. Nice one!