yvdriess

The problem implied by the parent post is probably the danger that the speed pedelecs or e-scooters pose to low speed cyclists and pedestrians.

I'm not familiar with the Netherlands, but in Belgium legislation was introduced to tackle that problem. Above 25km/h, they are essentially considered motorcycles, requiring a similar driver's license and follow the motorcycle rules of the road. (https://www.vlaanderen.be/speedpedelec)

E-scooters are limited to 25km/h and follow cyclist rules, e.g. they cannot be used on sidewalks.

The number of speed pedelecs in the Flanders region is relatively high, because many companies have started offering leased e-bikes as a way to do tax optimization. (sadly, the same tax incentive exists for car leasing, so the number of cars on the road is still too damn high)

That makes the slowdown of productivity growth only more worrisome. The EU area is sitting at -0.2% and the UK is having a full blown crisis.

https://data.oecd.org/lprdty/labour-productivity-and-utilisa...

It's true that the distinction is a bit vague, the term JIT is overloaded to enough that it stopped being a useful technical term.

Compared to 'JVM JIT' or 'LuaJIT': there is no instrumentation to detect what is hot or not. The CPU frontend will crack x86 instructions into micro-ops, while looking for some patterns to merge certain instructions or uops into larger micro-ops. The micro-coded instructions (like many of the legacy instructions) are likely just lookups.

Most of this is my speculation, mind. Modern CPU frontends are still kind of a black magic box to me, but I think they are limited by relatively simple transformations by virtue of being on the critical execution path.

ucode cracking is relatively straightforward, I wouldn't call it a JIT. https://intelxed.github.io/ref-manual/

It's more like an intepreter for x86, seeing as it is actually executed on a dataflow architecture.

The Tilera was also a spiritual successor in the 00's. Through an acquisition chain they ended up at Nvidia. The DPU compute cores are apparently derived from Tilera, which me kind of happy that it still survives in some form.

Europallettes, yea

nitpick: it's the number of physical registers that matter more here, not ISA registers

Right, I should have known, libunwind is a basic requirement for supporting a C++ runtime on a target.

yes and yes.

Can you elaborate? Isn't the c++ exception system built on top of setjmp/longjmp?

For setjmp to have a measurable performance impact, you have to be calling it an awful lot. It is just a handful of mov instructions without dependencies.

Another "grew up playing AC" here and fondly remember interacting with Bael'Zharon on the Harvestgain server during the life events. Did you also blow up Arwic? :D

I still use AC and to some extent AC2 as an example of how wild, weird, dynamic and interesting MMOs were before the EQ formula won through WoW's success.

Glad I'm not the only one who read that blog in Zap Brannigan's voice.

Most gaming consumers got an AMD whether they wanted it or not, as the Jaguar cores were in both PS4 and Xbox One.

One explanation I heard is that the Singapore market is the gateway to other asian markers.

The corecursive podcast recently had an excellent episode about the history around Eliza: https://corecursive.com/eliza-with-jeff-shrager/

It's very risky. The price has a tendency to jump up briefly when a large short needs to cover its position.

Possibly, but I would argue we're not doing a very good job at that. Things like precedent rules plug into what we're used to for mathematical expressions, but that's only a small part of actual programming. Teaching novices without prior PL experience, you notice how much language syntax can get in the way, I get to the core concepts faster with scheme-driven classes than python-driven ones.

Question to HN: have there been recent interesting empirical studies into the impact of PL syntax? I tend to always cite https://dl.acm.org/doi/10.1145/2534973 but newer ones might have superseded it.

You can link in and interop fine with C/C++ as long as you link in the D runtime, kind of how you can mix C and C++ by linking in libcxx.

D's betterC mode ensures that the binary can run purely on libc without D's runtime library. It's kind of like being able to link and execute C++ code without needing libcxx.

Can that space contain Go objects?

I get your point, but it seems to ignore the geopolitics involved in something like the CHIPS act. Those government investments are not to save the poor struggling semi industry, it is a strategic move to limit overseas dependencies in a supply chain that is seen as critical for the MIC and the economy at large.

You are right that those semi companies do not need the government investments to build fabs. However, those fabs materialize overseas, depending on overseas supply chains. The EU and US regions want to build out more of the supply chain domestically, for strategic reasons. Those governments could simply legislate to impose heavy restrictions, but that hurts the competitiveness of the companies involved. And so, they combine that stick with a carrot, which is the government investments. You can already see increased restrictions on the semi supply chain in China, timed right after the CHIPS act passed.

The current slump seems purely caused by a demand drop. It will take years to see the capacity increase because of those government investments. By then, we will hopefully be out of this recession.

Not just while(true) busy wait, running the hot path continuously and keeping the 'actually send packet' flag unset. Gotta keep them caches hot.

Or, busy wait in a hardware state using MONITOR / MWAIT

For some data sources, there's only city data available:

> Since the bicycle and car trip shares from travel surveys are mainly for cities, we used the mean of city-level values as the corresponding national trip share, because the derived values appear in line with national values from other sources

A good netcode that does not trust the client already gets you most of the way. Games developed for consoles first trust the client to a large extent, so the PC ports are easy to write cheats for.

They key is who is offering the higher price and is there a pattern. A company with a dominant market position can use the resources that flows from said dominance to keep out competitors.

A succinct way to distinguish both is to focus on what problem they solve:

> Concurrency is concerned about correctness, parallelism concerned about performance.

Concurrency is concerned about keeping things correct[1] when multiple things are happening at once and sharing resources. The reason why those problems arise might be for performance reasons, e.g. multiplexing IO over different threads. As such, performance is still a concern. But, your solution space still involves the thread and IO resources, and how they interleave.

Parallelism is in a different solution space: you are looking at the work space (e.g. iteration space) of the problem domain and designing your algorithm to be logically sub-dividable to get the maximum parallel speedup (T_1 / T_inf). Now, a runtime or scheduler will have to do the dirty work of mapping the logical subdivisions to hardware execution units, and that scheduler program is of course full of concurrency concerns.

[1] For the sake of pedantry: yes, parallelism is sometimes also used to deal with correctness concerns: e.g. do the calculation on three systems and see if the results agree.

Not exactly new no. QC simulators have been in use since before the actual machine have. And even a schmuck like me has developed a QVM for a phd nearly a decade ago. https://github.com/yvdriess/qvm

Their qvm is probably more accurately stimulating the exact machine behaviour of their hardware.

Similarly, the Ardennes draft horse genetic stock survived because of an (unsuccessful attempt at) an horse-meat breeding industry.

It's usually not economical to breed a horse just for meat, which in my eyes makes it a relatively ethical form of meat.

Judging by your alias: Are you the guy with Lisp EDA tools?

Are you sure it wasn't done before by IBM in the '60s?

That's usually the case. For hardware, at least

For software, it usually was done before by Lisp in the '70s.