![](/static/253f0d9b/assets/icons/icon-96x96.png)
![](https://programming.dev/pictrs/image/8140dda6-9512-4297-ac17-d303638c90a6.png)
Nothing else has code completion that even comes close to being that good.
Well, except Visual Studio (for C++), Qt Creator, and every Java IDE in existence.
Nothing else has code completion that even comes close to being that good.
Well, except Visual Studio (for C++), Qt Creator, and every Java IDE in existence.
There aren’t many good cross platform GUI toolkits. I mean realistically is there anything other than Qt?
formatting does depend on the type of variables. Go look at ktfmt’s codebase and come back after you’ve done so…
I skimmed it. It appears to visit the AST of the code and format that, as any formatter does. ASTs have not been type checked.
Can you give an example?
it gives you an option, just like if it was an interface. Did you actually try this out before commenting?
Precisely! It doesn’t know the answer so it has to guess, or make you guess.
And how often are you naming functions the exact same thing across two different classes without using an interface?
You mean how often does the same field name come up more than once? All the time obviously! Think about common names like id
, size
, begin
, children
, etc. etc.
I’m sorry, but you clearly haven’t thought this out, or you’re really quite ignorant as to how intellisense works in all languages (including Ruby, and including statically typed languages).
I’m sorry but you clearly haven’t thought this through, or you’re just happy to ignore the limitations of Ruby. I suspect the latter. Please don’t pretend they aren’t limitations though. It’s ok to say “yes this isn’t very good but I like Ruby anyway”.
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?
Maybe, but I think the only app store that does vet apps is the Apple one, so that should be the default expectation.
And I think even they wouldn’t manually look for something like this. They’re mainly concerned about people breaking the commercial rules.
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:
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:
There’s also this article which has more reasons.
I am leaving it a while longer before I try Mojo.
I mean… let’s just hope he isn’t doing this professionally.
Yeah possible, but this of the amount of effort that would take!
A recent notable example is xz, but there’s also event-stream npm package a few years ago that got infected with Bitcoin stealing code.
They’re asking if the entire project is somehow fake, not if it’s a real project that got backdoored. That’s obviously impossible to tell just based on stars, language quality, and similar heuristic signals.
Maybe all of the stars, forks, and discussions on the GitHub page are from fake accounts
All 9k stars, 10k PRs, 400 forks & professional web site are fake? Come on this is about the most obviously not fake project I’ve seen!
How do you know when a product like this can be trusted?
The same way you tell if anything can be trusted - you look at the signals and see if they are suss. In this case:
The amount of effort it would take to fake this for very little benefit is enormous.
Maybe I’m just being paranoid.
Yeah just a little!
Yeah definitely! I wouldn’t hold your breath though. Especially as that’s pretty much an escape route from POSIX. I doubt they’d be too keen to lose power.
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.