pron

18 ms·

181.
by pron 4mo ago
In every user-mode thread or stackless coroutine (async/await) implementation I know, the construct is pinned (i.e. can't be preempted) while there's a foreign frame on the stack. There is no advantage to either design on t
182.
by pron 4mo ago
.NET do what they do because they believe many people like it, and we do what we do because we believe many people like it. Because different developers like different things, we may both be right. The only explanation to why we do what we
183.
by pron 4mo ago
> including providing less control and making interop a pain This is true in some languages but not in Java. The limitations (and performance cost) are not from the nature of continuations/stackful coroutines/"colourless
184.
by pron 4mo ago
Except we like delivering features by pieces, so unless your proposal is to first deliver global flags with no instance-specific control and later add more control (and I think you're not suggesting that), I don't see any differen
185.
by pron 4mo ago
> the syntax proposed in the Null-Restricted Value Class Types JEP is a major step backwards. Forcing exclamation marks into every variable and parameter is a lot of annoying noise that quite simply nobody will do. The default should be
186.
by pron 4mo ago
I think user-mode threads are better when the language already has threads . I'm not sure they would have been better for JS. But yeah, this one is probably less controversial than things like properties and extension members, which w
187.
by pron 4mo ago
I have no idea about MySQL, but what I always remind people is that HN is more GQ/Vogue than the NYT. It focuses on novelty and aspiration more than on coverage of what the industry is actually doing. Like others, I enjoy it because
188.
by pron 4mo ago
> Didn't they just get finished talking about how heap flattening won't work for objects with > 64-bit representations In this initial commit. As was made clear in the JEP, this is just the first deliverable of a huge featur
189.
by pron 4mo ago
Yes, but it comes from Java having both runtime and compile-time types; it's harder to make the distinction in languages that don't have runtime types. In Java, you can ask, `x instanceof T` (and this is a runtime test), which mea
190.
by pron 4mo ago
What's funny is that the only languages in the same popularity league as Java are Python and JS/TS (and possibly C and C++ if you want to extend things to more domains) yet I rarely ever hear people saying Java should be more like
191.
by pron 4mo ago
> int is not nullable and Integer is nullable, and they are thus different types under the hood Yes and no, because in Java we have runtime types and compile-time types. The frontend compiler will treat these types as having different de
192.
by pron 4mo ago
That's not quite how it works in Valhalla. Because Integer and int already exists, your declarations above will be interpreted with those meanings, but (assuming some TBD nullability annotation), they will be equivalent to `int? x` and
193.
by pron 4mo ago
I didn't say nullability is orthogonal to value types; I said it was orthogonal to the two-projections world, which is what that text in the article was about rather than nullability. As to value types and null, I'm not sure about
194.
by pron 4mo ago
> If Java was a child, imagine it being brought up by loving parents for the first few years (Sun) then it was thrown in a garage with some other children and neglected by its evil guardian (Oracle). > Neglected and unloved till JDK 8
195.
by pron 4mo ago
First, your parent comment misunderstood what the section they were critiquing is referring to. It's not about nullability (which is orthogonal) but about reference/value projections. Now, as a member of the Java team (although I&
196.
by pron 4mo ago
> it is this interpretation that kills off the null-safety debate entirely. Saying you have a variable that cannot be null is not a mentally taxing distinction, especially since everything is labelled thoroughly. I think you've miss
197.
by pron 4mo ago
The problem is that generating either code or proofs with LLMs is very expensive, and generating good proofs (I don't mean elegant, I mean proving the most important properties) is probably not very fast, either. Reducing the verificat
198.
by pron 4mo ago
This is already changing again now that CEOs have wised up to the fact that they're paying for code by the line but these lines don't translate to profit.
199.
by pron 4mo ago
C, C++, and C# are obviously also major players in "serious software", but you can estimate the volume of software through the number of people involved (e.g. https://www.devjobsscanner.com/blog/top-8-most-dem
200.
by pron 4mo ago
The reason most "serious" or important software is written for the JVM these days is because it gives you an unparalleled combination of performance, productivity, and observability. There's almost no competition if these thi
201.
by pron 4mo ago
> My favourite thing in C++ is just loading a big binary blob and being able to point directly into it. That's what the Foreign Function & Memory API (FFM) is for: https://docs.oracle.com/en/java/javase
202.
by pron 5mo ago
> A lot of our C++ code is intrinsics (including memory primitives like _mm_stream_ps and barriers) Java has such intrinsicts, too: https://docs.oracle.com/en/java/javase/25/docs/api/java.bas
203.
by pron 5mo ago
C++ is no doubt king in games (for reasons that aren't necessarily primarily performance [1]), but not only are there plenty of high-throughput low-latency applications in C++, I believe there are more than in C++. BTW, "low lat
204.
by pron 5mo ago
https://www.youtube.com/java Don't confuse it with the interview about my talk, which is already up, but doesn't cover any of the important details.
205.
by pron 5mo ago
> So invoking Cuda (or the likes) in the middle of computation is a cheat code that Java does not have. It does (and has since JDK 22). But what we're working on now is JIT-compiling Java code to CUDA (not arbitrary code, but certai
206.
by pron 5mo ago
> The performance scales between them are many orders of magnitude. Imho it does not mean that Java anywhere near the best of what C++ can do. I don't think you're aware of where Java is today. Here's a recent talk about s
207.
by pron 5mo ago
> Ah yes, the swapping induced by IntelliJ overflowing my system RAM is supposed to reduce the inefficiencies of using too little memory. Great... That's like me saying, oh great, so the swapping introduced by MS Word or Outlook sho
208.
by pron 5mo ago
> Isn’t that only true though specifically at 100% CPU utilization? No. Because any RAM access requires CPU, using up any CPU effectively captures some ability to use RAM. > I don’t see how you can map X% CPU utilization to Y% RAM cap
209.
by pron 5mo ago
You're right, because I certainly don't consider resource-constrained programs to be the only performance-sensitive applications. I consider an application performance-sensitive when it has severe performance requirements (either
210.
by pron 5mo ago
> If you use Rust with serdes, you get access to one of the fastest ways to turn JSON documents into struct accessible data on the entire planet. Yeah, because most people who choose Rust are those coming from JS, Python, or Ruby, and al

More ›