My theory is that is what is latent in the terrain of human psychology is a propensity to view misconceptions about which problem it is, as evidence there isn't one. When I stop to think about it, I realize that the misconceptions are evidence there is.
With that in mind: in what way should we terraform the latent terrain of human psychology to fix this problem? Because breaking up the tech companies seems like a way, but you seem to have a different one in mind.
I tend to agree with your general intuition that presupposing modern understandings creates all kinds of problems understanding ancient texts, some of which is in translation. But the specific case of "apokalypsis" it is kind of the opposite.
There is quite the extensive record of first/second century apocalyptic literature, (some of it even became the NT). These preserve remarkably detailed pictures of what apocalyptic thinking looked like long before Nicea.
The main thing to say is the concept of apocalypse was much broader than today's. To your question, it did mean a revelation of relationship with god, and then it also meant an end-of-times sense, and it also was political commentary, and it was also a conspiracy theory, etc. People did not distinguish between which modern, narrower concept they meant, because they actually meant the broad concept.
I suppose a different claim strikes me as false. "should have been deemed classified at the time they were sent" is one thing, "there was, in fact, confidential stuff in there" is a different thing.
I think a decent case can be made that one rounds up to the other, but I guess that case seems more like an argument to be made than a fact to be corrected.
To me, it is apparent that the data cannot support any clean division between two "sides", it tells a more complicated story about sometimes there was apostolic authorship, sometimes not, and sometimes we don't really know.
I would suggest that the real academic consensus is that we can confidently rule out the us-vs-them preoccupation that is common in lay discussion.
Consider an alien which subsists on photons, which is a form of life that exists today. We know from heseinberg that the sensing of this food "here" or "there" is nonphysical. Presumably our creature's civilization would require no heisenberg to discover what anyone can see from their own photosensor.
Rather it is the concept of objects remaining in a single place that would require some real mathematical innovation to a creature with no experience of such an idea. And so this distinction of entirely separate logical states, far from being basic or inescapable, is our very human invention. It is useful for creatures like us, who perceive things in one place when they are not really so, who do their computing with sand in a region where it's bountiful, and who encode abstractions as software because doing so in dedicated hardware is more costly.
While it is certainly possible that all intelligent life would have these constraints, there is no particular reason to expect it. What we can expect is that humans will expect others to be too much like ourselves; it's a well-known cognitive defect in our species.
I am also writing a game engine, also because of the gameobject issues, also doing tens of thousands of simulated AI agents. In my case they are GPU-accelerated and I'd guess you are doing something basically similar even if it's CPU-based.
Would be interested to discuss architecture as there aren't many of us out there and not much of a shared knowledge base. I looked for contact info in your profile but didn't immediately turn it up.
So, one answer (not necessarily the right one!) to how you can use software without copying it is that "the license says you can". In other words the license definitely views "running" and "copying" as distinct, regardless of you, me, or federal law.
The other, maybe more familiar idea to lawyers, and maybe more plausible to you, is the one in MAI v. Peak, that running is copying by definition. (The argument is based on the idea that running a program copies it into RAM, so we don't even need to talk about how you obtained the software.)
The way this shakes out is as follows:
a. If running the program is "not covered by this License", then we can stop reading the license and return to copyright law. But copyright law says we need a license to run (that is, to copy, MAI v. Peak) the program, so where do we get it, if not from "this license"? Bit of a puzzler.
b. If "running the Program is not restricted", maybe that sentence is by itself some kind of license to "run" the program, even though that contradicts the "not covered" part? If so, we need to understand what the license means by "run" which is evidently something different than "copy".
Very probably, what this clause originally meant was that people who think like MAI v. Peak are wrong and nobody should need a license to run software. If so, it's pretty challenging to turn around and argue "just kidding, they do"
The main problem with the interpretation that the GPL sets conditions for use of software is that it specifically claims it does not:
> Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted,
Now there are some ways to try to do an end-run around this clause, it does raise some questions about how you get the right to run the program without "this License". But if we take the text seriously, it disclaims any restrictions on use.
This is the part where the derivative work standard comes in. Because if the GPL doesn't set conditions on use, your use of the software doesn't require complying with that license. The GPL would only enter in if you are going beyond mere use, e.g. are you making a legal derivative work (not the GPL definition)
OED gives the following usages, the first of which suggest users predate computers:
1950 Science 112 732/1 Analog machines..are enthusiastically supported by their users.
1959 E. M. McCormick Digital Computer Primer x. 139 The number of instructions which can be executed by a computer represents a compromise between the designer's and user's requirements.
In general, a retained object is deallocated on last release. However ownership of some objects somewhere may have been given to an autoreleasepool, in which case “the last release” for those objects will come from the pool. To what extent this happens is implementation-defined.
Swift and ObjC implementations have levers which discourage objects being sent to the pool in common cases. It is possible to pull them from other languages but not easy.
That discussion is a bit strange. In that example Foo is implicitly #[repr(Rust)] meaning it has an undefined layout. In particular, a,b is unordered, and even if you don't care which order you get, there is the question of padding (a reasonable compiler will tightly pack a,b but that's not required).
For this reason, we never reach the question of alignment because we know neither i32, u8, nor any other type has the same layout as Foo (undefined layout).
It is certainly true that unsafe Rust is veeeeery unsafe, as perhaps evidenced by me being the first person to point out the repr issue. On the other hand this scheme has a lot of advantages for writing safe Rust.
Concurrent memory safety is definitely a goal. Try the new ‘-warn-concurrency’ flag to see what I mean, it is comparable to rust and quite different than thread sanitizer. There’s also a new runtime sanitizer this year with swift intrinsics, not best effort like tsan was.
That said. Swift is in the tough position of trying to be a lot of things at once to users with competing needs. Applications, systems, performance, education, prototyping, etc. While there’s broad agreement concurrency safety is important, not everybody thinks it is important enough to bury your working build under a thousand errors (though that view is represented)
Ultimately swift’s philosophy is that safety is practice and not theory. Some people do turn on ‘-warn-concurrency’ and fix their errors, others would want to ignore them and find some escape hatch to squash them which doesn’t appreciably improve safety, still others might not upgrade if that was required and maybe the ecosystem as a whole becomes less safe for it. Swift feels responsible for these kinds of outcomes.
It’s a tough problem but it does lead to interesting ideas that make safety more practical and productive. Remains to be seen how much of both worlds you can have, but swift/clang/llvm have a long history of doing stuff like that better than you expect.
I think it boils down to the fact that time isn’t reversible, so the “reverse problem” isn’t like the “forward” version.
Let’s take some new problems. Suppose you have 100 doors and no switching. Your probability is 1/100, even if the host later opens a goat door, so in that sense the new information is irrelevant. But if we “reverse it” and the host opens the door first and you guess second, your probability improves to 1/99. So now suddenly the same information is relevant. Two things to observe here, one is that the forward and reverse problems are different, the other is that the relevance or irrelevance of the information depends on the direction of time. If you learn the information before you act it is relevant, afterward it is irrelevant.
One way to think about Monty Hall is you’re deciding which of these games to play. If you will stick with your first decision, you are sorta turning it into the toy problem above, where you decide the door first and then the goat information is irrelevant. Vs if you will switch, the goat door is opened before you decide, which is relevant.
Another way to think about it is with two contestants. Let’s say I pick the door initially, then someone opens the goat door, and finally you decide whether to switch. In this scenario, you don’t have self-preference bias to stick with “my” original door. In fact, my decision was the irrelevant information. It doesn’t matter at all what door I picked, what matters is whether you pick the right door, and involving me at all is a kind of misdirection to anchor you to the 1/3 probability.
It’s an interesting conjecture but I don’t think the data makes a compelling case. When you compare 2 points in time you have a lot of alternative hypotheses, like the 2016 languages just being historically unpopular for some reason. A better support is a cohort analysis where we see languages start green/liked and transition to brown/disliked over their lifecycle.
The real difficulty though, is addressing the alternative hypothesis that language design improves over time. This is obviously the view of language designers or else they wouldn’t make languages.
In that case, you would see the languages turn brown in your analysis, and even in more robust cohort analysis. But it would not be because of a honeymoon bias, it would be because you don’t want to use a horse-drawn carriage if you could use an automobile.
I’m affected and have been stress-reading every report ever about this since it began.
The short version is, to a first approximation power generation requires power first. For many of the same reasons your house with solar panels is itself on the grid - your one source is not a reliable way to operate all the equipment on your home.
Another issue is that on a grid everything has to run on similar clock. The process of aligning the clock frequency takes time and you have to do it for every node.
There are special plans to “black start” a power grid but if you didn’t prepare adequately for cold which happens every decade, you definitely didn’t plan adequately for black start which happens theoretically never.
Queues are a dynamic concept; which queue you’re on is a runtime property. For this reason you may be familiar with assertions to check if a function is running on some queue.
Actors however are a static concept, we know at compile time which actor is local, and if we have the right one active. So the check about whether you’re on right actor happens at compile time.
You can think of it as if queues are part of the type system, and the compiler can work out statically what queue is used by any code, and so it can label an entire call tree’s queues by control flow analysis.
Because of this you wouldn’t dispatch onto the same queue twice and deadlock. Rather, the compiler would see that the correct actor is local already in the call tree and there’s nothing to do so the dispatch is elided. It would only “switch queues” if it needs a new one.
Besides the deadlock issue, the other advantage of this is it gets optimized out if you have several calls with the same actor.
I freely concede that I'm doing a poor job of defending it, because it isn't my view to defend. The part of it that I don't understand is limited to how it is self-consistent, which is not something I see addressed in your reply, although I could be mistaken.
But I think we are still saying talking points instead of getting to the core. I understand and I share the concern about an important voice being silenced. But I think the mechanism of that silence in the current environment is probably related to loudness of noise rather than quietness of signal. Obviously, it may be different at different situations and times in history. But I think if our goal is to hear quiet voices we ought to consider both sources of the issue pretty seriously. A philosophy that only considers the problem of transmitting and ignores the problem of receiving through a noisefloor seems an incomplete troubleshooting procedure to me.
Whereas you perceive a threat about the slide into censorship, I perceive a threat about the slide into unrest and violence. In reality, it seems likely we will get both: one of them first and the other following as a reaction. So I think our interests would really be best served by hammering out a workable compromise so as to hang together rather than separately.
I agree that we ought to return to the "liberal discourse", but we may perceive its makeup differently. Limitations on discourse have always been part and parcel of the institution. Some limitations have been very harmful. Others, like 'you can't threaten not to leave when you lose an election', have been very helpful. Liberal discourse is presently threatened because we have abandoned that sort of polite limitation, and it is by reintroducing it that we can recover the institution.
> If we had an oracle of truth, then censorship of falsehood would be easy and practical. We also wouldn't need democracy at all, we could just ask the oracle of truth what to do, and do it. But we don't have any such creature.
This is a bit of a strawman. I do empathize with the skepticism of authority in our present climate. However, you rely on some method to determine whether a person is doing censorship in the same way I rely on a method to determine if a person is doing misinformation. I expect it is a similar method, which is to say, imperfectly, based on values present in our historical age, individual biases, and so on. Which is the "same sort of stuff" that democracy otherwise uses to make any of its decisions.
I expect this dispute arises because, in your worldview, limiting the discourse is very exceptional, and doing it properly should require an exceptional method. Whereas from my perspective, laws, elections, jail, and wars are very serious, and we have processes to decide those.
It's pretty simple, although it may not be obvious. There are 2 different views about "what freedom/democracy is" that are presently doing battle in america, at least among inteligentsia
One, the worldview embedded into your comment, is that freedom is about the limits of discourse. Under this system, limiting discourse is inherently undemocratic, so if facebook "censor(s) things they disagree with" this is bad and we don't need any analysis of what specifically the discourse was to make our determination, which is why your comment abstracts over any value it could be. Full disclosure, I don't fully understand this worldview because it seems to enforce a particular discourse on Mark Zuckerberg, which seems a bit contradictory to me although I assume there must be some way philosophically to resolve this objection.
The other worldview is that certain kinds of discourse are inherently against freedom. For example, misinformation that might persuade voters into voting based on a false premise undermines a democratic system. Under this worldview, the question of what the discourse is, is the whole analysis, and we don't need any analysis of what Zuckerberg "disagrees with" to decide if it's right to limit. Obviously the people who will advocate for removing a discourse are people who don't like it, but that's separate from analysis of whether the discourse itself is a force against democracy.
These ideas are at cross purposes, and success of the one is often at the expense of the other. For this reason we seem reluctant to just lay out the underlying value systems the way I did here, which is unfortunate, because I think the fundamental disagreement is really important to discuss.
We do have a secondary form of capital: what we charitably call ethics/guidelines, or uncharitably - peer pressure. This is the currency that dominates FSF language like the “harm done” by proprietary software, the free software “manifesto” and so on. It is in this currency that developers are given a “perk” of occasionally working on open code at their otherwise closed day job, or are compensated in in exchange of a more lucrative proprietary model for their side project.
I don’t have anything against those who take their free software views seriously. But I am very annoyed that the currency of “ethical behavior” is one that burdens the individual and benefits the corporation. Only individuals can feel guilty that their software is not free, can agonize over copyleft vs permissive, can feel obligated to pass up compensation in exchange for ethical currency, can feel drained by an internet argument, etc. Corporations meanwhile can mostly ignore this secondary currency and operate entirely within the system of money.
Please understand I don't in any way mean to pick on you. The comment has 8 paragraphs that are mostly a description of how property rights work. Analogies to how they worked in other markets, examination of the law, etc. This detail is all very clear and I appreciate it because it helps me understand your point of view.
It is less clear to me, why the current situation of property rights is good. Of course many bad things (and for that matter many good things) have been done in the name of how property rights worked at one time. But in democratic societies we decide how things work, so in that sense we are the author of things like property rights, we decide how we want them to be based on our values.
> If you think Apple has failed to comply with some law in the way they implemented their products, I'd appreciate some clarity about exactly what you think Apple has done wrong, and how that should be redressed.
I don't know if they have "broken the law" but there are certainly similarities to historical situations.
You discuss game consoles and licensing games. I might suggest from Sega v. Accolade that a hardware marker's ability to license games exclusively was quite controversial at that time, was ultimately reversed by courts.
In DOJ vs MS, Microsoft was convicted as an illegal monopoly for (among other things) illegally bundling software with Windows, and using technical means to keep Netscape off the platform.
I am sure that Apple has great arguments for why they are different than these cases, and a lot has changed since then. At the same time, some things are similar. It's really about our values. Is the law about encouraging companies to innovate new ways to lock out all their competitors? Or is it about helping competitors? Or helping the large companies? Society has not yet decided, so the question has no answer.
> What kinds of requirements should be put on manufacturers? Under what criteria should they apply and to what devices?
Personally? My designer regulation is one where we have a tiered regime which gets worse the bigger you are.
So, for a small startup that serves basically nobody, we have the current regime, or maybe even we remove some things. There's still regulation on things like HIPAA and SEC rules, fraud, etc. I would also be in favor of much stronger privacy regulation, and limiting arbitration clauses, mostly because a lot of adtech is fly-by-night.
Once you reach some threshold, we regulate at a basic level. This is probably defined as some combination of revenue, daily active users, units sold, subscribers, employee/contractor headcount, but let's just call it a $10m company. Here you fill out a form once a year with an address the regulators can write letters to you, send in your EULA and privacy policy, and there's a list of basic rules like "don't sell user data", "make your software accessible", that are mostly on the honor system unless someone complains in which case the regulator writes you letters.
As we go up in orders of magnitude it becomes a bigger deal. By the time we get to FAANG, you have a regulatory team looking at individual products full-time, the same way we have inspectors in food or finance or anything else. For Apple specifically, maybe "users can jailbreak their device, subject to certain warranty consequences", "all first-party apps will only use public APIs", "developers of first-party apps will find out about new APIs the same time as everyone else", etc.
With that in mind: in what way should we terraform the latent terrain of human psychology to fix this problem? Because breaking up the tech companies seems like a way, but you seem to have a different one in mind.