Traister101

Permits is only required when the compiler can’t see the extending classes. IE inner classes can extend without needing to be written out in a permits clause. This isn’t really that useful but I’ve taken advantage of it more than once so who knows

Um what? I didn’t like hide extra meaning in what I said. High quality code doesn’t imply all that extra shit you added. It’s code that’s easy to read and modify. Typically this just means you name stuff well and document things that aren’t obvious. Usually my docs explain why something exists since thinking it’s unnecessary cause you don’t remember what the original problem was a common occurrence before I started doing so.

Is high quality code ran through a formatter? I’d hope so yeah. There should be a consistent code style across the entire project. Doesn’t matter what it it long as it’s consistent.

100% code coverage is meaningless and as such a pointless metric. Also 100% coverage is explicitly tied to the implimentaion as all code paths have to be reached which is obviously not a good idea (tests have to change when the implimentaion changes as you’re testing the implimentaion not the api).

Really a lot of this is just meaningless buzz words as an attempt at some sort of gotcha. Really don’t understand how you even interpreted a statement so simple in this way.

Ah sure, like scripts and stuff. I have some absolutely atrocious python hanging out to help me do shit. I don’t have like any actual projects that are just a trash fire though

I don’t really get the code point. Like your own code written for personal projects is probably gonna be pretty high quality I’d hope? Sometimes we just write trash to get something finished but soon as I’ve had to change it… hell yeah I’m unfucking that mess, no way do I want to figure out what it does a second time.

I mean yeah but not anywhere near badly enough to be willing to deal with a phone keyboard…

ಠ_ಠ

I think primarily I don’t really care to argue about if it’s harder to write or not since it doesn’t really matter. I think the pros Rust provides are worth all it’s cons

I’d probably say it depends but I’m no Rust expert and I have no direct experience with C (though quite familiar with C++).

Basically I’d expect writing C to be easy, but not safe. IE you can quickly and easily write C that compiles but has runtime issues. Rust for the most part will catch everything but logic issues during/before compilation meaning once the program runs you’ll have very high confidence in it’s runtime behavior leading to time spent “fighting the compiler” instead of figuring out wtf is going wrong at runtime.

What Rust provides is statically guaranteed memory safety. Some C++ types will prevent memory issues however the language itself is unsafe. Playing with raw pointers is just as valid as using std::unique_ptr. In Rust however you must sign a contact (using unsafe) in order to play with raw pointers. Unsafe is you the programmer promising that you followed the rules. This is like how C++ says it’s illegal to write UB and your program will break (and it’s your fault) but enforced through a special type of block

Yes Rust is harder to write than C, that’s basically by design as it’s due to the statically guaranteed memory safety. That’s pretty magical. C doesn’t have that and neither does C++ even with smart pointers and such. Rusts unsafe keyword is poorly named, what it actually does is tell the compiler that you the programmer guarantee Rusts rules are upheld within the unsafe block.

For example

Access or modify a mutable static variable

That is a global, that’s incredibly hard to impossible to statically prove it’s safely done, so you have to do it in an unsafe block. So you violating Rusts rules within an unsafe block is actually using the unsafe block wrong. That’s not what it’s for

Unsafe Rust really just let’s you play with pointers

This is the entirety of what Unsafe Rust allows

• Dereference a raw pointer
• Call an unsafe function or method
• Access or modify a mutable static variable
• Implement an unsafe trait
• Access fields of unions

When it’s easier to think about a system in terms of objects. The classic example is video game Entities/Game Objects. GUI stuff has also been very pleasant with OOP as buttons and the like are all easily conceptualized and worked with when seen as objects.

Huh, I totally missed that my bad

Languages with GC

Oooh like a GUI designer thing. That seems pretty nifty never used one before haha

Okay so what do you actually mean by “GUI” I assumed you mean a Graphical editor IE Eclipse, Intellij, Visual Studio ect. A non GUI editor would be a terminal editor along the lines of Vim with an LSP and other such things. All out of the box IDEs are graphical in nature, that’s kind of their entire point so I can’t believe we’re talking about the same thing here.

NetBeans??? In 2024??? Intellij has a free community version which I’d recommend over literally anything else for JVM langs.

If you really do wanna swap languages (tbh I’d recommend you just stick with Java) of those choices C++ is probably the best one? Python definitely isn’t a good choice for what you want. I haven’t used dart but I’m pretty familiar with Java, Python and C++. C++ build systems are frankly very pooie. Cmake is hard to get into because it’s purpose is to generate make files which are essentially files which store a bunch of commands to run in the terminal. You can have Cmake generate stuff for ninja (recommend) but it’s still just kind of a mess. Since you want to support cross platform C++ might be a huge pain.

You could use a different JVM lang like Kotlin. If you want a compiled language you could maybe do Zig? I’m not very familiar with it outside of knowing the tool chain is much better than C++ or C. I’ll toss in the obligatory Rust mention but you’ll need to dedicate quite a lot of time and effort before you’ll be proficient. The tool chain however is fantastic.

Kinda long rambly response hopefully it’ll be helpful somehow

Rebasing shines for local commits not remote commits. IE rebase your commits onto the remote or amend the previous commit (yes that’s actually a rebase)

In other words “please dick me harder capitalism”. Right…

She’ll make all your friends nut blazingly fast