Dr. Dobb's Blogs

Aliasing Is Particularly Troublesome With Vector Elements

Thu, 16 May 2013 22:28:00 -0400

I would like to continue our discussion with a particularly nasty case in which the result is not well defined.

Some Subtleties of Aliasing

Thu, 09 May 2013 19:27:00 -0400

Aliasing can cause paradoxical behavior.

Sometimes, Making a Program Clearer Makes It Faster

Wed, 01 May 2013 21:15:00 -0400

We can "optimize" our code by removing requests for operations that our data structures do not really need to support.

Some Optimizations Are No-Brainers

Fri, 26 Apr 2013 14:53:00 -0400

Kernighan's rule for optimizations (Don't do it) is good advice. But as with most rules, there are exceptions.

Sometimes Optimizations Cancel Each Other

Wed, 17 Apr 2013 14:43:00 -0400

Two rights can make a wrong in the software-design world.

Optimizing a Program Means Making It Run Faster, Right?

Wed, 10 Apr 2013 14:18:00 -0400

People often use optimization to mean changing a program in ways that they think will make it run faster, but that casual definition is far from complete.

Optimization Versus Flexibility — An Example

Thu, 04 Apr 2013 15:04:00 -0400

Last week, I discussed how optimization can sometimes mislead programmers into writing code that works better in the lab than in the field, perhaps because the problems that programs encounter in the field are larger than those that are used during testing. As luck would have it, since I wrote that article, I encountered a real-world example of that phenomenon.

Is Optimization Immoral?

Thu, 28 Mar 2013 07:50:00 -0400

Dynamic memory allocation in C++ (and C) can be surprisingly expensive.

If Order Relations are Such a Pain, Why Bother?

Fri, 22 Mar 2013 05:30:00 -0400

Whenever a problem turns out to be harder to solve than we expected, it makes sense to ask whether perhaps we were solving the wrong problem in the first place.

Comparing an Integer with a Floating-Point Number, Part 2: Tactics

Thu, 14 Mar 2013 21:27:00 -0400

We continue last week's discussion by getting down to details.

Comparing an Integer With a Floating-Point Number, Part 1: Strategy

Thu, 07 Mar 2013 21:10:00 -0500

We have two numbers, one integer and one floating-point, and we want to compare them.

It's Hard To Compare Floating-Point Numbers

Fri, 01 Mar 2013 09:06:00 -0500

Last week I posed a problem: Suppose you have an inheritance hierarchy that lets you represent integers or floating-point numbers. How would you define comparison within your hierarchy? We can restate this problem in a language-independent way: How can we compare two numbers, either of which might be integer or floating-point?

Comparison and Inheritance

Fri, 22 Feb 2013 16:36:00 -0500

We continue last week's discussion of comparison functions by thinking about how to compare objects from different parts of an inheritance hierarchy.

Concrete Examples of Orderings

Fri, 15 Feb 2013 09:42:00 -0500

There is a commonly used strategy, often called lexicographical order or dictionary order, for taking the ordering strategies for individual components and combining them.

How Dictionaries Work

Wed, 06 Feb 2013 18:35:00 -0500

Treat each object as a sequence of symbols and impose a dictionary order on the symbols.

A Strategy for Defining Order Relations

Fri, 01 Feb 2013 05:44:00 -0500

If you want to compare two complicated objects, the strategy is to define a function that computes a single number from each object and then compares those numbers.

If C++ Objects Are Unrelated, Are They Equal?

Thu, 24 Jan 2013 13:27:00 -0500

Last week, I said that sorting in C++ depended on an appropriately defined comparison operation, and ended by explaining some properties that any such comparison operation must have. Let's continue our discussion.

Introducing C++ Order Relations

Fri, 18 Jan 2013 06:23:00 -0500

The C++ library facilities for sorting, binary searching, and ordered containers work only on types with appropriate order relations defined on them.

It's A Heisenbug!

Thu, 10 Jan 2013 09:23:00 -0500

It's finally time to wrap up the discussion I started in December about what seemed at first to be a mysterious compiler bug.

Isolating A Superbug

Wed, 02 Jan 2013 10:55:00 -0500

How could it possibly be that concatenating preamble and output would always work with one strategy but not another?

Down The Rabbit Hole

Wed, 26 Dec 2012 18:55:00 -0500

Last week, I described how I almost traced a bug to the wrong program. Having come this far, I would like to describe the actual source of the bug — such a strange source that I would never have suspected it when I began looking.

Are You Sure You Know What's Broken?

Wed, 19 Dec 2012 05:39:00 -0500

This week, I continue in our discussion of a bug in a multipass compiler.

Debugging by Hypothesis

Thu, 13 Dec 2012 04:34:00 -0500

There's a technical term for people who claim that their programs don't compile because of a compiler failure rather than a bug in their own programs: arrogant.

Debugging As Science: A Concrete Example

Thu, 06 Dec 2012 16:43:00 -0500

Last week, I argued that debugging is more science than art. I would like to continue that discussion with an example from my own experience.

Debugging: Art or Science?

Thu, 29 Nov 2012 05:12:00 -0500

Every bug is different, so saying something that applies to the act of debugging requires finding something general to say about a bunch of unrelated specific cases that defy generalization by their very nature.