Quotes About Complexity

The problem is there are no simple "right" answers for most Web design questions (at least not for the important ones). What works is good, integrated design that fills a need—carefully thought out, well executed, and tested. That

Designing, building, and maintaining a great Web site or app isn't easy. It's like golf: a handful of ways to get the ball in the hole, a million ways not to.

He never complicates a desire by overthinking it, unlike Mirabelle, who spins a cocoon around an idea until it is immobile.

There is nothing too mysterious about Ray Porter, at least not in the usual sense of the word. He is single, he is kind, he tries to do the right thing, and he does not understand himself, or women, or his relationships with women.

Because it's a poor tradeoff to add complexity for dubious performance gains, a good approach to deep vs. shallow copies is to prefer deep copies until proven otherwise.

One symptom that you have bogged down in complexity overload is when you find yourself doggedly applying a method that is clearly irrelevant, at least to any outside observer. It is like the mechanically inept person whose car breaks down—so he puts water in the battery and empties the ashtrays. — P. J. Plauger

At the software-architecture level, the complexity of a problem is reduced by dividing the system into subsystems. Humans have an easier time comprehending several simple pieces of information than one complicated piece.

The more independent the subsystems are, the more you make it safe to focus on one bit of complexity at a time. Carefully defined objects separate concerns so that you can focus on one thing at a time. Packages provide the same benefit at a higher level of aggregation.

NASA identifies reuse candidates at the ends of their projects. They then perform the work needed to make the classes reusable as a special project at the end of the main project or as the first step in a new project. This approach helps prevent gold-plating—creation of functionality that isn't required and that unnecessarily adds complexity.

Here's a summary list of the valid reasons to create a class: Model real-world objects Model abstract objects Reduce complexity Isolate complexity Hide implementation details Limit effects of changes Hide global data Streamline parameter passing Make central points of control Facilitate reusable code Plan for a family of programs Package related operations Accomplish a specific refactoring

One indication that a routine needs to be broken out of another routine is deep nesting of an inner loop or a conditional. Reduce the containing routine's complexity by pulling the nested part out and putting it into its own routine.

If a class contains more than about seven data members, consider whether the class should be decomposed into multiple smaller classes (Riel 1996). You might err more toward the high end of 7±2 if the data members are primitive data types like integers and strings, more toward the lower end of 7±2 if the data members are complex objects.

inheritance is a powerful tool for reducing complexity because a programmer can focus on the generic attributes of an object without worrying about the details. If a programmer must be constantly thinking about semantic differences in subclass implementations, then inheritance is increasing complexity rather than reducing it.

There is no code so big, twisted, or complex that maintenance can't make it worse.

The underlying message of all these rules is that inheritance tends to work against the primary technical imperative you have as a programmer, which is to manage complexity. For the sake of controlling complexity, you should maintain a heavy bias against inheritance.

Design Is a Wicked Problem Horst Rittel and Melvin Webber defined a wicked problem as one that could be clearly defined only by solving it, or by solving part of it (1973). This paradox implies, essentially, that you have to solve the problem once in order to clearly define it and then solve it again to create a solution that works.

Global data is generally subject to two problems: routines operate on global data without knowing that other routines are operating on it, and routines are aware that other routines are operating on the global data but they don't know exactly what they're doing to it.

the automatic computer confronts us with a radically new intellectual challenge that has no precedent in our history. Of course software has become even more complex since 1989, and Dijkstra's ratio of 1 to 109could easily be more like 1 to 1015 today.

Dijkstra pointed out that no one's skull is really big enough to contain a modern computer program (Dijkstra 1972), which means that we as software developers shouldn't try to cram whole programs into our skulls at once; we should try to organize our programs in such a way that we can safely focus on one part of it at a time.

Because successful programming depends on minimizing complexity, a skilled programmer will build in as much flexibility as needed to meet the software's requirements but will not add flexibility—and related complexity—beyond what's required.

Quicksort a few times, but what are the odds that your custom version will be fully correct on the first try?

Notably, the core of NASA's approach to creating reusable classes does not involve designing for reuse. NASA identifies reuse candidates at the ends of their projects. They then perform the work needed to make the classes reusable as a special project at the end of the main project or as the first step in a new project. This approach helps prevent gold-plating—creation of functionality that isn't required and that unnecessarily adds complexity.

Experts depend on the fact that you don't have the information they do. Or that you are so befuddled by the complexity of their operation that you wouldn't know what to do with the information if you had it. Or that you are so in awe of their expertise that you wouldn't dare challenge them.

Prediction," as Niels Bohr liked to say, "is very difficult, especially if it's about the future.