History of JavaScript
Today, we see JavaScript used pretty much everywhere. For the seventh year in a row, we see it ranking as the most popular and widely used programming language, a good 67.8% of developers having used it in 2019.
JavaScript is used to build 95.2% (1.52 billion) websites today, including Facebook and YouTube and some of the most popular and useful apps such as Google Maps and eBay.
Let’s take a closer look at what JavaScript is, how and why it was created, and how it seems to be taking over front-end development.
It all began in the late 90s when Netscape Navigator, a popular browser was launched by Netscape Communication. In the initial days of Netscape, it was just a software which was able to render static HTMLs, but people wanted it to do more. Netscape envisioned that web pages should be more dynamic in nature. If users are not able to engage with HTMLs, browsers will end up becoming boring pieces of software, they figured.
That’s when Brendan Eich came into the picture. He was contracted in 1995 by Netscape Communications to develop a language which would have a low learning curve, so that anyone would be able to write functionalities with it. He developed the language in just 10 days and named it Mocha. A working prototype of Mocha was integrated in the Netscape Browser in May 1995, renaming the language to LiveScript and later in December 1995, it was renamed again, this time as JavaScript.
The marketing team at Netscape chose to call it "JavaScript" as Java was extremely popular at that time. With the popularity of Netscape Navigator, Microsoft wished to capture the browser market and developed Internet Explorer with a scripting language named JScript. For a long time, there was no common standard formed for JavaScript, resulting in huge cross browser compatibility issues. Finally, in 1997, Netscape invited ECMA (European Computer Manufacturing Association) to take the responsibility of forming a specification for JavaScript.
Since then, the ECMA has released updated specifications for JavaScript regularly and browsers try to follow these specifications in their implementation of JavaScript engine.
Fact Check: Today, Brendan Eich is the CEO of Brave Software which builds a privacy oriented, chromium-based browser named Brave.
Fact Check: Netscape Navigator later became the foundation stone for Mozilla Firefox. They retained the same name for their JavaScript engine "Spider Monkey" which was part of the Netscape navigator.
Need of Framework
With the ECMAScript specifications in place, developers began to use JavaScript to make the HTML page much more dynamic using JavaScript. However, there were still a few developers who preferred to write big client-side functionality with JavaScript, owing to low performance of browser and JavaScript engines. Perhaps, the industry had a more a server-side performance focus in that era. Then, as computers became more powerful, browser performance improved and JavaScript engines evolved, developers started moving client-side logic to browser using JavaScript.
Once developers started writing more and more JavaScript, the community felt the need to write logic in a more structured and scalable manner, so as to be more understandable, readable, manageable and less error prone. The need for a framework in JavaScript was clearly felt.
Many frameworks like Dojo, Backbone, Ember and AngularJS eventually emerged within their own communities, which tried to solve problems in their unique way. Collectively, this has helped the whole JS community to move forward towards a more scalable and maintainable web application.
ReactJS
In 2011, Codebase for Facebook Ads was getting bigger. Developers began to face maintenance issues with it and it was getting harder to add new features in an efficient way. That's when Facebook engineer, Jordan Walke, built a prototype for an efficient application UI. This marked the birth of ReactJS, initially called FaxJS. Later, when Instagram was acquired by Facebook, the folks at Instagram wanted to adopt this framework. Pete Hunt and Jordan Walke then improved, decoupled the library and made it open source as ReactJS in 2013. Since then ReactJS has gone through many changes. The latest version of ReactJS in 2020 is currently 16.13.
ReactJS follows component-based architecture and encourages developers to think in terms of small, composable components. Interestingly, this methodology is aligned with an efficient approach for solving any problem in life: the first step to solve a big problem is to break it down into multiple smaller sub problems. Once you have a solution for each sub-problem, you can then add it up to get the overall solution. This can be applied to all problems, big or small. ReactJS asks developer to adopt a problem-solving approach like this to build any UI. It must be noted that ReactJS does not aim to solve each and every problem of building a web application. Rather, it has a narrow focus and a limited scope to solve the one core problem of web development around how to efficiently updating the UI/views.
When ReactJS was open sourced in the JSConf 2013, the ideas and changes that ReactJS was proposing were not very well received. For instance, although two-way binding was very popular, ReactJS went ahead with one way data flow. In another example, writing HTML inside JS was considered a bad practice, but ReactJS still wanted to use JSX. All these ideas initially attracted a lot of criticism from the web developer community. In time, however, developers started using it and found it easy to build components efficiently.
So, ReactJS now solved the one problem around updating views. But what about all the problems in web development? An ecosystem began to emerge to address the other problems along with ReactJS. Libraries like Redux and React-Router came to life, making ReactJS a complete web framework, although this meant that there would be a dependency on multiple libraries. The ease of using ReactJS trumped all the negative points of the framework and this is what continues to make it a very popular library in web development. In 2020, ReactJS has 50K plus stars on Github and is downloaded 6 million times per week.
The ReactJS ecosystem continues to grow steadily; React Native recently bought ReactJS to build cross mobile platform apps. Libraries like Gatsby and NextJS encourage developers to use ReactJS on server and provide benefits of server-side rendering without much hassle. ReactJS has also stood out in multiple developer surveys such as the State of JavaScript.
Main design concepts in ReactJS
Main design concepts in ReactJS
Declarative, composable, reusable components
ReactJS motivates developers to write small components and reuse the same component at multiple places. Re-usability of components greatly speeds up the overall development and results in less amount of code. Less code is always better because it is less prone to errors.
ReactJS encourages developers to write composable components which can be wrapped around any other React component to provide special functionality, thus discouraging the writing of components that do too many things. ReactJS always encourages developers to break their problem into smaller problems, solve the smaller problems first and then combine them to present the overall solution. Less functionality in components always leads to less error prone components.
ReactJS encourages developers to write clean, readable, and maintainable code. This is why it emphasizes writing declarative components, which make a codebase easier to read and understand by fellow developers.
Declarative, composable components looks a lot like HTML in JS. Instead of standard HTML tags, we have React components as tags. This similarity to standard web semantics is what makes JS somewhat familiar to developers starting out.
Reactive Updates
Writing static HTML is no fun and it can be said that JavaScript was born to bring interactivity to web pages. ReactJS helps developer to add functionalities in components with which the user can interact and see the results. ReactJS allows developers to attach a state to component and whenever the state of components changes, the component efficiently re-renders itself to produce an updated view. Now, the state of the component can be changed by clicking a button, entering text into the input box or any other part of the component triggering an event. The React component listens to these events and acts accordingly. Updating the whole component UI seems like a terrible idea, but ReactJS has implemented this terrible idea wonderfully by doing it efficiently.
In-memory DOM representation
ReactJS is able to efficiently update views by keeping a DOM representation in memory known as virtual DOM. Upcoming updates always compare the new DOM with an older copy of the DOM and based on the difference, it figures out the actual DOM elements which need to be updated on the UI. Reducing the number of DOM manipulations makes ReactJS faster. What this means is that writing smaller React components will take up less memory to store DOM representations (Virtual DOM) and ultimately, this results in better performance.
Features of ReactJS
Main features of ReactJSJSX and Why is it needed
When ReactJS was released, it was mentioned in documentation that it is recommended to use JSX along with ReactJS. Now, what is JSX? and do i really need another library to use the ReactJS library? So, let us see how a simple ReactJS component looks without JSX:
import React from "react";
function Greeting({ name }) {
return React.createElement("h1", null, `Hello ${name}`);
}
ReactDOM.render(
React.createElement("Greeting", { name: "Gully Boy" }, null),
document.getElementById("root")
); There is no way the above code looks like a declarative component. The truth is JavaScript does not understand HTML or XML like tags. That is why we need someone to do that conversion for us. Here enters JSX, also known as a syntax extension for JavaScript. With JSX, the above Greeting React component will look something like this:
import React from "react";
function Greeting({ name }) {
return {`Hello ${name}`};
}
ReactDOM.render(<Greeting name="Gully Boy" />,
document.getElementById("root")); JSX actually makes ReactJS code more readable and understandable. You can assume this as a templating library which converts HTML looking syntax into ReactJS element JS code by calling createElement().
Virtual DOM
ReactJS has made the term, 'VDOM' or virtual DOM very popular in the JavaScript community. Web browsers have provided APIs to interact with DOM to make our web page dynamic. One can dynamically add or remove nodes in the web page by using these APIs. But interacting with these APIs was very slow, as changing node triggers re-layout and re-paint event for sub-tree. Although the entire subtree is re-rendered (diffing stops when an element type has been modified and subtree is freshly rendered), even in case of virtual DOM reconciliation, the advantage that React offers is that the developer is freed from figuring out which part of DOM really requires updates - the diffing and reconciliation algorithm takes care of it.
React has thus provided a way to reduce the number to change in DOM using virtual DOM. The VDOM is a JavaScript object which contains information of DOM sub tree. We can also call this an object representation of DOM. React uses this object to compare subsequent modification and figure out the minimum number of modifications needed to make in browser DOM to get the desired result. ReactJS claims that the wonderful performance of their library is because of the algorithm they use to compare the virtual DOM.
React Native
React native is another popular library which is used to build cross platform mobile applications using JavaScript. Before ReactJS, Cordova and ionic were some frameworks which were very popular to build mobile applications using JavaScript. However, these applications did not perform very well. React native uses popular component-based concepts of ReactJS and provides a way to build an efficient mobile application. React native converts JS code into native platform code to run in mobile devices. This approach has improved the performance of mobile applications by a great deal in comparison to other frameworks like ionic. With React Native, ReactJS has now become a very popular library to build UI on any platform.
ReactJS: Here to stay
Over the past decade, the JavaScript community has seen tremendous changes in language within the developer community. It has seen a lot of new ideas and terms surface in the form of libraries. Developers are building and sharing their work with rest of the world quite frequently and every other day, implementations are open sourced on Github.
These new ideas and the problem solving approach continues to help the JavaScript ecosystem to evolve and become better. Prior to ReactJS, JQuery was very popular and was the default library for any web project involving DOM manipulation. With AngularJS and other MVC libraries, we were encouraged to think about a problem in terms of Modal, View and Controller.
People have always sought to figure out an approach that can solve the problem. And structuring a solution in a scalable manner is not a new challenge either. We have already implemented scalable solutions at server-side, and they are performing quite well. ReactJS now brings the same pattern to the front-end, where the final output is a UI. To implement this, we break the problem into smaller sub-problems and write solutions for them. This is the basic mental model to solve all UI problems and ReactJS focuses on the same.
New ideas in the JavaScript community help the community move forward and eventually, the best solutions become part of the standard JS (ECMAScript). ES modules, promises and some lodash utilities are examples of this.
When a library moves in the same general direction as the web, it is bound to be used by a large community. Developers will use these solutions until new specifications are finalized and browsers adopting new specifications. Interim, people will use the feature in the form of third party library.
So, is ReactJS moving in the right direction?
I would say yes. ReactJS is evolving right along the evolving standards of JavaScript. The front-end community is leaning more towards concepts of functional programming rather than object-oriented methodology. In a similar direction, ReactJS continues to move towards a functional programming pattern.
ReactJS has introduced hooks in version 16.8, which encourages developer to build more and more functional components instead of class-based components. Hook does not even work with class-based component. Understanding well that it sometimes becomes a hectic task to figure out which library one should choose to handle state management, ContextAPI and useReducer hooks have been introduced, which help in managing state in small applications much better. Today, with the help of ContextAPI and useReducer hooks, you can build an application without using any other library like Redux. This, however, does not mean that you should stop using Redux as it has its own benefits.
Component based architecture is also aligned with the standard web components support in browsers, which allow developers to write non-standard HTML tags in code. In short, ReactJS has made the community become familiar with some of the upcoming web standards. For this reason, I feel that conceptually, ReactJS is going to stay with the community for long.
Many big companies like Facebook, Microsoft and AirBnB are supporting the direction and concepts of ReactJS, thus adding credibility to the library. With many big brains backing the library, the ReactJS community looks poised for growth.
With no perfect solution to all the problems in web development in sight, the best option is to move forward with whatever is available at the moment. In the JavaScript community too, there is an effort to figure out an alternate to ReactJS such as VueJS and Svelte. Perhaps, ReactJS will get replaced by some other library in the future. However, the basic idea of creating smaller, reusable components is here to stay.
Whatever framework we learn, it is most important to grasp the basic idea behind the library. It is this idea or design pattern that is going to remain for good. It may appear in front of you in a different form and shape, but the idea will remain forever.
