Minidev News

Serverless computing is an emerging technological advancement in IT infrastructure that effectively automate its operations and provide more efficiency. Despite its popularity, the term “serverless” still lacks a cohesive definition and is often not understood completely when compared to other established IT services such as Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS), and Software-as-a-Service (SaaS) clouds. Hence, this article aims to dissect the nuances of serverless computing and provide a comprehensive understanding of its applications and future prospects.

What is Serverless Computing?

A comparison of IT services and moving homes
The term serverless computing is often used to describe a situation where the development and running of cloud applications do not require server management. However, such phrasing leaves much room for interpretation, thereby leading to misunderstanding and confusion. This article attempts to provide a concrete and precise definition of serverless computing, tracing its historical evolution and discussing its practical applications.

Dissecting Serverless Computing

Popular definitions of serverless computing
There are several definitions of serverless computing, but they do not provide a unanimous agreement. These existing definitions fail to encapsulate the central aspects of this new technology in a clear, unambiguous manner. To address this issue, we propose a refined definition of serverless computing, characterized by cloud computing platforms that allow applications to run without allocating and managing servers and resources. It also offloads responsibility for operational aspects such as fault tolerance or elastic scaling of resources to the cloud provider.

The Evolution Towards Serverless Computing

Sixty years of technological evolution toward serverless computing
Dating back to the 1950s, the process of computing has come a long way, from mainframe virtualization in the 1960s through grid and cloud computing to serverless computing today. Severless computing is a high-level, applicable term that can be applied at many levels, including functions, containers, middleware, and backend services.

Future of Serverless Computing: Outlook and Challenges

Despite the benefits and growing adoption of serverless computing, it also faces a range of challenges, including performance, security, programming and applications. Moreover, the increasing diversity of serverless offerings and blurry boundaries between different cloud service models further necessitates clear understanding of the concept.

Conclusion

A depiction of the potential of serverless computing
The notion of serverless computing is undergoing various transformations. The critical emphasis of cloud platforms continues to shift towards automation, fine-grained resource usage, and focus on operational aspects of the cloud service, thereby gradually metamorphosing the landscape of cloud computing.

#serverless #computing #cloud #technology #IT-infrastructure
Reference Link

As we witness the continual rise of serverless technologies, it’s worth noting the highlights that stand out from the year as seen in key surveys. The technology remains at the forefront with the rapid adoption of cloud platforms and services by organizations across industries and sizes.

The Upswing of Serverless Adoption

In an annual survey by CNCF, a clear paradigm shift towards serverless computing has been noted over the years. Paradigm shifts in tech, as history has shown us with Functional Programming (FP) and NoSQL databases, are not easy and usually take longer than expected to penetrate mainstream thinking. However, the adoption of serverless technologies is indeed visible and gaining momentum.

As seen in Datadog’s survey, Node.js, and Python continue to be the dominant languages for AWS Lambda, the most common type of serverless workload. An increase in using Java has been observed owing to enterprise organizations finally moving towards serverless technologies.

Customer Trends and Serverless

Datadog’s customer trends reflect a diverse use of different cloud platforms and services. However, it’s important to note a certain bias in the results, resulting from the source of the data, which is largely from Datadog’s customer base. Despite being quite extensive, it can’t function as a perfect representation of the entire global market.

When looking at serverless adoption, Datadog’s focus extends beyond serverless functions to include managed container applications and edge functions. On AWS, for instance, an organization is considered serverless if it has adopted Lambda, App Runner, Fargate, or CloudFront Functions.

Looking Ahead

Despite seeming like old news to some industry observers, the continual normalization and standardization of serverless are noteworthy trends. For larger organizations using AWS Lambda, Terraform is leading the way, mainly due to their hybrid workloads. Interestingly, Frontend development is spearheading the creation of new serverless platforms, further highlighting the need for cloud providers to improve their DX for these services.

In conclusion, the momentum that serverless technologies have gained signals a shift in the industry. As more companies adopt these technologies, it will be intriguing to monitor how the serverless landscape evolves.

About the Author:

Renato Losio is a seasoned cloud architect and tech lead with specialization in cloud services and relational databases. Presently, he splits his time between Berlin and Trieste, while working remotely as a principal cloud architect. He also contributes as an editor at InfoQ and is an AWS Data Hero. You can find him on LinkedIn.

Tags

#Serverless #AWSLambda #CloudComputing #TechnologyTrends

Reference Link

In this guide, we will delve into the world of snapshot testing in React Native going through, first, an overview of the Jest framework and then, how snapshot testing can be incorporated in your React Native application.

Using Jest for Testing in React Native

Jest is a very common testing library when it comes to React and React-Native due to its simplicity and the integrated snapshot testing feature. In order to initialize jest in your project, you can use react-native init. This will setup your test script and jest preset in your package.json as seen below.

{
  "scripts": {
    "test": "jest"
  },
  "jest": {
    "preset": "react-native"
  }
}

To test if Jest has been correctly set up, simply run yarn test. Jest should run and pass without any tests.

Snapshot Testing in Action

Snapshot tests are a very useful characteristic when you want to make sure your UI does not change unexpectedly. A snapshot test will capture a snapshot of your component and compares it to a reference snapshot file stored alongside your tests. Let’s illustrate this with a Intro component.

import React, {Component} from 'react';
import {StyleSheet, Text, View} from 'react-native';

class Intro extends Component{
  render(){
    return(
      <View style={styles.container}>
          <Text style={styles.welcome}> Welcome to React Native!</Text>
          <Text style={styles.instructions}>This is a React Native snapshot test.</Text>
      </View>
    );
  }
}

const styles = StyleSheet.create({
  container: {
    alignItems: 'center',
    backgroundColor: '#F5FCFF',
    flex: 1,
    justifyContent: 'center',
  },
  instructions: {
    color: '#333333',
    marginBottom: 5,
    textAlign: 'center',
  },
  welcome: {
    fontSize: 20,
    margin: 10,
    textAlign: 'center',
  },
});

export default Intro;

To create the snapshot for this component, we will make use of React’s test renderer and Jest’s snapshot feature. We will build a generic test that will render our component and compare it with the snapshot.

import React from 'react';
import renderer from 'react-test-renderer';
import Intro from '../Intro';

test('renders correctly', () => {
    const tree = renderer.create(<Intro/>).toJSON();
    expect(tree).toMatchSnapshot();
});

We run this test with yarn test. Jest will then create a snapshot file which records the current state of the component. The snapshot file would look like something as below.

exports[`Intro renders correctly 1`] = `
<View style={ { "alignItems": "center", "backgroundColor": "#F5FCFF", "flex": 1, "justifyContent": "center", }}>
  <Text style={ { "fontSize": 20, "margin": 10, "textAlign": "center", }}>Welcome to React Native!</Text>
  <Text style={ { "color": "#333333", "marginBottom": 5, "textAlign": "center", }}>This is a React Native snapshot test.</Text>
</View>
`;

Congratulations! You have now created your first snapshot test. Every subsequent run of the test will compare the rendered output with this snapshot. If the output is different, the test will fail.

To update the snapshot, you can use the -u flag as jest -u.

Conclusion

In this guide, we took a dive into snapshot testing in React Native with Jest. Snapshot tests provide a great way to ensure your UI does not change unexpectedly, further ensuring the stability of your application.

However, snapshot testing does not replace good old unit testing. These tests should be seen as an additional layer to validate your application’s UI logic.

Tags

react-native, jest, snapshot-testing, react-component

Reference Link