As the article reports, the ruling actually states that the amount of time must be reasonable. Any gross or blatant violation would be picked up by any lawyer or judge.
Let's invent a new programming language that tells its users that the amount of time for which they hold memory should be "reasonable", without getting into specifics. This means the language can reclaim memory whenever it deems a violation has occurred. How well do you think would that work for the program? Not very well.
There are times that parts of a law should be vague to allow those evolved to make intelligent decisions. They should be specific enough to come to a resolution quickly if needed.
This opens the door to routine injustices whereby those who can afford expensive attorneys get a sweet deal, and everyone else gets stabbed in the name of justice.
Courts tend to follow precident, indeed precident is nearly the same as law. It's not really the case that an expensive attorney can argue his way around the well-established interpretations of the meaning of the constitution and other laws. Maybe, in the case of something novel, or for a question that has never come up before. It's not at all routine.
Why not? It would seem that you're just used to a state of exploitation and selective application, both of which are a mockery of justice. Sometimes it helps to see things from an outsider's perspective.
I'm not commenting on the way things should be, I'm commenting on the way things are.
And if you're saying that this ruling is bad because it doesn't work well in an idealized model of the law as you think it should be... that's an interesting observation, but you can hardly fault the judge for crafting a ruling that works in the context of the actual legal system.
Yes, the constitution itself only prohibits "unreasonable" searches and seizures, and only states that "probable cause" is required for a warrant. These terms are undefined, and left to the courts to interpret.
The definitions are well defined in theory. How they get applied to specific cases and how they have been perverted over time is the real problem.
Take warrants and probable cause. It's supposed to be that by a preponderance of the evidence that the crime has been committed. The quality of many warrants today seem to completely miss this to the point that many of the descriptions fail to even claim that the elements of the offense have been satisfied. Then we have such a lazy system that warrants foe summary offenses don't even have to be for the correct crime - all that needs to be claimed is that any crime has been committed. That's how it goes when the system is too lazy to give each issue the correct level of attention to protect your basic rights.
I know you think you're being facetious, but you've just described how modern operating systems work.
They give programs a reasonable amount of memory, without getting into specifics about the limits. And they reclaim memory as necessary based on the demands of the OS and other programs. See, for example, browser memory usage vs video game usage.
It turns out that in practice "reasonable" works quite well as long as you are reasonable about it.
I dunno, I think it's generally quite useful to identify relations between similar concepts. Not always easy to find one that fits perfectly but usually it just needs a bit of a tweak.
Like in this case, the situation you describe is exactly what a garbage collected language does, the key is that they let you mark what memory is still in use with a reference. Similarly in this case, there should be an explicitly defined time with a rule that if police want to hold something longer, they need to actively justify why and what the expected timeline is for the return without the owner needing to take them to court over it. Not perfect, but neither is garbage collection, and to me sounds much improved from what we've got.
I’m still not sure if GC is the police (i.e. returning the money/memory at an arbitrary undefined point in the future) or me trying to take it back.
The topic at hand is pretty straightforward and easy to understand, not sure what’s the point of trying to explain it using significantly more complex concepts besides making it more confusing and harder to understand for no reason..
(I mean I find it hard to believe that any person who understands how GC works would find the analogy in anyway useful).
> Not always easy to find one that fits perfectly but usually it just needs a bit of a tweak.
On a very superficial level sure. But then that mechanism starts coming apart at the seems if you start talking about the details.
Garbage collection doesn't impose a subjective reasonable vs unreasonable time limit for holding memory. It checks if the memory is still in use or not. Garbage collection is never subjective; it is entirely objective and without ambiguity or bias with regard to the guarantees it offers.
This claim is false for a lot of modern language runtimes which use tracing garbage collection, like the CLR (C#/VB), JVM (Java/Kotlin/Scala/etc), Go, BEAM (Erlang/Elixer), etc.
There are no hard promises about when or even whether GC will reclaim a particular piece of garbage, precisely to enable optimizations and necessary compromises. Application availability is often more important than immediately collecting every possible piece of garbage. The use of tagging, generations, arenas, etc. all allow the GC to use heuristics and apply different collection regimes to different pieces of garbage.
Apologies, but I meant it terms of the guarantees that a GC offers. Yes, the GC can delay, but it will never over-eagerly reclaim beyond its advertised guarantee. It will always err on the side of not reclaiming.
So exactly the same as saying that you will get your money back at some undefined point in the future whenever the police agency you’re dealing it will find it convenient?
I'm not sure of your definition of objective here. If you mean a specific implementation and exact version of a specific language does one objective thing that might be true.
But, different implementations of the same language and different versions of those implementations can all do different things. GC rarely says exactly when something will be collected. Only that it will eventually.
Firefox GCs after about 8 seconds, Safari GCs immmediately, Chrome never (probably not until there's pressure). And, you'll find different behavior if you go check different versions of those browsers.
Apologies, but the point was that a GC will never unjustly take your memory from you without a well-defined rule. It may delay in taking it away, but if it does, it will be very clear why it did.
Earlier you wrote "Let's invent a new programming language that tells its users that the amount of time for which they hold memory should be "reasonable", without getting into specifics."
"Objects are never explicitly destroyed; however, when they become unreachable they may be garbage-collected. An implementation is allowed to postpone garbage collection or omit it altogether — it is a matter of implementation quality how garbage collection is implemented, as long as no objects are collected that are still reachable."
That subjective language specification is quite different than its objective implementation in a Python implementation, which appear to be what you refer to now.
