Excel, Apparently

There are some computer problems that are genuinely serious.

A hard drive dies.
A database becomes corrupted.
A server goes down.
A backup turns out not to be a backup.

And then there are the problems that are, objectively, not serious at all—but somehow manage to consume an unreasonable portion of your day.

Today, I experienced exactly that.

It started with something so simple that I would normally never remember it.

I was working in Excel. I had selected all the cells in the first row—the header row of the table I was working with—because I wanted to search for something in the headers.

I meant to press:

Ctrl + F

Instead, I pressed:

Ctrl + V

That was it.

One wrong key combination.

Unfortunately, my clipboard wasn’t empty.

It contained about 40 lines of text, roughly 800 characters in total.

And because I had selected the entire first row, Excel apparently interpreted my mistake as a request to paste that 40-line clipboard content into every selected cell across the row.

I immediately realized what I had done.

So I did what any reasonable person would do:

Ctrl + Z.

Undo.

Surely this should be easy.

Paste.

Undo.

Done.

Right?

No.

Excel stopped responding.

Not “a little slow.”
Not “please wait.”
Not even a helpful progress bar.

Just:

Microsoft Excel — Not Responding

At first, I wasn’t particularly worried.

The operation had only just happened. Maybe Excel was simply processing the undo.

So I waited.

And waited.

And waited.

Eventually I opened Task Manager to see what was actually happening.

And this is where the situation became strangely interesting.

Excel wasn’t completely dead. The CPU usage was sitting around 5–6%, sometimes 5.8%, sometimes 6.1%, sometimes 6.2%…

That was actually encouraging.

At first, I thought that perhaps Excel was still doing something heavy.

But then another question occurred to me:

How do you know whether Excel is actually working or merely pretending to work?

After all, “Not Responding” doesn’t necessarily mean “doing nothing.” It can mean that the application’s interface isn’t responding because the application is busy doing something else.

So I started watching the process.

The Working Set—the memory usage—was changing over time.

That was another good sign.

Maybe Excel was alive.
Maybe it was undoing the paste.
Maybe it would come back.

I decided not to kill it.

The CPU percentage mystery

There was another thing worth remembering.

A modern CPU may have many cores and threads.

So if Excel is doing a mostly single-threaded operation, 5–6% total CPU usage can still represent substantial activity on one CPU core, even though the overall percentage looks small.

In other words, looking at “Excel is only using 6% CPU” and concluding “Excel is doing nothing” isn’t necessarily correct.

So I watched it.

5.9%.
6.1%.
6.2%.
5.9%.
6.2%.

Excel remained “Not Responding.”

But it was moving.

This became the strange middle ground where you don’t know whether you are waiting for something or merely postponing the inevitable.

Should I increase Excel’s priority?

At some point, I wondered whether I could make the situation better by increasing Excel’s process priority.

Task Manager allows you to change the priority.

Maybe if Excel was working so hard, giving it more priority would help.

The answer was: possibly, but probably not much.

I could use Above normal or High.
But Realtime was a terrible idea.
Realtime priority could allow Excel to take CPU time away from important Windows processes and potentially make the entire computer less responsive.

Besides, CPU wasn’t obviously the problem.
Excel was already using CPU.

The bottleneck could have been something else entirely, possibly:

• Excel’s internal undo processing
• memory operations
• worksheet structures
• recalculation
• dependency handling
• or simply the enormous amount of state Excel had decided it needed to process.

So increasing the priority wasn’t really the magic solution.

Then I checked I/O

I looked at the I/O counters in Task Manager.

At one point:

• I/O reads: 254,264
• I/O writes: 2,618

And they weren’t moving.

For a while, that made Excel look more suspicious.

If it wasn’t reading or writing anything, perhaps it had become stuck inside some internal operation.

But then the numbers started changing slightly.

That changed the picture again.

CPU was moving.
Memory was changing.
I/O was changing.

Excel was apparently doing something.

But what?

And, perhaps more importantly:

How much longer?

That was the information Excel wasn’t giving me.

The most useful number: CPU time

Then I checked CPU time.

It was around:

1:04:40

And it was still increasing.

That was probably the strongest evidence that Excel was genuinely executing instructions rather than simply sitting there dead.

So now I knew something important:

Excel was alive.

But I still didn’t know whether it would finish.

That distinction turned out to be extremely important.

“Still working” does not mean “will finish soon.”

It could mean:

Two more minutes.

Or:

Two more hours.

Or:

I have no idea, please consult Task Manager.

And that is where my frustration with Excel really started to become less about this particular incident and more about the design of the application itself.

The real problem isn’t that Excel is slow

At this point, it would be easy to say:

“Excel is slow.”

But that’s not really what bothered me.

Computationally expensive operations happen.
Large spreadsheets happen.
Big files happen.
Long calculations happen.

That’s normal.

The real problem is that Excel gives you almost no useful information or control while it happens.

Imagine if Excel had simply said:

Undoing paste… 37%

Or:

Undoing paste…
Restoring the selected header cells…
Estimated time remaining: 3 minutes

Or even:

Large operation in progress. Excel is working. Cancel?

That would completely change the experience.

Instead, you get:

Not Responding

And now you’re left wondering:

Is it frozen?
Is it working?
Should I wait?
Should I kill it?
If I kill it, how much work will I lose?
If I wait another 30 minutes, will it actually finish?

There is no useful answer inside Excel itself.

Task Manager becomes your progress indicator.
CPU percentage becomes your progress indicator.
Memory changes become your progress indicator.
I/O counters become your progress indicator.

You end up debugging Excel from outside Excel.

The worst part: you can’t really stop it

Another problem became obvious.

Once Excel enters one of these long operations, you don’t have a reliable way to stop it.

You might try:

Esc.

Maybe it works.
Maybe it doesn’t.

You might click the window’s close button.

Now Windows may simply tell you that Excel isn’t responding.

And eventually you arrive at the ultimate button:

End task.

But that’s not really a “Cancel” button.

That’s:

Destroy Excel and hope for the best.

Those are very different concepts.

A proper cancel operation would allow Excel to say:

“Okay, I’ll stop after safely rolling back what I’ve already done.”

Ending the process says:

“Good luck.”

And then there is the problem of starting another Excel

Another thing that makes this particularly annoying is that when one Excel instance is tied up, you may want to simply open another Excel and continue working.

Why should one workbook prevent you from doing something else?

Fortunately, there is a way to explicitly start a separate Excel instance:

excel /x

The /x switch tells Excel to start a new instance.

So, theoretically, you can have:

Excel instance #1 — currently contemplating the meaning of Undo

and:

Excel instance #2 — actually doing useful work.

That is useful, but it’s still something the user has to know about.

And obviously, you shouldn’t open the same workbook in the second instance while the first one has it open.

The question of whether to kill Excel

Eventually, the decision becomes uncomfortable.

If the workbook has been saved recently, killing Excel is relatively easy.

You lose whatever you did after the last save.

Annoying, but survivable.

If you’ve made a lot of changes since the last save, however, suddenly waiting another 30 minutes doesn’t sound so bad.

Because if you kill Excel, you may have to redo everything.

And that was exactly my situation.

I could kill Excel.

But then I would have to do the same work again.

That’s the part that makes the situation so frustrating.

It’s not simply:

“Excel is frozen.”

It’s:

“Excel might be working, but I have no idea whether waiting is going to save me from having to redo my work.”

At nearly an hour, the distinction becomes almost philosophical.

Excel really is an extraordinary application

And this is where I want to be fair.

Because despite all of this, Excel has helped me with a huge number of things.

Excel isn’t a useless program.

Quite the opposite.

It is incredibly capable.

You can use it for:

• complicated calculations
• financial models
• data analysis
• pivot tables
• reporting
• dashboards
• automation
• VBA
• large-scale data processing
• importing and transforming data
• organizing information that would otherwise require a database

I’ve used Excel for many things where it genuinely excels.

And that is precisely why these failures are so frustrating.

If Excel were simply bad, you would stop expecting much from it.

But Excel is often extremely capable.

It can do complicated things brilliantly.

And then you accidentally paste 40 lines into a row and suddenly you’re watching Task Manager for an hour.

That contrast is what makes Excel special.

Maybe Microsoft should change the name

At some point, after watching this thing for far too long, I started thinking:

Maybe Microsoft should change the name.

Something more honest.

Perhaps:

Microsoft NotSoExcelAsOneMightThink

Because Excel is sometimes remarkably bad at very basic spreadsheet operations.

But then I thought about what the word excel actually means.

To excel means:

to be exceptionally good at something; to surpass; to exceed.

And suddenly the name started making sense again.

Because Excel really does excel.

It excels at spreadsheets.
It excels at automation.
It excels at data processing.
It excels at letting ordinary people do things that would otherwise require specialized software.

But apparently, it can also:

excel at making a simple task complicated.

And today it particularly excelled at:

making a 40-line paste into a nearly one-hour philosophical experience.

Maybe Microsoft actually chose the perfect name.

They never promised that Excel would excel at only the things we wanted it to excel at.

What could Microsoft actually improve?

There are many things Microsoft could do here.

And they don’t necessarily have to change the basic Excel interface.

1. Don’t materialize millions of cells unnecessarily

Suppose I accidentally paste a 40-line clipboard into an entire row.

The meaningful clipboard data is only about 40 lines, even though the selected range may contain thousands of cells.

Excel could conceptually represent that as:

A1  ← paste operation
B1  ← paste operation
C1  ← paste operation
D1  ← paste operation
...

Excel should recognize that this is one paste operation applied across a range, rather than unnecessarily treating every resulting cell change as a completely independent operation.

This kind of deferred or lazy materialization could potentially make huge operations dramatically cheaper.

2. Make operations transactional

Instead of thinking:

“I changed 16,384 cells.”

Excel could think:

“I performed one paste operation across a large selection.”

Then Undo could simply reverse that transaction.

Conceptually:

Operation 1234
    Paste into Row 1

Undo Operation 1234

rather than reconstructing an enormous collection of individual cell states.

3. Make Undo genuinely reliable

Undo should be one of the most dependable things in an editor.

You do something.

You press Undo.

It goes back.

But Excel’s Undo history has limitations and can be cleared or affected by certain operations, including some macro activity.

That’s frustrating because users naturally think:

Undo means undo.

Not:

Undo means undo, provided nothing happened that caused Excel to forget the history.

A more robust transactional history would make Excel feel much safer.

4. Make long operations cancellable

There should be a real:

Cancel

button.

Not End Task.

Not “wait and see.”

Cancel.

And it should work even during large operations whenever technically possible.

5. Show progress

If an operation genuinely takes a long time, tell me.

Something like:

Undoing paste… 62%

would be enough.

Even better:

Undoing paste… 5,459 / 16,384 cells Estimated time remaining: 3 minutes

Suddenly the user knows what is happening.

6. Warn about enormous accidental operations

If you select a large range of cells, such as an entire row, and paste multi-line clipboard content into it, Excel could recognize that you’re about to perform an unusually large operation.

Something like:

This action will affect 16,384 cells. Continue?

Maybe experienced users could disable the warning.

But for an accidental Ctrl+V, that would be an extremely useful safety net.

7. Keep Excel responsive

Where possible, heavy operations should happen in the background.

The interface shouldn’t completely disappear simply because Excel is processing a large operation.

Even if the operation takes 20 minutes, I should still be able to see what’s happening.

8. Don’t let one workbook hold everything hostage

A stuck workbook shouldn’t make the entire Excel environment feel unavailable.

Independent instances should be easier and more obvious.

And then there is the elephant in the room: more rows and columns

Microsoft has increased Excel’s capacity over the years.

Modern Excel has 1,048,576 rows and 16,384 columns.

That’s impressive.

But bigger isn’t necessarily better if the fundamental operations aren’t equally robust.

I don’t necessarily need Excel to keep expanding its theoretical capacity if the fundamental operations on the cells I actually use aren’t equally robust.

I’d rather have:

A faster, safer, cancelable Undo.

I’d rather have:

A paste operation that can’t accidentally consume my afternoon.

I’d rather have:

A progress indicator instead of “Not Responding.”

I’d rather have:

An application that handles basic operations exceptionally well.

In other words, before adding more capacity, make the existing capacity behave intelligently.

Maybe Microsoft is listening

To be fair, Microsoft does accept feedback and has continued making performance and usability improvements to Excel.

And I’m sure the engineering challenges are significant.

Excel is an enormous, decades-old piece of software with an enormous compatibility burden.

There are countless things that depend on its existing behavior:

• formulas
• formatting
• VBA
• tables
• conditional formatting
• merged cells
• named ranges
• external links
• data validation
• filters
• macros
• old workbooks
• third-party integrations

Changing the underlying cell model isn’t something you can casually do.

So I understand why some of these improvements could be genuinely difficult.

But that’s also why the simpler improvements are attractive.

You don’t necessarily have to redesign Excel to make it better.

A cancel button is simpler.

A progress indicator is simpler.

A warning before an enormous operation is simpler.

Better independent-instance behavior is simpler.

Better recovery is simpler.

Even just telling the user:

“Excel is still working. Please wait.”

would be better than:

“Not Responding.”

The positive side of the story

In an effort to excel at being positive about Excel, I have decided to look at this whole experience from a different perspective.

After all, Excel has helped me with a huge number of things.

It has helped me excel at organizing data.
It has helped me excel at calculations.
It has helped me excel at automation.
It has helped me excel at turning messy information into something usable.
And, through VBA, it has helped me excel at making Excel do things that I would otherwise have to do manually.

So I have to give Excel credit where credit is due.

It is an extraordinarily capable piece of software.

You can throw complicated data at it, build elaborate formulas, automate repetitive work, create reports, analyze hundreds of thousands of records, and generally make Excel excel at things that would otherwise require completely different software.

And then there are the other ways Excel excels.

Today, Excel excelled at turning a simple search for a header into an unexpected data-processing event.
It excelled at taking a clipboard containing about 40 lines of text and making me wonder what exactly Excel thought I was trying to accomplish.
It excelled at making Ctrl+V followed immediately by Ctrl+Z into an operation long enough for me to start monitoring CPU time, memory usage, and I/O counters in Task Manager.
It excelled at showing:

Not Responding

while simultaneously demonstrating, through increasing CPU time, changing memory usage, and changing I/O activity, that it was in fact very much responding internally—just not to me.

And perhaps most impressively, Excel excelled at making me spend nearly an hour asking myself:

“Is Excel still working, or am I simply watching Excel excel at not finishing?”

But that’s the strange thing about Excel.

I can’t honestly say that I hate it.

If anything, this experience reminds me why I keep using it.

Excel is powerful.

It has an enormous amount of functionality packed into one application. It can be simple enough for a quick table and powerful enough to become a serious data-processing and automation environment.

That’s why its failures are so frustrating.

When an application is mediocre, you expect mediocre behavior.
When an application is as capable as Excel, you expect the basic things to excel too.

Paste should excel.
Undo should excel.
Cancel should excel.
Recovery should excel.
Responsiveness should excel.
And perhaps most importantly, when Excel decides to spend an hour thinking about something, the explanation should excel at explaining what on earth it is doing.

So perhaps the name really is appropriate after all.

Microsoft didn’t call it “Microsoft Always Works Exactly As Expected.”

They called it Excel.

And Excel certainly does excel.

Sometimes it excels at spreadsheets.
Sometimes it excels at automation.
Sometimes it excels at data analysis.

And sometimes, apparently, it excels at turning a 40-line paste into a nearly one-hour philosophical experience.

Excel excels.

I just wish it would occasionally excel at telling me why.

The overnight experiment

By now, the Excel operation had been running for almost two hours.

Excel was still showing:

Not Responding

And yet, Task Manager continued to show signs of activity.

The CPU usage was still moving.
The CPU time was still increasing.
The Working Set was still changing.
Even the I/O counters had started changing slightly.

At this point, however, I had begun to wonder whether these numbers were really telling me anything useful.

They proved that EXCEL.EXE was doing something.

But were they proof that it was actually making progress?

I wasn’t so sure anymore.

There was no percentage.
No progress bar.
No estimated remaining time.
No message saying:

“Don’t worry, I’m almost finished.”

There was just Excel, quietly consuming CPU time while displaying Not Responding.

And then I realized something.

I was at work.

Eventually, I had to go home.

I could kill Excel, reopen the workbook, and redo the work. Or I could simply leave the computer running and let Excel continue whatever mysterious process it had decided to pursue.

So I chose the second option.

I’m leaving it running overnight.

Not because I have any particular confidence that it will finish.

At this point, it’s more of an experiment.

Maybe tomorrow morning I’ll come back to work and find Excel happily sitting there, completely responsive, as though nothing ever happened.
Maybe the 40-line paste will finally have been undone.
Maybe Excel will have spent the entire night contemplating the meaning of Ctrl+Z.

Or maybe I’ll find exactly the same:

Microsoft Excel — Not Responding

In which case, I think we can safely say that this particular Excel incident has entered a new phase.

At this point, I have stopped asking when Excel will finish.

I am merely grateful that Excel has given me something to write about.

So I’m leaving the computer running overnight.

Day 1 ends here.

Tomorrow, we’ll find out what Excel decided to excel at next.