Could We Be Living in a Simulation?

P.Z. Myers, in his own inimitable way, is taking on the idea that some prominent people have at least expressed some sympathy for that we are more likely to be living in a simulation than to not be living in one.  He is forming his opinion based on a video by Sabine Hossenfelder.  As it turns out, I’ve taken on a video of hers before, talking about free will that was referenced by Jerry Coyne (so the two of them at least have her in common despite their sniping at each other).  And I think the same comments that I made there also apply to this video:  she feels free to opine on the topics without really understanding them enough to justify her confidence in her position.

Let me start with what the simulation hypothesis actually is.  She references Nick Boström’s argument, which as I understand it is actually this:  If it is possible to simulate a world with simulated consciousnesses, then a sufficiently advanced civilization will create such simulations.  But then each civilization will create one if not more simulated worlds.  This means that if these simulations are perfect, there will be a significant number of perfect simulations that the consciousnesses inside the simulation will not be able to tell are simulations.  Thus, if we take the total number of “worlds” like ours, a significant number of them will be simulated.  Thus, there is a significant likelihood that our world is, indeed, one of those simulated worlds.

She starts by dismissing one of the more common objections to the idea:

The point I have seen people criticize most frequently about Boström’s argument is that he just assumes it is possible to simulate human-like consciousness. We don’t actually know that this is possible. However, in this case it would require explanation to assume that it is not possible. That’s because, for all we currently know, consciousness is simply a property of certain systems that process large amounts of information. It doesn’t really matter exactly what physical basis this information processing is based on. Could be neurons or could be transistors, or it could be transistors believing they are neurons. So, I don’t think simulating consciousness is the problematic part.

The first problem here is that she assumes that it doesn’t matter what the physical basis for certain systems that process large amounts of information is, but then notes that it is a property of “certain systems”.  Which systems?  Well, for her, that would at least be the ones with brains, and obviously simulated people will not actually have brains, and may not have anything like neurons.  In short, we don’t know in any way that computers can be conscious, and so don’t at all know if we can simulate consciousness.  And obviously if we can’t simulate consciousnesses then we can’t have simulations of consciousnesses, which defeats the argument.  But let’s assume that she’s right and it’s not really that big an issue to assume that we can simulate consciousness.  Then since we don’t really know any way to tell if something is conscious or not except by how it acts, we run into the ruminations of Bear from .hack, wondering about when he would find that a game he was playing wasn’t going too well and would start over or restore a save, what happened to the world that he was leaving behind?  Was he abandoning that world to evil?  Or were those consciousnesses simply snuffed out?  Arguing that we could definitely create simulated consciousnesses raises a host of moral and philosophical issues beyond are we, ourselves, simulated consciousnesses (an argument could be made that presumably sufficiently advanced civilizations to create simulated consciousnesses are as likely as not to be morally advanced as well and so at that point would never actually create such a world, or at least a world where the inhabitants couldn’t tell, which would defeat the argument as well).

The second problem here is that we actually don’t know that it’s a property of systems that process large amounts of information, and in fact in line with the comment above if that really was the case then it seems like we already have many, many systems that would be conscious based on the amount of data they process.  Fortunately, we don’t think that it’s simply large amounts of data processing, but instead at a minimum making it be about the sort of information it’s processing, mostly self-aware information.  And even that is controversial.  So her comment that the most common argument doesn’t seem well-motivated.

But since she doesn’t think this is a concern, what arguments do she think works?

The problematic part of Boström’s argument is that he assumes it is possible to reproduce all our observations using not the natural laws that physicists have confirmed to extremely high precision, but using a different, underlying algorithm, which the programmer is running. I don’t think that’s what Bostrom meant to do, but it’s what he did. He implicitly claimed that it’s easy to reproduce the foundations of physics with something else.

Actually, no, he didn’t, because she misses what a simulation would actually do.  It would not be taking a set of natural laws and trying to simulate them, but would instead be creating that set of natural laws for the simulation.  So the simulation isn’t aping the laws we see, but is instead producing them.  In short, the foundations of physics just are what the simulation is producing by its algorithm, and so no reproduction is required or even occurring.

However, she could fairly argue that it we are talking about simulations then we are talking about simulating a “real world”, and so the system would still have to be reproducing the foundations of physics, which then would be the physics of the simulating world and not our own.  Sure, but the obvious issue with that is that what is important for the original argument is that we, from inside that world, think of it as a natural world with consistent natural laws, not that the laws that we experience are consistent across all real and simulated worlds.  So the first counter here is that we don’t have any reason to think that these simulated worlds will indeed try to reproduce the laws of the creating world.  As we saw with the video game example, a lot of life simulations deliberately do not attempt to simulate the rules of the world itself, but instead try to simulate worlds with other rules for various reasons.  This is also true for scientific simulations.  And the second is that if it’s actually difficult to simulate worlds with the laws of physics of an existing world, the simulation may well be simplified to take that into account.  So, then, we don’t have any reason to think that simulated worlds will necessarily have the same rules and laws as the simulating world, and so again from our perspective all we have are laws and rules, not reproduced laws and rules.

So she needs to shift, here, to an argument about it being too difficult to make a simulation that, from the inside, would really look like a natural world.  She does try to make that argument:

A second issue with Boström’s argument is that, for it to work, a civilization needs to be able to simulate a lot of conscious beings, and these conscious beings will themselves try to simulate conscious beings, and so on. This means you have to compress the information that we think the universe contains. Bostrom therefore has to assume that it’s somehow possible to not care much about the details in some parts of the world where no one is currently looking, and just fill them in in case someone looks.

The problem is that this argument is basically an argument from processing power:  we cannot build a processor powerful enough to do this all in real-time, so we need an algorithm that reduces those processing demands.  This, however, comes completely from her and not from Bostrom at all, as he only needs to assume that such a world can be built.  He doesn’t need to assume in any way how it is built.  And in Computer Science arguments from processing power are pretty poor ones, since we have seen time and time again that arguments that say “You’ll never get enough processing power to do that!” have been overturned by us either finding a way to get more processing power out of our computers or finding algorithms that greatly reduce the processing requirements or both.  Massive programs that used to require massive mainframes now run on small cellphones, and we are building massive computer systems to process even more demanding programs than we’d ever imagined possible.  Insisting, then, that a specific method will be required to deal with these sorts of issues is a pretty weak one from a Computer Science standpoint.

And as it turns out, her skepticism that that method will work is a bit misplaced:

Again though, he doesn’t explain how this is supposed to work. What kind of computer code can actually do that? What algorithm can identify conscious subsystems and their intention and then quickly fill in the required information without ever producing an observable inconsistency.

There are two problems here.  The first is that such systems already do exist, in video games and graphics processing for them with things like draw distance.  While they aren’t simulating an entire world of people, MMOs even do it for a large number of people with different perspectives.  So this sort of thing already exists in our existing simulations.  And while she can argue that they don’t do it perfectly, it turns out that it doesn’t have to be perfect, which is the second problem.  It’s certainly not true that our world is perfectly ordered and consistent.  Her own example of climate change and weather proves that even in our understanding things are far more loose than we’d like.  We assume that this is because we don’t know enough to make the proper predictions, but what if those really are just inconsistencies in the system?  What if the odd acausal nature of quantum mechanics is simply that the system can’t keep up or, in line with climate change, that it’s just not simulating things at that level until someone actually observes it?  As long as we don’t constantly see a large number of inconsistencies that we cannot explain, we will be willing to suspend disbelief and treat this like a real world.  So since it doesn’t have to be perfect, and we know that we can simulate things well enough that things that we know are conscious are able to suspend disbelief, in a simulated world that is far better at it we are much more likely to be able to suspend disbelief as well.  So this seems like far less of an issue than us being able to create consciousnesses at all.  If the simulation can create a consciousness, it can probably simulate natural laws well-enough to keep us fooled.

She concludes:

And that’s my issue with the simulation hypothesis. Those who believe it make, maybe unknowingly, really big assumptions about what natural laws can be reproduced with computer simulations, and they don’t explain how this is supposed to work. But finding alternative explanations that match all our observations to high precision is really difficult. The simulation hypothesis, therefore, just isn’t a serious scientific argument. This doesn’t mean it’s wrong, but it means you’d have to believe it because you have faith, not because you have logic on your side.

The problem is that the assumptions are not on the side of those who believe it, but on her side … and the history of Computer Science has pretty much shown her assumptions untenable.  That doesn’t mean she’s wrong, but it does mean that we shouldn’t take her conclusions as seriously as she’d like us to.

So you need someone to learn new stuff …

I overheard my manager talking to someone last week. This isn’t hard for me to do because for some reason when we all moved over to this side of the floor my manager arranged it so that I’d sit right next to him. I’m not sure if he regrets that decision, especially since I’m not always the most talkative of people. Or maybe he likes that. He might regret the fact that I will sometimes start listening to Christmas music very, very early in the season, but he’s never commented on that to me.

Anyway, the other person was commenting that what they needed was to get someone to be an expert in some new technology and then run how that gets integrated into our product. My manager commented that that was hard to do because every time they get someone up to that level in that technology they leave the company to get a higher paying job, since skills in that area are in demand, adding that they were having the same problem with another technology that they needed skills and expertise in. Which got me thinking.

There are generally only two types of people who will eagerly volunteer to learn a new technology. The first are the people who just really like learning new things. These are the people who will work all day and then go home and spend their evenings writing code and playing around with new languages and systems. However, these sorts of people generally aren’t that interested in simply maintaining an old and used technology. They always want to learn new things. They also aren’t necessarily very good at simply doing the day-to-day things to keep a product going with a technology that they already know and so aren’t learning anything about. I’ve seen a number of cases where these sorts of people build an at least cool-looking new system and then move on, only for those who have to maintain it to discover that it’s often too complicated and rigid to maintain easily. These people, then, aren’t a good bet if you want something that someone will stick around and maintain in the future.

The other type are people who see it as a good opportunity to pad their resumes. It’s an up-and-coming technology that for whatever reason lots and lots and lots of companies want to try out, and so will need people who know how to do it. Obviously, once they get to the point where they can pass interviews claiming that they know how to do it, they’re going to be looking for better jobs that require that expertise. So they aren’t likely to be around for very long after that point unless your company massively overpays. So, again, they aren’t a good bet if you need them to stick around.

What you need are the people who really don’t care about learning new things and have no real interest in leaving the company for a better offer. Alternatively, you need people for whom job security is more important than the absolute highest salary. Of course, these have to be people who are willing to learn new things and not simply stick with their set role and are in fact capable of learning new technologies if they put their mind to it. These sorts of people are relatively rare, and importantly they aren’t going to be the ones clamoring to do it. Managers would have to identify them and justify choosing them over the people who really, really want to learn it. That’s … not an easy task.

So we will continue to give these sorts of things to the people who are worst suited for them, at least from the company perspective. Another one of those ironic contradictions that we find in business and, in fact, in life itself.

Musings on the Starcraft II AI Test …

So, today I’m going to muse on the Alpha Star AI playing Starcraft II that I kinda talked about here. These are just musings on the topic and so might be a bit inaccurate, and I’m not doing any extra research and so am just relying on what Shamus and the commenters said about it (links to the posts are in the post I linked above).

As best I can understand it, the system was essentially a neural net that was trained using what were in my day called Genetic Algorithms and potentially have evolved a much more “cool” name, where there were a number of agents that played the game against each other and the best ones were kept to play against each other again and so on and so forth. What I did way back in university — as part of my Honours Project I did a GA simulating a “Diplomacy Problem”, with various countries getting advantages or disadvantages based on whether or not they agreed with the others — was create a set number of agents — 50? — and rank them by score, and then drop the bottom 10, double the top 10 for the next run, and leave the rest. I hope they did something similar, but at any rate the overall idea is the same: run the agents, see which ones get the best score, keep those, keep or introduce some new agents so that they can learn new behaviour, rinse, repeat.

What this meant is that they needed to have agents that could play each other in order to generate the massive data sets that you need to train a neural net, which led them to limit the agents to being able to play as Protoss against players that are playing as Protoss. Right away, this is a little unimpressive, as humans can learn to play as pretty much any combination of the races a lot faster than the agents learned to play as Protoss against Protoss. This also led me to comment on the posts that there’s a risk with trying to get it to learn to play as other races or against other races because of the nature of neural nets. The big advantage of neural nets is that you don’t need to program any rules or semantics into it to get it to solve the problems. There aren’t really any rules or semantics in a neural net. Sure, there may be some in there somewhere, and it often acts like it has rules or semantics, but internally to the system there aren’t any. The system learns by semi-randomly adding and removing nodes and connections and adjusting the weights of connections, but the system doing that, at least in a pure neural net (supposedly Deep Learning systems combine the semantics of inference engines and the flexibility of neural nets, but I haven’t looked at them yet) doesn’t have any idea what actual rules or decisions those things are involved in. Thus, a common problem with early neural nets was that when you decided to train it to do something different or learn anything there was always a risk that you’d break existing behaviour unless you also trained it on the old functionality at the same time, which is not how things seem to work in humans. You can limit that by restricting how much it can change the original net, but then it has a harder time learning anything new. Make it static and the machine can’t learn, but make it random and it will forget lots of things it used to know.

What this means for our agents is that teaching them to play as another race or against another race might cause them to forget important details about how to play as a Protoss against a Protoss. I opined that what they’d probably do instead is build separate agents for each case and then have a front-end — which could be an inference engine since this is all deterministic — pick which agent to use. After all, while there are nine different combinations — the AI playing each race potentially against all other races — that’s set at the beginning of the game and so it’s a pretty straightforward decision of which agent to use, and there’s no real reason to try to teach the AI to try to find the ideal match-up given who they’re playing against. So this seems to me to be the easier way to go than trying to build a generic agent that can play all combinations, and it’s actually even less artificial than some of the other things that the agents were already committed to.

So, after the AI beat all the players the first round, how did the one player get a rematch and beat it rather handily? What he did was adopt a strategy that the AI was vulnerable to, which was harassment. The player waited until the AI had built a big army and sent it off towards his base, and then sent a few units in to attack the base. The AI turned its army around to meet the threat, and he moved the units away. After they were chased off and/or destroyed, the AI started out again … and the player repeated the harassing attack. Rinse, repeat, and eventually win the game.

One issue with neural net type AIs is that since they learn through repetition over massive data sets, they don’t really have the ability to learn or adapt on the fly. They don’t really learn much from one event or run. Inference engines actually can learn on the fly because their actions are driven by the premises and logic of their systems, and so if one event doesn’t turn out right they can immediately try to reassess their inferences. In this case, for example, the AI was probably bringing the army back because it anticipated that it was a mass invasion that it needed to repel. A neural net won’t store this explicitly, but an inference engine will. So there’s a chance that after a few repetitions it concludes that this doesn’t indicate a mass invasion and will learn to ignore it. Which, then, would leave it vulnerable to a “Cry Wolf” strategy: harass it until it learns to ignore the harassment, and then launch a full-scale attack to catch it napping. Which it could then learn to defend against as well, and so on and so forth.

People in the comments asked if you could just teach it to ignore the harassment, but the problem with neural nets is that you can’t really teach them anything, at least by explaining it or adding it as an explicit rule. Inference engines can be tweaked that way because they encode explicit rules, but neural nets don’t. To add a rule to the system you have to train it on data sets aimed at establishing that rule until they learn them. There are approaches that allow for feedback and training of that sort from what I’ve seen (mostly through short presentations at work) but either those will establish explicit rules which the system has to follow — even if wrong — or else they can be overridden by the training and so would need to be trained and retrained. In short, you can explain things to an inference engine, but not really to a neural net. You can only either let the net learn it itself or flat-out tell it the answer.

Neural nets, I think, excite people for two reasons. First, because they don’t generally have explicit rules they can come up with unique correct answers that we, ourselves, can’t figure out, or that at least are extremely difficult for us to figure out. This makes them look more intelligent than we are for coming up with answers that we couldn’t see. Inference engines and expert systems can come up with novel solutions as well, but all of those systems can explain how they came to that conclusion and so seem less “mysterious”, in much the same way as when we see Sherlock Holmes explain his reasoning it seems less mysterious and, often, more of a “Why didn’t we see that?”. We aren’t that impressed by computers having access to all the data and never forgetting or forgetting to consider any of it since that’s kinda what they do, but we are impressed by what seem like leaps of intuition that we can’t match. The other reason is that they loosely resemble the structure of the human brain — although anyone doing AI will tell you that they aren’t really that close, but as they are designed to model that in at least some ways the point still stands — and so people impressed by neuroscience will think that it’s closer to what we really do. Personally, I’m more interested in the reasoning aspects of intelligence and am more interested in finding the algorithm we use rather than emulating the hardware, so I’m less impressed by them. Still, they do manage to do the pattern-matching aspects of intelligence well and far better than more reasoning based systems, which has led me to opine that the ideal AI has an inference engine front-end and a neural net back-end. The inference engine answers what it can and passes off anything else to the neural net, assess the answer, adopts it if it seems to work and retrains the net if it doesn’t. Again, some people commented that this seems like what Deep Learning does.

All of this starts to tie back into the heart of questions about AI leading all the way back to Searle: does the Alpha Star agent actually understand how to play Starcraft II? There’s no semantics to a neural net. You could take those agents and hook them up to something that is, say, trying to run a factory and if the weights were correct the system could do that just as well (and people have indeed taken neural nets trained for one specific task and had them perform entirely different tasks and noted that they can more or less work). So what does the agent actually understand about Starcraft II itself? Does it know what the units are and what they mean? It doesn’t have to, as it doesn’t really encode that information in the neural net itself? If you don’t have the semantics, do you really understand anything at all? With Searle’s Chinese Room, most will agree, at least, that the person inside the room is not doing anything intelligent by simply taking in a symbol, looking up the answer, and passing it back out. That person doesn’t understand Chinese. What people say the error is with the thought experiment is assuming that the room itself can’t understand, or couldn’t if it had the right context and information. But all of that is semantic information about meaning. Does a neural net in and of itself ever have meanings? Does the Alpha Star agent store any semantic information at all, even to the extent that an inference engine does? Having the right output doesn’t guarantee meaning, especially if it can be used for things that mean things that are completely different. So does it have meaning? And if it doesn’t, does it really understand?

These may not be questions that the creators are worried about. They may simply want to build an AI to beat humans at a video game. But these questions will obviously be raised by these things, and the answers — and attempts to answer them — are of great interest to fields like Philosophy of Mind, Cognitive Science and Psychology.

Thanks, Shamus!

So, Shamus Young made two posts talking about Alpha Star’s attempts to create an AI that can play Starcraft II, and how it managed to beat human players and then where a human player exploited a tendency in it to beat it. There was a lot of discussions about that in the comments, and that made me want to do AI again after it being a … few years since my last attempt. And, of course, I clearly have lots of time to spare and no other projects that I want to look at that I could be doing instead of that. Thanks, Shamus!

Anyway, I went out and bought some books on the subject, two of which are detailed books about how to do AI in general and how to do Deep Learning in Python (the last is a technical book on Deep Learning that I would have already started reading except that it starts with Linear Algebra, which is not something I want to review while watching curling …). So I have that to get to, but in pondering it and reading the comments another idea percolated in me.

The AI there focuses a lot on neural nets, as far as I can tell. Now, neural nets have been around for ages, and have waxed and waned in their popularity for AI due to their rather well-known weaknesses (I’ll talk more about that in general in a later post). But one thing that kept coming up, especially when the exploit was revealed was “Can’t you just explain to it or make a rule in it to deal with that exploit?” And the answer is that you can’t really do that with neural nets, because they don’t explicitly encode rules and don’t really have an “Explain this to me” interface. What you can do is train them on various training sets until they get the right answers, and what often makes them appealing is that they can come to right answers that you can’t figure out the reasoning behind, which makes them look smarter even though they can’t figure out the reasoning behind them either. So, perhaps, they can be very intuitive but they cannot learn by someone carefully explaining the situation to them.

But inference engines, in theory, can.

There’s also a potential issue with using a game like Starcraft II for this, because as people have pointed out the intelligent parts of it — the strategy — can get swamped by simple speed of movement or, in the vernacular, “clicking”. As is the case in curling, the best strategy in the world doesn’t matter if you can’t make the shots, and in this case while you’re working out that grand strategy someone who builds units faster and maneuvers them better will wipe you out. A Zerg rush isn’t a particularly good strategy, but if you build them fast enough and can adjust their attack faster than your opponent can you might win, even if your opponent is a better strategist than you are. In short, Starcraft II privileges tactical reasoning over broad strategic reasoning, and while tactical reasoning is important — and arguably even more so in an actual battlefield situation — broad strategic reasoning seems more intelligent … especially when some of those tactical considerations are just how quickly you can get orders to your units.

So what we’d want, if we really wanted intelligence, is a game where you have lots of time to think about it and reason out situations. There’s a reason that chess is or at least was the paradigm for artificial intelligence (with Go recently making waves). But that game can be solved by look-ahead algorithms, and look-ahead algorithms are a form of reasoning that humans can really use because we just can’t remember that much (although it has been said that chess grandmasters do, in fact, employ a greater look-ahead strategy than most people are capable of. And now I want to start playing chess again and learning how to play it better, in my obviously copious spare time). There’s also an issue that it and Go are fairly static games (as far as I can tell because I’m not a Go expert) and so things proceed pretty orderly from move to move, and so aren’t very chaotic or diverse.

Which got me thinking about the board games I have that have chaotic or random elements to them, like Battlestar Galactica or Arkham Horror. These games let you develop grand strategies, but are generally random enough that those grand strategies won’t necessarily work and you have to adjust on the fly to new situations. They’re also games that have set rules and strategies that you can explain to someone … or to an AI. So my general musings led me to a desire to build an inference engine type system that could play one of those sorts of games but that I could explain what the system did wrong to it, and see how things go. Ideally, I could have multiple agents running and explain more or less to them and see how they work out. But the main components are games where you have set overall strategies that the agents can start with, and yet the agent also has to react to situations that call for deviations, and most importantly will try to predict the actions of other players so that it can hopefully learn to adjust that when they don’t do what is expected.

Now, other than picking a game to try to implement this way — Battlestar Galactica’s traitor mechanism is a bit much to start with, while Arkham Horror being co-operative means that you don’t have to predict other players much — the problem for me is that, well, I’m pretty sure that this sort of stuff has been done before. I’m not doing anything that unique other than with the games I’m choosing. So, if I did some research, I’d find all of these and get a leg up on doing it, at least. But a quick search on books didn’t give me anything for that specifically, a search of Google will make it difficult to sort the dreck from the good stuff, and the more up-front research I try to do the less actual work I’ll be doing, and I want to do some work. Simple research is just plain boring to me when I’m doing it as a hobby. So my choices are to reinvent the wheel or else spend lots of time looking for things that might not be there or might not be what I want.

So, I’ll have to see.

Anyway, thanks Shamus for adding more things to my already overflowing list of things I want to do!

More Net Neutrality

So, after the FCC in the United States dropped Net Neutrality regulations, a number of states have jumped on the bandwagon. Unfortunately, as I showed in an earlier post on the topic, most of them have no real idea how the Internet works, and Net Neutrality has become a buzzword that covers so many different things that it has become meaningless. I’m going to look at California’s proposed law to show that (which is referenced in the above Wired link).

First, again, the “Fast Lane” idea is brought up, and completely misunderstood:

The bill also leaves open the possibility of offering “fast lanes” for select content, but only at a customer’s discretion. Essentially, a carrier could allow you to pick a few applications to prioritize. For example, if you want to make sure your family’s video streaming doesn’t cut into your Skype calls, you could, hypothetically choose to prioritize Skype. But it must leave the selections to the customers, and not allow companies to pay for preferential treatment.

Except, as I pointed out in the original post linked above, that was never how “Fast Lanes” were going to work. What was almost certainly going to be the case was that additional infrastructure in the core was going to be added that would either have more available bandwidth or faster equipment — or both — and that the companies that required that would pay to get access to that. This would likely be accomplished by tagging the packets they sent with a tag in the header that the equipment would recognize and then route along the appropriate path. Thus, all of this was going to be done at the end that was sending the videos, not the side that was receiving them. Thus, at the customer side, nothing would be added and nothing would be done. It would all start from the company’s end and all the important things would be done long before the data reached the customer.

This “allowed” plan is completely different, as it’s all receiver/requester side. There are only two reasons that a customer could want this. The first is that the set-up inside their home that connects the routers to their own equipment is too slow to handle all of that bandwidth. There isn’t anything that the ISP can do about that, and I believe there are software and router solutions to allow this sort of prioritization. So no ISP is going to provide a solution for that kind of problem. The other reason is that there isn’t enough bandwidth on the line that comes from the outside equipment to the router to handle that load. In theory, an ISP could probably prioritize data at that point, although it would require them to deeply inspect the traffic or at least map the sending IP address to a specific destination address to do so. However, the preferred solution for them for these cases would be for the customer to upgrade to a faster Internet connection, which would make them more money. So, since this would require extra work on their end and would potentially cost them the money that the upgrade could provide, they would charge for it, and in general would charge more for doing it than it would cost to upgrade to a higher speed (since they can already do that without any extra work or software). Thus, this “possibility” will likely only be of use for people who are already at the highest speeds, or have very specific conditions that require the prioritization to be outside of their own routers and routing software. Somehow, I don’t really see this as being something that ISPs will rush to provide (and am not even really sure if there is any great demand for it now).

So, what the law allows for does not in any way address the issue that “Fast Lanes” were meant to address — which was that applications that required a lot of incredibly reliable bandwidth required equipment investments that telcos might not see extra profit from making — and instead allows a solution that customers may not want and ISPs aren’t going to see huge benefits from adding. This does not seem like a well-informed law to me.

This gets even worse when we look at a relatively new thing that wasn’t in most of the big Net Neutrality discussions, which is about things like “zero rating” and other ways to exclude some data from a customers download cap:

Wiener’s bill explicitly prohibits carriers from using interconnection agreements to circumvent its net neutrality rules, and bans certain types of zero rating. Broadband providers would no longer be able to exempt their own services from data caps, and they wouldn’t be allowed to selectively choose to exempt outside services from data caps, regardless of whether those services pay for the privilege or not. That means Verizon would no longer be able to zero rate live streaming National Football League games, even if the NFL doesn’t pay for the privilege.

Zero rating has long been controversial. Proponents argue that zero rating is consumer friendly because it lets customers use more data. Critics argue that it lets carriers pick winners and losers on the internet, which goes against the idea of net neutrality. The Obama-era FCC leaned towards the latter view. Towards the end of former FCC chair Tom Wheeler’s tenure in late 2016, the agency warned AT&T and Verizon, which exempts its Go90 video service from data caps, that their zero-rating practices were likely anticompetitive. But one of the first things Republican FCC chair Ajit Pai did after he was appointed by President Trump was end the agency’s investigation into the companies.

The California bill would allow zero rating in some cases. For example, a carrier could exempt a category of apps or services, as long as the exemption applied to all services in that category. T-Mobile’s Binge On and Music Freedom, which zero rate a large number of streaming video and music services, might be allowed. T-Mobile claims that all services that meet its technical requirements can be included in the service. The California bill would also allow carriers to zero rate all data under certain circumstances. For example, a provider could let people use unlimited amounts of data at night, but charge for data use during the day.

Now, “zero rating”, in this way, is a problem, and so it’s surprising how little attention it got in the original Net Neutrality debates. While excluding certain things from download caps does indeed allow customers to access more applications and more data-intensive applications before hitting their cap and having to pay more, in general it isn’t likely that they will use that to subscribe to two different competing apps, especially if they have to subscribe to both. It’s far more likely that they will be able to subscribe to both a video streaming service and an online game, say, because since both use a lot of bandwidth the cost of using both would exceed their cap and thus end up costing more than they are worth, and so they’d have to give up at least one of them. By being able to exclude their own, say, streaming service they give customers a reason to subscribe to theirs and not to their competitors, which is something that regulation might want to do something about. But this, then, is more about a business practice than about Net Neutrality.

And the law itself pretty much allows for that, by allowing ISPs to exempt full categories or to have day and time exemptions. But what’s interesting — especially in light of what is allowed for “fast lanes” — is that they don’t mention making these exemptions be at customer discretion. Being able to pay to exempt an MMO or streaming service, say, from my download cap seems pretty useful, and isn’t at all mentioned, and if it isn’t in the law then it might not be allowed because it wouldn’t be “Net Neutral”. And my experience with cable companies and the reasons given for why they, in general, couldn’t just allow complete choice — until, in Canada, the CRTC demanded they do it — was that the CRTC rules wouldn’t allow them to do what they needed in order to be able to provide that (my belief is that they were at least using the “Canadian content” rules as an excuse). Unless they see great money to be made from this, ISPs are likely to use the Net Neutrality rules as a reason not to do it, and to instead hold out for weakening Net Neutrality rules in other ways that benefit them along with doing this. Thus, this thing that would actually be really consumer-friendly won’t get off the ground until these laws are weakened.

Now, there are technical reasons why day and time and certain service exemptions might be useful for ISPs. Large downloads during peak times can slow the system and slow things down for everyone, so encouraging people to do these things outside of peak hours can make things better for everyone. And if certain applications aren’t an issue — because they aren’t time sensitive and so don’t have to get there right way — then excluding them allows them to focus on the content that is causing technical issues. But the law references them and, at least in the article, doesn’t reference another useful case that is similar to the “fast lane” one that is not that useful for “fast lanes”. Again, this does not seem like a well-informed law to me.

Does the Internet need some regulation? Sure. But what has struck me almost every time this whole “Net Neutrality” thing comes up is how little the people advocating for it seem to understand the Internet, and yet their voices end up being the loudest in this whole thing. That is how we’ll end up with terrible laws that people then point to to say how regulation is a bad thing and only hurts industry and consumers, and that’s not what we want. What we want is good, solid, well-informed regulation that works out best for everyone, ISPs and consumers alike. I don’t see us getting that this way.

Net Neutrality again …

So, the FCC in the United States has abandoned Net Neutrality, at least for now, and the panic has set in again. I was going to go through and talk about Net Neutrality because I have had sites — mainly “The Orbit” — crying wolf about the idea that sites like theirs might be blocked by their ISP — which is an odd claim to make considering that the original outcry about Net Neutrality was over “fast lanes” — and that we needed Net Neutrality to stop that, which struck me as odd. So I thought I’d go out and read up on what the issues were since things seemed inconsistent, and then talk about that … but, as it turns I’ve already done that. Twice. So I encourage everyone to read those posts for the issues around the “fast lane”, while here I’ll talk specifically about blocking sites.

There are essentially three places that a site can be blocked by an ISP. The first is at your end, when you request data from that site. The ISP can refuse to make that connection and thus deny you access to that site. There’s one issue here, though: you are paying for service from that ISP. If they deny you access to a site, they already have to have a reason or else they would be, at least potentially, violating the service contract. This is added to the fact that if they do that, customers complain bitterly. Typically, the argument here is that if an ISP is the only one available for an area, then it doesn’t need to care about that, but that doesn’t really apply in most cases. So if an ISP is going to do this, it’s going to have to be important to them to do so. They aren’t going to do that for a small site like “The Orbit”.

The second place they can do it is at the site’s end. This pretty much runs afoul of the same service contracts as the end user, only more so. This is especially dangerous because you might end up, say, blocking a blog from WordPress, and WordPress is a bit bigger than one customer or even a number of them, and they aren’t going to take it lying down. If they make a big enough fuss, lots of people will pay attention. Again, if they do this, they’d have to have a really good reason.

The third place they can do it is when they are an intermediary in the connection. So, say, Verizon hands off to AT&T in the core and then it gets switched back to Verizon for the end customer. Putting aside the fact that an ISP would be stupid to block a site this way if they didn’t block it for their own customers, there are already a lot of features that rely on ISPs treating packets they get from other ISPs as if they had originated it themselves, without adding extra restrictions. If an ISP suddenly starts blocking access to sites when the two end users are not their customers, those end users will complain to the other ISP, who will have to do damage control, and are likely to at least threaten to start inhibiting their services in retaliation. So even if an ISP blocks sites for their users, they aren’t likely to inhibit pass-through traffic.

All of this changes if they have sufficient reason, such as blocking problematic sites (child pornography being the obvious and uncontroversial example). Besides those cases, the most likely reason would be to give themselves a competitive advantage in some way. If they have a competing service, they can try to block their competitors so that they get more users than they do. Of course, all the other ISPs will try the same thing, which will only cause customers to be incredibly unhappy and likely refuse to use any of them. And the negative publicity will likely force regulations blocking that. They’re more likely to cheat with “fast lanes”, charging huge fees for access to it knowing that their service would, essentially, be paying themselves for that and so they’d break even, while other sites would run into problems with the cost and how to keep their site profitable having to pay for that. Again, note that ISPs are quite likely to respect each others’ “fast lanes”, so it’s sites like Netflix and any site that is independent of an ISP that will feel the heat there. But the issue here is not “fast lanes” or Net Neutrality, but is the fact that companies that own ISPs can and do also own content providers, meaning that they have a conflict of interest that they can exploit. We probably should focus more on dealing with consolidation rather than worrying about Net Neutrality.

As I’ve said in my previous posts, no one really wants Net Neutrality. What we really want is protection from unfair business practices. Net Neutrality is a “motherhood” statement that people are using to get that, but when examined closely that’s not really the way to go, since we can see benefits from not having Net Neutrality and the concerns people are pushing aren’t that credible.

Crap, It Succeeded …

So, at work I am quite busily working on a feature where, essentially, what I’m trying to do is take an operation that used to be one-step and introduce a step into it where you can do that first step — which is most of the work a user might want to do — and then finish it later. This means that there are two major parts to the feature. The first is to do the first step so that everything is stored and there when we want to finish it off. The second is the operation to complete the original one-step operation in precisely the same way as the one-step operation did it. Thus, a lot of testing has to be done to ensure that the end result of my two-step operation is exactly the same as the end result of the one-step operation. Since there are a ton of different combinations, this is something that I need a lot of help from QA to do.

It also means that I can get into an interesting situation, which happened over the weekend. One specific scenario was failing, so I was working through the code and fixing up all the places where that failed. After I did that, it completely succeeded! But, I had to check to see that it did all the same things as the one-step operation, and things were looking a little funny, so I tried to create it using the one-step process … and it failed. After making sure that what I was doing wasn’t screwing something up, I then spent the next day trying to figure out where my code was going wrong and succeeding when it should have failed. I finally managed to successfully get it to fail and thus knew that my code was closer, at least, to being correct.

This is the second time on this feature where I had something succeeding when it should have failed, and so was incorrect. The other time, it seemed to work — meaning fail or succeed appropriately — for the QA people, so I ignored it as being something odd with my set-up. But it’s one of those odd cases where succeeding is really a failure and a failure would really be a success.

Of course, all error cases are like that. But this wasn’t supposed to be an error case. It just happened to be a failure case due to misconfiguration. And that always leads to that odd feeling of “Damn, it worked, so I did something wrong!”

Needing the big picture …

So, in an attempt to update my programming skills — I’ve spent most of my career in C/C++, only now really getting into Java — I’ve decided to start doing little projects in HTML/Javascript, which I’ve been poking around with over the past few weekends. And what I’ve noticed is that, for me, the Javascript is generally pretty easy. I built an XML file and loaded it into classes in a couple of hours. No, when I get stuck, it’s always on the HTML stuff: hooking it up to Javascript, adding panels, etc, etc.

And I, of course, didn’t buy a book on HTML because, hey, how hard could it be?

The issue, I think, is that for HTML — and for any UI — it’s pretty hard to just build a bunch of small pieces and stick them together and make it work. For Javascript — or Python, for that matter — it’s relatively easy to start with some small classes and functions, stick them together, and then just Google or search through the book to find an example of what you need to do at this very moment, stitch that in, and move on. With a UI, everything pretty much has to work inside an overall context, and you need that overall, “big picture” definition before you’ll be able to do the small things. Again, in Javascript I can read in my XML file without storing it in a class, and can store it in a class without having that be used anywhere. In short, I can work “bottom-up” if I want to, which means that I can break things down into small tasks that I can assemble into a working program later. But with the UI, if I don’t have the overall structure in place, then nothing will look right, and nothing will work.

(The fact that, like Weyoun, I have no sense of aesthetics doesn’t really help [grin]).

I have a book now, and after skimming through it a bit it looks like it will be able to teach me what I need to know to progress. So all I have to do is actually sit down and do it.

…

That might be harder than doing the HTML …

Cacheing and Intelligence

At one point in my Cognitive Science/Philosophy courses, we talked a bit about contextualism about language, which is the idea that we critically rely on various contexts to determine the meaning of a sentence. For example, if I say “I went to the bank yesterday”, the sentence itself is perfectly compatible with my going to that place where I keep my money or to the place beside the river. For the most part, we get the determination right, but most interestingly to me are the cases where we in fact get that spectacularly wrong. In the case where I first heard about this, for example, in the example everyone in the room thought that the lecturer meant that the person should get on the desk, instead of looking for something that they could use on the desk. There are entire genres of comedy built entirely around someone failing to parse the right meaning out of a sentence, and having hilarity ensue. So we find that our ability to disambiguate words is both massively successful and shockingly terrible at times. What explains this ability?

To me, the main clue starts from the psychological process of “priming”. Essentially, this is the process where if we are exposed to, say, a word that is related to another word in a list that we’ve already recently processed, we process that word faster than we would otherwise. So, for example, if you’re reading a list of words and come across the word “Doctor” and then not too much later come across the word “Nurse”, you process “Nurse” faster and easier than you would if you hadn’t come across it beforehand. This is hard to explain.

Being someone from both a philosophical and a computing background, I do have a suggestion for what could be going on here. In general, it seems to me that what we probably have is a combination of time-saving techniques that are common in computer science when loading time is an issue. First, if it is common for a bunch of things to all be referenced together, instead of loading precisely the part you need and no more and then immediately loading the other parts, you load the whole thing into memory and use it. If you don’t use all of it, you don’t lose much because the problem is the initial loading and seeking out the object you’re looking for, not loading the individual parts of it. The second thing is to store things in memory that you have recently used because you’re likely to want to use it again in a short period of time, which is often implemented by or called “cacheing”. There are a number of Cognitive Science AI theories that rely on storing and loading objects and contexts instead of, say, simply words, so all we need to do, then, is add cacheing.

I’ve written a little program to play with cacheing to show how priming could work using it. I won’t reproduce the program here because HTML wants to ignore leading spaces and Python critically depends on leading spaces, so it’s a lot of work to put a program here, but in general what the program does is set up a number of lists that contain various characters that have various traits. For my demo, I created one with David Eddings characters, one with Persona characters, and one with other characters. The lists are as follows:

[Kalten, Sparhawk, Sephrenia, Ulath, Ehlana]
[Akihiko, Dojima, Yukari, Junpei, Naoto, Adachi, Yu, Mitsuru]
[Sherlock Holmes]

I then set up some matching criteria that you can ask the system to look for. You can look to see if the character is a Knight, is Male, is a Fictional Character, Carries a Sword, is a Detective, or is a Video Game Character. And you can ask for multiple criteria to be matched. For example, this was my first criteria:

print(matchMemoryElement([“Video Game Character”,”Carries A Sword” ]))

And given the lists above, the first one that it finds is Junpei.

So what if I run that search and then run another one looking for an Eddings Character. Note that since I randomize the lists every time (to allow me to get odd results without having to plan things out), the lists on this run start as follows:

[Kalten, Ehlana, Ulath, Sparhawk, Sephrenia]
[Dojima, Akihiko, Naoto, Junpei, Yukari, Adachi, Yu, Mitsuru]
[Sherlock Holmes]

And the results are:

[Sephrenia, Dojima, Akihiko, Naoto, Junpei]
Junpei
[Sephrenia, Dojima, Akihiko, Naoto, Junpei]
Sephrenia

So we still find Junpei for the first criteria, as he’s still the first person in the lists that is both a video game character and carries a sword. But how come I found Sephrenia first for the Eddings character? She’s the last in the list; shouldn’t I have found Kalten first?

The reason is that 5 element list that is printed out before the answer. That’s a cache, where I store the last five elements I’ve processed in case I need them again so I don’t have to go back to the lists. In this case, I parsed through all of the Eddings characters list, and then only got to the fourth element in the list of Persona characters before finding one, and then when I tried to match the second set of criteria it looked in the cache, found Sephrenia, and gave me that one … which would have been embarrassing if I was really looking for Kalten.

Let’s see what happens when instead of looking for an Eddings character, I look for a detective. The lists this time are:

[Ehlana, Sparhawk, Kalten, Sephrenia, Ulath]
[Yu, Junpei, Adachi, Yukari, Akihiko, Dojima, Naoto, Mitsuru]
[Sherlock Holmes]

And the results are:

[Sparhawk, Kalten, Sephrenia, Ulath, Yu]
Yu
[Sephrenia, Ulath, Yu, Junpei, Adachi]
Adachi

This time, there wasn’t a detective in the cache when it started, so it had to go back to the list to look for one, and ended up with Adachi.

Caches save loading time, because if you’ve already loaded an object and might use it again you might be able to get it from the cache without having to load any objects again. Also, despite the fact that the behaviour looks intelligent, it’s really quite simple, as all it does is store what you’ve loaded. Simple caches have no idea what you might load next, and even don’t have to intentionally cache in case that object might be needed again. All you need is a kind of white board that you just don’t erase, and a system that always looks on the white board first, and if nothing is there it erases some space and writes something else down. It’s a system that a brain could indeed implement by accident just by dealing with activation potentials. And yet, it has a lot of power to explain things like priming and contextualization of language processing. I hope to delve more into this if I have some time, but for now this ought to do to give a quick idea of the potential of cacheing for AI.

NOBODY wants Net Neutrality …

So, from The NY Times, it looks like Net Neutrality is going to go through, kinda, sorta. The FCC is going to regulate the Internet as if it was a public good, which would allow it to impose net neutrality. And the summary of what it would prevent is this:

The F.C.C. plan would let the agency regulate Internet access as if it is a public good. It would follow the concept known as net neutrality or an open Internet, banning so-called paid prioritization — or fast lanes — for willing Internet content providers.

In addition, it would ban the intentional slowing of the Internet for companies that refuse to pay broadband providers. The plan would also give the F.C.C. the power to step in if unforeseen impediments are thrown up by the handful of giant companies that run many of the country’s broadband and wireless networks.

The ability to step in and say that the providers can’t arbitrarily de-prioritize the content of companies that won’t play ball is good. However, no one wants the elimination of fast lanes. Even those who would never use a fast lane would rather there be a fee tacked on for high priority traffic than that all content providers are asked to pay for the infrastructure to provide high priority traffic. If all I’m doing is simple file transfers, I don’t need a high Quality of Service throughout the Internet or low latencies; a short delay is not going to impact my service at all. For video, however, a delay or packets coming out of order will hugely impact their service. Asking companies to pay to get access to even a priority that allows their traffic to be routed with low latency/high priority/high bandwidth routing features helps them guarantee their services work as expected, while the companies that don’t care as much about that don’t have to pay anything and get standard services, which works for their needs. No one really wants all traffic to be treated the same, because different traffic has different requirements and so needs different features to make it work to their ideal. If you try to treat them all the same, no one is happy because they aren’t getting the features they need.

The fact is that video services are as I’ve said before both bandwidth intensive and require low latency and a high priority. This is very expensive for ISPs to provide, requiring dedicated equipment that switches at a very high rate with an exceptionally low rate of dropped packets. As these services start to dominate, ISPs will have to provide some kind of infrastructure to handle them, or else the growing congestion will make those services unusable while also flooding out the services that didn’t care about that. Someone is going to have to pay for that infrastructure growth. The end user can’t because they are paying for the line to their system, and that’s not where the infrastructure needs to be added. If ISPs try that, they will end up charging end users more for speeds that aren’t any higher and for the needs of content that they aren’t using. This will not go over well. Despite what people have claimed, the issue is not at the end user, but is in the core, and ISPs will need to find a business case to expand the infrastructure in the core. Otherwise, their capital expenditures won’t result in an increase in revenue, and so they’ll simply end up losing money on the deal. It will not do well for the Internet to drive ISPs into loss trying to provide the services that customers want.

So if sites like Netflix want their content to have the features that they need to make their customers happy, they’ll have to find some reason for ISPs to provide those features. Trying to do it by standing on the “common good” or net neutrality won’t work because ISPs will simply insist on treating everyone alike as the regulations state and so won’t treat Netflix traffic differently than anyone else’s … and Netflix wants that. They also won’t develop new features for traffic like Netflix’s because there’s no profit in them to do so. Both of these are totally consistent with Net Neutrality.

So, no, no one really wants Net Neutrality. This issue has been clouded by the reasonable desire to limit dishonest business practices so that people aren’t seeing that there are business practices that everyone wants that can’t be provided under strict Net Neutrality.