Interview Questions & Answers

A programming paradigm that organises code around objects — units that combine data (state) and behaviour (methods). Its four pillars are encapsulation, abstraction, inheritance and polymorphism.

A class is a blueprint that defines properties and methods. An object is a concrete instance created from that blueprint, with its own values for those properties.

Encapsulation hides internal state and controls access to it. Abstraction exposes what an object does while hiding how. Inheritance lets a class reuse and extend another class. Polymorphism lets different objects respond to the same call in their own way.

Semantic HTML uses elements that describe their meaning — <header>, <nav>, <main>, <article>, <button> — rather than generic <div>s. It improves accessibility (screen readers expose landmarks and roles), SEO (search engines understand the main content) and maintainability.

It tells the browser to render the page in standards mode. Without it, browsers fall back to “quirks mode”, which emulates old, inconsistent behaviour.

Block elements (div, p, h1) start on a new line and take the full available width. Inline elements (span, a, strong) flow within text and only take the width of their content. CSS display can change either.

Every element is a box of content, padding, border and margin. With the default content-box, width covers only the content; padding and border are added on top. With border-box, width includes padding and border, which makes sizing predictable.

static (default flow), relative (offset from its normal place), absolute (positioned relative to the nearest positioned ancestor), fixed (relative to the viewport) and sticky (behaves like relative until a scroll threshold, then sticks).

px is a fixed unit. em is relative to the font size of the element (or parent for font-size), so it compounds when nested. rem is relative to the root font size, which makes it predictable and good for accessibility.

var is function-scoped and hoisted with the value undefined. let and const are block-scoped and are in the temporal dead zone until declared. const cannot be reassigned, although objects it refers to can still be mutated.

"object", because arrays are objects. Use Array.isArray(value).

1typeof [];          // "object"
2Array.isArray([]);  // true

=== compares value and type without conversion. == converts types first, which leads to surprises like 0 == "" being true. Use === by default.

10 == ''     // true
20 === ''    // false
3null == undefined   // true
4null === undefined  // false

A JavaScript library that simplified DOM selection, events, animations and AJAX with a concise, chainable API and smoothed over browser inconsistencies at a time when browsers differed greatly.

It runs a function once the DOM is fully parsed, so elements can be safely selected. The shorthand is $(function () { … }). It does not wait for images like window.onload does.

.text() gets or sets text content (safe against HTML injection). .html() gets or sets inner HTML (unsafe with untrusted input). .val() gets or sets the value of form fields.

ECMAScript is the language specification; JavaScript is the most widely used implementation. ES6 (ES2015) was a major update, and new editions now appear every year.

Arrow functions are shorter, do not have their own this, arguments or super, cannot be used with new, and implicitly return a single expression when written without braces.

Both use …. Spread expands an iterable or object into individual elements ([...a, ...b], { ...obj }). Rest collects remaining elements into an array or object (function f(...args), const { id, ...rest } = obj).

Both describe object shapes. Interfaces can be re-opened (declaration merging) and extended with extends. Type aliases can also name unions, tuples and mapped types. For object shapes, either works; teams usually pick one convention.

A superset of JavaScript that adds static types. The compiler catches type errors before runtime, editors give better autocompletion and refactoring, and types document how code is meant to be used.

any disables type checking. unknown accepts any value but forces you to narrow it before use — the safe choice for untrusted data. never represents values that never occur, such as a function that always throws or an exhaustive switch default.

Both calls read count from the same render, so both schedule the same value. Use the updater form setCount(c => c + 1) so each update receives the latest value.

Keys let React match items between renders. If items are reordered, inserted or removed, index keys can attach state to the wrong item. Use a stable unique id.

A syntax extension that lets you write HTML-like markup in JavaScript. A build tool compiles it into function calls that create React elements. Expressions go inside { }.

Services marked @Injectable({ providedIn: "root" }) are registered with the root injector. Components receive them through inject() or constructor parameters. Providers can also be scoped to routes or components.

The building blocks of the UI: a TypeScript class decorated with @Component, plus a template and styles. Modern Angular uses standalone components that declare their own imports.

Interpolation {{ value }} and property binding [prop]="value" flow from component to view. Event binding (event)="handler()" flows from view to component. Two-way binding [(ngModel)] combines both.

A function (req, res, next) that runs during the request lifecycle. It can modify req/res, end the response, or call next() to pass control on. Error-handling middleware has four parameters (err, req, res, next).

A JavaScript runtime built on Chrome’s V8 engine that runs JavaScript outside the browser. It uses an event-driven, non-blocking I/O model, which suits APIs and real-time apps.

package.json describes the project, its scripts and dependency ranges. package-lock.json records the exact installed versions so every install is reproducible.

An API that exposes resources at URLs and uses HTTP methods (GET, POST, PUT, PATCH, DELETE) and status codes to operate on them, with stateless requests usually exchanging JSON.

PUT replaces the entire resource with the request body and is idempotent. PATCH applies a partial update to some fields.

Use nouns for resources and HTTP methods for actions: GET /api/products, POST /api/products, GET /api/products/42, PATCH /api/products/42, DELETE /api/products/42. Nest only for true ownership (/api/orders/7/items) and use plural, lowercase names.

Value types (int, struct, record struct) hold their data directly and are copied on assignment. Reference types (class, string, arrays) hold a reference to an object on the heap; assignment copies the reference.

const is a compile-time constant, implicitly static, and must be a primitive or string. readonly is set at runtime — in the declaration or constructor — and can hold any type.

A C# 8+ feature where reference types are non-nullable by default and string? marks values that may be null. The compiler warns when you might dereference null.

ViewData is a string-keyed dictionary; ViewBag is a dynamic wrapper over it. Both last for one request. TempData persists across a redirect until it is read, which suits flash messages.

Model holds data and business logic, View renders the UI, and Controller handles requests, works with models and selects a view. It separates concerns so each part can change and be tested independently.

Routes registered in RouteConfig (or with [Route] attributes after MapMvcAttributeRoutes) map URL patterns like {controller}/{action}/{id} to controller actions.

It creates the WebApplication builder, registers services in the DI container, builds the app, configures the middleware pipeline and maps endpoints, then calls app.Run().

They are action results that tell ASP.NET Core how to respond: View renders Razor, Json serialises data, RedirectToAction issues a 302, NotFound returns 404 and Ok returns 200 with a body.

A cross-platform framework for server-rendered web apps on modern .NET. Controllers handle requests, models carry data and Razor views render HTML. It runs on Kestrel, has DI, configuration and logging built in and deploys to Windows, Linux or containers.

A framework on .NET Framework for building HTTP services. Controllers derive from ApiController, routing is configured in WebApiConfig, and it is typically hosted on IIS.

An interface returned from actions that represents an HTTP response, with helpers such as Ok(), NotFound(), BadRequest() and Created(). It makes actions easier to unit test than returning HttpResponseMessage directly.

A Web API returns data (JSON or XML) for other programs — SPAs, mobile apps, other services — instead of HTML pages. In Web API 2 controllers inherit ApiController and actions are selected by HTTP method.

DTOs define a stable API contract, prevent over-posting (clients setting fields like IsAdmin), avoid leaking internal data, and avoid serialisation problems with navigation properties.

GET 200 (404 if missing), POST 201 with a Location header, PUT/PATCH 204 or 200, DELETE 204, invalid input 400, unauthenticated 401, forbidden 403, conflicts 409.

Enables API behaviours: automatic 400 responses for invalid models, binding-source inference ([FromBody] for complex types), attribute routing requirement and ProblemDetails error responses.

A .NET framework for building interactive web UI with C# and Razor components instead of JavaScript. Components can render on the server or run in the browser via WebAssembly.

Public properties marked [Parameter] receive values from the parent component. [EditorRequired] warns when a required parameter is missing, and EventCallback parameters let children notify parents.

A .razor file that combines HTML markup with C# in an @code block. It renders UI, handles events and can be reused with parameters, like <ProductCard Product="p" />. Components can be pages (with @page) or building blocks.

INNER JOIN returns only rows with matches in both tables. LEFT JOIN returns all rows from the left table, with NULLs for unmatched right-hand columns.

WHERE filters rows before grouping; HAVING filters groups after GROUP BY and can use aggregate functions.

1SELECT Department, COUNT(*) AS Staff
2FROM Employees
3WHERE IsActive = 1
4GROUP BY Department
5HAVING COUNT(*) > 5;

DELETE removes rows (optionally filtered), is fully logged and fires triggers. TRUNCATE removes all rows quickly, resets identity and cannot use WHERE. DROP removes the table itself.

The data access technology built into .NET. Providers such as Microsoft.Data.SqlClient supply connections, commands, data readers and adapters, so C# code can run SQL and stored procedures and read the results. EF Core and Dapper are built on top of it.

Connected: open a SqlConnection, run a SqlCommand and stream rows with a SqlDataReader while the connection stays open. Disconnected: a SqlDataAdapter fills a DataSet/DataTable, closes the connection, and you work with the in-memory copy, later pushing changes back with Update.

ExecuteNonQuery returns the number of rows affected (for INSERT/UPDATE/DELETE). ExecuteScalar returns the first column of the first row (or null if there are no rows). ExecuteReader returns a SqlDataReader for streaming result rows.

The compute that runs App Service apps: region, OS, pricing tier, instance size and count. Several apps can share one plan and its cost.

IaaS gives you virtual machines and networks to manage (Azure VMs). PaaS manages the platform so you deploy code (App Service, Azure SQL). SaaS is a finished application (Microsoft 365).

A logical container for related Azure resources that share a lifecycle. You can deploy, secure (RBAC), tag and delete them together.

Grant identities only the permissions they need for their task, nothing more. Prefer roles with temporary credentials over long-lived access keys, and avoid using the root user.

Elastic Compute Cloud provides resizable virtual servers. You choose an instance type, AMI, storage and security groups, and pay for the time instances run.

Simple Storage Service is object storage for files of any size, organised in buckets, with very high durability, versioning, lifecycle rules and multiple storage classes.

An image is a read-only template with the OS layer, runtime, code and dependencies. A container is a running instance of an image with its own writable layer.

A set of practices and culture that brings development and operations together to deliver software faster and more reliably through automation, continuous integration and delivery, monitoring and shared ownership.

CI merges and tests code frequently and automatically. Continuous delivery keeps every build releasable, with a manual approval to production. Continuous deployment releases every passing change automatically.

Software testing is evaluating a product to find defects and check it meets requirements and user needs. It reduces the risk of failures in production, protects users and reputation, and gives the team confidence to release.

Verification asks “are we building the product right?” — reviews of requirements, designs and code against specifications. Validation asks “are we building the right product?” — executing the software to check it meets user needs.

Requirement analysis, test planning, test case design, test environment setup, test execution, and test closure. Each phase has entry and exit criteria and produces deliverables such as the test plan, test cases and the closure report.

Automate stable, repetitive, high-value checks: regression suites, smoke tests, data-driven cases and API tests. Do not automate one-off tests, rapidly changing UI, exploratory or usability testing, or anything cheaper to check by hand.

Many fast unit tests at the base, fewer integration/API tests in the middle and a small number of end-to-end UI tests at the top. Lower tests are faster, cheaper and more stable.

Stable, unique attributes first: id, name or a dedicated data-testid via CSS selectors. Avoid absolute XPath and positional selectors that break with small layout changes.

Search engine optimization improves a site’s visibility in organic search results. Main areas: technical SEO (crawling, indexing, speed), on-page SEO (content, titles, headings, links) and off-page SEO (links and mentions from other sites), plus local SEO for physical businesses.

They crawl the web by following links and sitemaps, render and analyse pages, index the content, and rank indexed pages for each query using many signals such as relevance, quality, links and page experience.

The goal behind a query: informational (learn), navigational (find a site), commercial (compare) or transactional (buy). Pages rank best when their format and content match the dominant intent.

Internet Information Services is Microsoft’s web server for Windows. It receives HTTP(S) requests through the kernel driver HTTP.sys and serves static files or hands requests to applications such as ASP.NET Core (via the ASP.NET Core Module) or ASP.NET Framework running in worker processes.

An isolated container of one or more w3wp.exe worker processes with its own identity, .NET CLR setting, pipeline mode and recycling rules. Separate pools keep one crashing or slow app from affecting others.

The combination of protocol, IP address, port and host name that IIS uses to decide which site receives a request — for example https, All Unassigned, 443, shop.example.com with SNI.

The JVM runs Java bytecode. The JRE is the JVM plus the standard libraries needed to run programs. The JDK is everything in the JRE plus development tools such as javac, jar and jshell. Developers install the JDK.

== compares primitive values, or object references (same object in memory). equals() compares object contents when the class overrides it, as String does. Always compare strings with equals().

1String a = new String("java");
2String b = new String("java");
3System.out.println(a == b);      // false — different objects
4System.out.println(a.equals(b)); // true  — same contents

Immutability makes strings safe to share between threads, allows the string pool to reuse instances, and keeps hash codes stable for HashMap keys. Use StringBuilder when building text in loops.

val declares an immutable reference that cannot be reassigned; var declares a mutable one. Idiomatic Scala prefers val and immutable collections.

A class for immutable data. The compiler generates a constructor without new, field accessors, equals/hashCode based on values, toString, copy and pattern-matching support.

1case class User(name: String, age: Int)
2val a = User("Asha", 25)
3val b = a.copy(age = 26)   // User(Asha,26)
4a == User("Asha", 25)      // true

A type that is either Some(value) or None, used instead of null to represent a value that may be missing. Use map, getOrElse, fold or pattern matching to handle both cases.