Explore topic-wise InterviewSolutions in .

A programming LANGUAGE is referred to as a pure object-oriented language if everything within the program is treated as an object. The pure Object Oriented Programming language does not support primitive types. A pure object-oriented programming language must also satisfy the following properties:

• Encapsulation: Encapsulation can be defined as the wrapping up of data members and member functions into a single entity. In encapsulation, data and the functions that alter it are bound together in Object-Oriented Programming.
  Let us take a real-world example of encapsulation into consideration: a company has various departments, including accounting, finance, and sales, to name a few. All financial transactions are handled by the finance department, which also keeps TRACK of all financial data. The sales department, therefore, is in charge of all sales-related activities and keeps track of all sales. For whatever reason, an official from the finance department may occasionally request all of the sales data for a specific month. He is not allowed to access the data in the sales area directly in this case. He must first speak with another sales officer and request that he deliver the needed information. It is all about encapsulation. The data from the sales department, as well as the personnel who can affect it, are grouped under the heading "sales division." Data abstraction or hiding is also a result of encapsulation. Because encapsulation hides data, it is a good idea to use it. The data of any of the sections, such as sales, finance, or accounting, is hidden from any other component in the above example.

• Inheritance: Inheritance refers to a class's capacity to derive features and traits from another class. One of the most significant characteristics of Object-Oriented Programming is inheritance.
  • Sub Class or Derived Class: A Sub Class or Derived Class is a class that inherits properties from another class.
  • Base Class or Super Class: A Base Class or Super Class is a class whose properties are inherited by subclasses.
    Inheritance supports the concept of "reusability," which means that if we want to create a new class but there is already one that contains some of the code we need, we can derive our new class from the old one. We are reusing the old class's fields and functions in this way.
    Dog, Cat, and Cow are examples of Animal Base Class Derived Classes.

• Polymorphism: Polymorphism refers to the fact that something exists in multiple forms. Polymorphism, in simple terms, is the ability of a message to be displayed in multiple formats. At the same time, a person might have a variety of characteristics. At the same time, he is a father, a spouse, and a worker. As a result, the same person behaves differently in different settings. Polymorphism is the term for this. In different situations, an operation may behave differently. The behaviour is determined by the data types utilised in the operation. Operator and function overloading are supported in C++ which inherit Polymorphism.
  • Operator Overloading: Operator overloading is the process of forcing an operator to behave differently in different situations.
  • Function Overloading: When a single function name is used to accomplish many tasks, this is known as function overloading.
    Inheritance is frequently implemented via polymorphism. An example of Polymorphism is given below:
    Consider the following scenario: We need to construct a function to add several integers; sometimes there are two integers, and other TIMES there are three integers. We can WRITE the sum Method with the same name but different parameters and the method concerned will be invoked based on the parameters.

• Abstraction: One of the most fundamental characteristics of object-oriented programming in C++ is data abstraction. Abstraction refers to revealing only the most important information while concealing the details. Data abstraction refers to exposing only the most important aspects of the data to the outside world while concealing the IMPLEMENTATION specifics. Consider the case of a man at the wheel of a car. The man only knows that pressing the accelerators will increase the car's speed and that applying the brakes will stop it, but he has no idea how the speed is increased by pressing the accelerators, nor does he understand the car's inner mechanism or how the accelerator, brakes, and other controls are implemented in the car. This is the definition of abstraction. There are two ways in which Abstraction can be implemented:
  • Abstraction using Classes: We may use classes to implement Abstraction in C++. Using the available access specifiers, the class assists us in grouping data members and member functions. A-Class has the ability to control which data members are visible to the outside world and which are not.
  • Abstraction in Header Files: Header files are another sort of abstraction that can be used in C++. Consider the pow() method in the math.h header file, for example. We just call the function pow() in the math.h header file whenever we need to calculate the power of a number and supply the numbers as arguments, without knowing the underlying algorithm through which the function calculates the power of numbers.
    • Objects are all predefined types.
    • Objects are all user-defined types.
    • All operations on objects must be done through methods that have been exposed to the objects.

Because predefined data types are not recognized as objects in Java, it is not a pure object-oriented programming language.

The pros of using Object-Oriented Programming  Languages are as follows:

• Object-Oriented Programming  Languages follow a bottom-up approach which helps programmers in simulating the real world and its entities.
• It makes code re-usability possible.
• Using abstraction, the user is not exposed to superfluous data.
• Object-Oriented Programming  Languages requires designers to go through a LENGTHY and thorough design phase, which yields a better design with fewer faults.
• Object-Oriented Programming  Languages break down a large problem into smaller pieces.
• Programmers are able to achieve their objectives more quickly via Object-Oriented Programming  Languages.
• The usage of Object-Oriented Programming Languages reduces the amount of complexity of code written by programmers.
• Code may be EASILY redesigned and EXTENDED without affecting other features.

The cons of using Object-Oriented Programming  Languages are as follows:

• It is necessary to do a lot of PLANNING in order to use these languages.
• There is a tendency for classes to be overly generalized in Object-Oriented Programming Languages.
• These are not SUITABLE for small problems as they lead to over-complication.
• In certain instances, programs written in Object-Oriented Programming Languages can consume a lot of memory which is obviously unwanted.

A few benefits of using C ++ as a language are as follows:

• C++ not only preserves all parts of the C language but also simplifies memory management.
• C++ is a highly PORTABLE language, which implies that CODE written in it may operate on any platform.
• Classes, objects, inheritance, polymorphism, and abstraction are all ideas of C++, which is an object-oriented programming language.
• Inheritance is a notion in C ++. Through inheritance, unnecessary code can be removed and existing classes can be reused.
• Data HIDING aids the programmer in creating secure APPLICATIONS that are not vulnerable to intruders.
• Message passing is a communication method that allows objects to communicate with ONE another.
• C++ has a large library of functions.

A subquery in SQL is a query that is defined inside ANOTHER query to retrieve data or information from the database. The outer query of a subquery is referred to as the main query, while the inner query is referred to as the subquery. Subqueries are always PROCESSED first, and the subquery's RESULT is then passed on to the main query. It can be nested inside any query, including SELECT, UPDATE, and OTHER. Any comparison operators, such as >, or =, can be used in a subquery. The syntax of a subquery in SQL is given as follows:

A SQL query using subqueries to find all the employees with SALARIES GREATER than five thousand in the employee's table is given below:

A transaction is a logical unit of work performed on a database. Transactions are logically ordered units or sequences of work that can be completed manually by a human or automatically by a database application. The propagation of ONE or more changes to the database is referred to as a transaction. For instance, whether you create, update, or delete a record from a table, you are completing a transaction on that table. To preserve data integrity and address database issues, it's critical to keep track of these transactions. In practice, you will group several SQL queries TOGETHER and run them all at the same time as part of a transaction. Transactions n SQL contain the four standard qualities listed below, which are frequently abbreviated as ACID.

• Atomicity: Atomicity ensures the successful completion of all processes INSIDE the work unit. Otherwise, the transaction will be aborted at the point of FAILURE, and all preceding activities would be reversed.
• Consistency: When a transaction is successfully committed, consistency ensures that the database changes states properly.
• Isolation: Isolation allows transactions to execute independently of one another while remaining TRANSPARENT to them.
• Durability: Durability ensures that a committed transaction's outcome or effect is preserved in the event of a system failure.

Index HUNTING is the process of enhancing a collection of indices. The purpose of doing Index Hunting is that INDEXES make the performance of the QUERIES better and ALSO reduce the TIME required to process a query. Given below are the various ways in which Index Hunting improves the  performance of the queries:

• The most optimal queries are suggested with the usage of the query optimizer.
• For checking the effect, measurements such as index, query distribution, and performance are used.
• Optimization is also done on the databases for a few of the problem queries.

The meaning of Intension and Extension are as follows:

• Intension: Intension, often known as Database Schema, is a term that refers to the description of a database. This is DEFINED during database design and is largely unmodified.
• Extension: The number of tuples available in the database at any given TIME is REFERRED to as the extension. The value of this variable changes as tuples are CREATED, UPDATED, and destroyed. As a result, the data in the database at a certain point in time is referred to as the database's extension or, more generally, the database's snapshot.

The meaning of the GIVEN terms are as follows:

• Proactive Updates: These changes are made to the database before it is PUT into use in the ACTUAL WORLD.
• Retroactive Updates: These updates are applied to a database after it has been operational in the real world.
• Simultaneous Updates: These updates are applied to the database at the same moment as they become effective in the actual world.

In Database Management Systems, there are three basic levels of data ABSTRACTION. They are as follows:

• Physical Level: The physical level of abstraction specifies how data is stored and is the lowest DEGREE of abstraction.
• Logical or CONCEPTUAL Level: After the Physical level, there is the Logical level of abstraction. This layer decides what data is saved in the database and how the data pieces relate to ONE another.
• View Level: The greatest level of abstraction, the View Level describes only a PORTION of the entire database.

 The DEFINITION of the given TERMS are as follows:

• Aggregation: Aggregation is an ENTITY Relationship model feature that allows one relationship SET to interact with another relationship set.
• Atomicity: The atomicity attribute specifies that a database alteration must either adhere to all of the rules or not at all. As a result, if one portion of the transaction FAILS, the transaction as a whole fails.

ACID is an acronym for Atomicity, Consistency, Isolation, and Durability. A transaction is a logical unit of work that reads and updates the contents of a DATABASE in some instances. Transactions employ read and write operations to access data. To maintain database consistency, certain properties are followed before and after a transaction. They are referred to as ACID properties. LET us now take a closer look at each of these characteristics:

• Atomicity: When a transaction is ATOMIC, it means that it either happens all at once or it does not happen at all. There is no intermediate ground, which means that there are no steps to transactions. Each transaction is viewed as a single entity that is either completed or not. It entails the two processes listed below.
  • Abort: Any database updates are lost if a transaction aborts.
  • Commit: When a transaction commits, the changes contained within it become visible. 
    Atomicity is often known as the "all or nothing rule.

Think about the following scenario: T, which is made up of two separate transactions: T1 and T2. A $100 transfer was made from account X to account Y.
The amount deducted from X but not added to Y is deducted if a transaction fails after T1 but before T2 (for example, after write(X) but before write(Y)). As a result, the database is in a state of inconsistency. As a result, to ensure that the database state is legitimate, the transaction must be completed in its entirety.

• Consistency: To ensure that the database is consistent, integrity constraints must be maintained both before and after the transaction. It relates to the accuracy of a database. As seen in the sample above, the total amount before and after the transaction must be maintained.
  The total before T is 500 + 200 = 700.
  The total after T is 400 + 300 = 700.
  As a result, the database is well-organized. There is inconsistency when T1 succeeds but T2 fails. As a result, T isn't finished.
• Isolation: This property ENSURES that several transactions can run concurrently without generating database state inconsistencies. Transactions are carried out in a non-disruptive manner. Changes in one transaction are not visible to other transactions until the change for that transaction is put to memory or committed. This feature ensures that concurrently running transactions provide the same state as if they were run sequentially in some order. To better understand Isolation, consider the following scenario. Let us say X and Y are both 500, and there are two transactions T and T."

Assume T has been operating until Read (Y), after which T" will start. T" reads the correct value of X but the incorrect value of Y as a result of this interleaving, and the sum computed by T" (X+Y = 50, 000+500=50, 500) is inconsistent with the sum at the end of the transaction: T = 50, 000 + 450 = 50, 450 (X+Y = 50, 000 + 450 = 50, 450).
This results in a database inconsistency due to the loss of 50 units. As a result, transactions must be carried out in isolation, and modifications should be seen only after they have been written to the main memory.

• Durability: This property ensures that database updates and modifications are stored and written to disk after the transaction has concluded and that they survive even if the system fails. These modifications are now permanently recorded in nonvolatile memory. As a result, the transaction's effects are never lost.

Each transaction is a series of actions that works as a single unit, provides consistent outcomes, is separated from other processes, and the modifications it makes are durably stored, according to the ACID properties.

A diagrammatic APPROACH to database architecture in which real-world things are represented as entities and relationships between them are indicated is known as an Entity-Relationship model. Given below is an image of a sample ER diagram for a student studying in college.

The definition of the given terms are as follows:

• Entity: A real-world object with attributes that indicate the object's qualities is DEFINED as an entity. A student, an employee, or a teacher, for example, symbolizes an entity.
• Entity Type: A group of entities with the same attributes is referred to as an entity type. An entity type is represented by one or more linked tables in a database. Entity type or attributes can be thought of as a trait that distinguishes the entity from others. A student, for example, is an entity with properties such as student ID, student name, and so on.
• Entity SET: An entity set is a collection of all the entities in a database that belongs to a given entity type. For instance, a group of all students, employees, TEACHERS, and so on represents an entity set.

Data warehousing is the PROCESS of collecting, extracting, processing, and importing data from numerous sources and storing it in a single database. A data warehouse can be thought of as a central repository for data analytics that receives data from transactional systems and other relational databases. A data warehouse is a collection of historical data from an organization that AIDS in decision making. The data from a data warehouse is further USED for Data visualization, REPORTING, BUSINESS intelligence and many more activities.

Some benefits of using views in a Database Management System are as FOLLOWS:

• Views can represent a subset of the data in a table. As a result, a view can limit the extent to which the underlying tables are exposed to the outside world: a user MAY be allowed to query the view but not the whole of the BASE database.
• Views can be used as aggregated tables, in which the database engine aggregates data (sum, average, and so on) and displays the generated results alongside the data.
• Views allow us to combine and simplify numerous tables into a single virtual table.
• Views take up extremely minimal storage space; the database simply MAINTAINS the specification of a view, not a copy of all the data it displays.
• Views can obscure data complexity.
• Views can give additional SECURITY depending on the SQL engine utilized.

A database object is any object defined in a database that is used to store or reference data. Everything we create from the create command is called a database object. It can be used to store and manipulate data. Some examples of database objects are as follows: 

• Table - Table is a basic storage unit with compound rows and columns. Its SYNTAX is as follows:

• Views - Views are a logical representation of subsets of data from one or more tables. A view is a logical table that is based on another view or a table. A view is similar to a window through which data from tables can be viewed or updated, but it does not include any data of its own. Base tables are the tables that a view is built on. In the data dictionary, the view is saved as a SELECT statement. Its syntax is as follows:

• Sequence - Sequences generate primary key values. A sequence is a database object that has been CREATED by a user and can be shared by several users to generate unique integers. The creation of a primary key value, which must be unique for each row, is a common use for sequences. An internal Oracle ROUTINE generates the sequence and increments (or decrements) it. Its syntax is as follows:

• Indexes - Indexes are used to improve the performance of some queries on the databases. This database object is used to create an index in the database. It is a schema object that can speed up row fetching by using a pointer. Indexes can be created explicitly or automatically. If you don't have an index on the column,  full crawling of the table will occur. Indexes provide direct and fast access to table rows. Its goal is to reduce disk Input and Output needs by using an indexed path to quickly locate data. The index is used and maintained automatically by the database server. Once an index is created, no direct action is required by the user. Indexes are LOGICALLY and physically independent of the table they index. This means they can be created or deleted at any time and do not AFFECT the base tables or other indexes. Its syntax is as follows:

• Synonyms - This database object is used to build database indexes. It creates a synonym to make object access easier (another name for an object). You can use synonyms to make referring to a table owned by another user easier and to shorten long object names. You must prefix the table name with the name of the user who created it, followed by a period, to refer to a table owned by another user. Creating a synonym for a table, view, sequence, procedure, or other object avoids the requirement to qualify the object name with the schema and gives you an alternate name. This approach is very handy when dealing with long object names, such as views.
  In terms of syntax, the meaning of various things are as follows:
  • PUBLIC: creates a synonym accessible to all users
  • SYNONYM: it is the name of the synonym to be created
  • OBJECT: identifies the object for which the synonym is created

Its syntax is as follows:

DATA independence is a concept ACCORDING to which, the change in data at one level of the DBMS three-tier architecture should not influence data at another level. Data independence is of two types of data independence:

• Physical Data Independence: According to Physical Data Independence, any change in the physical location of tables and indexes should have no bearing on the conceptual level or the external display of data. This data independence is simple to achieve and is supported by the majority of Database Management Systems.
• Conceptual Data Independence: According to Conceptual Data Independence, data at the conceptual and external levels must be independent. This means that any changes to the conceptual schema should have no impact on the external schema. Adding or removing CHARACTERISTICS from a table, for EXAMPLE, should have no effect on the user's view of the table. However, unlike physical data independence, this form of independence is more difficult to achieve SINCE changes in conceptual schema are mirrored in the user's view.

Some of the benefits of kernel-LEVEL threads are as follows:

• Kernel level threads can manage and schedule all threads.
• The scheduler may decide to USE more CPU time in a large threaded process.
• Kernel level threads are great for frequency blocking applications.

Some of the drawbacks of Kernel Level threads are as follows:

• Implementing kernel threads is harder than implementing user-level threads.
• The kernel-level THREAD is usually slower than the user-level thread.

Some advantages of User Level Threads are as follows:

• User Threads can be easily implemented over kernel threads.
• User-level threading can be applied to operating system types that do not support kernel-level threading.
• It is faster and more efficient. Context switch TIMES are shorter than kernel-level threads.
• It does not require any CHANGES to the operating system and REPRESENTING streams at the user level is simple.
• Small registers, PCs, stacks, and flow control blocks are stored in the address space of a user-level process.
• It is easy to create, change, and synchronize streams without process intervention.

Some Disadvantages of User Level Threads are as follows:

• User Level Threads lack coordination between thread and kernel.
• If one thread causes a page FAULT, the whole process is BLOCKED.

Multithreading is the ability of a central processing unit (CPU) (or a single core in a multi-core processor) to run many threads of CODE at the same time, with the operating system supporting it. Multiprocessing is not the same as Multiprocessing. Threads in a multithreaded application share resources from a single or several cores, such as computational units, CPU caches, and the Translation Lookaside Buffer or TLB (A translation lookaside buffer or TLB is a memory cache that speeds up access to user memory. It is a component of the Memory MANAGEMENT Unit or MMU on the chip. The TLB, also known as an address translation cache, records recent virtual memory to physical memory TRANSLATIONS). Multithreading TRIES to increase the use of a single core by exploiting thread-level parallelism as well as instruction-level parallelism in multiprocessing systems with several full processing units in one or more cores. Because the two approaches are complementary, they are used together in practically all modern system architectures that INCLUDE multiple multithreading CPUs and multithreading cores. 

We can see that in the above image, one single process has two threads of execution that run on one processor.

The advantages of thread over processes are as follows:

• Faster thread context SWITCHING: Thread context switching is faster than process context switching. Process context shift necessitates greater CPU overhead.
• Responsiveness: If the process is separated into numerous threads, the OUTPUT of one thread can be returned promptly as it completes its execution.
• Resource sharing: WITHIN a process, resources such as code, data, and files can be shared throughout all threads. It is worth noting that the stack and registers can't be shared between threads. Each thread has its own registers and stack.
• Effective multiprocessor system utilization: If a single process has numerous threads, we can schedule several threads on multiple processors. The process will run more quickly as a result of this.
• Increased System Throughput: When a process is separated into several threads, each thread function is treated as a single TASK, the number of jobs done per unit of TIME increases, boosting the system's throughput.
• Communication: Because the threads share a similar address space, communication between them is easier. During the process, we must use a special communication approach to communicate between the two processes.

A thread is a single sequential flow of task execution in a process, and it is also known as a thread of execution or a thread of control. Thread execution is possible within any operating system's process. Aside from that, several threads can exist within a process. A distinct program counter and a stack of activation records and control blocks are used by each thread of the same process. Threading is frequently referred to as a light technique. A process can be broken down into numerous threads. MANY tabs in a BROWSER, for example, can be considered as threads. MS Word employs many threads to prepare the text in one thread, receive input in another thread, and so on. Within a process, a thread is a single sequence stream. Threads have the same qualities as the process, hence lightweight processes are referred to as threads. Threads are executed one after the other, giving the appearance that they are running in parallel. Each thread has a unique state. Each thread is unique and has the following in them:

• A counter for a program.
• A series of registers.
• A STACKING area.

Threads are not self-contained since they share code, data, and other Operating System resources. There are two types of threads:

• User Level Thread (ULT) — This TYPE of thread is created in the user-level library rather than using system functions. Thread switching does not NECESSITATE a call to the Operating System or a kernel interrupt. The kernel is unaware of the user-level thread and treats them as single-threaded processes.
• Kernel Level Thread (KLT) - Kernel Level Thread or KLT is in charge of thread management. Instead of each process having its own thread table, the kernel maintains a master thread table that keeps track of all the threads in the system. In addition, the Kernel Level Thread keeps track of the processes using the standard process table. The kernel of the operating system includes system calls for creating and managing threads.

The term "Real-Time Operating System" REFERS to a system that is subjected to real-time constraints, i.e., the response must be guaranteed within a certain time restriction or the system must satisfy a specific deadline. 

For instance, a flight control system, real-time monitoring, and so on. Real-time systems with timing constraints include the FOLLOWING types:

• Hard Real-Time Operating System — A system of this type will NEVER miss a deadline. The implications of missing the deadline might be disastrous. If tardiness increases, the utility of a hard real-time system's result declines abruptly, and it may even become negative. Tardiness refers to how late a real-time system does a task in COMPARISON to its deadline. As an example, consider a flight controller system.
• Soft Real-Time Operating System — This type of system can occasionally miss its deadline with a low likelihood. There are no dire implications if you miss the deadline. With the increasing delay, the utility of a soft real-time system's result rapidly reduces. Switches on PHONES are examples of Soft Real-Time Operating Systems.

A few types of Operating Systems which I know about are as follows:

• Batch Operating System: A batch operating system is a computer program that automatically sequences jobs without the need for human interaction.
• Time-Sharing Operating System: Many people can share computer resources with a time-sharing operating system. There is maximum resource utilization in this type of operating system.
• Distributed Operating Systems: A distributed operating system (DOS) is software that manages a number of computers and makes them APPEAR to be one.
• Network Operating System: In-Network Operating Systems, computers with VARIOUS operating systems can connect to a common network. It is used usually for security purposes.
• Real-Time Operating Systems: Real-Time Operating Systems (RTOS) are employed in situations where a great number of events, most of which are external to the computer system, must be accepted and processed quickly or under tight deadlines. Industrial CONTROL, telephone switching equipment, aircraft control, and real-time simulations are examples of such uses.

Some examples of Operating Systems are as follows:

• Windows (Graphical User Interface Operating System based for Personal Computers)
• GNU or Linux (for Personal Computers, File and Print server, Workstations, ISP, Three-tier Clients and Servers)
• iOS (Apple’s OS for iPhone, iPad, and iPod Touch)
• MACOS (for Apple’s Personal Computers and Workstations like MacBook, iMac, etc.
• Android (Google’s Operating System for Google's smartphones, tablets, smartwatches, etc.)