Comments on: It’s All About Interfaces

By: Ferenc Mihaly

Ferenc Mihaly — Sun, 22 Jan 2012 23:26:42 +0000

I read this post with great interest, software interface design being a passion of mine. I completely agree that getting the interfaces right is the key to building large-scale software systems.

The current situation is not very good. I only realized just how bad some interfaces can be after I left academia and started working in the software industry. I haven’t seen truly bad interfaces, at least not interfaces used by hundreds of thousands of programmers, until I worked with some “enterprise systems”.

Large scale systems are built by necessity using interfaces at a much higher level of abstraction than the operating system. If these interfaces were built at least with as much care as those of the OS, this, in itself, would be a huge improvement. While I’m sure new knowledge will continue to emerge, I’m convinced that we can achieve big improvements by simply spreading and applying the knowledge we already have.

By: gasche

gasche — Sun, 22 Jan 2012 15:12:49 +0000

I feel you are misinterpreting the VPRI initiative a bit. Indeed, their stated goal is to reduce the total size of code in a system. But what’s interesting is what they’re doing in practice: designing small, hopefully clean and powerful abstractions to capture the different problem domains of personal computing. So the approach they have to size reduction is exactly the approach you advertise for system robustness, and in practice I expect both initial motivations to provide related results.

By: Greg Morrisett

Greg Morrisett — Thu, 19 Jan 2012 15:29:08 +0000

Great post. Seems like there are two kinds of durability for interfaces though. On the one hand, there are interfaces like ASCII that replaced a bunch of other things, were clearly superior and simpler, and made the world a better place for a long time.

Then there are interfaces like x86 ISA and Win32 and GCC that are durable, but out of necessity—too much on top needs to keep running—and so heroic engineering is done to keep them viable. These things are ripe for replacement, but the trick is figuring out when, and getting sufficient mass/compatibility to make it stick. A good recent example is LLVM which has taken on the GCC interface.

By: Ben L. Titzer

Ben L. Titzer — Wed, 18 Jan 2012 18:34:38 +0000

Sometimes things get simpler when we look at the stack of layers as a whole. Each the layers was built up incrementally upon the layers below, and they usually co-evolve from simpler forms, with more rapid evolution happening in higher layers. But after a sufficient end-state of the higher layers (those closest to the application) has been reached, it sometimes yields surprising simplicity gains to collapse adjacent layers together and redesign them together. Lower layers are necessarily more general-purpose than the layers above, and sometimes that generality is unwarranted, and the vestigial parts can be removed.

I think as computer scientists and architectures we should be courageous enough to throw out all of our lower level software and rebuild it from scratch at least once a decade, reusing the knowledge from the previous iteration. If the abstractions from the previous iteration are worthwhile they will reemerge. If they aren’t, they will die.

/axe-grind
And I think each iteration should also strive for a better language in which to be expressed. 40 years of C/C++ is about 25 too long, in my opinion.
/axe-grind-off

By: reno

reno — Wed, 18 Jan 2012 09:56:58 +0000

@Eddie Kohler ” For RISC, wordy ISAs”
Remember that during some time, the number of transistors used to decode CISC was a real issue and slowed down significantly the CPU: x86s were much slower than RISCs, even if x86s used more transistors..
SW compatibility with Windows proved more important than raw performance and nobody cares about the number of transistors in the decoder anymore (except for their power usage), still you cannot say that RISC was only about “wordy ISA”, it was about better performances.