00:00:00 --- log: started forth/13.01.21
00:00:11 --- quit: protist (Ping timeout: 240 seconds)
00:24:48 --- quit: rabenauge (Remote host closed the connection)
00:26:20 --- join: rabenauge (~sag@i59F6BB88.versanet.de) joined #forth
00:26:20 --- mode: ChanServ set +v rabenauge
00:27:25 --- join: protist (~protist@125-237-130-19.jetstream.xtra.co.nz) joined #forth
00:27:25 --- mode: ChanServ set +v protist
00:30:50 --- join: epicmonkey (~epicmonke@188.134.41.175) joined #forth
00:30:50 --- mode: ChanServ set +v epicmonkey
00:37:47 --- join: proteusguy (~proteusgu@cm-171-98-97-11.revip7.asianet.co.th) joined #forth
00:37:47 --- mode: ChanServ set +v proteusguy
00:53:08 --- quit: epicmonkey (Ping timeout: 244 seconds)
01:24:37 --- quit: proteusguy (Remote host closed the connection)
01:48:06 --- join: proteusguy (~proteusgu@ppp-115-87-199-155.revip4.asianet.co.th) joined #forth
01:48:07 --- mode: ChanServ set +v proteusguy
02:03:33 --- join: epicmonkey (~epicmonke@host-224-58.dataart.net) joined #forth
02:03:33 --- mode: ChanServ set +v epicmonkey
02:37:16 --- join: foxes (~fox@124.193.192.54) joined #forth
02:37:16 --- mode: ChanServ set +v foxes
02:41:22 --- quit: Fox78 (Ping timeout: 252 seconds)
03:52:24 --- join: Fox78 (~fox@123.125.33.110) joined #forth
03:52:24 --- mode: ChanServ set +v Fox78
03:53:08 --- quit: foxes (Ping timeout: 248 seconds)
04:18:54 --- join: foxes (~fox@123.235.38.22) joined #forth
04:18:54 --- mode: ChanServ set +v foxes
04:22:11 --- quit: Fox78 (Ping timeout: 240 seconds)
04:48:05 --- quit: nighty^ (Read error: No route to host)
04:50:33 --- join: nighty^ (~nighty@tin51-1-82-226-147-104.fbx.proxad.net) joined #forth
04:50:33 --- mode: ChanServ set +v nighty^
05:16:02 --- quit: Bahman (Remote host closed the connection)
05:44:09 --- join: kumul (~Kumool@173.215.194.228) joined #forth
05:44:09 --- mode: ChanServ set +v kumul
06:10:41 --- join: fantazo (~fantazo@213.129.230.10) joined #forth
06:10:41 --- mode: ChanServ set +v fantazo
06:19:51 --- quit: epicmonkey (Remote host closed the connection)
06:20:01 --- join: epicmonkey (~epicmonke@host-224-58.dataart.net) joined #forth
06:20:01 --- mode: ChanServ set +v epicmonkey
06:22:54 --- join: I440r (~zhiming@150.sub-70-194-67.myvzw.com) joined #forth
06:22:54 --- mode: ChanServ set +o I440r
06:45:23 --- quit: protist (Quit: leaving)
07:07:43 --- quit: fantazo (Ping timeout: 244 seconds)
07:37:12 --- join: IAmHere_ (~IAmHere@c-75-70-11-91.hsd1.co.comcast.net) joined #forth
07:37:12 --- mode: ChanServ set +v IAmHere_
07:39:39 --- quit: IAmHere (Ping timeout: 255 seconds)
07:39:39 --- nick: IAmHere_ -> IAmHere
09:06:38 --- join: ncv (~quassel@unaffiliated/neceve) joined #forth
09:06:38 --- mode: ChanServ set +v ncv
09:19:47 --- join: MayDaniel (~MayDaniel@unaffiliated/maydaniel) joined #forth
09:19:47 --- mode: ChanServ set +v MayDaniel
09:47:28 --- join: ASau (~user@46.115.91.173) joined #forth
09:47:29 --- mode: ChanServ set +v ASau
10:10:32 <kumul> new isforth version huh?
10:29:20 --- join: IAmHere_ (~IAmHere@c-75-70-11-91.hsd1.co.comcast.net) joined #forth
10:29:20 --- mode: ChanServ set +v IAmHere_
10:31:15 --- quit: IAmHere (Ping timeout: 248 seconds)
10:31:15 --- nick: IAmHere_ -> IAmHere
10:51:31 --- quit: kulp (Ping timeout: 248 seconds)
10:52:59 --- quit: epicmonkey (Ping timeout: 244 seconds)
11:03:41 --- join: JDat (JDat@89.248.91.5) joined #forth
11:03:41 --- mode: ChanServ set +v JDat
11:05:55 <I440r> yes
11:06:05 <I440r> and another one again as soon as ive rewritten the debugger
11:06:18 <I440r> i just did some semi minor surgery on the decompiler
11:06:27 <I440r> but the debugger will require an almost complete rewrite
11:06:32 <I440r> the design was very flawed
11:10:04 <I440r> see.s if cleaner now but its still one huge wall of source code. problem is, i cat see any clean ways of modularizing it
11:10:24 <I440r> well i sort of can but ill still have one file thats a large wall of source code.
11:10:44 <I440r> making it semi pointless.  need to see a better way to break it up
11:37:37 --- join: xpoqp (~xpoqd@unaffiliated/xpoqz) joined #forth
11:37:37 --- mode: ChanServ set +v xpoqp
12:00:19 --- join: epicmonkey (~epicmonke@188.134.41.175) joined #forth
12:00:19 --- mode: ChanServ set +v epicmonkey
12:43:58 --- join: Onionnion (~ryan@adsl-68-254-165-254.dsl.milwwi.ameritech.net) joined #forth
12:43:59 --- mode: ChanServ set +v Onionnion
13:16:52 --- join: kulp (~kulp@unaffiliated/kulp) joined #forth
13:16:52 --- mode: ChanServ set +v kulp
14:21:40 --- quit: JDat (Quit: Shlaaphen!)
14:25:49 --- join: Onionnion|Eee (~ryan@adsl-68-254-165-254.dsl.milwwi.ameritech.net) joined #forth
14:25:49 --- mode: ChanServ set +v Onionnion|Eee
14:31:12 --- quit: I440r (Ping timeout: 248 seconds)
14:44:35 --- join: Nisstyre (~yours@oftn/member/Nisstyre) joined #forth
14:44:35 --- mode: ChanServ set +v Nisstyre
14:58:56 --- join: I440r (~zhiming@167.sub-70-194-68.myvzw.com) joined #forth
14:58:56 --- mode: ChanServ set +o I440r
15:09:40 --- quit: ASau (Remote host closed the connection)
15:24:56 --- quit: MayDaniel (Read error: Connection reset by peer)
15:44:03 --- join: karswell (~user@93-97-29-243.zone5.bethere.co.uk) joined #forth
15:44:03 --- mode: ChanServ set +v karswell
15:45:33 --- join: RodgerTheGreat (~rodger@71-13-215-242.dhcp.mrqt.mi.charter.com) joined #forth
15:45:33 --- mode: ChanServ set +v RodgerTheGreat
15:48:00 <RodgerTheGreat> 'sup all
15:52:41 --- quit: Onionnion|Eee (Quit: Leaving)
15:53:40 --- quit: IAmHere (Ping timeout: 248 seconds)
15:57:44 <kulp> i'm avoiding learning the linear algebra i need to do my job :(
15:57:45 <kulp> you ?
15:58:39 <RodgerTheGreat> I just made it home and I am taking a break before resuming work on this fucking analysis pass
15:59:11 <kulp> haha
15:59:17 <kulp> llvm ?
15:59:27 <RodgerTheGreat> good lord no
16:00:10 <kulp> well that would have explained the enragement
16:00:10 <kulp> ;)
16:00:56 <RodgerTheGreat> llvm and gcc internals are both terrible, for different reasons
16:01:11 <RodgerTheGreat> they are both sprawling monsters
16:02:41 <kulp> i hear llvm likes to change its shape of monstrousness every six months
16:02:57 <kulp> the compiler team is almost fed up with having to update code for every API change
16:03:45 <RodgerTheGreat> they both have bloody awful documentation
16:04:00 <RodgerTheGreat> in the case of LLVM it is mostly autogenerated and unhelpful
16:04:10 <RodgerTheGreat> in the case of GCC it is ancient and it lies
16:04:20 <RodgerTheGreat> I'm not really sure which is worse
16:04:22 <kulp> haha
16:04:30 <kulp> so are you using your own framework, or what
16:04:43 <RodgerTheGreat> I'm building a standalone prototype
16:04:50 <RodgerTheGreat> so basically yes
16:05:00 <kulp> \o/
16:05:18 <kulp> i started writing a C pass framework for mine
16:05:18 <RodgerTheGreat> I can spoonfeed it CFGs and observe the results
16:05:26 <kulp> and then i got so bogged down i had to integrate lua to get anywhere
16:05:30 <kulp> my poor puny brain
16:06:34 <RodgerTheGreat> I will eventually have to port my code to C and try to integrate it with GCC but I would go completely fucking insane if I tried to debug my algorithms and GCC at the same time
16:06:50 <kulp> what are you writing it in right now ?
16:06:53 <RodgerTheGreat> Java
16:06:55 <kulp> yeah that's what happened to me
16:07:00 <kulp> i'm not a clever man
16:07:11 <kulp> for one's first compiler one should not write a c compiler in c
16:07:24 <RodgerTheGreat> mmm
16:07:47 <kulp> so to get anywhere i'm sure i will eventually write an llvm backend, separately
16:08:01 <kulp> and then if i have any hair left to tear out i will go back to the original project
16:08:23 <RodgerTheGreat> every time I try to write something non-trivial in C I end up wasting a huge amount of time writing and debugging data structures. It is in my opinion essentially useless for real work unless you have an inordinate amount of time, are insane or both
16:08:57 <RodgerTheGreat> it has every downside to writing applications in forth with none of the power or flexibility
16:09:56 <kulp> well, yes, if you need sophisticated data structures
16:10:11 <kulp> i've had the good fortune to write small self-contained apps
16:10:17 <RodgerTheGreat> when I must write C I write and debug in Java first, simplify as much as I can and then hand-convert to C
16:10:26 <kulp> and the poor memory to forget how much quicker it was to prototype things in perl
16:11:25 <RodgerTheGreat> in this way I catch all my logical errors well ahead of time in a language with good tooling and when I get to C I'm only tracking down typos and minor things like that
16:11:38 <kulp> not a bad idea
16:11:57 <kulp> and you can check the new implementation against the proven one
16:12:03 <kulp> next you'll be having me writing java :(
16:12:05 <RodgerTheGreat> bingo
16:12:21 <kulp> i realised the other day i don't really know any statically-typed langs comfortably besides C
16:12:24 <kulp> seems like a big gap
16:13:18 --- quit: epicmonkey (Ping timeout: 245 seconds)
16:13:32 <RodgerTheGreat> especially given that C only has a type system by the barest of margins
16:14:07 <RodgerTheGreat> C# isn't terrible either but from a practical perspective running it on anything but windows is a joke
16:14:41 <RodgerTheGreat> I have tried to like Go, but it's full of goofy design decisions that exist for no reason
16:14:57 <RodgerTheGreat> there's like 6 different ways to declare a variable with slightly different semantics
16:15:03 <RodgerTheGreat> optional semicolons
16:16:24 <RodgerTheGreat> The go tutorial was like "a simplified, modern language sorta like C" and I was extremely excited. My enthusiasm was slowly eroded by how ugly and inconsistent the syntax and language features were.
16:16:40 <kumul> dont debate or point stuff like that here, try #go-nuts
16:16:48 <RodgerTheGreat> eh
16:17:10 <RodgerTheGreat> anyway Java and Forth are two languages which I find aesthetically pleasing in their own ways
16:17:12 <kumul> im sure the reason they chose to do it that way isnt "for no reason"
16:17:47 <RodgerTheGreat> kumul: I apply hyperbole. Reasons include "because shorter code is simpler, I guess"
16:18:05 <RodgerTheGreat> ie bad reasons rather than completely nonexistent reasons
16:20:12 <RodgerTheGreat> kumul: is there anyone who uses Lua who actually likes the 1-indexed lists?
16:20:17 <kumul> as i said, debate the reasoning in #go-nuts, not to me
16:20:33 <kumul> yes, look at the Ml list
16:20:41 <kumul> you can change that in the .h
16:21:01 <kumul> as well, ask in #lua
16:21:19 <kumul> it seems 50/50 annoyance
16:28:09 <kumul> im sorry, im too much of a fanboy to stay coherent
16:28:17 <RodgerTheGreat> ok
16:32:15 <kulp> fortran programmers love the 1-indexed lists i'm sure
16:32:24 <kulp> :)
16:33:37 <RodgerTheGreat> despite the large demand for compiling and running fortran programs in this day and age I have yet to see anyone actually writing code in the language
16:33:48 <RodgerTheGreat> I believe that most of the fortran run today was written 30 years ago
16:34:12 <kulp> you are mostly correct :P
16:34:16 <RodgerTheGreat> presumably the souls of said programmers walk the earth, restless
16:34:24 <kulp> i in fact just edited some of that 30-year old code ... five minutes ago
16:34:34 <kulp> no they still work at ORNL
16:34:35 <kulp> :)
16:34:43 <kulp> good old jack
16:34:52 <kulp> http://www.netlib.org/utk/people/JackDongarra/
16:35:11 <RodgerTheGreat> this is related to the theory that there was only ever one original COBOL program and all other programs were modified from that common ancestor
16:35:47 <kulp> IDENTIFICATION DIVISION
16:35:51 <kulp> ^ that's all the COBOL i know
16:35:57 <kulp> but it's already too much
16:36:10 <kulp> who has a keyword that's ... 14 characters long !
16:36:39 <RodgerTheGreat> ADD FIFTY TO CHARACTER_COUNT GIVING CHARACTER_COUNT
16:36:50 <kulp> haha what
16:36:56 <kulp> i mean does it really parse "FIFTY"
16:37:14 <RodgerTheGreat> even if it doesn't dollars to donuts somebody has defined it as a constant
16:37:45 <RodgerTheGreat> ADD _ TO _ GIVING _ is real syntax though
16:38:26 <kulp> yeah i recognise that
16:43:07 <kulp> i hear that fortran can't be parsed with a typical parser generator's parser
16:43:22 <kulp> maybe that's just because of the format / picture stuff though
16:43:53 <RodgerTheGreat> it straight up has an ambiguous grammar
16:44:26 <kulp> well so does C innit, with "if - else"
16:44:38 <RodgerTheGreat> you don't need whitespace at all between keywords and/or identifiers and it is possible to define variables with the same names as constants
16:44:50 <RodgerTheGreat> erm
16:44:57 <RodgerTheGreat> I mean variables with the same name as identifiers
16:45:21 <RodgerTheGreat> also you can typically assign to numeric literals thus changing the value of the number
16:45:47 <RodgerTheGreat> I believe this is a side effect of early IBM machines not having an immediate addressing mode and instead storing all constants in core
16:47:46 <RodgerTheGreat> when I made my fortran compiler I did an ad-hoc parser. Not supporting floating-point numbers actually helped a lot because it removed many possible ambiguities
16:48:07 <RodgerTheGreat> since variable names and variable types are inseparable in fortran
16:48:12 <RodgerTheGreat> (classically)
16:50:55 <RodgerTheGreat> until I wrote an implementation I had no idea that fortran didn't have any (non-array-based) form of indirection or user-defined types
16:51:55 <RodgerTheGreat> it slowly starts to dawn on you why it took programmers months or years to boostrap their first pascal or algol compilers out of fortran
16:52:18 <kulp> what do you mean by "variables with the same name as identifiers" ... variables names ARE identifiers
16:52:48 <RodgerTheGreat> kulp: oh wow my brain is not working
16:52:50 <RodgerTheGreat> I meant keywords
16:52:53 <kulp> oh okay
16:52:58 <kulp> yeah that would be problematic
16:53:02 <kulp> i mean the names
16:53:07 <kulp> (also your brain not working could be problematic too)
16:53:31 <kulp> for indirection there's Cray pointers ;)
16:53:34 <kulp> good old Cray
16:53:56 <RodgerTheGreat> but, like, you can't implement a recursive descent parser in fortran because fortran doesn't allow recursive procedure calls because when fortran was developed callstacks hadn't been invented
16:54:18 <kulp> yeah
16:54:22 <kulp> well i mean that's old fortran
16:54:31 <kulp> fortran is a living language ; it gets updated more and better than C :P
16:54:34 <RodgerTheGreat> well yeah I realize modern fortran has many of these features
16:54:35 <kulp> but i know what you mean
16:54:49 <RodgerTheGreat> we're talking fortran as in pre-80s
16:54:56 <RodgerTheGreat> or pre-70s even
16:55:13 <RodgerTheGreat> at the time when fortran was the only real language available
16:55:29 <RodgerTheGreat> before algol-60
16:55:37 <kulp> so why did you do a fortran compiler anyway
16:55:50 <RodgerTheGreat> a mixture of curiosity, boredom and masochism
16:56:11 <RodgerTheGreat> I found a paper describing the first draft of the language on the computer history museum's website
16:56:30 <kulp> aha
16:56:30 <RodgerTheGreat> and I attempted to implement a mostly accurate version of the language as described there
16:56:46 <kulp> does "attempted" imply a lack of success
16:56:55 <RodgerTheGreat> I left a few things out
16:57:14 <RodgerTheGreat> the original fortran had a much scarier version of the do loop
16:58:18 <RodgerTheGreat> it was something like "DO <VAR> = <MIN> : <MAX> <FIRST-LINE>, <LAST-LINE>, <RESUME-LINE>
16:58:30 <RodgerTheGreat> "
16:58:52 <RodgerTheGreat> with growing horror I came to understand that it had no mechanism for defining procedures
16:58:52 <kulp> i think i've written maybe one or two do-loops, and i probably couldn't do it without a reference
16:59:00 <kulp> i only know enough fortran to read it and update some constants here and there
16:59:03 <kulp> and that's good enough for me :P
16:59:15 <RodgerTheGreat> instead you use overlapping sequences of statement numbers in a do loop as a reuse mechanism
16:59:21 <kulp> oh haha
16:59:31 <kulp> you're still talking pre-f77 okay
16:59:33 <kulp> nice
16:59:44 <kulp> well i mean it's still better than BASIC right ? :)
16:59:48 <RodgerTheGreat> er
16:59:52 <RodgerTheGreat> no not really
17:00:01 <kulp> but you can do real maths with it !
17:00:05 <RodgerTheGreat> basic almost always had gosub
17:00:17 <RodgerTheGreat> early basic had complex and matrix datatypes
17:00:53 <kulp> :O
17:01:03 <RodgerTheGreat> basic's badness largely came from awful versions meant for 8-big microcomputers
17:01:04 * kulp rewrites BLAS in basic
17:01:25 <kulp> interesting
17:18:27 --- quit: proteusguy (Ping timeout: 264 seconds)
17:30:44 --- join: proteusguy (~proteusgu@ppp-58-8-104-96.revip2.asianet.co.th) joined #forth
17:30:44 --- mode: ChanServ set +v proteusguy
17:33:21 --- quit: ncv (Remote host closed the connection)
19:07:47 --- join: Onionnion|Eee (~ryan@adsl-68-254-165-254.dsl.milwwi.ameritech.net) joined #forth
19:07:47 --- mode: ChanServ set +v Onionnion|Eee
19:32:37 --- quit: kumul (Quit: Leaving)
20:28:45 --- quit: foxes (Ping timeout: 260 seconds)
20:29:20 --- join: foxes (~fox@123.125.33.110) joined #forth
20:29:20 --- mode: ChanServ set +v foxes
20:58:18 --- quit: Onionnion|Eee (Quit: Leaving)
21:34:54 --- join: IAmHere (~IAmHere@c-75-70-11-91.hsd1.co.comcast.net) joined #forth
21:34:55 --- mode: ChanServ set +v IAmHere
21:36:38 --- quit: kulp (Ping timeout: 252 seconds)
21:45:44 --- join: Bahman (~Bahman@bba141175.alshamil.net.ae) joined #forth
21:45:44 --- mode: ChanServ set +v Bahman
21:47:38 --- join: FLIMFLAM774 (~FLIMFLAM@blk-215-117-36.eastlink.ca) joined #forth
21:47:38 --- mode: ChanServ set +v FLIMFLAM774
21:51:26 <FLIMFLAM774> is there anyone here who could field a question abou a small piece of forth code?
21:51:37 <RodgerTheGreat> possibly?
21:52:01 <FLIMFLAM774> ok let me explain
21:52:41 <FLIMFLAM774> these two scripts are a part of a tutorial, but i cannot figure out why the COUNTS code works when the count is given as 1
21:53:00 <FLIMFLAM774> http://www.forth.com/starting-forth/sf2/2-6.forth
21:53:09 <FLIMFLAM774> and http://www.forth.com/starting-forth/sf9/9-1.forth
21:54:18 <I440r> because the do loop is effectivly 1 0 do .... loop in that instance
21:54:33 <I440r> that should howevr really be a ?do not a do
21:54:34 <FLIMFLAM774> if i run CONVICTED-OF 1 COUNTS HOMICIDE WILL-SERVE
21:54:54 <FLIMFLAM774> yea i realize that, it doesn;t expect you to know taht at that point
21:54:57 <FLIMFLAM774> but if i run taht it will work
21:55:08 <I440r> yes as long as you dont try 0 counts :)
21:55:12 <FLIMFLAM774> but shouldn;t it also run an additional +20 for the homicide
21:55:18 <I440r> wherein lies your confusion
21:55:42 <I440r> do this : test 1 0 do i . loop ;
21:55:44 <FLIMFLAM774> i expect the command 1 COUNTS HOMICIDE to produce a value of 40
21:55:54 <I440r> no
21:56:05 <I440r> 1 0 do will count 1 and then stop
21:56:26 <I440r> a for loop may or may not do an extra itteration as there is no standard for for
21:56:57 <I440r> 10 for can count 1 2 3 4 5 6 7 8 9 10  or 0 1 2 3 4 5 6 7 8 9 or 10 9  8 7 6 5 4 3 2 1 or 9 8 7 6 5 4 3 2 1 0
21:57:03 <I440r> depending on which forth you use
21:57:14 <I440r> which is another reason to use for loops sometimes
21:57:30 <I440r> the best test for you to do is do a do i . loop  type test
21:57:40 <I440r> and see exactly how many itterations you get
21:58:11 <FLIMFLAM774> i get 1 iteration displaying index 0
21:58:14 <FLIMFLAM774> as i expect
21:58:35 <FLIMFLAM774> but the problem is that im expecting teh actual HOMICIDE command to run after COUNTS ahs
21:58:52 <I440r> you itterated ONCE.  the index displayed was 0
21:59:00 <I440r> but your not passing the index, your merely itterating
21:59:17 <I440r> the index just showed you how many times the loop looped
21:59:44 <FLIMFLAM774> the index is the 'loop counter' relative to teh starting point of teh index right?
22:00:30 <RodgerTheGreat> on a side note I am increasingly impressed at how consistently you misspell the words "the" and "that"
22:00:38 <I440r> with a do loop the loop always counts up unless you specify something like -1 +loop
22:00:53 <I440r> i can type 35 wrong words per minute
22:01:04 <I440r> i always type T E H too
22:01:07 <I440r> its very common
22:01:26 <I440r> 10 0 do i . loop  will display 0 1 2 3 4 5 6 7 8 9
22:01:43 <FLIMFLAM774> i understand the loop i believe but the COUNTS command copes the execution token of HOMICIDE and runs ir (1 time lets say)
22:01:55 <I440r> yes
22:01:56 <FLIMFLAM774> so after thats done
22:02:02 <FLIMFLAM774> doesnt homicide also run
22:02:08 <FLIMFLAM774> and add an additional 20 years?
22:02:14 <RodgerTheGreat> no
22:02:21 <RodgerTheGreat> ' grabs a name and gets an XT
22:02:26 <FLIMFLAM774> so you 'steal' the Xtoken?
22:02:30 <FLIMFLAM774> ohh
22:02:36 <FLIMFLAM774> so the  ' consumes the next string?
22:02:37 <RodgerTheGreat> the name is consumed from the input stream
22:02:40 <RodgerTheGreat> yes
22:02:40 <FLIMFLAM774> yay
22:02:43 <FLIMFLAM774> bingo lol
22:02:52 <RodgerTheGreat> if it didn't work that way it would be very inconvenient
22:02:54 <FLIMFLAM774> therein lay the slain dragon
22:02:56 <I440r> ' (pronounced tick) is a parsing word
22:02:58 <RodgerTheGreat> I mean think about it
22:03:06 <FLIMFLAM774> i agree
22:03:11 <I440r> now i understand your confusion :)
22:03:17 <FLIMFLAM774> hehe
22:03:21 <I440r> : blah ." blah" ;
22:03:27 <I440r> ' blah execute
22:03:40 <I440r> blah will only get executed once
22:03:57 <FLIMFLAM774> VARIABLE Thank-You -1 Thank-you !
22:04:20 <I440r> that sets the varible thankyou to -1  i think you meant 1-
22:04:33 <FLIMFLAM774> hmmmm
22:04:37 <I440r> in some forths you could do Thank-You decr
22:04:38 <RodgerTheGreat> we'll also accept "Thank-You on"
22:04:39 <FLIMFLAM774> isnt -1 a true flag?
22:04:43 <I440r> to decrement the contents of the variable
22:04:45 <RodgerTheGreat> FLIMFLAM774: yes
22:04:53 <I440r> -1 CAN be a true flag
22:04:57 <I440r> it an also be -1
22:05:04 <RodgerTheGreat> uh
22:05:05 <FLIMFLAM774> all depends on how you perate with him
22:05:09 <I440r> 4294967295  <-- it can also be this
22:05:10 <FLIMFLAM774> operate*
22:05:16 <FLIMFLAM774> anything but 0
22:05:21 <FLIMFLAM774> involving if
22:05:34 <I440r> any non zero value can be taken as a true.. more accurately as a "Not False"
22:05:51 <I440r> 0 is zero or its false depending on how your code treats it
22:06:18 <RodgerTheGreat> 0 invert constant true
22:06:29 <I440r> ugh i HATE the word invert
22:06:35 <RodgerTheGreat> I know
22:06:39 <RodgerTheGreat> that's why I used it
22:06:40 <FLIMFLAM774> it uses bit logic right?
22:06:40 <I440r> the word is NOT and it performs a 1's complement
22:06:49 <I440r> i hate the stupid ans forth standard.
22:07:14 <I440r> if you do x y AND then the values of X and Y are bitwise anded together
22:07:16 <RodgerTheGreat> : on  true swap ! ;
22:07:19 <I440r> thers no logical and in forth
22:07:29 <I440r> so you have to be careful
22:07:54 <I440r>  x y xor not if " ..... "  could be wrong because any x xor'd wiht y that produces a non zero value will pass
22:08:06 <RodgerTheGreat> short-circuiting logic operators would be rather strange in a stack language
22:08:46 <I440r> you should really always do a 0= if or a 0= NOT if on math results to convert them into true TRUE/FALSE values
22:09:13 <RodgerTheGreat> : = xor if false else true then ;
22:09:13 <FLIMFLAM774> yea i like my 0= if .. else then loop
22:09:30 <FLIMFLAM774> err
22:09:32 <FLIMFLAM774> thats not a loop
22:09:35 <FLIMFLAM774> conditional*
22:09:48 <FLIMFLAM774> but it could be a loop i spose
22:09:49 <I440r> in c  if x = 1 and y is 2  then if(x & y) is not the same as if(x and y)
22:09:52 <RodgerTheGreat> conditionals are forward branches, loops are backward branches
22:10:04 <RodgerTheGreat> yin and yang
22:10:10 <RodgerTheGreat> insert mysticism here
22:10:12 <FLIMFLAM774> do if blank, stop if blank? sotra?
22:10:16 <FLIMFLAM774> sorta*
22:10:17 <I440r> until is a conditional branch 
22:10:53 <FLIMFLAM774> key? until is a good one to test loops with when you're new like me
22:11:04 <I440r> yes
22:11:07 <RodgerTheGreat> I440r: in C, & is bitwise and && is logical (short circuiting). There is no "and"
22:11:08 <I440r> begin key? until
22:11:17 <FLIMFLAM774> begin 0 0 do 42 emit loop key? until ;
22:11:19 <I440r> or begin key? 0= while .... repeat
22:11:29 <I440r> thats what i meant but yea
22:11:56 <I440r> no that wont work
22:12:03 <FLIMFLAM774> : test
22:12:08 <I440r> your key? wont be able to test until the loop has completed
22:12:09 <FLIMFLAM774> first ^
22:12:14 <FLIMFLAM774> ohhh
22:12:14 <I440r> which will take a very long time
22:12:19 <RodgerTheGreat> in my forth I have a -if which is a "not if"
22:12:28 <I440r> : 0 0 do key? ?leave 42 emit loop
22:12:29 <I440r> ;
22:12:40 <FLIMFLAM774> : test begin 0 0 do 42 emit key? until loop ;
22:12:51 <I440r> -if compiles a 0branch not a ?branch ?
22:12:52 <FLIMFLAM774> will mine work?
22:13:08 <I440r> no
22:13:22 <I440r> you cannot have begin do until loop like that
22:13:29 <I440r> your loops are overlapping
22:13:44 <FLIMFLAM774> yea you're right
22:13:51 <I440r> and to abort a do loop you must either do undo or leave
22:13:56 <FLIMFLAM774> the begin would need to end each time for the do to continue
22:14:08 <I440r> 100 o do i 30 = if undo exit loop
22:14:09 <I440r> or
22:14:13 <FLIMFLAM774> what about quit or exit?
22:14:26 <I440r> 100 0 do i 30 = ?leave loop xxx yyy zzz
22:14:41 <I440r> you can quit. you cannot exit from inside a loop without first doing an undo
22:15:05 <I440r> you can also abort from within a loop because abort jumps to quit
22:15:38 <RodgerTheGreat> I440r: I thought the word was called "unloop"
22:15:42 <I440r> no
22:15:47 <I440r> only with GHEY people
22:15:55 <FLIMFLAM774> WHAT DOES UNDO DO?
22:15:57 <RodgerTheGreat> oh for pete's sake dude
22:15:58 <FLIMFLAM774> IT UNS THE DO?
22:16:02 <FLIMFLAM774> oops caps
22:16:23 <I440r> ut undoes the do loop.  ANS forth calls it "unloop" because ans forth is devised by a committe of complete and utter morons
22:16:34 <I440r> its called undo. it UNDOES a DO LOOP
22:16:35 <FLIMFLAM774> lol
22:16:44 <I440r> forth is supposed to scan in english
22:16:50 <FLIMFLAM774> americans and their standards..
22:16:53 <RodgerTheGreat> I440r: isn't it rather vicious to use the names of words in your forth dialect when helping beginners who are probably running an ANS system?
22:17:00 <I440r> someone please give me the dictionary definition of the english word "unloop"
22:17:17 <I440r> RodgerTheGreat, no. 
22:17:24 <FLIMFLAM774> i have two forth systems, win32forth and minecraft forth!
22:17:27 <I440r> because my hate for the ans forth standard knows NO bounds
22:17:58 <RodgerTheGreat> minecraft seems to be a popular entrypoint to forth these days
22:18:07 <RodgerTheGreat> who'd have thunk it
22:18:10 <I440r> i will never give any explanation using ans forth word names
22:18:24 <I440r> why is that?
22:18:34 <RodgerTheGreat> minecraft itself is popular
22:18:35 <FLIMFLAM774> yea you can create a virtual computer and make it do fun stuff
22:18:36 <I440r> minecraft looks really neat but i KNOW that isnt coded in forth
22:18:41 <FLIMFLAM774> and to use it you need to know forth
22:18:44 <RodgerTheGreat> several mods add an in-game forth computer
22:18:50 <I440r> aha
22:19:09 <RodgerTheGreat> generally so you can control robotics or something in-game
22:19:17 <FLIMFLAM774> basically you have an 'i/o' expander which can output 'redstone signals'
22:19:23 <RodgerTheGreat> it's a pretty good environment for it, really
22:19:42 <FLIMFLAM774> and these signals can control machines and such
22:19:58 <FLIMFLAM774> minecraft actually got me into gate logic as well
22:20:01 <FLIMFLAM774> in addition to forth
22:20:28 <RodgerTheGreat> 'course redstone logic has almost no relation to real-world physics
22:20:39 <RodgerTheGreat> but once you get gates it doesn't matter how they're built
22:20:43 <ttmrichter> FLIMFLAM774: Next step: making a Forth machine from TTL components.  :)
22:20:43 <FLIMFLAM774> lol none at all, the the signal manipulation concepts are there
22:20:44 <RodgerTheGreat> that's the magic of abstraction
22:21:33 <RodgerTheGreat> 'night all
22:21:35 <FLIMFLAM774> brains are good
22:21:36 <FLIMFLAM774> gnight sir
22:21:43 <FLIMFLAM774> ty again
22:21:54 --- quit: RodgerTheGreat (Quit: RodgerTheGreat)
22:22:20 --- quit: Nisstyre (Ping timeout: 246 seconds)
22:23:23 <FLIMFLAM774> i love that feeling of understanding exactly how something works!
22:23:45 <FLIMFLAM774> now that i know '  consumes the work it copes the XT of, i bid you adieu!
22:23:57 <FLIMFLAM774> and thanks again I440r
22:24:17 --- quit: FLIMFLAM774 (Quit: irc2go)
22:24:21 <I440r> :)
22:24:29 <I440r> shudda stuck around and learn forth :P`
22:24:34 <I440r> as opposed to ans forth
22:34:36 <ttmrichter> Ah, if you know ANS Forth you can learn a real Forth quickly.
22:34:41 <ttmrichter> Just strip away the stupidity and bloat.
22:38:19 --- join: Nisstyre (~yours@oftn/member/Nisstyre) joined #forth
22:38:19 --- mode: ChanServ set +v Nisstyre
22:58:35 --- quit: proteusguy (Remote host closed the connection)
23:07:29 --- join: proteusguy (~proteusgu@ppp-58-8-104-96.revip2.asianet.co.th) joined #forth
23:07:29 --- mode: ChanServ set +v proteusguy
23:10:37 --- join: tangentstorm (~michal@108.218.151.22) joined #forth
23:10:37 --- mode: ChanServ set +v tangentstorm
23:11:15 <tangentstorm> I can't tell whether I hate this or not: https://gist.github.com/4592672
23:11:53 <tangentstorm> it's a mess, but maybe there's something easy i could be doing to clean up the quote/unquote mess?
23:12:54 <tangentstorm> i guess i'm asking: other than just plain rewriting it, what would my strategy be for refactoring it incrementally?
23:14:22 --- join: kulp_ (~kulp@205.185.118.106) joined #forth
23:14:22 --- mode: ChanServ set +v kulp_
23:40:58 --- join: nighty-_ (~nighty@static-68-179-124-161.ptr.terago.net) joined #forth
23:40:58 --- mode: ChanServ set +v nighty-_
23:43:27 --- quit: nighty- (Read error: Connection reset by peer)
23:59:59 --- log: ended forth/13.01.21