Programming Fundamentals interview questions

An abstract class is a class that can't be instantiated on its own; it shares code with its subclasses and declares methods that each subclass must implement.

An interface only declares what a type can do, and a class can implement several. An abstract class can also hold fields, a constructor and shared method code, but a class can extend only one. Use an interface for a capability and an abstract class for behavior shared by a family of related types.

Yes. You can't call it with new directly, but each subclass calls it, for example with super(...), to set up the fields that the abstract class defines.

Not as a keyword, but the standard abc module provides them. Inherit from ABC and mark methods with @abstractmethod, and Python raises a TypeError if you try to create an object before every abstract method is implemented.

Abstraction is hiding the complicated details of how something works behind a simpler interface, so code can use it by knowing only what it does.

Abstraction decides what to show: a simple interface that captures the essential idea. Encapsulation is how the rest is kept hidden: private fields and methods that outside code can't touch.

A class that can't be instantiated directly and may leave some methods unimplemented. Subclasses fill in the details. Unlike an interface, it can also contain shared code and fields.

An abstraction whose hidden details still affect the people using it. For example, an ORM hides SQL, but slow queries still force developers to understand the SQL it generates.

An algorithm is a finite, step-by-step set of instructions for solving a problem or completing a task, such as sorting a list or finding the shortest route.

An algorithm is the abstract sequence of steps for solving a problem. A program is a concrete implementation of that algorithm, usually along with many others, written in a specific programming language so a computer can run it.

Big O notation describes how an algorithm's running time or memory use grows as the input size grows. For example, O(n) means the work grows in direct proportion to the input, while O(1) means it stays the same no matter how large the input is.

You don't need to memorize every algorithm, but understanding common ones like searching and sorting, and knowing how to reason about efficiency, helps you write faster code. Algorithm questions are also common in technical interviews.

An array is an ordered collection of values stored under one name, where each item is accessed by its numeric position, called an index, usually starting at 0.

In languages like C, an index is the distance, or offset, from the start of the array in memory, so the first item is zero steps away. Most later languages kept this convention, although a few, such as Lua, MATLAB, and R, start counting at 1.

The terms overlap. Classically, an array is a fixed-size block of contiguous memory, while a list can grow and shrink; Python's list and JavaScript's Array are actually dynamic arrays that combine fast index access with automatic resizing.

Use Array.isArray(value), which returns true only for arrays. The typeof operator doesn't help here, because it returns "object" for arrays as well as for plain objects.

Async/await is a syntax for writing asynchronous code that reads like ordinary step-by-step code, pausing at each await until a promise or task finishes.

No. await pauses only the async function it is in; the rest of the program, including the browser's user interface, keeps running. The function resumes once the awaited promise settles.

In modern JavaScript, you can use top-level await directly in ES modules. In classic scripts and CommonJS files, await must be inside an async function.

Async/await is syntax built on top of promises, not a replacement for them. It lets you write the same promise-based logic in a more linear, readable style.

Base64 is a way to write any binary data, such as an image or a key, using only 64 safe text characters, so it can pass through systems built for text.

No. Base64 only changes how the bytes are written, and anyone can turn it back without a key. To keep data secret, encrypt it; Base64 is just a way to carry the result as text.

Base64 works on groups of three bytes. When the last group has only one or two, the output is padded with == or = so its length is a multiple of four. Some formats, such as JWTs, leave the padding out.

Big O notation describes how an algorithm's running time or memory use grows as its input gets larger, focusing on the growth rate rather than exact speed.

O(n), or linear time, means the work grows in direct proportion to the input size. If an O(n) function takes 1 millisecond for 1,000 items, it will take roughly 10 milliseconds for 10,000 items.

Time complexity describes how the number of steps an algorithm takes grows with the input, while space complexity describes how much extra memory it needs. Both are usually expressed in Big O notation, and improving one often costs the other.

Yes, for large inputs. O(log n) work grows very slowly, since doubling the input adds only about one extra step, so binary search can find an item among a billion sorted values in about 30 comparisons.

A callback is a function passed as an argument to another function, which then calls it later, for example when a task finishes or an event happens.

A callback is a function you pass in to be called when work finishes. A promise is an object that represents the future result of that work, which you can chain with .then() or wait for with await; promises make sequencing and error handling much simpler than nested callbacks.

Callback hell is code where many asynchronous callbacks are nested inside each other, forming a pyramid shape that is hard to read, debug, and handle errors in. It is usually fixed by switching to promises or async/await.

No. Callbacks passed to array methods like map, filter, and forEach run synchronously, immediately during the call. Only callbacks tied to timers, events, or input/output operations run asynchronously.