The question that started this wasn't about clocks. It was about what happens when you remove every cultural assumption from timekeeping and ask: what's left?
This still measures the time of day in seconds since midnight. It still encodes the number of seconds into the common base 60 system of hours, minutes, and seconds. It still encodes the base 60 digits as base 10 numerals. The only differences are the choice of digits - regular polygons instead of an established set of digits like the Arabic digits - and the writing direction - increasing in scale, radially outwards instead of horizontally or vertically - defining the positional value of each digit.
Simply a dot moving around a circle once per day would have abandoned way more cultural assumption than this. Of course at the cost of making it harder to read precisely and looking less fancy.
This combination of base 60 and base 10 can also be understood as a multi-base numeral system. 12:34:56 can be understood as 123456 with non-uniform positional values 1, 10, 60, 600, 3,600, 36,000 from right to left directly yielding the number of seconds since midnight as 1 x 36,000 + 2 x 3,600 + 3 x 600 + 4 x 60 + 5 x 10 + 6 x 1 = 45,296.
The polygon numerals are actually similar to Babylonian cuneiform numerals [1]. They use a positional system just like Hindu-Arabic numerals with the positional value increasing by a factor of the base - 10 for Hindu-Arabic numerals, 60 for Babylonian cuneiform numerals - from right to left but there are not different digits 0 to 9 - or actually 0 to 59 because of base 60 - but they just repeat a symbol for one (I) [2] n times like the Roman numerals do. This IIII II is 42 but in base 60, so 4 x 60^1 + 2 x 60^0 = 242. Ignoring the edges, the polygon numerals express the digit value by repeating a vertex 0 to 9 times and each scale increase of the polygon adds a factor according to the 60 and 10 multi-base representation described above.
[2] Because repeating the symbol for one (I) up to 59 times is inconvenient, they have a symbol for ten (<) as a shortcut, just as the Roman numerals have V for IIIII. <II <<<IIII is (1 x 10 + 2 x 1) x 60^1 + (3 x 10 + 4 x 1) x 60^0 = 754.
How many seconds of video did they generate per day for those $15,000,000, i.e. what would it actually cost me to generate, say, a three minute music video for my garage band? This should probably take into account how many attempts I would likely need to arrive at something I am satisfied with.
Assuming I know what I want and am somewhat competent at describing it, I would guess ten times the final length should be plenty. If you are exploring different options, you can of course produce an unlimited amount of videos. But that is not really what I was referring to, I was more thinking of how many attempts it takes the model to produce what you want given a good prompt - I have never used it and have no idea if it nails it essentially every time or whether I should expect to run the same prompt ten times in order to get one good result.
How effective is property based testing in practice? I would assume it has no trouble uncovering things like missing null checks or an inverted condition because you can cover edge cases like null, -1, 0, 1, 2^n - 1 with relatively few test cases and exhaustively test booleans. But beyond that, if I have a handful of integers, dates, or strings, then the state space is just enormous and it seems all but impossible to me that blindly trying random inputs will ever find any interesting input. If I have a condition like (state == "disallowed") or (limit == 4096) when it should have been 4095, what are the odds that a random input will ever pass this condition and test the code behind it?
Microsoft had a remotely similar tool named Pex [1] but instead of randomly generating inputs, it instrumented the code to enable executing the code also symbolically and then used their Z3 theorem proofer to systematically find inputs to make all encountered conditions either true or false and with that incrementally explore all possible execution paths. If I remember correctly, it then generated a unit test for each discovered input with the corresponding output and you could then judge if the output is what you expected.
In practice I’ve found that property based testing has a very high ratio of value per effort of test written.
Ui tests like:
* if there is one or more items on the page one has focus
* if there is more than one then hitting tab changes focus
* if there is at least one, focusing on element x, hitting tab n times and then shift tab n times puts me back on the original element
* if there are n elements, n>0, hitting tab n times visits n unique elements
Are pretty clear and yet cover a remarkable range of issues. I had these for a ui library, which came with the start of “given a ui build with arbitrary calls to the api, those things remain true”
Now it’s rare it’d catch very specific edge cases, but it was hard to write something wrong accidentally and still pass the tests. They actually found a bug in the specification which was inconsistent.
I think they often can be easier to write than specific tests and clearer to read because they say what you actually are testing (a generic property, but you had to write a few explicit examples).
What you could add though is code coverage. If you don’t go through your extremely specific branch that’s a sign there may be a bug hiding there.
An important step with property based testing and similar techniques is writing your own generators for your domain objects. I have used to it to incredible effect for many years in projects.
I work at Antithesis now so you can take that with a grain of salt, but for me, everything changed for me over a decade ago when I started applying PBT techniques broadly and widely. I have found so many bugs that I wouldn't have otherwise found until production.
"Exhaustively covering the search space" or "hitting specific edge cases" is the wrong way to think about property tests, in my experience. I find them most valuable as insanity checks, i.e. they can verify that basic invariants hold under conditions even I wouldn't think of testing manually. I'd check for empty strings, short strings, long strings, strings without spaces, strings with spaces, strings with weird characters, etc. But I might not think of testing with a string that's only spaces. The generator will.
One of the founders of Antithesis gave a talk about this problem last week; diversity in test cases is definitely an issue they're trying to tackle. The example he gave was Spanner tests not filling its cache due to jittering near zero under random inputs. Not doing that appears to be a company goal.
Glad you enjoyed the talk! Making Bombadil able to take advantage of the intelligence in the Antithesis platform is definitely a goal, but we wanted to get a great open source tool into peoples’ hands ASAP first.
Its independence war for Israel everyday since its 1948.
It is not an independence war, it is colonialization and occupation. And the Zionists at the time knew that and used this terminology themselves. 1948 was not an independence war, it was the preliminary culmination of the attempt to occupy and annex Palestine into a Jewish state against the resistance of the Palestinians. And the residence against this illegal act has continued to this day.
I randomly clicked and scrolled through the source code of Stavrobot - The largest thing I’ve built lately is an alternative to OpenClaw that focuses on security. [1] and that is not great code. I have not used any AI to write code yet but considered trying it out - is this the kind of code I should expect? Or maybe the other way around, has someone an example of some non-trivial code - in size and complexity - written by an AI - without babysitting - and the code being really good?
I would suggest not delegating the LLD (class / interface level design) to the LLM. The clankeren are super bad at it. They treat everything as a disposable script.
Also document some best practices in AGENT.md or whatever it's called in your app.
Eg
* All imports must be added on top of the file, NEVER inside the function.
* Do not swallow exceptions unless the scenario calls for fault tolerance.
* All functions need to have type annotations for parameters and return types.
And so on.
I almost always define the class-level design myself. In some sense I use the LLM to fill in the blanks. The design is still mine.
What actually stood out to me is how bad the functions are, they have no structure. Everything just bunched together, one line after the other, whatever it is, and almost no function calls to provide any structure. And also a ton of logging and error handling mixed in everywhere completely obscuring the actual functionality.
EDIT: My bad, the code eventually calls into dedicated functions from database.ts, so those 200 lines are mostly just validation and error handling. I really just skimmed the code and the amount of it made me assume that it actually implements the functionality somewhere in there.
Example, Agent.ts, line 93, function createManageKnowledgeTool() [1]. I would have expected something like the following and not almost 200 lines of code implementing everything in place. This also uses two stores of some sort - memory and scratchpad - and they are also not abstracted out, upsert and delete deal with both kinds directly.
switch (action)
{
case "help":
return handleHelpAction(arguments);
case "upsert":
return handleUpsertAction(arguments);
case "delete":
return handleDeleteAction(arguments);
default:
return handleUnknowAction(arguments);
}
From my experience, you kinda get what you ask for. If you don't ask for anything specific, it'll write as it sees fit. The more you involve yourself in the loop, the more you can get it to write according to your expectation. Also helps to give it a style guide of sorts that follows your preferred style.
Sadly yes. But it "works", for some definition of working. We all know it's going to be a maintenance nightmare seen the gigantic amount of code and projects now being generated ad infinitum. As someone commented in this thread: it can one-shot an app showing restaurant locations on a map and put a green icon if they're open. But don't except good code, secure code, performant code and certainly not "maintainable code".
By definition, unless the AIs can maintain that code, nothing is maintainable anymore: the reason being the sheer volume. Humans who could properly review and maintain code (and that's not many) are already outnumbered.
And as more and more become "prompt engineers" and are convinced that there's no need to learn anything anymore besides becoming a prompt engineer, the amount of generated code is only going to grow exponentially.
So to me it is the kind of code you should expect. It's not perfect. But it more or less works. And thankfully it shouldn't get worse with future models.
What we now need is tools, tools and more tools: to help keep these things on tracks. If we ever to get some peace of mind about the correctness of this unreviewable generate code, we'll need to automate things like theorem provers and code coverage (which are still nowhere to be seen).
And just like all these models are running on Linux and QEMU and Docker (dev container) and heavily using projects like ripgrep (Claude Code insist on having ripgrep installed), I'm pretty sure all these tools these models rely on and shall rely on to produce acceptable results are going to be, very mostly, written by humans.
I don't know how to put it nicely: an app showing green icon next to open restaurants on a map ain't exactly software to help lift off a rocket or to pilot a MRI machine.
BTW: yup, I do have and use Claude Code. Color me both impressed and horrified by the "working" amount un unmaintainable mess it can spout. Everybody who understands something about software maintenance should be horrified.
What I find interesting is how AI enthusiasts will recursively offer AI itself as the solution to any of the issues you mention.
Since AI can read and generate code, it can surely fix code, or find bugs, or address security flaws. And if this all turns into a hot mess, AI can just refactor the whole thing anyway. And so forth.
Personally, I think we'll be some years off before the whole software loop is closed by AI (if it even happens anyway).
In my experience its in all Language Models' nature to maximize token generation. They have been natively incentivized to generate more where possible. So if you dont put down your parameters tightly it will let loose. I usually put hard requirements of efficient code (less is more) and it gets close to how I would implement it. But like the previous comments say, it all depends on how deeply you integrate yourself into the loop.
The cloud providers charge per output token, so aren't they then incentivized to generate as many tokens as possible? The business model is the incentive.
This is only true in some cases though and not others. With a Claude Pro plan, I'm being billed monthly regardless of token usage so maximizing token count just causes frustration when I hit the rather low usage limits. I've also observed quite the opposite problem when using Github's Copilot, which charges per-prompt. In that world, I have to carefully structure prompts to be bounded in scope, or the agent will start taking shortcuts and half-assing work when it decides the prompt has gone on too long. It's not good at stopping and just saying "I need you to prompt me again so I can charge you for the next chunk of work".
So the summary of the annecdata to me is that the model itself certainly isn't incentivized to do anything in particular here, it's the tooling that's putting its finger on the scale (and different tooling nudges things in different directions).
I don't know, I would assume it works but I would not expect it to be free of bugs. But that is the baseline for code, being correct - up to some bugs - is the absolute minimum requirement, code quality starts from there - is it efficient, is it secure, is it understandable, is it maintainable, ...
So do you expect it not to be free of bugs because you've run a comprehensive test on it, read all of the code yourself or are you just concluding that because you know it was generated by an LLM?
It has not been formally verified which is essentially the only way to achieve code without defects with reasonable confidence. There are several studies that have found that there are roughly between one and twenty bugs per thousand lines of code in any software, this project has several thousand lines of code, so I would expect several bugs if written by humans and I have no reason to assume that large language models outperform humans in this respect, not at last because they are trained on code written by humans and have been trained to generate code as written by humans.
But you said "it's not great code" and then said "i don't know", so your idea of it being "not great code" is purely speculative and totally unfounded.
No, my judgment of not great code is not based on what the code does - and if it does so correctly - but on how the code is written. Those are independent things, you can have horrible code that does what it is supposed to do but you can also have great code that just does the wrong thing [1].
[1] I would however argue the later thing is more rare as it requires competent developers, however this still does not preclude some misunderstanding of the requirements.
It works really well, multiple people have been using it for a month or so (including me) and it's flawless. I think "not great" means "not very readable by humans", but it wasn't really meant to be readable.
I don't know if there are underlying bugs, but I haven't hit any, and the architecture (which I do know about) is sane.
You can make it better by investing a lot of time playing around with the tooling so that it produces something more akin to what you're looking for.
Good luck convincing your boss that this ungodly amount of time spent messing around with your tooling for an immeasurable improvement in your delivery is the time well spent as opposed to using that same amount of time delivering results by hand.
You literally have it backwards. It's the bosses that are pulling engineers aside and requiring adoption of a tooling that they're not even sure justifies the increase in productivity versus the cost of setting up the new workflows. At least anecdotally, that's the case.
I don't disagree with that, my claim is that bosses don't know what they're doing. If all of the pre-established quality standards go out the window, that's completely fine with me, I still get paid just the same, but then later on I get to point to that decision and say "I told you so".
Luckily for me, I'm fortunate enough to not have to work in that sort of environment.
I also managed to find a 1000 line .cpp file in one of the projects. The article's content doesn't match his apps quality. They don't bring any value. His clock looks completely AI generated.
Don't think it's fair to think any negative comment is from some anti-LLM-axe. I seriously gave you the benefit of the doubt, that was the whole reason I even looked further into your work.
It's no shame to be critical in todays world. Delivering proof is something that holds extra value and if I would create an article about the wonderful things I've created, I'd be extra sure to show it.
I looked at your clock project and when I saw that your updated version and improved version of your clock contained AI artifacts, I concluded that there's no proof of your work.
Sorry to have made that conclusion and I'm sorry if that hurt your feelings.
Saying things like "there's no proof of your work" is the anti-LLM axe. Yes, it's all written by LLMs, and yes, it's all my work. Judge it on what it does and how well it works, not on whether the code looks like the code you would have written.
I cannot empirically prove that my OS is secure, because I haven't written it. I trust that the maintainers of my OS have done their due diligence in ensuring it is secure, because they take ownership over their work.
But when I write software, critical software that sits on a customer's device, I take ownership over the areas of code that I've written, because I can know what I've written. They may contain bugs or issues that I may need to fix, but at the time I can know that I tried to apply the best practices I was aware of.
So if I ask you the same thing, do you know if your software is secure? What architecture prevents someone from exfiltrating all of the account data from pine town? What best practices are applied here?
Fair mistake on my end, I'm aware of what OSS means but my eyes will have a tendency to skip a letter or two. The same argument applies; because if I write something and release it to the OSS community there's going to be an expectation that A) I know how it works deeply and B) I know if it's reasonably secure when it's dealing with personal data. They can verify this by looking at the code, independently.
But if the code is unreadable and I can't make a valid argument for my software, what's left?
Are you saying you know your code has exactly zero bugs because you wrote it? That's obviously absurd, so what you're really saying is "I'm fairly familiar with all the edge cases and I'm sure that my code has very few issues", which is the same thing I say.
Regardless, though, this argument is a bit like tilting at windmills. Software development has changed, it's never going back, and no matter how many looms you smash, the question now is "how do we make LLM-generated code safer/better/faster/more maintainable", not "how do we put the genie back in the bottle?".
Also I will give myself credit for using three analogies in two sentences.
But you didn't say anything about wanting to know how it works, your comment was:
> The article's content doesn't match his apps quality. They don't bring any value. His clock looks completely AI generated.
I don't understand your point about proof. After more than 120 open-source projects, you think I'm lying about the fact that my clock works? All the tens of projects I've written up on my site over decades, you latch on to the one I haven't published yet as some sort of proof that I'm lying? I really don't understand what your point is.
The thing is, you can not chose once you are in the room. The fact that an [almost] perfect predictor exists implies that your choice must already be fixed at the point in time the predictor makes its prediction. Or the other way around, if you could still choose both options once you are in the room, say by basing your choice on some truly random and therefore unpredictable event like a radioactive decay - at least as far as we know truly unpredictable - then the predictor could not [almost] perfectly predict your choice, i.e. an [almost] perfect predictor can not exist.
So what you really want is to be in a state that will make you chose one box and you want to already be in that state at the time the predictor makes its predictions because the predictor will see this and place the million dollars into the second box. And as we have already said, you can not chose to take two boxes afterwards as that would contradict the existence of the predictor.
> So what you really want is to be in a state that will make you chose one box and you want to already be in that state at the time the predictor makes its predictions because the predictor will see this and place the million dollars into the second box.
Here’s the thing: no, I don’t. I’d much rather walk away with the easy million instead of risking it all for an extra thousand.
You can only get a thousand - take both boxes - or a million - take only the second box, zero and one million one thousand are not possible - or at least unlikely - because that would require a misprediction by the predictor but we assume an [almost] perfect predictor.
The existence of a flawless predictor means that you do not have a choice after the predictor made its prediction, the decision must already be baked into the state of the universe accessible to the predictor. It also precludes that any true randomness is affecting the choice as that could not be predicted ahead of time.
I do not think that allowing some prediction error fundamentally changes this, it only means that sometimes the choice may depend on unpredictable true randomness or sometimes the predictor does not measured the relevant state of the universe exactly enough or the prediction algorithm is not flawless. But if the predictor still arrives at the correct prediction most of the time, then most of the time you do not have a choice and most of the time the choice does not depend on true randomness.
Which also renders the entire paradox somewhat moot because there is no choice for you to be made. The existence of a good predictor and the ability to make a choice after the prediction are incompatible. Up to wild time travel scenarios and thinks like that.
> Which also renders the entire paradox somewhat moot because there is no choice for you to be made.
Not quite. You did choose your decision making methods at some point in your life, and you could change them multiple times till you came to the setup of Newcomb's paradox. If we look at your past life as a variable in the problem, then changing this variable changes the outcome, it changes the prediction made by the predictor.
> The existence of a flawless predictor means that you do not have a choice after the predictor made its prediction
I believe, that if your definition of a choice stop working if we assume a deterministic Universe, then you need a better definition of a choice. In a deterministic Universe becomes glaringly obvious that all the framework of free will and choice is just an abstraction, that abstract away things that are not really needed to make a decision.
Moreover I think I can hint how to deal with it: relativity. Different observers cannot agree if an observed agent has free will or not. Accept it fundamentally, like relativity accepts that the universal time doesn't exist, and all the logical paradoxes will go away.
> I believe, that if your definition of a choice stop working if we assume a deterministic Universe, then you need a better definition of a choice. In a deterministic Universe becomes glaringly obvious that all the framework of free will and choice is just an abstraction, that abstract away things that are not really needed to make a decision.
Indeed, I think of concepts like "agency", "choice", "free will", etc. as aspects of a particular sort of scientific model. That sort of model can make good predictions about people, organisations, etc. which would be intractable to many other approaches. It can also be useful in situations that we have more sophisticated models for, e.g. treating a physical system as "wanting" to minimise its energy can give a reasonable prediction of its behaviour very quickly.
That sort of model has also been applied to systems where its predictive powers aren't very good; e.g. modelling weather, agriculture, etc. as being determined by some "will of the gods", and attempting to infer the desires of those gods based on their observed "choices".
It baffles me that some people might think a model of this sort might have any relevance at a fundamental level.
This is a compatibilist view. However, we can tell that most people don't adhere to a compatibilist view of free will because it tends to make people very upset if you suggest they have no "genuine" free will or agency, and the moral implications behind the assumption of genuine agency are e.g. baked into everything from our welfare systems to our justice systems, that assumes people have an actual choice in what they do.
For that reason I strongly disagree with the compatibilist view - language is defined by use, and most people act in ways that clearly signal a non-compatibilist view of free will.
I personally don't see any problems with this. For example, in most cases we can agree if someone had free will or no when they committed a crime. Even if I prefer compatibilist view and you are not, we'll agree in the most cases. In the cases when we may not agree the reasons of disagreement will not stem from this fundamental disagreements, but from things like should we treat state of affect as a state when a human has no free will.
So, a compatibilist view is not incompatible with the world we live in, but moreover, it is needed to keep our world functioning. The world we live in is mostly artificially constructed. Welfare and justice systems are not "genuine", they are artificial constructs. They play a role in our society and the ideas of "free will" and "guilt" are constructed also, and they are tweaked to make our systems to work better. If you assume that free will and guilt are "genuine" or God given, then you can't tune them to better match their purposes. You are losing agency this way, losing part of your free will, you can't consciously and reasonably discuss if state of affect should be an exception from the rule "any person has a free will". You'll be forced either to skip the discussion, or to resort to some kind of theological arguments.
But if you accept, that "free will" is a social construct, then you can easily identify the affected variables: it is all about punishment for crimes or awarding people for their pro-social deeds. You can think of how "state of affect inhibits free will" can influence all these goals, you can think of the possibility of people simulating state of affect (or even nurturing their personal traits that increase the probability of entering state of affect) to avoid a punishment. You can think rationally, logically and to pick a solution that benefits the society the best. Those very society with baked in idea of free will. Or you can choose to believe "free will" is God given, because of an irrelevant linguistic argument, and lose the ability to make our world better.
> most people act in ways that clearly signal a non-compatibilist view of free will.
Of course, we are not living in quantum mechanics we live in a world that is constructed by people. I mean, all this is built on top of QM, but QM laws do not manifest themselves directly for us. We have other explanatory structures to deal with everyday physics. But even physics doesn't matter that much: I turn the switch and voila I have light, and the heck with conservation of energy. I can talk to you, despite we are residing on different continents, 1000s of km don't matter. If I want to eat I do not try to kill some animal to eat it nor do I gather seeds and roots in a wild to eat them. I go to work and do something, get my salary and buy food in a local store. We are living in an artificial world with artificial rules. Free will is part of this world. Of course we talk about it like it exists. We talk about it like it is a universal truth. Relativity I mentioned above doesn't show itself most of the time, because the world is constructed in a way, when we can agree about someone having it. Situations when this is not the case are very strange and can be even punished: manipulation (which is come close to taking people's agency away from them) is deemed amoral.
The world constructed so we can ignore that free will is just an illusion, moreover it is constructed to think about it in terms of free will, so you'll have issues thinking about it in other terms. Like you'll have a lot of issues trying to calculate aerodynamic of a plane relying on equations of quantum mechanics.
A compatibilist view, to me, is usually immoral, because it seems to maintain the pretence of agency while admitting it's an illusion, and so persist in accepting treating people as if they have agency.
People who at least genuinely believe in free will and agency has an excuse if they e.g. support punishment that is not strictly aimed at minimising harm including to the perpetrator. A compatibilist has no excuse.
It is of course possible to hold a compatibilist view and still argue we should restructure society to treat people as if they do not have agency, but then the point on holding onto the illusion drops to near zero.
> A compatibilist view, to me, is usually immoral, because it seems to maintain the pretence of agency while admitting it's an illusion, and so persist in accepting treating people as if they have agency.
Is thermodynamics immoral? You see, there is nothing fundamental about pressure or temperature, they are just statistical averages, they are all in imagination, it is an illusion. But we still pretend that pressure and temperature exist.
Or what about biological species? If you look into it, you'll see that there is no clear way to define what species are, all the definitions are imperfect projections of our high-level illusions onto the underlying biology and biochemistry. But we (and biologists also, who much more aware of the issues) still pretend that species exist. Are biologists immoral?
Nothing wrong with it. Nothing immoral, it is just a regular mental tool. You see, the question is what does it mean for thing to exist. Some things are easy: like there is a car, we can see it, we can touch it, we can drive it, therefore we agree that the car exists. But some things are not so easy, especially when we talk about immaterial things. But to make things even more interesting, some things seem to exist on some level, and do not exist on other levels. Like life for example. There is no life in an atom of carbon or hydrogen or nitrogen, but the bunch of such atoms connected just right can be alive. And it normally don't make people jumpy. At the some time some people have issues with the idea that free will exists on some levels but not others.
> People who at least genuinely believe in free will and agency has an excuse if they e.g. support punishment that is not strictly aimed at minimising harm including to the perpetrator. A compatibilist has no excuse.
Yea. I don't believe in free will and agency "genuinely", so I have no excuse. But I believe that any such excuses are borderline immoral. If anyone allows their emotions and animal instincts to take over them and act against the greater good of a society, it is immoral. I mean, if they do it for their own gain, it may be not immoral, there is a tradeoff between interests of a society and interests of an individual, and sometimes we should prefer the former and sometimes the latter. So going against the society interests is not inherently bad. But doing it because of uncontrollable emotions and animal instincts is bad. It still counts as an excuse, but I'm not sure if it is a good thing. I should believe that this is a good thing, because I don't know how to test it experimentally without risking to harm people even more. But still while I can accepts excuses of others, I don't accept such excuses from me. I just don't let myself to let emotions drive without any oversight from me (whatever this "me" is: this is one more interesting question without any good answers).
The point is: my "non-genuine" belief in free will make me much more free willed than a genuine belief. If I succumbed to my emotions and didn't control myself for three seconds, I'd see it as my personal failure. In my head I'm in control, not someone or something else.
> It is of course possible to hold a compatibilist view and still argue we should restructure society to treat people as if they do not have agency
No point in it. It is like arguing "lets forget thermodynamics and resort to pure QM because it is closer to fundamental laws of the Universe". We need the idea of free will, even if it doesn't hold on fundamental level.
A flawless predictor would indicate you’re in a simulation, but also we cannot even simulate multiple cells at the most fine-grained level of physics.
But also you’re right that even a pretty good (but not perfect) predictor doesn’t change the scenario.
What I find interesting is to change the amounts. If the open box has $0.01 instead of $1000, you’re not thinking ”at least I got something”, and you just one-box.
But if both boxes contain equal amounts, or you swap the amounts in each box, two-boxing is always better.
All that to say, the idea that the right strategy here is to ”be the kind of person who one-boxes” isn’t a universe virtue. If the amounts change, the virtues change.
A flawless predictor would indicate you’re in a simulation [...]
No, it does not. Replace the human with a computer entering the room, the predictor analyzes the computer and the software running on the computer when it enters. If the decision program does not query a hardware random source or some stray cosmic particle changes the choice, the predictor could perfectly predict the choice just by accurately enough emulating the computer. If the program makes any use of external inputs, say the image from an attached webcam, the predictor also needs to know those inputs well enough. The same could, at least in principle, work for humans.
I agree with you that it doesn't require that you are in a simulation, but a flawless predictor would be a strong indication that a simulation is possible, and that should raise our assumed probability that we're in a simulation.
I would think that the existence of a flawless predictor is probably more likely to indicate that memories of predictions, and any associated records, have been modified to make the predictor appear flawless.
Where does this obsession with the simulation hypothesis come from, it has been so widespread in the last years? It is more or less pointless to think about it, it will not get you anywhere. You only know this universe, to some extend, but you have no idea what a real universe looks like and you have no idea what a simulated universe looks like, so you will never be able to tell which kind our universe is.
But what if we discover that our universe is made from tiny voxels or something like that, that will be undeniable evidence, right? Wrong! Who says that real universes are not made of tiny voxels? It could be [1] the other way around, maybe real universes are discrete but their universe simulations are continuous, in which case the lack of tiny voxels in our universe would be the smoking gun evidence for being in a simulation.
[1] This is meant as an example, I have no idea if one can actually come up with a discrete universe that admits continuous simulations, which probably should also be efficient in some sense.
How did we end up with printf - within a loop - being Turing-complete? Was it designed that way from the beginning? Were new features added over time until we got there?
Having something Turing-complete is surprisingly easy, and it hides everywhere. The repository have a small document that explains how you can use printf() as a computer : it can performs additions, logical union and negation, which is enough.
It was unintentional, but Ken Thompson being Ken Thompson, can't be 100% sure.
It was probably unintentional, yeah, I don't recall any mentions of early printf being overloaded to do stuff, nor is it clear why you would do that since you're using it in a much more convenient Turing-complete language already (C).
No, because if I want something to happen everyday at 12 o'clock, I have to wait for one day, if I wait for 24 hours, I will be off by an hour for half of the year.
This still measures the time of day in seconds since midnight. It still encodes the number of seconds into the common base 60 system of hours, minutes, and seconds. It still encodes the base 60 digits as base 10 numerals. The only differences are the choice of digits - regular polygons instead of an established set of digits like the Arabic digits - and the writing direction - increasing in scale, radially outwards instead of horizontally or vertically - defining the positional value of each digit.
Simply a dot moving around a circle once per day would have abandoned way more cultural assumption than this. Of course at the cost of making it harder to read precisely and looking less fancy.
This combination of base 60 and base 10 can also be understood as a multi-base numeral system. 12:34:56 can be understood as 123456 with non-uniform positional values 1, 10, 60, 600, 3,600, 36,000 from right to left directly yielding the number of seconds since midnight as 1 x 36,000 + 2 x 3,600 + 3 x 600 + 4 x 60 + 5 x 10 + 6 x 1 = 45,296.
The polygon numerals are actually similar to Babylonian cuneiform numerals [1]. They use a positional system just like Hindu-Arabic numerals with the positional value increasing by a factor of the base - 10 for Hindu-Arabic numerals, 60 for Babylonian cuneiform numerals - from right to left but there are not different digits 0 to 9 - or actually 0 to 59 because of base 60 - but they just repeat a symbol for one (I) [2] n times like the Roman numerals do. This IIII II is 42 but in base 60, so 4 x 60^1 + 2 x 60^0 = 242. Ignoring the edges, the polygon numerals express the digit value by repeating a vertex 0 to 9 times and each scale increase of the polygon adds a factor according to the 60 and 10 multi-base representation described above.
[1] https://en.wikipedia.org/wiki/Babylonian_cuneiform_numerals
[2] Because repeating the symbol for one (I) up to 59 times is inconvenient, they have a symbol for ten (<) as a shortcut, just as the Roman numerals have V for IIIII. <II <<<IIII is (1 x 10 + 2 x 1) x 60^1 + (3 x 10 + 4 x 1) x 60^0 = 754.
reply