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

0 downloads

dbbasic-textbrowser/WEB-DESIGN-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
WEB-DESIGN-HISTORY.md · 17.4 KB · 822 lines

The Web Design Workflow: A History of Increasing Complexity

Status: Historical Analysis Date: 2025-01-28

The Evolution (or Devolution?)

1995-1998: The Simple Era

Workflow:

  1. Open Notepad/SimpleText
  2. Write HTML
  3. Open in browser
  4. Done

HTML:

<html>
<body bgcolor="#FFFFFF">
  <center>
    <font color="red" size="+2">
      <b>Welcome to My Homepage!</b>
    </font>
  </center>

  <p>Check out my <font color="blue">cool links</font>:</p>
  <ul>
    <li><a href="about.html">About Me</a></li>
    <li><a href="links.html">Cool Links</a></li>
  </ul>
</body>
</html>

Time to create: 10 minutes Files needed: 1 Tools needed: Text editor + browser Build process: None Works in: Every browser ever made

✅ Simple ✅ Fast ✅ Accessible ✅ Self-documenting


1999-2003: The Photoshop Era

Workflow:

  1. Design in Photoshop
  2. Add text with font tool
  3. Save as .psd
  4. Hand-code HTML looking at design
  5. Use <font> and <table> to match layout
  6. Open in browser
  7. Tweak

The Key Insight: Designers still HAND-CODED the HTML while looking at the Photoshop file. They didn't export it.

<table width="600" bgcolor="#CCCCFF">
  <tr>
    <td>
      <font face="Arial" size="4" color="#000099">
        <b>My Web Design Portfolio</b>
      </font>
    </td>
  </tr>
</table>

Time to create: 1-2 hours Files needed: 1 HTML, 1 .psd (for reference) Tools needed: Photoshop, text editor, browser Build process: None Works in: Every browser

✅ Design-first thinking ✅ Still semantic HTML ✅ Visual + functional ⚠️ Starting to get complex


2003-2008: The Slicing Disaster

Workflow:

  1. Design in Photoshop
  2. Use Slice Tool to cut design into pieces
  3. File → Save for Web → HTML + Images
  4. Photoshop generates:
  • 20+ image files
  • HTML table soup
  • Inline styles
  1. Upload mess to server
  2. Cry when you need to edit text

Generated HTML:

<table width="760" border="0" cellpadding="0" cellspacing="0">
  <tr>
    <td><img src="images/header_01.gif" width="200" height="80"></td>
    <td><img src="images/header_02.gif" width="560" height="80"></td>
  </tr>
  <tr>
    <td colspan="2">
      <img src="images/content_bg.gif" width="760" height="5">
    </td>
  </tr>
  <!-- ... 50 more rows ... -->
</table>

Time to create: 4-8 hours Files needed: 1 .psd, 1 HTML, 20-50 image slices Tools needed: Photoshop, FTP client Build process: Photoshop export Works in: Most browsers (barely)

❌ Can't edit text without Photoshop ❌ Huge page size (hundreds of images) ❌ Slow loading ❌ Impossible to maintain ❌ Zero semantic meaning ❌ Screen readers completely lost

This was terrible. Everyone knew it was terrible. But tools made it easy to be terrible.


2008-2012: The CSS Separation Era

"Let's separate content from presentation!" - The rallying cry

Workflow:

  1. Design in Photoshop
  2. Hand-code semantic HTML (content only)
  3. Write CSS file (presentation only)
  4. Link CSS to HTML
  5. Test in multiple browsers
  6. Debug CSS bugs for hours
  7. Create separate stylesheets for IE6

HTML:

<div id="header">
  <div class="logo">
    <h1>My Site</h1>
  </div>
  <div class="nav">
    <ul>
      <li><a href="/">Home</a></li>
    </ul>
  </div>
</div>

CSS:

#header {
  background: #003366;
  height: 100px;
  position: relative;
}

#header .logo {
  float: left;
  margin: 20px;
}

#header .logo h1 {
  color: #FFFFFF;
  font-family: Arial, sans-serif;
  font-size: 24px;
}

Time to create: 8-16 hours Files needed: 1 HTML, 1 CSS, several images Tools needed: Photoshop, text editor, 5 browsers for testing Build process: None yet Works in: Most modern browsers

✅ Semantic HTML returning ✅ Easier to update text ⚠️ Tri-Hard pattern emerging (HTML + CSS + images) ❌ CSS browser compatibility nightmare ❌ Design still locked in Photoshop


2012-2016: The Framework Era

"Don't reinvent the wheel!" - The new rallying cry

Workflow:

  1. Design in Photoshop
  2. Download Bootstrap
  3. Copy-paste components from docs
  4. Customize variables.less
  5. Compile LESS to CSS
  6. Test responsive breakpoints
  7. Override Bootstrap styles you don't like

HTML:

<div class="container">
  <div class="row">
    <div class="col-md-12">
      <div class="jumbotron">
        <h1 class="display-4">Welcome!</h1>
        <p class="lead">This is a simple hero unit.</p>
        <hr class="my-4">
        <p>It uses Bootstrap classes.</p>
        <a class="btn btn-primary btn-lg" href="#" role="button">
          Learn more
        </a>
      </div>
    </div>
  </div>
</div>

Time to create: 16-24 hours Files needed: HTML, CSS, JS, Bootstrap files Tools needed: Photoshop, text editor, LESS compiler, browser dev tools Build process: LESS/SASS compilation Works in: Modern browsers

✅ Responsive out of the box ✅ Consistent components ⚠️ All sites look the same ❌ 200KB CSS framework for simple site ❌ HTML littered with framework classes ❌ Lost semantic meaning ❌ Need to learn framework, not just HTML


2016-2020: The Build Tool Era

"Optimize everything!" - The obsession

Workflow:

  1. Design in Sketch/Figma (Photoshop too slow)
  2. npm install 500 packages
  3. Configure webpack
  4. Configure babel
  5. Configure PostCSS
  6. Write React components
  7. Import CSS modules
  8. Run dev server
  9. Wait for webpack to compile
  10. Test
  11. Debug source maps
  12. Build for production
  13. Optimize bundle size
  14. Deploy

package.json:

{
  "dependencies": {
    "react": "^16.x",
    "react-dom": "^16.x",
    "styled-components": "^5.x",
    "react-router": "^5.x"
  },
  "devDependencies": {
    "webpack": "^4.x",
    "babel-core": "^7.x",
    "babel-loader": "^8.x",
    "css-loader": "^3.x",
    "style-loader": "^1.x",
    "postcss": "^8.x",
    "autoprefixer": "^9.x",
    "mini-css-extract-plugin": "^0.9.x"
  }
}

Component:

import React from 'react';
import styled from 'styled-components';

const StyledHeader = styled.header`
  background: ${props => props.theme.colors.primary};
  padding: ${props => props.theme.spacing.lg};

  h1 {
    color: white;
    font-size: 2rem;
  }
`;

export const Header = () => (
  <StyledHeader>
    <h1>Welcome</h1>
  </StyledHeader>
);

Time to create: 40-80 hours Files needed: 10+ component files, config files, package.json Tools needed: Figma, VS Code, Node.js, npm, webpack, babel Build process: Webpack, Babel, PostCSS, minification, bundling Works in: Modern browsers only

⚠️ "Modern" developer workflow ❌ Can't view source and understand ❌ Requires build process ❌ 500+ dependencies ❌ Breaks if any dependency updates ❌ Lost ALL semantic meaning ❌ Days of setup before writing first line


2020-2025: The Tailwind Apocalypse

"Just use utility classes!" - Give up on semantics entirely

Workflow:

  1. Design in Figma
  2. Export to code (maybe)
  3. npm install tailwindcss
  4. Configure tailwind.config.js
  5. Configure PostCSS
  6. Write HTML with 20+ classes per element
  7. Run build process
  8. Purge unused CSS
  9. Wonder why your HTML is unreadable

HTML:

<div class="min-h-screen bg-gray-50 flex flex-col justify-center py-12 sm:px-6 lg:px-8">
  <div class="sm:mx-auto sm:w-full sm:max-w-md">
    <h2 class="mt-6 text-center text-3xl font-extrabold text-gray-900">
      Sign in to your account
    </h2>
  </div>
  <div class="mt-8 sm:mx-auto sm:w-full sm:max-w-md">
    <div class="bg-white py-8 px-4 shadow sm:rounded-lg sm:px-10">
      <form class="space-y-6" action="#" method="POST">
        <div>
          <label for="email" class="block text-sm font-medium text-gray-700">
            Email address
          </label>
          <div class="mt-1">
            <input
              id="email"
              name="email"
              type="email"
              autocomplete="email"
              required
              class="appearance-none block w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm placeholder-gray-400 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm"
            >
          </div>
        </div>
        <!-- ... -->
      </form>
    </div>
  </div>
</div>

Time to create: 60-120 hours Files needed: HTML, tailwind.config.js, postcss.config.js Tools needed: Figma, VS Code, Node, npm, PostCSS, build tools Build process: PostCSS + PurgeCSS (required) Works in: Modern browsers only

❌ 3 MB framework before purging ❌ HTML is unreadable class soup ❌ Presentation in HTML (defeated purpose of CSS) ❌ Can't understand page without docs ❌ Build process mandatory ❌ Completely inaccessible to text browsers ❌ Semantic HTML is dead

We reached peak complexity.


The Return to Sanity: TextFirst.css (2025)

"What if we just... wrote HTML?" - Full circle

Workflow:

  1. Think about content structure
  2. Write semantic HTML
  3. Add <link rel="stylesheet" href="textfirst.css">
  4. Open in browser
  5. Done

HTML:

<!DOCTYPE html>
<html>
<head>
  <title>My Site</title>
  <link rel="stylesheet" href="textfirst.css">
</head>
<body>
  <banner type="info">
    Welcome to my site!
  </banner>

  <article>
    <header>
      <h1>My Article</h1>
    </header>

    <section>
      <p>
        This is <color name="success">good content</color>
        that works everywhere.
      </p>

      <details>
        <summary>More information</summary>
        <p>Additional details here...</p>
      </details>
    </section>

    <aside>
      <box>
        <h3>Related Links</h3>
        <menu type="numbered">
          <li><a href="/home">Home</a></li>
          <li><a href="/about">About</a></li>
        </menu>
      </box>
    </aside>
  </article>
</body>
</html>

Time to create: 30 minutes Files needed: 1 HTML, 1 CSS Tools needed: Text editor, browser Build process: None Works in: EVERY browser (text and graphical)

✅ Back to basics ✅ Semantic HTML ✅ Fast development ✅ Works everywhere ✅ Accessible by default ✅ View source makes sense ✅ No build tools ✅ No dependencies ✅ 15 KB CSS total


The Pattern We Discovered

Early Web (1995-2003)

Photoshop Design
      ↓
Hand-code HTML (looking at design)
      ↓
Works everywhere
  • Designer codes while looking at mockup
  • Direct translation of design to semantic HTML
  • Simple, fast, accessible

Slicing Era (2003-2008)

Photoshop Design
      ↓
Slice Tool
      ↓
Export HTML + Images
      ↓
Unmaintainable mess
  • Tools automated the process
  • Lost human intelligence in translation
  • First time tools made things worse

CSS Era (2008-2012)

Photoshop Design
      ↓
Write semantic HTML
      ↓
Write CSS separately
      ↓
Debug for hours
  • Good idea (separation of concerns)
  • Implementation was painful
  • Tri-Hard pattern emerges

Framework Era (2012-2020)

Figma Design
      ↓
npm install framework
      ↓
Copy-paste components
      ↓
Customize (fight framework)
      ↓
Build process
  • Frameworks to save time
  • Actually takes longer
  • Lost control

Modern Era (2020-2024)

Figma Design
      ↓
Export to code (maybe)
      ↓
npm install 500 packages
      ↓
Configure 10 tools
      ↓
Write components
      ↓
Wait for build
      ↓
Debug source maps
      ↓
Deploy 5 MB bundle
  • Peak complexity
  • Can't even view source
  • Complete abstraction from HTML

TextFirst Era (2025+)

Think about content
      ↓
Write semantic HTML
      ↓
Works everywhere
  • Back to 1995 simplicity
  • With modern semantic tags
  • Human intelligence, not tool automation

What We Lost Along the Way

1995: You could view source and learn

<font color="red"><b>ERROR:</b> File not found</font>

Anyone could read this and understand it.

2025 Modern: You cannot

<div class="bg-red-50 border-l-4 border-red-400 p-4">
  <div class="flex">
    <div class="flex-shrink-0">
      <svg class="h-5 w-5 text-red-400" viewBox="0 0 20 20" fill="currentColor">
        <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z"/>
      </svg>
    </div>
    <div class="ml-3">
      <p class="text-sm text-red-700">
        <span class="font-medium">ERROR:</span> File not found
      </p>
    </div>
  </div>
</div>

Nobody can read this and understand what it does without:

  • Knowing Tailwind
  • Looking up class definitions
  • Understanding utility-first CSS
  • Tracing through 20+ classes

The Core Problem

We automated the WRONG part.

Should automate:

  • Repetitive styling
  • Browser compatibility
  • Responsive design
  • Color schemes

Should NOT automate:

  • Content structure
  • Semantic meaning
  • HTML generation
  • What the page IS

Why TextFirst.css Works

It's the 1995 workflow with 2025 benefits:

1995 Way (Good but limited)

<font color="red">Error</font>

✅ Simple ✅ Semantic ✅ Works everywhere ❌ Limited styling ❌ No responsive design

TextFirst.css (Best of both)

<color name="error">Error</color>

✅ Simple ✅ Semantic ✅ Works everywhere ✅ Enhanced with CSS ✅ Responsive ✅ Customizable

The Magic

In text browser:

Error

Works. Content visible.

In graphical browser with CSS:

┌──────────┐
│  Error   │ <- Red background, rounded corners, padding
└──────────┘

Enhanced. Same HTML.


Lessons Learned

1. Tools Should Serve Humans

Wrong: Photoshop Slice Tool generating HTML Right: Human writes HTML looking at Photoshop

2. Automation Should Reduce Complexity

Wrong: npm install 500 packages to compile CSS Right: One CSS file that just works

3. Separation of Concerns ≠ Separation of Files

Wrong: HTML in one file, CSS in another, now need to maintain both Right: Semantic HTML that's enhanced by CSS

4. Frameworks Should Be Optional

Wrong: "You must use React/Vue/Angular" Right: "HTML works, framework makes it better"

5. View Source Should Teach

1995: Anyone could learn web design by viewing source 2025: Nobody can learn from webpack bundled minified React TextFirst: Back to learning from source


The Full Circle

1995: Simple HTML
        ↓
2000: Add Photoshop (design first)
        ↓
2003: Photoshop generates HTML (disaster)
        ↓
2008: Separate CSS (good idea, painful)
        ↓
2012: Frameworks (lost control)
        ↓
2020: Build tools required (peak complexity)
        ↓
2025: TextFirst.css (back to simple, but better)

We went in a circle and ended up where we started, but learned along the way:

  • How to handle responsive design (CSS)
  • Semantic HTML5 tags (article, aside, etc.)
  • Accessibility requirements (ARIA, etc.)
  • Progressive enhancement
  • Component thinking

But we're back to:

  • Writing HTML by hand
  • One or two files
  • No build process
  • Works everywhere
  • View source makes sense

The Photoshop Parallel

Before Slicing (1995-2003)

Designer creates .psd
     ↓
Designer looks at .psd
     ↓
Designer codes HTML to match
     ↓
Human intelligence translates design → code

During Slicing (2003-2008)

Designer creates .psd
     ↓
Designer uses Slice Tool
     ↓
Photoshop exports HTML
     ↓
Automated mess

Modern (2020-2024)

Designer creates Figma
     ↓
Export to code plugin
     ↓
Automated React/CSS mess

TextFirst.css (2025)

Designer (or developer) thinks about structure
     ↓
Codes semantic HTML
     ↓
CSS enhances appearance
     ↓
Human intelligence, not automation

The pattern: When humans translate design → code, it works. When tools automate it, it fails.


Why This Matters

For Education

Students can learn web development in days, not months:

  1. Learn HTML (1 day)
  2. Add TextFirst.css (1 line)
  3. Done

Not:

  1. Learn HTML (1 week)
  2. Learn CSS (2 weeks)
  3. Learn JavaScript (4 weeks)
  4. Learn React (4 weeks)
  5. Learn webpack (2 weeks)
  6. Learn npm (1 week)
  7. Build your first component (3 months later)

For Accessibility

Semantic HTML + CSS enhancement = accessible by default

Not:

<div onClick={handleClick} className="button-like-div">
  Click me
</div>

But:

<button>Click me</button>

For Performance

  • 15 KB CSS vs 3 MB framework
  • No build time vs 30 second builds
  • Instant updates vs restart dev server

For Maintenance

View source, understand, edit. That's it.

Not: Navigate component tree, find styled-component, update theme variable, rebuild, deploy.


Conclusion

We've completed the circle.

1995 web designers had it right: semantic HTML that works everywhere.

But they lacked:

  • Responsive design
  • Modern semantic tags
  • Cross-browser CSS

We now have all of that. We don't need:

  • Build processes
  • Massive frameworks
  • JavaScript for static content
  • 10+ file coordination

TextFirst.css proves: The 1995 workflow + 2025 CSS features = perfect web development.

The Tri-Hard Pattern is dead. Long live semantic HTML.


"Those who cannot remember the past are condemned to repeat it." - George Santayana

"Those who DO remember the past can cherry-pick the good parts and skip the mistakes." - Web developers using TextFirst.css