Politics of Power

With a growing number of networked and autonomous objects as well as the outbreak of fields such as « the IoT », communication protocols used by connected products are increasingly important as they act as the network’s backbone.
Since the end product is « black-boxed » to the user, we often assume that all nodes of a network are equal.

But is it?

For example, in a home, two appliances in the same network must be working at the same time, but because of a power shortage, they cannot run in parallel. This bring us to question, who should be given the priority and why?

In every existing network – be it machine or nature, rules are established in order to determine its structure, hierarchy, and the way the communication will be synchronized between all the actors of the network. But who and what criterions will define this power hierarchy? Products and networks are inherently embedded with ideologies of the designers, engineers, and other stakeholders who shape their trajectory along the way.

“Politics of Power” is an exploration of these questions on a micro-scale by using a simple ubiquitous product, the multi-plug.

The project looks at how a mass-manufactured product – although developed for a precise and unique purpose – could behave differently depending on the nature of its communication protocol and how the design of the product itself could reflect these hidden logic and rules.

Three multi-plugs – Model D, M and T – are designed to look and behave based on different ideologies and structures, allowing people to experience the hidden politics of networks in an everyday life products through an electrical system.

model D - Egalitarian
Elected
Balanced

# Constitution
# for Egalitarian arch.

# --- Election Routine ---
# Define which plug has the
# highest power

Elections:

# When are the next elections?
In_Charge_Time = Random(X_MINUTES)

# Each plugs vote for the president
for 1 to N_PLUGS:

vote = Random(1,N_PLUGS)

In_Charge = Plug with Highest vote
In_Charge_Corruption++

# The plug on left and right of the
# president become party
Right_Party = In_Charge + 1
Left_Party = In_Charge - 1
Citizens = Remaining Plugs

# --- Attribute Power Levels ---
# What amount of power each plug
# should have

Attribute_Power_Levels:

for 1 to N_PLUGS:

if In_Charge:

In_Charge = HIGHEST_POWER_LEVEL

else if Party:

Party = MIDDLE_POWER_LEVEL

else if Citizens:

Citizens = LOW_POWER_LEVEL

# --- Egalitarian Setup ---
Egalitarian_Constitution:

Elections()
Attribute_Level_Power()

# --- Reelection Routine ---
# Reelect a plug that is
# in charge

Reelections:

if Current_Time >= Presidency Time:

Elections()
if President Corruption > 3:

HIGHEST_POWER_LEVEL++
MIDDLE_POWER_LEVEL--
LOW_POWER_LEVEL--

else:

President Corruption = 0

Attribute_Power_Level()

# --- In_Charge Unplugged ---
# Delegate when the In_charge
# is unplugged

In_Charge_Unplugged:

# The new In_Charge is either
# the left or right party
In_Charge = Random(Left, Right)

if In_Charge == Right:

Right_Party = In_Charge+1
# Left party stays the same

else if In_Charge == Left

Left_Party = In_Charge-1
#Right party stays the same

Attribute_Power_Level()

# --- Party Unplugged ---
# Delegate when one Party
# is unplugged

Party_Unplugged:

# If right party unplugged
# then the plug on its right
# is becoming right party...
# Same for left party
if Party_Unplugged == Right:

Right_Party = Right_Party + 1

else if Party_Unplugged == Left:

Left_Party = Left_Party - 1

Attribute_Power_Level()

# --- Citizen Unplugged ---
# Delegate when one Citizen
# is unplugged

Citizen_Unplugged:

# If a citizen is unplugged
# then nothing happen
if Plugged_Citizen == 0:

# The egalitarian is destroyed
# as no citizen are remaining
# The government become citizens..
Citizen = Party
Citizen = In_Charge

Attribute_Power_Level()
Model M - Pyramidal
Corporate
Hierarchical

# Constitution
# for Pyramidal arch.

# --- Establish Pyramidal ---
# Define which plug has the
# highest power

Assign_Hierarchical_Power:

Top_Pyramid = HIGHEST_POWER_LEVEL
Middle_Pyramid = MIDDLE_POWER_LEVEL
Bottom_Pyramid = LOWEST_POWER_LEVEL

Top_Lifespan = Random(X_MINUTES)

# --- Pyramidal Setup ---
Pyramidal_Constitution:

Assign_Hierarchical_Power()

# --- Pyramidal Refresh ---
Refresh_Pyramidal:

Top_Pyramid = NO_POWER_LEVEL
Middle_Pyramid = HIGHEST_POWER_LEVEL
Bottom_Pyramid = LOWEST_POWER_LEVEL

if Current_Time >= Mourning_Time:

Assign_Hierarchical_Power()

Assign_Hierarchical_Power()

# --- Top Unplugged ---
# Delegate when the top is unplugged
Top_Unplugged:

# The top is more of an icon
# no big power changes if he isn't here
Middle_Pyramid = HIGHEST_POWER_LEVEL
Bottom_Pyramid = LOWEST_POWER_LEVEL

# --- Middle Unplugged ---
# Delegate when one plug in middle is
# unplugged
Middle_Unplugged:

# If all middle plugs are out
# then the bottom level is in chaos
if Middle_Pyramid == 0:

Bottom_Pyramid = UNSTABLE_POWER_LEVEL

# --- Bottom Unplugged ---
# Delegate when one plug in bottom is
# unplugged
Bottom_Unplugged:

# Plebs, nothing happen
NULL
Model T - Uneven
Decisive
Repressive

# Constitution
# for Uneven arch.

# --- Define Tyran Power ---
# Define the power relation
# of the authoritarian ideology

Set_Tyran_Behaviour:

# Benevolent or not tyran?
Is_Benevolant = Random(1,2)

if Is_Benevolent:

Citizens = VERY_LOW_POWER_LEVEL
Tyran = HIGHEST_POWER_LEVEL
# Citizen take longer to rebel
# if the tyran is benevolent
Rebellion_Time = Random(X_MINUTES*2)

else:

Citizen = NO_POWER_LEVEL
Tyran = HIGHEST_POWER_LEVEL
Rebellion_Time = Random(X_MINUTES)

# --- Authoritarian Setup ---
Authoritarian_Constitution:

Set_Tyran_Behaviour()

# --- Define the rebellion ---
# Define the power behaviour
# once citizens rebel against the tyran
Rebellion:

if Current_Time >= Rebellion_Time:

Tyran = MIDDLE_POWER_LEVEL
# Unstable means the power fluctuate
# between HIGH / LOW
Citizen = UNSTABLE_POWER_LEVEL
Rebellion_Lifespan = Random(X_MINUTES)

# Stop the rebellion after a certain
# time. The tyran goes back to power
if Current_Time >= Rebellion_Lifespan:

Set_Tyran_Behaviour()

# --- Tyran Unplugged ---
# Delegate when the tyran is unplugged
Tyran_Unplugged:

# NO ORDER = CHAOS
Citizen = UNSTABLE_POWER_LEVEL

# Chaotic times...
Time_Chaos = Random(X_MINUTES)

# --- Citizens Unplugged ---
# Delegate when a citizen is unplugged
Citizen_Unplugged:

# Nothing happens, citizens are
# worthless
NULL

# --- Egalitarian emerges ---
# If tyran isn't plugged for a certain
# amount of time, egalitarian emerges from
# chaos
Birth_Of_Egalitarian:

if Current_Time >= Time_Chaos:

destroy(Authoritarian_Constitution()) Egalitarian_Constitution()

# --- Egalitarian Destroyed ---
# If tyran is plugged back when egalitarian
# then it destroys it
Death_Of_Egalitarian:

destroy(Egalitarian_Constitution()) Authoritarian_Constitution()