furkan@admin:~/presentation/cover$EXECUTING

Algorithmic
Anatomy

Late Ottoman and Early Republic Era Transformation

Midterm Presentation

VCDS4112_s26 Capstone Project

Prof. Dr. Rıfat Hakan Ertep
Dr. Öğr. Üyesi Duygun Erim
Araş. Gör. Ali Doğukan Genç

Furkan Çağlar

furkan@admin:~/concept/what$WHAT

Visualizing
Transformations

This project is an interactive data art collection that visualizes the systemic, demographic, and cultural transformations during the late Ottoman Era, starting from the 19th century.

Historical events are traditionally represented through static texts or 2D maps. This challenge limits our ability to see the chaotic, organic network of systemic changes.

furkan@admin:~/concept/why$WHY

The Medium is the Message

This project transforms complex historical data into a living, interactive ecosystem that reflects the true nature of events.

By moving beyond static charts, we allow the data to breathe, crash, and form topographies in real-time based on actual historical parameters.

furkan@admin:~/methodology$HOW

Code as the Canvas

The project leverages p5.js for data visualization and creative coding, CSS/JS for architectural framework, and GSAP for DOM manipulations.

It utilizes Python scripts to compile historical data into structured JSON files, and ultimately uses this data as an algorithmic brush on WebGL canvases.

furkan@admin:~/scripts/parser.py$SCRIPT

# Parsing historical demographics & political data

import pandas as pd

import json

import numpy as np

def process_historical_data(filepath, module):

    df = pd.read_csv(filepath)

    # Clean and normalize missing coordinates

    df['lat'] = df['lat'].fillna(method='ffill')

    df['lon'] = df['lon'].fillna(method='ffill')

    # Apply algorithmic grouping based on module type

    if module == "migration":

        df = df.groupby(['origin', 'destination']).sum()

    json_output = df.to_json(orient='records')

    with open(f'dataset_{module}.json', 'w') as file:

        file.write(json_output)

process_historical_data('karpat_1881.csv', 'migration')

furkan@admin:~/modules/overview$SUBJECTS

The 3 Modules

1. Migration: Tracking the vectors, volumes, and routes of displaced populations.
2. Language: Mapping spoken mother-tongue ratios across districts and provinces.
3. Politics: Visualizing the democratization timeline and parliamentary compositions from Meşrutiyet to 1950.

furkan@admin:~/modules/sources$REFERENCES

Establishing Trustful Baselines

The architecture strictly relies on hard numbers over political commentary.

Kemal Karpat (1985): Ottoman Population. Essential for exact migration volume and ethnic distributions.
Justin McCarthy (1995): Death and Exile. Core statistical baseline for tracking displacement vectors and forced routes.
Republic Era Censuses: Utilized strictly for analyzing spoken language ratios across regions.
Hasan Kayalı (1997): Arabs and Young Turks. Used for structural analysis of the Parliament and origin provinces.
Tarık Zafer Tunaya (1952): Türkiye'de Siyasi Partiler. Crucial for mapping the political factions and semantic network of the early TBMM.

furkan@admin:~/modules/migration$MODULE 01

Demographic Vectors

Based on Kemal Karpat's data (1830-1914), viewing human migration not just as a historical event, but as "spatial density".

Focusing on exact parameters: Year, specific events, origin-to-destination routes, population volume, and ethnic groups.

Utilizing particle systems to model the volume and direction of human flow. Mapping origin and destination nodes where the "weight" of the data dictates the velocity.

furkan@admin:~/modules/migration/data_mapping$DATA TO VISUALS

Algorithm Mapping Rules

Data: Population Volume
➔ Visual: Particle Mass & Size.

Data: Origin & Destination Cities
➔ Visual: WebGL Steering Force Vectors.

Data: Event Urgency & Casualties
➔ Visual: Noise turbulence and velocity multiplier.

furkan@admin:~/modules/migration/physics.js$CODE

// Routing flow based on McCarthy & Karpat data

function injectForce(route) {

  let vol = route.population;

  let origin = createVector(route.oX, route.oY);

  let dest = createVector(route.dX, route.dY);

  let urgency = route.casualtyRate;

  // 10,000 people = 1 Mass Unit

  let mass = map(vol, 0, 500000, 2, 50);

  // Applying historical stress as Perlin noise turbulence

  let turbulence = noise(origin.x, origin.y) * urgency;

  let p = new Fluid(origin, dest, mass);

  p.applyForce(turbulence);

  particles.push(p);

}

furkan@admin:~/modules/migration/live$LIVE DEMO

furkan@admin:~/modules/language$MODULE 02

Language Ratios

Focusing strictly on data from the 19th and 20th centuries, up to the Republic era censuses where "Mother Tongue" was recorded.

Visualizing spoken language ratios directly on a topological map, breaking down distributions region by region, province by province, and district by district.

* Note: This module focuses purely on quantitative distribution ratios on the map, excluding linguistic reform or etymology.

furkan@admin:~/modules/language/data_mapping$DATA TO VISUALS

Topological Coloring Rules

Data: District Total Population
➔ Visual: Base opacity of the map node.

Data: Spoken Language %
➔ Visual: RGB Color blending weight.

Data: Urban vs. Rural Density
➔ Visual: Node extrusion scale and blur radius.

furkan@admin:~/modules/language/shader.js$CODE

// District language ratio mapping & blending

function renderDensity(district) {

  let pop = district.totalPopulation;

  let baseOpacity = map(pop, 0, 100000, 0.1, 1.0);

  district.languages.forEach(lang => {

    // Ratio for color weight calculation

    let ratio = (lang.speakers / pop) * 100;

    // Blend mode for overlapping linguistics

    blendMode(SCREEN);

    let finalColor = calculateHex(lang.color, ratio);

    fillMapNode(district.geoJSON, finalColor, baseOpacity);

  });

}

furkan@admin:~/modules/language/live$LIVE DEMO

furkan@admin:~/modules/politics$MODULE 03

Politic Topology

Focusing on the evolution from the 1st and 2nd Constitutional Eras (Meşrutiyet) to the 1st & 2nd TBMM, analyzing the democratization process up to 1950.

Visualizing where deputies came from, province seat counts, ethnic origins, and political groupings election by election.

A structural analysis mapping the seating positions and shifts caused by year-by-year political events.

furkan@admin:~/modules/politics/data_mapping$DATA TO VISUALS

Topological Seating Rules

Data: Political Faction / Ethnicity
➔ Visual: Hemicycle X/Y Cluster Position.

Data: Province Seat Count (Power)
➔ Visual: Z-Axis (Height) Extrusion of the mountain.

Data: Inter-party Coalitions
➔ Visual: Gravitational pull between distinct data nodes.

furkan@admin:~/modules/politics/mesh.js$CODE

// Re-rendering topology per election cycle

function buildParliament(year) {

  let deps = dataset.filter(d => d.year === year);

  deps.forEach(dep => {

    // Extrude height based on regional seat count

    let ext = map(dep.provCount, 1, 20, 10, 200);

    // Faction grouping creates gravity clusters

    let target = groupClusters[dep.faction];

    // Smooth transition between historical eras

    dep.node.lerp(createVector(target.x, target.y, ext), 0.05);

    dep.updateSpringPhysics();

  });

}

furkan@admin:~/modules/politics/live$LIVE DEMO

furkan@admin:~/presentation/end$FINISHED

Thank You.

This presentation is accessible at:

> caglarfurkan.com

AlgorithmicAnatomy