7 Innovative AI Test Automation Tools for the Future: The Third Wave

When I look back at my career in test automation, there are three distinct periods, or “waves” that come to mind.

Test Automation: First Wave

The first wave is filled with some good old-fashioned vendor tools like WinRunner, Silk Test, and QTP. In my eyes, these solutions started it all and set the stage for future testing automation innovations like Selenium.

Test Automation: Second Wave

Selenium began the second wave of test automation, focusing more on developers and programming best practices when creating automated tests.

But truth be told–in the quiet times when they think no one is listening–you can hear testers whispering the same curses they did about vendor tools: flaky tests and maintenance driving them crazy.

The current buzz these days is around AI and Machine Learning. Companies are rushing to create tools they can pitch as “AI-driven.” In fact, at a recent Google conference CEO Sundar Pichaiopened the event by stating that “We’re moving from a mobile-first to an AI-first world.”

We’re moving from a mobile-first to an #AI first world~Sundar Pichai

Click to tweet

Here are seven newer “AI”-based tools that I think will take us to the next stage of test automation–the Third Wave. (Also, check out the Automation Guild Online conference for some awesome sessions we will have on AI test automation. You'll also get a chance to ask question to many of  the vendors mentioned in this article)

Test Automation: Third Wave Tools

Here are just a few of the “third wave” automation tools I’ve seen in the market. One of the main features of this software is that many of them are leveraging machine learning and AI-assisted technology.

• Applitools
• SauceLabs
• Testim
• Sealights
• Test.AI
• Mabl
• ReTest

To learn more about these solutions, be sure to check out the Automation Guild 2018 online conference, where many experts from these vendors will be joining us for an epic event of automation awesomeness.

Applitools

Applitools was one of the first tools in the third wave that I got my hands on, and it made me start believing that a new way of testing was possible.

When I first heard about visual validation testing, which uses a sophisticated algorithm to out potential bugs in your application without you explicitly calling out all the elements, I thought it must be B.S.

After speaking with founder Adam Carmi, however, and checking out Applitools for myself, I became a believer.

I discovered there really are no visual processing settings, percentages or configurations that need to be set up to create visual testing with Applitools.

The algorithm is entirely adaptive, and I can only imagine where they’ll take the technology as AI and machine learning advances even further.

I recently saw an Applitools demo, and on their roadmap were some cool features they plan on adding on top of their existing machine-learning technology.

Possible AI Type Features:

• Leveraging ML/AI-based for automated maintenance (being able to group together similar groups of changes from different pages/browsers/devices)
• Modifying their comparison algorithms to be able to discern what changes are meaningful/noticeable
• Being able to automatically understand which changes are more likely to be bugs vs. desired changes and prioritize diffs

A lot of these things are too early to see in action, but looking at the roadmap will give you a sense of how much AI is now being incorporated into test tool company’s roadmaps.

Sauce Labs

Of course, Sauce Labs were one of the first players in the cloud-based test automation space, but with all the data they currently have access to they’re in a great position to leverage machine learning and come up with some cool insights.

That was one of the points that came up during the 2017 SauceCon conference. During the keynote, CEO Charles Ramsey displayed a slide that showed how we've gone from mainframe all the way to iOT, as well as things like artificial intelligence, machine learning, and deep learning.

It’s obvious that Charles believes the use of known pattern matching and different AI technologies can be powerful within testing.

Which got me thinking — with Sauce Labs running over a million and a half tests a day, they have a virtual treasure trove of data that can be used to help their customers become better testers.

I definitely foresee Sauce adding more intelligence into their analytics that will proactively help customers improve their test automation.

Testim

Testim tries to leverage machine learning to speed up the authoring, execution and most importantly the maintenance of automated tests. Their goal is to help you to start trusting your tests.

Testim focuses on reducing your flaky tests and test maintenance, which they see as one of the most significant challenges for most organizations.

Oren Rubin, co-founder of Testim, mentioned in a recent TestTalks interview that the firm’s main goal is to help liberate test automation from the exclusive realm of developers and make it simple enough for anyone on the team to create. After speaking with Oren I got a sense that Testim is well on its way to achieving that goal.

Sealights

Sealights is a Cloud-based platform. We all know that developers and QA–both managers and engineers–are super busy these days using CI and CD practices, where they have frequent releases and not enough time to test the entire application multiple times.

That’s one of the main reasons Sealights was created.

With their machine learning-like technology that analyzes both your code and the tests that run against it, it lets you know exactly what your tests are covering and what they're not. But when Sealights says “tests,” they don't only mean unit tests; they mean any kind of test, from functional, manual, performance, you name it.

“Quality Risks” is even a more exciting insight they provide, as it focuses the user's efforts on the things that matter, by letting him or her know exactly which files/methods/lines have changed in the last build that wasn't tested by a specific test type (or any test type). Once you know that, you can easily ensure that untested code will not reach production before undergoing, at the very least, a minimal validation.

As we move toward CI/CD, dashboarding becomes critical.

If you're like most companies, everything today is within your CI/CD, but often this data is not visible or accessible for consumption by your teams.

Sealights makes it easy to create a quality dashboard that everyone will see. So for every build, you’ll be able to understand what was tested, what the status and coverage were, and whether it’s improving, decreasing, or has quality holes or not.

Test.AI

Test.AI is billed as a tool that will add an AI brain to Selenium and Appium. It was created by Jason Arbon, co-author of How Google Tests Software and the founder of appdiff. Tests are defined in a simple format similar to the BDD syntax of Cucumber, so it requires no code and no need to mess with element identifiers.

The AI identifies screens and elements dynamically in any app and automatically drives your application to execute test cases.

It’s smart enough to know that if an element ever changes it can adjust and identify it with you having to make any manual changes. This tool is still in beta, but I was given a sneak peek of it by Jason.

I’m excited to learn more about it, as well as the potential of all these test tools.

Mabl

Mabl is similar to Test.AI. Mabl started by a bunch of ex-Google employess runs functional tests against your apps or website. In Mabl terminology, you “train” your tests to interact with your applications. When you’re done recording, your trained tests will run at a predetermined amount of time and alert you.

Their website makes three main promises:

1. Eliminates flaky tests–like the other AI-based test automation tools, Mabl can automatically detect whether elements of your application have changed, and dynamically updates the tests to compensate for those changes.
2. Mabl can continuously compare test results to test history to quickly detect changes and regressions, resulting in more stable releases.
3. Mabl helps identify and surface problems quickly, alerting you to possible impacts before they impact your customers.

ReTest

Use an artificially intelligent monkey to fully automatically test your application. That’s how ReTest markets itself.

ReTest claims to be different from other test automation tools because it was built specifically with testers in mind.

It also stems from an artificial intelligence research project, so it tries to bake that AI intelligence into their tool, effectively eliminating the need for their users to possess any programming skills.

They, like some of the other tools on this list, also avoid having to select element IDs to work with when creating a script. ReTest also automatically takes care of wait times.

If you want to try out ReTest, they offer an excellent step-by-step demo post.

So is AI/Machine Learning Just Hype?

Clearly, AI/Machine Learning is the latest buzz word currently being used in the testing industry. But is it real, or just hype?

Only time will tell if the third wave will finally fulfill the promise of reliable, easy-to-maintain test automation for all.

R, Python or SAS: Which one should you learn first?

Python, R and SAS are the three most popular languages in data science. If you are new to the world of data science and aren’t experienced in either of these languages, it makes sense to be unsure of whether to learn R, SAS or Python.

Don’t fret, by the time you’re done reading this article, you will know without a doubt which language is the right one for you.

R - R is the lingua franca of statistics. It is a free and open source programming language used to perform advanced data analysis tasks.

Python –Python is a multi-purpose, free and open source programming language which has become very popular in data science due to its active community and data mining libraries.

SAS – SAS has been the undisputed market leader in the enterprise analytics space. It offers a huge array of statistical functions, has a good GUI for people to learn quickly and provides brilliant technical support.

If you are looking to start a career in data science or to gain the skills to be able to transition to this field in the future. Then you are probably doing some research on which of these three programming languages you should learn first to maximize your chances of landing your dream job. Should you focus on mastering R? Or would be it better to make SAS a priority? Or should you learn Python?

Take a look at these 5 factors as a starting point to help you decide:

Industries where the tool is used

Burtch Works,HR firm, asked over 1000 quantitative professionals which language they preferred, SAS, R or Python. Here are the survey results:

SAS is largely preferred by big corporations because they are offered highly reputed customer service, which is also why SAS has an advantage in the financial services sector and marketing companies, where cost is not the primary concern for selecting a tool.

R and Python, on the other hand, are used by Startups and mid-sized firms. Tech and Telecom companies require huge volumes of unstructured data to be analyzed, and hence data scientists use machine learning techniques for which R and Python are more suitable.

SAS is an expensive commercial software and is mostly used by large corporations with huge budgets.

Python and R are free software that can be downloaded by anyone.

You don’t require prior knowledge in programming to learn SAS, and its easy-to-use GUI makes it the easiest to learn of all the three.  The ability to parse SQL codes, combined with macros and other native packages make learning SAS child’s play for professionals with basic SQL knowledge.

To analyze data in Python, you will use data mining libraries like Pandas, Numpy, and Scipy. In other words, you won’t code in native Python language when analyzing data. The code you write in these libraries looks somewhat similar to the code you write in R. Hence, it is easier to learn R when you are already familiar with the Python data mining libraries. If you already know R, then you should learn the basics of Python programming language before you start to learn the Python data mining ecosystem.

So, don’t think that R is difficult, and Python is easy to learn!

Data Science capabilities

SAS is extremely efficient at sequential data access, and database access through SQL is well integrated. The drag-and-drop interface makes it easy for you to create better statistical models quickly.  It has decent functional graphical capabilities, but it’s difficult to create complex graphical plots in SAS.

R is known for In-memory analytics and is mainly used when the data analysis tasks require a standalone server. R is an excellent tool for exploring data. Currently, R has more than 5000 community contributed packages in CRAN. The wide range of packages and modules available for statistics and data analysis makes it the most popular and powerful language in data science.  Statistical models can be written in a few lines of code.

You can draw complicated graphs beautifully in R using packages like Ggplot2, lattice, rCharts, etc.

Python libraries like Pandas, Numpy, Scipy and Scikit-learn makes it the second most popular programming language in data science after R. You can also create beautiful charts and graphs using libraries like Matlplotlib and Seaborn.  Python is actively used by the machine learning community to scrap and analyze unstructured data from the web.

I Python notebook – a web-based interactive environment – makes it easier to share your code with anther.

Community Support

SAS has an active online community moderated by community managers. These communities have evolved from peer to peer forums to become publishing platforms for essential content. You can ask queries related to SAS, and the community will answer them. The official blog of SAS is also an essential resource to refer to when you need help with a particular problem.

R has 125 active user groups worldwide, and the number of user group meetings has increased by a significant amount in the last year.  Python has 1,657 user groups, its communities strictly focused on data is much less when compared to R.

R and Python have huge online community support from Stackover flow, mailing lists, user-contributed code and documentation.

SAS doesn’t have an active open source community at all.

Job Scenario

SAS has more than 80,000 customers around the globe, and most of them are corporates with huge budgets. Analysts in these organizations use SAS to quickly and efficiently execute a wide range of statistical models on data sets. That is why the tile “analyst” is often mentioned in SAS job descriptions.

On the other hand, R and Python are used by startups and technology companies. R is more inclined towards tasks related to statistics and data analysis because of which R related jobs have mentions like “ Data miner”, “ Statistician” , “ Data analytics manager”, etc.

Learn R programming from Edvancer.

Meanwhile, given the boom in big data — projected by Ovum to grow 50 percent by 2019 on an already large base — you can expect increasing numbers of business analysts and other nonprogrammers to arm themselves with the R language as well.

Whereas, Python is used by programmers that want to delve into data analysis or apply statistical techniques, and by developers that turn to data science. Python related jobs have mentions like “Machine learning engineer”, “ Data engineer”, “ Big data architect”, etc.

Conclusion

If your goal is to become a business analytics professional and you are planning to join a startup, then you should learn R first. On the other hand, if you want to join a bank or pharma company you should start with SAS and then learn R once you are comfortable with SAS. If you are looking to become a big data professional, then you need to learn either R or Python. This depends on your background as well. If you come from a statistics/ mathematics background then you should learn R; If you have a programming background, then you should learn Python.

That ought to clear it up!

5 Quick Resources for Mastering CSS Grid Layout

In today’s quick tip I’ll show you five resources for mastering CSS Grid Layout. Let’s dive in!

A Quick Introduction to Grid

Grid Layout is arguably one of the most significant developments for web developers since the birth of CSS. It’s a layout system specifically for use with grid-based user interfaces, meaning that the standard “float” approach (something of a hack, let’s be honest) is no longer needed as a primary means of laying out a web page.

The first Working Draft was published in 2011, and, believe it or not, we have Microsoft to thank for much of its development; three of the initial four authors were part of the Microsoft team. That initial version is outdated now, having since been replaced by CSS Grid Layout Module Level 1.

5 Handy Resources

Browser support for Grid is already very promising, so it’s high time you became familiar with the syntax. Here are some great resources to kick you off.

Mozilla: Introduction to CSS Grid Layout

The first example comes from Mozilla. It’s introduction to CSS Grid Layout covers the basics, but also advanced concepts such as naming lines. It’s a thorough resource, but also beautifully presented with clear navigation, attractive graphics, and pens you can fork and play with.

learncssgrid.com

Another thorough resource is learncssgrid.com by Jonathan Suh. It explains the theory behind the syntax, whilst also showing examples of some of the most common layout patterns you might need.

CSS Tricks: A Complete Guide to Grid

Next up we head over to CSS Tricks for a great resource by Chris House (in the video I mistakenly credited Chris Coyier, apologies for that). The “Complete Guide to Grid” is exactly what you’d expect; very complete. It details properties for grid container and grid items in separate columns. Awesome work, as usual, from CSS Tricks.

Grid by Example

“Grid by Example” is developed and maintained by Rachel Andrew (herself a member of the working group for CSS Grid Layout) and has been around for quite some time. Besides the “get started guide”, which gives you all the essential information about the spec, it gives you lots of examples and “grab and go” patterns for the most common layouts.

CSS Grid Courses on Envato Tuts+

If you prefer learning by video, I strongly recommend (obviously!) you take a look at these courses by Craig Campbell. The first (3 CSS Grid Projects for Web Designers) walks you through three CSS Grid projects, with examples on Codepen for you to fork and practice on.

3 CSS Grid Projects for Web Designers

Craig’s most recent course (Bringing CSS Grid Layout and Flexbox Together) explains how you can use two of CSS’s most powerful layout modules (Grid and Flexbox) together.

Bringing CSS Grid Layout and Flexbox Together

Go Forth and Learn!

This quick roundup gives you a great start for learning CSS Grid. All the resources here include practical examples which you can use to dig in and reinforce the theory. I’ll leave you with a few more tutorials, but until next time–happy learning!

How to build a Progressive Web App

Convert any web application to a PWA by following these steps.

Mobile now accounts for over half the web's traffic, and web applications enable users to do things in the browser that rival native apps, but there's a problem: the quality of connections and devices varies massively all over the world. 

Catering both to users on lightning-fast connections in Seoul, and users in rural India on an outdated phone, is the latest usability challenge, and Progressive Web Apps are the solution.

PWAs use progressive enhancement to load the most important content first, then add presentational and functional extras as required, meaning that all your users get the same core experience as quickly as possible. If you want to reach the widest possible audience, PWAs are the way to go.

Though Progressive Web Apps bring a lot of benefits and functionality to the web, they don't require rewriting your entire application. Any app can be converted to a PWA by adding a few extra layers to it. 

For best results, you'll want to put a strong emphasis on performance from the beginning — but that's true of any web app. Here, we'll walk through the steps to make your app progressive.

01. Serve over HTTPS

Let's be honest: you should be doing this anyway. SSL adds an extra layer of security to the web, helping your users feel secure in using your site. With PWAs, HTTPS is essential for using service workers and allowing home screen installation. You can purchase an SSL certificate from your domain registrar at little expense and then configure it through your hosting service.

02. Create an application shell

Your app shell is the first thing that loads — the first thing the user sees. It should be exist entirely in your index HTML document, with inline CSS, to ensure it appears as fast as possible and your user isn't staring at a white screen for longer than necessary. The application shell forms part of the pattern of progressive enhancement. Your app should give the user content as soon as possible, and then progressively enhance it as more data (likely JavaScript) loads. 

The example below is taken from a React.js application. The user is presented with an outline of the app and a loading indicator in the index.html. Then, once the JavaScript loads and React boots up, the full application is rendered within the shell.

<!--index.html-->
<body>
<div id="root">
  <div id="container">
  <div class="inner-container">
  <div id="header">
  <img src="/assets/icon.png" alt="logo" />
  <h1>Chat</h1>
  </div>
  <div id="loading-container">
  <img src="/assets/icon.png" alt="logo" id="loader"/>
  </div>
  </div>
  </div>
  </div>
</body>
// index.js
ReactDOM.render(
<App />, 
document.getElementById('root')
);

03. Register a service worker

To tap into the full spectrum of PWA goodies (push notifications, caching, install prompts) you will need a service worker.

Luckily, they're pretty easy to set up. Below, we first check if the user's browser supports service workers. Then, if so, we can move ahead with registering the service worker file, here called service‑worker.js. Note that you don't need anything special inside that file at this point – it can be blank. 

In the example below, however, we show how to tap into the three key service worker lifecycle events. These are 'install', when the user first visits your page; 'activate', right before registration completes; and 'fetch', when the application makes a network request. The last one is relevant for caching and offline capability.

<script>
  if ('serviceWorker' in navigator) {
  window.addEventListener('load', function() {
  navigator.serviceWorker.register('service-worker.js').then(function(registration) {
  // Registration was successful
  console.log('Registered!');
  }, function(err) {
  // registration failed :(
  console.log('ServiceWorker registration failed: ', err);
  }).catch(function(err) {
  console.log(err);
  });
  });
  } else {
  console.log('service worker is not supported');
  }
  </script>
// service-worker.js
self.addEventListener('install', function() {
  console.log('Install!');
});
self.addEventListener("activate", event => {
  console.log('Activate!');
});
self.addEventListener('fetch', function(event) {
  console.log('Fetch!', event.request);
});

04. Add push notifications

Service workers allow your users to receive push notifications via the web Push API. To access it, you can tap into self.registration.pushManager from within your service worker file. Since the sending of push notifications relies heavily on your backend setup, we won't dive into it here. 

If you're starting an app from scratch, Google's Firebase service comes with Firebase Cloud Messaging for relatively painless push notifications. The code below shows how to register for push notifications via the Push API.

navigator.serviceWorker.ready.then(function(registration) {
  if (!registration.pushManager) {
    alert('No push notifications support.');
    return false;
  }
  //To subscribe `push notification` from push manager
  registration.pushManager.subscribe({
  userVisibleOnly: true //Always show notification when received
  })
  .then(function (subscription) {
  console.log('Subscribed.');
  })
  .catch(function (error) {
  console.log('Subscription error: ', error);
  });
})

05. Add a web app manifest

In order to make your application installable, you need to include a manifest.json in the application's root directory. You can think of this as a description of your application, similar to what you might submit to the App Store. It includes icons, a splash screen, a name and a description. 

There's also some configuration for how your application appears when it is launched from the user's home screen: Do you want to show the address bar in the browser or not? What colour do you want the status bar to be? And so on. Note that a proper manifest.json should include a full spectrum of icon sizes for various devices. The code below is a preview of some of the properties your manifest can include.

{
  "short_name": "Chat",
  "name": "Chat",
  "icons": [
  {
  "src":"/assets/icon.png",
  "sizes": "192x192",
  "type": "image/png"
  }
  ],
  "start_url": "/?utm_source=homescreen",
  "background_color": "#e05a47",
  "theme_color": "#e05a47",
  "display": "standalone"
}

06. Configure the install prompt

When a user visits a PWA with a service worker and manifest, Chrome will automatically prompt them to install it to their homescreen, given the following: the user must visit the site twice, with five minutes between visits. 

The idea here is to wait until the user demonstrates interest in your application, and then ask them to make it a fixture of their device (this is in sharp contrast to the native app approach, which asks for that investment up-front). 

But there may be cases where you want to show the install prompt in different situations, such as after the user takes a particular useful action. To do so, we intercept the beforeinstallprompt event and save it for later, then deploy the prompt when we see fit.

window.addEventListener('beforeinstallprompt', e => {
  console.log('beforeinstallprompt Event fired');
  e.preventDefault();
  // Stash the event so it can be triggered later.
  this.deferredPrompt = e;
  return false;
  });
// When you want to trigger prompt:
this.deferredPrompt.prompt();
  this.deferredPrompt.userChoice.then(choice => {
  console.log(choice);
  });
this.deferredPrompt = null;

07. Analyse your app's performance

Performance is the heart and soul of PWAs. Your app should be fast for users on all network conditions. Caching and offline capability helps a lot, but at the end of the day, your application should be speedy even if the user does not have the browser to support service worker technology. This is the definition of progressive enhancement – provide a great experience for everyone, regardless of device modernity or network conditions.

Advertisement

To do so, a useful set of metrics is the RAIL system. RAIL is what Google calls a 'user-centric performance model' – a set of guidelines for measuring our app's performance. 

The acronym stands for Response (how long it takes for your app to respond to user actions), Animation (keeping animation speed at 60fps), Idle (using time when your app isn't doing anything else to load and cache additional assets) and Load (loading your app in one second or less).

Here is a table of meaningful benchmarks for application loading, as supplied by Meggin Kearney, tech writer at Google Web Fundamentals.

Click the icon in the top right to enlarge the image

08. Audit your app with Lighthouse

Google is the biggest champion pushing Progressive Web Apps as the future of the web. As such, it has supplied a useful tool for guiding your PWA development.

Formerly called Lighthouse and supplied as a Chrome Extension, as of Chrome 60 it's a part of the Chrome DevTools, under the 'Audits' tab. What Lighthouse does is run your application under different conditions and measure its response and success according to PWA guidelines. It then gives you a score out of 100. It can also score your app on web best practices at the same time.

The following text is a list of the values Lighthouse measured. In use also shows descriptions.

• Registers a Service Worker
• Responds with a 200 when offline
• Contains some content when JavaScript is not available
• Uses HTTPS
• Redirects HTTP traffic to HTTPS
• Page load is fast enough on 3G
• User can be prompted to install the Web App
• Configured for a custom splash screen
• Address bar matches brand colours
• Has a <meta name="viewport"> tag with width or initial-scale
• Content is sized correctly for the viewport

This article originally appeared in Web Designer issue 266

The Most Clever Line of JavaScript

Recently my friend sent me a very interesting JS snippet, which he found in one open-source library:

addressParts.map(Function.prototype.call, String.prototype.trim);

At first, I laughed and thought “nice try”. Second thought was that map accepts only one argument, and I went to MDN docs, where I realized that you can pass context as a second argument. At this point I was really puzzled, and after running my confusion increased to the limit – it worked as expected!

I’ve spent at least half an hour playing with it, and it was an interesting example how magical JavaScript can be, even after years spent writing it. Feel free to figure it out by yourself, and if you want to check out my understanding, keep reading!

So, how does it work? Let’s start with super naive implementation (which is actually shorter and easier to read :)):

addressParts.map(str => str.trim());

But as it is clear, we strive here to avoid creating new functions, so let’s move on. Function.prototype.call is a function in prototype of all javascript functions, and it invokes function, using first argument as this argument, passing rest arguments as parameters of function invokation. To illustrate:

// this function has `Function` in prototype chain
// so `call` is available
function multiply(x, y) {
  return x * y;
}

multiply.call(null, 3, 5); // 15
multiply(3, 5); // same, 15

Typical usage of the second argument can be the following – imagine you have a class-based react component, and you want to render list of buttons:

class ExampleComponent extends Component {
  renderButton({ title, name }) {
    // without proper `this` it will fail
    const { isActive } = this.props;
    return (
      <Button key={title} title={title}>
        {name}
      </Button>
    );
  }

  render() {
    const { buttons } = this.props;

    // without second param our function won't be able
    // to access `this` inside
    const buttonsMarkup = buttons.map(this.renderButton, this);
  }
}

However, from my experience, it is not that common to use this second argument, usually class properties or decorators are used to avoid binding all the time.

There is one similar method – Function.prototype.apply, which works the same, except that the second argument should be an array, which will be transformed to a normal list of arguments, separated by comma. So, let’s see how we can use it to calculate maximum:

Math.max(1, 2, 3); // if we know all numbers upfront
// we can call it like that

Math.max([1, 2, 3]); // won't work!

Math.max.apply(null, [1, 2, 3]); // will work!

// however, ES2015 array destructuring works as well:
Math.max(...[1, 2, 3]);

Now, let’s try to recreate a call which will solve our problem. We want to trim the string, and it is a method in String.prototype, so we call it using . notation (however, strings are primitives, but when we call methods, they are converted to objects internally). Let’s go back to our console:

// let's try to imagine how trim method is implemented
// on String.prototype
String.prototype.trim = function() {
  // string itself is contained inside `this`!
  const str = this;
  // this is a very naive implementation
  return str.replace(/(^\s+)|(\s+$)/g, '');
};

// let's try to use `.call` method to invoke `trim`
" aa ".trim.call(thisArg);

// but `this` is our string itself!
// so, next two calls are equivalent:
" aa ".trim.call(" aa ");
String.prototype.trim.call(" aa ");

We are now one step closer, but still not yet there to understand our initial snippet:

addressParts.map(Function.prototype.call, String.prototype.trim);

Let’s try to implement Function.prototype.call itself:

Function.prototype.call = function(thisArg, ...args) {
  // `this` in our case is actually our function!
  const fn = this;

  // also, pretty naive implementation
  return fn.bind(thisArg)(...args);
};

So, now we can put all pieces together. When we declare function inside the .map, we pass Function.prototype.call with bound String.prototype.trim as this context, and then we invoke this function on each element in the collection, passing each string as thisArg to the call. It means that String.prototype.trim will be invoked using string as this context! We already found that it will work, using our example:

String.prototype.trim.call(" aa "); // "aa"

Problem solved! However, I think it is not the best example how one should write such a code in JavaScript, and instead just pass a simple anonymous function:

addressParts.map(str => str.trim()); // same effect

Consistency models

Why this post?

I have found somehow difficult to find an authoritative source which describes what is the contract that a certain consistency model defines with the programmer. Moreover, some resources seem to contradict each other.
The idea of this post is to document my findings around some of the most common consistency models that can be found in distributed systems which we interact with. When possible I'll add the resource where I found the definition.

Consistency model as abstraction

In distributed systems, a consistency model is a contract between the system and the developer who uses it. A system is said to support a certain consistency model if operations on memory respect the rules defined by the model.
They are a powerful abstraction which helps to describe a system in terms of its observable properties.
From a practical point of view, a consistency model answers to questions like: If Client 1 adds an object to a distributed data store at 1:00 pm and Client 2 tries to read the same object at 1:01 pm, will Client 2 be able to get the new object? Or will it get a 404 because the resource was not found?
The answer is that...it depends. There are many factors to consider to answer such a question. One of them is the consistency model adopted by the distributed data store.

Sequential consistency

The result of any execution is the same as if the operations of all processors were executed in some sequential order and the operations of each individual processor appear in this sequence in the order specified by its program.

Conceptually there is one global memory and a switch that connects an arbitrary processor to the memory at any time. Each processor issues memory operations in program order and the switch provides the global serialization among all the processors.
Therefore: Sequential consistency is not deterministic because multiple execution of the distributed program might lead to a different order of operations.

In the example above, four possible execution orders are possible no matter what is the actual order in which the operations were issued.
Important: no matter what the order of the operations are, it is guaranteed that is the same among all the processors. This also means that each process will observe the same history of operations. For example, in the first case b.1 will read the state which is the result of all the operations completed before b.1 : so b.1 is going to read a value for the account which is '150'.

Strict consistency

Also called Strong consistency or Linearizability. 
Like sequential consistency, but the execution order of programs between processors must be the order in which those operations were issued.
As analogy, this is pretty much what we would get from a multi threaded program in which there is no cache between the cores and the main memory, and neither the compiler nor the CPU is allowed to reorder instructions. 
Therefore: If each program in each processor is deterministic, then the distributed program is deterministic.

Casual consistency

Relax sequential consistency allowing also reordering of the operations in the same processors when they are not 'casually related'.

PRAM consistency

The write operations (and only the writes) of each processor appear in the order specified by the program.

Serializability

Unlike the models described above, serializability defines guarantees on group of operations (called transactions). It guaranties the execution of a set of transactions (usually read and writes operations) over multiple items is equivalent to some serial execution of the transactions.
Unlike linearizability, serializability does not impose a deterministic order, in this sense is similar to sequential consistency but for a group of operations.
Strict serializability, instead, guaranties the same constraint expressed by linearizability but for transactions: transactions must be executed in the order they were issued.
The definition looks a bit different from the ones above because it comes from database people, while sequential consistency, etc. come from distributed system people.

Read after write

The model guaranties immediate visibility of updates to an item to all the clients. The concept is similar to the one of Memory Barrier present in modern processors.
Note: Sometimes what is called Read after write in some systems, it's actually Read after create (for example in S3).

Read after create

The model guaranties immediate visibility of newly created data to all the clients. Updates to an existing object might not be immediately visible to all clients.

Conclusions

Those were my two cents about one of the many aspects around distributed systems. I'll keep adding more to the list as I go. Of course, any feedback would be greatly appreciated!