React provides a declarative API so that you don’t have to worry about exactly what changes on every update. This makes writing applications a lot easier, but it might not be obvious how this is implemented within React. This article explains the choices we made in React’s “diffing” algorithm so that component updates are predictable while being fast enough for high-performance apps.

When you use React, at a single point in time you can think of the 

 function as creating a tree of React elements. On the next state or props update, that 

 fuction will return a different tree of React elements. React then needs to figure out how to efficiently update the UI to match the most recent tree.

There are some generic solutions to this algorithmic problem of generating the minimum number of operations to transform one tree into another. However, the 

 have a complexity in the order of O(n3) where n is the number of elements in the tree.

If we used this in React, displaying 1000 elements would require in the order of one billion comparisons. This is far too expensive. Instead, React implements a heuristic O(n) algorithm based on two assumptions:

In practice, these assumptions are valid for almost all practical use cases.

When diffing two trees, React first compares the two root elements. The behavior is different depending on the types of the root elements.

Whenever the root elements have different types, React will tear down the old tree and build the new tree from scratch. Going from 

  - any of those will lead to a full rebuild.

When tearing down a tree, old DOM nodes are destroyed. Component instances receive 

 . When building up a new tree, new DOM nodes are inserted into the DOM. Component instances receive 

 . Any state associated with the old tree is lost.

Any components below the root will also get unmounted and have their state destroyed. For example, when diffing:

Reconciliation in react

You may wonder why you should use Flutter on your next project and what benefits your company will reap. This write-up is helpful whether you are the Chief Technology Officer, a TechLead, or in any other role where you need to make strategic decisions about the company’s use of technology.

Specifically, I will explain what Flutter is and why it is the best cross-platform framework available. You will gain an understanding of how the advantages of Flutter compare to those of alternative cross-platform solutions and how those advantages impact development and business operations.

Google’s Flutter is a free and open-source SDK (Software Development Kit) for creating mobile apps that run on several platforms. Flutter is an open-source framework that allows programmers to create high-performance, scalable apps with beautiful, functional UIs (User Interfaces) for both Android and iOS using a single, platform-agnostic codebase. With Flutter’s pre-built widget library, even those with minimal programming or development skills can quickly release mobile applications.

Google’s Flutter, an app development framework first announced in 2018, has swiftly become the de facto standard. Flutter is now the most popular 

  framework, according to Statista, dethroning the previously dominant React Native.

Flutter was developed to accommodate cross-platform Android and iOS apps and web and desktop-based interactive apps.

Flutter is ideal for apps that need to provide consistent visual branding across all devices. On the other hand, Flutter allows you to make experiences that are pixel-perfect matches for Android and iOS design languages.

An extensive range of devices (camera, GPS, network, and storage) and services can be integrated with Flutter thanks to the package ecosystem (such as payments, cloud storage, authentication, and ads).

What programming language is Flutter based on?

Flutter applications are developed in Dart and take advantage of several of the language’s more advanced features.

That is because Flutter is not a language at all. It is a pre-written SDK (software development kit) with both ready-to-use and customizable widgets, libraries, tools, and documentation for making cross-platform software.

Flutter is built on Google’s cross-platform programming language Dart and does not require a bridge to talk to the native layer (such as Android or iOS). Because of this, app loading times are shortened, and performance issues are mitigated.

Flutter requires developers fluent in Dart, its programming language, to construct your project. Dart’s ease of learning is comparable to other popular programming languages like Java, Net, Kotlin, Swift, and JavaScript.

Faster app development with flutter

Have you ever had the problem where a tool or a piece of software works fine on your machine, but the moment you install it on someone else's you get all kinds of issues? Well, I have, and particularly for this reason Docker was invented! In this blog post we will take a quick look at what Docker is and how easy it is to run a database in a Docker container. This container will work on any machine. I promise. Along the way you also learn some Docker specific lingo.

docker site

open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications.

For fully understanding Docker we also need to talk about the difference between Docker and a Virtual Machine (VM). The latter often runs in cloud environments like AWS and Azure. Whenever you create a VM you are sharing the 

with others and other VMs. What these cloud environments are doing is 'virtualise' the hardware. Docker doesn't do that and does it differently. In a VM you can have multiple Operating Systems running on the same hardware, whilst with Docker you virtualise the 

. Therefore, the big difference between VMs and Docker containers is that the former can have multiple (Guest) Operating Systems on the same hardware, through for example VMWare (which is called a Hypervisor). Whilst when you install Docker, you are going to use the Docker Engine to create isolated entities on the OS. These entities are called containers. Docker therefore allows you to 

the deployment of applications in these containers.

Enough theory, let's jump into installing Docker and firing up a Postgres database. In order to use Docker you first need to install it. You can either install Docker on a Desktop machine (both Windows and Mac), or on a server (Linux based installations). For this tutorial we're going to install Docker on a 

. Windows installation instructions can be found 

. For a Mac (and I think also for Windows) the installation is fairly straightforward. You download the app and drag it to Applications. Then you double click the  and it should start. You can check if it's working when there is a Docker icon (the whale or ship like image with containers) on the top right next to your other small icons. If this is the case you can quickly follow the 'Hello World' example to get up and running.

Hands down the easiest way of running a clean Postgres database is by running this command in a terminal window (after Docker has been installed):

docker run --name postgres-db -e POSTGRES_PASSWORD=docker -p 5432:5432 -d postgres


Now you can connect to this brand new Postgres database in any tool that allows you to communicate with databases. I tend to use RazorSQL or DBeaver. You need to use the following connection details to actually connect to the DB:

Once connected you can do anything you want with the database (Create tables, load data etc). But as you can see the database is completely empty. However, the real power of Docker is when you want to easily provision a database that has already content in it. This can be a simple or a complex database structure and schema. The choice is all yours. What this also means is that you can easily spin up such a container (and shut it down). Let's see how below:

useFetch.png

How to easily create a Postgres database in Docker

Way back when JavaScript was first created, no one worried too much about performance. JavaScript was designed to be a straightforward language  for running small bits of script in a web page. It was a frill — a simplified scripting language for amateur programmers. It certainly 
wasn’t meant to run anyone’s business.

Fast forward nearly 25 years, and JavaScript has taken over the web. It has professional responsibilities and — finally — professional features. One example is 

Web workers are designed to let you run big jobs without freezing up the page. For example, imagine you want to do some complex calculations when someone clicks a button. If you start doing the job right away, you’ll tie everything up. The person using the page won’t be able to scroll or click anything. They might even get the dreaded “this page is unresponsive” error message

Web workers are designed to let you run big jobs without freezing up the page. For example, imagine you want to do some complex calculations when someone clicks a button. If you start doing the job right away, you’ll tie everything up. The person using the page won’t be able to scroll or click anything. They might even get the dreaded “this page is unresponsive” error message.

In this situation, you need a way to do work quietly in the background, while the person using your page carriers on in the foreground, undisturbed. Technically, we say the background work takes place on another 

(Understanding how threads work is a bit more than we’ll talk about today. But the basic idea is that modern operating systems run hundreds of threads at once, and spend most of their time quickly switching from one thread to another. In fact, they switch so quickly and seamlessly that it seems like everything is happening at once.)

Web workers let you do any time-consuming job in the background. The process is simple:

A Simple Introduction to Web Workers in JavaScript

A JavaScript Promise is created with the new 

. A promise will let you start some work that will be done asynchronously and let you get back to your regular work. When you create the promise, you must give it the code that will be run asynchronously. You provide this code as the argument of the constructor function:

new Promise(function () {
  window.setTimeout(function createSundae(flavor = "chocolate") {
    const sundae = {};
    // request ice cream
    // get cone
    // warm up ice cream scoop
    // scoop generous portion into cone!
  }, Math.random() * 2000);
});

This code creates a promise that will start in a few seconds after I make the request. Then there are a number of steps that need to be made in the 

Indicated a Successful Request or a Failed Request

But once that's all done, how does JavaScript notify us that it's finished and ready for us to pick back up? It does that by passing two functions into our initial function. Typically we call these 

The function gets passed to the function we provide the Promise constructor - typically the word "resolve" is used to indicate that this function should be called when the request completes successfully. Notice the 

new Promise(function (resolve, reject) {
  window.setTimeout(function createSundae(flavor = "chocolate") {
    const sundae = {};
    // request ice cream
    // get cone
    // warm up ice cream scoop
    // scoop generous portion into cone!
    resolve(sundae);
  }, Math.random() * 2000);
});

Now when the sundae has been successfully created, it calls the 

 method and passes it the data we want to return - in this case the data that's being returned is the completed sundae. So the 

 method is used to indicate that the request is complete and that it completed 

If there is a problem with the request and it couldn't be completed, then we could use the second function that's passed to the function. Typically, this function is stored in an identifier called "reject" to indicate that this function should be used if the request fails for some reason. Check out the 

new Promise(function (resolve, reject) {
	window.setTimeout(function createSundae(flavor = 'chocolate') {
		const sundae = {};
		// request ice cream        
		// get cone        
		// warm up ice cream scoop        
		// scoop generous portion into cone!        
		if (iceCreamConeIsEmpty(flavor)) {
			reject(`Sorry, we're out of that flavor :-(`);
		}
		resolve(sundae);
	}, Math.random() * 2000);
});

. Notice that even though the request fails, we can still return data - in this case we're just returning text that says we don't have the desired ice cream flavor.

A Promise constructor takes a function that will run and then, after some amount of time, will either complete successfully (using the 

method). When the outcome has been finalized (the request has either completed successfully or unsuccessfully), the promise is now 

 and will notify us so we can decide what to do with the response.

The first thing to understand is that a Promise will immediately return an object.

const myPromiseObj = new Promise(function (resolve, reject) {
	// sundae creation code
});

 method on it that we can use to have it notify us if the request we made in the promise was either successful or failed. The 

mySundae.then(function (sundae) {
	console.log(`Time to eat my delicious ${sundae}`);
}, function (msg) {
	console.log(msg); self.goCry(); // not a real method
});

As you can see, the first function that's passed to 

 will be called and passed the data that the Promise's 

 function used. In this case, the function would receive the 

 object. The second function will be called and passed the data that the Promise's 

 function was called with. In this case, the function receives the error message "Sorry, we're out of that flavor :-(" that the 

 function was called with in the Promise code above

Promises-Part 2

new Promise(function () { 
   window.setTimeout(function createSundae(flavor = 'chocolate') { 
       const sundae = {}; 
 }, Math.random() * 2000);
});

new Promise(function (resolve, reject) {    
     window.setTimeout(function createSundae(flavor = 'chocolate') { 
     const sundae = {};       
      resolve(sundae);   
 }, Math.random() * 2000);
});

new Promise(function (resolve, reject) {    
   window.setTimeout(function createSundae(flavor = 'chocolate') {      
   const sundae = {};        
      if ( /* iceCreamConeIsEmpty(flavor) */ ) {           
        reject(`Sorry, we're out of that flavor :-(`);  
      }        
      resolve(sundae);  
  }, Math.random() * 2000);
});

const myPromiseObj = new Promise(function (resolve, reject) {   
 // sundae creation code
});

mySundae.then(function(sundae) {  
  console.log(`Time to eat my delicious ${sundae}`);
},
function(msg) { 
   console.log(msg); 
   self.goCry(); // not a real method
});

Reconciliation in react

Faster app development with flutter

How to easily create a Postgres database in Docker

A Simple Introduction to Web Workers in JavaScript

Promises-Part 2

Promises

Recent Posts

Categories