Paul_Diraq
I do not believe an UBI on the level of an livable income will increase labor participation. The linked study suggests that an increase of income for low income households will lead to a higher overall demand and therefore to an increased economic activity and a larger labor force. However I would predict an increase in labor costs in particular for the minimum wage sector. (People who aren't so concerned about feeding themselves won't take odd jobs so easily.) Companies will restructure towards less labor intensive processes and overall labor participation will decrease.
That said I believe the UBI has to come at some point:
I believe the economy of the 21th century can be described between three groups of people.
- Directors: (CEOs, Managers, Investors ...) those who own or at least direct the "means of production" which are largely automated.
- Digital Creatives: (Scientists, (Open Source) Programmers, Journalists, Digital Artists ...) those who "create" information and whose end product can easily and essentially without cost be copied and distributed.
- Service personel: (Servers, maids, nurses, butlers ...) Those who essentially "sell" human interaction. Their jobs largely could be automated, but humans value human interaction too much.
Secondly I am convinced, that any market economy resembling the current one values the work of digital creatives very inefficiently. Currently there is (to varying degrees in the subfields) an attention or fame economy where the work is often not valued by skill, but by luck and self presentation. Additionally sufficient success to live from their work is often to uncertain, to engage in the attempt. This is especially deplorable since such work has often strong compositional or cross inspirational effects. The UBI would allow digital creatives to publish their work freely without the need to rely on monetarization. This would in my eyes be the driving factor for entrepreneurial growth due to an UBI but it is a long term effect and very hard to measure.
Imagine you change code in an upstream module. Now the compiler has to recompile all downstream modules. In C and C++ this only happens if you change the header file. (On the other hand modern development techniques emphasize tests so you might only recompile your module and the testsuite until all tests pass and only then recompile all modules, minimizing the impact.)
For a full recompilation you can parallelize C and C++ compilations much better than any module system I know.
The nicest thing: you can throw in the exit method without the runtime falling over itself.
https://www.iter.org/doc/www/content/com/Lists/Stories/Attac...
Their conclusion: The technology was challenging and exaberated risks. But most problems were rather generic for a project of this size. Also the thechnology problems were novelty and tolerances. Neither of which SPARC alleviates.
Lastly founding: Wendelstein started with an estimate of 500 million euro and doubled to 1 billion euro(I count only doubling the cost as an success for a project of this size). ITER is currently at 20 billion euro for construction and 5 billion for operation. The 75 million dollars are cute. Even if the management team is very competent, they need probably a hundred times that. I am aware that the 75 million are just the seed money but still.
Also Wendelstein was 8 years over time (measured by target completion date at project beginn.) So when the startup says fusion energy in mid 2020ties I hear fusion energy in mid 2030 ties. Or they don't survive because they can't secure founding in a phase where the startup hype has left and maybe even a recession hits.
For the rare cases that you need finalizers which might throw I would go for something inspired by pythons with statement.
WITH(expr , lambda)
bool _exception_happened=false;
auto __temp = expr;
__temp.enter();
try{
lambda(__temp)
}catch(const std::exception & ex){
exception_happened = true;
__temp.exit(ex);
}
if (not exception_happened){
__temp.exit();
}https://lwn.net/Articles/250967/
AFAIK there have been no major breakthroughts since that time in memory technology (Transactional memory could be one). While modern processors may be build a bit different (e.g. added shared L3 chache) you will have no problem understanding them.
There is also this github :
https://github.com/Kobzol/hardware-effects
for programs which should show such effects. (I haven't used them yet but they may be interesting for you to play with.)
IT Hare has published a nice article about those costs including rules of thumb costs.
http://ithare.com/infographics-operation-costs-in-cpu-clock-...
Then there are the Agner tables. Giving you latencies and reciprocal throughput for your instructions.
https://www.agner.org/optimize/instruction_tables.pdf
If you are through these you have to read the intel and AMD optimization guides. (ARM may or may not have something similar.)
The paper by Kazushige Goto ("Anatomy of a High Performance Matrix Multiplication") is an example of Cache and TLB considerations in a non-trivial example.
http://www.cs.utexas.edu/users/pingali/CS378/2008sp/papers/g...
The question "What can we know?" is one of the central questions of philosophy. (see metaphysics.) Answers go back to Platos cave allegory (and even further) to discuss it without mentioning some great philosophers like Plato, Descartes and Kant (at least) is criminally neglegient. Similar goes for the question "What do we mean when we say words?". While to my understanding it has only become important in the 20th century, Nietzsche was neither the last nor the most famous. Not mentioning Wittgenstein or Derrida is similarly neglegient.
The whole blue-green color blindness experiment is very ill concieved: Assume you send a '1' (ascii character in some network endianness) to two computers one with big endian encoding, one with little endian encoding. Both correctly parse the character into an unsigned char. One into '10000000' and one into '00000001'. Does now one computer see the '1' as '128' if so which one? And what would the activation pattern of neurons which represent 1 mean to that computer? Perception means to translate an external simulus into an internal representation. Of course the internal representation might be different for different systems. So the only way we can compare those impressions is via the stimuli that they reference and the position we use to reason about them.
Consider two mathematical notations which are identical except they have exchanged the meaning of '0' and '1'.
One system would give as some of the axioms:
x * 0=0
x * 1=x
x+0 = x
The other would give :
x * 1 = 1
x * 0 = x
x+1 = x
because the axioms correspond we could show that the notations equivalent. Even if their representations of the neutral elements are vastly different.
Interesting there might be a way to use something similar for colors: It is known that colors influence the mood(red makes you agitated, blue calms down...). If this is inborn to humans and not learned, one could actually compare perceptions of colors. If you blue agitate you but calms me down and red calms you down but agitates me. It would not be wrong to say you percieve colors differntly. (Of course it would be equivalent to say "we percieve them the same way, but you react differntly to them").
This is a back of the envelop calculation, but realistically you would have to deal with leakage so you get much less than a liter of helium.
E.g. strassens-algorithms assumes something like:
(A+B)C - BC = AC
With the convential floating point representation this becomes a problem if B >> A because of rounding errors.
Most algorithms faster than Strassen assume:
(( fA + B)C - BC)/f = AC
and
(fA + B)C = BC +fAC
f is then choosen in such a way, that fAC is neglegible. But if that is the case fA is much smaller than B and we automatically get numerical problems.
There is a procedure to remove the fAC terms (which would imply that f could be choosen close to 1) which armortizes over enough recursions. But for Coppersmith-Winograd (and derivatives like Le-Galls algorithm). We need to divide the matrix in each recursion step into enough submatrices that the indices can be treated heuristically(lets say a division of each index in each iteration in 100 subindices). This would imply the sides of each matrix must be at least of size 100^n_recusion. We won't need to multiply matrices of that size.