Model View Controller

1. What is MVC?
Answer:
MVC stands for Model-View-Controller. It is a design pattern used for
developing web applications that separates application logic into:
• Model – Handles data and business logic.
• View – Handles UI/presentation.
• Controller – Manages user input and updates model/view.
 2. What are the benefits of using MVC?
Answer:
• Separation of concerns
• Easier to manage and scale
• Enables parallel development
• Improved testing and maintainability

3. What does the Model contain?

Answer:
The Model represents the application's data structure and business rules. It
fetches/stores data (usually from a database).

4. What does the View contain?

Answer:
The View is responsible for displaying data to the user. It’s the UI layer and
doesn't contain business logic.

5. What does the Controller do?

Answer:
The Controller handles user input, calls appropriate methods in the model, and
determines which view to render.

6. Explain the MVC flow briefly.

Answer:
1. User interacts with View
2. View sends request to Controller
3. Controller processes the request and interacts with Model
 4. Model sends data back to Controller
5. Controller updates the View

7. Is MVC a design pattern or architecture?

Answer:
MVC is a design pattern, though it's often referred to as architecture due to its
large-scale use in applications.

8. What are some popular MVC frameworks?

Answer:
• Frontend: Angular (component-based MVC), Backbone.js
• Backend: ASP.NET MVC, Django, Ruby on Rails, Laravel, Spring MVC

9. How does routing work in MVC frameworks?

Answer:
Routing maps the URL to a specific controller and action method.
Example (ASP.NET):
csharp
CopyEdit
routes.MapRoute("default", "{controller}/{action}/{id}");

10. What is the difference between MVVM and MVC?

Answer:

Aspect MVC MVVM

Binding Manual Two-way data binding

ViewModel Not present Used

Aspect MVC MVVM

Common in Backend frameworks Frontend frameworks (like Angular)

11. Can a controller return JSON data?

Answer:
Yes. Most MVC frameworks allow the controller to return different formats like
HTML, JSON, XML, etc.

12. What is a Partial View?

Answer:
A Partial View is a reusable part of a View, like a component or template used
in multiple places.

13. How is validation handled in MVC?

Answer:
• On the Model using annotations (e.g., @NotNull, @Email)
• On the Client-side using JavaScript
• On the Server-side by the Controller

14. Can you explain dependency injection in MVC?

Answer:
Dependency Injection (DI) is a technique where objects receive their
dependencies rather than creating them, promoting loose coupling.

15. How is session management handled in MVC applications?

Answer:
• Using Session variables
 • Cookies
• Authentication tokens (e.g., JWT)

Rest API

What is a REST API?

A REST API (Representational State Transfer Application Programming
Interface) is a set of rules and tools that allows different software applications
to communicate with each other over the internet. It is an architectural style
for designing networked applications, leveraging the HTTP protocol to enable
seamless interaction between clients (e.g., web or mobile apps) and servers.
REST is stateless, meaning each request from a client to a server must contain
all the information needed to process it, without relying on previous requests.
The term "REST" was coined by Roy Fielding in his 2000 doctoral dissertation,
and it has since become a standard for building scalable and maintainable web
services. REST APIs are widely used in modern web development, powering
everything from social media platforms to e-commerce websites.

Key Principles of REST

 1. Client-Server Architecture:
o The client (e.g., a web browser or app) and server (e.g., a database
or application server) are separate entities. This separation allows
the client to focus on the user interface and the server to handle
data storage and logic.
2. Stateless:
o Each request from the client to the server is independent. The
server does not retain information about previous requests,
ensuring simplicity and scalability.
3. Cacheable:
o Responses from the server can be cached to improve
performance, reducing the need for repeated requests for the
same data.
4. Uniform Interface:
o REST APIs use a consistent and standardized way to interact with
resources. This includes using HTTP methods (GET, POST, PUT,
DELETE) and resource identifiers (e.g., URLs).
5. Layered System:
o The architecture can have multiple layers (e.g., load balancers,
security layers) between the client and server, with each layer
unaware of the others, enhancing flexibility and security.
6. Resource-Based:
o Everything in a REST API is treated as a resource (e.g., users,
products), identified by a unique URL (e.g., /users/123). Resources
are manipulated using standard HTTP methods.

HTTP Methods in REST APIs

REST APIs rely on HTTP methods to perform actions on resources. The primary
methods are:
• GET: Retrieves data from the server (e.g., fetching a list of users).
 • POST: Creates new data on the server (e.g., adding a new user).
• PUT: Updates existing data (e.g., modifying user details).
• DELETE: Removes data from the server (e.g., deleting a user).
These methods align with CRUD operations (Create, Read, Update, Delete),
which are fundamental to managing data.

How REST APIs Work

1. Request:
o A client sends an HTTP request to a specific endpoint (URL) on the
server. For example, GET /api/users might request a list of users.
o The request includes a method (e.g., GET), headers (e.g.,
authentication tokens), and optionally a body (e.g., data for POST
requests).
2. Processing:
o The server processes the request, interacts with a database or
application logic, and prepares a response.
3. Response:
o The server sends back an HTTP response with a status code (e.g.,
200 for success, 404 for not found), headers, and a body (usually
in JSON or XML format) containing the requested data or
confirmation.
4. Data Format:
o REST APIs commonly use JSON (JavaScript Object Notation) due to
its readability and compatibility with web technologies.

Example of a REST API Interaction

Imagine an e-commerce API:
• Endpoint: GET /api/products/123
o Request: The client asks for product ID 123.
 o Response: The server returns { "id": 123, "name": "Laptop",
"price": 999.99 } with a 200 status code.
• Endpoint: POST /api/orders
o Request: The client sends { "productId": 123, "quantity": 2 } to
create an order.
o Response: The server returns the new order details with a 201
(Created) status code.

Benefits of REST APIs

• Scalability: Stateless nature and caching make it easy to scale.
• Flexibility: Works with various data formats (JSON, XML) and can be
integrated with different platforms.
• Simplicity: Uses standard HTTP methods, making it easy to understand
and implement.
• Interoperability: Allows different systems (e.g., iOS, Android, web) to
communicate seamlessly.

Visual Representation with Images

I’ve generated the following images to illustrate REST API concepts. Let’s walk
through them:
1. First Image: REST API Architecture Diagram
o Description: This image shows a flowchart of a REST API system. At
the top, "REST API" is the central hub, connected to "GET," "POST,"
"PUT," and "DELETE" methods. These methods lead to various
actions like retrieving data, creating resources, updating, and
deleting. Icons represent databases, servers, and client
interactions.
o Insight: This highlights the flow of requests and responses,
showing how HTTP methods interact with resources.
2. Second Image: Stacked Cylinders Representing API Layers
 o Description: This image uses colorful cylinders stacked on a board,
each labeled with terms like "GET," "POST," "PUT," and "DELETE,"
along with other components like "Server" and "Client." The
arrangement suggests a layered system where requests move
through different stages.
o Insight: This visualizes the layered architecture and the sequence
of operations in a REST API, emphasizing the client-server
interaction.
These images collectively illustrate the structure, methods, and flow of a REST
API, making the abstract concept more tangible.

Real-World Use Cases

• Social Media: APIs like Twitter’s allow apps to post tweets or fetch user
data.
• E-commerce: Amazon’s API enables third-party apps to access product
catalogs.
• Cloud Services: AWS and Google Cloud use REST APIs for managing
resources.