Explore topic-wise InterviewSolutions in .

CSS preprocessors are scripting languages that augment CSS's STANDARD functionality. They allow us to employ variables, nesting, inheritance, mixins, functions, and mathematical operations in our CSS CODE. CSS preprocessors make it simple to automate repetitive activities, eliminate code bloat and errors, DEVELOP reusable code snippets, and maintain backward compatibility.

The benefits and drawbacks of using a preprocessor vary depending on the type of project, but the following are some of the benefits and drawbacks.

Advantages:

• You may add variables and functions to CSS with CSS Preprocessor, which gives it a new dimension and scope, making development easier and more efficient. It also improves the organization and cleanliness of your code.
• CSS Preprocessors is a unique feature that allows you to combine numerous stylesheets into one. You can make separate files for each screen or page, then combine them in the main CSS file.
• The CSS Preprocessor assists you in avoiding REPETITIONS. Instead of rewriting common styles, you can write them once and then import them.
• CSS class nesting makes it simple to target DOM elements and saves time. It's also a lot easier to alter CSS files due to nesting.

Disadvantages:

• Preprocessing tools are required for preprocessors. The time they take to recompile can be lengthy.
• Although the source files may be small, the output CSS may be large, causing the request to take longer to finish.

Choosing a preprocessor comes down to personal choice, and it MIGHT be instructive to see how a developer could choose one over the other for your project.

OOPs

OS

SQL

Practice Problems

The following are the main distinctions between LOCALSTORAGE and sessionStorage objects:

• The data stored in the localStorage object has no expiration date. The sessionStorage object, on the other HAND, keeps data for a single session.
• When a BROWSER window is closed, data in a localStorage object is not deleted. In the case of sessionStorage objects, however, the data is destroyed when the browser window is closed.
• SessionStorage data is only AVAILABLE in the browser's current window. The data in the localStorage, on the other hand, can be shared ACROSS several browser windows.

RAID stands for RISK, Actions, Issues, and Dependencies in PROJECT management. These are extremely crucial aspects for a project manager to understand.

• Risks are potential pitfalls that COULD have a good or negative impact on the project, causing the final product to deviate from the original design.
• The tasks that you do during the project are referred to as actions.
• Issues are ROADBLOCKS that you may encounter over the COURSE of the project that must be effectively resolved or the project will be derailed or fail.
• Decisions are the actions/tasks you choose in the project.

The Project Management LIFE Cycle is a set of activities/tasks that must be COMPLETED in order for project objectives or targets to be met. This assists in organizing and streamlining the efforts required to complete the project into a sequence of logical and doable actions. The Project Management Life Cycle is divided into four SIMPLE phases, as follows:

• Initiation: It's the first and most important step in the project's life cycle, where the project's initial scope is determined and resources are allocated.
• Planning: This step requires you to jot down a sufficient amount of detail for the project in order to PLAN time, cost, and resources. It calculates the amount of work required and effectively manages risk.
• Executing: This step contains the processes that are utilized to complete the project management plan's work. It's all about meeting the project's goals. It also ENTAILS monitoring, assessing, and regulating the project's progress. You must also promptly recognize possible problems and take necessary action.
• Closure: This step is a crucial aspect of project management, and it is responsible for completing all project activities. This entails completing all activities across all the steps, disbanding the project team, and using the project closure report to sign off on the project with the customer.

Eucalyptus is commercial and open-source computer software for creating private and hybrid CLOUD computing environments that are compatible with Amazon Web Services (AWS). It was created by the company Eucalyptus Systems. Eucalyptus stands for Elastic Utility Computing Architecture for Linking Your Programs To Useful Systems. Eucalyptus enables application workloads to be flexibly scaled up or down by pooling compute, storage, and network resources.

Some of its functionalities are:

• Users can configure computing, network, and storage resources using the Eucalyptus USER Console. Using built-in key management and encryption capabilities, development and test TEAMS may control virtual instances.
• Eucalyptus can run a variety of virtual machine images, including Windows and Linux. Users can create a library of Eucalyptus Machine Images (EMIs) that are detached from infrastructure details, allowing them to run on Eucalyptus clouds.
• Eucalyptus supports storage area network devices that use storage arrays to boost performance and reliability. Direct-attached storage is also supported by Eucalyptus.
• New features for AWS compatibility have been added to Eucalyptus 3.3. Resource tagging, for example, allows application developers and cloud managers to add configurable metadata tags to resources like firewalls, load balancers, Web servers, and particular workloads to help them be more easily identified.
• Maintenance Mode in Eucalyptus 3.3 allows cloud managers to do maintenance on Eucalyptus clouds with no interruption to instances or cloud applications.
• Better image management and migrating tools, warm UPGRADE capabilities, a hybrid cloud user console to handle both Eucalyptus and AWS resources, Identity and Access Management (IAM) roles, and ENHANCED High Availability (HA) capabilities are among the new features in Eucalyptus 3.4.

A hybrid cloud is computing, storage, and service environment that combines on-premises infrastructure, private cloud services, and a public cloud (such as Amazon Web Services (AWS) or Microsoft Azure) with orchestration among the platforms. Hybrid cloud infrastructure is one that combines public clouds, on-premises computing, and private clouds in your cloud server.

The real value of cloud services comes from their ability to enable a fast-paced digital company to change. There are TWO agendas in every technology management organization: the IT AGENDA and the BUSINESS transformation agenda. Traditionally, the IT agenda has been concentrated on cost-cutting. Digital business transformation plans, on the other hand, are concentrated on making money through investments.

The main advantage of a hybrid cloud is its FLEXIBILITY. To acquire the agility it requires for a competitive advantage, your company may desire (or need) to INTEGRATE public clouds, private clouds, and on-premises resources.

Indexing is a technique for improving the database PERFORMANCE by reducing the number of disc accesses needed when a query is run. It's a data structure strategy for finding and accessing data in a database rapidly.

The following are some of the benefits of indexes:

• An index allows data to be RETRIEVED quickly.
• When an index is used in a query, the performance usually improves dramatically.
• They're GOOD for sorting. It is possible to eliminate the need for a post-fetch-sort procedure.
• The index ensures that each record in the database is UNIQUELY identified.

The cons of indexing are:

• Inserts, updates, and deletes are all slowed down by indexes.
• Indexes take up a lot of space (this INCREASES with the number of fields used and the length of the fields).

SHELL is a PROGRAM that acts as the interface between the user and the operating system. It is a command-line interface to the Unix operating system. It collects data from you and runs programs depending on that data. The output of the program is displayed once it has completed its execution.

Shell allows us to run commands, programs, and shell SCRIPTS. Kernel maintains resources between processes and regulates all-important computer operations. It also restricts hardware access, organizes all performing utilities, and manages resources between processes. Only kernel users have access to the operating system's utilities.

Types of SHELLS:

• The C Shell: It included aliases and command history, among other features. It has features like built-in math and C-like EXPRESSION syntax that make programming easier.
• The Bourne Shell: It's the very first UNIX shell. It is more convenient and faster. It lacks interactive features such as the ability to recall past commands. It also has no built-in support for ARITHMETIC and logical expressions. It is the default shell for the Solaris operating system.
• The Korn Shell: The Bourne shell is a subset of it. As a result, everything in the Bourne shell is supported. It includes interactive elements. Built-in arithmetic and C-like arrays, functions, and string manipulation facilities are among the features. It is more efficient than a C shell. It works with scripts written in the C shell.
• The GNU Bourne-Again Shell: It can be used with the Bourne shell. It incorporates Korn and Bourne shell features.

Time slicing allows a task to run for a set amount of time before returning to the pool of ready TASKS. The scheduler then determines the executable job depending on the priority and a variety of other factors. A task in a time-slicing method runs for a predetermined amount of time. If there is another task with a higher priority after that task is completed, the scheduler runs the priority task next, BASED on priority and other considerations. 

The advantages of time slicing in CPU Scheduling are:

• CPU resources are distributed fairly. The kernel of our CPUs does not simply allocate all of our PCs' resources to a single task or service. Because the CPU is always running multiple processes that are required for it to function, our kernel manages these processes without delay.
• It prioritizes all processes equally. The CPU accomplishes this by running processes one at a time, slice by slice. A time slice is a brief period of time that is allotted to a process and executed by the CPU.
• It's simple to integrate into the system.
• After a process has run for a set amount of time, it is interrupted and another process runs for the same amount of time. To save the states of preempted processes, the context switching approach is utilised. Hence, the states of the preempted processes are not lost.

The disadvantages of time slicing in CPU Scheduling are:

• The processor output will be delayed if the slicing time is short.
• It spends a lot of time switching between contexts.
• The time quantum/slice has a significant impact on process management.
• Processes do not have defined priorities.
• Priority is not given to more vital jobs.
• It's challenging to come up with an adequate time quantum/slice.

The following are some of the most important features of an operating system:

• The operating system allows diverse applications and peripheral devices to share the computer's memory and central processing unit time.
• Between the user and the computer hardware, an Operating System serves as a communication bridge (interface). A user interface, such as a graphical user interface or a command LINE, is provided by an operating system.
• The ability to boot the computer is part of an operating system.
• It manages the peripheral devices and does some simple activities like keeping a track of all devices connected to the system, DESIGNATING a program called the Input/Output Controller that is responsible for EVERY device, and so on.
• It offers file management, which is the process by which an operating system maintains, fetches, manipulates, and saves data.

//Javascriptfunction fib(n){ let [x, y] = [0, 1] while (n > 0){ [x, y] = [y, x + y] n -= 1 } return x}

This SOLUTION has a linear time complexity of O(n) and a constant space complexity of O(1). The number of loops required to determine the nth fib number will STILL increase linearly as n increases, but as we extend the sequence out, we are OVERRIDING the previous NUMBERS in the sequence, KEEPING the space complexity constant for any input n. It is often referred to as the Iterative Top-Down Approach.

We know that LCM (x, y) = (x * y) / GCD (x, y). We have to extend this idea to an array of numbers.

Let's imagine we have an array arr[] with n members for which the LCM must be calculated.

Our algorithm's major steps are as FOLLOWS:

• Set res = arr[0] as the first value.
• Iterate over all of the array's elements, from i = 1 to i = n-1.
  Our lcm, which is stored in res, is LCM of (arr[0], arr[1],........, arr[i-1]) at the ITH iteration. LCM (arr[0], arr[1],...., arr[i]) = LCM (ans, arr[i]). As a result, we only need to do res = LCM (ans, arr[i]) = (ans * arr[i]) / gcd at the i'th iteration (ans, arr[i]).

Output:

A copy CONSTRUCTOR is a member function that uses another object of the same class to initialise an object. Assignment operators are used to giving a variable a value. The assignment operator's left side OPERAND is a variable, while the assignment operator's right side operand is a value.

Output:

When a new object is GENERATED from an existing object as a copy of the old object, the copy constructor is called. When an already initialised object is given a new value from another object, the assignment operator is used.

Both delete() and free() are USED to dynamically deallocate memory.

• The free() function is a C library function that can ALSO be used in C++, whereas the keyword "delete" is a C++ keyword.
• The delete operator DELETES a pointer that was allocated using the new operator or a NULL pointer, whereas the free() function deletes a pointer that was allocated with the malloc(), calloc(), or realloc() functions or a NULL pointer.
• The delete operator in C++ invokes the class's destructor when it destroys the allocated memory, but the free() function does not; it just frees the memory from the HEAP.

Stack Unwinding is the process of eliminating function ENTRIES from the function CALL stack at runtime. EXCEPTION Handling is often ASSOCIATED with Stack Unwinding. When an exception occurs in C++, the function call stack is searched linearly for the exception handler, and any entries before the function with the exception handler are deleted from the function call stack. If the exception is not handled in the same code, stack unwinding is REQUIRED (where it is thrown).

A precondition is a condition that must be met before a member FUNCTION may be called. If PRECONDITIONS are never false, a CLASS is appropriately used. If a precondition fails to hold, the following function is not executed. For EXAMPLE, before inserting an element into a stack, we call the isfull() to check if the stack is full or not. Here, the isfull() is an example of a precondition.

A post-condition is a condition that must be true when a member function is exited if the precondition was true when the function was entered. For a code to be correctly implemented, the post-conditions must never be false For example, we know that isempty() must always hold after placing an element ONTO the stack. This is a push operation post-condition.

An error occurs when a user performs an unauthorised action that causes the code to behave abnormally. Errors in programming are frequently UNNOTICED until the code is compiled or run. Some of the errors make it impossible to compile or run a program. As a result, errors should be removed before COMPILING and running a program. Out of memory and system crash are two examples of errors.

In Java, an exception is an unwelcome or unexpected occurrence that occurs during the program execution, or during run time, and disturbs the usual flow of the program's instructions. Exceptions are circumstances that arise during the program execution and may result in its termination. However, try, catch, and throw keywords can be USED to recover them.

Unchecked exceptions (exceptions which are not checked at compile time), such as ArrayIndexOutOfBoundException, are KNOWN to the compiler at runtime, whereas checked exceptions (exceptions which are checked at compile time), such as IOException, are known to the compiler at compile time.

An association is a relationship that exists between two distinct classes and is established through their Objects. One-to-one, one-to-many, many-to-one, and many-to-many associations are all possible.

An Object communicates with other Objects to leverage the capabilities and services provided by that object in Object-Oriented programming. Association has two forms and they are composition and aggregation.

Aggregation is a unique type of association in which:

• It denotes a Has-A relationship.
• It's a one-way relationship or a unidirectional association.
• In Aggregation, both entries can PERSIST independently, IMPLYING that terminating one entity will have no influence on the other.

In the above image, we can clearly see that each teacher is associated with a college, and each student is also associated with a college. Thus, both the entities, the student and the teacher can exist independently. 

Composition is a type of Aggregation in which two entities are extremely reliant on one another.

• It denotes a part-of-relationship.
• Both entities are reliant on one another in composition.
• When two entities COME TOGETHER to form a composition, the composite object cannot exist without the other.

In the above image, we can clearly see that both TYRE and Engine form an integral part of a vehicle. Both are reliant on each other. Without either of them, the Vehicle entity is useless.

There are two ways to ask the JVM to run the Garbage Collection.

• The garbage collection methods are available in the Runtime CLASS given by Java. For any Java program code, the Runtime class is a singleton. A singleton instance of the Runtime class is returned by the function getRuntime(). This instance of Runtime can be used to call the gc() function to request garbage collection.
• Request the JVM to PERFORM GC USING the System class System.gc() function.

Output:

Explanation:

In the above code, we create two instances of a class and then re-initialize it to null. Then we call for the garbage collection using the two methods specified above. Thus, we get the above output.

Order of precedence:

The operators are arranged in order of precedence. When a number of operators are employed in an expression, the priorities of the operators determine how the expression is evaluated. In an expression CONTAINING multiple operators with various PRECEDENCES, operator precedence decides which one is executed first.

Order of precedence example:

The following expression is the same as:

The expression (2 + 8) will be executed first, yielding a value of 10.

After the first HALF of the equation (4 > 10) executes, the output is 0 (false).

Finally, (0 && 3) runs and returns 0. (false).

Associativity:
When two operators with the same precedence EXIST in an expression, associativity is employed. Left to right or right to left associativity is possible. To determine whether an expression is evaluated from left to right or right to left, associativity is used.

Associativity example:

Operators * and / have the same precedence in this case. "*" and "/" are both left to right associative, which means that the expression on the left is executed first and then moves to the right.

As a result, the preceding expression is identical to:

The FOLLOWING are the main differences between object-oriented and object-based LANGUAGES.

• Object-oriented languages adhere to all Object Oriented Programming concepts, but object-based languages do not adhere to all Object Oriented Programming concepts such as inheritance, polymorphism, etc.
• Object-oriented languages lack built-in objects, but object-based languages do. For example, JavaScript contains a built-in window object.

Java, C#, Smalltalk, and others are examples of object-oriented programming languages while JavaScript, VBSCRIPT, and others are examples of object-based languages.

Macros are sections of code in a programme that have been given a name. The compiler substitutes this name with the real piece of code whenever it encounters this name. To define a macro, use the '#define' directive. Macros can be defined either before or within the main method. 

Code 1:

Output:

Explanation:

In the above code, we defined a macro NAMED HRS to have a VALUE of 24. Now, when we call the macro in the printf function, 24 GETS printed in the output terminal.

The above code can be INFERRED to be the following code without the use of macros.

Code 2:

Output :

Explanation:

Here, we defined a function named HRS. When we call the HRS function in the printf function, the function returns 24 and so 24 is printed on the output terminal.

Macros are pre-processed, which implies that all macros are processed before the code is compiled, and functions are processed after the code is compiled.