Lightweight JavaScript Framework Review (For Django Developers) (saashammer.com)

which i think is, for the most part an exaggeration.

if someone feels that learning a new framework is heavy and has a steep learning curve, then either they are juniors that need more practice and experience, or they have never tried learning a second framework, or they have become lazy. (but here i'd also like to blame employers that don't give their developers time to learn new stuff)

Let us.

C# and the .NET Framework were some of my favorite tools. I thought LINQ was neat.

> You also still can't easily style the select component.

Forgoing JavaScript and CSS for a .NET abstraction wouldn't make the situation any better. You'd just get whatever the select component's library gave you until the browsers standardize a way to do it.

I just use typescript and nodejs and the database.

No framework except the express web server.

It's incredibly raw and close to the metal, which I like.

Here's a throwaway example of register and login from ChatGPT to illustrate how easy it is. Totally unchecked but it's just to show approximately what's involved - and it's not much at all.

    import express, { Request, Response } from 'express';
    import bcrypt from 'bcrypt';
    import db from './db';
    
    const router = express.Router();
    
    router.post('/register', async (req: Request, res: Response) => {
      const { username, password } = req.body;
    
      // Hash the password
      const saltRounds = 10;
      const hashedPassword = await bcrypt.hash(password, saltRounds);
    
      // Insert user into the database
      db.run('INSERT INTO users (username, password) VALUES (?, ?)', [username, hashedPassword], (err) => {
        if (err) {
          console.error(err.message);
          return res.status(500).json({ error: 'Internal Server Error' });
        }
        return res.status(201).json({ message: 'User registered successfully' });
      });
    });
    
    router.post('/login', async (req: Request, res: Response) => {
      const { username, password } = req.body;
    
      // Check if user exists
      db.get('SELECT * FROM users WHERE username = ?', [username], async (err, row) => {
        if (err) {
          console.error(err.message);
          return res.status(500).json({ error: 'Internal Server Error' });
        }
    
        if (!row) {
          return res.status(401).json({ error: 'Invalid username or password' });
        }
    
        const isPasswordValid = await bcrypt.compare(password, row.password);
    
        if (!isPasswordValid) {
          return res.status(401).json({ error: 'Invalid username or password' });
        }
    
        return res.status(200).json({ message: 'Login successful' });
      });
    });
    
    export { router as routes };

examples from postgres.js front page:

    import sql from './db.js'
    
    async function getUsersOver(age) {
      const users = await sql`
        select
          name,
          age
        from users
        where age > ${ age }
      `
      // users = Result [{ name: "Walter", age: 80 }, { name: 'Murray', age: 68 }, ...]
      return users
    }
    
    
    async function insertUser({ name, age }) {
      const users = await sql`
        insert into users
          (name, age)
        values
          (${ name }, ${ age })
        returning name, age
      `
      // users = Result [{ name: "Murray", age: 68 }]
      return users
    }

I should have said "better for ME".

>> you also get the Django ORM

I decided the best way (for me) to write back end application is:

* typescript

* nodejs

* postgres

* plain old SQL

I realised I hate using ORMs and much prefer the raw power and directness of SQL. Postgres is an incredibly powerful database - I find it's a problem to have any sort of abstraction between me and the DB.

And honestly typescript is a real pleasure to write.

I still use Python extensively for other stuff, but for web servers, typescript/node/postgres is my preference.

How could Python's runtime type checks be more safe than Typescript's completive type checks? Nobody sane uses typeless Javascript for serious business logic now anyway.

To be honest it's more that I prefer TypeScript to Python. Python and JS have been my main programming languages for 14 years or so.

Either are good - I'm not totally off python. I still write async web servers in Python for various reasons. I'm not much of a fan of Python's type system probably because I haven't yet spent enough time to really learn it.

I definitely use Python for Linux systems programming or non-web server stuff - Python is really great for more systems oriented stuff.

I really liked Django at first but after a while some things really started to bother me about it.

The ORM I found complex and clunky - any time I wanted to do something I kept thinking "Ugh this would be dead simple in SQL".

Needing to add plugins to Django - I often felt like it took me the same amount of time to work out how to install and configure a plugin, as it would to write the same functionality from scratch, with the disadvantage that at the end of the process I'd often still feel like the plugin was a black box that I'd managed to make work but was never sure I had done it right.

And the thing that really annoyed me most about Django is it's meant to be "batteries included", but the very first thing you need to do is work out how to implement users and signin and forgot password and signout - all stuff that should be the very definition of "batteries included". Instead, at the start of every Django project you're left to try to work out what is the right plug and how to install it and did you do it right. If I have to do all that stuff yet again for every project then why bother with Django at all? Why not just use a minimal web server and implement it myself because I'm going to have to anyway.

And then, after forming these hesitations about Django, I started doing async web programming with Starlette and FastAPI and found I really liked async web server programming and Django isn't async.

So at this point I'd pretty much lost interest in Django.

It's not really true for any other programming language. If I'm an expert in Java 8, I can build and ship a product using it. I don't need to be up-to-date in my knowledge of Java 17. Same holds for almost every language.

Javascript is an exception because you don't get to decide which version to deploy, so you have to constantly be keeping up with it.

However, there is no clear line between a content site and a web app. That’s why I suggest that, as a rule, if you see front-end becoming so complex that a full-blown framework is a must, then it might save you in future if you architect it as a separate project. (As sibling comment points out, it doesn’t need to compromise the ability to render static HTML and degrade in UAs without JavaScript.)