Hmmm. Maybe I should start an online museum. But of what?
Could a MOOM, itself an online museum, consistently claim to be complete (with repsect to the universe of online museums)?
This reduces to the question of whether a museum can exhibit itself. If by this we mean a species of strict inclusion, then clearly the answer is no, given our assumption that the existence of a museum requires that it have been (finitely) constructed.
Now if we consider that every museum can be construed as trivially exhibiting itself, then of course the answer is yes. But this requires a reflection principle that complicates the metatheory.
The museum can certainly exhibit itself, by having a link on its front page. The magic of names.
SB, the solution to that very conundrum was noted in the comments to this post from yesteryear.
The magic of names isn't quite a propos. Does a cookie jar, with the word "this" written on the inside, contain itself?
The property that saves the self-exhibiting museums has more to do with the interplay between exhibition and observation (in constrast to containment, for example, which neither requires nor admits an observer the same sense).
Thanks, apostropher! I wonder, is there anyone who can generate more than one level of meta-head?
Only our Lord and Savior, Jesus Christ.
How much head would the Godhead give if the Godhead could give head?
No, SB, but then, you can't follow the sign "this" to another cookie jar. You can follow a hyperlink to its destination.
This is why structures that contain themselves are possible in C.
Hey, everybody! Blogger is working again, which means comments at my blog are working again, which means that you could actually post your comments on this at my blog, where the goddam post is.
Why, no, I'm not frustrated at all; thank you for asking.
Gary, through a supreme act of will, I've foregone my own private amusement and not deleted that comment.
SB, it seems like you're having trouble with impredicability and the answer mayl have to be resolved with type theory. Thus allowing one to argue the MOOM is a different type of museum than the online-museums it catalogues.
Yeah, eruption of momentary silly over-reaction. My bad.
The discussion of static v dynamic typing in the article to which Michael linked is pretty incomplete without mentioning loose v strict typing; eg, C has static typing (ignoring varargs) but there are no guarantees that the program is using values correctly because it also has extremely loose typing.
the hell you say??
(I'm looking up "varargs" now, no guarantees I'll actually read the stuff)
varargs is what allows functions like printf() to work. The last argument to a function can just be written "...". "man va_start" will tell you what's what.
Here's a not-too-informative presentation: Haskell has static and strict/strong typing: a variable's type is known at compile time, and it never changes. C has static and loose typing: a variable's type is known at compile time, but you can change it using casts, or via type promotion--adding a char to an int or doing pointer arithmetic. Python has dynamic and strict typing: you never declare a variable's type, but you can't change it and the language won't change it for you during runtime—"6 + 'hi'" doesn't work. (You can rebind names—"x = 5; x = file("foo"); x = ord(0)" is valid—but the values bound to the name are strongly typed.) Perl has dynamic and loose typing: you never declare a variable's type, and you can change it on the fly, and the language will change it for you during runtime, so that "6 + "hello"" is not an error (I think it's 6).
Now that I think of it "strong" and "weak" might be more usual terms than "strict" and "loose". Whatever, I'm tired.
Good thing I previewed. I just attempted to re-say what you had previously said, thinking I was doing a fine job, but now we're off in programming-nerdistry. I just downed a double Dickel on the rocks and am going to relax a bit before attempting any masoachistic task of trying to understand what you just said.
Aren't you a philosopher, anyway?
Yeah, and my understanding of type theory is its application in the philosophy of math, not so much in programming.
The really insane modern functional languages (Haskell, SML) are basically applications of math.
Combinatory Haskell programmer
(eschews variables, if not obfuscation;
all this currying's just a phase, though it seldom hinders)
s f g x = f x (g x)
k x y = x
b f g x = f (g x)
c f g x = f x g
y f = f (y f)
cond p f g x = if p x then f x else g x
fac = y (b (cond ((==) 0) (k 1)) (b (s (*)) (c b pred)))
seriously, you doing this to me on purpose?
If you think that I am not contemplating a post about whether a sentence that contains a hyperlink on a demonstrative (e.g., "I didn't understand this comment") is directly referential, you are sadly mistaken.
I think it should be analogized to an utterance in which the speaking of the demonstrative is accompanied by a gesture of pointing towards the referent. Or maybe it shouldn't be.
In Tristram Shandy, during, I think, the birth of Tristram, Tristram-the-narrator describes his uncle's saying something and simply dropping out any sort of pronoun or noun in favor of simply exhibiting that to which he refers.
I might should add that I don't really understand Haskell. I get lost every time I come up against monads.
every time I come up against monads.
I love it when you talk all dirty like that.
Me an' Leibnixxx gettin' mad rutty.