The first homework assignment has a fair amount of reading attached to it. Some students feel that the best approach is to read it all, and then try to do the homework. For most of us, such an approach doesn’t work very well.

Before you begin the course, read the general material, such as “Getting Started,” “Software You Need for This Course,” and “How to Work.”

Later, as you begin the homework, let the homework drive your reading choices. For instance, the first homework assignment does require that you master certain techniques. Read “Names” and “The Ripple Principle.” Then, if something confuses you, read up on it: examples are “The Basics of Recalculation” and “References.” Learning something when you need it, and only when you need it, is usually the best way to go.

Parentheses sometimes make a real difference. For instance A1*B1+2 is very different from A1*(B1+2). But A1*(B1*2) is exactly the same as A1*B1*2. When the parentheses don’t make any difference in the value of the result, it’s not usually a good idea to include them. They tend to make the formulas harder to read, and there’s always the chance that you’ll put them in the wrong place. More

For many of you, matrix multiplication and array arithmetic are new ideas. It’s easy to get lost in the details of how they work and then forget about why we use them.

To keep a clear view of the forest and avoid focusing only on the trees, remember why we use matrix multiplication and array arithmetic. Briefly, we use them because we find that it’s very often helpful to decompose a problem into parts (analysis), then do calculations on the parts, and finally reassemble the final solution from the results of those partial calculations (synthesis).

Matrix multiplication and array arithmetic provide us with very convenient methods for performing those intermediate calculations on the parts. They’re the tools that make analysis and synthesis so powerful.

Implicit Intersection is one of the most underrated — and at the same time one of the most powerful — techniques in all of Excel. Yet few people truly understand it.

Implicit Intersection is the method by which one cell can retrieve a value from another range by examining the intersection of its row (or column) with that range. If the intersection is unique — a single-cell — then the formula of the cell that depends on implicit intersection can update its value without incident. If not, an error results.

When talking about worksheet functions, it’s important to be careful about your choice of terminology. Technology is like that, and like it or not, Excel is a piece of technology.

Cells can have formulas, as we’ve seen, and those formulas can invoke worksheet functions. Cells do not contain functions — rather, they can contain formulas, which, in turn, can invoke one or more worksheet functions.

User-defined names are not functions.

To invoke a worksheet function in the context of a cell formula, one calls a worksheet function. Often, you hear this described as “applying a worksheet function.” Do not use that terminology. For example, we’ll speak of “calling a function on its arguments,” or “calling a function with its arguments.” We do not say that we “apply a function to its arguments.”

When Excel calculates the value of a cell, and that cell’s formula contains a call to a worksheet function, that function call is evaluated. Its value is then returned to the formula, which uses it, in turn, to compute its own value.

Sometimes you hear worksheet functions referred to as commands. They aren’t commands. Commands are found on Excel’s menus, or perhaps in some dialog boxes. Commands do things, like format a cell, or sort a range. Commands don’t return values — functions return values.

The space character, in many cases, doesn’t change the value of a formula. For instance, these two formulas return the same value:

• =A1 + 2
• =A1+2

Some people think that well-placed spaces make formulas easier to read. Although that might be true, the practice is both inconvenient and extremely dangerous. More

Excel’s online help, and many of the how-to books you can buy, provide long lists of keystroke shortcuts for carrying out specific operations, such as inserting rows, selecting regions, or deleting columns. And they are useful.

But the true power of the keyboard comes not from using these particular commands. Rather, it comes from learning combinations that are useful for particular situations that you encounter frequently.

For instance, there’s no command for deleting the rows that contain the selected cells, but there is a combination:

• Shift+Space selects the rows that contain the selection.
• Ctrl+- deletes the now-selected rows.

And so, Shift+Space Ctrl+- deletes the rows containing the selection.

Learning a vast array of keystroke commands is probably less useful than learning the keystroke combinations that do exactly what you need to do most often.

In the demonstration for this session, we installed a formula for depreciation that looked pretty complicated. It does save maintenance trouble, though, when the depreciation term changes for any reason. But what happens when the depreciation schedule changes in a more radical way? What if the depreciation schedule is made to be some form other than linear?

The end of this session’s demonstration gives an example of an alternative schedule, but as you can see, its formula is very different. If we’re developing a complex model with several applications of depreciation formulas, and the depreciation formulas must be changed, we would have a significant maintenance task on our hands. To avoid that kind of labor, we can define a user-defined name that contains the depreciation formula. For more about this technique, see the tip box in the narrative for this session’s demonstration.

Nesting invocations of worksheet functions can be a bit tricky, because nested function calls are difficult to think about. Sometimes, in developing a spreadsheet model, we can gain clarity by avoiding nesting. That is, while we’re still thinking about how to approach a modeling problem, we intentionally choose to avoid nesting function calls. After we understand the problem better — and only then — we might go back and replace what we’ve done with a more compact version that exploits nesting. In addition to producing forms that are easier to think about, this practice of developing a simpler form first has another benefit. It enables us to examine intermediate values more easily, which enables us to confirm that the calculations we’re performing make sense.

Some feel that building something that you intend to replace is a waste of effort — that it’s far easier to build things in final form from the start. When that approach works, it is faster and more efficient. But when we think we’re likely to make mistakes, the “slower” way is faster.

In years past, we’ve learned that what makes a model dynamic — as opposed to static — can be difficult to grasp. If you have some doubts yourself, and you haven’t yet looked at the reading on Models vs. Tools, we believe that you will find it helpful.

Although the assumption of constant demand is critical to justifying the derivation of the formula for Economic Order Quantity, most problems don’t satisfy that requirement in the strict sense. But EOQ is nevertheless a valuable concept in two kinds of circumstances. The first case is when the time scale of the inventory management decisions is much shorter than the time scale of the variations in demand. And the second is when the fluctuations in demand occur much more rapidly than the inventory management decisions.

These two approximations occur repeatedly in modeling problems. Watch for opportunities to apply them elsewhere.