Easily Confused Concepts

In software engineering, terminology often blurs the lines between different architectural layers and conceptual models. Confusing these terms can easily lead to flawed system designs, ambiguous API contracts, and misguided debugging efforts. To help clarify these distinctions, let's examine several frequently confused pairs of programming concepts by looking at their definitions, core differences, and practical examples.
Pass by value means that when a function is called, a copy of the actual parameter's value is passed into the formal parameter; modifications made to the formal parameter inside the function do not affect the original argument. Pass by reference, on the other hand, means the formal parameter directly references the memory address of the actual argument, so any changes made to the parameter are immediately reflected in the original variable.

It is worth emphasizing that Java is strictly pass by value. When passing an object, the value being passed is actually a copy of the object reference. Consider the following example:

class Person { String name; }

public class Demo {
    static void changeRef(Person p) {
        p = new Person();
        p.name = "Bob";
    }

    static void changeField(Person p) {
        p.name = "Bob";
    }

    public static void main(String[] args) {
        Person a = new Person();
        a.name = "Alice";

        changeRef(a);   // a.name remains Alice
        changeField(a); // a.name becomes Bob
    }
}

Therefore, when determining the impact scope of an operation, it is essential to distinguish between modifying the reference itself and modifying the object that the reference points to.

Shallow Copy vs. Deep Copy

A shallow copy duplicates only the top-level properties of an object. If a property is a primitive type, its value is copied; if it is a reference type, only the reference address is copied, meaning both the old and new objects share the underlying nested data. A deep copy, however, recursively clones all levels of nested structures, resulting in an entirely independent copy of the original object.

Consider this JavaScript example:

const original = { user: { name: "Tom" }, tags: ["a"] };
const shallow = { ...original };

shallow.user.name = "Jerry";
console.log(original.user.name); // Jerry

const deep = structuredClone(original);
deep.user.name = "Spike";
console.log(original.user.name); // Jerry

When deciding on a copying strategy, if an object is expected to be mutated across multiple parts of an application, deep copying or immutable data patterns should be preferred.

Overloading vs. Overriding

Overloading occurs within the same class, where multiple methods share the same name but have different parameter lists, regardless of the return type. It is resolved by the compiler at compile-time based on the method signature, representing compile-time polymorphism.

Overriding occurs between a parent class and a subclass. The subclass provides a specific implementation of a method that already exists in its parent class, matching the method name, parameter list, and compatible return types. It is determined at runtime based on the actual object type, representing runtime polymorphism.

Consider this Java example:

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; } // Overloading
}

class Child extends Calculator {
    @Override
    int add(int a, int b) { return a + b + 1; } // Overriding
}

A handy rule of thumb: overloading looks at parameters, while overriding looks at objects.

Concurrency vs. Parallelism

Concurrency refers to the ability to deal with multiple tasks by interleaving their execution over a given time period. Even a single-core CPU can achieve concurrency through time-slicing. Parallelism refers to physically executing multiple tasks at the exact same instant, which typically requires multi-core processors or multi-processor hardware.

• Concurrency focuses on how tasks are structured, scheduled, and managed.
• Parallelism focuses on how tasks are simultaneously executed.
• Concurrency is a structural problem, whereas parallelism is an execution capability.

For instance, a web server managing a massive number of incoming connections via a single-threaded event loop is demonstrating concurrency; leveraging multiple CPU cores to process separate requests at the exact same moment is parallelism. While they can be combined in modern systems, they are fundamentally distinct.

Authentication vs. Authorization

Authentication answers the question: "Who are you?" Common mechanisms include passwords, SMS verification codes, OAuth tokens, and JWTs. Authorization answers the question: "What are you allowed to do?" Common access control models include RBAC (Role-Based Access Control), ABAC (Attribute-Based Access Control), and ACLs (Access Control Lists).

In HTTP semantics:

• 401 Unauthorized: Typically indicates that the user is not authenticated or that authentication has failed.
• 403 Forbidden: Typically indicates that the user is authenticated, but lacks the necessary permissions to access the resource.

When designing secure systems, authentication must always precede authorization. Failing authentication should return a 401 status, while insufficient permissions should return a 403 status, ensuring the two security dimensions remain strictly separated.

Conclusion

When untangling ambiguous technical concepts, asking a few targeted diagnostic questions can clarify their boundaries:

1. Does it deal with identity (Authentication) or permissions (Authorization)?
2. Does it occur at compile-time (Overloading) or runtime (Overriding)?
3. Does it focus on interleaved task scheduling (Concurrency) or simultaneous execution (Parallelism)?

Mastering these distinctions not only elevates the precision of our technical communication but also guides us toward cleaner architecture, more robust code reviews, and more efficient troubleshooting.