blub

There’s a few things happening here.

First of all, Rust is default safe. In C++ developers always trade performance for safety, in Rust they just swallow the penalty (which is often still performant enough). C++ code will often not be as memory safe as it could because someone decided to not use particular checks (like compiler-driven integer overflow checks).

Secondly, Android C++ code is not particularly high quality, also when it comes to memory safety. A lot of it is also quite old. I would consider it your average massive project, not a masterpiece coded by amazing engineers.

Thirdly, it has a massive target on its back and is under attack by pretty much everyone. They have to use whatever they can to keep up with the attackers.

Several companies have these issues and approach them in different ways. Rust is a very attractive approach for developers, since it’s just another programming language. It’s also quite ugly, people complain about its complexity and is unfortunately suffering from dependency explosion. I hope it’s a stepping stone to something better.

And yet with all that experience you’ve still managed to come up with a conclusion which describes the exact opposite way humanity evolved and currently lives.

Good luck with your revolution. :)

Yours is a good book (got both editions myself), but sadly language learning books will be hit the hardest by AI. Partly it’s what you said regarding copyright washing, but the other big reason is that people will code less; I am writing little to no golang and am prompting it instead. The book is still useful to me, since I want to continue to understand what’s happening, review code, etc, however I expect that my kind of software engineer will be in the minority in the future.

If you publish a 3rd edition and I’m not replaced by AI by then, I’ll buy it. :)

On other topics, using AI can fill some gaps, but books summarizing years of hard-won knowledge are priceless. NoStarch is amazing when it comes to such resources. They have an upcoming book on Linux kernel Memory Management for example, the classic Linux tome from Kerrisk and very specialized security books.

On the other hand I cancelled my O’Reilly sub because I didn’t read enough to make it worth the price and now I purchase DRM-free e-books individually, as needed.

In a student or IT worker bubble, countries are very similar. When one steps out, they’re going to get a rude awakening.

Culture shock is a real phenomenon.

Even if that were the case, working in a team is very different from working solo.

One of the authors commented below that the “teams” were actually persons and the Rust person was an intern.

This is even less serious than the typical pattern of grabbing random students for experiments and then drawing conclusions about the general population.

Germany has the Schufa. Should be trivial to narrow down to a specific group based on name only.

All of these didn’t prevent Go from competing with Rust and I’m guessing that Fil-C will be the better choice in some cases.

Rust has managed to establish itself as a player, but it’s only the best choice for a limited amount of projects, like some (but not all) browser code or kernel code. Go, C++, C with Fil-C) have solid advantages of their own.

To name two:

* idiomatic code is easier to write in any of these languages compared to Rust, because one can shortcut thinking about ownership. Rust idiomatic code requires it.

* less effort needed to protect from supply-chain attacks

No, UV is unrelated to your issue.

First you need to figure out if it’s a surface infestation because of condensation or if it’s a constructive thermal bridge. The latter can be solved by raising the surface (wall, ceiling, etc) temperature through insulation or more inefficiently special heaters designed for this purpose.

In both cases, the contaminated material is removed down to the plaster or masonry. Wood, wallpaper and similar materials will likely be deeply contaminated and must be removed. For areas larger than 1 sq meter, it’s better to get a specialized contractor which will use HEPA vacuum cleaners, special bags, etc to ensure that the mould spores don’t spread in other rooms.

For small areas the agents of choice are bleach or hydrogen peroxide, both available in products for home use.

Was it from flooding or how did it get there? How did you detect it?

ZoneAlarm, assuming it still exists, would be at least 20 years old.

Back then there was also a nice ~$15 program called Net Limiter which allowed one to cap network speeds individually per program.

The web and web apps as pushed by Google and others was another nail in the coffin of efficient software.

From Android to whatever web framework they’re peddling as development solutions, these are not designed for efficiency, but for time-to-market and consumption by front-end developers.

I worked on Windows programs similar to WinAmp, which had custom drawing, skins with custom shapes, etc. Usually written directly in WinAPI, VCL (C++ Builder, not Delphi) or a combination.

It was a matter of having access to the right (although limited) resources such as Petzold’s book, Codeproject and experimentation. There was no big rush, no start-up hustler mentality and most importantly hardware resources mattered a lot and it was a point of pride to create efficient software.

The development culture of present time is the opposite of that: developers are drowning in documentation, the default solution is technically inferior and the hustler mentality’s dominating.

A good rule of thumb for programming languages is to check what the general recommendation is on HN and do the opposite.

Using win32 from Rust is nonsensical. This is the kind of use-one-tool-for-any-job Visual Basic 6 programmers used to have, except VB6 would have actually been much better than Rust at Windows programming.

It’s certainly doable, but not as nice and easy as Delphi or Qt, which are WYSIWYG.

Of course, if one is a web developer, even attempting such a feat this could result in a brain-melting experience.

That’s genuinely nice that it doesn’t have the multimedia crap. They do also have an “extreme” model with touchscreen and connected services. At ~220km range it probably has about 100km in winter though. :-/

The UN has released a report on human rights abuses in China, but has not called these a genocide. The more credible accusations of genocide came from a handful of political bodies in Western countries, but crucially the acting governments have not defined it as such.

There’s absolutely no consensus that the legal definition is met, in contrast with another ongoing situation which enjoys wide recognition.

It feels that this is more a geopolitical cudgel, pulled out when the discourse against the US becomes negative. But given the events in the last years, this seems like a lost cause even in the West, never-mind the rest of the world.

This is less about languages and more about so-called AI. One thing’s for sure: it’s becoming harder and harder to deny that agentic coding is revolutionizing software development.

We’re at the point where a solid test suite and a high-quality agent can achieve impressive results in the hands of a competent coder. Yes, it will still screw up, needs careful human review and steering, etc, but there is a tangible productivity improvement. I don’t think it makes sense putting numbers on it, but for many tasks, it looks like there’s a tangible benefit.

I feel similar about the potential of this technique and have heard this from other C++ developers too.

Rust syntax is a PITA and investing a lot of effort in the language doesn’t seem worth the trouble for an experienced C++ developer, but with AI learning, porting and maintenance all become more accessible. It’s possible to integrate Rust in an existing codebase or write subparts of larger C++ projects in Rust where it makes sense.

I was recently involved in an AI porting effort, but using different languages and the results were fine. Validating and reviewing the code took longer than writing it.

The apparently widespread enthusiasm for spyware on wheels (a category in which Tesla also competes) is sobering.

Many customers really only care about price and that it generally works and looks fine and have zero idea about the hidden costs.

Losing connectivity is a non-issue because it will come back soon enough absent some global event. The realistic risks are rather:

* all services are run at a loss and they increase price to the point the corp doesn’t want to pay for everyone any more.

* it turns out that our chats are used for corporate espionage and the corps get spooked and cut access

* some dispute between EU and US happens and they cut our access.

The solution’s having EU and local models.

I had already said it’s a PR piece, you’re merely rephrasing that and making it sound like a good thing.

This and the Google blogs offer zero technical insights and I haven’t learned anything from any of them.

The dependency management and complexity/poor ergonomics are the two major technical problems with Rust. Normally the first one’s ignored while the second is downplayed, so it would have been interesting to see what (if anything) Facebook have done about them.

Not only can AIs help, but they can write most if not all the code and spare the human from learning all the intricacies of individual programming languages. Problem is, reports are contradictory on compatibility with Rust. We know they work great with simpler/friendlier languages like Go or Python.

Just like Google’s Rust-in-Android blogs this reads like a PR piece (and in the case of facebook also recruitment piece) with some technical words sprinkled in for effect. The overall communication quality is that of a random startup’s “look what we did” posts.

The interesting aspects, such as how they protect against supply-chain attacks from the dependency-happy rust toolchain or how they integrated the C++ code with the Rust code on so many platforms - a top challenge as they said - remain a mystery.

Would also be interesting to hear how much AI-driven development they used for this project. My hope’s that AI gets really good at Rust so one doesn’t have to directly interact with the unergonomic syntax.

> I'm trying really hard to buy European made products and to use European services where possible.

European companies are trying even harder to outsource to China.

In the past months I’ve seen an increase and it feels like almost everything is made in China, from books to Christmas trinkets to clothes and kitchen utensils, it’s a pain the ass to find locally produced goods.

This has a lot to do with the energy crisis triggered by decoupling from Russia, which was never properly put into context and evaluated from an economical perspective.

QtBase is C++ first of all.

Massive projects like Qt also push compilers to their limits and use various compiler-specific and platform-specific techniques which might appear as bugs to Fil-C.

(Not the OP)

For many years, all the projects I’ve been in had mandatory code review, some in the form of PRs (a github fabrication), most as review requests in other tooling.

This applies to everything from platform code, configuration, tooling to production software.

Inside a component, we use review to share knowledge about how something was implemented and reach consensus on the implementation details. Depending on developer skill level, this catches style, design issues or even bugs. For skilled developers, it’s usually comments on code-to-architecture mismatches, understandability, etc. Sometimes not entirely objective things, that nevertheless contribute to developing and maintaining a team consensus and style. Discussions also happen outside and before review, but we’ve found reviews invaluable.

If a team has yearly turnover or different skill levels (typical for most teams), not reviewing every commit is sloppy. Which has an additional meaning now with AI slop :)

Doing a vehicle check-up is a pretty normal thing to do, although in my case the mandatory (EU law) periodic ones are happening often enough that I generally don’t have to schedule something out of turn.

The few times I did go to a shop and ask for a check-up they didn’t find anything. Just an anecdote.

There was an interesting video on YT where an engineer from a fastener company joined a carpenter to compare their products with traditional joints.

The traditional joints held up very well and even beat the engineered connectors in some cases. Additionally one must be careful with screws and fasteners: if they’re not used according to spec, they may be significantly weaker than expected. The presented screws had to be driven in diagonally from multiple positions to reach the specified strength; driving them straight in, as the average DIYer would, would have resulted in a weak joint.

Glue is typically used in traditional joinery, so less glue would actually have a negative effect.

Google have published a couple high-level Rust blog posts with many graphs and claims, but no raw data or proofs, so they haven’t demonstrated anything.

By now their claims keep popping up in Rust discussion threads without any critical evaluation, so this whole communication is better understood as a marketing effort and not a technical analysis.