Lec 1

1. What is software development?

• Software development is the process of designing, coding, deploying, and

maintaining software to create solutions for users and businesses.

2. What are the stages of software development?

• Designing Software: Planning the software's functionality, user interface, and

structure.
• Creating Software: Writing the actual code based on the design.
• Deploying Software: Making the software available to users.
• Maintaining Software: Fixing bugs, updating security, and adding new features.

3. What is the Software Development Life Cycle (SDLC)?

• SDLC is a process that includes:

o Planning: Setting objectives, scope, and resources.
o Analysis: Identifying requirements and studying feasibility.
o Design: Creating the system’s architecture and specifications.
o Implementation (Coding): Writing the actual software.
o Testing: Ensuring the software works as expected.
o Deployment: Delivering the software to users.
o Maintenance: Providing updates and support.

4. Why is testing important in software development?

• Testing ensures the software meets user expectations and functions correctly.
• Types of testing include:
o Unit Testing: Checking individual parts of the code.
o Integration Testing: Ensuring components work together.
o System Testing: Testing the entire software.
o Acceptance Testing: Confirming it meets user needs.
5. What does a software engineer do?

• Designs, develops, and maintains software applications.

• Writes code, tests, and fixes issues.

6. What is the difference between a front-end and back-end developer?

• Front-End Developer: Works on the user interface using HTML, CSS, and
JavaScript.
• Back-End Developer: Handles server-side logic, database management, and APIs.

7. What does a full-stack developer do?

• Manages both front-end and back-end development.

• Handles the complete development of a web application.

8. What is the role of a mobile app developer?

• Creates applications for iOS and Android using frameworks like React Native or
Flutter.

9. What does a DevOps engineer do?

• Automates the deployment process and manages infrastructure.

10. Why is maintenance important in software development?

• It ensures the software stays secure, up-to-date, and functional.

• Involves fixing bugs, adding features, and improving performance.

------------------------------------------------------------------------------------------------------------------

Lec 2
1. What are software design patterns?

• Reusable solutions to common software design problems.

• Provide structured approaches to solving recurring design issues.
• Promote reusability, modularity, and maintainability.

2. What are the main types of design patterns?

• Creational Patterns: Focus on object creation. Examples: Singleton, Factory,

Abstract Factory.
• Structural Patterns: Deal with the composition of classes and objects. Examples:
Adapter, Decorator, Facade.
• Behavioral Patterns: Focus on object interactions. Examples: Observer, Strategy,
Command.

3. What is the Singleton Pattern?

• Ensures a class has only one instance and provides global access to it.
• Used to control instantiation and manage resources efficiently.
• Example use case: A logging system that writes to a single log file.

4. What are the benefits of the Singleton Pattern?

• Centralized Instance Management: Ensures one global instance.

• Reduced Memory Footprint: Avoids creating multiple instances.
• Lazy Initialization: Instance is created only when needed.
• Improved Performance: Minimizes redundant resource usage.
• Global Access: Makes the instance accessible throughout the program.

5. What are the steps to implement the Singleton Pattern?

1. Declare a private constructor to restrict instantiation.

2. Create a private static variable to hold the single instance.
3. Provide a public static getInstance() method to access the instance.
4. Implement thread-safety in multi-threaded environments.
 5. Use lazy initialization to create the instance only when needed.

6. What is lazy initialization?

• Instance is created only when accessed for the first time.

• Reduces memory usage and improves performance.
• Example: private static PrinterSingleton instance;
public static PrinterSingleton getInstance() {
if (instance == null) {
instance = new PrinterSingleton();
}
return instance;
}

7. How is thread safety handled in Singleton?

• Use synchronization to prevent multiple threads from creating separate instances.

• Example: public static synchronized PrinterSingleton getInstance()
{
if (instance == null) {
instance = new PrinterSingleton();
}
return instance;
}

8. What is the difference between single-threaded and multi-threaded environments?

• Single-threaded: One process executes at a time.

• Multi-threaded: Multiple processes run simultaneously.
• Problem: Without synchronization, multiple threads can create separate instances
of Singleton.
• Solution: Use synchronized methods or double-checked locking.
9. How can the problem of multiple threads be solved in Singleton?

• Implement double-checked locking: public static PrinterSingleton

getInstance() {
if (instance == null) {
synchronized ([Link]) {
if (instance == null) {
instance = new PrinterSingleton();
}
}
}
return instance;
}

10. What are the advantages of using design patterns?

• Provide tested and proven solutions to common problems.

• Improve code reusability and readability.
• Facilitate communication among developers through a common vocabulary.
• Reduce development time by reusing established patterns.

------------------------------------------------------------------------------------------------------------------

Lec 3

1. What is the Prototype Design Pattern?

The Prototype Design Pattern is a creational design pattern that allows creating objects by
copying an existing object, known as the prototype, instead of creating a new object from
scratch.

2. What are the advantages of the Prototype Design Pattern?

• It improves performance by reusing an existing object.

• It reduces the time spent on object creation.
• It simplifies the creation of complex objects by allowing them to be copied easily.
3. In which scenarios can the Prototype Design Pattern be used?

It is commonly used in situations where you need to create objects with complex
configurations, such as:

• Game development
• Image processing
• Configuration management systems

4. What is the difference between Shallow Copy and Deep Copy?

• Shallow Copy: Creates a new object but does not clone the referenced objects; it
just copies the references.
o Modifications to the referenced object affect both the original and the copy.
• Deep Copy: Creates a completely independent copy of the original object,
including all referenced objects.
o Changes in the copy do not affect the original object.

5. What is Shallow Copy in programming?

A shallow copy creates a new object that shares references to the same underlying data as
the original object. This means that changes made to the referenced objects will affect
both the original and the copied object.

6. What is Deep Copy in programming?

A deep copy creates a new object and recursively copies all data, including referenced
objects, to ensure that the copied object is completely independent of the original.

7. When should you use Shallow Copy?

Shallow copy is ideal for simple objects where changes to referenced data don't need to be
independent. It is faster and consumes less memory.

8. When should you use Deep Copy?

Deep copy is required when you need to ensure that changes made to the copied object do
not affect the original object, especially when objects contain nested or complex data
structures.
9. What are the performance and memory considerations for Shallow
Copy vs. Deep Copy?

• Shallow Copy is faster and uses less memory since it only copies references.
• Deep Copy is slower and consumes more memory because it duplicates all
referenced objects.

10. Can you give an example of Shallow Copy in C#?

public class Person

{
public string Name { get; set; }
public int Age { get; set; }
public Address Address { get; set; }

public Person ShallowCopy()

{
return (Person)[Link](); // Creates a shallow
copy
}

public void Display()

{
[Link]($"Name: {Name}, Age: {Age}, City:
{[Link]}");
}
}

public class Address

{
public string City { get; set; }
}

// Main program
Person person1 = new Person { Name = "Alice", Age = 25, Address = new
Address { City = "New York" } };
Person personCopy = [Link]();

[Link] = "Los Angeles"; // This will affect both

person1 and personCopy

11. What happens after modifying the original object after a Shallow
Copy?

In the shallow copy example above, after modifying the address of person1, the change
also reflects in personCopy because both objects share the same reference to the
Address object.

12. Can you give an example of Deep Copy in C#?

public class Person

{
public string Name { get; set; }
public int Age { get; set; }
public Address Address { get; set; }

public Person DeepCopy()

{
Person personCopy = (Person)[Link](); // Creates
a shallow copy
[Link] = new Address { City = [Link] };
// Creates a new Address object
return personCopy;
}

public void Display()

{
[Link]($"Name: {Name}, Age: {Age}, City:
{[Link]}");
}
}

public class Address

{
public string City { get; set; }
}
// Main program
Person person1 = new Person { Name = "Alice", Age = 25, Address = new
Address { City = "New York" } };
Person personCopy = [Link]();

[Link] = "Los Angeles"; // This will not affect

personCopy

13. What happens after modifying the original object after a Deep Copy?

In the deep copy example, after modifying the address of person1, personCopy remains
unaffected because it has its own independent Address object.

14. What should you consider when choosing between Shallow Copy and
Deep Copy?

• Consider the complexity of the objects you are working with.

• Shallow copy is appropriate for simple objects with few references to other objects.
• Deep copy is necessary when objects have nested data structures or when you
need complete independence between the original and the copy.

15. What are the real-world applications of Shallow Copy and Deep Copy?

• Shallow Copy: Used when duplicating files in file systems or copying data in simple
databases.
• Deep Copy: Used for cloning virtual machines, duplicating game levels, or complex
data structures.

------------------------------------------------------------------------------------------------------------------

Lec 4
1. What is the Factory Design Pattern? Why is it useful?

The Factory Design Pattern is a creational design pattern. It provides a way to create
objects in a superclass while allowing subclasses to define which specific type of object
will be created.

Usefulness:

• It reduces code duplication by centralizing object creation logic.

• It ensures that the client code doesn’t need to know about the concrete
implementation of objects.
• It makes the code more maintainable and scalable, as new types can be added
without altering existing code.

2. What are the key components of the Factory Design Pattern?

• Interface or Abstract Class: Defines the structure (methods) that all concrete
classes must follow.
• Concrete Classes: Implement the interface and provide specific functionality.
• Factory Class: Contains a method that returns an object of the required type.
• Client Code: Uses the factory to get an object and interact with it without knowing
its specific type.

3. How does the Factory Method differ from the Abstract Factory Pattern?

Feature Factory Method Abstract Factory

Creates a single object
Purpose Creates families of related objects.
type.
Implementa
Relies on inheritance. Relies on composition.
tion
More complex, as it involves multiple
Complexity Simple to implement.
factories.
4. What are real-world examples of the Factory Design Pattern?

• Payment Systems: A factory can decide which payment method (e.g., CreditCard,
PayPal, GooglePay) to use.
• Game Development: A factory can create different types of animals, enemies, or
characters in a game.
• Database Connection: A factory can choose the type of database (e.g., MySQL,
PostgreSQL, MongoDB) at runtime.

5. How is the Factory Design Pattern implemented in code?

Here is a simplified implementation of the Factory Design Pattern:

// Step 1: Define the interface

public interface IPayment
{
void Pay(double amount);
}

// Step 2: Create concrete classes

public class CreditCardPayment : IPayment
{
public void Pay(double amount)
{
[Link]($"Successfully paid ${amount} using Credit
Card.");
}
}

public class PayPalPayment : IPayment

{
public void Pay(double amount)
{
[Link]($"Successfully paid ${amount} using
PayPal.");
}
}
public class GooglePayPayment : IPayment
{
public void Pay(double amount)
{
[Link]($"Successfully paid ${amount} using Google
Pay.");
}
}

// Step 3: Define the factory class

public class PaymentFactory
{
public static IPayment Create(PaymentMethod method)
{
switch (method)
{
case [Link]:
return new CreditCardPayment();
case [Link]:
return new PayPalPayment();
case [Link]:
return new GooglePayPayment();
default:
throw new NotSupportedException($"{method} is not
supported.");
}
}
}

// Enum for Payment Methods

public enum PaymentMethod
{
CreditCard,
PayPal,
GooglePay
}

// Step 4: Client Code

class Program
{
static void Main(string[] args)
{
IPayment payment =
[Link]([Link]);
[Link](1000.00);
}
}

6. Explain the output of the provided code.

If the user chooses [Link] in the factory method, the output will be:

Successfully paid $1000.00 using PayPal.

This happens because the PaymentFactory class instantiates a PayPalPayment object

and invokes its Pay method.

7. What are the advantages and disadvantages of the Factory Design Pattern?

Advantages:

• Centralizes object creation logic.

• Promotes loose coupling by separating object creation from usage.
• Makes code more scalable and easier to maintain.

Disadvantages:

• Can increase the number of classes and complexity.

• May lead to overengineering if not necessary.
8. What role does the switch statement play in the factory class?

The switch statement determines which concrete class to instantiate based on the input
(e.g., [Link]). This allows the factory to dynamically decide the
type of object at runtime.

9. How can you improve the Factory Design Pattern?

• Replace the switch statement with a dictionary for better performance and
scalability.
• Use dependency injection to avoid tight coupling between the factory and concrete
classes.
• Combine with other patterns like Singleton to limit the number of instances.

10. What happens if a new payment method needs to be added?

To add a new payment method:

1. Create a new class implementing the IPayment interface.

2. Add a case for the new method in the PaymentFactory class.
3. Update the PaymentMethod enum to include the new method.

This approach ensures that changes are localized and do not affect the client code.

-----------------------------------------------------------------------------------------------------------------

Lec 5

1. What is the Proxy Design Pattern? Why is it used?

The Proxy Design Pattern provides a surrogate or placeholder for another object. It controls
access to the real object and adds additional functionalities without modifying the real
object itself.
Purpose:

• Control access to an object.

• Enhance functionality like security, logging, or caching.
• Improve performance through lazy initialization or remote object communication.

2. What are the key components of the Proxy Pattern?

1. Subject Interface: Defines common methods that both the Real Subject and Proxy
implement.
2. Real Subject: The actual object that performs the operation.
3. Proxy Class: Controls access to the Real Subject. It can perform additional actions
before or after delegating to the Real Subject.
4. Client: Uses the Proxy object, unaware that it is not directly interacting with the
Real Subject.

3. What are some real-world examples of the Proxy Design Pattern?

• Access Control: Restrict access to certain users or locations.

• Remote Proxy: Represents objects in a different system or location (e.g., accessing
a server).
• Caching Proxy: Caches results of expensive operations to improve performance.
• Virtual Proxy: Delays the creation and initialization of heavy objects until needed.

Example:

A website proxy controls access based on user location.

4. What are the advantages of the Proxy Design Pattern?

• Adds functionality without modifying the original object.

• Centralizes control logic like security or logging.
• Supports lazy initialization, reducing resource usage.
• Enhances maintainability by separating concerns.
5. What are the disadvantages of the Proxy Design Pattern?

• Adds complexity to the codebase.

• May slightly reduce performance due to the extra layer.
• Requires careful implementation to avoid introducing bugs or security loopholes.

6. What is the structure of the Proxy Design Pattern?

1. Subject Interface: IWebAccess

2. Real Subject: Implements the actual logic (e.g., RealWebAccess).
3. Proxy Class: Adds additional control logic (e.g.,
LocationBasedWebAccessProxy).
4. Client Code: Calls methods on the Proxy, unaware of the Real Subject.

7. How is the Proxy Pattern implemented in code?

Here’s an example of a location-based website access proxy:

// Step 1: Define the Subject Interface

public interface IWebAccess
{
void AccessWebsite(string website, string userLocation);
}

// Step 2: Implement the Real Subject

public class RealWebAccess : IWebAccess
{
public void AccessWebsite(string website, string userLocation)
{
[Link]($"Accessing website: {website} from
{userLocation}");
}
}

// Step 3: Implement the Proxy Class

public class LocationBasedWebAccessProxy : IWebAccess
{
 private RealWebAccess _realWebAccess;

public LocationBasedWebAccessProxy()
{
_realWebAccess = new RealWebAccess();
}

public void AccessWebsite(string website, string userLocation)

{
string[] allowedLocations = { "USA", "Canada", "UK" };

if ([Link](allowedLocations, location =>

[Link](userLocation, [Link])))
{
_realWebAccess.AccessWebsite(website, userLocation);
}
else
{
[Link]($"Access Denied: Users from
{userLocation} cannot access {website}.");
}
}
}

// Step 4: Client Code

class Program
{
static void Main(string[] args)
{
IWebAccess webAccess = new LocationBasedWebAccessProxy();

[Link]("[Link] "USA");
[Link]("[Link] "Canada");
[Link]("[Link] "Germany");
[Link]("[Link] "UK");
[Link]("[Link] "Australia");
}
}
8. What is the output of the above code?

Output:

Accessing website: [Link] from USA

Accessing website: [Link] from Canada
Access Denied: Users from Germany cannot access [Link]
Accessing website: [Link] from UK
Access Denied: Users from Australia cannot access [Link]

9. How does the Proxy Pattern handle access control in the example?

The proxy (LocationBasedWebAccessProxy) maintains a list of allowed locations. When

the AccessWebsite method is called:

• It checks if the user’s location is in the allowed list.

• If allowed, it delegates the request to the RealWebAccess class.
• If not, it denies access and displays a message.

10. What are common scenarios for using the Proxy Pattern?

• Security Proxy: Validates user permissions before accessing a resource.

• Logging Proxy: Logs requests for auditing purposes.
• Virtual Proxy: Loads a resource-intensive object only when needed.
• Smart Proxy: Manages additional actions (e.g., reference counting, thread safety).

11. What would happen if a new feature needs to be added to the proxy?

If a new requirement arises (e.g., logging all denied access attempts):

• Modify the LocationBasedWebAccessProxy class to log such events.

 • Example: if (![Link](allowedLocations, location =>
[Link](userLocation,
[Link])))
{
[Link]($"Access Denied: Users from {userLocation}
cannot access {website}.");
LogDeniedAccess(userLocation, website); // Add logging here
}

This keeps the implementation modular and ensures that changes do not impact the Real
Subject or Client Code.

12. Why is the client unaware of the Proxy?

The Proxy implements the same interface (IWebAccess) as the Real Subject. From the
client’s perspective, it interacts with an object that performs the required operations. The
client does not know or care whether it is a Proxy or the Real Subject.

This abstraction allows seamless integration of additional functionality without modifying

the client code.

---------------------------------------------------------------------------

Lec 6
1. What is the Adapter Pattern?

The Adapter Pattern is a structural design pattern used to make two incompatible
interfaces work together. It allows classes with incompatible interfaces to collaborate
without changing their source code.
2. What is the Purpose of the Adapter Pattern?

The purpose of the Adapter Pattern is to convert one class's interface into another
interface that the client expects, enabling them to work together.

3. What are the Key Components of the Adapter Pattern?

• Target Interface: The interface the client expects.

• Adaptee: The existing class with an incompatible interface.
• Adapter: The class that implements the target interface and translates requests to
the adaptee.

4. How is the Adapter Pattern Structured?

• Client: Uses the target interface.

• Target Interface: Defines the interface the client expects.
• Adapter Class: Implements the target interface and wraps the adaptee, translating
requests.
• Adaptee Class: The existing class with a different interface than the target.

5. Give an Example of the Adapter Pattern.

Consider a company transitioning from a legacy salary calculation system to a new

system with a standardized interface. The legacy system uses a method
CalculateOldSalary, while the new system expects a method CalculateSalary.

6. What Problem Arises Without Using the Adapter Pattern?

Without the Adapter Pattern, the legacy system’s CalculateOldSalary method would
not be compatible with the modern system’s CalculateSalary method, leading to
incompatibility between the two systems.
7. How Would the Code Look Without the Adapter Pattern?

• The legacy system’s class LegacySalarySystem has a method

CalculateOldSalary that calculates salary based on hours worked and hourly
rate.
• The modern system requires an interface ISalaryCalculator with a method
CalculateSalary that takes an employee object as input.

8. How Does the Adapter Solve This Problem?

The adapter class SalaryAdapter implements the ISalaryCalculator interface and

uses the CalculateOldSalary method of the legacy system to calculate the salary,
making it compatible with the new system.

9. What is the Role of the Adapter in the Example?

The SalaryAdapter acts as a bridge between the legacy system and the new system. It
converts the legacy system’s interface into one that the new system expects, allowing both
systems to work together.

10. What Would the Client Code Look Like After Implementing the Adapter?

• The client creates an instance of SalaryAdapter, passing the legacy system to it.
• The client can then call the CalculateSalary method of the adapter, which
internally calls the legacy system’s method.
• The output would be the calculated salary based on the employee's hours worked
and hourly rate.

11. How Does the Adapter Pattern Enhance Code Reusability?

The Adapter Pattern allows for the reuse of the legacy system by making it compatible with
new interfaces. Without changing the legacy code, the system can be integrated into the
new system, promoting code reuse.
12. What Is the Output in the Provided Example Code?

The output would be:

Salary for John Doe: $1000

13. What Is the Benefit of Using the Adapter Pattern in This Case?

The Adapter Pattern allows the legacy system to be used with the new system without
modifying the legacy code. It provides a clean solution to the interface incompatibility
problem.

14. What is the Difference Between an Adapter and a Proxy?

• Adapter: Converts one interface to another to make two incompatible systems

work together.
• Proxy: Controls access to an object, adding extra functionality like lazy initialization
or access control.

15. When Should You Use the Adapter Pattern?

You should use the Adapter Pattern when you have a system that needs to interact with
other systems or classes but cannot directly communicate because their interfaces are
incompatible.

16. When Should You Avoid the Adapter Pattern?

You should avoid the Adapter Pattern when the interfaces are already compatible or if
modifying the existing classes to meet the required interface is a better solution.
------------------------------------------------------------------------------------------------------------------

Lec 7

1. What is the Chain of Responsibility Design Pattern?

The Chain of Responsibility (CoR) is a behavioral design pattern that allows passing a
request along a chain of handlers until one of them handles the request. If no handler can
process the request, the chain ends.

2. What are the Benefits of Using the Chain of Responsibility Pattern?

• It allows decoupling of sender and receiver.

• The request is passed through the chain without the sender knowing which handler
will process it.
• The handling logic is divided into small, manageable units, making it easier to
maintain.

3. How Does the Chain of Responsibility Work?

Each handler in the chain has a reference to the next handler. When a request arrives, the
first handler in the chain checks if it can handle the request. If not, it passes the request to
the next handler, and this continues until the request is processed or the chain ends.

4. What Are the Components of the Chain of Responsibility Pattern?

• Client: Initiates the request.

• Handler: Defines the processing logic and the reference to the next handler.
• Concrete Handler: Implements the specific handling logic for the request.
• Request: The data being passed through the chain.
5. What Is the Structure of the Chain of Responsibility?

• The request is passed from one handler to the next in the chain.
• Each handler checks if it can process the request.
• If a handler can handle the request, it does so; otherwise, it passes the request to
the next handler.

6. Can You Explain the Chain of Responsibility Pattern with an Example?

In an authentication system:

1. Check if the user is registered.

2. Verify the password.
3. Check the user’s access level.

Each of these steps is handled by a specific handler in the chain. If one handler can't
process the request, it passes it to the next.

7. How is the Chain of Responsibility Pattern Implemented?

1. Create the abstract handler class with a NextHandler reference and a method to
set the next handler.
2. Concrete handlers extend the abstract handler class and implement the Handle
method for specific logic (e.g., validating registration, password, or access level).
3. Create the request class to store data (e.g., user information).
4. Setup the chain of handlers and invoke the Handle method to start processing the
request.

8. What Does the Client Code Look Like in the Chain of Responsibility Pattern?

• The client creates instances of each handler (e.g., RegistrationHandler,

PasswordHandler, AccessLevelHandler).
• The handlers are linked in a chain using the SetNext method.
• The client creates a request (e.g., a UserRequest object) and passes it to the first
handler in the chain.
9. What Is the Output If All Steps Pass in the Example?

User is registered. Passing to the next handler...

Password is correct. Passing to the next handler...
Access level is sufficient. Authentication successful.

10. What Happens If One of the Steps Fails in the Example?

If any step fails (e.g., invalid password), the request is denied:

User is registered. Passing to the next handler...

Invalid password. Access denied.

11. What Are the Advantages of the Chain of Responsibility Pattern?

• It allows adding new handlers without modifying the client or existing handlers.
• It supports the dynamic handling of requests.
• It provides flexibility in handling requests through various possible paths in the
chain.

12. What Are the Disadvantages of the Chain of Responsibility Pattern?

• It may increase the complexity of the system if the chain becomes too long.
• The request may not be handled if there’s no handler capable of processing it.
• Performance can be impacted if the chain is large and many handlers are involved.

13. When Should You Use the Chain of Responsibility Pattern?

You should use it when:

 • You need to process a request through a series of steps, where each step can be
handled by different classes.
• You want to avoid coupling the sender and receiver of the request.
• You need to add or remove handlers dynamically at runtime.

14. When Should You Avoid the Chain of Responsibility Pattern?

Avoid it when:

• The logic is simple and does not require multiple handlers.

• The steps are predefined and do not need dynamic chaining.