CodeIsGo.com

How a team that was new to Elixir over-delivered a big project in just three months. By Sophie DeBenedetto.

Adopting a new language is more than just a technical journey. A language is only the right tool for the job if your engineers can wield it well. So, as a technical leader you don’t just select a language or a framework based on its technical capabilities and how suited it is for the problems you need to solve, you also try to optimize for the skills your team already has, for a robust ecosystem surrounding that language, for strong community support, and so much more.

This Elixir success story centers on a three month engagement with an EdTech company to deliver Flatiron School’s in-browser IDE (Interactive Development Environment) and curriculum management system into their own ecosystem. This meant that we would be porting over some existing codebases in both Ruby and Elixir, as well as building out a new Phoenix application that our partnering EdTech company would need to maintain. These applications together represented a non-trivial set of features:

The article describes the success story in these steps:

• The project
• Why we chose Elixir
• The team
• The journey
• Our secrets to Elixir success
• Elixir has a gentle learning curve
• Elixir has a robust ecosystem
• Fast and comprehensive testing in Elixir
• Easy Elixir releases
• First class observability in Elixir
• An Elixir library for all your needs
• Elixir was the right tool for the job
• Elixir makes it easy to teach and learn

… and more. Many teams and organizations reach for Elixir to solve complex technical problems well-suited for Elixir’s concurrent, fault-tolerant, and distributed nature. Very interesting read!

Recursion is a technique used to solve computer problems by creating a function that calls itself until your program achieves the desired result. By Nathan Sebhastian.

function randomUntilFive(result = 0, count = 0){
    if(result === 5){
        // base case is triggered
    }
    // recursively call the function
}

randomUntilFive();

This tutorial will help you to learn about recursion and how it compares to the more common loop:

• What is recursion?
• Why don’t you just use loop?
• How to read a recursive function
• How to write a recursive function

When reading a recursive function, you need to simulate a situation where the base case is immediately executed without executing the recursive call. Nice one!

As the healthcare industry continues to expand and adapt to new technology use, many remain skeptical about the benefits while critical of the hindrances. While these concerns are valid, it is important to understand the true implications of expanding healthcare technology, and not allow myths to deter this growth. By Heather Turnbaugh.

Here are some common healthcare technology myths, and the facts behind them:

• Myth #1: Technology takes jobs
• Myth #2: Only younger generations use digital healthcare
• Myth #3: AI outperforms clinicians
• Myth #4: EHRs have more problems than potential
• Myth #5: Technology creates higher cybersecurity threats

Because the hype and excitement surrounding new healthcare technology can contribute to exaggerations and the spread of myths, it is important to understand the exact role new technology plays in the ever-changing healthcare landscape. Good read!

Knative is a Kubernetes based tool to deploy and manage serverless workloads and this guide will look at the way how to use it. By Anaïs Urlichs, site reliability engineer.

Kubernetes is great for running stateless applications. As we are moving to the cloud and containers to manage our microservice infrastructure, our goal is to spend less time maintaining our infrastructure resources and more time to develop features and improve our application.

The guide further describes:

• Knative use cases
• Setting up Istio for traffic management
• Installing Knative Serving on Civo
• Connecting Istio and Knative
• Deploying the first version of our stateless application
• Observability in our deployments
• Updating our Deployment

To get insights into our metrics from Istio, author will show you how to install Prometheus and Grafana. Note that you are gonna use the quick installation from the Istio documentation. You will get detailed explanation of each step plus code sampled to go with it. Very good!

We can test a React Native application using Cypress end-to-end test runner while running it in the web moPersonal experience led author to share some of the things he has learned hoping that it might help other developers in a similar position. By Sam Walpole.

Every person is different, and every person’s circumstances are different. Therefore the only meaningful measure of success is against yourself. Are you a better developer than you were 6 months ago? Yes, so that sounds like success to me.

The article is split into these sections:

• Stop comparing yourself to others
• Give yourself a break
• Focus on now

We liked: … the truth is that looking at these people and having such high standards of success for yourself is only going to leave you feeling inadequate and not good enough. Nice one!

We can test a React Native application using Cypress end-to-end test runner while running it in the web mode using Expo. By Gleb Bahmutov.

If your company is evaluating using the React Native technology for developing its native mobile application, you are probably wondering how to write and run the tests. The React Native testing docs really only focus on unit testing using Jest running in Node. You cannot see what the application is doing, and if something goes wrong, good luck debugging it.

Most of the sections in this post are covered by short videos in author’s Testing React Native Application Using Cypress video playlist. Some of the videos are embedded in the relevant sections of the post:

• The initial application
• The first Cypress test
• Continuous integration
• Network control
• Test the loading indicator
• Stubbing network call
• Code coverage
• Resources
• Adding expo to react-native projects
• Expo camera
• Code examples

… and much more. You will also get link to further learning resources in the article. Good job!

Learn how to analyze time-series data through RedisTimeSeries with Apache Kafka in this practical walkthrough. RedisTimeSeries is a Redis module that brings native time-series data structure to Redis. By Abhishek Gupta.

Generally speaking, time-series data is (relatively) simple. Having said that, we need to factor in other characteristics as well: Data velocity - e.g. Think hundreds of metrics from thousands of devices per second and volume (big data): Think data accumulation over months (even years)

Thus, databases such as RedisTimeSeries are just a part of the overall solution. You also need to think about how to collect (ingest), process, and send all your data to RedisTimeSeries. What you really need is a scalable data pipeline that can act as a buffer to decouple producers and consumers. That’s where Apache Kafka comes in! In addition to the core broker, it has a rich ecosystem of components, including Kafka Connect (which is a part of the solution architecture presented in this blog post), client libraries in multiple languages, Kafka Streams, Mirror Maker, etc.

The article also deals with:

• Scenario: Device monitoring
• Solution architecture
• Set up the infrastructure components
• Setup local services
• Deploy the device data processor application
• Start simulated device data generator
• Delete resources
• What about long term data retention?

Your time-series data volumes can only move one way—up! It’s critical for your solution to be scalable. Very nice!

Data without context is meaningless. We want every dossier, page, and visualization to tell a story. By Keng Fu Chu.

A great story usually progresses towards a central message, and so should your dossier. In this article, you will learn how to incorporate storytelling to deliver insights to your end users, as well as how to use dossier features to build a narrative dossier.

Further in the article:

• Creating stunning infographic-style dossiers with vertical scrolling pages
• Freeform Layout - Blending data into your design, not the other way around
• Responsive group and form-factor show/hide — Tailoring the mobile consumption experience
• Enable authors to create information - rich dossiers with panel stack
• Create data-oriented design with Visualization Gallery, Rich Text, Shapes, and more

Unlike data visualization, storytelling with data enables authors to offer a more narrative, emotional, and holistic view of their information. It has never been easier for analysts, designers, or data scientists to engage in data storytelling. Recommended for anybody interested in the UX and UI.

A very popular stack for building responsive web apps is Tailwind CSS and Next.js by Vercel. By Max Lynch.

Tailwind, a utility-first CSS framework that replaces the need to write custom class names or even any CSS at all in many cases, makes it easy to design responsive web apps through small CSS building blocks and a flexible design foundation.

Next.js, a React framework for building high performance React apps, is one of the leading environments for building production React apps on the web.

The article then describes:

• The stack visualized
• Mobile UI and native runtime
• Introducing the Next.js + Tailwind CSS + Ionic Framework + Capacitor Starter
• Deploying to iOS and Android

If you’ve been interested in building mobile apps using popular web dev projects like Next.js or Tailwind, hopefully this starter provides inspiration and a solid foundation for building your next app using web technologies. Good read!

The benefits of multi-model serving where latency matters. By By Alejandro Lince and Steven Ross.

Machine Learning (ML) inference, defined as the process of deploying a trained model and serving live queries with it, is an essential component of many deployed ML systems and is often a significant portion of their total cost. Costs can grow even more uncontrollably when considering hardware accelerators such as GPUs.

Many modern user-focused applications critically depend on ML to substantially improve the user experience (by providing recommendations or filling in text, for example). Accelerators such as GPUs allow for even more complex models to still run with reasonable latencies, but come at a cost.

The article then deals with:

• Benefits of multi-model serving
• Analyzing single versus multi-model serving latency
• Costs Versus Latency

Multi-model serving enables lower cost while maintaining high availability and acceptable latency, by better using the RAM capacity of large VMs. While it is common and simple to deploy only one model per server, instead load a large number of models on a large VM that offers low latency, which should offer acceptable latency at a lower cost. These cost savings also apply to serving on accelerators such as GPUs. Good read!