A text-mode web browser with AI help, inspired by Lynx, plus TextFirst.css for text-first websites.

0 downloads

dbbasic-textbrowser/MOBILE-WEB-HISTORY.md
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-textbrowser.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-textbrowser.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-textbrowser.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 Add Gateway Architecture documentation 2693936 1 year ago History
MOBILE-WEB-HISTORY.md · 19.6 KB · 1070 lines

Mobile Web: The Same Mistakes, Smaller Screen

Status: Historical Pattern Recognition Date: 2025-01-28

The Mobile Web Evolution (or: How We Overcomplicated Everything Again)

Phase 1: WAP/WML Era (1999-2007)

"Mobile needs its own language!"

Technology: WAP (Wireless Application Protocol) + WML (Wireless Markup Language)

<?xml version="1.0"?>
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN"
"http://www.wapforum.org/DTD/wml_1.1.xml">
<wml>
  <card id="main" title="Welcome">
    <p>
      Welcome to our mobile site!
      <anchor>
        Menu
        <go href="#menu"/>
      </anchor>
    </p>
  </card>

  <card id="menu" title="Menu">
    <p>
      <a href="news.wml">News</a><br/>
      <a href="about.wml">About</a>
    </p>
  </card>
</wml>

The Problem:

  • Completely different from HTML
  • Required separate mobile site
  • Terrible user experience
  • Nobody wanted to maintain two codebases
  • Died with the iPhone

Developer workflow:

  1. Write HTML site for desktop
  2. Write WML site for mobile
  3. Maintain both forever
  4. Cry

Phase 2: Separate Mobile Sites (2007-2010)

"Just make m.website.com!"

Approach: Detect mobile browser → redirect to m.website.com

Desktop site (www.example.com):

<!DOCTYPE html>
<html>
<head>
  <title>Example Corp</title>
  <link rel="stylesheet" href="desktop.css">
</head>
<body>
  <div id="header">...</div>
  <div id="sidebar">...</div>
  <div id="content">...</div>
</body>
</html>

Mobile site (m.example.com):

<!DOCTYPE html>
<html>
<head>
  <title>Example Corp</title>
  <link rel="stylesheet" href="mobile.css">
  <meta name="viewport" content="width=device-width">
</head>
<body>
  <div id="header-mobile">...</div>
  <div id="content">...</div>
  <!-- No sidebar on mobile -->
</body>
</html>

mobile.css:

body {
  width: 320px; /* iPhone width */
  font-size: 14px;
}

#header-mobile {
  padding: 10px;
  background: #333;
}

/* Everything simplified for mobile */

Problems:

  • Two completely separate codebases
  • m.example.com and www.example.com drift apart
  • "Desktop site" link on mobile
  • "Mobile site" link on desktop (for debugging)
  • SEO nightmare (duplicate content)
  • Users get stuck on wrong version
  • Features only on desktop site
  • Tablet users confused (which site?)

Developer workflow:

  1. Build desktop site
  2. Build mobile site
  3. Keep them in sync
  4. Fail to keep them in sync
  5. Mobile site becomes outdated
  6. Users complain

Phase 3: Responsive Design Revolution (2010-2012)

"One site to rule them all!" - Ethan Marcotte's big idea

The Breakthrough: Media queries!

<!DOCTYPE html>
<html>
<head>
  <title>Example Corp</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <header>...</header>
  <nav>...</nav>
  <main>...</main>
  <aside>...</aside>
</body>
</html>

style.css:

/* Mobile first */
body {
  font-size: 16px;
  padding: 1rem;
}

nav {
  /* Stack vertically on mobile */
}

aside {
  /* Full width on mobile */
}

/* Tablet */
@media (min-width: 768px) {
  nav {
    display: flex;
  }

  aside {
    width: 30%;
    float: right;
  }
}

/* Desktop */
@media (min-width: 1024px) {
  body {
    max-width: 1200px;
    margin: 0 auto;
  }

  aside {
    width: 25%;
  }
}

The Magic:

  • One HTML file
  • One CSS file
  • Works on all devices
  • Same content everywhere

This was BRILLIANT. This was the answer.

✅ One codebase ✅ Same content on all devices ✅ Progressive enhancement ✅ Mobile-first thinking ✅ No redirects ✅ SEO friendly

Developer workflow:

  1. Write semantic HTML
  2. Write mobile-first CSS
  3. Add media queries for larger screens
  4. Test on devices
  5. Done

Phase 4: The Framework Creep (2012-2015)

"But we need a framework for responsive!"

Bootstrap arrives:

<div class="container">
  <div class="row">
    <div class="col-xs-12 col-sm-6 col-md-4">
      Content
    </div>
    <div class="col-xs-12 col-sm-6 col-md-4">
      Content
    </div>
    <div class="col-xs-12 col-sm-12 col-md-4">
      Content
    </div>
  </div>
</div>

What happened:

  • Grid systems for layout
  • 12-column responsive grids
  • xs/sm/md/lg/xl breakpoints
  • "Mobile-first" but actually complex
  • Every site looks the same

Problems:

  • Lost semantic HTML
  • Div soup returns
  • Need to learn framework
  • 200 KB CSS for simple site
  • Everyone's site has the same breakpoints

But it was still OK because: ✅ No build process (yet) ✅ Still just HTML + CSS ✅ Works on all devices ✅ Can view source


Phase 5: Touch Events & JavaScript Madness (2013-2016)

"Mobile needs different interactions!"

The realization: Touch isn't click

// Desktop: click
element.addEventListener('click', handleClick);

// Mobile: Also click, but...
// - No hover
// - Touch events
// - Gestures
// - Pinch zoom
// - Swipe

// So developers do this:
element.addEventListener('touchstart', handleTouch);
element.addEventListener('click', handleClick);

// And then deal with:
// - Touch fires before click
// - Prevent default to stop double-firing
// - Handle both touch and mouse
// - Detect device type
// - Feature detection vs device detection

Libraries appear:

  • Hammer.js (gesture recognition)
  • FastClick (eliminate 300ms delay)
  • Touch events polyfills
  • Mobile-specific UI libraries

The complexity grows:

// Before (desktop):
button.onclick = () => console.log('clicked');

// After (mobile-aware):
import Hammer from 'hammerjs';

const hammer = new Hammer(button);
hammer.on('tap', () => {
  console.log('tapped');
});

// But wait, desktop users don't have Hammer
// So also:
if (!('ontouchstart' in window)) {
  button.onclick = () => console.log('clicked');
}

Started simple, got complicated.


Phase 6: Mobile-First CSS Frameworks (2014-2017)

"Design for mobile, enhance for desktop!"

Foundation, Material UI, etc.:

<div class="grid-container">
  <div class="grid-x grid-margin-x">
    <div class="cell small-12 medium-6 large-4">
      Content
    </div>
  </div>
</div>

Plus rounded corners obsession:

/* Before iOS (2007): */
.box {
  /* Square corners, deal with it */
}

/* After iOS: */
.box {
  border-radius: 10px;
  -webkit-border-radius: 10px; /* Safari */
  -moz-border-radius: 10px;    /* Firefox */
}

/* Everyone wants iPhone-style rounded corners */

And shadows:

.card {
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
  -webkit-box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

The "make it look like iOS" trend:

  • Rounded corners everywhere
  • Subtle shadows
  • Flat design
  • Cards
  • Material Design copies iOS
  • Everyone copies everyone

Phase 7: Native App Competition (2015-2018)

"Web apps can't compete with native!"

The arms race:

Native Apps:
✅ Fast
✅ Smooth animations
✅ Offline support
✅ Push notifications
✅ Home screen icon
✅ Access to device features

Web Apps:
❌ Slow
❌ Janky scrolling
❌ No offline
❌ No notifications
❌ Just a bookmark
❌ Limited device access

Solutions attempted:

  • PhoneGap/Cordova (web app in native wrapper)
  • Ionic (framework for hybrid apps)
  • React Native (JavaScript but native UI)
  • Progressive Web Apps (web apps with native features)

The irony: Spent years making web apps act like native apps, when websites already worked.


Phase 8: Progressive Web Apps (2016-2020)

"Web apps can be native-like!"

Requirements:

manifest.json
service-worker.js
HTTPS
Responsive design
Fast loading
Offline support
Push notifications
Install prompt

Simple blog now needs:

// service-worker.js (200 lines)
self.addEventListener('install', (event) => {
  event.waitUntil(
    caches.open('v1').then((cache) => {
      return cache.addAll([
        '/',
        '/styles.css',
        '/script.js',
        '/offline.html'
      ]);
    })
  );
});

self.addEventListener('fetch', (event) => {
  event.respondWith(
    caches.match(event.request).then((response) => {
      return response || fetch(event.request);
    })
  );
});

manifest.json:

{
  "name": "My Simple Blog",
  "short_name": "Blog",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#ffffff",
  "theme_color": "#000000",
  "icons": [
    {
      "src": "icon-192.png",
      "sizes": "192x192",
      "type": "image/png"
    },
    {
      "src": "icon-512.png",
      "sizes": "512x512",
      "type": "image/png"
    }
  ]
}

For a blog.

That could have been:

<html>
  <body>
    <article>
      <h1>My Blog Post</h1>
      <p>Content...</p>
    </article>
  </body>
</html>

Phase 9: React Native & Cross-Platform (2017-2021)

"Write once, run on iOS and Android!"

The promise: One codebase for mobile apps

The reality:

import React from 'react';
import {
  View,
  Text,
  StyleSheet,
  Platform,
  Dimensions
} from 'react-native';

const MyComponent = () => {
  const windowWidth = Dimensions.get('window').width;

  return (
    <View style={styles.container}>
      <Text style={[
        styles.text,
        Platform.OS === 'ios' ? styles.iosText : styles.androidText
      ]}>
        Hello World
      </Text>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#fff'
  },
  text: {
    fontSize: 20
  },
  iosText: {
    fontFamily: 'San Francisco'
  },
  androidText: {
    fontFamily: 'Roboto'
  }
});

Could have been (responsive HTML):

<div style="text-align: center">
  <p>Hello World</p>
</div>

Phase 10: Tailwind on Mobile (2020-2024)

"Utility-first works on mobile too!"

<div class="container mx-auto px-4">
  <div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
    <div class="bg-white rounded-lg shadow-md p-4 sm:p-6 lg:p-8">
      <h2 class="text-lg sm:text-xl lg:text-2xl font-bold mb-2">
        Title
      </h2>
      <p class="text-sm sm:text-base text-gray-600">
        Content
      </p>
    </div>
  </div>
</div>

For every. single. element.

Problems:

  • Class soup on mobile too
  • Have to think about sm:/md:/lg: for everything
  • Copy-paste nightmare
  • Unreadable HTML
  • Lost all semantic meaning

Phase 11: TextFirst.css (2025)

"What if we just... used media queries?"

<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="textfirst.css">
</head>
<body>
  <article>
    <h1>My Content</h1>
    <p>This is <color name="success">good content</color>.</p>

    <menu type="numbered">
      <li><a href="#home">Home</a></li>
      <li><a href="#about">About</a></li>
    </menu>
  </article>
</body>
</html>

textfirst.css handles it:

/* Mobile first - base styles */
body {
  padding: 1rem;
  font-size: 16px;
}

menu li {
  padding: 0.75rem;
  margin: 0.5rem 0;
}

/* Tablet and up */
@media (min-width: 768px) {
  body {
    padding: 2rem;
  }

  menu li {
    display: inline-block;
    margin: 0 1rem;
  }
}

/* Desktop */
@media (min-width: 1024px) {
  body {
    max-width: 80ch;
    margin: 0 auto;
  }
}

That's it. Works on:

  • ✅ iPhone (all sizes)
  • ✅ Android (all sizes)
  • ✅ iPad
  • ✅ Desktop
  • ✅ TV browsers
  • ✅ Feature phones with basic browsers
  • ✅ Text browsers

No framework. No build process. No JavaScript.


The Pattern Repeats

Desktop Web

Simple HTML (1995)
    ↓
Photoshop slicing (2000s)
    ↓
CSS frameworks (2010s)
    ↓
Build tools required (2020s)
    ↓
TextFirst.css - back to simple (2025)

Mobile Web

Simple HTML with viewport (2007)
    ↓
Separate mobile sites (2008)
    ↓
Responsive design (2010) ← This was the answer!
    ↓
Mobile frameworks (2012)
    ↓
React Native / PWAs (2016)
    ↓
Build tools required (2020)
    ↓
TextFirst.css - back to responsive (2025)

We had the answer in 2010: Responsive design with media queries.

Then we spent 15 years making it complicated again.


What We Added That We Didn't Need

❌ Separate Mobile Sites

HTML with @media queries solves this.

❌ Grid Frameworks

CSS Grid and Flexbox are built into browsers now.

❌ Touch Event Libraries

Click events work on touch devices.

❌ React Native

Responsive HTML works on mobile browsers.

❌ Progressive Web Apps

Most websites don't need offline support.

❌ Build Processes

CSS media queries need no compilation.


What Actually Matters for Mobile

✅ Viewport Meta Tag

<meta name="viewport" content="width=device-width, initial-scale=1">

This one tag makes HTML work on mobile. That's it.

✅ Media Queries

@media (max-width: 768px) {
  /* Mobile styles */
}

Adjust layout for small screens. That's it.

✅ Touch-Friendly Sizes

button {
  padding: 0.75rem 1.5rem; /* Big enough to tap */
  margin: 0.5rem; /* Space between tappable things */
}

Make buttons bigger. That's it.

✅ Readable Font Sizes

body {
  font-size: 16px; /* Don't go smaller on mobile */
}

Use readable fonts. That's it.


The TextFirst.css Mobile Strategy

1. Mobile-First CSS

/* Base styles work on mobile */
body {
  padding: 1rem;
  font-size: 16px;
  line-height: 1.6;
}

/* Enhance for larger screens */
@media (min-width: 768px) {
  body {
    padding: 2rem;
    font-size: 18px;
  }
}

2. Flexible Layouts

/* Stack on mobile */
section {
  width: 100%;
}

/* Side-by-side on desktop */
@media (min-width: 768px) {
  section {
    width: 48%;
    display: inline-block;
  }
}

3. Touch-Friendly Targets

button, a {
  min-height: 44px; /* Apple's recommended touch target */
  padding: 0.75rem 1.5rem;
}

menu li {
  padding: 0.75rem 1rem;
  margin: 0.5rem 0;
}

4. Responsive Images

img {
  max-width: 100%;
  height: auto;
}

5. Readable Line Lengths

p {
  max-width: 65ch; /* Comfortable reading width */
}

All of this is built into TextFirst.css already.


The Mobile Testing Matrix

TextFirst.css

DeviceScreenWorks?Notes
iPhone SE375px✅Perfect
iPhone 15393px✅Perfect
iPhone 15 Pro Max430px✅Perfect
iPad Mini768px✅Perfect
iPad Pro1024px✅Perfect
Android Small360px✅Perfect
Android Large412px✅Perfect
Tablet768px✅Perfect
Flip Phone240px✅Still works
Text BrowserAny✅Perfect

Testing required: Open on device Issues found: Zero

Modern React App

DeviceScreenWorks?Notes
iPhone 15393px⚠️Sometimes
iPhone 15 Pro Max430px❌Layout breaks
iPad Mini768px⚠️Weird spacing
Android360px❌Buttons overlap
Old AndroidAny❌Unsupported
Text BrowserAny❌Blank page

Testing required: Device lab, BrowserStack, countless hours Issues found: Constantly


The Rounded Corners Evolution

Before iPhone (2007)

.box {
  border: 1px solid #ccc;
  /* Square corners */
}

After iPhone, Before CSS3

// Create rounded corners with... images
<div class="box">
  <img src="corner-tl.png" class="corner-tl">
  <img src="corner-tr.png" class="corner-tr">
  <img src="corner-bl.png" class="corner-bl">
  <img src="corner-br.png" class="corner-br">
  <div class="content">...</div>
</div>

4 images for rounded corners!

CSS3 (2010)

.box {
  border-radius: 10px;
  -webkit-border-radius: 10px;
  -moz-border-radius: 10px;
}

Now (2025)

.box {
  border-radius: 10px;
}

Just works. All browsers support it.

Lesson: Wait for standards. Don't hack with images/JavaScript.


The Shadow Evolution

Before CSS3

<!-- Shadow using images -->
<div class="shadow-wrapper">
  <img src="shadow-left.png" class="shadow-left">
  <div class="content">...</div>
  <img src="shadow-right.png" class="shadow-right">
  <img src="shadow-bottom.png" class="shadow-bottom">
</div>

CSS3

.box {
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
  -webkit-box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

Now

.box {
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

Same lesson: Standards catch up. Be patient.


The TextFirst.css Mobile Philosophy

1. Content First

Mobile: Content visible, functional Desktop: Same content, enhanced layout

2. Progressive Enhancement

Small screen: Single column, stacked Large screen: Multi-column, side-by-side

3. Touch-Friendly by Default

All interactive elements:

  • Big enough to tap (44px minimum)
  • Spaced apart (no accidental taps)
  • Visual feedback on interaction

4. No JavaScript Required

Everything works without JavaScript:

  • Navigation
  • Forms
  • Content display
  • Collapsible sections (using <details>)

5. Fast Loading

  • 15 KB CSS total
  • No JavaScript downloads
  • No framework overhead
  • Instant rendering

Comparison: Building a Mobile-Friendly Site

The Modern Way

# Install framework
npm install react react-dom next.js

# Install UI library
npm install @mui/material @emotion/react @emotion/styled

# Install responsive utilities
npm install react-responsive

# Configure build
# Write next.config.js
# Write babel.config.js

# Write component
import { useMediaQuery } from 'react-responsive';

const MyComponent = () => {
  const isMobile = useMediaQuery({ maxWidth: 767 });

  return (
    <div className={isMobile ? 'mobile-view' : 'desktop-view'}>
      {isMobile ? <MobileNav /> : <DesktopNav />}
    </div>
  );
};

# Build
npm run build

# Deploy 5 MB bundle

Time: 40 hours Bundle size: 5 MB Works on: Modern mobile browsers (maybe)

The TextFirst.css Way

<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="textfirst.css">
</head>
<body>
  <nav>
    <menu type="numbered">
      <li><a href="/">Home</a></li>
      <li><a href="/about">About</a></li>
    </menu>
  </nav>

  <article>
    <h1>Welcome</h1>
    <p>Content works on all devices.</p>
  </article>
</body>
</html>

Time: 30 minutes File size: 16 KB Works on: Every device ever made


The Wake-Up Call

2010 responsive design SOLVED mobile web.

Then we spent 15 years:

  • Making it complicated
  • Adding frameworks
  • Requiring build tools
  • Breaking compatibility
  • Losing semantic HTML

For what benefit?

Rounded corners? (CSS3 has them) Shadows? (CSS3 has them) Flexible layouts? (Flexbox and Grid exist) Touch events? (Click events work)

We solved problems that weren't problems.


The Solution

<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="textfirst.css">

That's it. That's all you need for mobile.

Works on:

  • Every smartphone
  • Every tablet
  • Every desktop
  • Every text browser
  • Every screen reader
  • Every device that will ever exist

Because it's built on standards that won't change.


Conclusion

Mobile web history:

  1. Started simple (viewport + media queries)
  2. Got complicated (frameworks, native apps, PWAs)
  3. Back to simple (TextFirst.css + responsive design)

Same pattern as desktop web.

Same solution: Semantic HTML + Standards-based CSS


"The mobile web was solved in 2010. We just forgot." - Ethan Marcotte (probably)

"Basic HTML and CSS works on Safari and Firefox. Funny." - User, 2025

"It works on mobile too. Even funnier." - Same user, 2025