DEV Community: Laxmi Narayana Pattanayak

How JavaScript Really Works?

Laxmi Narayana Pattanayak — Fri, 12 Apr 2024 09:46:00 +0000

When your browser encounters JavaScript code nestled within your HTML, it hands the code off to a specialised interpreter called the JavaScript engine which converts the code into computer understandable langauge.

The JavaScript Engine

Every web browser comes equipped with a JavaScript engine, a specialized program responsible for interpreting and executing JS code. Some of the popular JavaScript engines include Chrome's V8, Firefox's SpiderMonkey, and Safari's JavaScriptCore.

How JavaScript engine works?

Parsing: The engine starts reading your JavaScript line by line, breaking it down into its core elements like functions, variables, and expressions. This analysis builds an Abstract Syntax Tree (AST), a tree-like data structure that captures the structure and relationships between elements in your code.
Code Generation: The AST is then used to generate bytecode. Bytecode is a lower-level, machine-independent format that's easier for the engine to optimize. And now this byte code is ready for execution.
Optimization: When executing the bytecodes, JS engine keeps monitoring the codes and start optimizing code parallelly by compiling it into machine code. This is called Just-in-Time compilation. This compiled machine code runs much faster than interpreted bytecode, giving JavaScript a performance boost.

But What if the optimization fails?

If the optimization fails for any reason, then the compiler de-optimizes codes and let the interpreter executes the original bytecodes.

The Execution Context : Deep Dive

When ever your browser encounters JavaScript code, the browser's JavaScript engine then creates a special environment to handle execution of this code. This environment is known as the Execution Context.

During the Execution Context run-time, the code gets parsed and, the variables and functions are stored in memory, executable byte-code gets generated, and the code gets executed.

Two types of execution context are there-

Global Execution Context (GEC) : When a JavaScript program initiates execution, the browser's JavaScript engine establishes the Global Execution Context (GEC). This GEC serves as the foundation upon which all other contexts are built.

Function Execution Context (FEC): Every time a function is invoked in JavaScript, a new Function Execution Context (FEC) is created. This FEC becomes the active context during the function's execution.

Since every function call gets its own FEC, there can be more than one FEC in the run-time of a script.

Creation of Execution Context

The creation of execution context occurs in three steps ->

Creation of the Variable Object (VO): The VO is a container that stores variables and function declarations within the execution context. In the GEC, variables declared with var are added to the VO and initialised to undefined.

Also, function declaration are stored in memory. This means that all the function declarations will be stored and made accessible inside the VO, even before the code starts running.

FECs, on the other hand, don't have a VO. Instead, they create an argument object containing the arguments passed to the function.

This process of storing variables and functions before execution is called hoisting.

Creation of the Scope Chain: Scope determines where variables and functions are accessible in your code.

Each FEC creates its own scope chain, which is a hierarchy of scopes. The function's local scope is at the top, followed by the scopes of its parent functions, all the way up to the GEC.

When a function is defined in another function, the inner function has access to the code defined in that of the outer function, and that of its parents. This behavior is called lexical scoping.

However, the outer function does not have access to the code within the inner function.

This concept of scope brings up an associate phenomenon in JavaScript called closures.

function outerFunction() {
  var outerVar = "I'm from the outer function!";

  function innerFunction() {
    // Accessing outerVar from the inner function
    console.log("Inner function can access outerVar:", outerVar);  

    var innerVar = "I'm from the inner function!";
    console.log("Inner variable:", innerVar);
  }

  innerFunction();  
}

outerFunction();  

//Output
//Inner function can access outerVar: I'm from the outer function!
//Inner variable: I'm from the inner function!

In above example if we try to access inner var in outer function by console logging inner var, it will give error.

Setting the Value of the this Keyword: The this keyword refers to the current execution context.

"this"in Global Context
In the GEC, this refers to the global object (usually the window object in browsers).

"this"in Functions
In the case of the FEC, it doesn't create the this object. Rather, it get's access to that of the environment it is defined in.

The Execution Phase

Once the creation phase is complete, the JavaScript engine moves on to the execution phase. Here, the Javascript engine reads code line by line once more in the current execution context, and the variable which are set to undefined in VO, assigned with actual values, functions are called, and the code gets transpired to executable byte code, and finally gets executed.

The Call Stack: Keeping Track of Function Calls

The Call Stack is a LIFO (Last-In-First-Out) data structure that manages function calls. As a function is invoked, a new Stack Frame is pushed onto the call stack. This frame holds information about the function's arguments, local variables, and the return address (where to continue after the function finishes). When the function returns, its stack frame is popped off the stack, and execution resumes at the return address.

var name = "John";

function func1() {
  var a = "Hello";
  func2();
  console.log(`${a} ${name}`);
}

function func2() {
  var b = "World";
  console.log(`${b} ${name}`);

}

func1();

Initially as the js code loaded on the browser, the Global execution context is being created and pushed to the bottom of the Call Stack. The name variable is present inside the GEC.

Now, when js engine encounters func1 call, it creates Function execution context for func1 and this new context is placed on top of the current context, forming the Execution Stack.

The variable 'a' which is inside the func1 is stored in the Function execution context(FEC) not in GEC.

Similary FEC is created for func2 when encounters function call inside the func1.

As the functions execution is finished, the function execution context of the function is popped out one by one from the top and at last reaches the Gobal Execution Context remains in the stack.

And lastly, when the execution of the entire code gets completed, the JS engine removes the GEC from the current stack.

The Event Loop: Handling Asynchronous Operations

JavaScript is single-threaded, meaning it can only execute one task at a time. However, it can handle asynchronous operations, through the Event Loop.

Let us understand how it works:

Main Thread: Executes the main JS code sequentially.
Callback Queue: The callback queue includes callback functions that are ready to be executed. The callback queue ensures that callbacks are executed in the First-In-First-Out (FIFO) method and they get passed into the call stack when it’s empty.
Event Loop: Continuously monitors the main thread and the callback queue. When the main thread becomes idle (after executing a synchronous task or reaching the end of the code), the event loop dequeues a callback from the callback queue and pushes the callback onto the call stack for execution

This approach allows JS to appear responsive while handling asynchronous operations without blocking the main thread.

Reasons to Choose TypeScript Over JavaScript

Laxmi Narayana Pattanayak — Thu, 11 Apr 2024 16:28:38 +0000

JavaScript has traditionally been the backbone of web development, but as projects grow larger and more complex, the demand for features like maintainability and scalability becomes crucial. TypeScript emerges as a strong contender, providing a robust alternative.

What is JavaScript?

JavaScript is a versatile programming language popular for both front-end and back-end development. It enables the creation of diverse applications, including mobile, desktop, web apps, back-end servers, and interactive experiences.

Modern iterations of JavaScript, like ECMAScript 12, introduce enhanced execution, performance, and language interaction. JavaScript is foundational for front-end developers due to its integration with HTML and CSS.

What is TypeScript?

TypeScript is a modern, open-source programming language developed by Microsoft. It extends JavaScript by introducing optional static types, making code more predictable and easier to maintain.

It brings several advantages:

Variable Type Declarations: Developers can explicitly define the data types that variables can hold (e.g., string, number, boolean). This clarity leads to improved code quality and maintainability.

Early Error Detection: TypeScript's static nature allows the compiler to identify potential type-related errors during development, rather than waiting for runtime execution failures. This proactive approach significantly reduces development time and debugging efforts.

Understanding Static and Dynamic Typing

Static typing and dynamic typing describe how programming languages manage variable types either before or during program execution.

Static typing: In statically typed languages like TypeScript, variable types are defined and verified during compile-time, before running the program. This allows developers to identify and fix type-related errors early in the development process.

Dynamic typing: In dynamically typed languages like JavaScript, variable types are determined and checked during runtime, as the program executes. Variables can change types dynamically, and type checking is performed on-the-fly as the program runs.

Advantages

TypeScript has recently approached the top 5 programming languages because it is the most widely used, provides new features to developers, and has a fantastic community. Also, TypeScript listened more carefully to developers’ needs compared to JavaScript.

TypeScript’s most advantage is the compiler that checks errors and types. The compiler shows errors in real time. It’s useful while refactoring the code and shows you that you may be missed.
If TypeScript is paired with IDE, TypeScript can provide more great features like hinting and code completion. It helps speed up development.
If a developer uses a tsconfig file, then TypeScript provides an option to transpile the code to the previous version. That means the code can run on all browsers.
TypeScript can run parallel with JavaScript code, making it easy to implement JavaScript files in legacy projects.
TypeScript has features that make code more fun and easily readable. Features like interfaces, Enums, and generics make code interesting.

Why Typescript for complex and large projects?

As your projects grow in size and complexity, the following reasons make TypeScript an attractive choice:

Type Safety: One of the standout features of TypeScript is its static typing system. In JavaScript, variables can change types dynamically, leading to potential runtime errors that may not surface until a later stage of development. TypeScript's static typing allows developers to catch such errors during the compilation phase, providing an early safety net for code quality.

Easier Scalability: As projects grow in size, maintaining a clean and organized codebase becomes crucial. TypeScript provides features such as modules, namespaces, and interfaces that facilitate better project organization.

Improved Readability and Maintainability: TypeScript's explicit typing not only contributes to better code quality but also enhances code readability. When you read a TypeScript file, the types explicitly convey the intentions of the code. This clarity is especially beneficial for developers who are new to a project or for those reviewing code written by others.

TypeScript: When To Use And When To Not

When Is TypeScript Appropriate for a New Development?

TypeScript can be a great choice for a new development project, particularly if you're the sole developer. It provides robust type checking, which can lead to fewer bugs and more maintainable code. While the initial learning curve and setup might require time and effort, you'll likely appreciate TypeScript as you become accustomed to it.
In a team setting, adopting TypeScript can pose some initial challenges, such as coordinating code changes and obtaining agreement from your peers. However, these challenges often pay off in the long run as your codebase becomes more reliable and easier to maintain.

When Should You Avoid TypeScript for a New Development Project?

Tight Deadlines: If you have a tight project timeline and you're not already familiar with TypeScript, learning and setting it up might slow you down initially.
Complex Configuration: Setting up TypeScript can be daunting for beginners. Configuring TypeScript and integrating it with your existing toolchain can add complexity and time.
Dependency Management: TypeScript often requires installing and managing multiple npm libraries, which can be time-consuming and complicate the project setup.

Project Migration

Migrating a project from JavaScript to TypeScript can offer mobile app and front-end developers numerous benefits throughout the development lifecycle, including the identification of previously unnoticed bugs and simplified project maintenance.

For small projects, the migration process is relatively straightforward: install the necessary libraries, change file extensions from .js to .ts, and let the TypeScript compiler resolve the errors.

However, migrating larger projects with extensive JavaScript code can be more complex. One approach is to prioritize migrating certain files and running them in parallel with the remaining JavaScript code. This allows for gradual adoption without disrupting existing functionality.

Another viable strategy is to introduce new features using TypeScript while keeping the existing JavaScript codebase intact. This way, TypeScript is only applied to new portions of the project, allowing for a smooth transition and interaction with legacy code.

Artificial Intelligence: The Future

Laxmi Narayana Pattanayak — Thu, 11 Apr 2024 07:03:48 +0000

Introduction

Artificial intelligence (AI) is a wide-ranging branch of computer science that aims to build machines capable of performing tasks that typically require human intelligence.

Artificial Intelligence is composed of two words Artificial and Intelligence, where Artificial defines "man-made," and intelligence defines "thinking power", hence AI means "a man-made thinking power."

Goals of AI

Replicating Human Intelligence
Mastering Complex, Knowledge-Intensive Tasks
Intelligent Learning and Adaptation
Future Possibilities: AI as a Knowledgeable Advisor

Types of AI

Artificial Intelligence can be divided in various types, there are mainly two types of main categorization which are based on capabilities and based on functionally of AI.

Based on the Capabilities it is 3 types:

Narrow AI: Narrow AI, also known as Weak AI, refers to artificial intelligence systems that are designed and trained to perform a specific task. The most common and currently available AI is Narrow AI in the world of Artificial Intelligence.
General AI: General AI is a type of intelligence which could perform any intellectual task with efficiency like a human. The idea behind the general AI to make such a system which could be smarter and think like a human by its own. Currently, there is no such system exist which could come under general AI and can perform any task as perfect as a human.
Super AI: Super AI is a level of Intelligence of Systems at which machines could surpass human intelligence, and can perform any task better than human with cognitive properties. Super AI is still a hypothetical concept of Artificial Intelligence. Development of such systems in real is still world changing task.

Based on functionality it is 4 types:

Reactive Machines: Purely reactive machines are the most basic types of Artificial Intelligence. Such AI systems do not store memories or past experiences for future actions. These machines only focus on current scenarios and react on it as per possible best action. IBM's Deep Blue system and Google's AlphaGo is an example of reactive machines.
Limited Memory: Limited memory machines can store past experiences or some data for a short period of time.
These machines can use stored data for a limited time period only. Self-driving cars are one of the best examples of Limited Memory systems.
Theory of Mind: Theory of Mind AI should understand the human emotions, people, beliefs, and be able to interact socially like humans. This type of AI machines are still not developed, but researchers are making lots of efforts and improvement for developing such AI machines.
Self-Awareness
Self-awareness AI is the future of Artificial Intelligence. These machines will be super intelligent, and will have their own consciousness, sentiments, and self-awareness. These machines will be smarter than human mind. Self-Awareness AI does not exist in reality still and it is a hypothetical concept.

How Does AI Work ?

Artificial intelligence systems work by using algorithms and data. First, a massive amount of data is collected and applied to mathematical models, or algorithms, which use the information to recognize patterns and make predictions in a process known as training. Once algorithms have been trained, they are deployed within various applications, where they continuously learn from and adapt to new data. This allows AI systems to perform complex tasks like image recognition, language processing and data analysis with greater accuracy and efficiency over time.

Applications of AI

Artificial Intelligence (AI) has a wide range of applications and has been adopted in many industries to improve efficiency, accuracy, and productivity. Some of the most common uses of AI are:

Healthcare: AI is used in healthcare for various purposes such as diagnosing diseases, predicting patient outcomes, drug discovery, and personalized treatment plans.
Finance: AI is used in the finance industry for tasks such as credit scoring, fraud detection, portfolio management, and financial forecasting.
Retail: AI is used in the retail industry for applications such as customer service, demand forecasting, and personalized marketing.
Manufacturing: AI is used in manufacturing for tasks such as quality control, predictive maintenance, and supply chain optimization.
Transportation: AI is used in transportation for optimizing routes, improving traffic flow, and reducing fuel consumption.
Education: AI is used in education for personalizing learning experiences, improving student engagement, and providing educational resources.
Marketing: AI is used in marketing for tasks such as customer segmentation, personalized recommendations, and real-time audience analysis.
Gaming: AI is used in gaming for developing intelligent game characters and providing personalized gaming experiences.
Security: AI is used in security for tasks such as facial recognition, intrusion detection, and cyber threat analysis.
Natural Language Processing (NLP): AI is used in NLP for tasks such as speech recognition, machine translation, and sentiment analysis.

Future Of AI

AI and ML will transform the scientific method
AI will become a pillar of foreign policy
AI will enable next-gen consumer experiences
AI will enable truly personalized medicine
Addressing the climate crisis will require AI