Ecosystem

Ecosystem#

+ Expand

What makes for a suitable problem for AI (Demis Hassabis, Nobel Lecture)?

Space: Massive combinatorial search space

Function: Clear objective function (metric) to optimize against

Time: Either lots of data and/or an accurate and efficient simulator

Guess what else fits the bill (Yours truly, amateur philosopher)?

Space

Intestines/villi

Lungs/bronchioles

Capillary trees

Network of lymphatics

Dendrites in neurons

Tree branches

Function

Energy

Aerobic respiration

Delivery to "last mile" (minimize distance)

Response time (minimize)

Information

Exposure to sunlight for photosynthesis

Time

Nourishment

Gaseous exchange

Oxygen & Nutrients (Carbon dioxide & "Waste")

Surveillance for antigens

Coherence of functions

Water and nutrients from soil

-- Nobel Prize in Chemistry, 2024

Ukubona struts onto the stage draped in poetic grandeur, a philosophy masquerading as a company, all about “seeing” with a capital S—layered gazes, mythic resonance, and a theology of visibility. Oh, please. 🙄 It’s a fantasy so drenched in self-important metaphors—seas, ships, screwdrivers, sharks, and scissors—that it forgets the raw truth:

Truth. A tree only needs select nutrients from the earth. Filter. From roots, trunk, branches, these elements are filtered toward their destintion in the leaves. Illusion. Here water, minerals, nitrates, and carbondioxide are directed to the "last mile" for photosynesis and other synthetic processes

nothing matters until resources are yanked out of the ground, figured out, and shoved into the hands of those who need them. Resources aren’t born; they’re made. Some clever fork has to spot the potential, wrestle with the risks, and teleologically grok their value before they’re worth a damn. Ukubona’s dreamy architecture, with its oceanic servers and curated platforms, acts like the hard part’s already done—like the world’s just waiting for its pretty Kaplan-Meier curves to save the day. Nah, fam. That’s a fairy tale. 😴 Resources come first, and distribution only makes sense after the sweaty, bloody work of extraction. To swoon over Ukubona’s distributive vibes without clocking that? Pure delusion.

Let’s strip this down. Ukubona’s “sea”—those humming servers full of renal patients’ data, donor stats, and medical trade-offs—sounds deep and profound, right? 🌊 Sure, until you realize it’s just a fancy pool of already-extracted info. Someone else took the risks—miners digging up rare earths for those servers, doctors collecting diagnoses, patients signing consent forms in dingy clinics. Ukubona didn’t make that sea; it’s sipping from it like a hipster at a craft coffee bar. ☕ The real game happened upstream, where forks (you know, us humans with grit) decided what’s valuable—silicon, blood samples, bandwidth—and hauled it into existence. To fetishize the “visibility” of that data without bowing to the extraction hustle is like praising a chef but ignoring the farmer who grew the damn potatoes. 😂

Truth (Input) Resources
Filter (Hidden) Extracted
Illusion (Output) Undistributed
— Steve Bannon

Europeans dominating North America, colonialists tearing through Africa—it’s the same deal. They saw gold, timber, bodies, and took ‘em. Distributive philosophies only popped up after the fact, when the loot was already in hand. Ukubona’s acting like it invented the wheel, but it’s just spinning on someone else’s axle.

https://abikesa.github.io/github/_images/antiquarian.jpeg — Fig. 4 Karugire’s Magnus Opus#

Then there’s the “ship”—Ukubona’s platform, all coded and curated with JavaScript sails and Cox regression rigging. 🛳️ It’s cute how it floats above the chaos, turning messy clinical data into neat little curves for patients to “choose knowingly.” But let’s not kid ourselves: that ship’s a luxury liner, not a fishing boat. It’s not out there catching the raw stuff—resources like lithium for chips or datasets from underfunded hospitals. Nope, it’s coasting on what’s already been netted by tougher hands. The politics of care? The right to see trade-offs? Lovely sentiments, but they’re downstream from the real action. Resources-extraction-distribution says you don’t get to navel-gaze about survival curves until someone’s risked their neck to mine the cobalt or log the patient’s GFR. Ukubona’s doctrine of clarity is a second-act play—it’s meaningless without the first act of getting the goods. 🤷‍♂️

And don’t get me started on the “pirates” and “screwdrivers.” 🏴‍☠️🔧 Ukubona paints this epic battle where institutions hijack intent, and its humble screwdriver—ooh, so unromantic!—fights back with maintenance and repair. Spare me. The real pirates aren’t some shadowy data-obscurers; they’re the ones who control the mines, the supply chains, the patents. The screwdriver’s a toy when the game’s about who owns the quarry. Resources aren’t about tweaking curves—they’re about who’s got the muscle to extract and move ‘em. Ukubona’s fiddling with deck chairs while the Titanic’s already hit the iceberg of reality: distribution’s a pipe dream without extraction’s heavy lifting. 😅

Show code cell source Hide code cell source

import numpy as np
import matplotlib.pyplot as plt
import networkx as nx

# Define the neural network layers
def define_layers():
    return {
        'Tragedy (Pattern Recognition)': ['Cosmology', 'Geology', 'Biology', 'Ecology', "Symbiotology", 'Teleology'],
        'History (Resources)': ['Resources'],  
        'Epic (Negotiated Identity)': ['Faustian Bargain', 'Islamic Finance'],  
        'Drama (Self vs. Non-Self)': ['Darabah', 'Sharakah', 'Takaful'],  
        "Comedy (Resolution)": ['Cacophony', 'Outside', 'Ukhuwah', 'Inside', 'Symphony']  
    }

# Assign colors to nodes
def assign_colors():
    color_map = {
        'yellow': ['Resources'],  
        'paleturquoise': ['Teleology', 'Islamic Finance', 'Takaful', 'Symphony'],  
        'lightgreen': ["Symbiotology", 'Sharakah', 'Outside', 'Inside', 'Ukhuwah'],  
        'lightsalmon': ['Biology', 'Ecology', 'Faustian Bargain', 'Darabah', 'Cacophony'],
    }
    return {node: color for color, nodes in color_map.items() for node in nodes}

# Define edges
def define_edges():
    return [
        ('Cosmology', 'Resources'),
        ('Geology', 'Resources'),
        ('Biology', 'Resources'),
        ('Ecology', 'Resources'),
        ("Symbiotology", 'Resources'),
        ('Teleology', 'Resources'),
        ('Resources', 'Faustian Bargain'),
        ('Resources', 'Islamic Finance'),
        ('Faustian Bargain', 'Darabah'),
        ('Faustian Bargain', 'Sharakah'),
        ('Faustian Bargain', 'Takaful'),
        ('Islamic Finance', 'Darabah'),
        ('Islamic Finance', 'Sharakah'),
        ('Islamic Finance', 'Takaful'),
        ('Darabah', 'Cacophony'),
        ('Darabah', 'Outside'),
        ('Darabah', 'Ukhuwah'),
        ('Darabah', 'Inside'),
        ('Darabah', 'Symphony'),
        ('Sharakah', 'Cacophony'),
        ('Sharakah', 'Outside'),
        ('Sharakah', 'Ukhuwah'),
        ('Sharakah', 'Inside'),
        ('Sharakah', 'Symphony'),
        ('Takaful', 'Cacophony'),
        ('Takaful', 'Outside'),
        ('Takaful', 'Ukhuwah'),
        ('Takaful', 'Inside'),
        ('Takaful', 'Symphony')
    ]

# Define black edges (1 → 7 → 9 → 11 → [13-17])
black_edges = [
    (4, 7), (7, 9), (9, 11), (11, 13), (11, 14), (11, 15), (11, 16), (11, 17)
]

# Calculate node positions
def calculate_positions(layer, x_offset):
    y_positions = np.linspace(-len(layer) / 2, len(layer) / 2, len(layer))
    return [(x_offset, y) for y in y_positions]

# Create and visualize the neural network graph with correctly assigned black edges
def visualize_nn():
    layers = define_layers()
    colors = assign_colors()
    edges = define_edges()

    G = nx.DiGraph()
    pos = {}
    node_colors = []

    # Create mapping from original node names to numbered labels
    mapping = {}
    counter = 1
    for layer in layers.values():
        for node in layer:
            mapping[node] = f"{counter}. {node}"
            counter += 1

    # Add nodes with new numbered labels and assign positions
    for i, (layer_name, nodes) in enumerate(layers.items()):
        positions = calculate_positions(nodes, x_offset=i * 2)
        for node, position in zip(nodes, positions):
            new_node = mapping[node]
            G.add_node(new_node, layer=layer_name)
            pos[new_node] = position
            node_colors.append(colors.get(node, 'lightgray'))

    # Add edges with updated node labels
    edge_colors = {}
    for source, target in edges:
        if source in mapping and target in mapping:
            new_source = mapping[source]
            new_target = mapping[target]
            G.add_edge(new_source, new_target)
            edge_colors[(new_source, new_target)] = 'lightgrey'

    # Define and add black edges manually with correct node names
    numbered_nodes = list(mapping.values())
    black_edge_list = [
        (numbered_nodes[3], numbered_nodes[6]),  # 4 -> 7
        (numbered_nodes[6], numbered_nodes[8]),  # 7 -> 9
        (numbered_nodes[8], numbered_nodes[10]), # 9 -> 11
        (numbered_nodes[10], numbered_nodes[12]), # 11 -> 13
        (numbered_nodes[10], numbered_nodes[13]), # 11 -> 14
        (numbered_nodes[10], numbered_nodes[14]), # 11 -> 15
        (numbered_nodes[10], numbered_nodes[15]), # 11 -> 16
        (numbered_nodes[10], numbered_nodes[16])  # 11 -> 17
    ]

    for src, tgt in black_edge_list:
        G.add_edge(src, tgt)
        edge_colors[(src, tgt)] = 'black'

    # Draw the graph
    plt.figure(figsize=(12, 8))
    nx.draw(
        G, pos, with_labels=True, node_color=node_colors, 
        edge_color=[edge_colors.get(edge, 'lightgrey') for edge in G.edges],
        node_size=3000, font_size=9, connectionstyle="arc3,rad=0.2"
    )
    
    plt.title("Self-Similar Micro-Decisions", fontsize=18)
    plt.show()

# Run the visualization
visualize_nn()

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[1], line 3
      1 import numpy as np
      2 import matplotlib.pyplot as plt
----> 3 import networkx as nx
      5 # Define the neural network layers
      6 def define_layers():

ModuleNotFoundError: No module named 'networkx'

Fig. 5 View code or view image.#

The “shark” of algorithmic bias and the “scissors” of personalization? More fluff. 🦈✂️ Sure, it’s noble to trim models to fit real bodies, to snip away irrelevance. But who’s feeding the beast? The data’s still coming from somewhere—someone’s risked capital, time, or lives to pull it out of the ether. Ukubona’s life-raft for the weary? A sweet gesture, but it’s floating on a sea of pre-extracted stuff—public trust, clinical honesty, federal access. That’s not a gift; it’s a privilege built on others’ labor. Resources-extraction-distribution cuts through the noise: value starts with discovery and risk, not with pretty visualizations. Ukubona’s island of “understood uncertainty” is a postcard from a vacation spot—it’s nice, but someone else built the damn resort. 🏝️

Here’s the kicker: Ukubona’s whole vibe—its protest against opaque systems, its moral feedback loops—assumes the resources are just there, ready to be looped back to humans. Nope. They’re not. Someone’s gotta find ‘em, claim ‘em, and ship ‘em. History’s brutal on this: colonial powers didn’t “see” risk in some poetic sense—they saw profit, took it, and dealt with the fallout later. Ukubona’s fantasy of visibility skips the part where value’s forged in the crucible of extraction. It’s all metaphors and no muscle. Resources-extraction-distribution isn’t sexy like a ship battling sharks, but it’s real. You don’t get to “see” until you’ve dug, fought, and delivered. Ukubona’s a mirage—lovely, layered, and ultimately irrelevant next to the hard truth of who gets the goods and how they got ‘em. 💪🌍