TehPers

Work on open source projects, especially those that people use. Show that you can take user feedback and turn it into features. Show that you can work with others as a team on a large project.

Those will look the best.

As your southern neighbor, in skilled fields, the last thing you want is companies to outsource their skilled labor to other countries instead of bringing immigrants to your country to work there since they can create jobs, and if their position becomes vacant again, it’s still in your country. In unskilled jobs, when you decide to kick them out of your country, you’re left with a lot of vacant jobs that nobody wants to take.

The real issue is rampant exploitation of immigrants. With fair wages, you actually favor non-immigrants because of the additional costs associated with relocating someone from another country. When you’re unfairly exploiting them, the upfront cost becomes less relevant.

Anyway, I agree that getting into freelancing is going to be a nightmare. Trying to convince skilled devs that LLMs generate garbage in bulk is already difficult enough. Doing that to a non-dev manager is practically impossible.

Probably people reading the title and not the body.

id like to investigate about rewriting my “decentralized p2p encrypted messaging app” in Rust. if you are familiar with any of the details, id like to hear your opnions on the approach.

For learning purposes? If you actually intend to create a service people are supposed to use, then use something that already exists like Matrix or Signal. No encryption is secure if it isn’t peer reviewed and extensively tested.

If it’s just for personal learning, then that doesn’t matter.

the core reason behind investigating rust is that it has better tooling for things like formal-verification.

You can do formal verification in any language, but it’s mostly used for languages with certified compilers (and you’d have to use one of those compilers). For that, you’d want to look at something like Ferrocene, but that costs money.

Instead, the core reason behind using Rust should be the ability to use constant-time algorithms. This can help defend against timing attacks.

Rust also has a great crypto ecosystem, so a lot of the tools you’ll want are already built for you. Use them.

things like audits and formal-proofs/verification are fundamentally invalid because i used AI to create it.

Correct. An audit depends on someone’s reputation, and formal verification requires review.

Anyway, learning Rust will take some time. For backend, the ecosystem goto is usually axum, and Rust has a built-in TCP client/server but you might want to see what tokio offers if you’re using async.

There are a few tools out there that can recommend improvements to grammar. For example, a tool might suggest rewriting:

Benchmarks are a tool to validate a list of things, contrast, page load, images using modern formats, dead links, time to first paint, and semantic HTML, a <button> isn’t a <div>.

to:

Benchmarks are a tool to validate a list of things: contrast, page load, images use modern formats, dead links, time to first paint, and semantic HTML (i.e. a <button> isn’t a <div>).

Many of them are now LLM-based, so you could probably just ask a locally-running Qwen3.5 or something for advice as well. Just be careful if you do this to constrain it only to grammar suggestions and not allow it to rewrite your article (LLM-speak is easy to spot).

All feedback in the post is welcome.

Would it be rude to recommend a grammar checker? The topic and supporting arguments for the post are fine (if a little disorganized, but that’s common for blog posts). I just found the run-ons a bit distracting.

Otherwise, I agree that the internet is getting shittier. More ads, more walls to defend against scraping, less accessibility, etc. There’s no real metric for how well a page presents its contents, only metrics for specific things like load times, layout shift, and so on. I also suspect that, over time, page scoring will shift toward which sites present the data in ways that are more usable by LLMs.

This is a very pedantic complaint. Given that you haven’t read past the first sentence, I’m not really sure what to discuss here.

“Smart pointer” is commonly used to refer to reference-counted pointers that free automatically.

While interesting, this entire article works with a static MyStruct. This means the type already is Any, and if you define MyTrait: 'static, then you can do the downcast by first casting to an Arc<dyn Any> and using one of the downcast methods.

For non-'static types, downcasting soundly is incredibly difficult. You need to somehow get the correct lifetime back from the trait. You’re better off using unsafe at that point anyway. If the trait itself holds the lifetime (impl<'a> MyTrait<'a> for MyStruct<'a>), then that can help with it, though I’m not really sure how lifetime variance plays into the soundness of a downcast here.

Finally, at the end, I’d rather just use an assert! over an unchecked assertion. I know the goal is to look at the assembly with that assertion in place, so it makes sense why they used it here. In practice, an actual assertion is a lot better because the compiler gets the same information from it and you get validation at runtime that the information is correct.

Anyway, great article! The goal was to explore how Arc casting works, and I think it does a great job at showing and explaining that.

SQLite allows for more efficient querying of data than doing it by hand, can enforce constraints on the data, and I can query it from my shell.

Of course it’s not going to replace a commonly-used format for a domain. If no such format exists, it’s a perfectly acceptable data format for data that’s tabular in nature. And it can by sync’d/backed up the same as any other file.

I don’t know why it’s worth arguing (both of you) over the versioning scheme of a LLM-assisted/generated project that was posted by a new user with no other activity, but anyway…

PyPi (and Python) do not require semver, nor do all packages in the ecosystem use semver. However, Python tooling depends on packagers following a semver-esque versioning scheme while still allowing some freedom to maintainers to pick a scheme that works best for them.

One.

The recent news was about network traffic, not market share. Anyone talking about increased market share is making up their own conclusions from the data.

The data is interesting, but not sufficient for that kind of conclusion.

Edit: other market share articles are interesting if they actually show new data and aren’t making up a conclusion.

Code shows signs of LLM use, in case anyone’s curious. Unless, of course, you normally type em dashes in your documentation I suppose.

Anyway, this feels to me like a small part of what is essentially a durable task framework. If you need atomicity and durability, consider one of those. If all you need is atomicity, a database guarantees it through so many methods, from inserts to locks*.

*Edit: and transactions, of course, but long running transactions aren’t usually a good idea.

To answer the question posed in the title: if you’re processing images given to you by strangers, you should normalize RGB values by 255.

The author isn’t advocating for you to do so. They are just exploring the two approaches. Even in the sentences following this one where they mention where 256 might work, they conclude with your colleagues breaking it all anyway by using 255.

Sure, Mexico has its problems, but I wouldn’t dare classify a whole country of people as stupid.

And Canada?

I would guess it’s a lot of people finding out the price of the Steam Machine ($1049 with no controller is a lot!) and deciding instead to run Linux on a PC instead

If this were the case, then they’d be zipping through the waitlist. I’ve been waitlisted since release (with the small hope that prices come down by the time it’s my turn, otherwise I’ll most likely give up my spot lol) and I’ve seen no emails about it since then.

They have been selling them, but they are also struggling to get RAM allocation. My guess is that they are being held back by RAM (and possibly storage to a lesser extent) and aren’t able to make them fast enough to satisfy the current demand.

Many tech influencers have been advocating Linux due to how bad Windows is and how great Linux is at this point. I’d expect most growth to be coming from there.

The Cloudflare chart would probably be pretty representative given how much traffic goes through it.

1 million line PR? LGTM

I don’t understand specifically the copyright issue with respect to “trained on x data”

It’s a question of whether the output of the LLM is a derivative work of the training data. From a copyright standpoint, if the work is derivative (and not fair use), then it needs to follow the terms set by any licenses you have to its parent works.

Stabilize yeet.