Citation needed? Where did you hear that this is a routine occurrence? That seems risky for everybody involved, and it requires a report to the government from the seller.
Because the legal system in most Western countries is set up that the seller bears liability for laundering money if they accept duffel bags of cash for a car without the same documentation a bank would require.
This is absolutely not true in the US. Are you trying to tee up one of those "the US is not a developed country" type quips that are popular around here?
A dealership may take issue with it but a private party accepts no liability by taking cash.
Firstly, I said "Western" not "developed", you need to calibrate your quip detector lest you become what you dislike.
Secondly, while it's possible to construct a private party transaction in the US where this is fine, if the person spending the duffel bag acquired the money illegally, you the seller are liable if you should have known. "Willful blindness" when accepting illegal proceeds makes you liable too. See 18 U.S.C. § 1957
Maybe I misspoke by saying you would be liable for laundering specifically, but certainly accepting that money is a crime if you have any reason to think it was ill-gotten. And that's a huge risk that no one wants to take on.
The difference, and I think we as an industry will have to reconcile this depending on how advanced llms get, is that you don’t see the quality in handmade code like you do in a high end watch or a luxury automobile or appliance. The veneer might be identical. It’s going to be tough to convince people that handmade software has added value or quality over slop. I still believe it does right now, but that might not always be true. And this is an industry that has pumped out a lot of sloppy code for decades, even before it was actual slop.
well this is not exactly unique to software. It is not a given that the 'handmade' nature of a product (luxury or otherwise) manifests in anything tangible or self-evidently superior. Luxury products in general overwhelmingly treat the crafted nature of the product as almost solely an investment in narrative (read: marketing) and market positioning, not an actual material outcome.
I like this take a lot. Posting a counter-example not because I disagree but because I think it’s interesting.
Ghostty is a terminal emulator with a pretty good narrative. The author is very accessible on podcasts to go over the story. It is also actually very good though. I think the jump in performance and usability put it on the map before the narrative could help push it further. The product does have to actually be good before the crafted nature can be invested into.
What're you talking about? I can instantly detect if software was created with AI. It has a stench much like a cheap product who's materials off gassing, and Im certainly not using it over the handmade solution. There will always be two options, like in clothes or watches.
Maybe you should take a step back and realize that sofware developers themselves are not the primary purchasers of most software. The average joe or jane purchaser doesn't have some magical AI slop detector, especially if the UI is well done.
I didnt downvote you, I cant. But I have yet to see a vibe coded project have good UI/UX. You'd be surprised how much thought and intention goes into making a great UI. An LLM simply cant, guided or unguided.
I actually predict that frontend devs and designers will become more valuable in the coming years as people (stupidly) abandon these disciplines.
Yes, many people instinctively stay away from anything microsoft (except github, typescript and npm). But the stack is solid. I’m always reminded of Stack Overflow and how they built on asp.net and like 7 servers and it scaled very well for years.
Everyone has what they like and what they’re familiar with, and for better or worse, especially for startups it’s rarely .net. But I couldn’t imagine e.g. using js instead on the back end, but that’s just me.
They are aligning more closely with the Rust 2024 model for unsafety, which requires inner annotations at the point of unsafety in addition to notation of the function (unless it is the safe-unsafe boundary) plus it imposes a requirement for a SAFETY doc notation for describing the specific invariants the caller must enforce to uphold the safety guarantees. Not terribly onerous in my opinion. I maintain a few native library wrappers on nuget, so I will have to do some updates around IntPtr usage, but this doesn’t seem like it will be terribly painful in my case. Thankfully I don’t do much marshalling. Plus you get a nifty badge on nuget for making your library safe.
The blurb toward the end about Rent/return makes me a bit nervous though. They say they’re not going full borrow checker, but rent at least sounds an awful lot like borrow to me. Details were basically non-existent though.
I guess I wonder what the end game is here though. The more they make C# like Rust with a GC, the less incentive people have to use C# except maybe to support legacy work. I am still far more comfortable in C# than Rust, and I believe C# is superior for e.g. web, but over time this advantage could be lessened quite a bit as the Rust ecosystem continues to grow.
> The blurb toward the end about Rent/return makes me a bit nervous though. They say they’re not going full borrow checker, but rent at least sounds an awful lot like borrow to me. Details were basically non-existent though.
Since they state outright that they're not going for a borrow checker, I would assume they're going for "second class references": the borrow checker is both powerful and complicated because references are first-class types: you can pass a reference as parameter, you can return a reference, and you can store a reference.
You can get a lot of the benefits (though also lose a fair amount of expressive power) if you drop the last two and only allow borrows downwards, and that is way easier to track.
Although the rent/return case doesn't even seem like a references concern, instead it's affine types which is orthogonal: after you `Return` an array to the pool, you want the array to become inaccessible to the caller (you could make the value linear, but as the text explains missing a `Return` is a safe leak it doesn't look like that's in scope). Rust mutable references are affine but you don't need references to do this...
C# already has second-class references; this is essentially what the ref keyword does. It's actually a bit more expressive than what Hoare suggests he'd have done (you can return ref structs and you can store them in other ref structs), but it doesn't have full-blown Rust-style lifetime annotations.
It's been over for years. Google scares companies into bidding against each other just to be seen. It's a complete farce & a racket. It's the pay to play web.
OS Development has halted in 1970 at this point. I know everybody loves Unix, but it has the same problem as Windows- namely that anything you run under your user context has access to your whole user context. And it will continue to be a scourge until/if we ever figure out how to make capabilities ergonomic. I've been racking my brain for 30 years to try and do it, but they just make certain things very painful.
Look at Plan 9, if you haven't. I can open a window, add/remove things from its environment (via mounting and unmounting files into that window's namespace) seal that environment to prevent changes, then launch a program.
The program can only see what is available to it via the file system. If it has no /net folder then it can't talk to the network. At all. If it has a truncated /env then it can only see a subset of the environment variables available to me, the user.
EVERYTHING being a file is ... weird. Unix has that, but Plan 9 takes about as far as it can go, which is pretty far. But that makes permissions to things quite easy, because file permissions are easy.
The other thing that Plan 9 does is that everything is a file, including your environment, mounting and unmounting things from/to your environment is how you gain/deny access to yourself and to programs.
If this permissions model was common, ransomware would have never been possible. No virus could infect your system, only its own environment (with caveats).
If you already know all of this, I apologize. If you don't, then you owe it to yourself to have a look at Plan 9. It's very weird, but once you wrap your head around it, you start seeing why some people really rave about it.
There's a channel on YouTube called "adventuresin9"[0] which has TONS of content about Plan9.
They still prioritize developers, look at .NET Core, Typescript, NPM, Github (lol), but the problem is that they're not Windows exclusive enclaves anymore. In fact, I'd bet most people now deploy (and probably develop) .NET Core on non-Windows machines.
But it doesn't take too many cash purchases that are not inline with your tax returns before somebody is going to start snooping around.
edit: although sometimes, a lot longer than one might expect.
reply