Non profits do have corporate leeches too. The executives at Mozilla have executive salaries. That is, hundreds of thousands, or millions.
They don’t work out of the goodness of their hearts. And Mozilla has to find a way to earn the income to pay their bloated salaries.
Meanwhile game studios make profit and still lay off their employees.
And that’s why lunch should be paid if it’s inside the workday.
I thought teflon being long is what made it safe. It’s the smaller molecules used in the process of making the long Teflon that are bad.
I learned python with it back in the day. However, since then, python 3 has come out. And I believe their python 3 course is paid instead of free.
You can go through one of their free courses. If you like it, go for a paid one, if you don’t, search for other resources.
It is not propaganda as it is factual information. If you believe this is 4D chess from Google to manipulate us to dislike Firefox you are out of your mind. https://github.com/mozilla/bedrock/commit/d459addab846d8144b61939b7f4310eb80c5470e this is an actual commit made by mozilla. It was not made by Google.
Changes include:
That to me indicates one of the following:
I don’t like either of those alternatives.
I don’t know if they are able to sell the data you mentioned. Because I’m not in the enshittification minds of giant American corporations. 20 years ago people would laugh at the idea of buying data about the screen size of a user. But now they do, and use it for fingerprinting. If recent history has shown anything is that most data has some kind of value. And giant corporations will find their way to use that data against users.
I’ve seen way too many companies that were supposed to be the cool kids and were doing everything morally enshittify. There’s no reason to believe Mozilla is going to be different. They’re showing the same signs.
You probably missed the news. But Firefox is becoming a data seller too.
Recently they updated their policies, since they are on GitHub you can see the exact changes.
One of them was the elimination of a phrase like “we won’t sell your data, and that’s a promise”. So promise broken I guess.
Simplicity is easy to pirate though.
If the product is a program that executes 100% of its functionality on your computer, it is impossible to make it pirate-proof. Even if all the functionality is client-side and the server is used only for authentication, it can be pirated.
The only way to make a program pirate-proof is if it runs on the server with a thin client.
That being said, some products execute on the client. Therefore if they want to prevent piracy, the only thing they can do is security through obscurity. That is, make it as complex as possible so the pirates take as much time as possible to reverse-engineer it.
With your definition this conversation doesn’t make sense though. Since rust’s direct array access doesn’t perform bounds checks when building in release mode. And it doesn’t require using unsafe.
As I said, I don’t consider going out of bounds of a buffer a memory safety issue. Forcing the programmer to handle an out-of-bounds case every time there is an array access can be incredibly tedious. So much that not even rust forces you to do so. And if that language has iterators, it’s even less of an issue.
I consider out-of-bounds array access to same as casting a pointer to another type. Just because a language lets you do it, it doesn’t mean that it is not memory safe. It is a performance feature, since checking the bounds every time is always possible (and incredibly easy to implement), but also with too big of an impact when you could just check the length once per loop instead of per loop iteration.
How can you not have memory-safety while also having a garbage collector?
Garbage collection means that all objects live as long as you have a reference to it. Which means that you can only dereference a pointer to invalid memory if you willingly create an invalid pointer, or reinterpret the type of one pointer into another. Going out of bounds of an array counts as the first case.
If a language has garbage collection but no compiler/interpreter supports it, then the language doesn’t have garbage collection.
Null safety and memory safety are different features.
Null safety means that you cannot access a struct’s fields without first checking if the pointer to that struct isn’t null. And this must be a compile-time check.
Memory safety means that you cannot read or write to/from memory that has been free-ed. Without leaks ofc, otherwise it would be very easy.
I kinda disagree. The reason rust caught on is because it is much safer than C++ while having the same or even better performance. And in some contexts, being garbage collected means bad performance.
Before rust you could either have a fast language (C/C++) or a memory safe language (any other language. That is, languages with garbage collector). But if you required memory safety and peak performance, there wasn’t any option.
Yes, the reason that rust is both memory safe and fast is because it has a borrow checker. But the borrow checker is the means, not the end.
Boeing is famous for enshittifying its part manufacturers. Even if it wasn’t manufactured by boing, if it is in a boing plane chances are that boing pressured them to make it faster/for cheaper. Which is what leads to all these plane failures.
What are you gonna do? Lose the boing contract and be out of work? Or sacrifice quality to meet boing’s demands? This is the only possible outcome.
Your library has dedicated parking?
It is not. App X creates image A with location data.
App Y without location permission accesses image A in read mode. Now image A has no location.
You open image A again from app X and the location is no longer there. It makes no sense. Had app Y written to image A, it makes sense that location data was stripped. But opening a file in read mode should not alter it. Except for metadata of the kind “last opened at …”.
Traffic circles are not real roundabouts. They are just a road that have a circle shape. For example traffic circles often have traffic lights.
Roundabouts are traffic circles. But they have to be just a circle with “give way” at the entrance. No stop signs, no traffic lights.
Ah my bad. The original post was per month but the comment I replied to was per year. I assumed it was per month too.
So it would be 3k/year.
Yeah, that’s definitely not a lot.
That’s a shit ton of money for someone that is “broke and desperate”. This is from a European cost of living PoV. In india it is probably a shitton of money
EDIT: this comment is wrong. See responses below.
Rust doesn’t have “safe” and “unsafe” modes in the sense your comment alludes to.
You can just do the little unsafe thing in a function that guarantees its safety, and then the rest of the code is safe.
For example, using C functions from rust is unsafe, but most of the time a simple wrapper can be made safe.
Example C function:
int arraysum(const int *array, int length) { int sum = 0; while (length > 0) { sum += *array; array++; length--; } }In rust, you can call that function safely by just wrapping it with a function that makes sure that
lengthis always the size ofarray. Such as:fn rust_arraysum(array: Vec<i32>) -> i32 { unsafe{ arraysum(array.as_ptr(), array.len() as i32)} }Even though
unsafeis used, it is perfectly safe to do so. And now we can callrust_arraysumwithout entering “unsafe mode”You could do similar wrappers if you want to write your embedded code. Where only a fraction of the code is potentially unsafe.
And even in unsafe blocks, you don’t disable all of the rust checks.