Why Good Code Depends on Data Structures, Logic, and Control

What Is Programming?

Programming is the act of translating real‑world problems into executable instructions; its essence is often questioned on platforms like Zhihu, where answers range from abstract paradigms to concrete, actionable guidance.

Program = Algorithm + Data Structure

A well‑written program consists of algorithms that operate on appropriate data structures. Many developers focus only on algorithms, neglecting the choice of data structures such as arrays, linked lists, stacks, queues, trees, or graphs, which can be the first reason for poor code quality.

As Linus Torvalds famously said, “Bad programmers worry about code. Good programmers worry about data structures and their relationships.”

Algorithm = Control + Logic

Beyond data, an algorithm can be split into control flow and business logic.

Control

Control comprises language constructs (if, for, map, reduce) and execution strategies (parallel vs. serial, sync vs. async, scheduling, module organization, functions vs. classes, multithreading, service discovery, deployment, elasticity). These aspects are independent of the business problem.

Logic

Logic refers to business logic: the concrete rules that implement requirements, such as validating a user’s login credentials.

Relationship

Logic solves the problem and determines the inherent complexity; it sets the lower bound for code optimization.

Control influences performance and is the focus of code‑level optimization.

Logic and control are independent.

Separating them makes code easier to improve and maintain.

Underlying Logic: Separating Logic, Control, and Data

Both low‑level code and high‑level architecture aim to separate control from logic.

Step 1: Choose the appropriate data structure.

Step 2: Abstract the business logic (process flow + model).

Step 3: Design the control process (programming paradigm + design pattern).

Example

function check_form_x() {
    var name = $('#name').val();
    if (null == name || name.length <= 3) {
        return { status : 1, message: 'Invalid name' };
    }
    var password = $('#password').val();
    if (null == password || password.length <= 8) {
        return { status : 2, message: 'Invalid password' };
    }
    var repeat_password = $('#repeat_password').val();
    if (repeat_password != password.length) {
        return { status : 3, message: 'Password and repeat password mismatch' };
    }
    var email = $('#email').val();
    if (check_email_format(email)) {
        return { status : 4, message: 'Invalid email' };
    }
    // ...
    return { status : 0, message: 'OK' };
}

After separating concerns:

// logic
var meta_create_user = {
    form_id : 'create_user',
    fields : [
        { id : 'name', type : 'text', min_length : 3 },
        { id : 'password', type : 'password', min_length : 8 },
        { id : 'repeat-password', type : 'password', min_length : 8 },
        { id : 'email', type : 'email' }
    ]
};
// control
var r = check_form(meta_create_user);

This table‑driven approach uses a JSON structure to describe business requirements and a single control function, achieving clear separation of data, logic, and control while remaining highly extensible.

Essential Knowledge

To write decoupled, high‑quality code, developers should master the following fundamentals:

Data structures: study textbooks or solve algorithm problems.

Business‑logic abstraction: draw flowcharts and models to outline required steps.

Control design: understand various programming paradigms.

Programming paradigms: imperative, declarative, functional, object‑oriented.

Design principles: SOLID (Single Responsibility, Open‑Closed, Liskov Substitution, Interface Segregation, Dependency Inversion).

Design patterns: creational (factory, singleton, prototype), structural (adapter, decorator, proxy, facade, bridge), behavioral (observer, strategy, command, iterator, state, chain of responsibility).

Conclusion

The underlying logic described provides a solid direction for code reviews: ask what constitutes the logic, what is the control, whether the business can be expressed with suitable data structures, and which structure best fits the problem.

By habitually separating data, logic, and control, code becomes more extensible, readable, and stable over time.