In normal English, when not using a number, sure! But in software, with numbers versions it almost universally means chronological releases of something.

There are many different versions of Windows, like Home or Enterprise. You can get hardcover or paperback versions of many books.

Great examples! Those are both called “editions”, not versions. Thanks for proving my point 😄

They chose “version” because they are just that, versions. Improvements over the original design that benefit from new insights and technological improvements. We’re lucky they had the foresight to include a version number in the spec.

No they aren’t. A higher version of UUID isn’t “newer and better”, like the word “version” implies. It’s just different. It’s like they called a car “vehicle version 1” and a motorbike “vehicle version 2”. The common use of “version” in the software world would mean that a motorbike is a newer and hopefully improved version of a car, which is not the case.

The talking pumpkin is 100% right that they should have used “type” or “mode” or “scheme” or something instead.

There aren’t many good cross platform GUI toolkits. I mean realistically is there anything other than Qt?

I think you’re getting a bit confused. How do you know where x’s type is defined and therefore where x.bar is defined if you don’t know what type x is? It’s literally impossible. Best you can do is global type inference but that has very big limitations and is not really feasible in a language that wasn’t designed for it.

Do you think that formatters for dynamic languages need to know the type in order to format them properly? Then why in the world would you need it to know where to jump to in a type definition!?!

Not sure if that is a serious question, but it’s because formatting doesn’t depend on the type of variables but going to the definition of a field obviously depends on the type that the field is in.

Maybe my example was not clear enough for you - I guess it’s possible you’ve never experienced working intellisense, so you don’t understand the feature I’m describing.

class A:
  bar: int

class B:
  bar: str

def foo(x):
  return x.bar

Ctrl-click on bar. Where does it jump to?

Oh really? How would an IDE go-to-definition on x.bar in this code?

def foo(x):
  return x.bar

Best it can do is heuristics and guesswork.

I’ve literally never heard anyone say that

Well you didn’t listen then. Google the phrase.

I can tell you’ve literally never even tried this…

I do not need to try it to know that this is fundamental impossible. But I will try it because you can go some way towards proper type knowledge without explicit annotations (e.g. Pycharm can do this for Python) and it’s better than nothing (but still not as good as actual type annotations).

It’s also much more readable than bash, python, javascript, etc. so writing a readable (and runnable everywhere)

Bash definitely. Not sure I’d agree for Python though. That’s extremely readable.

You’re talking about rails.

Maybe other Ruby code is better, but people always say Rails is the killer app of Ruby so…

Use an IDE like I said and you can literally just “Find all usages” or “Jump to declaration”, etc.

That only works if you have static type annotations, which seems to be very rare in the Ruby world.

In any case, you shouldn’t be using any of these for large projects like gitlab, so it’s completely inconsequential.

Well, I agree you shouldn’t use Ruby for large projects like Gitlab. But why use it for anything?

Ever tried to follow a large Ruby codebase like Gitlab? Absolutely nightmare. Not only does it not have type annotations, so you can’t follow code by clicking, but you can’t even follow it by grepping because Rubyists seem to love generated identifiers. Even the syntax of the language makes grepping worse, e.g. the lack of brackets prevents you from grepping for function calls like foo(.

Real moral of the story: STATIC TYPING!

Seriously so many people think it’s a waste of time, and then stuff like this happens.

Microsoft doesn’t have a vetting process for publishing extensions in the store. Maybe the failure is that people assume they do?

You can count Ruby out immediately. Terrible language.

Also replace JavaScript with Typescript. It’s strictly superior.

I don’t think Go has any mature GUI libraries.

For desktop GUI your main options are:

• Qt, via C++. Probably the best option but if you don’t know C++ that’s a huge barrier.
• Qt, via Python. Reasonable but Python is quite a shit language. It’s very slow and the tooling/infrastructure is absolutely abysmal. Be prepared to bang your head against the wall trying to e.g. get relative imports to work.
• Dart/Flutter. This is quite nice but not super mature for desktop apps. Also the Dart ecosystem is very small so libraries you want may not be available.
• Electron/Typescript. This is quite a good option. Nobody here will recommend this because nerds have a slightly weird hatred of Electron because the minimum download size is like 80MB. But normally it doesn’t really matter. Especially for big apps.

For the web frontend you basically want Typescript. For the backend you can use literally any language.

I would recommend Electron for the GUI and Typescript for the web frontend and Electron GUI. It means you can use the same language everywhere and you won’t need to even implement the same program twice.

If you’re worried about the download size / RAM usage you can look into Tauri which uses your OS’s browser engine. I’ve never used it though.

Yeah but be prepared for a lot of pain if you want to distribute your app. Python tooling/infra is abysmal.

Haven’t tried Mojo yet but I have tried Julia and it kinda sucked balls. Sorry Julia fans, but it did. My main complaints:

• It’s a research language like MATLAB, so the emphasis is on repl’s, trying things out etc. But the compilation model is like C++. When you import a package it spends like 2 minutes compiling it. I think it’s supposed to cache it but the second time it was still like 10 seconds for me just to import a package. I believe they’ve improved this since I used it but still, huge red flag.
• 1-based indexing. Come on guys. Anyone using this is smart enough to learn 0-based indexing. It’s like putting a steering wheel in a jet fighter because you worry about pilots getting confused by a joystick. Again, red flag.
• The plotting libraries (a core feature for this sort of language) kind of sucks. In fairness nothing comes close to MATLAB on this front. I ended up paying for MATLAB because of that.

There’s also this article which has more reasons.

I am leaving it a while longer before I try Mojo.

I was going to say there are about a gazillion free Git tutorials so this seems like a strange thing to charge quite a lot of money for. But it does look very well done.

Yeah I get what you’re saying. Gitlab can pretty much do that too, you just need a branch & MR for each commit, and then you tell it to merge each branch into the previous one. It automatically rebases them when their dependency merges.

Definitely more tedious to set up than just pushing one branch though. Maybe I should make a tool for that… Does Gerrit test each patch in CI sequentially or just all of them together?

But in any case that wasn’t really the problem I was talking about. What I’m saying is that whether or not you should squash a branch depends on what that branch is. Neither “always squash” not “never squash” are right. It depends. And developers seem to have a real problem with knowing when a change is important enough to warrant a commit.

Though I suppose if people have to actually review each commit they would get a lot more push-back to “fix fix fix” type commits so maybe you are right.

Does Gerrit require each individual commit to be approved or can you just approve the whole branch/changeset?

How does that help?

Yeah I agree but in my experience developers seem to struggle with “keep important things in history; squash unimportant things”. An open “merges allowed” policy leads to people unthinkingly merging branches with 50 “typo”, “fix” commits for a 100 line change.

Dunno what the answer is there.

you should spam git log --graph

Yeah… but that’s just a poor man’s GUI. Why use that when you can use a proper GUI? The only reason I can think of is if you happen to be in a situation where using a GUI is a bit of a pain (e.g. SSH).

You’ve misunderstood the issues completely. They had no issue with paying more. The issue is with the extortion of demanding they pay for 12 months up front, the 40x increase (7 million visits a month is 3 visits per second on average; not huge - definitely doesn’t cost $10k/month), the terrible communication, and the retaliatory shutdown of their account. If you can’t see the issue with any of those I’m not sure what’s wrong with you.

Consider how Cloudflare should have handled this:

1. Instead of connecting them to sales repeatedly, connect them to a technical team who could explain the actual issue.
2. Let them pay monthly (honestly based on the emails from them it sounds like there actually is a monthly option; they just were trying to strongarm them into paying for a year).
3. Have less insane pricing.
4. Give them proper warning before shutting their site down. Not “your site may be closed”, but “we will close your site on XXX”.

Cloudflare are the clear villains here, assuming none of this is an outright fabrication, which seems unlikely based on the similar experiences of other people. You desperately grasping at the fact that its a casino to swing the moral balance is hilarious. Why do you want to defend Cloudflare so much? Do you have shares in them or something? (Pretty sure I do.)

It is very powerful, but it is painfully obvious that no one has ever gone back and said, “but what if anyone else who wants to use this is not a Linux cli guru and already has an expert understanding of git commands?”.

This x100. I mean I think I know the answer - Git was written by a C kernel guy, and the devs that it attracted are C guys. The kind of people who think user friendliness is a weakness. Guess how you contribute a patch to Git? Well step 1 is reading a 10 page essay… Needless to say that isn’t going to attract many people that care about beginners.