Software development terms

See also Principles from software development and DynamoDB in examples, Example 1.5: Distributed system terms.

Accidental complexity

Complexity is accidental if it is not inherent in the problem that the software solves (as seen by the users) but arises only from the implementation.

"Out of the Tar Pit" by Ben Moseley and Peter Marks

Async frameworks

Async frameworks use a single thread as much as possible. Uses modern operation system's IO multiplexing functions: select(), poll() and epoll(). If we are single-threaded, we don't suffer the costs of context switches and save resources that extra thread requires.

The largest benefit of single thread is code simplicity, writing thread-safe code is more difficult.

Code smell

Code smell - a symptom of bad OO design. Smells are certain structures in the code that indicate violation of fundamental design principles and negatively impact design quality.

Complex universal vs simple specific

Vote for simple specific. KISS.

Composition vs inheritance

Favor object composition over class inheritance.

Design Patterns by Gamma et al.

Concurrency vs parallelism

Concurrency is about dealing with lots of things at once.
Parallelism is about doing lots of things at once.
Not the same, but related.
One is about structure, one is about execution.
Concurrency provides a way to structure a solution to solve a problem that may (but not necessary) be parallelizable.

Rob Pike, Co-inventor of the Go language

Duck typing

When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.

James Whitcomb Riley

A form of polymorphism where functions operate on any object that implements the appropriate methods, regardless of their classes or explicit interface declarations.

Functional programming

It is a declarative programming paradigm, which means programming is done with expressions.


A hacker - someone who strives to solve problems in elegant and ingenious ways.

Implementation vs interface

The design must be simple, both in implementation and interface. It is more important for the implementation to be simple than the interface. Simplicity is the most important consideration in a design.

Richard P. Gabriel, The rise of Worse is Better

Large and complex

There are two schools of thought about teaching computer science. We might caricature the two views this way:

Brian Harvey and Matthew Wright, Preface by Simply Scheme

Lazy implementation

A lazy implementation postpones producing values to the last possible moment. This saves memory and may avoid useless processing as well.


Programming is science dressed up as art because most of us don't understand the physics of software and it's rarely, if ever, taught.
This is the science of programming: make building blocks that people can understand and use easily, and people will work together to solve the very largest problems.


Thread safety

Thread-safe code is code that will work even if many threads are executing it simultaneously within the same process.

Thread safety is a computer programming concept applicable to multi-threaded code. Thread-safe code only manipulates shared data structures in a manner that guarantees safe execution by multiple threads.

Software libraries can provide certain thread-safety guarantees. For example, concurrent reads might be guaranteed to be thread-safe, but concurrent writes might not be:

Ways to achieve thread safety:

See Thread Synchronization Mechanisms in Python.

Ugly code

Ugly code hides problems and makes it hard for others to help you. You might get used to meaningless variable names, but people reading your code won't. Use names that are real words, that say something other than "I'm too careless to tell you what this variable is really for". Use consistent indentation and clean layout. Write nice code and your world will be more comfortable.


Licensed under CC BY-SA 3.0