Knee-jerk reaction to the internal Java that everyone has in their brain.

By not being a web developer.

Most writing spaces are full of incompetent people who are terrible at what they do, give bad advice, blame everyone else for their problems, and have wildly incorrect opinions on topics that they aren't qualified for.

In other words, most writing spaces are just like HN. Take your pick.

> but if the poorest are helped accordingly

Good joke!

I get where this comes from, but at least in France and Germany it's not questioned that there will be assistance and even direct intervention from the gouvernement on the electricity market. We're talking about democracies with strong socialist components after all. And also, Macron will definitely do everything to avoid another Yellow Jackets episode...

Interesting way of saying "no"

Maybe you can better explain what they're asking for. Because otherwise, I find it unclear. Isn't the point of OpenResty to provide a system for building your app right inside the webserver? Because you can absolutely do that with Caddy, by writing plugins.

Here's an example of how I'm using it. Basically to log part of the response body to API requests.

    log_format  main  '$remote_addr - - [$time_local] "$request" '
                      '$status $body_bytes_sent "$host" '
                      '"$http_user_agent" $http_content_length $request_time '
                      '"$resp_body" *$connection $connection_requests';

    server {
        set $resp_body "";
        location ~ "^/api/v1/...$" {
            # Append response to resp_body until it reaches max_len.
            # - ngx.arg[1] is input chunk.
            # - ngx.arg[2] is eof flag (response is done).
            # - ngx.ctx.resp_body holds partial result between calls
            # - ngx.var.resp_body holds final result.
            # From:
            # - https://gist.github.com/morhekil/1ff0e902ed4de2adcb7a
            # - https://github.com/openresty/lua-nginx-module/
            body_filter_by_lua_block {
                local max_len = 256
                local resp_body = (ngx.ctx.resp_body or "")
                if string.len(resp_body) <= max_len then
                    resp_body = resp_body .. string.sub(ngx.arg[1], 1, max_len)
                    ngx.ctx.resp_body = string.sub(resp_body, 1, max_len)
                end
                if ngx.arg[2] then
                    ngx.var.resp_body = ngx.ctx.resp_body
                end
            }
    }

But there are many scenarios where being able to extend the HTTP server via Lua is more convenient than writing a plugin I would think?

I've also used Lua in the past with haproxy and with Redis. It's a powerful, performant, light-weight, and flexible escape hatch/extension mechanism.

> But there are many scenarios where being able to extend the HTTP server via Lua is more convenient than writing a plugin I would think?

Well, Caddy is written in Go, so it's only natural to write a plugin in Go. Statically compiled into your binary. We provide a tool called `xcaddy` which is used to produce builds of Caddy with any plugins you need. You just need Go installed on your system to run it, no other dependencies.

The reason why Lua is used for OpenResty is because writing plugins in C is... not fun.

You can absolutely do what you described with an HTTP handler module in Caddy. You'd just wrap the req.Body with a reader that watches the bytes as they're copied through the stream, and when you see the part you want to log, you do that.

We have a replace-response plugin which takes a similar approach, except it manipulates the response as it's being streamed back to the client. https://github.com/caddyserver/replace-response The whole plugin is just one file of Go code.

Thanks for the reply.

> now you have to create a database, create a user, grant that user access to the database, setup credentials and start using them.

CREATE ROLE dumbo WITH LOGIN PASSWORD 'fuck';

CREATE DATABASE dumbo OWNER dumbo;

It's that easy.

I only have to run these about once every year or two, and have to look them up every time.

Many developers don't run those commands very frequently, so they're easy to forget.

> It's not a chore, it's not a task, it's fundamentally important, it's what you are on this planet to do.

I'm here to sit on my arse and get fat eating chocolate and makeing games, then kill myself at age 34, actually.

Sounds like you've got solid advice on how to not get fit then ;)

Applying technological solutions to social problems hasn't worked a single time before, but SURELY it'll work this time

Encryption and use of signed certificates has certainly been a big help against web fraud. No, it's not perfect, and can't prevent certain kinds of phishing, but it has definitely raised the bar for would-be scammers. It makes it nearly impossible to spoof "amazon.com" in the browser, and it prevents passive snooping on open WiFi.

You can't make it impossible, but you can make it very difficult.

My elderly uncle almost gave $10,000 to a scammer who had convinced him that his nephew was sitting in a jail and needed this money to be paid for his bail. Luckily, he reached out to me for help and I was able to confirm that his nephew was at home, not in jail.

I honestly can't imagine some of the scams that are coming, particularly to the tech-vulnerable, if we don't do SOMETHING to make real-time deepfake video harder than it now is.

DeepFakes are a technological problem, not a social problem.

> That does not mean that one should not be aware that the creation of such words was based on laziness and ignorance and one should not coin any new words of this series.

You say this, and yet you are writing English and not Proto-Indo-European. Curious!

> all memory could be handed off to a separate dedicated thread that actually calls free().

You could go a bit further and have multiple concurrent threads mark the references, then sweep them up in a separate thread, too. Some sort of concurrent sweep and mark reference count system.

With concurrency you need atomics or locks to synchronize reference counts between cores, unless you can somehow guarantee that ref counts only decrement and can never increment.