The Caveman Web Is Gone — Can We Bring It Back?

April 26, 2026

 

Logo

The Caveman Web Is Gone — Can We Bring It Back?

There was a time when using the internet felt less like searching… and more like hunting.

You didn’t know exactly what you were looking for. You just had a rough idea—and a direction. You’d throw a few keywords into a search engine, follow a trail of links, and see where it led.

Sometimes you’d find nothing.

Sometimes you’d strike gold.

That was the caveman web.


🪨 The Hunter-Gatherer Internet

Back then, the web wasn’t about efficiency—it was about discovery.

You’d land on a page and start exploring its edges. Almost every personal site had them:

  • Link pages
  • “Cool sites” lists (the original blogrolls)
  • Friend networks
  • Categories and subcategories
  • These were pages built by real people, pointing to other real people. One link led to another. Then another.

    You weren’t just searching.

    You were wandering.


    🔗 The Web of Links

    Links weren’t mere navigation—they were connections with meaning:

  • “This is worth your time.”
  • “These are my people.”
  • “If you liked this, you’ll like that.”
  • Sites linked freely. Communities formed organically across domains. Webrings and blogrolls helped small corners of the web find each other without any central authority.

    And somehow, no matter how tiny your site was… people still found it.

    Not through optimization.

    Not through algorithms.

    Just by following human trails.


    ⚙️ When Search Changed the Game

    Then search engines—especially Google—got really good.

    At first, it felt like magic. Type anything and get instant results. The web became searchable, accessible, fast.

    But convenience came with a subtle shift: people stopped wandering as much. Why explore when the perfect result was already ranked for you?


    📉 When Links Became Currency

    Search engines didn’t just find content—they ranked it using links as “votes.”

    That one change rewired everything:

  • Linking out started to feel risky (diluting your own authority)
  • Getting links became a competitive sport
  • Big sites consolidated power
  • Small, independent sites quietly stopped connecting outward
  • The open, freely connected web began to shrink—not technically, but culturally.


    🧱 The Rise of Gatekeepers

    Then came the platforms: social media feeds, algorithm-driven discovery.

    Now, visibility often means:

  • Post on a platform
  • Hope the algorithm favors you
  • Compete in an attention economy
  • The open web is still there—but it’s no longer the starting point for discovery. It’s where you land if you make it past the gatekeepers.


    🎯 The Death of Wandering

    Today, most people don’t explore. They:

  • Search once
  • Click a top result (or none at all)
  • And stop
  • Try broad terms like “free,” “game,” or “code.” You’ll often get ads, SEO-optimized listicles, and the same handful of dominant sites.

    Discovery has been replaced by filtering.

    Exploration has been replaced by quick answers.


    🤖 When You Don’t Even Leave the Page

    Now we’re deeper into the next phase. Search engines (and AI tools) don’t just point—they synthesize and answer directly. Zero-click results mean you rarely need to browse, let alone wander.

    The loop is closing. The caveman spirit feels further away than ever.


    🧭 So… What Can We Do?

    Here’s the hopeful twist: the solution isn’t new tech or a grand movement.

    It’s something we already did, and can do again.


    🔗 Links Still Matter

    We stopped linking freely—not because we had to, but because the incentives and culture shifted.

    Nothing technical prevents us from reversing that.

  • Add (or revive) a links page
  • Curate “Recommended reading,” “Friends of the site,” or “Other cool corners”
  • Share other independent creators generously
  • Build small, human networks again
  • Those old “Blogroll” or “Cool Sites” sections used to be everywhere. They’re rare now—but they don’t have to stay that way.


    🌱 Rebuilding the Web (One Link at a Time)

    The caveman web didn’t die because it was flawed.

    It faded because we optimized the serendipity out of it.

    But the foundation remains. Every outward link you add:

  • Creates a new path
  • Opens a door for someone else
  • Revives the chance of unexpected discovery
  • That’s how the old web grew—organically, imperfectly, humanly.


    🚀 Final Thought

    You don’t need permission to link.

    You don’t need an algorithm’s approval.

    You just need the courage to say:

     `This is worth seeing` 
    

    …and put the link on your page.

    That simple act is how the web once expanded.

    And maybe—just maybe—that’s how we bring the caveman web back, one genuine connection at a time.

    The Hidden Hardware Tax: Why Your “Simple” Movie Night Costs Thousands

    March 12, 2026

     

    Logo

    The Hidden Hardware Tax: Why Your “Simple” Movie Night Costs Thousands (and Fails Fast)

    Remember when watching a movie at home meant plugging in a cheap DVD player and turning on the TV?

    That setup could last 10 years or more without updates, subscriptions, or account logins.

    Fast-forward to 2026, and the cost of “just watching something” has quietly turned into a multi-thousand-dollar hardware commitment — while the devices themselves are increasingly designed to age out long before they physically fail.

    The convenience revolution has a hidden price tag.


    The $4,000 Movie Night

    Start with the modern “basic” setup.

    A reasonable smartphone today — one with decent storage, a usable camera, and 5G — typically lands somewhere around $500–$800 for mid-tier models. Flagships easily cross $1,000.

    A laptop capable of browsing and streaming comfortably? Expect $500–$1,000 for entry-level machines, with mid-range systems landing between $1,200–$1,700.

    Then there’s the TV. Even budget televisions now default to 4K smart displays, with a typical 55–65″ set costing $500–$1,000 from brands like Hisense, TCL, or Kogan.

    Add it all together and the typical household spends somewhere between $1,500 and $4,000 assembling the hardware used to access modern streaming entertainment.

    All just to access content that used to run on a $60 DVD player.


    The Mass-Production Paradox

    Technology was supposed to get cheaper over time.

    Manufacturing has never been more automated. Semiconductor fabrication has advanced dramatically. Global supply chains operate at enormous scale.

    So why aren't devices dramatically cheaper?

    Instead, prices remain stubbornly high — partly because the industry now packs devices with features nobody asked for:

    AI processing units

    ultra-high-resolution displays

    voice assistants everywhere

    always-connected cloud services

    These features inflate base prices while doing little to improve the simple experience of watching a movie.

    Meanwhile, rising demand from AI data centres is also pushing up the cost of memory and components, placing additional pressure on consumer device prices.


    Built to Age Out

    The bigger issue isn’t the price — it’s how quickly the hardware becomes obsolete.

    Modern smartphones often remain physically functional for years, yet their practical lifespan averages roughly 3–4 years before battery degradation, performance slowdowns, or loss of software support pushes users toward replacement.

    Many users replace their phones even sooner — typically every 2–3 years.

    Laptops follow a similar trajectory. While the hardware may last longer, glued batteries, soldered memory, and sealed components make repairs difficult and expensive. Many systems become sluggish or unsupported after 3–5 years.

    Televisions should last far longer — and often the display panels do.

    But the smart software inside them doesn’t.

    Streaming apps stop updating. Operating systems lag. Services quietly drop support.

    Ironically, the “smart” part of the TV often becomes obsolete before the screen itself.


    The 4K Illusion

    Modern TVs are aggressively marketed around 4K resolution.

    But in Australia, free-to-air broadcasts still mostly operate in HD (1080i or 1080p). The widely discussed 4K broadcast future never really materialised.

    That means the biggest benefits of 4K typically appear only on paid streaming tiers, where services like Netflix or Disney+ charge extra for Ultra-HD plans.

    Consumers pay more for hardware that exceeds most broadcast content — while streaming platforms monetise the difference.


    The Upgrade Cycle

    All of this feeds a predictable loop.

    1. 1. Buy expensive hardware to access streaming platforms
    2. 2. Pay monthly subscription fees across multiple services
    3. 3. Watch devices lose support or performance within a few years
    4. 4. Replace the hardware
    5. 5. Repeat

    What began as a promise of convenience has quietly evolved into a permanent upgrade economy.

    Households now juggle multiple streaming services, often spending around $41 per month on average, while broader digital entertainment subscriptions average $78 per month across nearly four services.

    Meanwhile the hardware required to access them continues to grow more complex — and more disposable.


    The Ownership Problem

    Physical media had its flaws, but one thing was simple:

    If you bought a DVD, you owned the movie.

    Streaming changed that relationship. Access replaced ownership.

    Movies and shows can disappear overnight when licensing deals change. Entire libraries vanish without warning.

    Consumers pay continuously — but never actually own the content.


    The E-Waste Elephant in the Room

    There’s also an environmental cost hiding beneath the upgrade cycle.

    Globally, electronic waste has grown to over 60 million tonnes annually, making it the fastest-growing waste stream in the world.

    Only about one quarter of that waste is formally recycled.

    Much of it comes from devices that still function — but are no longer supported or economically repairable.

    Perfectly usable hardware ends up in landfill simply because the software moved on.


    A Simpler Alternative?

    For light users, the economics are starting to look strange.

    Instead of maintaining thousands of dollars in fragile home hardware, some people are drifting toward minimal setups — a cheap laptop or tablet connected to a mobile hotspot.

    A $30–$40 mobile data plan can suddenly look more appealing than maintaining a full entertainment ecosystem of smart devices, subscriptions, updates, and inevitable replacements.


    Why “Dumb TVs” Disappeared

    There’s one more detail that explains a lot about modern hardware.

    A decade ago you could easily buy a “dumb TV” — a screen with no operating system, no tracking, no apps, and no software updates.

    Today they’re almost impossible to find.

    Because smart TVs aren’t just televisions anymore — they’re data platforms.

    Many modern TVs collect viewing behaviour, app usage, and device information to power advertising systems and recommendation engines. Some manufacturers also earn ongoing revenue from ads displayed directly in the TV interface.

    In other words, the television you already paid for can still generate income long after it leaves the store.

    From a business perspective, this explains why manufacturers aggressively push smart features and connected ecosystems. A simple display that lasts ten years and never connects to the internet doesn’t generate additional revenue.

    But a connected device that needs updates, services, and eventual replacement?

    That fits perfectly into the modern tech economy.


    The Real Question

    The system isn’t broken.

    It’s working exactly as designed.

    Modern entertainment hardware is no longer a long-term purchase — it’s part of an ongoing revenue cycle built around upgrades, subscriptions, and software lock-in.

    Which raises a simple question:

    At what point does “convenience” stop being convenient — and start looking like a very expensive con?


    Pricing & Data Notes

    Prices mentioned in this article reflect typical Australian retail ranges observed between 2025–2026. Actual costs vary depending on brand, specifications, promotions, and retailer discounts.

    Average figures referenced throughout the article are based on publicly available consumer research and industry reports covering device lifespans, subscription services, and consumer technology pricing.

    Where averages are cited (such as internet or streaming costs), they represent national consumer surveys rather than individual household spending.


    References

    1. 1. Canstar Blue — What Is The Average Internet Bill Per Month? (Feb 2026). Average Australian NBN bill around $85/month.
    2. 2. The Guardian — Australians pay $84 a month for their internet (Apr 2025).
    3. 3. NBN Co — nbn wholesale price changes from 1 July 2025 (May 2025).
    4. 4. WhistleOut Australia and provider pricing examples (e.g., Amaysim prepaid 5G plans).
    5. 5. Everyday Mobile from Woolworths — $30 prepaid 30-day plan.
    6. 6. Deloitte Australia — Digital Media Trends: Paying More, Scrolling Less (Nov 2025).
    7. 7. Canstar — Cost of Streaming Services in Australia (2026).
    8. 8. Australian Communications and Media Authority (ACMA) — Australia’s TV Prominence Framework (Jan 2026).
    9. 9. Freeview Australia — DVB-I broadcast testing announcements (Dec 2025).



    Mini Golf Demo – Conceptual Overview

    February 21, 2026

     

    Mini Golf Demo – Conceptual Overview

    This demo shows a simple but powerful way to build a top-down mini-golf style simulation in PlayBASIC.

    Rather than focusing on complex physics, the code demonstrates how to combine a few clean ideas to create believable behaviour using fast, data-driven techniques.


    1. Separating visuals from gameplay logic

    The program uses two images of the same size, each with a different purpose:

    • Visible Screen

    This is what you actually see: grass, shapes, and moving balls.

    • Zone Screen

    This image is never shown to the player. Each pixel stores a zone value that tells the code what type of surface the ball is currently rolling over.

    This is a very common game-dev trick:

    images aren’t just for graphics – they can also be fast lookup maps for gameplay data.


    2. Zone-based friction using lookup tables

    Each terrain type (short grass, medium grass, long grass) is assigned:

    • A zone ID

    • A friction value

    • A display colour

    When a ball moves, the code reads the pixel value from the zone screen at the ball’s position and uses that value as an index into a friction array.

    This avoids large blocks of conditionals and makes it easy to add or tweak terrain types later.


    3. Direction-based movement

    Each ball stores its:

    • Position

    • Angle

    • Speed

    Movement is calculated using basic trigonometry (sin and cos) to convert angle and speed into X and Y motion.

    The friction value from the current zone scales the speed, giving the impression of different grass lengths slowing the ball down.


    4. Ray-based collision and reflection

    Instead of moving the ball first and checking overlaps later, the code uses ray intersection:

    • A ray is cast from the current position to the next position

    • If it hits geometry, the surface normal is used to calculate a reflection angle

    • The ball bounces naturally off walls and obstacles

    This method is robust, avoids tunnelling, and works well even at higher speeds.


    5. Vector-based world geometry

    The course is built from vector lines and convex shapes, not tiles.

    • Borders are simple line segments

    • Obstacles are procedurally generated convex polygons

    • The world is partitioned to improve collision performance

    This keeps the layout flexible and easy to expand or randomise.


    6. Data-driven design

    One of the key ideas in this demo is data-driven gameplay:

    • Terrain behaviour is defined by data, not hard-coded logic

    • Friction, colour, and movement all come from lookup tables

    • New terrain types can be added with minimal code changes

    This approach scales well and is widely used in real game engines.


    Summary

    At its core, this demo demonstrates how to:

    • Separate visuals from logic

    • Use images as gameplay data

    • Apply simple physics with believable results

    • Handle collision using raycasting

    • Build systems that are easy to extend

    It’s a compact example of practical game programming techniques, written in a way that new coders can understand and build upon.



      Constant Zone_ShortGrass    =ac(1)
      Constant Zone_MedGrass        =ac(1)
      Constant Zone_LongGrass        =ac(1)
    
    
      Dim Palette(100)
      Palette(Zone_ShortGrass)      = rgb(55,200,80)
      Palette(Zone_MedGrass)          = rgbfade(Palette(Zone_ShortGrass),50)
      Palette(Zone_LongGrass)          = rgbfade(Palette(Zone_ShortGrass),25)
     
      dim Friction#(100)
      Friction#(Zone_ShortGrass)    =1
      Friction#(Zone_MedGrass)      =1.5
      Friction#(Zone_LongGrass)      =2
     
     
      ; get the screen size 
      sw=GetScreenWidth()
      sh=GetScreenHeight()
    
      ; create the visible screen
      DisplayScreen      =NewIMage(sw,sh,true)
    
      ; create the zone screen.
      ; the zone screen is the same size as the 'visible'
      ; but is just used to tell what zone the ball is currently over
      ZoneScreen        =GetFreeimage()
      createfximageex ZoneScreen,sw,sh,32
     
    
      // Draw the Visible scene..
      rendertoimage Displayscreen
      c=Palette(Zone_ShortGrass)
      shadebox 0,0,sw,sh,c,rgbfade(c,80),c,rgbfade(c,80)
    
      inkmode 1+32 
      ellipsec sw*0.7,sh*0.5,200,100,true,Palette(Zone_MedGrass)     
      ellipsec sw*0.7,sh*0.5,100,50,true,Palette(Zone_LongGrass)     
      inkmode 1
    
    
      // draw the collision (zone) scene. 
      rendertoimage Zonescreen
      Cls Zone_ShortGrass
      ellipsec sw*0.7,sh*0.5,200,100,true,Zone_MedGrass     
      ellipsec sw*0.7,sh*0.5,100,50,true,Zone_LongGrass     
     
    
    
      // create collision world
      CollisionWorld=CreateVectorWorld()
     
    
     
      rendertoscreen
    
    
      camera=newcamera()
      cameracls camera,off
    
      setfps 60
    
    
    
      Type tBall
            x#,y#,angle#,speed#
      endType
    
      Dim Ball as tball List
    
        AddNewBallTime=0
    
      Do
    
            CT = Timer() and $7fffffff
          if CT>AddNewBallTime
                ball = new Tball
                ball.x#=rnd(sw)
                ball.y#=rnd(sh)
                Ball.Angle#=rnd(360)
                Ball.speed#=rndrange(2,10)
                AddNewBallTime=CT+1000
          endif
    
           
           
    
          capturetoscene
          clsscene
         
          CaptureDepth 100
    
          CameraGrabWorld Camera,CollisionWorld
    
          DrawImage DisplayScreen,0,0,false
    
          CaptureDepth 10
    
          rendertoimage ZoneScreen
    
          for each Ball()
    
            ; check what zone the ball is currently over.       
            ZoneType=Point(Ball.x#,Ball.y#) and 255
    
            ; get the amount of friction this zone has
            Friction#=Friction#(ZoneType)
     
            ; move the ball 
            Speed#=Ball.Speed#*1/Friction#
    
            newx#=ball.x#+(cos(Ball.angle#)*speed#*1)
            newy#=ball.y#+(sin(Ball.angle#)*speed#*1)
    
            if RayIntersectWOrld(CollisionWorld,Ball.x#,Ball.y#,NewX#,NewY#)=true
                  x2#  =getintersectx#(0)
                  y2#  =getintersecty#(0)
                  ; Calc reflection Direction
                  WallAngle#=AtanFull(getnormaly#(0),getnormalx#(0))
                  RayAngle#=GetAngle2d(x2#,y2#,ball.x#,ball.y#)
                  Ball.Angle#=WrapAngle(WallAngle#,WallAngle#-RayAngle#)
    
                  ball.x#=x2#
                  ball.y#=y2#
               
            else
                  ball.x#=newx#
                  ball.y#=newy#
            endif
    
            ; draw the circle to represent the ball
            circle ball.x#,ball.y#,10,true
          next
    
          drawcamera camera
          Sync
      loop
    
    
    
    
    
    Function CreateVectorWorld()
      WorldWidth=GetScreenWidth()
      WorldHeight=GetScreenHeight()
    
    
    ; Create world
      World=NewWorld()
      CaptureToWorld World
    
    ; draw a series of boarder line for this world
      line 0,0,worldwidth,0
      line worldwidth,0,worldwidth,worldheight
      line worldwidth,worldheight,0,worldheight
      line 0,worldheight,0,0
    
      for lp=0 to 7
          x=100+lp*80
          y=100+lp*80
          Make_Convex(4,x,y,50,90+lp*20)
      next
    
      Make_Convex(6,700,100,90,70)
    
      PartitionWorld World,32
      DrawGFXImmediate
    
    EndFunction World
    
    
    
      ; This function creates a convex polygon shape
    
    Function Make_Convex(edges,xpos#,ypos#,Size,angle)
          sa#=360.0/edges
          c=rndrgb()
          for lp=0 to edges-1
            a#=angle+(lp*sa#)
            x1#=xpos#+cosRadius(a#,size)
            y1#=ypos#+SinRadius(a#,size)
            if lp<(edges-1)
                a#=angle+((lp+1)*sa#)
            else
                a#=angle
            endif
            x2#=xpos#+cosRadius(a#,size)
            y2#=ypos#+SinRadius(a#,size)
            line x2#,y2#,x1#,y1#
          next lp
    endfunction i