Q.

Explain Type and Type classes in Haskell

Types in Haskell
 Definition: A type in Haskell is a way to classify values and expressions to ensure
correctness at compile time. Types define what kind of data an expression can
work with.
 Examples of Basic Types:
o Int: Integer numbers (e.g., 42)
o Float: Floating-point numbers (e.g., 3.14)
o Bool: Boolean values (True or False)
o Char: A single character (e.g., 'a')
o String: A list of characters (e.g., "Hello")
 Compound Types:
o Lists: [Int], [Char] (e.g., [1, 2, 3], "abc")
o Tuples: (Int, String) (e.g., (1, "Haskell"))
 Functions:
o Functions also have types, e.g., add :: Int -> Int -> Int.

Type Classes in Haskell

 Definition: A type class defines a set of operations (functions) that can be
implemented by different types. It is a way of defining generic behavior
 Key Features:
o Allows polymorphism: Functions can work with different types as long as
they belong to a specific type class.
o Defines constraints on types.

Common Type Classes

 Eq: Provides equality (==) and inequality (/=) operators.
o Example: instance Eq Int allows comparing integers for equality.
 Ord: Defines ordering (<, >, <=, >=).
o Example: instance Ord Int allows comparing integers for ordering.
 Show: Converts values into strings using show.
o Example: show 5 returns "5".
 Read: Parses strings into values using read.
o Example: read "5" :: Int gives 5.
 Num: Represents numeric types, enabling operations like addition and
multiplication.
Defining a Custom Type Class
 A type class can be created using the class keyword:
class My Class a where
my Function :: a -> a
Instance of a Type Class
  Specific types can implement a type class using the instance keyword:
instance My Class Int where
myFunction x = x + 1
Example
class Printable a where
printValue :: a -> String

instance Printable Int where

printValue x = "Int: " ++ show x

instance Printable Bool where

printValue x = "Bool: " ++ show x
Here, Printable is a type class that defines a function printValue. The types Int and Bool
implement this type class.
Significance
 Type Safety: Ensures operations are applied to appropriate types.
 Reusability: Generic functions can work with any type that implements a type class.
 Extensibility: Custom type classes allow defining new behaviors.
[Link] do you mean by Programming Paradigm? Explain with example the difference
between declarative and imperative programming paradigm
A programming paradigm refers to a style or approach to programming. It provides a
framework for designing and implementing software based on specific principles, concepts,
and methodologies. Common paradigms include imperative, declarative, object-oriented,
and functional programming. Each paradigm dictates how programs are structured and
how the logic of the computation is expressed.

Imperative vs. Declarative Programming Paradigm

1. Imperative Programming Paradigm
 Focuses on how to perform tasks.
 The programmer explicitly defines the steps (control flow) to achieve the desired
outcome.
 Includes loops, conditionals, and variable updates.
 Examples: C, Java, Python (when written procedurally).
Example (Imperative Approach): Finding the sum of numbers in a list.
numbers = [1, 2, 3, 4, 5]
sum = 0
for num in numbers:
sum += num
print(sum)

2. Declarative Programming Paradigm

 Focuses on what needs to be done, rather than how to do it.
 The programmer specifies the desired outcome, and the underlying system
determines how to achieve it.
 Examples: SQL, HTML, functional programming languages like Haskell.
Example (Declarative Approach): Finding the sum of numbers in a list.
numbers = [1, 2, 3, 4, 5]
result = sum(numbers)
print(result)
[Link] encapsulation. How does it differ from abstraction
Encapsulation:-Encapsulation is the process of bundling data (variables) and methods
(functions) that operate on the data into a single unit, usually a class. It also involves
restricting direct access to some of the object's components, making them accessible only
through well-defined interfaces.
Key Points:
1. Data Hiding: Encapsulation hides the internal implementation details of an
object from the outside world. Only necessary information is exposed through
methods (getters and setters).
2. Access Modifiers: Encapsulation is implemented using access specifiers
like private, protected, and public in languages like Java or C++.
3. Improved Security: By controlling access, encapsulation prevents unintended
interference and misuse of the data.
4. Example:
class Student {
private String name; public String getName() {
return name; }
public void setName(String name) {
[Link] = name; } }
Abstraction:-Abstraction is the process of hiding the complexity of a system by exposing
only the relevant details. It focuses on what an object does rather than how it does it.
Abstraction is primarily used to design interfaces and abstract classes.
Key Points:
Simplification: It simplifies complex systems by breaking them into smaller, more
manageable components.
Hiding Implementation: The implementation details are hidden, and only the essential
functionality is shown to the user.
Achieved Through: Abstract classes and interfaces in Java, for example.
Example:
abstract class Shape {
abstract void draw();}
class Circle extends Shape {
void draw() {
[Link]("Drawing Circle"); } }
[Link] are Scripting Languages? Explain characteristics of scripting languages

Scripting Languages

Scripting languages are programming languages designed to automate tasks, control other
software, or create dynamic behavior within applications. They are often interpreted
rather than compiled and are commonly used for web development, system
administration, game scripting, and more.

Characteristics of Scripting Languages

[Link] Execution

 Scripting languages are usually interpreted, meaning code is executed line-by-line

by an interpreter, rather than being compiled into machine code.
 Example: Python, JavaScript, and PHP.

[Link] of Use

 They are often simpler and more user-friendly compared to traditional

programming languages. They have minimal syntax and quick execution for smaller
tasks.

[Link]-level Abstractions

 Scripting languages offer high-level abstractions, allowing developers to perform

complex tasks with simple commands.

[Link] Typing

 Variables in scripting languages are not bound to a specific data type. The data type
is determined at runtime.
 Example: In Python, x = 5 and x = "Hello" are both valid.

[Link] Language

 Scripting languages are often used to "glue" other software components together.
They can control or interact with multiple systems or software.

[Link] Independence

 Most scripting languages are platform-independent, meaning the same script can
run on multiple operating systems with little or no modification.

[Link] Development
  Due to their simplicity and minimal compilation requirements, scripting languages
enable quick prototyping and faster application development.

[Link]-driven and Embeddable

 Scripting languages like JavaScript are often used in event-driven programming.

They can also be embedded into larger programs to extend functionality.

[Link] Memory Management

 Many scripting languages have built-in garbage collection and memory

management, reducing the programmer's workload.

[Link] Applicability

 They are used in various domains such as web development (JavaScript, PHP),
system administration (Bash, PowerShell), and data analysis (Python, R).

Examples of Scripting Languages

 Python: General-purpose scripting, data analysis, machine learning.

 JavaScript: Web development, client-side and server-side scripting.
 PHP: Server-side web development.
 Bash: System administration and task automation.
[Link] is Inheritance? Explain different types of Inheritance in OPP
Inheritance in Object-Oriented Programming (OOP):
Inheritance is a fundamental concept in OOP that allows one class (child or derived class)
to acquire the properties (fields) and behaviors (methods) of another class (parent or base
class). It promotes code reusability and establishes a relationship between classes,
supporting hierarchical design and polymorphism.
Types of Inheritance in OOP
[Link] Inheritance:
 A child class inherits from a single parent class.
 Example:
class Parent {
public:
void display() { cout << "Parent class"; } };
class Child : public Parent { };
[Link] Inheritance:
o A class inherits from another derived class, creating a chain of inheritance.
o Example:
class Grandparent {
public:
void show() { cout << "Grandparent class"; } };
class Parent : public Grandparent { };
class Child : public Parent { };
[Link] Inheritance:
o Multiple child classes inherit from a single parent class.
o Example:
class Parent {
public:
void display() { cout << "Parent class"; } };
class Child1 : public Parent { };
class Child2 : public Parent { };
[Link] Inheritance:
o A child class inherits from more than one parent class.
o Example:
class Parent1 {
public:
void show1() { cout << "Parent1 class"; } };
class Parent2 {
public:
void show2() { cout << "Parent2 class"; } };
class Child : public Parent1, public Parent2 { };
[Link] Inheritance:
o A combination of multiple and hierarchical inheritance.
o This often results in a "diamond problem," which is solved using virtual
inheritance in languages like C++.
o Example:
class A {
public:
void display() { cout << "Class A"; } };
class B : public A { };
class C : public A { };
class D : public B, public C { };
Key Points:
 Inheritance facilitates reusability, extensibility, and modular design.
 Proper use ensures reduced redundancy and maintains clear hierarchies.
 Challenges like ambiguity in multiple inheritance are addressed using virtual
inheritance or interfaces.
[Link] different storage allocation mechanism
1. Static Allocation
 Definition: Memory is allocated at compile time, and the allocation size is fixed
throughout the program's execution.
 Characteristics:
o Suitable for variables with known sizes and lifetimes (e.g., global variables,
static variables).
o Memory location is reserved in the data segment.
 Advantages:
o Simple and efficient.
o No runtime overhead.
 Disadvantages:
o Inefficient use of memory if the program has unused or oversized variables.
o Cannot accommodate dynamic or recursive data structures.
 Example:
int x = 10; // Memory for x is allocated statically.
2. Stack Allocation
 Definition: Memory is allocated and deallocated in a Last-In-First-Out (LIFO)
manner using a stack data structure.
 Characteristics:
o Used for local variables, function parameters, and return addresses.
o Memory is automatically managed as functions are called and return.
o Resides in the stack segment of memory.
 Advantages:
o Efficient allocation and deallocation.
o Automatic cleanup of memory after function exits.
 Disadvantages:
o Limited to small, temporary storage needs.
o Stack overflow may occur if memory demand exceeds stack size.
 Example:
void func() {
int y = 5; // Memory for y is allocated on the stack. }
3. Heap Allocation
 Definition: Memory is allocated dynamically at runtime from the heap segment.
 Characteristics:
o Suitable for dynamically sized data structures (e.g., linked lists, trees).
o Requires explicit allocation (e.g., malloc, new) and deallocation (e.g., free,
delete).
 Advantages:
 o Provides flexibility to handle variable-sized data.
o Suitable for long-lived data structures.
 Disadvantages:
o Memory fragmentation may occur.
o Programmer responsibility for deallocation can lead to memory leaks.
 Example:
int* ptr = (int*)malloc(sizeof(int)); // Dynamically allocates memory.
free(ptr); // Explicit deallocation.
4. Dynamic Allocation (Runtime Allocation)
 Definition: Memory is allocated during the program's execution, based on program
needs.
 Characteristics:
o Encompasses both stack and heap allocation.
o Used for arrays or data structures whose size is unknown at compile time.
 Advantages:
o Adaptable to changing memory needs.
 Disadvantages:
o Overhead of managing memory dynamically.
 Example:
int n;
scanf("%d", &n);
int arr[n]; // Memory allocated dynamically based on user input.
5. Memory Pool Allocation
 Definition: Memory is pre-allocated in chunks or pools for specific use cases,
improving allocation speed.
 Characteristics:
o Often used in embedded systems or real-time applications.
 Advantages:
o Faster allocation and deallocation.
o Reduces fragmentation.
 Disadvantages:
o Limited flexibility for varying memory sizes.
 Example:
Predefined memory pools for fixed-size objects.
[Link] is logic programming? Explain Facts and Rules along with an example
Logic Programming
Logic programming is a programming paradigm that is based on formal logic. Programs in
this paradigm consist of a set of sentences in logical form, expressing facts and rules about
some problem domain. The execution of a logic program is a process of automated
reasoning that attempts to derive conclusions from the given facts and rules.
Prolog (short for Programming in Logic) is the most widely used logic programming
language. Logic programming is particularly useful for problems involving knowledge
representation, databases, natural language processing, and artificial intelligence.

1. Facts
Facts represent basic information or truths about the problem domain. They are always
true and do not depend on any conditions. In logic programming, facts are stated as
atomic predicates with arguments.
 Syntax of Facts:
predicate(argument1, argument2, ...).
 Example of Facts:
parent(john, mary).
parent(mary, susan).
Here:
 parent(john, mary) means John is the parent of Mary.
 parent(mary, susan) means Mary is the parent of Susan.

2. Rules
Rules are conditional statements that define relationships between facts or other rules.
They consist of a head (conclusion) and a body (condition). A rule states that the head is
true if the body is true.
 Syntax of Rules:
head :- body.
The :- symbol can be read as "if".
 Example of Rules:
grandparent(X, Y) :- parent(X, Z), parent(Z, Y).
Here:
 grandparent(X, Y) states that X is the grandparent of Y if X is a parent of Z and Z is a
parent of Y.

3. Example Combining Facts and Rules

Facts:
parent(john, mary).
parent(mary, susan).
parent(anna, john).
 Rule:
grandparent(X, Y) :- parent(X, Z), parent(Z, Y).
 Query:
To find the grandparent of Susan, we can query:
?- grandparent(X, susan).
Output:
X = john.
This output indicates that John is the grandparent of Susan.
[Link] Static Scoping vs. Dynamic Scoping.

Aspect Static Scoping Dynamic Scoping

Definition The scope of a variable is The scope of a variable is

determined at compile time, determined at runtime, based
based on the program's on the program's call stack
structure.
Binding of Variables Variable binding is resolved Variable binding depends on
by examining the program’s the execution sequence of the
code structure. program.
Implementation Uses a symbol table created Requires a runtime stack to
at compile time. manage variable bindings.
Performance Faster because bindings are Slower because bindings need
pre-determined during to be resolved dynamically
compilation. during execution.
Readability Improves code readability Reduces readability as variable
and predictability. bindings may change
dynamically.
Example Static Scoping: Dynamic Scoping:
<br>x = 10<br>def foo():<br> <br>x = 10<br>def foo():<br>
print(x)<br>foo()<br>Output: print(x)<br>def bar():<br> x =
10 20<br>
foo()<br>bar()<br>Output: 20
Advantages - Predictable behavior. - Flexibility in certain cases.
- Easier to debug and - Simplifies the implementation
maintain. of closures in some contexts.
Disadvantages - Less flexibility in reusing - Unpredictable behavior.
variables across different - Hard to debug and maintain.
scopes.
Languages Used in most modern Used in some older languages
programming languages like like Lisp (in early versions) and
C, C++, Python (default), and Bash.
Java.
Q. What is the role of an Exception Handler in a programming language? Briefly explain
important tasks it performs.
An Exception Handler in a programming language is a block of code designed to
manage runtime errors or exceptions that may occur during the execution of a program.
Its primary role is to ensure that the program doesn't crash or behave unpredictably when
errors occur. Instead, it allows the program to respond to exceptions in a controlled
manner. The key tasks performed by an exception handler are:
1. Detecting Exceptions: The exception handler identifies when an error or
exceptional condition occurs during program execution. This may be due to invalid
user input, a network failure, or an attempt to access a non-existent file.
2. Handling Errors Gracefully: Once an exception is detected, the handler takes
appropriate actions, such as displaying user-friendly error messages, logging the
error for later analysis, or correcting the issue (if possible).
3. Maintaining Program Flow: Instead of allowing the program to terminate abruptly,
the exception handler ensures that the program can continue its execution, either
by recovering from the error or by redirecting the flow to a safe part of the
program.
4. Resource Management: The handler also manages system resources, such as
closing files, releasing memory, or terminating connections properly, to avoid
resource leaks.
5. Custom Exception Handling: It allows developers to define custom exceptions,
enabling more specific and meaningful error messages or actions tailored to the
needs of the application.
6. Preventing Program Crashes: By catching exceptions and handling them effectively,
it prevents the program from crashing, thereby improving robustness and reliability.

Q. Explain lifecycle of a thread.

The lifecycle of a thread in Java refers to the various stages a thread undergoes
from creation to termination. Here's a brief explanation of each stage:
1. New (Born) State: When a thread object is created but not yet started, it is in the
new state. At this stage, the thread has not yet been scheduled for execution.
2. Runnable State: After the thread’s start() method is called, it enters the runnable
state. In this state, the thread is ready to run, but the CPU might not assign it
resources immediately, depending on the thread scheduler. A thread can be in the
runnable state even if it is not actively executing (waiting for CPU time).
3. Blocked State: A thread enters the blocked state when it cannot proceed because it
is waiting for a resource, such as I/O or a lock. This can occur if the thread is
waiting for access to a synchronized block or another resource that is currently
being used by another thread.
4. Waiting State: A thread enters the waiting state when it waits indefinitely for
another thread to perform a particular action (like join() or wait() method). The
thread will remain in this state until it is notified or interrupted.
5. Timed Waiting State: A thread enters this state when it waits for a specific amount
of time, as specified by methods like sleep(milliseconds) or join(milliseconds). After
the specified time elapses, the thread returns to the runnable state.
6. Terminated (Dead) State: A thread enters the terminated state once it completes its
task or if it is interrupted. Once in this state, the thread cannot be restarted or
reused.
Q. Discuss Call by value vs Call by reference with example code in C or C++

Call by Value vs Call by Reference in C/C++

In C and C++, function arguments can be passed in two different ways: Call by Value and
Call by Reference. The main difference between these two is how the function receives
and modifies the arguments. Here’s an explanation of both, with example code for each
approach.
1. Call by Value
In Call by Value, a copy of the actual value of the argument is passed to the function. The
function operates on the copy, and any changes made to the parameter inside the function
do not affect the actual value outside the function.
 Example Code (Call by Value):
#include <iostream>
using namespace std;
void addTen(int num) {
num = num + 10; // Modifies the local copy of num
cout << "Inside function (Call by Value), num = " << num << endl; }
int main() {
int x = 5;
cout << "Before function call, x = " << x << endl;
addTen(x); // Passes a copy of x
cout << "After function call, x = " << x << endl; // x remains unchanged
return 0; }
 Output:
Before function call, x = 5
Inside function (Call by Value), num = 15
After function call, x = 5

2. Call by Reference
In Call by Reference, the actual address of the argument is passed to the function. This
means the function works with the actual data and any changes made inside the function
directly affect the original variable in the calling function.
 Example Code (Call by Reference):
#include <iostream>
using namespace std;
void addTen(int &num) {
num = num + 10; // Modifies the original variable
cout << "Inside function (Call by Reference), num = " << num << endl;
}
int main() {
int x = 5;
cout << "Before function call, x = " << x << endl;
addTen(x); // Passes the reference (address) of x
cout << "After function call, x = " << x << endl; // x is modified
return 0; }
 Output:
Before function call, x = 5
Inside function (Call by Reference), num = 15
After function call, x = 15
Q. Curried Function in Haskell

A curried function in Haskell refers to a function that takes multiple arguments one at a
time, each returning a new function that takes the next argument. It allows partial
application of functions, meaning you can apply some arguments to a function and get
another function that expects the remaining arguments.
 Explanation:
In Haskell, every function is curried by default. This means that a function that looks like it
takes multiple arguments (e.g., add x y = x + y) is actually a function that takes the first
argument (x) and returns a function that takes the second argument (y), and so on.
 Example:
Let’s define a simple curried function that adds two numbers:
add :: Int -> Int -> Int
add x y = x + y
The function add takes the first argument x (of type Int), and returns a new function that
takes the second argument y (of type Int), and then returns their sum. Here, the type
signature Int -> Int -> Int means that add is a function that takes an Int and returns a
function of type Int -> Int, which ultimately returns an Int.

You can apply add to arguments partially:

addFive = add 5 -- `addFive` is now a function `Int -> Int`
result = addFive 3 -- `addFive` applied to 3 returns 8
This is how currying works:
 add 5 returns a function of type Int -> Int.
 When we apply addFive 3, it gives the result 8.

Partial Application:
Partial application is the process of supplying some arguments to a function, leaving the
rest to be provided later. With currying, this becomes very straightforward.
 Example:
addFive = add 5 -- A partially applied function
result = addFive 10 -- 5 + 10 = 15

Benefits of Currying:
1. Reusability: You can create specialized functions by partially applying a curried
function.
2. Functional Composition: Currying allows for better composition of functions since
you can easily pass intermediate results between functions.
3. Flexibility: Currying allows for flexible application of functions in various contexts
without needing to pass all arguments at once.
[Link] the different communication and synchronization techniques in Concurrent
Programming model.

In concurrent programming, communication and synchronization are essential to ensure

that multiple processes or threads can work together correctly without causing errors like
race conditions, deadlocks, or data inconsistency. There are several communication and
synchronization techniques used in concurrent programming models to manage the
interactions between concurrent entities (threads, processes, etc.).
1. Shared Memory Communication
 Description: In shared memory communication, multiple processes or threads
access the same region of memory. This allows for efficient communication, as data
can be shared directly by reading and writing to a common memory space.
 Techniques:
o Global Variables: Threads or processes access and modify the global
variables in shared memory.
o Memory Mapped Files: A file is mapped into the memory address space,
which allows concurrent processes to access and modify the file contents
directly.
2. Message Passing Communication
 Description: In message-passing communication, processes or threads
communicate by sending and receiving messages through channels or queues. This
is commonly used in distributed systems.
 Techniques:
o Direct Communication: Processes send messages directly to each other (e.g.,
using sockets or inter-process communication mechanisms).
o Indirect Communication: Messages are sent via a message queue or a
shared mailbox, where processes enqueue and dequeue messages.
Synchronization Techniques
Synchronization ensures that shared resources are accessed in a controlled manner,
preventing conflicts.
3. Locks (Mutexes)
 Description: A lock is a synchronization mechanism that ensures only one thread or
process can access a shared resource at a time.
 Types:
o Mutex: A mutual exclusion object that only allows one thread to access a
resource at a time.
o Spinlock: A type of lock where a thread continuously checks if the lock is
available, spinning in a loop until it acquires the lock.
4. Semaphores
 Description: A semaphore is a signaling mechanism that controls access to a shared
resource by multiple processes. It is typically used to control access to a pool of
resources or to coordinate activities between threads.
 Types:
o Binary Semaphore (Mutex): Similar to a lock, it has two states: locked (0)
and unlocked (1).
o Counting Semaphore: It can hold any non-negative integer value, and
processes decrement or increment the value to control access to a resource.
5. Condition Variables
 Description: A condition variable is used for thread synchronization. It allows
threads to wait for certain conditions to be met before proceeding.
 Usage: A thread can call wait() on a condition variable, which causes it to block
until another thread signals that the condition has been met by calling notify() or
notifyAll().
6. Barriers
 Description: Barriers are used to synchronize a group of threads, ensuring that all
threads reach a certain point in their execution before any can proceed.
 Usage: In parallel computing, threads may need to wait until all threads have
completed a certain task before proceeding to the next phase. Barriers are often
used in parallel algorithms where multiple threads must synchronize at certain
stages.
7. Read-Write Locks
 Description: A read-write lock is a synchronization primitive that allows multiple
readers or one writer to access a shared resource. Multiple threads can read from a
resource simultaneously, but only one thread can write at a time.
 Usage: This is particularly useful in situations where reads are more frequent than
writes, optimizing access to the resource.
8. Monitors
 Description: A monitor is an abstraction that combines data and operations on the
data, with automatic synchronization. It is a higher-level construct that
encapsulates both the data and the methods that operate on it, ensuring mutual
exclusion.
 Usage: Monitors provide automatic handling of locks and condition variables,
making it easier for developers to write correct concurrent programs.
9. Atomic Operations
 Description: Atomic operations are low-level synchronization mechanisms that
guarantee an operation is performed without interruption. An atomic operation is
indivisible, meaning it will not be preempted or interfered with by other threads.
 Usage: Commonly used in lock-free programming, such as incrementing a shared
counter or performing read-modify-write operations safely.
10. Deadlock Prevention
 Description: Deadlock occurs when two or more threads are waiting for each other
to release resources, causing all of them to be blocked. Deadlock prevention
involves ensuring that certain conditions are met to prevent deadlock.
 Techniques:
o Resource Allocation Graphs: A graphical method to track resource allocation
and requests, helping to avoid cyclic dependencies.
o Timeouts: Imposing time limits on how long a thread can hold a lock, thus
preventing indefinite waiting.
Q. Types of bindings in Programming Languages.

In programming languages, binding refers to the association of variables, constants, or

functions with their corresponding values, data types, or memory locations during various
stages of program execution. There are several types of bindings in programming
languages, including:
1. Name Binding (Variable Binding):
o This type of binding associates a variable's name with a memory location
during the program's execution.
o Example: In the statement int x = 10;, the name x is bound to the memory
location holding the value 10.
2. Type Binding:
o This binding defines the data type of a variable or expression at a particular
point in the program.
o Example: In float y = 3.14;, y is bound to the type float.
3. Value Binding:
o This refers to associating a value with a variable at a specific point in time.
o Example: If a = 5; is executed, the variable a is bound to the value 5.
4. Scope Binding:
o It defines the region of the program where a variable or identifier is
accessible.
o Example: A variable defined inside a function has local scope, while one
defined globally has global scope.
5. Time Binding:
o This binding defines when a variable's value is bound. It can happen during
compile-time or runtime.
 Compile-time binding: The association is done at the time of
compilation (e.g., constants).
 Runtime binding: The association is done during the execution of the
program (e.g., dynamic variables or dynamic function calls).
Q. Forward chaining vs backward

Aspect Forward Chaining Backward Chaining

Definition Starts with known facts and Starts with the goal and
applies rules to infer new works backward to find
facts until a goal is reached. supporting facts or rules.

Direction Data-driven (progresses Goal-driven (progresses

from facts to conclusions). from goals to facts).
Starting Point Begins with the available Begins with the desired
data or initial facts. outcome or goal.

Use Case Best for scenarios with no Best for scenarios with a
clear goal but abundant specific goal to achieve
data (e.g., diagnostics, (e.g., problem-solving,
predictions). decision-making).
Efficiency May explore unnecessary Focuses only on the
paths if the goal is relevant rules to achieve
unknown. the goal, making it more
efficient for specific tasks.
Example Diagnosing a disease by Verifying if a specific
analyzing symptoms and treatment is suitable for a
inferring the cause. disease by checking
conditions.
Rule Application Applies all possible rules at Applies only those rules
each step to generate new that directly lead to the
facts. goal.
Control Mechanism Requires a mechanism to Requires a mechanism to
avoid infinite loops when ensure all goal-related
exploring all possibilities. conditions are met.

Typical Applications Expert systems, Expert systems, query

simulations, and processing, and decision-
predictions. making tasks.

Complexity Can become More focused but may

computationally intensive if require extensive
the search space is large. backtracking for complex
problems.
Q. List operations in prolog.

1. Checking if a list is empty

 [] denotes an empty list.
Prolog:- is_empty([]).

2. Finding the head and tail of a list

 The Head is the first element, and the Tail is the rest of the list.
Prolog:- head_tail([H|T], H, T).

3. Appending two lists

 Use the built-in append/3 predicate.
Prolog:- append([1, 2], [3, 4], Result).
% Result = [1, 2, 3, 4].

4. Finding the length of a list

 Use the built-in length/2 predicate.
Prolog:- length([a, b, c], L).
% L = 3.

5. Checking membership of an element

 Use the built-in member/2 predicate.
Prolog:- member(a, [a, b, c]).
% true.

6. Concatenating lists
 This is similar to append/3.
Prolog:- append([1, 2], [3, 4], [1, 2, 3, 4]).

7. Reversing a list
 Use the built-in reverse/2 predicate.
Prolog:- reverse([1, 2, 3], R).
% R = [3, 2, 1].

8. Checking if a list contains sublists

 Match the list pattern using [H|T].
Prolog:- has_sublists([H|_]) :- is_list(H).

9. Deleting an element from a list

 Use the select/3 predicate.
Prolog:- select(2, [1, 2, 3], Result).
% Result = [1, 3].

10. Sorting a list

 Use the built-in sort/2 predicate.
Prolog:- sort([3, 1, 2], Sorted).
% Sorted = [1, 2, 3].
Q. Programming languages vs scripting.

Feature Programming Languages Scripting Languages

Definition Standalone languages used Languages used to
to create complete automate tasks or control
applications. other software.
Compilation Requires compilation into Executed directly or
machine code before interpreted without prior
execution. compilation.
Speed Faster execution due to Slower execution as they
compilation. are interpreted.

Syntax Complexity Generally more complex Simpler and more lenient

and strict. syntax.

Usage Used for developing Used for automating tasks,

systems, applications, and web development, and
games. scripts.
Examples C, C++, Java, Rust Python, JavaScript, PHP,
Perl

Environment Runs independently on Runs within another

hardware or operating program or environment.
system.
Learning Curve Steeper, requires Easier to learn due to
understanding of core simplicity and less
programming concepts. boilerplate.

File Type Generates executable files No standalone executables;

(.exe, .class). runs as scripts (.py, .js).

Interactivity Less interactive, used for More interactive, often

pre-built logic. used for dynamic content.
Q. Explain database manipulation commands in prolog with example
Database manipulation commands in Prolog are used to dynamically add, remove, or
modify facts and rules in a Prolog program during execution. Prolog provides several built-
in predicates for this purpose, including assert/1, retract/1, and retractall/1. Here's an
explanation with examples:

1. assert/1
 Purpose: Adds a new fact or rule to the database.
 Syntax: assert(FactOrRule).
 Example:
Prolog:- ?- assert(employee(john, manager)).
This adds the fact employee(john, manager) to the knowledge base.

2. retract/1
 Purpose: Removes a specified fact or rule from the database if it exists.
 Syntax: retract(FactOrRule).
 Example:
Prolog:- ?- assert(employee(john, manager)).
?- retract(employee(john, manager)).
The fact employee(john, manager) is removed from the knowledge base.

3. retractall/1
 Purpose: Removes all facts or rules that match the specified predicate.
 Syntax: retractall(Predicate).
 Example:
Prolog:- ?- assert(employee(john, manager)).
?- assert(employee(mary, assistant)).
?- retractall(employee(_, _)).
This removes all facts that match the employee(_, _) predicate, effectively clearing the
employee database.

4. Example Program
Here's a sample program that demonstrates the use of these commands:
% Initial facts
employee(john, manager).
employee(susan, engineer).

% Adding a fact dynamically

add_employee(Name, Role) :-
assert(employee(Name, Role)).

% Removing a specific fact

remove_employee(Name, Role) :-
retract(employee(Name, Role)).

% Clearing all employee facts

clear_employees :-
retractall(employee(_, _)).
% Querying employees
list_employees :-
findall((Name, Role), employee(Name, Role), Employees),
write(Employees).

Queries:
1. Add an employee:
prolog:- ?- add_employee(mary, assistant).
Output: Adds employee(mary, assistant) to the database.

2. Remove an employee:
Prolog:- ?- remove_employee(john, manager).
Output: Removes employee(john, manager) from the database.

3. Clear all employees:

prolog:- ?- clear_employees.
Output: Removes all employee facts from the database.

4. List all employees:

Prolog :-?- list_employees.
Output: Displays all current employee facts.