CodeIsGo.com

Gregor intro into GraphQL. The article is accompanied with video presentation. If you ever wondered what GraphQL can do for you and you know a bit of JavaScript, this is an excellent post explaining basic concepts of GraphQL.

He explains basic concepts on the example of existing RESTful API for imaginary restaurant with 2 resources and concepts like:

• Under and over fetching
• GraphQL specification
• How GraphQL API is built around a schema
• How schema serves as contract between client and server
• Persisted queries
• Mutations
• GraphQL subscriptions

Persisted queries are query strings stored with a unique ID in a key/value store. They are not part of the GraphQL specification but a common implementation detail. Good read!

Josh Lane interesting article on lambda architecture in Azure. His article focuses mainly on IoT specifics, but this design requires only a few minor tweaks to accommodate other non-IoT contexts. The concepts behind lambda architecture are straightforward and uncomplicated on their own.

Imagine we have a single logical stream of data against which we’d like to perform both just-in-time aggregation of narrow slices of the stream (“what’s the average value of X appearing in the stream over the last 15 seconds?”), as well as batch-oriented, resource-intensive queries that may require large subsets (or even all) of the data we’ve seen in the stream thus far (“what’s the average value of X across the entire stream history?”).

In his article he dives into 4 core key part of lambda:

• A logical, streaming data source
• A speed processing layer
• A batch processing layer
• A serving or presentation layer

Implementation for each layer is explained in detail. Author also describes why he wanted to use serverless architecture everywhere. You will also get access to schemes and example code accompanying this article. Excellent!

Fran Mendez article about event-driven architecture. Engineers, often forget that APIs are not just HTTP APIs. API stands for “Application Programming Interface”. It’s exactly the “Interface” where author wants to focus.

In software engineering, high-quality architectures always go hand in hand with well-defined interfaces and responsibility boundaries.

Topics and messages are first-class citizens because they precisely represent services interfaces. AsyncAPI provides a specification that allows you to define message-driven APIs in a machine-readable format.

The spec is very similar to OpenAPI/Swagger so, if you’re familiar with them, AsyncAPI should be easy for you.

Use cases:

• Documentation-first development
• API testing
• API management
• Monitoring

You will also find further resources in the article.

Daniel Westheide article in which he wants to clarify how the terms used should be understood and show that HTTP and REST for internal service communication can be perfectly fine. He also explains that choosing to do so has nothing to do with whether your services integrate synchronously or asynchronously –- and the latter question is what you should really be concerned with.

He argues, that when talking about synchronous versus asynchronous, one needs to consider:

• Async IO (callbacks, futures, streams)
• Asynchronous protocols (message passing, request-reply pattern)
• Asynchronous service integration
• Self-contained systems

In an ideal world, no communication whatsoever between your microservices should be necessary. And if it has to happen, it should be asynchronous. If you have to call other services in order to be able to serve a response to a request from a public client, this is really an architectural problem.

Author then argues that what you should really care about when designing your services is decoupling in time, which can be achieved or violated with both REST and message passing. Learn more in this interesting article.

Abhishek Tiwari article about curated list of 10 open-source Kubernetes tools for highly effective SRE and Ops Teams. If you are running workloads in Kubernetes, your site reliability engineering (SRE) and operations (Ops) teams need right kind of tooling to ensure the high-reliability of the Kubernetes cluster and workloads running in it.

Kubernetes ecosystem is observing an explosive growth. There is a large number of open source and commercial tools which you can help you to be more effective and efficient when operating missing-critical Kubernetes cluster and services.

The tools in this article focus mainly on cluster orchestration, cluster monitoring and dashboards. Among the tools he recommends you will find:

• Cabin is the native mobile dashboard app for Kubernetes
• Kube-shell is an integrated shell with auto-completion of commands, auto-suggestions, in-line documentation
• PowerfulSeal is inspired by Chaos Monkey and developed by Bloomberg engineering team
• Sysdig is container troubleshooting too
• Weave Scope is troubleshooting & monitoring tool for Docker and Kubernetes

And much more. Good selection of tools to make your life easier.

Jesper Hammarbäck article in which he argues why Kafka is not the best tool for event sourcing. Kafka is a great tool for delivering messages between producers and consumers and the optional topic durability allows you to store your messages permanently. Forever if you’d like.

The Event Sourcing pattern defines an approach to handling operations on data that’s driven by a sequence of events, each of which is recorded in an append-only store. Application code sends a series of events that imperatively describe each action that has occurred on the data to the event store, where they’re persisted.

He argues that Kafka is a great tool for event store or an event log, but it really isn’t a suitable tool for event sourcing.

His arguments are around:

• Loading current state - fast forwarding to current state is not easy in Kafka
• Consistent writes

He concludes that Kafka might be a good complement to your event store as a way of transporting events to downstream query services or read models

To learn more, read this interesting article.

Lesley Cordero article about sentiment analysis. Sentiment analysis uses computational tools to determine the emotional tone behind words. Python has a bunch of handy libraries for statistics and machine learning so in this post we’ll use Scikit-learn to learn how to add sentiment analysis to our applications.

Scikit-learn is a Python module with built-in machine learning algorithms. Author uses the Logistic Regression model, which is a linear model commonly used for classifying binary data.

Further in this article:

• Environment setup for Python 3.6
• A quick note on Jupyter
• Preparing the data
• Linear classifier using the LogisticRegression
• Note on model accuracy

You can build a classifier with less than 50 lines of Python code and no math. This is a good starting point for anybody interested in machine learning.

MIT technology review article about storing data in DNA and how this can be a lot easier than getting it back out. Humanity is creating information at an unprecedented rate—some 16 zettabytes every year (a zettabyte is one billion terabytes). Last year, the research group IDC calculated that we’ll be producing over 160 zettabytes every year by 2025.

Researchers have long known that DNA can be used for data storage. What’s impressive for computer scientists is the density of the data that DNA stores: a single gram can hold roughly a zettabyte.

Bacteria often carry genetic information in the form of tiny circular rings of double-stranded DNA called plasmids

The idea is simple:

• Store data in plasmids inside bacterial cells that are trapped in a specific location
• To retrieve send motile bacteria to this site
• Conjugate with the trapped bacteria and capture the data-carrying plasmids
• The motile bacteria carry this information to a device

But nobody has come up with a realistic system for storing data in a DNA library and then retrieving it again when it is needed. Innovation at your fingertips.

Simon Brown post on InfoQ site regarding things developers should know about software architecture. Even now, it seems that software development teams are still struggling with some of the basics, especially those aspects related to software architecture.

On the contrary, a good software architecture enables agility, helping you embrace and implement change.

Some interesting notes and recommendations:

• Software architecture isn’t about big design up front
• Every software team needs to consider software architecture
• The software architecture role is about coding, coaching and collaboration
• A good software architecture enables agility

There still exists a common misconception that “architecture” and “agile” are competing forces, there being a conflict between them. On the contrary, a good software architecture enables agility, helping you embrace and implement change. Many teams today still implement “architecture indifferent design.” In other words, they adopt an architectural style without necessarily considering the trade-offs. Good read.

Chris Down lengthy post about swap and how it is a useful tool to allow equality of reclamation of memory pages, but its purpose is frequently misunderstood, leading to its negative perception across the industry.

There are different types of memory in Linux, and each type has its own properties. Understanding the nuances of these is key to understanding why swap is important.

Article provides answers on common questions:

• What is the nature of swap
• What happens with / without swap
  • Under no / low memory contention
  • Under moderate / high memory contention
  • Under temporary spikes in memory usage
• How to go about tuning

And remember disabling swap does not prevent disk I/O from becoming a problem under memory contention, it simply shifts the disk I/O thrashing from anonymous pages to file pages. Great read!