Depending on what you do, it will probably only be a few lines of rust. Most of the complexity would be in the DB setup and SQL queries. Since you’ll probably use an HTTP server crate that will handle all of that for you.

So, yes, it should be possible.

Even if you don’t intend to make it a UI project. You should still do a shitty UI. Otherwise you will spend more time testing it than actually developing it.

Lots of talk about the problems of implicit conversions. Which is known, and is the reason that rust does not have implicit conversions. But when it came to the heart of the article, the explanation of why unsigned is bad for sizes, it’s just:

• One example about wrapping in ring buffers.
• Saying “in the 90s there were a lot of problems”.
• The lower boundary “0” being near “normal” numbers.

I can see how you can think the 3rd one is an issue. But then the answer should be the java one of just removing unsigned. Since that issue is not exclusive to sizes, every unsigned use case has it.

It seems like the real problem here is having implicit conversions.

Wtf is this?

The most foreseeable event of the last 20 years.

Massive out of this world investment + no demand = prices so cheap they were operating at a huge loss

Operating at a huge loss + time = huge enshittification

Raising prices is the easiest form of enshittification. Ads are coming too. Lastly it will be degrading features. Incorporating more features that no one wants, and bundling with other services that no one wants.

And that is shown by the markings.

I just looked one up, it’s less than 20€, 0,02mm of precision. There are just 4 markings between 1mm and the next.

So instead of 9 markings, each marking adding 0,01mm, you just add 0,02mm. Doesn’t sound complicated at all.

I haven’t found an analog one, but a digital one with 0,01mm of precision costs 30€. Maybe an analog one costs 50€.

So if adding 0,02 is too complicated, you can just buy a 0,01 one for 30€ more. Which is the price of a pizza for a tool that will last years.

Anything more precise than 0,01. You probably have a lot of experience using a caliper. Whatever method it uses to display that precision is gonna be second nature.

Is there anyone in this world needs a caliper of precision between 1cm and 1mm that can’t afford a 1mm of precision caliper?

As I said in another (larger) comment, you just don’t know how precision is encoded in decimals, which doesn’t mean that it isn’t. In fact, precision is encoded in decimals, just like with fractions.

0,7 is 0,7 ± 0,05 0,7000 is 0,7 ± 0,00005

1/14. Easy

If programs can handle February having 28 days, sometimes 29. It can handle 14 having 1 day, sometimes 2.

Some people are just elitist.

“Ew? You use the GUI? I’m way better since I do that from the terminal”.

But since the terminal has a shit UI, they do all sort of things for it to resemble a GUI more. So they can have the convenience of a GUI while not hurting their pride.

No. Maybe in the last one. Since I haven’t seen it and just pretend doesn’t exist

I’m not looking to argue about the importance of my points. I wouldn’t have listed so many in that case.

The point I’m trying to make is that this is a very incomplete article, as it doesn’t seem that much thought was put on the downsides.

A good article would’ve considered every angle. And so would probably conclude (if it had a conclusion) that the premise is incorrect, and the world of language design is more nuanced than “having both modifiers and annotations is bad language design”.

And at that point, the article would’ve probably ended up being: when should annotations be used instead of modifiers?

Many of the most popular languages have both modifiers and annotations:

• Java
• Rust
• Python *Javascript

C doesn’t have both because it doesn’t even have annotations. Idk about C++, but it either doesn’t have annotations (like C) or it should be in the list above

All of those have been heavily criticized from a language design PoV. And I’ve never seen anyone complain about this. People genuinely don’t believe this to be an issue.

The closest is public static int main() for java. But making them annotations would not fix that, only rearrange the issue vertically.

I did not intend to sound angry. I was trying to do an honest review of this article. Since I did not consider it good at all.

What is this article? There is no author, and it is written as if it were an objective truth when it is clearly subjective.

There is no conclusion, it’s just an introduction paragraph that says “do this, this is good design”, followed by a pro-con analysis, and then the article just ends. Given that it has real drawbacks, you would think it would be more nuanced than “do this, this is good design”.

Furthermore the analysis is not even complete. The only 2 drawbacks mentioned only affecting the developer of the language. And ignoring more obvious drawbacks that would affect the users of the language:

• Aesthetics. Annotations are just uglier than modifiers. Due to their special syntax instead of just a naked keyword.
• Annotations take up more space. Screen space is valuable, annotations usually are stacked vertically, which takes up a lot of vertical screen space. This is in order to mitigate their use of horizontal screen space by their syntax.
• Disorder. Annotations are not ordered, which means they are harder to parse by a human. And if there is a wall of annotations, a human might miss an important one because it is surrounded by others that are just boilerplate.
• “Downgrading” modifiers to annotations removes their perceived importance. Modifiers modify the class/function/whatever, annotations add to it. Usually, you can ignore annotations and just look at the modifiers. If modifiers are annotations, you have to read the annotations to filter which ones are important to you and which aren’t. Which is harder to do due to the previous point “Disorder”.
• If annotations were objectively better than modifiers, the logical conclusion would be “your language should not have modifiers, do annotations instead” instead of “if your language has both, remove modifiers”.
• Namespacing is not objectively better. I don’t want to import “public” in every single file. It’s just useless boilerplate at that point. And some dependency might export their own “public”. Or even worse, a non-annotation (function, class) named “public”. If reserving keywords for modifiers is a concern, you can just prepend the uncommon ones with “__”. Nobody is going to complain that they can’t use the name “__readonly” because it’s reserved.
• Variable declarations do have modifiers too (for example “const” in C). Annotations are awful for variable declarations. See the point about screen space. Same for closures or code blocks.

There never was a time when feminazis didn’t exist. The amount of them might have changed over the years. But there have always been.

EDIT: I meant feminist in the sense of “people that call themselves feminist but just want to kill all men or similar”.

Headline: says something. (That is obviously not true and just clickbaiting)

Instant disclaimer: the headline is not good, it should be instead “don’t do this other thing”.

Later in the article: how do we avoid doing the thing I told you not to do? By doing what I told you not to do.

The dude may be correct (idk, haven’t bothered reading the rest of the article), but he doesn’t know how to write/communicate. I don’t believe he’s respecting my time. Just tell in the title what you actually want to talk about.

5 seconds at every boot and shutdown is important.

The reason you shouldn’t blindly benchmark an init system is because most of the time is not caused by the init system itself being slow, but the processes it manages being slow.

As the other commenter says, it is very easy to make the system “faster” by just configuring the timeouts to be lower. If you just set the timeout to 0 it will be very fast, but it won’t be a very good system.

You can count em. Another comment said there were 8 workers.

It’s even worse than that. They increase the price right after they increase the ad length. As in “well, now that ads are longer, this subscription has more value. Therefore we should increase the price”.

It was a dream when it wasn’t available. Once it existed, we saw the many flaws it had. That’s why statically strong typed languages still exist. And even new ones are being created.

You have to trust them though. That’s my point.They may say they are funded only by donations and still sell your data.

In fact the first link says the same as I do as the first phrase. When using a VPN, you are moving your trust from your ISP to your VPN provider.

Of course there may be exceptions that are actually free and don’t sell your data. But the ones that sell your data will rarely state so.

Idk what either of those are. I don’t endorse any VPN. All I’m saying is that it doesn’t matter how strong the encryption algorithm is, you still have to trust your provider.

VPNs have the exact same power over you as ISPs. Using a VPN to avoid your ISP is just kicking the can down the road. That’s why you better choose a VPN that you trust.