CodeIsGo.com

Managing applications at scale often comes up as one of the biggest concerns for businesses; How can it work smoothly? How do we monitor so many resources? By Taavi Rehemägi.

In this article, we run through the best approach for operational excellence looking at serverless monitoring strategy, serverless alerting strategy, and security and compliance best practices.

The main points from the article:

• The serverless challenge
• Observability
• Serverless application monitoring strategy
• Serverless application alerting strategy
• Serverless security and compliance best practice

It goes without saying that operational excellence takes a lot of time and practice, especially in serverless.

Some things you can do today to get started or continue doing:

• Read the AWS Well Architected Serverless Whitepaper.
• Work with AWS solutions architects and the serverless community.
• Use third-party tools to implement best practices.

Good read!

This post is about NULL values in SQL, and comes courtesy of my friend and database wizard, Kaley. You should check out his website if you’d like to learn more about SQL, Oracle database, and making queries run faster. By Mitchum.

Whenever you issue a SQL query to a database…and you want to know whether a column has a NULL value in it…what is the proper way to write a query that will find the result?

SELECT * FROM SOME_TABLE
WHERE SOME_COLUMN IS NULL

So why on earth would we do the IS keyword with a NULL value? Why would we need to treat NULL differently? The answer is this: In SQL, NULL represents the concept of “unknown” (so a NULL value represents an “unknown” value).

In most databases, there is a difference between NULL and an empty string (represented by a “double apostrophe” or “). But this isn’t always true for all databases: For example, Oracle database won’t allow you to have an empty string. Anytime Oracle database sees an empty string, it automatically converts the empty string into a NULL value.

For the majority of the other databases out there, though, a NULL value is treated differently than an empty string:

• An empty string is treated like a known value where there is no value
• A NULL value is treated like a value that is not known

It’s important to consider a NULL value to be equivalent to an unknown value–it’s going to help you whenever you craft complex SQL queries. Good read.

Paul Done brought together a set of techniques he has identified to effectively deliver resilient yet evolvable data-driven applications.

In the talk, he identifies the resulting best practices as a set of six key principles, which he refers to as “resilient evolvability.” Below is a summary of the six principles:

• Support optional fields. Field absence conveys meaning
• For Finds, only ask for fields that are your concern, to support variability and to reduce change dependency
• For Updates, always use in-place operators, changing targeted fields only. Replacing whole documents blows away changes made by other applications
• For the rare data model Mutative Changes, adopt “Interim Duplication” to reduce delaying high priority business requirements
• Facilitate entity variance, because real-world entities do vary, especially when a business evolves and diversifies
• Only use Document Mappers if they are NOT “all or nothing,” and only if they play nicely with the other five principles

He also shared, on Github, a sample Rust application he built that highlights some of the patterns described. Nice read!

For many in the world of data science, distributed training can seem a daunting task. In addition to building and thoughtfully evaluating a high-quality ML model, you have to be aware of how to optimize your model for specific hardware and manage infrastructure. By Nikita Namjoshi.

In this tutorial-style article, you’ll get hands-on experience with GCP data science tools and train a TensorFlow model across multiple GPUs. You’ll also learn key terminology in the field of distributed training, such as data parallelism, synchronous training, and AllReduce.

The article then walks you through:

• Why distributed training?
• Single GPU training
• Multi-GPU training
• Long running jobs on the DLVM
• Take your distributed training skills to the next level

In this article you learned how to use MirroredStrategy, a synchronous data parallelism strategy, to distribute your TensorFlow training job across two GPUs on GCP. You now know the basic mechanics of how to set up your GCP environment and prepare your code, but there’s a lot more to explore in the world of distributed training. Good read!

Estimating the time-of-arrival is a common problem in a wide range of settings, e.g. in logistics. This post will show a distribution-based approach that enables us to get more insights about arrival times and how we could use this information for decision-making in the logistics industry. By Jonas Laake.

In times of Google maps the estimation of expected times of arrival has become a common thing in everyday lives. Point estimators give us a single time of arrival and we assume or at least hope, that this estimated time will be as accurate as possible.

For these use-cases more information is required to answer questions like, in which time window will our cargo arrive with a n-percent probability (quantiles), how sure are we that the goods will arrive at that day +/- n-days and so on. To answer that kind of questions we need a time-of-arrival distribution rather than a point estimator.

The article main bits:

• A little introduction to distributions
• Routing considerations and notation
• Deriving the building blocks
  • Edges (Direct leg model)
  • Nodes (Transfer model)
• Assembling the parts
• Use case scenarios
• Possible issues: Talking about data

Source: https://www.inovex.de/blog/time-of-arrival-distributions/

The framework discussed here is the base of an advanced analysis setup for time-of-arrival analysis. It can provide useful insights in the logistic setups of different kinds of companies. By leveraging or restricting assumptions and inserting business knowledge into models and routers it can be customized to serve the individual needs. Good read!

How breaking down your product backlog can help your team create great products. By Filipe Rigueiro.

Teams that have mastered Scrum know that the key to success lies in a just-in-time, increasingly refined, breakdown of work on the Product Backlog. Having smaller items on the backlog improves the flow or development, reduces risks of failing the goal of the sprint and increases velocity. In this article, I will try to highlight some useful strategies to breakdown a product backlog into bite-sized user stories.

Even when delivering smaller pieces of functionality, you are still delivering value, in small increments, and with a nice flow and rhythm. The psychological effect of delivering a finished piece of functionality works as a boost to the team, helping them perform better.

The article main partts:

• Why and when to break down items
• Breaking down in vertical slices
• Breaking using workflow steps
• Breaking down by platform
• Breaking down by operations
• Breaking down by roles
• Other Strategies

When do you know that a story is small enough? A good rule is not to aim for the shortest possible but to the most size-appropriate PBI. This depends on the sprint length and your team, it usually takes some experience and several sprints to find the most appropriate size. With the users in mind and using some smart strategies, scrum teams can create unique products and deliver real value to end-users. Good read!

Webhook backend is a popular use case for FaaS (Functions-as-a-service) platforms. Using a serverless function, it’s quite convenient to encapsulate the webhook functionality and expose it in the form of an HTTP endpoint. By Abhishek Gupta.

In this tutorial you will learn how to implement a Slack app as a serverless backend using Azure Functions and Go. You can extend the Slack platform and integrate services by implementing custom apps or workflows that have access to the full scope of the platform allowing you to build powerful experiences in Slack.

The main points of this article:

• Get an overview of Custom Handlers in Azure Functions
• Understand what’s going on behind the scenes with a brief code walk through
• Learn how to setup the solution using configure Azure Functions and Slack
• Run your Slack app in the workspace!
• What are Custom Handlers?
• Application structure
• Code walk through

You will aso get all the code in the Github repo. Now, there is nothing stopping you from using Go for your serverless functions on Azure! Great!

Serverless is definitely a trend that enables organisations to just manage what matters to them rather than the whole infrastructure to run their business. Serverless Decision Service seems to be an answer to business agility that drives the business performance as it will take the worry and efforts of how to run operational decisions away from organisations. By Arash Aghlara.

Source: https://www.flexrule.com/archives/serverless-decision-service/

The article does a good job explaining:

• Decision service and decision model
• Service management
• Core requirements
  • Versioning: Ability to model, deploy, run and manage multiple versions of a decision
  • Business Decision KPI: Ability to define KPIs for services and measure their success based on those KPIs
  • Ability to support the full business scenario
  • Ability of services to support both stateless and stateful behaviours

When the decisioning platform provides serverless capabilities, it means the activities related to managing infrastructure is done for you by host provider. If that’s a cloud service provider that means the services can simply be run by Azure Functions, AWS Lambda and other equivalent serverless platforms. Good read!

Applications author worked on in the last decade were rarely isolated from the rest of the world. Most of the time, they had many interactions with other applications out there. From time to time, some of these integrations are using WebSockets, which makes our integration realtime. By Slobodan Stojanović.

There’s a big chance that you worked with many similar integrations, such as Stripe, Slack, Github, and many others. Events are the core of the common serverless application. We use events to trigger our functions; we send them to queues and notification services, we stream them. But events are also the core of almost any application.

The article is split into these sections:

• A quest to a cleanest webhook integration
• Why AWS EventBridge
• EventBridge integration with AWS SAM
• Testing the webhook
• SAR (AWS Serverless Application Repository) application

EventBridge represents a new home for your events. We can use it to integrate with some of the third-party services or build our integrations. We can connect Amazon SNS with a few other services directly. At the moment, EventBridge supports 20 different targets, including Lambda functions, SQS, SNS, Kinesis and others. We’ll use the same event bus for multiple events, so it’s better to keep it outside of the SAR app and pass the reference to it to the SAR app.

For unsuccessful deliveries, SNS retries up to three times. EventBridge does retries out of the box for 24 hours. Both SNS and EventBridge support Lambda Destinations. EventBridge has Schema Registry for events. It supports versioning, and it has an auto-discovery and can generate code bindings.

EventBridge has Schema Registry for events. It supports versioning, and it has an auto-discovery and can generate code bindings.

Simple SAR application is provided for you in the Github repository. Good read!

For optimal runtime resource usage and millisecond startup times, though, it remains hard to beat C. Comparatively few people in the IT industry have experience implementing middleware components in C. This fact is ironic because C is an ideal vehicle for implementing truly micro microservices. By Kevin Boone.

This article discusses some of the implications of implementing a REST-based web service in C. My example is a component called solunar_ws that calculates sun and moonrise and sets times at any location on any day. Author has deliberately chosen an example that is self-contained, but which does real computational work. With 8,000-or-so lines of C code, this example is a good deal more complex than a “Hello, World.”

The main points:

• About the web service
• About the container
• Challenges
  • BusyBox
  • Alpine dependencies
  • MUSL
  • TLS issues
• Developing for an ultra-lightweight container
• Testing in a virtual machine
• Testing (and possibly developing) in a development container
• Building the production container
  • A multi-stage container build
  • The first-stage build
  • The second-stage build
• Deploying on OpenShift

… and more. However, as author pouints out, although it’s possible to create a tiny container, it isn’t necessarily advisable. . In particular, this container image has no diagnostic tools of any kind. In addition, examining a core dump from a container like this will be an unhappy experience for anyone without a development environment that perfectly matches the container’s base layer. You will also get access to GitHub repository for the complete source code. Excellent read!