To be a friend means to be nice to someone. But what does it mean to be nice to someone.
Some people say I'm not friendly because I'm never physically close to them. I'm at my house, and they're at their house, and I never visit. But I've tried visiting and the results were not that great. The resulting mutual feeling was one of dissatisfaction.
They also say I'm not friendly because I don't write, but I've tried writing with the same results.
We would want to be physically close presumably so we could talk, these people and myself. We would want to exchange letters to exchange thoughts. And we could do that, but are the thoughts we're exchanging nice?
What, in the end, does it mean to be nice? Smiling isn't enough. Saying "I love you" isn't enough. To be truly nice to another person we need to be helpful to that person, or at least interesting. I believe in the end it's a question of business, which sounds unpleasant, because, where it's easy to love someone, which is to say, for example, to emotionally wish they were over at your house, it's hard to do business. But I have concluded that, if we don't do that hard thing, we can't have a solid relationship.
One of the businesses I want to be active in is, well, operating systems. You might find it interesting. Here are my thoughts on the subject.
An operating system is the software that makes a computer do what we want it to do.
If you look for definitions of the term operating system, you find a whole bunch of technical mush. You do not find a concise definition. Well, the above is concise, but it's not exactly a definition. If we want to make it into a definition we need to define what we want a computer to do.
Well, pretty much everyone thinks that's essentially not definable, and that everyone will want their computer to do something different, and different things at different times, or, at any rate, pretty much everyone but myself. I think what we want computers to do is one thing which can be described in a very few words, maybe two words: create space.
No, that's not quite right. We don't seek space per se, from computers. Rather, we seek the effect of space, the experience of space. In fact, we would like to achieve this without the actual use of space, as much as possible. We would like to experience a lot of space, without needing a lot of space to have that experience. This, of course, is because space is very expensive. But computers - and media generally - are very good at creating an experience of space without requiring much space for that purpose.
True, we might also want computers to do things for us while we are directing our attention elsewhere. If doing something would take a certain amount of time, normally, and we can spend considerably less time telling a computer to do that thing, and then the computer will do it, we have saved a lot of time, ourselves.
But that is not what people mostly use computers for. Also, the two things might in fact be one thing. Either way, what most people use computers for is to create the effect of having extra space, without the expense of actually having extra space.
A lot of people will say this isn't actually true. I don't know if I can prove it's true, but it's fun to argue the point. People might say computers are for storing documents, and that documents are really just collections of thoughts, or collections of data so space isn't an issue, or it's only an issue of the volume of data to be stored. But if what we want to manage is just thoughts, then we would manage just thoughts. Well, the way to manage thoughts is with documents. Documents are not just thoughts, they're, let's say, geometries. And geometries take space.
The counter - argument would be that even if a document is a geometry, it's just a two dimensional geometry that doesn't actually take up space, it just needs to be displayed.
It has come to seem to me, though, that documents can't be understood in isolation from each other. What's meaningful isn't a document, it's a collection of documents, and that the meaning of a collection of documents depends on the disposition of those documents in space. It has come to seem to me that if we say "because we are now in the world of computers, which operate on data, which is an abstraction, everything that is not an abstraction is now meaningless and ought to be discarded, and the experience of space, as it relates to documents, is merely a relic of a now irrelevant way of managing things, and to the extent it's still present it ought to be rooted out", as so many people are saying, in effect, then we end up throwing out utility itself.
This thing, which is treated as a peripheral issue in computing, nice for games, needed by architects and the like, but peripheral, that is the creation of the effect of space, is actually the essence of computing's purpose.
Of course, there is all sorts of software that creates the effect of space. What I would observe about all of it is it is either expensive, or hard to understand, or, really, both. So, is this because creating the effect of space, using computers, is very hard? I don't think so. I think it's because the world is convinced that creating that effect is a side issue, and if we take a very direct approach, people think we are being unrealistic, or frivolous, giving our attention to something that is ultimately irrelevant. In order to convince ourselves that we are in fact doing computing, we need to make it look not like something simple and direct and complete, but like something arcane and difficult and abstract.
Well, anyway, because I want to program representations of space, I've been in a sense studying how to do that. I find it very hard to be interested in other people's systems that do that, because of the lack of simplicity and directness and completeness built into them.
function thepointsonalineadistancefromapointontheline(theline,thepoint,thedistance) {
// define op, which is a point a certain distance from the point on the line
// given a distance d between two points, thepoint and op
// sqr(thedistance) = sqr(thepoint.x - op.x) + sqr(thepoint.y - op.y) + sqr(thepoint.z - op.z)
// what we know is that
// (thepoint.y - op.y) / (thepoint.x - op.x) = theline.my and
// (thepoint.z - op.z) / (thepoint.x - op.x) = theline.mz
// let's play
// thepoint.y - op.y = theline.my * (thepoint.x - op.x)
// op.y = thepoint.y - theline.my * (thepoint.x - op.x)
// success: op.y is defined in terms of op.x and known values
// similarly
// op.z = thepoint.z - theline.mz * (thepoint.x - op.x)
// sqr(thepoiinnt.x - op.x) = sqr(thedistance) - (sqr(thepoint.y - op.y) + sqr(thepoint.z - op.z))
// thepoint.x - op.x = sqrt(sqr(thedistance) - (sqr(thepoint.y - op.y) + sqr(thepoint.z - op.z)))
// op.x = thepoint.x - sqrt(sqr(thedistance) - (sqr(thepoint.y - op.y) + sqr(thepoint.z - op.z)))
// (sqr(thepoint.y - op.y) = (sqr(thepoint.y - (thepoint.y - theline.my * (thepoint.x - op.x))) =
// (sqr(thepoint.y - (thepoint.y - ((theline.my * thepoint.x) - (theline.my *op.x)))) =
// (sqr(thepoint.y - (thepoint.y - (theline.my * thepoint.x)) + (theline.my *op.x)))) =
// sqr((theline.my * thepoint.x) + (theline.my*op.x)) =
// sqr(theline.my*(thepoint.x + op.x) = op.x
// sqrt(op.x) = theline.my * (thepoint.x + op.x)
// sqrt(op.x) - (theline.my * thepoint.x) = theline.my * op.x
// op.x = thepoint.x - sqrt(sqr(thedistance) - (sqr(thepoint.y - (thepoint.y - theline.my * (thepoint.x - op.x))) + sqr(thepoint.z - (thepoint.z - theline.mz * (thepoint.x - op.x)))))
