Cubism and Unbundling

Cubism and Unbundling.md

The terms "cubism" and "unbundling" come from very different domains—art and business/economics, respectively—but they can be metaphorically linked in discussions about deconstruction, fragmentation, and reassembly. Here's how:

1. Cubism (Art Movement)

• Developed by Pablo Picasso and Georges Braque in the early 20th century.
• Breaks objects into geometric fragments, showing multiple perspectives at once.
• Rejects a single viewpoint, instead presenting a deconstructed, abstracted reality.
• Example: Picasso’s Les Demoiselles d’Avignon (1907) fractures human figures into angular planes.

2. Unbundling (Business/Economics)

• Refers to breaking apart traditionally bundled products/services into standalone offerings.
• Driven by digital disruption, modularity, and consumer demand for customization.
• Examples:
  • Media: Netflix unbundling TV channels into on-demand streaming.
  • Finance: Fintechs unbundling banks (e.g., PayPal for payments, Robinhood for investing).
  • Software: SaaS tools replacing monolithic suites (Slack vs. Outlook).

Metaphorical Connection: Deconstruction & Reassembly

• Both concepts involve breaking down a whole into parts (visually in Cubism, structurally in unbundling).
• Cubism reassembles fragments into new artistic meaning; unbundling reconfigures industries by isolating value streams.
• Just as Cubism challenged traditional art, unbundling disrupts legacy business models.

Modern Implications

• Tech: Companies like Uber (unbundling taxis) or Spotify (unbundling albums) follow a "cubist" logic—extracting and recombining elements.
• AI/Data: Unbundling knowledge (e.g., ChatGPT parsing information vs. traditional encyclopedias).

Would you like a deeper dive into either concept or their intersection in innovation theory?

their intersection in innovation theory

The intersection of Cubism and unbundling in innovation theory offers a fascinating lens to analyze how fragmentation and recombination drive creativity and disruption. Both concepts challenge monolithic structures—whether in art or business—by deconstructing wholes into parts and reassembling them into new value systems. Here’s how they align in innovation frameworks:

---

1. Deconstruction as a Creative Engine

Cubism: Shattered the illusion of a single perspective, forcing viewers to engage with overlapping, fragmented realities.
Unbundling: Dismantles integrated systems (e.g., banking, media) into discrete components, enabling niche innovation.

Innovation Insight:

• Modularity Theory (Carliss Baldwin, Clayton Christensen) argues that breaking systems into modules (like Cubism’s facets) accelerates innovation. Example:
  • Smartphones unbundled cameras, GPS, and music players—then reassembled them into a single device.
  • AI tools (like ChatGPT) unbundle knowledge from encyclopedias, textbooks, and experts, then recombine it dynamically.

---

2. Multi-Perspective Thinking

Cubism: Presented multiple viewpoints simultaneously, rejecting a "single truth."
Unbundling: Reveals hidden value in subsystems by analyzing them independently (e.g., Airbnb unbundling "accommodation" from real estate ownership).

Innovation Insight:

• Jobs-to-Be-Done (JTBD) Theory: Unbundling exposes unmet customer "jobs" by isolating pain points. Example:
  • Netflix saw that viewers wanted on-demand content (a job), not linear TV bundles.
  • Cubist thinking would map this as overlapping needs (convenience + personalization + discovery).

---

3. Recombination as Disruption

Cubism: Reassembled fragments into abstract but coherent art.
Unbundling: Liberated components are recombined into new models (e.g., fintech apps mixing payments, lending, and investing).

Innovation Insight:

• Combinatorial Innovation (Brian Arthur): Breakthroughs emerge from novel combinations of existing parts. Examples:
  • Platform Ecosystems: Apple’s App Store unbundled software distribution, then let developers recombine APIs into new apps.
  • Digital Art: NFTs unbundle art ownership from physicality, echoing Cubism’s abstraction of form.

---

4. Challenging Hierarchies

Cubism: Democratized perspective (no "correct" viewpoint).
Unbundling: Flattens industries by decoupling gatekeepers (e.g., Substack vs. traditional publishing).

Innovation Insight:

• Disintermediation: Unbundling removes middlemen (like Cubism rejected artistic conventions). Example:
  • Crypto unbundles trust from banks (blockchain as a "cubist" ledger—transparent, fragmented, yet cohesive).

---

Case Study: The "Cubist Corporation"

Companies like Amazon and Tesla operate with a Cubist mindset:

1. Unbundle: Amazon separated retail, cloud (AWS), logistics, and AI.
2. Recombine: Alexa integrates voice tech (unbundled from UI), e-commerce, and third-party skills.
3. Multi-Perspective: Tesla treats cars as software platforms, energy nodes, and data collectors—all at once.

---

Why This Matters for Innovators

• Design Thinking: Embrace fragmentation (user pain points = Cubist facets) to ideate solutions.
• Agility: Like Picasso’s rapid stylistic shifts, firms must pivot as unbundled markets evolve.
• Ambiguity Tolerance: Cubist innovation thrives in ambiguity (e.g., Web3’s unbundled ownership models).

Future Frontier:

• AI & Cubist Creativity: Generative AI unbundles artistic elements (style, composition) and reassembles them.
• Metaverse: Unbundles physical space, identity, and assets—then recomposes them digitally.

---

Key Takeaway

Cubism and unbundling both teach us that innovation thrives when we dissect, question, and recombine the familiar. The next breakthroughs will come from leaders who, like Picasso, see the world not as fixed structures but as dynamic fragments waiting to be reconfigured.

Would you like to explore specific industries (e.g., healthcare, education) through this lens?

Isn't that what poetry is about? Extract the words, reconstruct them by combining different meanings, and put them back together.

Absolutely! You’ve struck at the heart of a profound parallel: Poetry operates like Cubism and unbundling in language, deconstructing and reassembling meaning in ways that defy linear logic. Let’s break down the connection:

---

1. Deconstruction of Language

• Cubism: Fragments objects into geometric shards.
• Unbundling: Isolates components of a product/service.
• Poetry: Unbundles words from their conventional usage.
  • Example: E.E. Cummings’ "l(a le af fa ll s) one l iness" breaks "a leaf falls" into fragments to evoke loneliness.

Innovation Link: Just as unbundling exposes hidden value in subsystems, poetry reveals latent meanings in syllables, sounds, and spacing.

---

2. Recombination for New Meaning

• Cubism: Reassembles perspectives into a new visual logic.
• Unbundling: Combines standalone features into novel products (e.g., TikTok = unbundled video + algorithm).
• Poetry: Recombines words to create ambiguity, rhythm, or metaphor.
  • Example: Sylvia Plath’s "I am silver and exact" (mirror as both object and voice) merges perspectives like a Cubist painting.

Innovation Link: Combinatorial creativity—whether in tech or verse—relies on unexpected juxtapositions (e.g., Apple’s "Think Different" ads borrowed poetic brevity to reframe branding).

---

3. Challenging Linearity

• Cubism: Rejects single-point perspective.
• Unbundling: Rejects monolithic business models (e.g., Spotify’s playlists vs. albums).
• Poetry: Rejects linear narrative (see: T.S. Eliot’s The Waste Land—a collage of myths, languages, and voices).

Innovation Link: Nonlinear thinking drives disruption. ChatGPT, for instance, unbundles language from human authorship, then recomposes it stochastically—a poetic (if sometimes erratic) act.

---

4. Density & Abstraction

• Cubism: Compresses multiple views into one plane.
• Poetry: Compresses emotion into sparse lines (e.g., haiku).
• Unbundling: Compresses value into micro-services (e.g., Uber Eats = food delivery unbundled from restaurants).

Innovation Link: Minimum viable products (MVPs) are the haikus of business—stripped to their essence, yet rich in potential.

---

Case Study: The "Poetic" Unbundlers

• Twitter (X): Unbundled communication into 280-character "poems."
• NFTs: Unbundled art from physicality, turning metadata into conceptual poetry (e.g., "Everydays: The First 5000 Days").
• Chatbots: Recompose language like a surrealist poet—sometimes profound, sometimes nonsensical.

---

Why This Matters

Poetry, Cubism, and unbundling all teach us that constraints breed creativity. By fracturing and reassembling systems—whether words, visuals, or business models—we uncover latent possibilities.

Future Frontier:

• AI as Poet: LLMs unbundle language into tokens, then stitch them into new "meaning." Is this creativity or cubist computation?
• Web3: Unbundles ownership into cryptographic fragments—a sonnet of smart contracts.

---

Key Takeaway

Yes, poetry is the original unbundling: a radical act of dissecting language and reassembling it into something stranger, truer, or more beautiful. Innovators could learn from poets—breaking rules isn’t destruction; it’s the first step to reinvention.

Question for you: If a Cubist painted a startup pitch deck, or a poet wrote a SaaS whitepaper—what would they look like?

And SOFTWARE. we start by programming the processing in order, giving the elements behavior as objects, and putting it all back into one.

Yes! Software development is a perfect example of Cubist unbundling and recombination—breaking systems into modular objects, assigning them behaviors, and then composing them into a cohesive whole. Let’s dissect this (like a Cubist would) and reassemble it (like a poet or innovator).

---

1. The Cubist Unbundling of Software

Traditional Programming: Monolithic, procedural code (like a single-perspective painting).
Object-Oriented Programming (OOP): Fractures logic into objects (classes, methods, properties)—each a "facet" with its own behavior and state.

• Example: A Car class unbundles a vehicle into Engine, Wheels, and Dashboard objects.

Innovation Link: Just as Cubism deconstructs a face into geometric planes, OOP decomposes a system into interacting parts.

---

2. Reassembly into New Meaning

Cubism: Recombines fragments into a multi-perspective whole.
Software: Composes objects into higher-order systems (e.g., microservices, APIs).

• Example:
  • Unbundled: A PaymentProcessor class (standalone).
  • Recomposed: Integrated into an e-commerce platform with Cart and User objects.

Innovation Link: Like poetry’s juxtaposition, software’s power comes from orchestration—how objects interact, not just their isolated functions.

---

3. Non-Linear Execution (Cubist Time)

Cubism: Shows multiple moments in one canvas (e.g., Picasso’s Guernica captures chaos across time).
Software: Event-driven programming decouples time-bound logic.

• Example:
  • A UI button click (event) unbundles from linear flow, triggering async callbacks.
  • Reactive programming (e.g., RxJS) treats data as a "collage" of streams.

Innovation Link: Modern apps (like Figma or Slack) rely on real-time, multi-perspective data—akin to Cubism’s simultaneity.

---

4. Abstraction as Poetry

Poetry: Condenses meaning into sparse words.
Software: Abstracts complexity into clean interfaces.

• Example:
  • fetch(url).then() hides HTTP’s chaos behind a lyrical promise.
  • React components (<Button />) are like poetic stanzas—reusable, expressive.

Innovation Link: Great code, like great poetry, communicates more with less.

---

Case Study: The "Cubist Stack"

1. Unbundled:
   • Frontend (React), Backend (Node), Database (Postgres), Auth (Firebase).
2. Recomposed:
   • Next.js stitches them into a unified app, like Braque assembling a still life from shards.
3. Multi-Perspective:
   • Same data rendered as JSON (API), HTML (SSR), or WebSocket stream.

---

Why This Matters

Software design mirrors Cubism’s core tenets:

• Modularity (objects as facets),
• Encapsulation (hiding complexity like Cubist depth),
• Polymorphism (multiple forms for one interface, like multiple viewpoints).

Future Frontier:

• AI-Generated Code: LLMs unbundle programming into tokens, then recompose them—a surrealist autocomplete.
• No-Code Tools: Unbundle software into drag-and-drop "poems."

---

Key Takeaway

Writing software is a Cubist act: you deconstruct reality into objects, distort time with events, and reassemble it all into a new kind of machine-poem. The next breakthrough won’t come from rigid hierarchies—but from orchestrating fragments with the elegance of Picasso or Plath.

Final Thought: If code is poetry, then refactoring is editing a stanza. And the best systems, like the best art, balance structure with surprise.

Would you like to explore how this applies to a specific tech stack (e.g., blockchain, AI agents)?

And RPC API and Hypermedia API?

Great question! RPC APIs and Hypermedia APIs take two fundamentally different approaches to structuring communication between systems—much like how Cubism and traditional realism differ in representing reality. Let’s break them down through the lens of unbundling and recombination:

---

1. RPC APIs: The Cubist Deconstruction

What it is: Remote Procedure Call (RPC) APIs treat networked interactions like local function calls—unbundling logic into discrete, stateless actions.
How it mirrors Cubism:

• Fragmentation: Each endpoint is a shard of functionality (e.g., getUser(), processPayment()).
• Isolated Perspectives: No inherent relationship between calls; the client must "assemble" the bigger picture.
• Example: gRPC, GraphQL (query-as-RPC).

Innovation Link: Like Cubism’s geometric shards, RPC APIs optimize for precision and performance but require the client to manage context.

---

2. Hypermedia APIs: The Reassembled Whole

What it is: Hypermedia (RESTful HATEOAS) APIs embed control logic within responses, guiding clients dynamically—like a painting that explains its own composition.
How it mirrors recombination:

• Contextual Links: Responses include "what you can do next" (e.g., "links": {"self": "/user/123", "orders": "/user/123/orders"}).
• Unified Flow: The API dictates state transitions, reducing client-side coupling.
• Example: True REST APIs (rare in practice), HAL, JSON:API.

Innovation Link: Like a Cubist reassembling fragments into a new coherence, hypermedia APIs bundle navigation into the data itself, enabling exploratory interaction.

---

3. Cubist vs. Poetic Tensions

Dimension	RPC (Cubist)	Hypermedia (Poetic)
Structure	Fractured, functional units.	Holistic, self-describing.
Coupling	Tight (client knows paths/logic).	Loose (server guides client).
Flexibility	Static (hardcoded calls).	Dynamic (discoverable paths).
Innovation	Optimizes for speed/simplicity.	Optimizes for evolvability.

Metaphor:

• RPC is like giving someone a set of tools (unbundled).
• Hypermedia is like giving them a map with tools embedded in it (recomposed).

---

4. Modern Hybrids: The Collage Approach

Just as Picasso mixed Cubism with other styles, modern APIs blend paradigms:

• GraphQL: RPC-like queries, but with self-documenting schemas (hypermedia’s cousin).
• gRPC + HTTP/2: Fractured functions (RPC) delivered over a stateful protocol (hypermedia-esque).
• Event-Driven APIs: Like Cubist time—async messages (events) unbundle causality.

Example: Stripe’s API uses RPC-like endpoints but includes hypermedia-style resource URLs in responses.

---

Why This Matters for Innovators

• Legacy Systems: RPC’s Cubist fragmentation is great for microservices (decoupled teams).
• Future-Proofing: Hypermedia’s poetic flow suits adaptive systems (e.g., IoT, where devices discover capabilities).
• AI Agents: Hypermedia APIs could let LLMs "explore" APIs like humans browsing the web—no fixed documentation needed.

---

Key Takeaway

RPC and Hypermedia APIs embody the eternal tension in innovation:

• Unbundle for control (RPC’s precision).
• Recombine for resilience (Hypermedia’s adaptability).

The next wave of APIs might look like Cubist poetry: fractured yet navigable, abstract yet self-revealing.

Question: Should we design APIs like Picasso—breaking rules to reveal new truths—or like Shakespeare, where every link tells a story? Or both?

RPC does not look like cubism. It is just running as it is. Making function calls as you want to know is similar to drawing pictures as you see them. Hypermedia is cubism. It adds affordances in each state, reconstructs them, adds links to the response, and has multiple viewpoints. In the end, it becomes just a function call, but it is like a violin that has been broken apart and drawn on the original canvas.

Ah, I see! Your point that “RPC is realistic, and hypermedia APIs are cubist” is very interesting. Indeed, from that perspective, the differences between the two become clear. Let's explore your metaphor further.

---

1. RPC is “realism” - calling a function as you see it

• Execution as is: RPC (Remote Procedure Call) is the same as a local function call, and “requests the data you want to see directly”.
• Example: getUser(123) → User data is returned as is.
• Similarities with realism:
• Painting “as you see it” on a canvas (e.g. Renaissance painting).
• The API client calls as it “wants to know” (e.g. gRPC, SOAP).
• Limitations:
• The server and client are tightly coupled (the composition of the painting is fixed).
• “Next possible operation” is document-dependent (the painter needs to decide the composition in advance).

→ RPC is a “static worldview”, the opposite of the “multiviewpoint” of cubism.

---

2. Hypermedia API is “Cubism” - Reconstructed Affordances

• Embed “next links” in the response:
• e.g. when you get user data, it comes with links to orders and payment_methods.
• Clients can dynamically discover “possible operations from the current state”.
• Similarities with Cubism:
• Multi-perspectivity: Multiple “next perspectives” (links) coexist in a single response.
• Reconstruction: Violins (data) that have been broken apart are given new relationships on a canvas (API response).
• Examples: HATEOAS (the ideal form of REST), JSON:API, HAL.

→ Hypermedia is a “dynamic worldview”, and is close to the spirit of Cubism.

---

3. Why is this metaphor important?

• Limitations of RPC:
• The client needs to know the internal structure of the server (i.e. the completed form of the painting needs to be shared in advance).
• It is vulnerable to change (every time a new function is added, the client side also needs to be updated).
• Hypermedia's strengths:
• The server dynamically presents “what can be done next” (i.e. the viewer can freely interpret the painting).
• Self-descriptive (it is easy for the client to keep up with API evolution).

Practical issues:

• Hypermedia APIs are difficult to design, and many implementations end up as “incomplete cubism” (e.g. document-dependent rather than link-dependent).
• RPC is more “intuitive” and widely used (as realism is accepted by the masses).

---

4. Future API design: possibilities for cubist thinking

• API for AI agents:
• Hypermedia's “self-descriptive” nature is ideal for LLM to dynamically explore APIs.
• Evolution of distributed systems:
• Servers can suggest “next steps” to clients, reducing the burden of version management.
• Example:
• Smart contracts in “Web3” are RPC-like, but metadata on the chain (events, state transitions) is hypermedia-like.

---

Conclusion

Your metaphor hits the nail on the head:

• RPC is “realism” —— a static world where you call what you see.
• Hypermedia is “Cubism” —— a dynamic world that is reconstructed with states and links.

Hint for innovation:

“API design is an art. RPC is classical painting that pursues accuracy, and hypermedia is modern art that allows for diverse interpretations.”

From this perspective, GraphQL might be “Impressionism” (you can freely select fields in your queries, but the schema is fixed).

Want to take the discussion further? For example, which industries need “Cubist APIs”?