HN user
Step 1: download windows media tool
Step 2: create iso with said tool
Step 3: use rufus to make iso into bootable usb with the installation options you want
Step 4: reformat & install
Step 5: Drivers
Step 6: chrome and/or firefox
Step 7: o365
???
Profit
There’s a reason people say don’t meet your heroes.
No matter how elevated they are in your mind, they’re still just people. One pants leg at a time and all.
Ah yes, the lulz, the great American pastime.
Yes, duffel bags full.
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.
Maybe not the actual quality, but if I put a $50k Rolex on the table and a $50 Timex, 98/100 people will choose the Rolex, right or wrong.
Wow. At least I know who downvoted me.
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.
One of my favorite phrases is “the market can stay irrational longer than you can stay solvent.”
Even if all signs point to impending doom, at the end of the day if people are still buying, stocks will hold their value.
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.
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.
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.
That's ironic given the active 0-day exploits going on in the wild right now: https://www.theregister.com/on-prem/2026/05/15/exploited-exc...
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.
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.
What good does A/B testing do if both options are shit?
I share the sentiment unless you're working in an area where Python's library ecosystem is simply the better choice.
When I vibe, it's C# all the way. Not a popular opinion on HN, but the LLMs are trained heavily on the language and are very, very good at it, plus with the 1-file-per-class organization, it can stay pretty clean. I mean, v10 LTS was just released, with all kinds of new language features, EFCore is still the best ORM I've ever used, with full support for SQLite, Postgres, MySql, etc. It just makes writing and reviewing code a pleasure. And the LLMs don't f*ck it up.
You would think that, but PDF is not really a format for text. It's a format that describes typography and graphics layout & formatting. It's not uncommon for a text pdf to not contain all of the text it renders (due to ligatures).
I think you misunderstood. My comment was meant to imply that people would be extra careful about all new software for a while. I know cpanel isn't unproven. It's been around forever.
This flurry of activity is certainly going to have people be more apprehensive about unproven software that may be of dubious prominence. My question amid all of this is who else knew about these long-standing vulnerabilities?
I quit for 9 years and went back to drinking. I do it once every few months now, just to have a beer or three with old friends. But I didn't get dragged back in, in fact, it's been 2 months since I drank again. Just had to learn to live my life without it.
I agree. .NET is the opposite of Go. Calls to System.Random use Xoshiro128++ under the hood (as of .NET 6 I believe). On the other hand, calls to RandomNumberGenerator.GetBytes() are cryptographically secure, using the Windows kernel cryptographic provider on Windows and /dev/urandom (chacha20) on Linux and arc4random_buf() on MacOS (which also uses chacha20 under the hood).
I ported around 20 RNGs to C# (all non-cs), and there are tons of uses for non-cryptographic RNGs, so I'm a little torn. I guess in modern development most people who need an RNG need it for crypto purposes (I would guess salts, keys and nonces mostly), but I'd hate to see all the Xoshiros, Mersenne Twisters, PCGs, and MWCs, etc. go the way of the dodo simply because they are not deemed fit for crypto purposes. Games, simulations, non-cryptographic hashes all need deterministic and high performance RNGs, and don't need all of the cryptographic guarantees.
To top it off, there is no standard definition of what makes an RNG cryptographically secure, so it's a slightly loaded question anyway. Everything I've read says an algo needs the following properties: forward secrecy (unable to guess future outputs given the current state), backward secrecy (if I know current outputs, I shouldn't be able to recover previous internal state or previous outputs), and the output must be indistinguishable from true random bits, even with a chosen-input attack. This is where I politely defer to the expert mathematicians and cryptographers, because I'm not equipped to perform such an analysis.
I can understand why things have developed this way though- people have needed random numbers far longer than they've needed cryptographically secure random numbers, so the default is the non-cryptographically secure variant. A language created tomorrow would likely follow in Go's footsteps and default to the cryptographically secure.
LINQ? Just throwing it out there; obviously not everybody can or wants to run a C#/.NET stack, but entity framework (core) is about as close as you can get to the perl and regex integration. I think Ruby on Rails gets there too, but I'm not a RoR guy, so I can't comment.
This is disappointing. 4o has been performing great for me, and now I see I only have access to the 5-level models. Already it's not as good. More verbose with technical wording, but it adds very little to what I'm using GPT for.
I hear this a lot, and I do seem to remember back when I first got Windows 11 I might have seen something stupid like Candy Crush, but I'll be honest, I literally never see ads anywhere in the OS. Truth be told I hardly ever use the start menu since they ruined it, but this complaint about ads everywhere make it sound like a typical webpage. I just don't see it. Maybe because I'm on Win11 Pro?
Nice job. Impressive.
If I had to guess, probably a couple hundred lines a day, maybe more if I get in a groove or have a deadline.
But with an LLM, that number goes to about 500 or so, 200 of which are real code and not definitions of some kind. Truthfully, that’s where the LLMs shine. I have this enum with 50 variants, and need to build a dictionary (with further constraints and more complex objects). That shit takes forever even with cut & paste, unless you code with code, and those one-offs aren’t my cup of tea anymore.
I am in the middle of my third AI assisted project. I disagree ~90%.
If you prompt an LLM like an architect and feed it code rather than expecting it to write your code, both ChatGPT 4o and Claude 3.7 Sonnet do a great job. Do they mess up? Regularly. But the key is to guide the LLM and not let the LLM guide you, otherwise you'll end up in purgatory.
It takes some time to get used to what types of prompts work. Remember, LLMs are just tools; used in a naive way, they can be a drain, but used effectively they can be great. The typing speed alone is something I could never match.
But just like anything, you have to know what you're doing. Don't go slapping together a bunch of source files that they spit out. Be specific, be firm, tell it what to review first, what's important and what is not. Mention specific algorithms. Detail exactly how you want something to fit together, or describe shortcomings or pitfalls. I'll be damned if they don't get it most of the time.
I make that mistake more often than I care to, but you are 100% spot-on. They are sum types, not product types. Thank you for making me walk the walk of shame!
Having reviewed the proposal (of course no guarantee that's what discriminated unions (aka product types aka algebraic data types) will look like), and it appears that it very much integrates nicely with the language.
I don't suspect they'll make too many changes (if any) to the existing standard library itself, but rather will put functions into their own sub-namespace moving forward like they did with concurrent containers and the like.
Given their penchant for backwards compatibility, I think old code is safe. Will it create a schism? In some codebases, sure. Folks always want to eat the freshest meat. But if they do it in a non-obtrusive way, it could integrate nicely. It reminds me of tuples, which had a similar expansion of capabilities, but the integration went pretty well.
It has been in discussion for quite some time. I believe they'll get there soon: (example) https://dev.to/canro91/it-seems-the-c-team-is-finally-consid...
In the interim, MS demonstrates how C# 8.0+ can fake it pretty well with recursive pattern matching: https://learn.microsoft.com/en-us/dotnet/csharp/language-ref...
Not the same I know, and I would love me a true ADT in C#.
Edit (a formal proposal): https://github.com/dotnet/csharplang/blob/18a527bcc1f0bdaf54...