CodeIsGo.com

It’s a common requirement: persisting NgRx state in order to load it back up when your Angular application is restarted. This process of populating an empty object with domain data is called re-hydration. While it’s common to persist the store data to the browser storage (mostly localStorage), you might also re-hydrate from a server-side cache. By Nils Mehlhorn.

There are some pitfalls to watch out for when applying this pattern. For one thing, you should take care not to store sensitive data in potentially insecure storages. Consider factors such as multiple users working on the same machine. Additionally, the state you’re storing can become outdated. Consequently, you might incorporate techniques like validation and partial re-hydration.

The article pays attention to:

• Persist with Redux DevTools
• Re-Hydration Meta-Reducer
• Re-Hydration Meta-Reducer + Effects

You will find detailed code examples for each of the discussed topics. The only disadvantage To learn about advantages and disadvantages of re-hydration follow the link to full article. Nice one!

Curious how to containerize your Linux applications? Learn by example, and understand the challenges of various application types and how to overcome them. By Scott McCarty (Red Hat, Sudoer).

Author’s admission how he just couldn’t find time to convert his personal Linux services. So don’t feel bad if you are still staring, longingly, from afar, at other people’s fancy containerized services, as author has only recently gotten over the hump himself.

He wants to share his technical solution and break down his conscious design decisions. He hopes it will help you move your own services into containers. The goal is to give you some solid, concise, and technical guidance.

The author will deal with the three services: WordPress, MediaWiki, Request Tracker.

The article describes the process, how to consider one of industry accepted methodologies (Lift & Shift, Refactor, Rewrite), how to analyze architecture, security, and performance. You will get the links to further reading. Really good!

In recent years, stateless middle-tiers have been touted as a simple way to achieve horizontal scalability. But the rise of microservices has pushed the limits of the stateless architectural pattern, causing developers to look for alternatives. By James Ward, Developer Advocate at Google Cloud and Viktor Klang, Head of Cloud Engineering and Deputy CTO at Lightbend.

Stateless middle-tiers have been a preferred architectural pattern because they helped with horizontal scaling by alleviating the need for server affinity (aka sticky sessions). The stateless model pushed all “state” out of the middle-tier into backing data stores. In reality the stateless pattern just moved complexity and bottlenecks to that backing data tier.

New patterns are now emerging which fundamentally change how we compose a system from many services running on many machines. One approach, is to build an event-driven system that co-locates partitioned data in the application tier, while backing the event log in a durable external store. To take the fraud detection example, this means a consumer can receive transactions for a given customer, keep those transactions in memory for as long as needed, and perform real-time analysis without having to perform an external query. Each consumer instance receives a subset of commands.

Source: https://cloud.google.com/blog/topics/developers-practitioners/stateful-serverless-on-google-cloud-with-cloudstate-and-akka-serverless

By separating commands and queries we can easily achieve end-to-end horizontal scaling, fault tolerance, and microservice decoupling. The new Cloudstate open-source project attempts to enable building more approachable programming and operational models. Cloudstate’s programming model is built on top of protocol buffers (protobufs) which enable evolvable data schemas and generated service interaction stubs. When it comes to data schemas, protobufs allow you to add fields to event / message objects without breaking systems that are still using older versions of those objects.

You will also get video that walks through the full fraud detection sample and find the source for the sample on GitHub. Exciting!

In Akka, ask is a pattern and involves Actors as well as Futures. Ask is used to sends a message asynchronously and it returns a Future which represents a possible reply. If the actor does not reply and complete the future, it will expire after the timeout period. After the timeout period, it throws a TimeoutException. By Purva Agrawal.

This is short and straight to the point article reading about:

• Communication among Actors
• What is Ask pattern?
• Using the Ask pattern
• Combining Ask and PipeTo patterns
• Ask pattern: Do’s and Don’ts

In Akka, actors communicate with each other by sending and receiving messages. The messages can be sent in many patterns like: Fire and Forget, Request and Response. Good read!

Some of the most interesting projects I worked on at LinkedIn involved building large scale real-time pricing and machine learning products. They required crafting fault-tolerant distributed data architectures to support model training, forecasting and dynamic control systems. By Luthfur Chowdhury.

None of this work involved a traditional relational database. Instead event streams, derived data and stream processing became the core building blocks.

The author worked with teams which built entire multi-billion dollar products on top of these architectures. The experience gave hom a new perspective on how organizations can think about their data infrastructure in terms of data flows.

The article deals with:

• Logs and Event Streams
• Loose Coupling of Systems
• Unbundling the Database
• Data Integrity and Fault Tolerance
• Data Quality, Integrity and Security

Log based data integration promises to improve data availability across the breadth of an organization. It creates the ability to democratize data access and analysis. With stream processing systems we are able to work with continuous flow of data in real-time using composable components. The links to further reading is provided. Nice one!

Data storage has always been a key tenet of compute, and with the massive growth in cloud compute, the demand for cloud data storage has opened an avenue for both revisiting prior technologies and developing new ones. It is projected that around 125 zettabytes of data will be generated annually by 2024, and storing this in a cost-effective way is going to be a big challenge. By Benn Thomsen , Senior Principal Researcher Dushyanth Narayanan , Senior Principal Researcher Ant Rowstron , Distinguished Engineer / Deputy Lab Director.

The cloud has also changed the way we think about compute and storage. In the cloud, services are virtualized. In cloud data storage, for example, customers pay for storage capacity and access rate rather than for physical storage devices.

The massive growth we see in the cloud today has been largely powered by advances in integrated electronics. Looking forward, however, these advances are stalling.

In the article you will find more information on:

• How does holographic storage work?
• So why revisit holographic storage as a solution for the cloud?
• Bringing holographic storage to the present with commodity hardware and deep learning
• Looking forward: Scaling up optical storage solutions for the cloud

It is exciting to see how the team has exploited machine learning on high resolution images to do in software what previously required expensive optics or could not be done at all, pushing the holographic storage performance beyond the state of the art. Great!

This documentation will help identify the trade-offs of the different React patterns and when each pattern would be most appropriate. The following patterns will allow for more useful and reusable code by adhering to design principles like separation of concern, DRY, and code reuse. By Alexi Taylor.

Some of these patterns will help with problems that arise in large React applications such as prop drilling or managing state

By utilizing React’s Context API we can create a data provider component that deals with fetching data and providing the shared state to the entire component tree. This way, multiple child components, regardless of how deeply nested, can access the same data. Fetching data and showing data are two separate concerns.

The content is split into:

• Compound components
• Flexible compound components
• Provider pattern

You will get many examples with thorough explanation. Each major pattern includes an example hosted on CodeSandBox. Very good!

Ever wished you could just use typescript to write your infrastructure? You may or may not have heard about the release of the terraform cdk (short for cloud development kit). By Julian Krispel-Samsel.

CDK (Cloud Development Kit) for Terraform allows developers to use familiar programming languages to define cloud infrastructure and provision it through HashiCorp Terraform.

The article then describes how:

• To generate the boilerplate
• Adding a provider package and importing modules from it
• Adding a lambda function to our stack
• Deploying your stack

The article prvides step by step instruction for deploying serverless lambda function to AWS, including IAM Role configuration. cdktf compiles your javascript/typescript modules into terraforms alternative JSON configuration syntax. This is an extremely powerful feature of terraform’s design since it can be a compile target not just for javascript and typescript, but any kind of language. How exciting!

Dynamic Application Security Testing (DAST) also called Black Box Testing is a testing practice that will test the application by executing your web application. As we know, In SAST, a Web application will be tested inside the application which doesn’t even require that the application should be running. By Prabhu Vignesh Kumar Rajagopal.

A Typical DAST process is really a complex and lengthy process that will require a lot of manual interference. Those lengthy manual processes are not completely feasible to integrate with Jenkins to see the automated Security scan. So, we are going to perform only ZAP Baseline scan in this tutorial.

The content of the article';

• Approach to DAST
• Setting up Jenkinsfile
• Configuration and Progress file

Since this tutorial is about the ZAP Baseline scan, author is using the Docker image for the OWASP ZAP proxy and perform the Dynamic Analysis on our python application. You will also get the links to further reading and previous articles on the topic. Well done!

Which is better, Rust or Go? Which language should you choose for your next project, and why? How do the two compare in areas like performance, simplicity, safety, features, scale, and concurrency? By John Arundel.

First, it’s really important to say that both Go and Rust are absolutely excellent programming languages. They’re modern, powerful, widely-adopted, and offer excellent performance.

Go provides a lightweight alternative: goroutines. Each goroutine is an independently executing Go function, which the Go scheduler will map to one of the OS threads under its control. This means that the scheduler can very efficiently manage a large number of concurrent goroutines, using only a limited number of OS threads.

The article content is split into:

• Rust and Go are both awesome
• The similarities
• Performance
• Simplicity
• Features
• Concurrency
• Safety
• Scale
• The differences

We’ve said that both Go and Rust produce extremely fast programs because they’re compiled to native machine code, without having to go through an interpreter or virtual machine. However, Rust’s performance is particularly outstanding. Rust allows you to create complex abstractions without paying a performance penalty at run-time. Good read!