Skip to content

Over the Rainbow: Of Laughter, Love, and Life in Antipolo

Updated: at 04:23 AM

As dawn breaks and the first sunrays touch the vibrant cityscape of Antipolo, I, Mark, a 32-year-old freelance software engineer, father, partner, and dreamer, awake to the ballet of life. Some days, life unfolds just as erratically as the tides of traffic along Marcos Highway. Still, the rhythmic predictability provides comfort and a melody to my life’s background score.

My fingers dance across the keyboard, crafting virtual worlds enshrined within lines of intricate code. Yet, the true symphony of my existence resounds through the rooms of our humble abode, orchestrated by the laughter of my children - Argi Denise, a thoughtful, brilliant 11-year-old, and playful Desmond, 6, whose energies transcend the limitations of age.

Engulfed in the laughter-echoed halls, time almost stands still, as if the hovering notes of Kamakawiwoʻole’s beautifully stitched medley ‘Over the Rainbow/What a Wonderful World’ were frozen in mid-air.

The complete embodiment of wonder is found not in grandeur but in the simplest moments – the joyful cacophony of Desmond chasing after Argi in the park, the perpetual dance of shadows and light on the Mango trees surrounding us as the sun takes its nightly bow, and the embrace of Arlene’s comforting hand, stirring a sense of rootedness amidst the winds of change. Life here in Antipolo, far from perfection, is a testament to resilience, the power of dreams, and the romantic dance between struggle and hope painted by Israel’s song.

As volatile and unpredictable as life can be, there is power and beauty in its constancy. The somnolent lull succeeding the lively hunts of the day brings a quiet symphony, the unvoiced whispers of the city. I see a silent canvas – painted with dreams of a farther horizon, the longed-for tomorrow. This city, my home, living its narrative, is a silent actor in the tale of our lives, shaping us with an indelible mark each day.

Antipolo – with its pulsating heart, warmed by the tropical sun, teeming with kindred souls – is more than just a city. It’s an anchor, tethering me to my roots under the shadow of the grand Cathedral, shaping my identity, and fostering a place of belonging. The same streets that nurture Desmond’s laughter, the markets enriching our daily table, and the very air we breathe each form a paragraph in the story of our existence.

Joy, hope, and dreams adorn the landscape, as do struggles, fears, and unfulfilled yearnings. As I look at the starlit sky over Antipolo, Desmond’s laughter syncopating with Argi’s poetic musing, the narrative of Kamakawiwo’ole’s song echoes through my heart. It’s a tuneful recognition of life’s dazzling moments interwoven with its somber shades of grey – much like the city enveloping us, much like life itself, each poignant note reverberating, whispering our collective affirmation, “Yes. What a wonderful world it is.”

Ultimately, the symphony of laughter and tears, triumphs and tribulations, dreams realized and unfulfilled tell our story. And through the chapters, across the verses, the city of Antipolo remains our silent companion, reflecting the universal harmonies of life’s ever-changing song.

import random
import pickle
from abc import ABC, abstractmethod
import matplotlib.pyplot as plt
from typing import Dict, List, Union

# Constants

class EmotionModel:
    Class EmotionModel simulates the emotional model of a being with certain attributes, feelings, and desires.

    def clamp_emotion(intensity: float) -> float:
        Clamp the emotion intensity between the minimum and maximum values.
        return max(MIN_EMOTION_INTENSITY, min(MAX_EMOTION_INTENSITY, intensity))

    def __init__(self, resilience: int = 2, sensitivity: int = 1, optimism: int = 3):
        self.attributes = {"resilience": resilience, "sensitivity": sensitivity, "optimism": optimism}
        self.feelings_over_time = self.init_over_time(self.feelings)
        self.desires_over_time = self.init_over_time(self.desires)

    def init_feelings_and_desires(self):
        Initializes feelings and desires to initial random values.
        feelings_keys = ["doubt", "fear", "rejection", "joy", "excitement", "sadness", "anger", "irritation", "stress", "calm", "love", "loneliness", "concern", "pride", "disappointment", "surprise", "disgust", "anticipation", "trust", "envy", "guilt"]
        desires_keys = ["acceptance", "belonging", "recognition", "achievement"]
        self.feelings = {key: random.uniform(5, 15) for key in feelings_keys}
        self.desires = {key: random.uniform(5, 15) for key in desires_keys}

    def init_over_time(self, indicator: Dict[str, float]) -> Dict[str, List[float]]:
        Initialize the time series result of an indicator with its initial value.
        return {key: [value] for key, value in indicator.items()}

    def calc_delta_and_update(self, indicators: Dict[str, float], attr_mod: int, over_time: Dict[str, List[float]]):
        Calculates new values for each indicator, updates their current state, and stores the outcome to their time series.
        delta = random.gauss(0, attr_mod)
        noise = random.uniform(-1, 1)
        for key, intensity in indicators.items():
            indicators[key] = EmotionModel.clamp_emotion(intensity + delta + noise)

    def feel(self, time: int):
        Simulates feelings and their change over time.
        attr_mod = self.attributes["resilience"] if self.feelings["fear"] < 5 else self.attributes["sensitivity"]
        self.calc_delta_and_update(self.feelings, attr_mod, self.feelings_over_time)

        if 6 <= time < 18:  # Daytime adjustment
            self.feelings["excitement"] += 0.1
            self.feelings["sadness"] -= 0.1
        else:  # Nighttime adjustment
            self.feelings["excitement"] -= 0.1
            self.feelings["sadness"] += 0.1

    def apply_feeling_effect(self, feeling_effect: Dict[str, float]):
        Changes feelings according to a particular feeling_effect.
        for feeling, effect in feeling_effect.items():
            self.feelings[feeling] = EmotionModel.clamp_emotion(self.feelings[feeling] + effect)

    def desire(self):
        Simulates desires and their change over time.
        attr_mod = self.attributes["optimism"] if self.desires["acceptance"] < 5 else -self.attributes["resilience"]
        self.calc_delta_and_update(self.desires, attr_mod, self.desires_over_time)

    def major_event(self):
        Simulates a major event where one negative and one positive feeling are affected.
        negative_feelings = ["doubt", "fear", "rejection", "sadness", "anger"]
        positive_feelings = ["joy", "excitement"]
        negative_feeling = random.choice(negative_feelings)
        positive_feeling = random.choice(positive_feelings)
        self.feelings[negative_feeling] = EmotionModel.clamp_emotion(self.feelings[negative_feeling] + random.uniform(0, 2))
        self.feelings[positive_feeling] = EmotionModel.clamp_emotion(self.feelings[positive_feeling] - random.uniform(0, 2))

    def update_feelings(self, emotion_changes: Dict[str, float]):
        Updates feelings according to some changes (common in interactions with other people).
        for emotion, change in emotion_changes.items():
            self.feelings[emotion] = EmotionModel.clamp_emotion(self.feelings[emotion] + change)

class Human:
    A simple class to encapsulate common attributes and behaviors of Child and Partner classes.

    def __init__(self, name: str): = name
        self.emotion_model = EmotionModel()

    def __str__(self):
        return f'{self.__class__.__name__}(name={})'

    def random_event(self, emotions: List[str]):
        A random event that changes certain feelings a Human has.
        emotion_changes = {emotion: random.uniform(-1, 1) for emotion in emotions}

class Child(Human):
    Child, a type of Human, with a simple method to simulate a random event.

    def __init__(self, name: str, age: int):
        self.age = age

class Partner(Human):
    Partner, a type of Human, with a simple method to simulate a random event.
    Also keeps track of availability with a boolean out_of_town.

    def __init__(self, name: str):
        self.out_of_town = False

class Behavior(ABC):
    Abstract class Behavior offers a structure on how a certain behavior must be implemented.

    def act(self, identity, society):

class ConformingBehavior(Behavior):
    Type of Behavior where the individual does not change identity and hence conforms to the society.

    def act(self, identity: List[str], society: 'Society') -> List[str]:
        return identity

class RebelliousBehavior(Behavior):
    Type of Behavior where the individual does not conform to the society and changes their identity.

    def act(self, identity: List[str], society: 'Society') -> List[str]:
        non_conforming_aspects = ['vibrant colors', 'tender laughter of children', 'single strokes of defiance', 'subtle rebellion with partner', 'introspective growth']
        identity += non_conforming_aspects
        identity = [aspect for aspect in identity if aspect not in society.expectations]
        return identity

class Society:
    Society class represents society's expectations on the Individual.

    def __init__(self):
        self.expectations = ['faithful son', 'devoted partner', 'father of two', 'mechanical existence', 'suppressing individuality']

class Individual:
    An Individual with a certain identity and behavior.

    def __init__(self, identity: List[str], behavior: 'Behavior'):
        self.identity = identity
        self.behavior = behavior

    def modify_behavior(self, new_behavior: 'Behavior'):
        Change the behavior of an individual.
        self.behavior = new_behavior

    def act(self, society: 'Society'):
        An individual acts (either conforming or rebelling, depending on behavior type) and changes the identity accordingly.
        if set(self.identity).issubset(set(society.expectations)):
            print("\nConforming to societal norms. Starting resistance...\n")
        self.identity = self.behavior.act(self.identity, society)
        print("Identity Updated: ", self.identity)
        if not isinstance(self.behavior, ConformingBehavior):
            print("\nSuccessfully resisted conformity and dismantled the oppressive bricks of societal norms.")
            print("Final Identity revealed: ", self.identity)

class Activity:
    Activity encapsulates a certain activity happening in a day, with starting and ending times.

    def __init__(self, name: str, start_time: int, end_time: int, feeling_effect: Dict[str, float] = None): = name
        self.start_time = start_time
        self.end_time = end_time
        self.feeling_effect = feeling_effect

    def duration(self) -> int:
        Calculate the duration of the activity.
        return self.end_time - self.start_time

class Weather:
    Weather class represents the daily weather and its effect on the Individual.

    def __init__(self, weather_type: str):
        self.weather_type = weather_type

    def get_weather_effect(self) -> Dict[str, float]:
        Return a dict representing the change in feelings due to the weather effect.
        weather_effects = {
            'sunny': {'joy': 0.2, 'sadness': -0.2},
            'rainy': {'joy': -0.2, 'sadness': 0.2},
            'hot': {'irritation': 0.3, 'joy': -0.1},
            'cloudy': {'joy': -0.1, 'sadness': 0.1},
        return weather_effects.get(self.weather_type, {})

class Self:
    Self represents the feelings of the user of the system. It includes relationships with partner and children.

    def __init__(self):
        self.emotion_model = EmotionModel()
        self.children = [Child("Desmond", 6), Child("Argi", 11)]
        self.partner = Partner("Arlene")

    def child_events(self):
        Simulate events involving children, update their feelings, and affect the user's feelings.
        for child in self.children:
            child.random_event(['joy', 'sadness', 'anger'])
        # Assuming having children makes you feel loved but a bit lonely
        self.emotion_model.feelings["love"] += 0.1
        self.emotion_model.feelings["loneliness"] += 0.1

    def partner_event(self):
        Simulate events involving the partner, update their feelings, and affect the user's feelings.
        self.partner.random_event(['joy', 'concern', 'anger'])
        # Assuming being with the partner makes you feel loved but less lonely
        if not self.partner.out_of_town:
            self.emotion_model.feelings["love"] += 0.1
            self.emotion_model.feelings["loneliness"] -= 0.1

class DayInLife:
    DayInLife represents a day in life simulation.

    def __init__(self, name: str, available_hours=DAY_HOURS, weather=None): = name
        self.activities = []
        self.available_hours = available_hours
        self.self = Self()
        self.society = Society()
        self.individual = Individual(['faithful son', 'devoted partner', 'father of two'], ConformingBehavior()) = weather

    def add_activity(self, activity: 'Activity'):
        Check if an activity fits into the day schedule. If yes, add it to activities.
        if self.available_hours - activity.duration() < 0:
            raise ValueError("Not enough time available for this activity.")
            self.available_hours -= activity.duration()

    def adjust_schedule(self, activity_name: str, start_time: int, end_time: int) -> str:
        Allow changing the schedule of the day, updating timings of a certain activity.
        for activity in self.activities:
            if == activity_name:
                self.available_hours += activity.duration()
                activity.start_time = start_time
                activity.end_time = end_time
                self.available_hours -= activity.duration()
                return f"The schedule for {}'s day was updated."
        raise ValueError(f"Activity {activity_name} does not exist.")

    def brief_day(self) -> str:
        Provide a brief summary of time spent in each activity.
        return f"In a typical day, {} spends {self.activities[0].duration()} hours with family, {self.activities[1].duration()} hours working, {self.activities[2].duration()} hours reflecting, and {self.activities[3].duration()} hours dreaming."

    def resist_conformity(self):
        Visualize human emotions, apply the weather effect, and other events (either normal or major)
        throughout the 24 hours of a day.
        for i in range(DAY_HOURS):  # Simulating the day
            # major events occurring at hours divisible by 4 (0, 4, 8, 12....)
            if i % 4 == 0:
            else:  # normal event on other hours
            # Apply the weather effect
            # Apply the effect of all activities happening at the current hour
            for activity in self.activities:
                if activity.start_time <= i < activity.end_time and activity.feeling_effect:

    def summary(self) -> str:
        A summary of the day's events, feelings, and available time.
        feelings_summary = ", ".join(f"{feeling}: {round(level[-1], 1)}" for feeling, level in self.self.emotion_model.feelings_over_time.items())
        return f"Summary of {}'s day:\nAvailable Hours: {self.available_hours}\nFinal Feelings: {feelings_summary}"

# Simulation
class Simulation:
    Simulation class enables simulating emotions and behavior of many individuals in parallel.

    def __init__(self, individuals: List[DayInLife]):
        self.individuals = individuals

    def run(self):
        Run the simulation for all individuals.
        for individual in self.individuals:

if __name__ == "__main__":
    # Activities
    family_time = Activity('Family Time', 0, 6, {'joy': 0.1, 'sadness': -0.1})
    work_time = Activity('Work Time', 6, 14, {'stress': 0.3})
    reflection_time = Activity('Self-Reflection Time', 14, 16, {'calm': 0.2, 'anger': -0.2})
    play_with_son = Activity("Play with Desmond", 16, 18, {'joy': 1})
    study_with_daughter = Activity("Study with Argi", 18, 20, {'pride': 2})
    dinner_with_partner = Activity("Dinner with Arlene", 20, 22, {'love': 1, 'joy': 1})
    resist_conformity = Activity('Resistance Against Societal Norms', 22, 24, {'excitement': 0.2})
    # Weather
    weather = Weather('hot')
    # Mark's day in life
    mark_day = DayInLife('Mark', weather=weather)
    # Simulation
    simulation = Simulation([mark_day])
    # Save the simulation state
    with open('day_in_life.pkl', 'wb') as file:
        pickle.dump(mark_day, file)
    # Plot feelings over time
    keys = list(mark_day.self.emotion_model.feelings_over_time.keys())
    values = list(mark_day.self.emotion_model.feelings_over_time.values())

    for i in range(len(keys)):
        plt.plot(values[i], label=keys[i])

    plt.title('Feelings Over Time')
    # Load the simulation state and print summary
    with open('day_in_life.pkl', 'rb') as file:
        day_in_life = pickle.load(file)

Run the code on Google Colab