// 16 Essential Fullstack Interview Questions

To be a full-stack developer, one must have various skills:

• Full-stack developers should be proficient in more than one programming language, such as Java, Python, PHP, Ruby, C++, etc.
• Front-end technologies such as HTML5, CSS3, JavaScript, and others should be familiar to you. Moreover, It is necessary to be familiar with third-party libraries such as jQuery, Ajax, Angular, ReactJS, and others.
• Frameworks: Proficiency in various development frameworks, such as Spring, Spring Boot, Django, MyBatis, PHP, Hibernate, and others, is required.
• Databases and caches: Full-stack developers should be familiar with DBMS (Database Management Systems) technologies such as MySQL, SQLite, Oracle, and MongoDB. Moreover, It is essential to understand caching mechanisms such as redis, memcached, and varnish.
• Design Understanding: To be a successful Full-Stack web developer, you must understand design. Furthermore, the individual should be familiar with prototyping and UX/UI design principles.
• Server experience with Apache or NGINX. A solid understanding of Linux is extremely beneficial when managing servers.

Code optimization is the best way to decrease the load time of web applications. However, there are many other ways to reduce load times:

• Image optimization: Changing the file format can significantly reduce the size of an image file. For instance, JPEG is ideal for images with a lot of colors and details, like photographs, while PNG format is best for excellent-quality transparent images.
• Keeping JavaScript and CSS in separate files will prevent them from needing to be downloaded each time an HTML document is loaded. Because browser caching is not used in this situation, the HTML document grows larger. Because it is a best practice and makes maintenance easier, you should always put CSS and JavaScript in external files.
• Fewer redirects: Too many redirects will affect a website's loading time. When a page redirects, HTTP requests and responses are delayed. Your site's load time will be significantly reduced if you remove all unnecessary redirects.
• Asynchronously load CSS and JavaScript files: Your website's CSS and JavaScript files can be loaded synchronously or asynchronously. Each file is loaded sequentially as part of synchronous loading, according to their order of appearance on your site. Asynchronous loading, as opposed to synchronous loading, enables multiple files to be loaded simultaneously, enhancing website performance.
• Minify JavaScript, CSS, and HTML: By streamlining the loading of your files, your pages will load more quickly. You can make your files smaller by removing extra spaces, characters, and comments. Your web pages will load more quickly as a result.

An application release model known as "blue green deployment" gradually moves user traffic from one version of an app or microservice to another, both of which are already in use in the real world.

Blue-Green Deployment Strategy:

Such a deployment strategy produces blue and green infrastructure environments, which are distinct from one another. A green environment (production) has the most recent code, while a blue environment (old version) contains older code (new version). At any given time, there is only one live production environment.

For Example: A program has two clones; the blue clone is idle while the green environment is active and handling all user traffic. An application can be deployed to the blue environment for testing once a new version is ready for release.

A switch is made from green to blue in the application traffic as soon as the new release passes testing. Green becomes vacant and ready for testing the following release, while Blue becomes the active production environment.

Rolling Deployment Strategy

By completely replacing the infrastructure they run, old versions of an application are completely replaced with new versions using this deployment strategy.

For Example: When a new version needs to be deployed to all nodes, the first node receives it while the other nodes manage end-user traffic. The new version will start controlling end-user traffic as soon as the first node has successfully installed it, and the second node will follow suit. The procedure is repeated until all nodes have successfully upgraded to the new version.

The "arrow functions" are one of ES6's most popular features (also known as "fat arrow functions"). A novel approach to writing brief functions is to use arrow functions. Compared to conventional function expressions, arrow functions are more condensed, but they have some restrictions and aren't always appropriate.

The above code is an ES5 function.

The same function can also be expressed as an arrow function in ES6 as follows:

var timesTwo = params => params * 2
timesTwo(5);  // 10

In JavaScript, 'Event Flow' refers to the propagation of events within the DOM (Document Object Model). The event flow specifies the order or sequence in which a specific web page receives an event. As a result, event flow (propagation) in JS is determined by the following factors:

• Event Bubbling: In Event Bubbling, the innermost element first captures and manages the event before propagating it to the outermost element. Events move up the DOM tree from child elements until the topmost element is handled.
• Event Capturing: In this method, the event is first detected and handled by the outermost element, which propagates to the innermost element. Event cycles spread from the wrapper elements to the target elements that started the cycle in the beginning.

Dealing with the various environments across various machines and platforms is one of the trickiest issues in software development. To quickly deliver software, you must be able to isolate your applications from your infrastructure using Docker.

Containers are executable components containing all the OS (Operating System) libraries and dependencies required to run an application in any environment. Developers can use them to package and run their applications. No matter what software is installed on the host, containers are small and come equipped with everything needed to run programs.

The main goal of Docker is to make configuration simpler. Virtual machines allow you to run any platform with its configuration on top of your infrastructure. Docker provides the same functionality without the overhead of virtual machines.

A class is a blueprint for your objects in a language that supports classical inheritance, such as Java, C#, or C++. You can then create new objects using that class definition or extend the class by defining a new class that adds to the original class.

JavaScript doesn't have the concept of classes, so you must first create an object before modifying it or creating new ones from it.

In Javascript, every object has a prototype. Instead of being class-based, JavaScript's inheritance system is prototype-based. JavaScript will try to locate a property in an object when a message reaches it. The message will be sent directly to the object's prototype if it is not found, and so forth. In many contexts, this behavior is referred to as prototype inheritance or prototype chain.

Constructor functions are the method of choice when building prototype chains in JavaScript. When we use the keyword new, JavaScript automatically inserts an implicit reference to the newly created object. Therefore, when the function ends, it also completely returns this reference.

function Foo() {
  this.kind = 'foo'
}

var foo = new Foo(); 
foo.kind //=> 'foo'

Long Polling is a web development pattern that helps push data more effectively from the server to the client. The client makes inquiries about the server using a Long Polling pattern.

Instead of sending an empty resource if the server has no information about the client, the server will hold the request and wait for information to become available.

JavaScript's event loop makes asynchronous programming possible. Every operation in JS occurs on a single thread, but we can use clever data structures to give the appearance of multi-threading. A queue and listener handle any async work with the Event Loop.

The main thread relays requests for async functions (or I/O) to other threads so that v8 (the Javascript engine) can continue processing requests or executing its code. Various FIFO (First-In-First-Out) queues are used in the event loop's various phases, such as pending callbacks, closing callbacks, timers, idle or preparing, polling, and checking.

When a variable defined external to the current extension is reached from an internal degree, closures are made.

It grants you access to an internal capacity's degree of an external function. Every time a capacity is created in JavaScript, closures are made. So simply describe and uncover a function inside another function to use a conclusion.

In pair programming, two programmers collaborate on a single machine. One programmer will act as the driver who codes during the development process. At the same time, another will be the observer (navigator), who will ensure the code is written correctly, proofread it, and spell-check it while also deciding where to go next. The driver can change into the observer at any time, and vice versa. Pairing, paired programming, or programming in pairs are other names for this practice.

The benefits of pair programming are numerous.

1. If two programmers run into any issues, they fix them faster.
2. Furthermore, rather than being 50% slower, two programmers working on the same program are only 15% slower than if they worked independently. (Source)
3. In addition, you can write better code if you have another programmer review your work. According to one study, it produces code with 15% fewer bugs than code written by a single programmer.

Moreover, Pair programming improves communication, code and consistently improves development procedures. Each person instructs the other while working on a project, resulting in a quicker and more effective knowledge transfer. Finally, the group improves its communication abilities.

For simple constructors, they look pretty similar.

The main difference in the constructor is observed when the effect of inheritance comes into play. This is what we need to do in addition to the above if we want to create a Student class that subclasses Person, and add a studentId field.

// ES5 Function Constructor
function Student(name, studentId) {
  // Call constructor of superclass to initialize superclass-derived members.
  Person.call(this, name);

  // Initialize subclass's own members.
  this.studentId = studentId;
}

Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;

// ES6 Class
class Student extends Person {
  constructor(name, studentId) {
    super(name);
    this.studentId = studentId;
  }
}

In ES5 and the ES6 version, using inheritance is much more verbose; here, it is simpler to understand and remember.

The clear CSS property determines whether a floating element that comes before it can be placed next to it or needs to be lowered (cleared) below them.

Clearing floats (also known as clear fixing) expand the containing element to include its child elements. As a result, it compels the elements below it to appear above it.

Like var, class, and function, let, and const are hoisted in ES6, but there is a time between entering scope and being declared during which they cannot be accessed. The temporal dead zone (TDZ) is at this period.

When a connection is opened and abandoned, it is referred to as a ‘leak’. This is because each time it occurs, the connection is no longer available for reuse. In addition, when certain database requests or transactions are not completed properly or are not committed, the connections are abandoned and permanently closed. This is known as a connection leak.

When using Connection Pools, Java developers frequently experience Connection Leaks. A connection will leak from the pool each time the code section is executed if it contains a section that improperly closes connections. If this situation persists, the pool will eventually exhaust its connections, referred to as pool exhaustion.

Once all connections have been exposed, the application will hang. We can resolve this by cutting off the connection and paying close attention to any error handling code.

Referential transparency is the primary differentiator in functional programming. Referential transparency is an expression's ability to be replaced or substituted with the value it computes, or vice versa, without affecting the program's output.

Example: Imagine we have a phrase called four: four val = add (1,3)
Any place in our code that uses four can be safely changed to add(1,3), 1 + 3, or 4 wherever it appears. Therefore, the meaning and output of all the expressions above are the same.

An expression is referentially transparent if we can switch back and forth between them anytime, anywhere, without changing their meaning or results.