DEV Community: Graham Patrick

The Age of the Smartphone Is Ending — And Most People Haven’t Noticed

Graham Patrick — Wed, 07 May 2025 16:02:22 +0000

For over 15 years, the smartphone has been the centre of our digital universe. It’s the screen we stare at, the tool we work on, the device we reach for instinctively. But look a little closer — and you’ll start to see the shift.

We’re entering the post-smartphone era. Not with a bang, but through quiet disruption. And it’s already on your body.

The Rise of the Wearable Web
I wear Ray-Ban Meta glasses. With a simple voice command, I can ask for directions, snap a photo, stream music, or get real-time translation.

I wear a smartwatch that tracks my health, receives notifications, and lets me respond instantly.

Samsung just launched a smart ring — one more layer of ambient computing wrapped around our daily lives.

And of course, I can speak to an AI assistant and get intelligent, contextual responses without touching a screen.

This is no longer sci-fi — this is now.

A New Hub: The Invisible Puck
The smartphone’s biggest strength was centralisation. But now, that central hub could shrink even further — into something like a “puck”: a small device in your pocket or bag that does nothing but supply data, compute, and connectivity.

Imagine:

A tiny 5G/6G puck lives in your backpack

Your glasses are your screen

Your ring is your security token

Your watch handles notifications and health

Voice becomes your primary interface

AI becomes your operating system

No more swiping. No more “app folders”. No more trying to type with your thumb while walking.

Screens Are Becoming Optional
We’re heading toward a world where the screen isn’t the experience — it’s a layer. Screens may still be there, but they’ll be optional, not essential.

Even today, I can ask my glasses to play a song, call someone, or answer a question — all without touching a smartphone. I don’t need a “phone” to live connected. I just need smart inputs, wearable endpoints, and a cloud intelligence layer.

What This Means
The next generation won’t grow up “addicted to their phones” — they’ll talk to tech instead of tapping it.

App developers will have to rethink interaction: conversational, contextual, multi-device.

Privacy, identity, and edge computing will take centre stage — because the phone as a walled garden will be gone.

We’ll be more present — or at least, less distracted by rectangles.

The Debate Begins
Is this the death of the smartphone — or just its evolution into something less visible?

Will we embrace ambient computing — or push back against losing physical control?

One thing’s clear: the era of staring at your hand all day is giving way to something new.

So here’s the question:

Would you give up your phone if you could wear the web instead?

Introducing Flaskion – A Lightweight MVC Framework for Flask

Graham Patrick — Mon, 05 May 2025 16:28:41 +0000

After 18 years in the web development world—first cutting my teeth in PHP and later exploring Node.js and Python—I’m excited to officially introduce Flaskion.

Flaskion is a modern, professional-grade MVC boilerplate for Flask that brings structure, clarity, and developer happiness to building web apps in Python.

Why Flaskion?

My Journey

Like many full-stack devs, I’ve always been on the lookout for tools that make development more intuitive. Years ago, after spending time with Laravel, I fell in love with its developer experience, clarity, and powerful CLI tools.

But when I transitioned to Flask, I quickly hit friction:

❌ Inconsistent project structures
❌ No standard routing pattern
❌ Lack of built-in scaffolding

Flask gives you freedom—but with freedom comes chaos.

That’s when Flaskion was born.

What Is Flaskion?

Flaskion is more than just a boilerplate—it's the foundation for your next Flask project.

Think of it as Laravel meets Flask, bringing:

✅ MVC structure
✅ Dynamic CLI generators
✅ Centralised routing
✅ Built-in support for SQLAlchemy, Marshmallow, Flask-Migrate
✅ Optional authentication scaffolding
✅ Beautiful templates (styled, not stock)

It’s clean, minimal, and perfect for both solo devs and professional teams.

Key Features

🏗️ make:new – Scaffold a new Flaskion project with SQLite, MySQL or Postgres
🧱 make:model – Generate SQLAlchemy models instantly
📄 make:controller – Class-based controller with web or API support
📦 make:resource – Full MVC: model, schema, controller, and route
🔐 make:auth – Instantly scaffold login, register, dashboard views

All CLI commands are designed to be intuitive, useful, and expandable.

Folder Structure

flaskion/
├── app/
│   ├── controllers/
│   ├── models/
│   ├── schemas/
│   ├── routes/
│   ├── templates/
│   ├── static/
│   └── config.py
├── run.py
├── .env
├── requirements.txt
└── migrations/

What’s Next?

Flaskion is still growing, and this is just the beginning.

I’m working on:
• Documentation & tutorials
• Pytest-ready testing layer
• More CLI tools (make:mail, make:form, etc.)
• Flaskion website & showcase

Get Started

Install Flaskion CLI:

pip install flaskion-cli

Create a project:

flaskion make:new myapp --db=sqlite

Flaskion is built with love by a developer who’s walked the same path as many of you—looking for simplicity, structure, and power in one place.

Let’s make Flask development feel like Laravel—without losing the beauty of Python.

check it out on pypi.org

Deploying Flask with Laravel Forge + GitHub Actions

Graham Patrick — Sun, 04 May 2025 18:25:08 +0000

This guide walks you through deploying a production-ready Flask application using Laravel Forge, GitHub Actions, and Supervisor — with automatic database migrations, SSH deployment, and secure environment variable management.

We’ll treat this as a fresh project with new migrations.

1.Provision Your Server

In Laravel Forge:

Create a new server (Ubuntu 22+ recommended)
Enable SSH access for your GitHub Actions
Add a site (e.g., api.yourapp.com)
Clone your Git repo (use "Deploy Script" toggle OFF for now)

On the server:

ssh forge@your-server-ip
cd /home/forge/api.yourapp.com
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

2.Project Structure & Entry Point

Your main app should have a run.py file:

from app import create_app

app = create_app()

if __name__ == '__main__':
    app.run()

Use Flask-Migrate and SQLAlchemy in app/init.py:

from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
from dotenv import load_dotenv
import os

load_dotenv()

db = SQLAlchemy()
migrate = Migrate()

def create_app():
    app = Flask(__name__)
    app.config.from_object('config.Config')

    db.init_app(app)
    migrate.init_app(app, db)

    return app

GitHub Actions Deployment

Create .github/workflows/deploy.yml:

name: Deploy to Forge

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Deploy over SSH
      uses: appleboy/ssh-action@v0.1.6
      with:
        host: ${{ secrets.FORGE_HOST }}
        username: forge
        key: ${{ secrets.FORGE_SSH_KEY }}
        script: |
          cd /home/forge/api.yourapp.com
          git pull origin main
          source venv/bin/activate
          pip install -r requirements.txt
          flask db upgrade
          sudo supervisorctl restart flask-app

Important: Add the Forge server's SSH private key (id_rsa) to GitHub Secrets as FORGE_SSH_KEY.

Managing Environment Variables

On the Forge server:

Add a .env file in your project root (/home/forge/api.yourapp.com/.env):

FLASK_ENV=production
SECRET_KEY=supersecret
DATABASE_URL=mysql+pymysql://user:pass@host:port/db
MAILGUN_DOMAIN=mg.yourapp.com
MAILGUN_API_KEY=your-mailgun-key

In app/init.py:

from dotenv import load_dotenv
load_dotenv(dotenv_path='/home/forge/api.yourapp.com/.env')

Confirm values load with:

flask shell
>>> import os
>>> os.getenv("MAILGUN_DOMAIN")

Running Migrations on Deploy

When you push code with new migrations:

flask db migrate -m "Add new table"
git add migrations/
git commit -m "Add new table"
git push

GitHub Actions will:

Pull the latest code
Install dependencies
Run flask db upgrade live
Restart Gunicorn

Supervisor Configuration

Set up supervisor to run your Flask app:

sudo nano /etc/supervisor/conf.d/flask-app.conf

[program:flask-app]
command=/home/forge/api.yourapp.com/venv/bin/gunicorn run:app
user=forge
directory=/home/forge/api.yourapp.com
autostart=true
autorestart=true
stdout_logfile=/var/log/supervisor/flask-app.log
stderr_logfile=/var/log/supervisor/flask-app.err.log
environment=FLASK_ENV="production"

Then reload:

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl restart flask-app

You Did It

You now have a full CI/CD pipeline:

GitHub commit → GitHub Actions → SSH to Forge → Pull, Migrate, Restart

New tables are deployed automatically

Environment is secure