Systems

I believe the way most organizations produce digital products is fundamentally broken. The elephant in the room is a dated understanding of the role of both design and engineering, which in turn shapes how organizations hire, manage, and produce digital things. These companies invest billions of dollars building teams, processes, and tools on top of an immature discipline and an outdated waterfall model that ends up being detrimental to productivity, team happiness, and ultimately, the resulting experiences we bring to life.

Then it struck me: the flair of filing was still here in Records Management—but it was in the implied aesthetic nature of the filing enterprise: in the alignment of tabs and arrangement of drawers. That pizzazz was to be found, too, in the style of the book itself—in its liberal use of diagrams and illustrations and photographs of state-of-the-art office equipment and fashionably dressed, well-coiffed office ladies. I figured, why not read Records Management against the grain, focusing less on the staid instruction and more on the aesthetic and even ludic nature of filing work? Why not read this textbook as a toy catalogue, or as a set of rules for a Monopoly-esque administrative game?

If control is perfect — if Frank’s car stays at exactly 35 mph — then the system is leaking literally no information to the outside world. You can’t learn anything about how the system works because any other variable plotted against MPH, even one like gas or brake, will look something like this:

This is true even though gas and brake have a direct causal influence on speed. In any control system that is functioning properly, the methods used to control a signal won’t be correlated with the signal they’re controlling.

Worse, there will be several variables that DO show relationships, and may give the wrong impression. You’re looking at variables A, B, C, and D. You see that when A goes up, so does B. When A goes down, C goes up. D never changes and isn’t related to anything else — must not be important, certainly not related to the rest of the system. But of course, A is the angle of the road, B is the gas pedal, C is the brake pedal, and D is the speed of the car.

I find it helpful to think about language models as a “squishy”...

What do I mean by “squishy”?

Language models feel like something organic and biological rather than something mechanical. It feels like we grew them, rather than built them.

...So given that these models are untamed, squishy, biological things, we have a core tension we need to navigate when we’re designing and building with them: squish vs. structure

We’re trying to make an unpredictable and opaque system adhere to our rigid expectations for how computers behave. We currently have a mismatch between our old and new mental models for computer systems.

Thinking [in terms of loops and arcs] allows us to let go of a specific journey or sequence, and imagine dozens of scenarios and possible sequences in which these skills can be learned. This doesn’t mean there aren’t more fundamental skills that other skills build upon, but we can let go the tyranny of how, precisely, a person will move through a system. We’re free to zoom in and obsess on these loops, which does two things for us:

• Approach the design of a system as the design of these as small but significant moments of learning.
• Consider the many ways these loops might be sequenced, with the exact order being less important.

It’s not that I advocate for no note-taking. I just strongly believe in keeping it as elementary as possible, such that the note-taking itself doesn’t become the thrust of the endeavor. Leonardo da Vinci kept all of his notes in one big book. If he liked something he put it down. This is known as a commonplace book, and it is about how detailed your note-taking system should be unless you plan on thinking more elaborately than Leonardo da Vinci. Taping a bunch of cryptic phrases to the walls is also acceptable, or keeping a shoebox full of striking phrases on a jumble of papers, as Eminem did.

Situated software isn't a technological strategy so much as an attitude about closeness of fit between software and its group of users, and a refusal to embrace scale, generality or completeness as unqualified virtues. Situated software…is personal from its inception. Teachers on the Run worked this way. Everyone knew that Paul and Keren built it. You could only rate Clay and Marianne and Tom and the other ITP professors. You didn't even know it even existed unless you were on the ITP mailing list. The application's lack of generality or completeness, in other words, communicated something – "We built this for you" – that the impersonal facade of RateMyProfessors.com doesn't have and can't fake.

Our bias is to always add more. More rules, more process, more code, more features, more stuff. Interdependencies proliferate, and gradually strangle us. Systems want to grow and grow, but without pruning, they collapse. Slowly, then spectacularly.

...A good system is designed to be periodically cleared of cruft. It has a built-in counterbalance. Without this pressure, our bias drives us to add band-aid after band-aid, until the only choice is to destroy the whole system and start from scratch.

Why is it so much easier to add than to remove? Maybe because we attach our identity to what is visible. But there is a difference between the ornamentation that defines our style and the vestigial burdens we carry.

Remember those who did the invisible work of removing. Their legacy was not to build a sand castle, but to care for the beautiful beach on which we play.

The degree of complexity of a system is tied to who we are and what we’re doing over time. When we buy back some complexity by using better tools or picking a simpler environment we’re going to spend that out again eventually.

...We can’t beat complexity, but we can be beat by it.

This talk is about a particular kind of media, which is "media for thinking in." And it's about a particular kind of thinking, which is understanding systems.

...Media are our thinking tools. Our representations of a system are how we understand it.

To understand and build new complex systems, we need powerful new representations, and we need a powerful new medium in which to work with these representations.

Today's representations were designed for the medium of paper. This talk will show examples of new representations for systems, and offer hints as to what a new medium might be look.

I’ve come to the conclusion that “enterprise web development” is just regular web development, only stripped of any joy or creativity or autonomy. It’s plugging a bunch of smart people into the matrix and forcing them to crank out widgets and move the little cards to the right.

In these structures, people are stripped of their humanity as they’re fed into the machine. It becomes “a developer resource is needed” rather than “Oh, Samantha would be a great fit for this project.” And the effect of all this on individuals is depressing. When people’s primary motivation is to move tickets over a column, their ability to be creative or serve a higher purpose are almost completely quashed. Interaction with other humans seems to be relegated to yelling at others to tell them they’re blocked.

Reading “AS PER THE REQUIREMENTS” in tickets makes me dry heave. How did such sterile, shitty language seep into my everyday work?

Adopting a new app is the only way for most people to get new interfaces and features into their personal computing environments. This presents users with a funny challenge: surveying pre-made apps for the ones that, hopefully, match the way they think and work. But this is a surprisingly arduous process because apps often operate on their own silo of data, and they present a new, separate environment which must be learned and adopted. When that doesn’t work, people are stuck trying to use software that doesn’t think or work the way they do.

Alexander has been exploring the concept of an “itemized” OS, one that allows users to construct their own environment. In such an OS all of your digital things — emails, todos, notes, reminders, webpages, podcast episodes, and so forth — are “items” that sit in one, local graph. Users are then able to create new interfaces with the items that matter in their lives and work, or introduce items that bring new functionality to their overall environment (such as having a reminder item which can be added to any other item).

My point here is that in a design system every paper cut is felt. Every collapse leads to another, every new modal or unnecessary checkbox component hinders the collective refactoring that’s required to make a codebase consistent and easy to understand. When it comes to hyperobjects and design systems everything matters (although, frustratingly, it is impossible to measure success) and the smallest problem is just a signal in the dark—a premonition of a monster; organizational dysfunction writ large.

To design a system means to orchestrate the interplay of its elements.

Such a system is considered “interactive” if it is open, which means that there are ways to engage with the processes that are happening inside of it. There is of course a range of interactivities which spans from very basic reactive behaviour to highly complex conversational interactions.

How do we even start to talk about complexity? You might have heard about the term coupling in software. Ideally, systems prefer loose coupling over tight coupling; that is, we try to reduce the amount of interdependencies on any two parts of a system so that if we need to swap out a component, it is easier to do. This becomes important in software because software must change over time, so reducing the complexity between parts will also help reduce the burden of change. But have you of Connascence? This term helps us measure how intertwined parts of your system might be.

Two components are connascent if a change in one would require the other to be modified in order to maintain the overall correctness of the system. — Meilir Page-Jones

...The connascence ranges from weak to strong and from static to dynamic. Counterintuitively, the weaker and more static the connascence, the easier the system is to change. The stronger and more dynamic the connascence, the more complex the system is to change.

I’ll try to convince you of two things:

1. Creating quality is context specific. There are different techniques for solving essential domain complexity, scaling complexity, and accidental complexity.
2. Quality is created both within the development loop and across iterations of the development loop. Feedback within the loop, as opposed to across iterations, creates quality more quickly. Feedback across iterations tends to measure quality, which informs future quality, but does not necessarily create it.

What if we proactively design our games to facilitate positive human relationships? We propose that games built on a foundation of kind aesthetics can deliver greater player satisfaction, greater long term engagement, and richer human experiences.

...Let’s make kind games where players help one another in safe, supportive environments. We define kind games as multiplayer games designed from the start with systems that deliberately promote prosocial behavior:

• Systems encourage players to help one another and their community.
• Players form authentic attachments that alleviate loneliness.
• Groups interact peacefully with each other.
• Toxic behavior is carefully monitored and mediated.
• Social systems foster belonging.

“In the past the man has been first. In the future the system must be first.” — Fred W. Taylor

Taylorism was a way of thinking that came at the expense of the workers’ own knowledge of their system. Taylor summed up his philosophy thus:

“It is only through enforced standardization of methods, enforced adoption of the best implements and working conditions, and enforced cooperation that this faster work can be assured. And the duty of enforcing the adoption of standard and enforcing this cooperation rests with the management alone.”

The unscripted practices of the old offices would remain, but as a kind of subterfuge: in the future, a leisurely pace wouldn’t be the norm; time would not be given, but stolen.

When trying to understand systems, one really eye-opening and fundamental insight is to realize that the machine is never broken*. What I mean by this is, when observing the outcomes of a particular system or institution, it’s very useful to start from the assumption that the outputs or impacts of that system are precisely what it was designed to do — whether we find those results to be good, bad or mixed.

...The next step, then, is to reflect on the systems around us now that we are cursed with the horrible truth that all of them are working correctly. Ask yourself, how do you get the power to change the system so that it wants something else, so that it can only inevitably do the right thing? Is there a reasonable path to that power? Or does that system need to be dismantled, so that it can be replaced by a system whose purpose is to do the right thing?

In the early days, design systems promised us more consistent interfaces, more collaborative teams, and improved shipping times. While they’ve certainly delivered on some of those fronts, they’ve introduced new challenges too. Let’s talk through what’s working well—and what could be working better—as we take a closer look at the systems between us and our work.

One of my favourite laws – one of those principles that seem to be universally applicable – is Gall’s Law. People who have worked with me in the past are probably very tired of hearing about it.

...In my experience, this is a universal rule.

I have never seen anybody manage to break John Gall’s Law. It applies to every single aspect of software development, in that we are fond of planning and organising and building complex systems from scratch. We design these intricate structures of objects and classes that interact. We build things that have no chance ever of working.

Instead, the alternative that I always advocate is to try to bake evolution into your design. It’s fine to have a complex system design that you’re aiming for in the long term, but you need to have a clear idea of how it will evolve from a simple system that works to a complex system that works.

You cannot leap straight into the complex system.

You have to start small.

The Cobra Effect refers to a situation where an attempted solution to a problem actually makes the problem worse as a result of unintended consequences.

The term comes from an unverified story taking place during the British colonial rule of India. Concerned about the number of venomous cobras in Delhi, the British government offered a bounty for every one killed. Initially, this was successful, with a massacre of the snakes. However, enterprising locals started breeding cobras to collect more of the bounty. When the government realised this, they canceled any more rewards, leading the breeders to release their now worthless snakes, causing the cobra population to increase beyond the number of the original population.

Our ancestors weren’t stupid. They were trying to find some kind of logical progression of cause-and-effect, but they lived in epistemic hell. This is why cargo-cult programming exists. This is why urban legends persist. This is why parents simply want their children to do as they say. This is why we have youtubers chastising NASA for not reading their own Apollo 11 postmortem. This is why corporate procedures emphasize checking boxes instead of critically examining the problem. When your cause-and-effect chain is a hundred steps long and caused by something 5 years ago, economic pressure incentivizes simply trying to avoid blame instead of trying to find the actual systemic problem. The farther up the chain of management a problem is, the longer it takes for the effects to be felt, and the worse we get at finding the root cause. Software engineering has the same issue, where incompetence may only cause performance issues years later, after the original coder has left, and the system has scaled up beyond a critical breaking point. This is why we still don’t know how to hire programmers.

A complex system that works is invariably found to have evolved from a simple system that worked.

A complex system designed from scratch never works and cannot be patched up to make it work.

You have to start over with a working simple system.

Modern computing is far too rigid. Applications can only function in preset ways determined by some far away team. Software is trapped in hermetically sealed silos and is rewritten many times over rather than recomposed.

This community catalogs and experiments with malleable software and systems that reset the balance of power via several essential principles:

1. Software must be as easy to change as it is to use it
2. All layers, from the user interface through functionality to the data within, must support arbitrary recombination and reuse in new environments
3. Tools should strive to be easy to begin working with but still have lots of open-ended potential
4. People of all experience levels must be able to retain ownership and control
5. Recombined workflows and experiences must be freely sharable with others
6. Modifying a system should happen in the context of use, rather than through some separate development toolchain and skill set
7. Computing should be a thoughtfully crafted, fun, and empowering experience

1. I want it to feel intuitive
2. I want any new features to be platform features, not one-offs.

And the second of those is weird, right? It’s like sketching out a toy spaceship, having a list of rules about play, and attempting to simultaneously invent the shape of the Lego brick.

That’s platform design I suppose. Redesigning a newspaper will mean bouncing between comps and style guides, designing both. Inventing the iPhone user interface will have seen apps and app paradigm evolving together.

The best software tester I’ve ever known once said to me, “Whenever I start at a new place, I find out which teams hate each other. Where their systems interface with each other is the first place I look for bugs — because they’re not talking to each other.”

Software projects stand and fall on the relationships between the humans who create them. (A corollary to Conway’s Law.)

It’s kind of funny when you think about it: what’s worse than the technical problem of building and maintaining multiple native applications? The people problem of building and maintaining multiple native applications.

To belabor the point, I am reminded of Dave’s post about states. He enumerates a large (but not comprehensive) list of the many of the dimensions that affect the your application. I’m not good at math, but to Peter’s point about how these compound, imagine the math on Dave’s list of states. That’s got to be a very, very large number.

How can you know that you have correctly functioning code?

This is what kills you with trying to control complexity. All the small variances play off of each other to create an unknowably complicated environment.

Sometimes, you have to learn to let go of control.

There must be a permanent conflict between a project and its programmers: 1) the project must be configured to reject anything that lowers the quality of its artifacts and 2) programmers must be interested in making changes to those artifacts. The project cares about the quality, the programmers care about fast delivery of modifications.

...If we put these two interests in conflict, we will get a high-quality product, which is growing very fast. The project will enforce quality, programmers will push the code forward, making changes fast and frequently.

The report follows up Dr. Rothenberg’s 1995 article in Scientific American, “Ensuring the Longevity of Digital Documents” by elaborating the author’s proposal for emulating obsolete software/hardware systems on future, unknown systems, as a means of preserving digital information far into the future.

It seems this transformation, from physical object to vector of data, is a general and oft-repeated process in the history of technology, where new inventions begin in an early experimental phase in which they are treated and behave as singular individual things, but then evolve into vectors in a diffuse and regimented system as the technology advances and becomes standardized.

In the early history of aviation, airplanes were just airplanes, and each time a plane landed or crashed was a singular event. Today, I am told by airline-industry insiders, if you are a billionaire interested in starting your own airline, it is far easier to procure leases for actual physical airplanes, than it is to obtain approval for a new flight route. Making the individual thing fly is not a problem; inserting it into the system of flight, getting its data relayed to the ATC towers and to flightaware.com, is.

The [Lake Erie] ecosystem underwent a series of changes, each of which were related. There was an increase in the human population; which led to higher phosophorus levels in the water; which led, at last, to an increased level of algae in the lake. In effect, Lake Erie’s ecosystem was rewritten. Changed by human activities into…something else.

But Franklin cites the study because it’s doing something slightly novel: applying Selye’s principle of stress to ecological systems, suggesting that they are, much like humans, just as susceptible to external stressors. And I’ve been thinking about that a lot lately, especially this week. Because Franklin’s suggesting that the work begins not by “fixing the system.” Rather, she suggests it’s about shifting the priority a little: to removing whatever stress you can.

[Brian Cantwell] Smith’s first example [from On the Origin of Objects] is fanciful but intended to quickly give the flavour of the idea:

…imagine that a species of “super-sunflower” develops in California to grow in the presence of large redwoods. Suppose that ordinary sunflowers move heliotropically, as the myth would have it, but that they stop or even droop when the sun goes behind a tree. Once the sun re-emerges, they can once again be effectively driven by the direction of the incident rays, lifting up their faces, and reorienting to the new position. But this takes time. Super-sunflowers perform the following trick: even when the sun disappears, they continue to rotate at approximately the requisite ¼° per minute, so that the super-sunflowers are more nearly oriented to the light when the sun appears.

A normal sunflower is directly coupled to the movement of the sun. This is analogous to simple feedback systems like, for example, the bimetallic strip in a thermostat, which curls when the strip is heated and one side expands more than the other. In some weak sense, the curve of the bimetallic strip ‘represents’ the change in temperature. But the coupling is so direct that calling it ‘representation’ is dragging in more intentional language that we need. It’s just a load of physics.

The super-sunflower brings in a new ingredient: it carries on attempting to track the sun even when they’re out of direct causal contact. Smith argues that this disconnected tracking is the (sunflower) seed that genuine intentionality grows from. We are now on the way to something that can really be said to ‘represent’ the movement of the sun:

This behaviour, which I will call “non-effective tracking”, is no less than the forerunner of semantics: a very simple form of effect-transcending coordination in some way essential to the overall existence or well-being of the constituted system.

In my opinion, what makes a designer competent is precisely their ability to credibly justify their conclusions. If you can’t do this as a designer—no matter how successful your results are—then neither I nor anybody else can tell if you aren’t just picking things at random.

What I am proposing, then, is no less than to make a designer’s entire line of reasoning a matter of permanent record. On the surface is the familiar set of prescriptions, components, examples and tutorials, like you would expect out of any such artifact. Attached to every element, though, is a little button that says Why? You click it, and it tells you. The proximate explanation will probably not be very satisfying, so you click on the next Why? until you get to the end, at which point you are either satisfied with the explanation, or you aren’t.

Everything points to the conclusion that the phrase 'the language of art' is more than a loose metaphor, that even to describe the visible world in images we need a developed system of schemata.

Knots, a 1970 book by the Scottish psychiatrist R.D. Laing, is based around a collection of patterns of human thinking, metacognition, and theory of mind, drawn from real experience with patients but turned into abstracted examples. The approach has the potential to be adapted into a range of formats which enable systemic design phenomena such as recursion, reflexivity, theory of mind, and second-order effects in systems to be explored, as a way of thinking about systems for design students and adding to their conceptual vocabulary, but potentially also as a method for doing research with people.

This paper illustrates example 'new knots' around topics including sharing data, social media, clickbait, and 'smart' homes.

Driving down the cost of operating all those systems is core to your business as a vendor, and that’s argument toward elegance in architecture on its own.  However, probably just as important to your offering is the effect of what you have in the background has on your user’s experience.  And obviously, that’s something that your customers care deeply about.

“No modes.” – There’s a story about Macintosh development at Apple in the early 80’s. Larry Tesler and Jef Raskin fought hard against software that forced the user to change “modes.” Larry Tesler even had a license plate that said “NOMODES.” ...Unfortunately, even in 2010 enterprise software is rife with ‘modes.’ ...Companies built by acquisition frequently “smush” their web products together and make you switch applications as well and then call that “integrated.” Yuck. 

Switching “modes,” as it were is a key clue that what a vendor is selling you isn’t truly connected under the covers.

General Systemantics (retitled to Systemantics in its second edition and The Systems Bible in its third) is a systems engineering treatise by John Gall in which he offers practical principles of systems design based on experience and anecdotes.

It is offered from the perspective of how not to design systems, based on system engineering failures. The primary precept of the treatise is that large complex systems are extremely difficult to design correctly despite best intentions, so care must be taken to design smaller, less-complex systems and to do so with incremental functionality based on close and continual touch with user needs and measures of effectiveness.

The basic idea of legibility is that the act of making something comprehensible enough to control is itself an act that shapes the thing to be controlled, often with far greater consequences than the control itself. This is because it removes complexity that is deemed as irrelevant that makes it harder to control, and that complexity may be in some way essential to the health of the system.

The importance of diversity is not so much the number of elements in a system; rather it is the number of functional connections between these elements. It is not the number of things, but the number of ways in which things work.

Nearly 50 years ago, long before smartphones and social media, the social critic Lewis Mumford put a name to the way that complex technological systems offer a share in their benefits in exchange for compliance. He called it a “bribe.” With this label, Mumford sought to acknowledge the genuine plentitude that technological systems make available to many people, while emphasizing that this is not an offer of a gift but of a deal. Surrender to the power of complex technological systems — allow them to oversee, track, quantify, guide, manipulate, grade, nudge, and surveil you — and the system will offer you back an appealing share in its spoils.

Why aim small in this era of fast computers with plenty of RAM? A number of reasons, but the ones that are most important to me are:

• Fewer moving parts. It’s easier to create more robust systems and to fix things when they do go wrong.
• Small software is faster. Fewer bits to download and clog your computer’s memory.
• Reduced power consumption. This is important on a “save the planet” scale, but also on the very local scale of increasing the battery life of your phone and laptop.
• The light, frugal aesthetic. That’s personal, I know, but as you’ll see, I’m not alone.

An API should be easy to learn and write to, and hard to misuse. Your API will also need to evolve, and a good design takes this into account.

The innovator has a systems mind, one that sees things in terms of how they relate to each other in producing a result, a new gestalt that to some degree changes the world.

Technology is not the sum of the artifacts, of the wheels and gears, of the rails and electronic transmitters. Technology is a system. It entails far more than its individual material components. Technology involves organization, procedures, symbols, new words, equations, and, most of all, a mindset.

Today, most design systems work like dictionaries, composed of a finite set of definitions. But there’s a new page turning, one that ushers in the age of functions. Design systems are evolving to survive in a world where applications and experiences exist on vastly different screen sizes, for different accessibility needs, language modes, hardware specifications, and spatial dimensions. For these complex interfaces, dictionaries just can’t cut it.

Design systems are starting to use functions that recreate the design decision making process, responding appropriately to any input they are given. The early uses of functions do a great job of extending the reach of design systems. But the potential is vast.

For things to work properly, we must remember that:

• The inputs needed by one element are supplied by other elements in the system; and
• The outputs needed by one element are used by other elements (including ourselves).

When the elements of a set belong together because they cooperate or work together somehow, we call the set of elements a system.

From a designer’s point of view, the physically unchanging part of this system is of special interest. I define this fixed part as a unit of the city.

Whatever picture of the city someone has is defined precisely by the subsets he sees as units.