philm

It's less the job post, more the implication, that they consider Rust to be better than (their internally developed) C# for one of their major products. And that I think is worth news (as it could further drive towards adoption of Rust in general).

Easy, it's just... continue programming in python. (large codebases are a mess in python...)

More seriously: Don't do that, it'll only create headaches for your fellow colleagues and will not really hit those (hard) that likely deserve this.

And yet, he's using the mouse and an Apple keyboard.

Where's mech-vim-hacker-typer-power?

I'm very split between Github (currently) providing a really nice interface/collection/way to access all kinds of open source projects and the obvious 'out-of-control centralisation' by the mega corp Microsoft.

It definitely got a little bit bloated the last years, but I still think it has a generally nice interface (browse code/review stuff, simple issue/PR system, simple way for CI via actions etc.).

But I really hope something like https://forgefed.org/ takes off someday, I feel like if the barriers are much lower to get onto a different network with the same user (without registering etc.) decentralisation can lead to more innovation in this space (management of all the stuff that Git doesn't manage itself, like issues, PRs etc.).

The beauty of Git though is that it's decentralized, so you can just mirror it on Github while mainly using a different platform. If you want a bigger userbase interacting/contributing with your project you'll allow PRs and issues there and if not just add a link to the README that points to the platform you're using...

Yep use a little bit more deeply cascaded generic rust code with a lot of fancy trait-bounds and error messages will explode and be similar as C++ (though to be fair they are still likely way more helpful than C++ template based error messages). Really hope that the compiler/error devs will improve in this area

On another look, though, we have to keep in mind, though that this is code-golf, so in no way representative for actual code-bases.

Is this a hard error? Like it doesn't compile at all?

Isn't there something like #[allow(unused)] in Rust you can put over the declaration?

(Nor anything else...)

Is most software getting worse?

Fixed for ya.

Yeah, but unironic...

If your code needs comments, it's either because it's unnecessarily complex/convoluted, or because there's more thought in it (e.g. complex mathematic operations, or edge-cases etc.). Comments just often don't age well IME, and when people are "forced" to read the (hopefully readable) code, they will more likely understand what is really happening, and the relevant design decisions.

Good video I really recommend: https://www.youtube.com/watch?v=Bf7vDBBOBUA

Don't get me wrong comments != documentation (e.g. doc-comments above function/method).

I probably was a bit unprecise, as others here summed up well, it's the why that should be commented.

Hmm interesting, I would've thought that Haskell would rank much higher

Calckey/Firefish

Much more beautiful than mastodon IMHO

Thanks for the info about the other projects.

Wow I pretty much disagree with everything you said haha. E.g. packaging/venv in python is absolute hell compared to something like cargo/crates in Rust. Try to manage a large project in python and you'll likely revise your answer (if you actually know all the nice alternatives out there...)

Until the competition isn't as shitty and doubles the salary ¯\_(ツ)_/¯

That only really works, if the method is self-contained, and written in a language that GPT has seen often (such as python). I stopped using it, because for 1 in 10 successful tries I waste time for the other 9 tries...

At this point, I think it's almost mainstream, and it's still growing fast (and it's getting better, rust-analyzer is really awesome these days, I was there at the beginning, no comparison to today...))

I may be biased, but I think it'll be the next big main language probably leaving other very popular ones behind it in the coming decade (Entry barrier and ease of use got much better over the last couple years, and the future sounds exciting with stuff like this)

I mean if you have a super nice working environment (team etc.), I don't see an issue with staying at the company.

But yeah as you say, if the new company is better in every single way, of course you should move.

Ah the good old times with C, when things were much more simple (but unsafe...)

// This enters the if branch if "myVar" == true
while otherVar == 42 {
    // do something
}

Yeah I have the feeling that sign-up should probably default to be manually moderated, to avoid a bot-swarm taking over accounts (and well probably a lot of bot instances need to be blacklisted then as well).

I'm not sure how dirty the game of big social media is/will be, but if they really feel threatened, they may start something like that (might make sense to be legally secured in that case...).

Yeah absolutely I quickly get bored playing a computer game or something, but I just love coding (in Rust obviously ^^), creating new things etc.

For reference, I think you want something like this: https://forgefed.org/

I agree with the other comment. It's Open source after all, they could've just crawled the web otherwise.

Private repos on the other hand is a different story.

yeah as nice as it is what you can achieve with trait-bounds there are definitely trade-offs, being compile time and error messages, and sometimes mental complexity, understanding what the trait-bounds exactly mean... I really hope, that this area gets improvement on at least the error-messages and compile time (incremental cached type-checking via something like salsa)

Yeah the whole situation is a little bit fucked, Google has too much power (over Mozilla) and browser engines in general. But I'm optimistic about the open source community, e.g. brave integrates their own ublock compatible rewrite (in Rust ^^) into chromium. So I think sooner or later there are patched/forked chromiums and if Mozilla indeed makes the move towards WebDRM then also Firefox forks.

I really hope servo under the umbrella of the Linux Foundation proves to be a viable alternative in the future, that's a little bit more independent than Firefox.

I’d be hesitant to suggest it for most backend application just due to the ramp up time for new developers.

I would probably suggest Rust for that exact reason, you'll have to fight the language a little bit at the beginning (at least if you'll have a very "interior mutable" experience instead of a functional background), but it teaches you how to write your code in a nicely relatively uniform compositional safe style, that IMHO can be read quite well between different people (team) and I think is easier to review (as long as it's not some super magic trait-heavy/proc-macro code of course, but I think for actual applications (vs libraries) that part will be rather low)

Also I think nowadays the barrier into the language is much lower than it was a few years ago. The tooling, specifically rust-analyzer (and probably Intellij Rust too, never tried it though) and the compiler itself got really good in the meantime (I actually think Rust-analyzer is by now the best LSP for any language I know of), so that getting into Rust is likely not that hard anymore (you'll have to learn/understand a few concepts though, like heap/stack and the lifetime system, but I think that it's not that hard to learn).

Go just often feels very hacky to write with a lot of quirky things like handling errors, and a lot of missing features like pattern matching or a relatively good type system, I don't think it really promotes that nice architectures (or limits the programmer kinda).

Hmm pretty sure, it's not vim, as that would be u and C-r

People use the most convenient way to collaborate, and that's for me currently Github. Really hope, some day a better alternative with ForgeFed becomes reality.

but effectively it's bash, I think /bin/sh is a symlink to bash on every system I know of...

Edit: I feel corrected, thanks for the information, all the systems I used, had a symlink to bash. Also it was not intended to recommend using bash functionality when having a shebang !#/bin/sh. As someone other pointed out, recommendation would be #!/usr/bin/env bash, or !#/bin/sh if you know that you're not using bash specific functionality.

Yet it still feels sloppy (and I couldn't find why to the defense of Jerboa, I skimmed through the relevant code but couldn't find immediate issues and there's an open issue: https://github.com/dessalines/jerboa/issues/445)

I don't get why, with so much hardware power we still have these issues...

And yet I wouldn't touch C nowadays if I can avoid it anyhow. Zig (simple low level) and Rust (where e.g. C++ would be used, and for large higher level projects, as it really composes nicely) are IMHO the way modern systems programming is done

$0.7k annually? Is it anyhow possible to live with that low salary in India? I can't even live a month with that here, even if I don't buy anything but the cheapest food and live in the smallest apartments here...

I can think of maybe 1 or 2 places where inheritance makes sense, and I haven't encountered these in the last 5 years... (not counting implementing interfaces of course, which definitely makes sense). In all other cases inheritance is IMHO a bad decision (why I think it should not be a thing in programming languages, because it leads someone to write bad code, as it seemed to be the right thing to do...).

Yeah works well, as long as the code is rather simple and it occurred rather often in the training set. But I seldom use it currently (got a little bit more complex stuff going on). It's good though to find new stuff (as it often introduces a new library I haven't known yet). But actual code... I'm writing myself (tried it often, and the quality just isn't there... and I think it even got worse over the last couple of months as also studies suggest)

Drew Devault’s Hare language

Ok, they say "use your distros package-manager", that's basically asking for the same disaster as C or C++. I think cargo is one of the selling points of Rust.

At least say something like we use "Nix" for default package-management (which does a lot of things right)...

Zig > Rust because actually writing safe Rust code

Start thinking more functional, I rarely have issues with the borrow-checker, or even have to write unsafe. But it obviously depends on the context, when the issue at hand really requires a lot of interior mutability or unsafe can be pain.

I'm also super fast nowadays with Rust, probably faster than with any other language (thanks to great tooling?).

.copy()?

Yeah, this is the way how to interact with it. It makes sense as well, because it's only predicting the next word based on the previous words, so it had can in hindsight find a lot more stuff and in general be smarter about it.

So cancer + a different form of cancer = ...?

I really don't get why you want an editor to be based on DOM, it feels just like sluggish ... cancer...