And yet another way to put this (just to further bewilder and bore most of the people who read this blog, which heretofore has not been a programming geekery blog; sorry about that) is that most of the Design Patterns in the Design Patterns book are actually symptoms of a mid-level language.
My gut feeling is that the utility of programming languages is trimodal.
On one end you have programs that are best done in Visual Basic or some other what they used to call 4GLs -- or else in scripting languages used as scripting languages. Programs that are, in one sense at least, not hard, and which need to be flat: the logic is straightforward, and the team you have doesn't want to traverse an inheritance heirarchy to figure out what's going on. Maybe you have a large, inexperienced team, or maybe you're going to use the program a few times and throw it away. So you don't care about refactoring much.
The second mode is programs that need to be long-lived, flexible, and robust, and have a lot of business/domain logic which is sort of arbitrary -- there's a limit to how elegantly it can be compressed down, because it was made up by business folks and there aren't any set of simple, coherent underlying principles you can reduce it to. So the real problem is organizing this large set of arbitrary, somewhat incoherent, changing rules and behaviors. I have a feeling that this is what object oriented languages are good at: they provide an infrastructure for you to organize all the logic.
The third mode is where you have programs that are hard in a good way: where you have a hard problem, but the difficulty is a feature of nature, not of a mass of sort-of-contradictory requirements. Something like, say, the core algorithms of indexing the web like Google does, I imagine would fall in this category. Or maybe not? I'm thinking of cases where it'd be a win not to have a large number of somewhat skilled programmers, but rather 1-3 extremely gifted programmers. In this mode, I'd imagine that you want a very concise, powerful, elegant high-level language (and then you want to profile it and rewrite the bottlenecks in C).
In that sense of truly high-level language, for that kind of problem, you can look at the Gang of Four Design Patterns as "language smells" analgous to Fowler's Code smells. If a language forces you to create a Visitor heirarchy rather than just passing in a block of code, it's a mid-level language, along the axis I'm describing.