HN user
blog: github.com/lewurm/blog/issues
contact: wien.tomnetworks.com
What is a former q3 champion doing these days? I'm genuinely curious. Since you are on hacker news I assume you do something with software. Any skills that you picked up back then that are useful today?
Firmware is using cache as RAM (e.g. https://www.coreboot.org/images/6/6c/LBCar.pdf) to do early init, like DRAM training. I guess later things in the boot chain rely on DRAM being set up probably though.
I actually think I'm going to rush out and buy a Windows ARM computer right now.
If you have an Apple Silicon machine you can run a Windows Insider build via UTM in a VM.
Probably a OpenJDK Zero VM build. That's a configuration without JIT or template interpreter, but a "plain" C++ switch dispatch interpreter that requires no runtime code generation.
Sure, but neither javac (the Java to bytecode compiler) or HotSpot are doing that. The former tries to preserve as much as possible, and for the latter interprocedure analysis is too costly at run-time.
Mac Mini running Asahi Linux might be an option
Thanks for the context!
What's the difference between the stage2 and stage3 binary? Does stage1 produce different binaries for the same input compared to stage2/stage3?
GraalVM will have a stable release that includes Apple Silicon support next week. Glad to see the snapshot did the job for you though :-)
For github: https://github.com/$user.keys
Issue at JetBrains: https://youtrack.jetbrains.com/issue/JBR-2074
I'm new to mechanical and split keyboards, but so far the moonlander has been great. Well, in the beginning it was a bit of a learning curve, but coming from the ergodox that shouldn't be an issue for you. Not being wireless is the only complaint that I have.
My pessimism tends to agree with you.
OTOH social distancing and wearing masks has shown recently that (most) people are fine with changing their behavior, if necessary.
Premature optimization is the root of all evil. There are lower hanging fruits. Avoiding animal products in your diet is your best bet as individual to fight climate change: https://www.theguardian.com/environment/2018/may/31/avoiding...
CoreCLR started to implemented Tiered Compilation https://github.com/dotnet/coreclr/blob/master/Documentation/...
It's experimental currently, no profile guided optimizations _yet_
[...] which is what for example .NET does.
.NET is the platform. There are different implementations for it doing different things.
JIT compilation is still different to AOT even without profile guided optimizations. Simple example: In AOT code you can't embed pointers easily and is often solved with indirection (e.g. something like GOT in ELF).
Targeting a stack machine is much easier when writing a compiler for the first time, but real-world machines are generally register based.
In general this is true, here however, we are targeting LLMV IR which is register based with infinite registers; so it's kinda easy again :-) The hard part, register allocation, is actually done by LLVM.
This class implements the conversion: https://github.com/lambdageek/mono/blob/mjit/mcs/class/Mono....
no, blazor uses a Mono version that interprets at runtime .NET. AOT is in the pipeline though
`jaotc` integrates with the HotSpot VM, while Substrate VM provides its own runtime (GC etc.) and intentionally supports only a subset of the JVM features.
FWIW, both use Graal as a compiler.
that's most likely intentional, I'm sure Oracle has a lot of lawyers to look over this kind of stuff ;-)
With Substrate VM you get way faster startup for your Truffle language and potentially overall less dynamic footprint.
Graal VM is based on HotSpot, which is sort of "bloated" for the specific use case that Truffle has.
This is huge, congrats to the team! I hope it helps Substrate VM to get better adoption outside of Oracle.
Ideally, an application doesn't have to choose, but the runtime uses some good defaults. For example, let's have a look at the HotSpot JVM: A Java method first gets executed in the interpreter, then, if it's hot enough it will compile the method with the C1 JIT, and then later uses the C2 JIT to bring the method up to full peak performance. There is also some profiling going on that is fed into the JITs to guide optimizations. The transition between the execution tiers is based on some heuristics and is kinda complex.
Do you need to care as an application? Ideally no :-) It should be transparent to the user and it's the runtime's job to do the best available thing for you. (Sure, the runtime can be tweaked for specific workloads etc.)
In Mono we aren't there yet: the interpreter is currently useful for restricted targets like iOS, where a JIT can't be used due to security concerns and AOT comes with certain limitations (that is, loading assemblies at runtime and execute them). If you want to use Mono's Interpreter to run roslyn, you can explicitly tell the runtime to do so, but it doesn't make much sense today, because it will give you less performance than the available JIT; we don't support switching the execution engine on the fly for single methods yet (it's also called tiered compilation).