00:04:47 -!- sebbu has quit ("@+").
00:15:17 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
00:26:28 -!- RedDak has quit (Read error: 113 (No route to host)).
01:20:59 -!- calamari has joined.
01:27:57 <calamari> RodgerTheGreat: working on a FUSE filesystem, it's quite a struggle
01:28:21 <RodgerTheGreat> I've heard they can be rather tricky. What is it sitting on top of?
01:30:46 <calamari> the easy part is working fine.. python program that breaks up a file (for example a disk image) into blocks and compresses each one with bzip2
01:31:19 <calamari> then when mounted, the FUSE fs makes it appear that the original image is there
01:32:13 <calamari> it works okay with raw blocks (if the bz2 was larger than the block size, I throw it out and just store the raw). But the bz2 randomly crashes
01:32:44 <calamari> my best guesses are a memory leak or a concurrency problem
01:37:07 <calamari> which language is that written in?
03:16:09 <calamari> yay, it was fine.. I guess FUSE does threads, and my code isn't thread safe
03:17:51 * calamari reworks .. can't write to globals
03:19:28 <calamari> hmm, never mind.. this is fine for reading but it won't work for writing
03:20:43 <calamari> unless fuse is smart about that
03:21:40 -!- ihope has joined.
03:23:19 <ihope> What's the shortest ski form of \a.`k`k``axy?
03:25:05 <ihope> Hopefully it's not ``s`kk``s`kk``s``si`kx`ky.
03:27:04 -!- Sukoshi has joined.
04:18:34 -!- RodgerTheGreat has quit.
04:53:49 <Sukoshi> GregorR: Can you use sane C pointer syntax in C++ ?
04:57:02 -!- bsmntbombdood has quit (Read error: 104 (Connection reset by peer)).
05:15:27 <Sukoshi> Yay. Stupid C++ reference BS.
05:17:13 <pikhq> The C++ "&" types don't need to be used if you don't want it; char * is still a perfectly cromulent type.
05:17:18 <calamari> it's funny because cat /dev/zero > a is actually making it take less space (0's compress well)
05:18:05 <Sukoshi> Because I'm not comfortable with that high-level pointer nonsense.
05:19:07 <pikhq> I've not actually *used* it at all.
05:19:33 <Sukoshi> Wait, the new-reference stuff you mean?
05:19:59 <pikhq> The C++ reference junk.
05:29:29 <ihope> Did somebody mention pointers?
05:29:39 * ihope dons a gas mask and heavy gloves
05:36:47 -!- GregorR-L has joined.
05:48:09 -!- calamari has quit ("Leaving").
06:36:24 -!- ihope has quit (Read error: 110 (Connection timed out)).
06:47:40 -!- bsmntbombdood has joined.
06:50:54 -!- ihope_ has joined.
06:50:56 -!- ihope_ has changed nick to ihope.
06:52:16 -!- bsmntbom1dood has joined.
06:56:47 -!- bsmntbombdood has quit.
06:57:22 -!- bsmntbom1dood has changed nick to bsmntbombdood.
07:17:23 -!- ihope has quit (Read error: 110 (Connection timed out)).
07:44:42 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
07:45:47 -!- puzzlet has joined.
07:46:40 -!- cherez has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:38:36 -!- oerjan has joined.
08:51:22 -!- oerjan has quit ("leaving").
09:04:27 -!- cherez has quit ("Leaving.").
09:55:20 -!- helios24 has joined.
09:55:31 -!- helios24 has quit (Client Quit).
09:56:30 -!- helios24 has joined.
09:56:58 -!- helios24 has quit (Client Quit).
09:57:54 -!- helios24 has joined.
09:58:53 -!- helios24 has quit (Client Quit).
09:59:18 -!- helios24 has joined.
11:25:10 -!- ehird` has joined.
13:48:36 -!- ihope_ has joined.
13:48:37 -!- ihope_ has changed nick to ihope.
14:36:43 -!- RedDak has joined.
15:16:15 -!- oerjan has joined.
15:25:40 -!- RodgerTheGreat has joined.
15:29:01 <ehird`> error : syntax anomaly at 'morning, folks\nMorn'.;
15:29:01 <ehird`> unexpected ;, expecting id
15:29:30 <oerjan> ERROR - Improperly terminated character constant
15:29:57 <ehird`> you're using a stone-age language with ' as the character-marker? :P
15:30:10 <oerjan> yep, one known as Haskell.
15:30:20 <ehird`> error : syntax anomaly at 'morning, folks\nMorn'.;
15:30:20 <ehird`> unexpected o, expecting '
15:36:44 -!- fizzie has quit (Read error: 54 (Connection reset by peer)).
15:38:09 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
16:08:29 -!- sebbu has joined.
16:15:07 -!- oerjan has quit ("leaving").
16:36:01 -!- ihope_ has joined.
16:52:45 -!- ihope has quit (Read error: 110 (Connection timed out)).
17:04:19 <SimonRC> Sukoshi: You aren't using Schildt as a reference are you?
18:03:53 <ehird`> bsmntbombdood, surely you mean (#\M . (#\o ...
18:04:21 <bsmntbombdood> the abbreviated list syntax should be used whenever possible
18:21:44 -!- cherez has joined.
18:25:32 -!- ihope__ has joined.
18:25:36 -!- ihope__ has changed nick to ihope.
18:37:10 -!- ihope_ has quit (Read error: 110 (Connection timed out)).
18:45:11 -!- aschmack has joined.
18:45:57 <aschmack> !bf ++++++++++++++++++++++++++++++++[>+>+<<-]
18:46:03 -!- aschmack has quit (Client Quit).
18:49:57 -!- jix has joined.
18:57:42 <Sukoshi> Except that he can't use copy/paste, obviously.
19:12:27 <ehird`> !bf ++++++++++++++++++++++++++++++++[>+>+<<-]>>+++++++++++++++++++++++++<< ++++++++++[>>.-<.<-]
19:12:54 -!- blahbot` has joined.
19:12:55 <ehird`> %bf ++++++++++++++++++++++++++++++++[>+>+<<-]>>+++++++++++++++++++++++++<< ++++++++++[>>.-<.<-]
19:13:10 <blahbot`> quit, eval, ps, kill, cmds, help, reload, join, part, send, topic, raw, bf, parse, reduce, wapr (use %help for argument information)
19:13:20 <ehird`> %wapr nobody loves wapr!
19:13:21 <blahbot`> [72, 73, 60, 73, 62, 83, 70, 73, 80, 63, 77, 81]
19:46:34 <ihope> May or may not be right, depending on how you look at it.
19:47:38 <ihope> %reduce $$^x^yx^yyA
19:47:45 <ihope> I think that's definitely wrong.
19:47:52 <ihope> %reduce $$^x^yx^zzA
20:02:37 -!- jix has quit (Nick collision from services.).
20:02:51 -!- jix has joined.
20:23:42 -!- ihope__ has joined.
20:24:23 -!- ihope has quit (Nick collision from services.).
20:24:25 -!- ihope__ has changed nick to ihope.
20:54:54 -!- ihope__ has joined.
21:04:50 -!- ihope has quit (Nick collision from services.).
21:04:53 -!- ihope__ has changed nick to ihope.
21:21:23 <ihope> Some would say that the worst type of language is that in which given a piece of code, knowing what it actually does requires knowledge of all the rest of the code as well.
21:22:46 <ihope> ...though your example is most likely better than mine, seeing as how a++ might be very obvious.
21:23:04 <ihope> Likewise, that the best type of language is that in which given a piece of code, even a very small one, you can probably tell exactly what it does and why it does it.
21:23:16 <cherez> And noone likes old BASIC.
21:24:02 <ihope> Others would argue that an extension of a language must be better than the original.
21:24:39 <cherez> Only in the hands of someone who knows when to use the extensions.
21:25:02 <ihope> Perhaps the extension consists of a switch which can be placed at the top of the main file so as to make every built-in function do something completely different.
21:25:16 <cherez> It seems the focus of Computer Science nowadays is asserting that you must use the extensions whenever possible.
21:25:18 <ihope> a++ meaning "decrement the value at a", perhaps.
21:25:39 <ihope> There are all kinds of philosophies you could bring in.
21:25:59 <ihope> Some philosophies directly contradict each other.
21:26:57 <ihope> Here, have some philosophy: Every piece should be as small and generally useful as possible.
21:27:37 <ihope> And being small being more important than being generally useful.
21:28:37 <ihope> (Do I look like I'm collecting obscure English language constructs and using them whenever I feel like doing so?)
21:28:39 <SimonRC> http://www.jwz.org/doc/worse-is-better.html
21:28:53 <cherez> So the best program immediately returns.
21:30:29 <ihope> That's not useful.
21:30:57 <cherez> And being small is more important.
21:31:14 <ihope> Okay. Being useful is more important than being small. Being small is more important than being generally useful.
21:31:27 <SimonRC> to quote my linked document: "# Simplicity-the design must be simple, both in implementation and interface. It is more important for the implementation to be simple than the interface. Simplicity is the most important consideration in a design.
21:31:40 <ihope> And being correct is more important than being useful.
21:32:18 <ihope> Better to give no answer than to give a wrong answer, since if you give no answer, it's obvious that you didn't give the right answer.
21:32:22 <SimonRC> "The good news is that in 1995 we will have a good operating system and programming language; the bad news is that they will be Unix and C++."
21:32:42 <ihope> There's all kinds of philosophy we could come up with...
21:34:14 <ihope> Maybe this: know exactly what you're doing and do it.
21:34:50 <ihope> Know exactly what you want to do. Do exactly what you want to do.
21:35:18 <lament> ihope: the ability to give wrong answers is what differentiates humans and AI from dumb machines.
21:36:17 <SimonRC> ihope: The waterfall model?
21:36:23 <ihope> SimonRC: waterfall model?
21:36:40 <SimonRC> yeah, "Know exactly what you want to do. Do exactly what you want to do." == waterfall modle
21:41:42 <ihope> The waterfall model looks more like "make everything be in the same phase".
21:44:47 <SimonRC> the waterfall model falls apart at the first half of your description: requirements
21:46:30 <ihope> So the waterfall model is avoiding things like "I want each function to do what the other doesn't" and "I *think* I've handled all the cases I need to"?
21:48:36 <ihope> The first one isn't knowing exactly what you want to do because you're not specifying just where the dividing line between the functions goes. The second one isn't doing exactly what you want to do because you might easily have missed a case.
21:48:38 <SimonRC> The problem is that the user doesn't really know what they *need*.
21:48:54 <SimonRC> even if the user thinks they know what they need, they're likely to be wrong in some ways
21:49:23 <ihope> Mm, I'm not actually sure what this philosophy is for.
21:49:41 <ihope> Languages, constructs or programs.
21:50:56 -!- ihope has left (?).
21:51:56 -!- ihope has joined.
21:52:17 <ihope> How is that the waterfall model?
21:52:25 <ihope> ...er, maybe I see.
21:52:40 <ihope> Both are "know what you do before you do it"?
21:55:48 -!- Sukoshi` has joined.
22:02:54 -!- RedDak has joined.
22:04:06 <SimonRC> ihope: or rather, don;t do anything until you know exactly what you are going to do
22:04:54 <ihope> Always be simple/consistent, never be wrong.
22:06:37 <lament> a very ineffective strategy :)
22:06:57 <ehird`> SimonRC, worse is not better
22:06:59 <ehird`> and better is not better
22:07:13 <ehird`> i propose, instead, that snakes and chickens is better, which is the philosophy i follow
22:07:30 <ihope> lament: ineffective?
22:07:39 <ehird`> it is a bit like the integers and real numbers versus the complex numbers, two follow the same sort of line and one is completely different
22:08:52 <lament> ihope: like i said, the ability to make errors and act on heuristics is one of the differences between humans/strong AI and dumb machines
22:12:03 -!- Sukoshi has quit (Read error: 110 (Connection timed out)).
22:12:20 <ehird`> i guess my metholodogy is like a less-specified agile strategy without the stupid parts and without the hype
22:12:52 <ehird`> it advocates a simple interface whenever possible, though if you can get a great shortage in code size without too much loss of interface quality, do it
22:13:08 <ehird`> hard-to-understand and complex bits of code should be abstracted away in a certain place
22:13:28 <ehird`> you should be able to read the code as a description of "what this does", not "how this does that". abstracting away complex hacks helps immensely
22:14:04 <ihope> A type system powerful enough to express exactly what a function does would be quite nice.
22:14:26 * pikhq has a simple methodology. . . "Make the program work. Make it readable. Make it beautiful."
22:14:54 <cherez> ihope: SortedSequence sort(Sequence);?
22:15:13 <ihope> I think Unlambda fits the category of languages in which you can take a small piece and tell exactly what it does.
22:15:15 -!- jix has quit ("CommandQ").
22:15:26 <ihope> Though it can't tell you why it does it.
22:16:16 <cherez> A type system that expresses exactly what a function does.
22:16:35 <lament> that's... rather difficult
22:16:41 <lament> Integer+2 Add2(Integer)
22:17:06 <lament> MaybeHaltsOrMaybeDoesn't HaltingProblem(void)
22:17:21 <ihope> Could be very difficult, given all this incompleteness and undecidability.
22:17:29 <pikhq> cherez: I invite *you* to do it. :p
22:18:39 <ihope> Doesn't Epigram restrict recursion for the sake of decidability?
22:18:47 <lament> GodKnowsWhatThisCouldPossiblyReturn input(FileStream)
22:19:01 <GregorR> I have written a program to tell you if another program will halt. Unfortunately, it has the nasty tendency of taking forever if the program being tested doesn't halt >_>
22:19:22 <pikhq> FileStreamInput input(FileStream)
22:19:35 <ehird`> ihope, that's just a turing-complete type system
22:19:43 <ehird`> incidentally, we call the signatures in those "code"
22:19:49 <pikhq> GregorR: Run it on itself. . .
22:20:07 <ihope> Epigram's type system is Turing-complete?
22:20:10 <SimonRC> ihope: It seems that you can write any sensible program in Epigram.
22:20:37 * ihope loads up the weird Epigram stuff
22:21:25 <pikhq> Any result is a paradox. ;)
22:21:26 <lament> ProbablyAlwaysReturns2 SmallestNumberOfPrimesAddingUpTo(PositiveEvenInteger)
22:21:38 <cherez> I suppose you could use that kind of a type system as a cleaner implementation of asserts....
22:21:48 <ihope> You know, Epigram has a type that can only hold numbers that are not multiples of 2.
22:22:19 <lament> ihope: is that so difficult?
22:22:32 <ihope> ...er, multiples of 3, I meant.
22:22:49 <ihope> If you can write any sensible program in Epigram, it probably also has a type that can only hold Turing machines that halt.
22:24:13 <lament> does it have a type for all integers except 1,3 and 41893?
22:24:33 <lament> it's not like it's very hard to implement
22:24:42 <pikhq> Does it have a type for all integers that are not real numbers?
22:24:50 <ihope> pikhq: what doesn't?
22:25:10 <ihope> Here it is in Haskell: data NonRealInteger
22:25:26 <ihope> Most languages don't have types that hold no values at all?
22:25:28 <lament> C only has a pointer to it :)
22:25:51 <lament> ihope: i can't think of any (other than the aforementioned haskell definition)
22:27:01 <ihope> Of course, most languages probably have only a finite number of types, yes?
22:28:12 <ihope> Yes, but can there ever actually be an infinite number of them, or just many many many?
22:28:34 <ihope> s/many many many/arbitrarily many/, to be a bit more exact
22:28:45 <bsmntbombdood> i think there can be an infinite many in most languages
22:28:58 <lament> ihope: any language with polymorphic types presumably has infinitely many
22:29:05 <lament> ihope: a list, a list of lists, a list of lists of lists....
22:29:37 <SimonRC> is void a proper type in C++?
22:29:47 <SimonRC> It ought to be, for parameterisation purposes.
22:30:07 * ihope ponders his piece of Epigram
22:30:46 <SimonRC> actually, void would work quite well if sizeof(void) == 0
22:30:54 <SimonRC> indexing is pointless, for a start
22:31:19 <SimonRC> it takes up no space as a return value...
22:32:54 <ehird`> sizeof(void) == 0 -> sizeof(*voidptr) == 0 -> oh no
22:34:21 <lament> it's difficult to have a completely empty type in a language where you have to explicitly create variables and assign a type to them, after which they hold some value (like C++)
22:34:37 <lament> since you shouldn't be able to do that
22:35:08 <lament> it should only work if you can't use the value in any way
22:35:13 <SimonRC> nah, you just say that its only value is automatically cast to and from the integer 0, and to and from the null pointer
22:35:21 <lament> void v, w; // v and w don't hold anything
22:35:47 <lament> if (v == w) // wrong!!! this should result in an error, you can't compare nothing with nothing
22:36:05 <lament> what would the result be?
22:36:13 <SimonRC> The void typ would be analogous to the 90 type in Haskell
22:36:21 <lament> don't confuse a type with one member with a type with 0 members
22:36:37 <SimonRC> the void type should have 1 possible value
22:36:49 <lament> we were talking about the type "integers that aren't real numbers"
22:36:55 <lament> such a type has no members
22:38:22 * ihope decides to use "specify everything" as his Epigram philosophy for now
22:39:06 <lament> ihope: you actually program in that thing?
22:39:22 <ihope> How many questions am I being asked?
22:39:33 <ihope> I don't actually program in it. I did get it to work.
22:39:37 <SimonRC> I mean, did you get the emacs mode to work?
22:39:59 <lament> epigram looks pretty ugly.
22:40:01 <SimonRC> It seems you can't go back and edit old bits of the program though
22:40:40 <ihope> "enclose a b f r x : Result a b f r"
22:40:44 <ihope> You can. It's just difficult.
22:41:42 <ihope> Or weird or something.
22:41:46 <ihope> It's not obvious how to do it.
22:42:17 <ihope> I mean, it's specified in the paper.
23:04:49 * ehird` ought to put his philosophy down in words sometime
23:06:37 <ehird`> ohh you're talking about THAT epigram
23:06:47 <ihope> There's more than one?
23:07:07 <ehird`> umm, i think i know what you're talking about
23:07:41 <ihope> So what is your philosophy, roughly?
23:08:04 <ehird`> a few main points are:
23:08:29 <ehird`> 1. explicit is better than implicit, apart from when explicit is ugly and/or doesn't matter to the reader/hacker of the code
23:08:46 <ehird`> 2. hard-to-understand and complex bits of code should be abstracted away into simple terms!
23:09:01 <ehird`> 3. because of 2 and 1, code will describe /what/ it does, not /how/ it does it
23:09:24 <ehird`> 4. interface simplicity is important, but code simplicity is more important, UNLESS it impacts on interface simplicity greatly
23:09:40 <lament> 1 seems to imply how rather than what
23:09:42 <ehird`> 5. comments are to be used sparingly, to explain algorithms and abstracts, but not code - which, because of 3, should already be self-explanatory
23:09:48 <ehird`> lament, indeed, but just to clarify
23:09:57 <ehird`> how does 1 imply that?
23:10:05 <ehird`> 1 is basically "no hidden magic"
23:10:09 -!- Sukoshi` has changed nick to Sukoshi.
23:10:18 <lament> explicit better than implicit
23:10:21 <ehird`> don't BRUSH OVER things, sure, but don't make code a recipe... make it a description
23:10:38 <lament> doesn't that mean "a hash table with buckets of size 150" instead of "a dictionary"?
23:10:52 <ihope> Hash tables have buckets?
23:11:18 <ehird`> Sukoshi, Yes, prolog heads in the right direction for that
23:11:33 <ehird`> python follows explicit>implicit in a way, do you see things like that in it?
23:13:14 <ihope> Stupid limited auxiliary verbs!
23:14:19 <ihope> I wonder how I would go about removing those limits...
23:14:40 <ihope> I guess I don't often see people speaking in moods other than the indicative.
23:23:07 <lament> aren't you a native speaker?
23:24:00 <lament> learn to speak your own language :)
23:24:09 <ihope> Can't I learn to speak Spanish instead?
23:24:25 <ihope> There's no English word for "debiendo"!
23:25:32 <ihope> ...and it seems I am indeed sort of mentally translating into English, seeing as how I'm apparently unable to comprehend anything containing the word "debiendo".
23:25:56 <lament> eso tambien seria bueno, pero el espanol tiene los mismos problemas con verbos auxiliares
23:26:05 <Sukoshi> In Java, is it good practice to assign null to something that's uninitialized, and then check against null to see if it's uninitialized?
23:26:21 <ihope> Spanish has auxiliary verbs?
23:26:36 <ihope> (Perhaps it's not the "debiendo" that's the problem.)
23:26:53 <ihope> Well, I don't believe I'm familiar with auxiliary verbs in Spanish...
23:27:02 <lament> Sukoshi: is that _supposed_ to be a bunch of squares?
23:27:43 <lament> i assumed it was japanese since it's Sukoshi, but all i see is squares :)
23:28:05 <ihope> Well, if you're using the right character encoding and other scary things...
23:28:11 <lament> ihope: 'haber' is the main one, meaning the same as the english 'to have'
23:28:23 <lament> i have talked - he hablado; etc
23:28:57 <ihope> I'm not at all experienced with haber apart from its being used to mean "there is".
23:29:02 <lament> instead of "would", though, spanish has a separate tense
23:29:09 <Sukoshi> Je peux aussi parle en francais, mais ce n'est pas une langue interessante.
23:29:18 <lament> (would talk - hablaria)
23:29:30 <ihope> Is the problem with things like "I would have talked"?
23:29:52 <lament> there's a separate tense for 'would X' where X is a verb
23:30:05 <lament> in this case, would have - habria
23:30:22 <lament> and talked is just the past participle in both languages
23:31:21 <lament> Sukoshi: all languages are interesting, surely :)
23:32:23 <ihope> Where's the problem with auxiliary verbs, then?
23:33:56 <lament> i think the situation is the same as in english
23:34:08 <lament> i thought you just disliked auxiliary verbs in general
23:34:13 <Sukoshi> I have varying degrees of facillity in 5, and I disagree lament :P
23:34:13 <lament> is there a specific problem?
23:34:36 <ihope> Things like "should" don't have all the forms that "normal" verbs do.
23:34:47 <lament> ihope: when is it a problem?
23:35:05 <lament> Sukoshi: frankly, "varying degrees of facility" doesn't sound very impressive :)
23:35:22 <ehird`> why doesn't everyone use utf8
23:35:43 <ihope> ehird`: because everyone SHOULD be using UTF-7!
23:37:44 <ihope> lament: well, you might use the present participle instead of other forms when discussing... hypotheticals, I guess.
23:38:20 <lament> present participle of "should"?
23:38:22 <ihope> "The sky being red would be pretty cool."
23:38:25 <Sukoshi> lament: One of them I have native-level proficiency, the other I have native-high-school level facillity, a third I have somewhat-below native facillity, a fourth I have layman-speech facillity, and a fifth I have layman-peech facillity.
23:38:54 <lament> ihope: so... you just said it. What's the problem then? :)
23:38:58 <ihope> Hey, plain old imperfect subjunctive is iffy.
23:39:44 <Sukoshi> Plus both of you are complaining about a lack of Western language features :)
23:39:52 <lament> I'm not complaining about anything
23:40:32 <ihope> I guess "should" is sort of equivalent to "has to".
23:41:20 <lament> Sukoshi: i just don't understand how a language can be "uninteresting" :)
23:42:08 <ihope> "The sky is blue, so people should wear red glasses if they don't want to see the light from it. It'd be cool if the sky were red, so people would have to wear blue glasses if they didn't want to see the light from it."
23:42:52 <ihope> The actual case that rather frustrated me was a hypothetical philosophy.
23:43:15 <ihope> Rather exceptional, really.
23:43:31 <lament> Sukoshi: "Western language" is a rather odd term. Linguists would laugh at you.
23:43:38 <ihope> (I'd rather not use that word the same way three times in a row.)
23:44:18 <ihope> "Indo-European language"?
23:44:44 <Sukoshi> lament: What superfluous derivationally-correct term would they use to refer to it?
23:45:05 <lament> Sukoshi: i'm not sure, because i don't know what you meant
23:45:21 <lament> (which is exactly the reason for more exact terms)
23:45:34 <Sukoshi> Hmph. Have you never heard the term ``Western'' in speech before?
23:46:10 <Sukoshi> The ``Western'' world, for instance?
23:46:29 <Sukoshi> Used by historians a good deal too, IIRC.
23:46:39 <lament> Sukoshi: in that sense, "western language" makes sense, but "western language feature" not really
23:46:53 <lament> Sukoshi: since there're so many western languages with all sorts of different features
23:47:34 <Sukoshi> Unless you refer to the Celtic languages, which I've never really heard being included as part of the ``West'', I don't see the argument there.
23:48:14 <lament> Sukoshi: is basque a western language? Is Finnish?
23:48:36 <lament> then our notions of "western world" are quite a bit different
23:49:24 <lament> mine certainly includes western europe.
23:49:41 <Sukoshi> Well, you cannot exactly call the Moors ``Western''.
23:49:51 <Sukoshi> And I wouldn't call Finland ``Western Europe''.
23:50:05 <lament> see, this is why "western" is a rather unfortuante term :)
23:52:18 <lament> it's politically loaded, among other things
23:52:29 <lament> for example, http://en.wikipedia.org/wiki/Image:Clash_of_Civilizations_%E2%88%9E.png
23:52:53 <lament> Huntington thinks both Spain and Finland are in the "Western Civilization"