Honestly, I more than half agree because the factor most seem to conveniently ignore is that languages and environments that encourage better and safer code are aimed at the lowest common denominator.

The lowest common denominator of developers are the ones that benefit the most from a reduction in defects or unsafe code they may produce. They are the biggest pool of developers. And in my experience, the ones least likely to proactively take measures to reduce defect rates unless it’s forced upon them and/or baked into their environment.

They are the ones that will slap any in typescript to resolve errors instead of actually resolving them, or the ones that will use dynamic in C# instead of actually fixing the bad design … etc

According to all teams I’ve worked on.

Pretty fucking hard.

I know this is satire, But really though better languages that make various classes of defects unrepresentable reduce defects. It’s wild that such a statement needs to be made, but our industry is filled with folks who don’t critically think about decisions like these.

Yeah, but charging $0.002/minute is pretty extreme for being a coordinator. That’s the current per minute rate for single core GitHub actions. Is being a coordinator really consuming an entire vCPU of compute for your own runners?

FYI You already pay for artifact storage.

Two things can be true at the same time!

Oof

Is it cynicism when it’s the reality around us?

I’m confused as to what this is.

You have a PAAS project like Coolify, that’s rather obvious. It tries to provide abstractions and automations for common platform scenarios, which is what the As A Service part is.

What is Dokku abstracting and automating that makes it a PAAS?

I’m probably missing something here.

What you say is true.

It’s not a product that you pay for or product that is sold. It is a product that is provided for free. However, that product can no longer be provided for free because Mozilla doesn’t profit off of you using their free product.

Mozilla (the non profit) actually doesn’t aim to profit at all. They aim to support the ongoing development of Firefox and similar projects. Which is currently under risk of not having the necessary funding to pay engineers to build and maintain it.

Mozilla needs more money so that they are not under the risk of sudden collapse if they stop getting money from Daddy Google.

Honestly, it’s a shitty situation to be in. As the grand majority of users don’t understand just how involved browser development is. And those users instead donate to projects that are either forks of Firefox (and directly depend on Mozillas investment) or are (at this stage) toys, like Ladybird.

Which leaves a slim set of choices for the continued funding of the project. All of which it’s core user base hates (Market trend following, new features to see what sticks, AI related integrations, ads, subscription services…etc)

Yet it’s core user base isn’t willing to donate so it’s kind of a self-caused problem.

Side note. IIRC the foundation’s highest paid executive employees make about what a senior engineer at Netflix makes. To put that into perspective.

Firefox is a commercial product. Is it not?

They need to make money so that they can fund hundreds of engineers salaries to keep building it and maintaining web standards operability.

And somehow do this while keeping off with Chrome who has a team 4-5x their size.

Trying to figure out a way to be independent of Google while competing with Google is a tough nut to crack. If they can’t sell it and they can’t get enough donations, then then it comes down to partnerships and advertising.

Then donate!

They are in this situation because they have to keep up with chrome’s capabilities _ velocity with a team that’s 1/4 the size at best.

Essentially they have to produce more with less and they have a funding problem. Almost all of their funding goes into software engineering salaries.

At the risk of not being able to keep up and becoming an obsolete web browser leaving Chrome as the only dominant one there is a shitty position of being the bad guy so that you can get money.

In short, I sympathize with the reasons why they are having to do this even if I greatly dislike them. Reality is complicated.

This is crazy misattribution.

99% of code is too complicated because of inexperienced programmers making it too complicated. Not because of the principles that they mislabel and misunderstood.

Just because I forcefully and incorrectly apply a particular pattern to a problem it is not suited to solve for doesn’t mean the pattern is the problem. In this case, I, the developer, am the problem.

Everything has nuance and you should only use in your project the things that make sense for the problems you face.

Crowbaring a solution to a problem a project isn’t dealing with into that project is going to lead to pain

why this isn’t a predictable outcome baffles me. And why attribution for the problem goes to the pattern that was misapplied baffles me even further.

The principles are perfectly fine. It’s the mindless following of them that’s the problem.

Your take is the same take I see with every new generation of software engineers discovering that things like principles, patterns and ideas have nuance to them. Who when they see someone applying a particular pattern without nuance think that is what the pattern means.

Yes, containers make your application logic work.

That’s the lowest hanging fruit on the tree.

Let’s talk about persistence logic, fail forwards, data synchronization, and write queues next.

Let’s also talk about cloud provider network egress costs.

Let’s also talk about specific service dependencies that may not be replicatable across clouds, or even regions.

Oh, also provider specific deployment nuances, I AM differences, networking differences…etc

I’m not sure if you are referring to the same thread.

I’m talking about the effort to build multi region and multi cloud applications, which is incredibly difficult to pull off well. And presents seemingly endless challenges.

Not the effort to move to the cloud.

It’s phenomenally expensive from a practical standpoint, it takes an immense amount of engineering and devops effort to make this work for non trivial production applications.

It’s egregiously expensive from an engineering standpoint. And most definitely more expensive from a cloud bill standpoint as well.

We’re doing this right now with a non trivial production application built for this, and it’s incredibly difficult to do right. It affects EVERYTHING, from the ground up. The level of standardization and governance that goes into just making things stable across many teams takes an entire team to make possible.

Screw the compute budget, the tripled team size without shipping any more features is a bigger problem here.

Still linear time at least, could always be much MUCH worse

TIL.

Is this redundant with DNSBL?

Honestly, the people that shit on C# as a Microsoft product are just as bad as the Microsoft Fanboys. It’s an asinine position.

Point at the objective reasons to use it such as first party frameworks, being incredibly stable and having some of the best devex and performance in the ecosystem. There are many reasons to use this, especially for large performance orientated, cross platform, long term stable applications.

It’s a FOSS language anyways, the majority contributions aren’t even from Microsoft employees, seeing crazy high levels of community contributions… Its also supported by a legally separate entity from Microsoft themselves.

Yes, typescript is my favorite language. There’s literally no other language out there that is as expressive and has as strong of a type system as typescript. It is the master of making impossible states unrepresentable through meta programming. Being able to move domain complexity into the type system instead of into the runtime is some of the best ways you can reduce your runtime complexity and defects.

Though .net is my favorite ecosystem, by far. It’s first party frameworks are unmatched in performance and developer experience. And its ecosystem is incredibly stable, unlike JavaScript. C# Is unfortunately a much less capable language from a type perspective than typescript though.

If C# got discriminated unions and strings as first class type citizens that would launch it pretty far.

I mean yeah you can do anything with it like most other languages. The problem comes in with the unstable ecosystem JavaScript has.

You simply don’t have longevity with libraries and frameworks. They churn and become deprecated far too quickly for really any stable project that requires a low maintenance burden.