The universe doesn’t do straight lines
“Everything you’ve learned in school as ‘obvious’ becomes less and less obvious as you begin to study the universe. For example, there are no solids in the universe. There’s not even a suggestion of a solid. There are no absolute continuums. There are no surfaces. There are no straight lines.”
- R. Buckminster Fuller (1895–1983)
If you haven’t thought about this before, it’s one of those ideas that generates a special feeling, something you’ve always known but never articulated. The kind of ideas that make you look up into the sky, eyes lost in the distance and say “Yeah, that’s right,” while you smile and nod slightly.
It also lends itself to pseudo-myth busting: Of course there are straight lines! Here, let me show you, after which we are look at a high-altitude image of salt flats, deserts, rocks, and any number of other things that appear to have reasonably straight lines here and there at different resolutions. But there’s no “reasonably straight” in math, geometry, topology, and that’s what we’re talking about.
Even the most ubiquitous, inescapable “line” in nature, the skyline, or horizon, is not a line at all, but a curve of such diameter that it can’t be discerned by the naked eye unless you’re, well, flying.
But… why? There’s no law of physics or biology expressly against straight lines, 90-degree angles, or perfect geometric shapes. DNA is a construct of incredible complexity. Surely a straight line wouldn’t be a problem if it had an advantage.
Thinking about it from an evolutionary/natural selection perspective it becomes clear pretty quickly that there’s little advantage to something being perfectly straight compared to anything “reasonably” straight (in the few cases in which you need it). On the other hand, “perfection” has a very clear cost.
Consider — Anything that can bend will eventually bend and cease being straight if that was its initial state. Therefore, the only way for something to remain straight for a long time with all the environmental uncertainty created by nature is for it to be extremely rigid, not flexible. So you end up with something that will not bend but that, no matter how strong, will have a point at which it breaks.
Flexibility matters. Bending is better than breaking, a fact that becomes a problem for humans since our bones get stronger as we grow, but the strength translates into less flexibility and therefore more of a chance of breaking outright.
It seems logical then that a perfectly straight line isn’t a thing you’d want in your evolutionary tree.
Speaking of trees.
Trees are interesting when you think about them in terms of construction. When we (humans, that is) started building really big things, we needed the help not only of straight lines but also of the simplest convex polyhedron possible, the tetrahedron, aka pyramid. (Even though the pyramids humans tend to build are not tetrahedrons, since they generally use a square, rather than triangular, polygonal base, the point remains.)
It’s taken us 8,000 years to figure out how to build high without building wide. Meanwhile, many trees grow tall enough and strong enough that humans can live in them, and yet their weight distribution is not unlike a pyramid standing on its tip, supported by the root structure, which while smaller in mass is generally larger in surface covered. (The triangular areas I marked in the images above reference mass, not surface.) The tensile strength and toughness of the materials used matters a lot of course, but so does what you’re trying to use them for.
If you’re just getting started at the whole civilization thing, and you’re going to build a hut to protect yourself from the elements, or a small vehicle to carry stuff, it is better to use artificial constructs (straight lines, circles, etc) because they make calculations easier, it makes reproduction easier, and it makes verification easier. Early on, at small scale, knowledge can transferred verbally, but as soon as you start writing things down, simple geometries become even more important. You could carry the design to another city, and the master builder that came up with it wouldn’t be able to verify your construction. The certainty of mathematics becomes a necessity, and the simpler the design, the simpler the concepts behind it, the easier it is not only to propagate but also to verify.
For us, then, up until well past the point when we’ve moved beyond simple construction capabilities, it pays off to expend the additional energy necessary to approach mathematical perfection. The advantages are many. The time and energy invested in, say, turning a tree trunk into lumber is acceptable not only because it is easier to use, but also because it’s easier to measure, partition, buy, sell. This, in turn, makes markets and therefore whole economies function more effectively and efficiently as well.
As you advance in building your civilization you start to see that evolving past a certain point both requires and enables flexibility in how and what you create. It’s not just about architecture, or mechanical engineering. Clothing, for example, also had to pass through a period in which mass-production constraints around what you could deliver resulted in straight lines everywhere. Think back at the sharp edges and angles in suits and dresses of the late 1940s and 50s, when mass production of those items became commonplace.
Now, Betty & Don probably aren’t fooling around with mass produced stuff, but manufacturing capabilities invariably affect design and therefore fashion — even for high end goods since, after all, they are part of the same ecosystem.
Attack of the rectangles
Now, this has all been very entertaining so far but my point is really (you guessed it) about software.
Straight lines are easier in software, too. Software interfaces have been somewhat stuck in the same era of rigidity as architecture, engineering, and even clothing were stuck in until the very end of the 20th century, when new processes and materials allowed us to start creating strong, bendable, curved surfaces.
Take a step back and look at your phone, or laptop screen. Start counting rectangles, or, as we could also call them, boxes.
There are boxes everywhere! Invisible boxes contain other boxes all over the place.
Don’t get me wrong, I am not saying boxes are evil or anything like that. Rectangles are fine, they’re our friends. They’re cool. In the 80s, I think it was even hip to be square for a while. But we’ve become overly reliant on them. We use them as a crutch. Instead of trying to figure out how to make something work for a specific task, we use rectangles everywhere, because we know they work, even if they aren’t perfect.
This matters because rigidity propagates directly from the interface into our thoughts. It is not the same to have an open white space to write in than to be given a small box and a 140 characters. It is not.
In that vein, I don’t see it as a coincidence that there’s so many great text editors around that focus on eliminating everything but what you’re typing.
Circular/Rotating dials are better than vertical knobs because the human hand has more precision on radial movements than on linear movements. Our extremities are well adapted to rotating and sliding along curves, but everything in our computers is stuck within the vertical and horizontal confines of 2D cartesian coordinate space. With touch on devices (and 3D) we can create interfaces that are both more natural, organic, and can be better adapted ergonomically to how we operate in the real world. The moment you add any kind of spatial analysis using IR and so forth (e.g., Kinect, Leap) significant vertical and horizontal movements, while definitely useful, become secondary to the expressive power of the hand.
Some calendaring systems have now added margins around events to account for travel time, and if you happen to allow enough of your information to be constantly provided to a server, they can help find routes in advance, be smarter about alarms, and so forth.
The event itself though, fundamentally, is still some text in a box.
To begin with, no ‘event’ of any kind that you put in a calendar ever fits in a box. Aha! You’d say — Many calendaring systems let you add text, attachments, and locations, and change colors, and so forth.
But you just put those things in a box, metaphorically, and literally, as far as the interface is concerned.
If you open the event you get even more boxes within boxes that contain some of these files and information, much of which is also in rectangle form.
And when you’re done, as the clock marks 1 pm, that box remains forever frozen to collect digital dust, exactly the same as it was when it started.
Finding meaning and purpose in actions
But that’s not what the event is, is it?
Whatever it is, it’s fluid. Maybe it doesn’t exactly start at that time. Maybe it doesn’t exactly end at that time. Can’t software take note of that?
Have you ever been to any kind of event, meeting, presentation, appointment, that could be properly described by the boundaries of a box or a rectangle? Something that starts here and ends there? Ever?
Say it was a meeting. What about the things that happened during the event? Why can’t you keep track of the links you loaded, the documents seen, changes made right there?
Phone calls made?
People that came and went? We had a list of participants, but we got Joe to come in and help us with something because, duh, he’s actually the one in charge of…
Right? See what I mean?
Maybe you can’t say exactly what shape all of that stuff takes, but it sure as hell doesn’t feel like it fits in anything that has right angles and a preset width and height.
These ideas are obviously important to me and fundamental to how I’ve approached thinking about N3xt, but this isn’t about one system. It’s about trying on new ways to think about what we build, how we build it, and for what purpose.
We need to expand how we think about data and information to the point of challenging the modeling, storage and processing of long-standing fundamental constructs like pages, folders, lists, and so on, on “clients”. It’s a change that’s already been happening in the “backend world” for a while now, and it’s long overdue on the other side. It’s time we move past from using metaphors and concepts anchored in a paper-centric, office-centric, container-centric view of the world. It’s time we let go of linear organizational schemes. Lists are great for some things, but surely they don’t have to be the foundation for everything.
All the major online services rely on incredibly complex infrastructures in which data exists and interacts in a virtual world that is so… removed from what happens when you squeeze it all into http://… and a grid of pixels that it might as well be in another universe. Backend filesystems at scale stopped looking like filesystems a while ago, just to take one example. It’s time to bring some of the magic pixie dust over to the other side and see what happens.
We also have to consistently push against rigid structures to create interfaces based on grids and boxes and lists and menus. We have lived with the same fundamental ideas for almost 50 years now, since the great Douglas Engelbart cracked open the fire pits of invention with the Mother of All Demos. Desktops, files, folders, pages, “cabinets”, a digital approximation of the American Corporation in the 50s and 60s.
We’ve got the tools. We’ve got WebGL, and 3D frameworks, and inputs and sensors up the wazoo.
People aren’t going to be confused or terrified or anything like that. People are constantly adapting to new ways to interact, and we now have a generation that has grown up without knowing what a dialtone is.
In client software in particular, layers are closely linked, more interdependent than in backend software. In the server world hardware homogeneity and network layers actually help a bit in creating more elastic relationships between endpoints — so you can have something amazing like Presto, which gives you new possibilities: an aging squirrel in a wheelchair (SQL) strapped to the nose of a Space Orbiter (Presto) which can turn various toxic-otherwise-unusable solid and liquid fuels (in my metaphor, all the various horrible data sources that you can tap into… I’m looking at you, Oracle-over-JDBC) into precisely guided propulsion that will get you into orbit and back, so the squirrel gets to see space and we get to do something useful with all that horrible toxic stuff while still actually using something cool and shiny and moving things forward in between the two.
On the client, you can’t quite do that. The coupling is too close, the constraints too tight, so if your data model is literally a SQLlite table with 1,000 rows and columns, and you actually use row-access mechanisms and even, God help you, normalized table structures, then it is kind of inevitable that what’s going to show up on screen will look like that. And if it doesn’t, if you’re smushing up the 1,000 rows into a neural network that will give you the ONE row you need and display just that, then why the hell are you storing and fetching stuff using SQLlite? Why not just have a blob of 1,000 other blobs that you read and write atomically, along with whatever you preserve of the neural net between runs?
This doesn’t mean that we have to throw everything away and start from scratch.
Not what I’m saying.
When I see something like what Microsoft proposed here for HoloLens, I have to concentrate pretty hard keep myself from hitting my head against the wall repeatedly.
Because while what we already have is ok at what it does, we just have to let go of the notion that we can keep juicing it forever.
What I’m saying is that we’ll rethink how we approach everything new, and, sure, some of the old stuff might be replaced, but that’s not the point.
So for a quick glance at your watch, just some text that says “Event, 1 hr, starts in 5m” may be fine. You could even have a little colored rectangle around it.
But back in our growing mixed reality world, dealing with ambient sensors, phones, holographic lenses and wall displays … a BB-8 replica that rolls around the room beeping and whistling quietly…. and supercomputers in our pockets, in our desks, and in the infrastructure all around us, the only straight lines should be there only when we create them in our minds.
Just like the horizon.