Nicholas Shaheed


Music 256A / CS476a, Stanford University

Reading Response: Balance and Tradeoffs

From this week’s reading I’d like to respond to a number of different sections that either directly address, or touch on, Pareto efficiency. This is a mental model which I think integrates well with many of the principles of design outlined in Artful Design.

As Wikipedia states:

Pareto efficiency or Pareto optimality is a situation where no individual or preference criterion can be made better off without making at least one individual or preference criterion worse off.”

So, in a situation/idea/creation/problem where something has multiple dimensions of quality, trying to seek improvements along some dimension without making the other dimensions worse. This is basically making the situation unequivocally better.

However, for most things, once a certain level of optimization has been reached it’s no longer possible to make improvements along one dimension without making another dimension worse. This is a situation that is Pareto-optimal or Pareto-efficient, which Wikipedia helpfully defines as:

“A situation is called Pareto-optimal or Pareto-efficient if no change could lead to improved satisfaction for some agent without some other agent losing or, equivalently, if there is no scope for further Pareto improvement.”

Which means that there is some plane of optimality, where it’s no longer about making improvements, but making trade-offs about which dimensions you want to optimize at the expense of others. This concept of making trade-offs is obviously a common theme in engineering, but I believe it also applies to art, design, and many other parts of life. For example, Principles 1.6 of Artful Design:

Principle 1.6: Design is an interplay between function and form

Here there is an obvious trade off, where the extremes are optimizing function or optimizing form (as much as you can with form every following function). However, somewhere in between is where design is. Using the pencil bag example, the choice to make it made completely out of zippers probably negatively affects the cost and durability of the bag (the function) in order to enhance the playfulness and aesthetic interest of the end-product. This is not necessarily a less optimal solution than a more plain pencil bag, but it is a different point in space along the plane of Pareto-optimality. Like Principle 1.6 states, design is operating along that intersection and I think it could be argued that the sublime (or at least some small aspect of it) is finding some point of Pareto-optimality that speaks to your personal experiences and values. Another way of stating that in terms of Artful Design’s Definition 1.2 is that artful design seeks to find points of Pareto-optimality that are sublime.

Design Etude

Part 1

Take note of three things in your day you find beautiful and that you recognize to be design.

  1. The page layout in a notebook I own
  2. Generalized abstract datatypes (GADTs), particularly, the implementation of this in Haskell.
  3. Mayonnaise

Part 2

Perform a functional-aesthetic analysis on the three things in part 1.

Notebook Page

I find the design of the page in a notebook that I own (which is called the Standard Issue Project Notebook No.4 and made by Designworks Ink) to be particularly elegant in how well it is laid out as well as how it makes writing itself feel good.

Physically, the paper itself feels both sturdy and is smooth with the slightest amount of texture to it. Writing on it with a pen/pencil/fountain pen all feel smooth, but with a little bit of tactile scratch that is unique to paper. It doesn’t feel like you’re writing on a screen. All of these subtle physical properties of the paper make it satisfying and enjoyable to write on, it makes you feel like you’re writing something important.

The layout of the paper feels like a very thoughtful interplay of form and function. The majority of the space is allocated towards the ruled print to write prose in. However, the margins and external additions feel like they meaningfully add to what information you can present on the paper without deprioritizing the paper as a space for writing.

At the top you have the date markers, which are smartly laid out horizontally. This accomplishes three things: it’s compact to help maximize the amount of paper that is ruled, it quickly lets you mark the date, in a physically spread-out way that allows you to quickly glance at a page and see the date (without having to parse specific words or numbers). These all encourage organization and being able to reference back to old pagers without taking up much more space than just the subject line.

The left and right margins are mostly blank, but there is enough room that you can write headers here instead of taking up an entire line of paper. The horizontal rules extending out past the vertical rule subtly encourage this while also helping you keep your notes aligned.

At the top and bottom of the ruled printing there are small vertical notches. This makes it easy to draw straight lines if you need to make a quick graph or something, helping prevent awkwardly angled vertical lines that might happen if you try to freehand this. This is all a seriously impressive amount of functionality that looks and feels while not impeding your ability to use the notebook to write! 

Generalized Abstract Datatypes (GADTs)

Without getting too much into the weeds on this, GADTs are a language construct that I first encountered in the language Haskell (which is a lazy, statically types, purely functional programming language). They provide a really powerful and elegant way to express structure in the language that takes advantage of many of Haskell’s conceptual and ergonomic niceties.

Here’s an example from the above link:

data Expr a where
EBool  :: Bool     -> Expr Bool
EInt   :: Int      -> Expr Int
EEqual :: Expr Int -> Expr Int  -> Expr Bool

-- A function that evaluates an expression
eval :: Expr a -> a
eval e = case e of
EBool a    -> a
EInt a     -> a
EEqual a b -> (eval a) == (eval b)

Functionally, this example is defining a very simple language that checks for equality of two values.  But it’s much more than that, it takes advantage of Haskell’s type system to define the relationships in a readable manner (you can figure out 90% of what this code does by just looking at the type definition)  that is powerful (notice how this language is a recursively-defined abstract syntax tree), easy to expand (you just add an extra line if you want to define Floats), and easy to write code for (pattern-matching in Haskell lets you simply have a case for each type of expression). It also takes advantage of Haskell’s type system to make it easy to refactor: if you modify the type definition you will just get type errors pointing to every part in your code where the old behavior is incorrect. Just follow the compiler until it stops complaining.

I think one of the many aspects of how GADTs are designed is that they feel like there’s very little friction in going from idea to implementation, which makes using this construct very satisfying to use.


I really like mayo. Not only does it taste great (which might be a contentious opinion), but it is a simple and flexible condiment that fills a fundamental role in cooking (namely, as a source of fat in a dish). I’ll mostly be talking about homemade mayo here.

Functionally, it is cheap and easy to make - you literally just need an oil, acid, and an emulsifier (like egg) - that is easy to store and easy to add onto food. As a way to make tasty food, it is as flexible as it is easy. There’s a huge variety of sauces that use mayo as a base, from ranch to caesar dressing to the sauce that makes spicy tuna. It also makes things taste good (within reason).

Guerilla Design

My aesthetic addition to my life was through my todo list I’ve built up in my gmail inbox using labels. The before and after pictures are below, but previously I just had a single TODO label where I dumped all emails that I needed to get to. Now I’ve added different categories of things I need to get to as sublabels (i.e. _TODO/Apps for things to apply to) as well as color-coded the labels to make it easier to navigate. In addition, I set up filters so that, for example, an email is sent to me as <my-email>, it will automatically apply the proper label, meaning I can just send myself an email if I need to add something to my todo list.



Chuck Program

Here is a chuck program that does in fact make sound

// A really inefficient way to make an impulse

1000 => int count;

for(0 => int i; i < count; i++) {
        SinOsc s => dac;
110 + i => s.freq;
1.0 / count => s.gain;

// it's slow so printing out a progress report while it's
// rendering is helpful.
for(0 => int j; j < 45; j++) {
        <<< j >>>;
1::second => now;