> According to Snyk, apps built on the Spring Boot Java framework are also vulnerable since they come with a pre-included Tomcat server. Per Red Hat, Tomcat also ships with other Java-based frameworks and servers, such as JBossWeb and JBoss EAP.
Even if that claim about "most people" was true, the point is still valid - OSS contributors _are_ "innovating" (creating new things to make money on), despite the innovations being freely copied. In part, the innovation happens _because_ or _with_help_ of free copying. Free sharing of some ideas/knowledge can be benefitial to innovation.
Nobody is claiming _all_ ideas business finds / works on should be immediately shared freely with the world. The benefactors of a business are naturally motivated to protect their know-how. But it should be the business' responsibility to protect its secrets, not HN commenters or governments'. If an idea can't be kept secret, then government issues patents, which should be time limited and regional.
Innovation is a techno/bureau -cratic buzzword, which (noun) roughly means "new thing that is novel and can be used to boost the economy". A derivative of an old product can be an innovation, if you can still make or attract money on it.
Its a substantially different article mostly about running on Windows 3.1; whereas the first is about shrinking the executable under 8 kilobytes (but not DOS).
There are two main ways to do async/concurrency where you release the thread to do other work while you are waiting.
1. stackless (async/await) where the operation becomes an inspectable object that you can choose what to do with (awaiting being suspend for completion) as taken by C#, C++, Python, JS, PHP, Swift and Rust
2. "with stack" where you pretend its not async; but this means when something else uses the thread you need to get the suspended operation's stuff off the thread; usually by not using the thread's stack at all and having it in the heap and just jumping into and out of these "off-thread" stacks; as used by Go and being looked at for Java (as Project Loom)
> While fibers may have looked like an attractive approach to write scalable concurrent code in the 90s, the experience of using fibers, the advances in operating systems, hardware and compiler technology (stackless
coroutines), made them no longer a recommended facility.
Disadvantage of stackless is the extra boilerplate (e.g. async/await everywhere); though it also gives more control as the consumer of the operations (e.g. fanout and wait for many; or continue not waiting for the result at all)
Advantage of the "with stack" approach is it looks the same as non async code as its all hidden (goroutines aside); which is why Java is no doubt looking at doing it as there is a large body of code that would need to be rewritten so "hiding it" is easier to avoid that.
C# had/has teething issues when async/await was introduced as it kept the initial thread blocking methods; and added the async and they don't mix very well, you need really to go one way or the other when developing.
Javascript leapt at async/await as it was all async anyway, but callback based which makes for horrible code to follow; so it made everything much cleaner.
Yes. Inflation decreases debts and means people with wealth need to do something with their money (e.g. invest) in order to retain its value.
However, speculative increases (buying land for increase in prices, buying shares for increase in share price, etc) and rent seeking adds price but doesn't add real value/investment to the economy.
