Software Engineering Concepts Explained: The Fundamentals Every Developer Should Know
Plain-English explanations of the concepts that come up in code reviews, interviews and debugging sessions — complexity, equality, references, mutability, recursion, concurrency, idempotency, SQL joins, HTTP and testing — each linked to an in-depth guide.
By Software Side Hustles Editorial Team · Published · Updated · 5 min read
How to use this page: each concept below gets a short, precise definition, the practical consequence you will actually meet in code, and a link to a full guide. Together they cover most of the "why did that happen?" moments in day-to-day development — and most of the fundamentals technical interviews probe.
Time and space complexity (Big O)
Definition: how the work or memory an algorithm needs grows as its input grows, ignoring constant factors.
Why it matters: an O(n²) loop is invisible on test data and catastrophic on production data. The most common cause is a hidden linear operation inside a loop — x in some_list, list.pop(0), string concatenation, or a database query per item.
Rule of thumb: if you search a list inside a loop, you probably want a set or a dictionary. Big O notation explained.
Hash tables
Definition: a structure that maps keys to values by computing a hash of the key to find a storage slot directly — Python's dict and set, JavaScript's Map and Set, Java's HashMap.
Why it matters: lookups, inserts and deletes are O(1) on average, which is why "use a set" fixes so many slow loops. Keys must be hashable and must not change while stored — and in Java, objects used as keys need consistent equals and hashCode. Checking for keys.
Equality versus identity
Definition: equality asks "do these have the same value?"; identity asks "are these the same object?".
Why it matters: == on Java strings, is on Python integers and === on JavaScript objects all compare identity, and all produce bugs that pass small tests. == vs === vs is vs equals().
References, values and mutability
Definition: in Python, JavaScript and Java, variables holding objects hold references. Passing an object to a function passes a copy of the reference, so the function can mutate the object but cannot rebind the caller's variable. Immutable values (numbers, strings, tuples) cannot be changed in place at all.
Why it matters: "I changed the copy and the original changed too" and "my function modified the caller's list" both follow from this. So does Python's mutable default argument trap. Pass by value vs pass by reference · Deep vs shallow copy.
Floating-point numbers
Definition: most languages store decimals in binary (IEEE 754), which cannot represent values such as 0.1 exactly.
Why it matters: 0.1 + 0.2 != 0.3, rounding surprises like round(2.675, 2) == 2.67, and money that drifts by a penny. Use decimal types or integer cents for money, and tolerances for comparisons. Rounding and floating point.
Recursion and the call stack
Definition: a recursive function solves a problem by calling itself on a smaller version, until it reaches a base case. Each active call occupies a frame on the call stack, which has a limited size.
Why it matters: a wrong base case or accidental recursion (a getter calling itself) produces stack overflows, and correct recursion can still fail on very deep input. Any recursion can be rewritten with an explicit stack or queue. Recursion depth and stack overflow.
Concurrency and parallelism
Definition: concurrency is managing several tasks in overlapping time; parallelism is executing several at the same instant on multiple cores.
Why it matters: I/O-bound work (network, disk) benefits from async or threads; CPU-bound work needs multiple cores — and in CPython, usually multiple processes because of the GIL. Shared mutable state invites race conditions and deadlocks. Concurrency vs parallelism · async/await mistakes.
Idempotency
Definition: an operation is idempotent if doing it twice has the same effect as doing it once. PUT /users/7 {name: "Ada"} is idempotent; POST /payments is not.
Why it matters: networks fail and clients retry. Non-idempotent operations retried after a timeout create duplicate orders and double charges. Idempotency keys, upserts and "set" rather than "increment" operations make retries safe. HTTP status codes and methods.
Time: instants versus calendar dates
Definition: an instant is a single moment worldwide (store it in UTC); a local date or time is a calendar value with no time zone (a birthday, an opening hour).
Why it matters: mixing them produces off-by-one-day bugs for users in other time zones, and daylight saving time makes "add a day" differ from "add 24 hours". Dates, times and time zones.
Relational joins
Definition: a join combines rows from two tables based on a condition. Inner joins keep only matches; outer joins keep unmatched rows with NULLs.
Why it matters: the joins are easy; the mistakes around them are not — a WHERE clause that silently turns a LEFT JOIN into an INNER JOIN, COUNT(*) counting missing rows, totals inflated by one-to-many fan-out, and NOT IN returning nothing when a NULL is present. SQL joins explained.
Injection and untrusted input
Definition: injection happens when data is interpreted as code — SQL, shell commands, HTML. The fix is to keep data and code separate: parameterised queries, argument lists instead of shell strings, and output encoding.
Why it matters: SQL injection remains one of the most common serious vulnerabilities, including in AI-generated code. Preventing SQL injection.
HTTP semantics
Definition: HTTP status codes tell clients what happened: 2xx success, 4xx "change your request", 5xx "the server failed".
Why it matters: clients, proxies, monitoring and retry logic all depend on the code. Returning 200 with an error body breaks them; confusing 401 with 403 confuses users. CORS is a browser-enforced layer on top. Status codes for APIs · CORS errors.
Testing
Definition: automated tests check behaviour against expectations. Unit tests isolate small pieces; integration tests check pieces working together.
Why it matters: most bugs live at the edges — empty input, boundaries, nulls, time zones, rounding. Good tests are deterministic, named after behaviour and focused on those edges. How to write good unit tests.
Version control
Definition: Git records snapshots (commits) of a project and lets branches diverge and merge.
Why it matters: knowing the difference between rewriting history (reset, amend) and adding to it (revert), and how to resolve conflicts calmly, prevents lost work and broken shared branches. Undoing commits · Merge conflicts.
Frequently asked questions
Which of these concepts matter most for interviews?
Big O, hash tables, recursion and equality/references come up constantly in coding interviews; concurrency, idempotency, HTTP and SQL dominate system-design and backend interviews.
How do I get better at these fundamentals?
Read code critically. Predict what a snippet will do before running it, then check. Reviewing other people's (or AI models') solutions is one of the fastest ways to build intuition.
Do I need a computer science degree to understand these?
No. Every concept on this page can be learned from practice and the linked guides. What matters is being able to apply them when reading real code.
Where this skill pays off
These fundamentals are exactly what AI training platforms assess when they hire developers to evaluate model-written code — the ability to say why one answer is better. Read what coding-focused AI data annotation is, then try the free practice labs to see how your judgement compares.