Can someone just make another MMO with the skill based combat of Tera again (Tera classic please, not what happened after the OP special classes started appearing). I keep thinking someone will repeat. But every action combat MMO hasn't come close to how combat in Tera felt to both play and master.

#TeraGotCombatRight

@dylancode have to admit, having lots of dependencies from a public repository means having to spread your trust thin. It becomes a very large attack surface.

But people seem to like to work this way, and the only real solution is to modify people's behaviour, which is, for all intents and purposes, impossible.

So all you can do is limit your own dependency use, and/or be in control of as many dependencies as possible.

@TheFox21 I mean that's not strictly true right? string literals are stored in the read only part of the binary as zero terminated strings. So the compiler is aware of the convention, it's not just a c std library thing. In fact, I would imagine, that the convention of the compiler is probably the reason why the c std library ran with it.

@profoundlynerdy I don't think #Rust is a fad language, I think it'll be around for quite some time. I also don't think #C is going anywhere either. Just like #C++ didn't kill #C, #Rust won't either.

@thomy2000 You nearly caught me with that one.

@Axman6 I just use KeePassXC. The database is local. It's open source. QT for UI. Does the job.

@mcc Personally, I just use https://cakebuild.net instead for putting together more complicated builds, and I just leave the ms build file as a convient target for getting the C# compiler to compile the right files.

@hack.imax.in.ua your function needs to return result or option. And whatever you apply ? needs to also be the same as the return. I think ? also injects a call to `into` at the very least on Err(_) items, so errors don't have to match your error type, but they do need to implement Into<YourReturnErrorType>.

@cinebox Is type inference not working when using the closures? Because I wouldn't normally bother specifying the closures argument types unless forced to.

@oscarmlage @reidrac personally, I toyed around with go back before rust release 1.0. However, once rust did go 1.0, I've been using that and haven't looked back. That's not to say I haven't used many other languages (including go) since, but if given the choice, I'd reach for rust.

> There are a few things in recent history that may have contributed to the current state of things. First, a whole army of developers writing JavaScript for the browser started self-identifying as “full-stack”, diving into server development and asynchronous code.

https://renegadeotter.com/2023/09/10/death-by-a-thousand-microservices.html

Well that made me chuckle.

@luny That's fair, if it works for you, it works for you.

@luny Huh, surprised to see sourceforge unironically.

@aburka @prma The ideal design isn't always possible to reach, either just outright or within the external constraints placed upon you.

Ultimately there's a place for panic. When it makes the most sense, use it. Don't reach for it otherwise. Especially not as a lazy way to handle normal errors.

@prma @aburka Because in such a case it's not an error that resolvable by the end user. It's an error caused by invalid programming on the part of the developer using the library and thus only resolvable by the developer. It makes little sense to treat like an error that you'd expect to either be handled later or potentially surfaced to the end user. You need to get in there and fix your usage.

@aburka @prma Disagree. Libraries should panic when you use something in a way that's clearly a developer mistake. Such as failing to maintain invariants that should have never been broken in correct usage.

@sramsay Yeah, I can understand with source organization. It's complicated by the fact there's two valid ways of doing it. (The old and the new, but both are supported and will remain so).

@sramsay Have you been pointed towards the `anyhow` crate for it's Error type that can be converted to for any error type. The `thiserror` crate for quick error type creation via derive. And the `?` operator for quick "give me the valid result or return the error"?

All together it eases working with errors in rust.

Permission can be sort after, but it should be clear, explicit, at the point in time it's required, limited in time that it's required, limited in scope and being hidden in a wordy EULA or ToS is *not* being explicit.

We really need some sort of ethical software development manifesto.

Not ethical in the sense of "how I affect the world". But ethical in "how do I treat my users".

Here's some example points I'd put on such a manifesto.

The users computer is a personal, private space. Treat it as such. Just because you can write code that gathers information about a user and their computer doesn't mean you should. Just like you shouldn't go through someone's personal belongings when you visit their house. Even when you get permission, it's usually in a very narrow sub-window rather than a free for all.

Just because you can write code that locks them out of doing something on their own machine, doesn't mean you should. It's their machine. Not yours.

If you website is running client-side code. Remember that's code running on their machine, the above statements still apply.