Everything we experience is far larger in time than space, so of course time effects dominate on scales we perceive.
But this just raises the question of what it means to be larger in time than space. You can look at it in terms of multiples of Planck distance or time, but I think there's a more enlightening way to look at it. If you express the speed of light in those Planck units, it's 1. But the speed of light is also the maximum speed of causality. Any causally-bound system must run long enough for chains of causation to propagate, usually far below the speed of light in practice. This means that basically anything that exists within the bounds of our manipulation must be happening at scales where there is far more time involved than space.
We all exist below the diagonal because the diagonal is the bound at which the ways chemistry and biology work no longer even are theoretically possible.
The heading saying "Simple (SPJ)" caught my eye, because I'm not sure SPJ has ever talked about simplicity in an especially referenceable way. Were you thinking of Rich Hickey's "Simple made Easy", or did SPJ do a presentation I missed out on?
Yeah, 12px is fine (27" 1440p, no display scaling). It is on the small side. I'd go a bit larger for something I made. But it's not a small enough to slow down my reading.
No, I think that ycombinator, who provides this forum... shouldn't.
This thing where we've traded societal trust for profits for the companies destroying it is a bad choice, and section 230 is what enables it. Let it all burn. Bring back small communities with internal trust relationships. Growth is not an automatic good.
(No, pointing out that I wouldn't be allowed to post this isn't a clever gotcha. The whole point of advocating for change is that it would affect me too.)
> No, I think that ycombinator, who provides this forum... shouldn't.
Good, then we're in agreement on that.
> This thing where we've traded societal trust for profits for the companies destroying it is a bad choice
We're in agreement on that too.
> section 230 is what enables it.
Here is where we disagree. Section 230 is not what enables the big tech giants. Section 230 is what protects sites like this one, that do not do the sorts of things the big tech giants do, but do host user-provided content. Without Section 230, ycombinator would have to be prepared to defend every moderation action it takes in court. The big tech giants actually don't care whether or not they have to do that; the cost of that is hardly even rounding error in their accounting. If Section 230 were repealed, they'd be fine; maybe they'd have to charge some more for ads on average to make up the difference. Big deal.
Sites like this one, however, would not be fine. Ycombinator might still be able to keep this site up, because they're well enough known that they might be able to get some political traction if someone took them to court. But the "small communites with internal trust relationships" that you talk about? Those need something like Section 230 to avoid being sued out of business by the first a*hole that wants to post there and is told they can't because of their behavior, and has enough time and effort to spare to take them to court.
If we want to outlaw something that might put a spoke in the wheels of the big tech giants, IMO it would be the ad-supported business model--the idea that a large corporation providing a service that's of obvious value to billions of people can get out of any responsibility towards those people simply by saying, well, we're providing the service for free, take it or leave it. And then saying they need to monetize those same people's data to stay in business, because, well, how else are we going to pay for this valuable service we're providing?
What if the goal of an economic system was to support everyone instead of maximizing the upside for winners? Perhaps that's the sort of change necessary for improvement. Perhaps having billionaires is the failure state.
A goal fails - who sets a goal? The keyword is system.
An economic system needs something like a Nash equilibrium where defectors are sufficiently discouraged (and cooperators are rewarded as you imply). https://en.wikipedia.org/wiki/Nash_equilibrium
What's culture got to do with it? If I wanted LLM responses, I'd have prompted for them myself. This is true in every single culture. The very fact that I asked a person means that I want the information they can provide, not LLM information. There is no culture in which that is false. So there is no culture in which providing LLM content is a useful response.
How you politely communicate that you don't have anything to add? That varies by culture. That LLM content is not a useful response? That does not vary by culture.
If in my culture I can't tell the boss 'I don't know' 'I can't do it' and I am handed a machine and told it's an answer machine, I can understand this conflict coming up. OP specifically said " I don't even entirely disagree, I just think it's worth reflecting on". OP is saying there might be dynamics that can be resolved with understanding why you are getting AI.
He doesn't have a role at Facebook anymore AFAIK, although I can't find the source now. I remember hearing it was mostly due to filtering engine at Facebook being rewritten in Hack, so they don't have the need for Haskell people anymore.
But in this case, C is not "good". It is more like "abysmal". "Good" is just producing a correct result or error, with no ambiguity which case applied and no UB. "Perfect" is arguing over the most usable and elegant API for it.
You report an error and exit cleanly with a proper operating system error code. Crashing is a quick hack, acceptable for throwaway projects but not in software used long-term.
I think you're using "crash" to mean "exit early". I am using "crash" in the sense of "this program did something causing the OS to terminate it externally". I suppose that's a real point of difficulty in communication across different programming languages.
We agree that the program should exit early. I think we agree it should do it cleanly and intentionally. I'm adding the constraint that "crash" doesn't necessarily mean "cleanly and intentionally", especially when talking about a C program.
There's a position in between "exit cleanly" and "general protection fault, core dumped" where the process essentially does the internal equivalent of SIGKILLing itself.
I.e. either intentionally (e.g. tripping an assertion failure), or accidentally due to some logic-failure in exception/error-handling, the process ends up calling the exit(3) syscall without first having run its libc at_exit finalizers that a clean exit(2) would run; or, at a slightly higher runtime abstraction level, the process calls exit(2) or returns from main(), without having run through the appropriate RAII destructors (in C++/Rust), or gracefully signalled will-shutdown to managed threads to allow them to run terminating-state code (in Java/Go/Erlang/Win32/etc), or etc.
This kind of "hard abort" often truncates logging output at the point of abort; leaves TCP connections hanging open; leaves lockfiles around on disk; and has the potential to corrupt any data files that were being written to. Basically, it results in the process not executing "should always execute" code to clean up after itself.
So, although the OS kernel/scheduler thinks everything went fine, and that it didn't have to step in to forcibly terminate the process's lifecycle (though it did very likely observe a nonzero process exit code), I think most people would still generally call this type of abort a "crash." The process's runtime got into an invalid/broken state and stopped cleaning up, even if the process itself didn't violate any protection rules / resource limits / etc.
It's a very language-dependent meaning. In C, the only type of crash is the OS shutting it down on some sort of trap. Everything else is the result of an explicit code path. Since we're talking about C, it's the definition I'm using. In other contexts, other definitions will apply.
Definitely! An interesting distinction. I spend much of my time in the BEAM these days, where "let it crash" is a common practice with a very distinct meaning (green threads under supervisor trees, etc). Different strokes.
You seem to be operating under the assumption "undefined behavior" means "the compiler authors can decide what to do." That's not what it means. It means "any program that causes this behavior to be triggered is not a valid C program, the programmer knows this and did not submit an invalid program, and the programmer explicitly prevented this from happening elsewhere in ways automated analysis cannot detect. Proceed with compilation knowing this branch is impossible."
The spelling for compiler authors getting to choose a behavior is "implementation defined", as the other comment mentions.
It means the C standard does not specify what the program does. Other documents may still specify what the program does. And the program definitely still does something, whether specified or not.
But this just raises the question of what it means to be larger in time than space. You can look at it in terms of multiples of Planck distance or time, but I think there's a more enlightening way to look at it. If you express the speed of light in those Planck units, it's 1. But the speed of light is also the maximum speed of causality. Any causally-bound system must run long enough for chains of causation to propagate, usually far below the speed of light in practice. This means that basically anything that exists within the bounds of our manipulation must be happening at scales where there is far more time involved than space.
We all exist below the diagonal because the diagonal is the bound at which the ways chemistry and biology work no longer even are theoretically possible.
reply