00:00:00 --- log: started forth/12.06.10
02:15:41 --- quit: fantazo (Remote host closed the connection)
02:26:27 --- join: ttmrichter (~ttmrichte@58.55.124.245) joined #forth
02:26:27 --- mode: ChanServ set +v ttmrichter
03:37:26 --- nick: ttmrichter -> ttmranter
03:37:50 --- nick: ttmranter -> ttmrichter
04:18:31 --- join: SplinterOfChaos (~soc@cblmdm24-52-84-142.buckeyecom.net) joined #forth
04:18:32 --- mode: ChanServ set +v SplinterOfChaos
05:28:47 <DocPlatypus> regnirps: that's a bit primitive
06:03:03 <ASau`> No, it isn't.
06:03:21 <ASau`> First of all, that's exactly how subroutines are implemented on S/360.
06:03:55 <ASau`> Second, it is even more effective than how it is implemented in PDPs and later.
06:04:12 <ASau`> You avoid unnecessary memory access.
06:10:18 <regnirps> SOme assemblers make it look "normal" with pseudo-ops.
06:11:12 <ASau`> Motorola assemblers even generated code for subroutine calls.
06:12:03 <regnirps> I don't recall exact opcode, but there is something like branch with link that will push the link register (it does not have to be used as a link register).
06:13:11 <regnirps> Yep. Apple's entire OS back then used the software interrupt to dispatch or call routines, since it could carry an argument.
06:13:26 <regnirps> And was faster than other methods.
06:15:44 <ASau`> I don't have numbers, but I suspect that it is better to have return address cached in register.
06:16:00 <ASau`> At least you optimize leaf subroutines this way.
06:16:32 <ASau`> (For the rest it makes no difference.)
06:20:44 <regnirps> My ARM Forth has the top of stack in a register for all stacks including return stack. It is nice to have plenty of registers.
06:21:59 <regnirps> I did a lot of testing about 10 years ago (more?) on an ARM a friend sent me from VLSI and the top item in a register is definitely better.
06:22:34 <regnirps> SO, stack pointers and TOS are all in registers including a loop stack and FP stack.
06:24:07 <regnirps> Separating a loop stack from the return stack has some nice advantages.
06:25:46 <regnirps> I did two versions. A slow one with NEXT as a routine so tracing and profiling are easy.
06:26:19 <ASau`> It has disadvantages as well.
06:26:28 <regnirps> But NEXT for ITC on ARM is only two instructions so for the fast version I in-lined NEXT to the end of every word.
06:27:24 <regnirps> I have not run across any. It is tranparent to ANS.
06:29:14 <regnirps> If you want to get creative and not portable, it also lets you play around with return stack values without messing up loops.
06:30:07 <regnirps> If it was the standard way of doing things, exceptions could be handled in a nicer way.
06:31:57 <regnirps> is AFK.
06:50:06 --- quit: phirsch (Ping timeout: 245 seconds)
06:59:15 --- join: phirsch (~phirsch@xdsl-89-0-183-47.netcologne.de) joined #forth
06:59:15 --- mode: ChanServ set +v phirsch
06:59:18 --- join: RodgerTheGreat (~RodgerThe@71-13-215-128.dhcp.mrqt.mi.charter.com) joined #forth
06:59:19 --- mode: ChanServ set +v RodgerTheGreat
07:08:04 --- join: Onionnion (~ryan@adsl-68-254-169-141.dsl.milwwi.ameritech.net) joined #forth
07:08:04 --- mode: ChanServ set +v Onionnion
07:54:53 --- part: RodgerTheGreat left #forth
07:55:14 --- join: RodgerTheGreat (~RodgerThe@71-13-215-128.dhcp.mrqt.mi.charter.com) joined #forth
07:55:15 --- mode: ChanServ set +v RodgerTheGreat
08:37:17 --- quit: Onionnion (Quit: Leaving)
09:53:32 --- join: Monevii (~Monevii@67.224.254.22) joined #forth
09:53:33 --- mode: ChanServ set +v Monevii
09:54:00 --- join: Kumul (~Kumul@67.224.254.22) joined #forth
09:54:09 --- mode: ChanServ set +v Kumul
12:17:17 --- join: fantazo (~fantazo@91.119.75.149) joined #forth
12:17:17 --- mode: ChanServ set +v fantazo
12:32:00 --- join: black_13 (4343dc9e@gateway/web/freenode/ip.67.67.220.158) joined #forth
12:32:00 --- mode: ChanServ set +v black_13
12:32:22 <black_13> kids
12:42:48 <fantazo> what about kids? don't you like them? aren't they kinda cute?!
12:48:26 <black_13> fantazo: kids in the hall, with the kids are all right.
12:48:58 <black_13> the movie "kids". gotta love rosario dawson
12:50:09 --- join: impomatic (~digital_w@87.114.246.192) joined #forth
12:50:09 --- mode: ChanServ set +v impomatic
13:39:02 <Kumul> kids like kidding?
13:46:42 <fantazo> ok... don't know that movie
13:51:19 <Kumul> that wasnt a movie
13:52:53 --- quit: black_13 (Ping timeout: 245 seconds)
15:33:06 --- join: arke (~Chris@p5DDCD307.dip.t-dialin.net) joined #forth
15:33:06 --- mode: ChanServ set +v arke
15:41:17 <RodgerTheGreat> I am having a mild ethical dilemma
15:41:59 <RodgerTheGreat> a friend of mine has expressed an interest in programming and making video games, and has no prior experience. I have a forth compiler and toolchain which I use for making video games.
15:42:10 <RodgerTheGreat> I am tempted to introduce her to programming with forth
15:42:35 <RodgerTheGreat> do you guys think that would be scarring and discouraging to someone just starting out, or is this a good idea?
15:43:19 <RodgerTheGreat> the alternative would be something like Processing, which is a Java-based language that makes graphical stuff easy and accessible or possibly a scheme, which would provide a solid basis in functional programming
15:43:48 <RodgerTheGreat> of the latter two, Processing better nails the "instant gratification" angle, I think
15:43:57 <RodgerTheGreat> I've used Processing to teach introductory programming courses
15:44:30 <RodgerTheGreat> but in those cases it was largely a practical choice because ultimately my students need to learn Java, and Processing provides a gentle introduction without boilerplate
15:45:49 <RodgerTheGreat> Starting Forth is a great, accessible book, but I read it as a seasoned coder and I could easily mentally separate the parts that are archaic and no longer apply from the things that are still relevant- I'm not sure if that would be a problem for a newbie
15:46:31 <RodgerTheGreat> obviously I would be teaching hands-on at least at first, rather than just giving my friend a book and telling her to read it and become a programmer
15:46:44 <RodgerTheGreat> any thoughts?
15:47:52 <RodgerTheGreat> part of the reason I consider this an ethical dilemma is because it also presents an opportunity to explore my own suspicion that stack-based languages only seem strange to people with prior experience in imperative languages with named variables/arguments
15:48:16 <SplinterOfChaos> I used to think that a beginning programmer should learn at once a high level language, low level (x86 assembly), and something in the middle (C/Java/etc). At this point, i might say Forth, C, and Python.
15:48:26 <RodgerTheGreat> hm
15:48:28 <SplinterOfChaos> (Forth instead of assembly)
15:49:05 <RodgerTheGreat> maybe go with Processing (java) and forth together?
15:49:06 <Kumul> i dont know, im no programmer, and my introduction to low level stuff other than shellscriptand lua has been forth (i havent tried C, although rc is like that) i dont know if i've been scarred but i havent managed to pick up a C book till im a good forther
15:50:37 <Kumul> mental note: never start sentence with "i dont know"
15:52:42 <SplinterOfChaos> Though, on Starting Forth, that was written for an audience of smart programmers who could pick up on the concepts and do neat things with it. Haskell has a similar problem in how cryptic its structure can be, but makes up for this with a large community and beginner-friendly tutorials.
15:53:42 <SplinterOfChaos> There's always that jump that's difficult to make from toy functions to useful examples.
15:53:49 <RodgerTheGreat> SplinterOfChaos: well, it does go into a lot of detail to explain what loops, conditionals, procedure calls and so on are
15:54:05 <RodgerTheGreat> I'm not sure it was exclusively targeted at people who were already coders
15:54:23 <ASau`> It is better not to introduce novices to Forth.
15:54:36 <Kumul> surprising you would say that ASau` 
15:54:45 <RodgerTheGreat> ASau`: literally nobody cares about your opinions in this channel
15:54:51 <SplinterOfChaos> RodgerTheGreat: That's the point. If the book were written today, it'd probably come with a library that abstracted out those "details".
15:54:55 <Kumul> ASau`: what should they be introduced with?
15:55:15 <Kumul> please dont say python, i tried learning python as everyone said, and i couldnt understand anything
15:55:20 <ASau`> Scheme, Python are the languages that are taught to novices these days.
15:55:23 <Kumul> lol
15:55:24 <Kumul> python
15:55:44 <RodgerTheGreat> SplinterOfChaos: that kind of approach is why I prefer books written before the 90s. They can't rely on frameworks and IDEs, so they focus on the brass tacks
15:55:48 <SplinterOfChaos> Scheme?
15:55:57 <ASau`> If you couldn't understand python, you can't understand programming.
15:56:10 <RodgerTheGreat> ah yes, SICP, a gentle introduction to programming
15:56:10 <Kumul> ASau`: then i cant
15:56:25 <Kumul> i suppose scripting isnt programming
15:57:00 <ASau`> Programming in small is very very limited programming.
15:57:09 <SplinterOfChaos> RodgerTheGreat: Agreed. Don't get me wrong, i just think it's not as beginner-friendly as other modern-day analogues.
15:57:19 <ASau`> It's true that you can calculate roots of square equation in Forth,
15:57:26 <ASau`> building anything complex is different.
15:57:46 <RodgerTheGreat> SplinterOfChaos: I can see that, I'm just wondering how easily I could make up for that with coaching
15:58:14 <RodgerTheGreat> there's a huge difference between reading about something in a book and having something to explain things, rephrase things and answer questions
15:58:54 <SplinterOfChaos> RodgerTheGreat: I doubt it'd be too difficult. The hardest part in learning is just not having anyone to ask questions.
15:59:29 <Kumul> RodgerTheGreat: just try it to prove ASau` wrong :)
15:59:46 <ASau`> One of fundamental differences between Forth and, e.g., Scheme community
15:59:46 <ASau`> is that there's strong pedagogical interest in the latter.
15:59:51 <RodgerTheGreat> as a counterexample to the sentiment that you can't do interesting things when starting with Forth, I actually made a little game that can be used to provide tasks and goals: https://github.com/JohnEarnest/Mako/tree/master/games/Warrior
16:00:25 <RodgerTheGreat> there's a graphical maze with goodies, you write a few forth words and you watch your warrior explore and kill monsters, step by step
16:00:57 <Kumul> who came here wanting to learn forth because of a minecraft mod?
16:01:00 <arke> I think if you want somebody to learn programming with the intent of programming (and not with the intent of doing some cool stuff), then stepping through SICP (Scheme) is probably the best you can do.
16:01:34 <Kumul> i think he was a beginner no?
16:01:49 <ASau`> You can count active Forth teachers on one hand (if they exist at all).
16:02:08 <RodgerTheGreat> arke: I agree with that, but I also think that "making cool stuff" can be a gateway to wanting to learn real programming
16:02:19 <ASau`> And there're several strong universities using Scheme for teaching.
16:02:41 <RodgerTheGreat> ASau`: I'm a forth programmer, and I would be teaching this person. Availability is completely irrelevant and you know it.
16:03:01 <ASau`> Have you got pedagogical skills?
16:03:11 <RodgerTheGreat> I am a teacher
16:03:13 <ASau`> That's important factor as well.
16:03:51 <RodgerTheGreat> I've worked as a lab TA and I've taught programming to people from 25 years old down to 11
16:04:06 <RodgerTheGreat> I also have lecturing experience
16:04:29 <ASau`> Well...
16:04:35 <ASau`> Do as you wish.
16:05:26 <ASau`> Though I seriously doubt that Forth can be made reasonably good introduction language in short time.
16:05:58 <ASau`> Python and Scheme communities have invested more time in it,
16:06:02 <ASau`> and continue doing so.
16:06:29 <RodgerTheGreat> you're really a big fan of this whole "consensus equals correctness" thing, aren't you?
16:06:32 <ASau`> You can really guide novice through some course and write impressive programs.
16:08:08 <ASau`> I'm not a fan in any way.
16:09:10 <ASau`> That's why I don't push programming languages I like onto novices.
16:37:33 --- quit: ttmrichter (Quit: Leaving)
16:51:43 --- join: black_13 (614d7a6d@gateway/web/freenode/ip.97.77.122.109) joined #forth
16:51:43 --- mode: ChanServ set +v black_13
16:51:53 <black_13> engrish
17:12:53 --- quit: black_13 (Ping timeout: 245 seconds)
17:55:39 --- join: Onionnion (~Ryan@adsl-68-254-169-141.dsl.milwwi.ameritech.net) joined #forth
17:55:39 --- mode: ChanServ set +v Onionnion
17:55:47 <Onionnion> o/ Kumul 
17:55:55 <Onionnion> what BSD distro would you suggest for a newbie?
17:55:58 <Kumul> erro Onionnion 
17:56:03 <Kumul> pcbsd
17:56:11 <Kumul> and there are no Distro's
17:56:32 <Onionnion> what would they be called?
17:57:19 <Onionnion> they're just based on BSD? Or this one is based on freebsd
18:02:02 --- quit: arke (Quit: Leaving)
18:02:32 <Onionnion> if security is your goal, then I'd suggest Linux/Unix/BSD
18:02:40 <Onionnion> pretty much unhackable
18:03:40 <Onionnion> oops
18:03:41 <Onionnion> XD
18:14:14 <Kumul> Onionnion: this is offtopic, but just look at each BSD and what their goals are
18:16:27 <Kumul> Onionnion: open = security, net = portability, pc = user friendly; free = misc
18:20:15 --- quit: Onionnion (Quit: Leaving)
18:27:47 --- join: Onionnion (~ryan@adsl-68-254-169-141.dsl.milwwi.ameritech.net) joined #forth
18:27:47 --- mode: ChanServ set +v Onionnion
18:28:04 <Onionnion> Kumul, for me: http://crunchbanglinux.org/forums/topic/5729/distrohoppers-anonymous/
18:30:54 <Kumul> windoze?
18:30:55 <Kumul> meh
18:31:47 <Onionnion> I do miss #!. it executes openbox so perfectly
18:33:12 <Kumul> #!?
18:33:18 <Onionnion> crunchbang
18:33:27 <Onionnion> debian based
18:35:43 <Onionnion> extremely lightweight
18:37:11 <Onionnion> ubuntu, even lubuntu, feels like a mess sometimes
18:37:46 <Kumul> thats because it is
18:38:16 <Onionnion> I know
18:38:36 <Kumul> i have a hunch you wrote this article
18:38:53 <Onionnion> there was just a small frustrating thing that made me throw away #!/debian, which was something with packages and LFS not working
18:39:33 <Onionnion> might as well have lol. I have tried many distros. chakra, ubuntu (before it really went crappy with unity), opensuse, fedora, a few others
18:40:23 <Onionnion> I still miss Gnome 2..haven't touched it in so long and I was just so comfortable with it
18:42:00 <Kumul> im going away, need to reboot
18:42:07 <Onionnion> was about to say the same
18:42:11 <Onionnion> boop
18:42:13 <Kumul> then you shouldnt try BSD
18:42:17 <Onionnion> why
18:42:20 <Kumul> since compiling gnome2 must be hell
18:42:42 <Onionnion> nah, then I found openbox and wanted everything to run it lol
18:42:58 <Onionnion> #! runs it better than anything else
18:43:53 <Kumul> ahh ok
18:44:55 <Onionnion> I should've approached a community about it for help..lol
18:46:26 <Kumul> well i need to reboot, before this itch to install plan9 fades
18:46:36 <Kumul> try asking on ##bsd about bsd
18:47:16 <Onionnion> will reboot, too
18:48:18 --- quit: Onionnion (Quit: Leaving)
19:26:56 <Kumul> it faded...
19:29:00 --- quit: phirsch (Ping timeout: 240 seconds)
19:36:21 --- join: phirsch (~phirsch@xdsl-89-0-173-217.netcologne.de) joined #forth
19:36:22 --- mode: ChanServ set +v phirsch
19:48:44 --- quit: ASau` (Ping timeout: 244 seconds)
20:18:03 --- quit: nighty^ (Ping timeout: 248 seconds)
20:24:36 --- join: Onionnion (~ryan@adsl-68-254-169-141.dsl.milwwi.ameritech.net) joined #forth
20:24:36 --- mode: ChanServ set +v Onionnion
20:49:26 <regnirps> RTG: Try Win32Forth for Windows. Then you get a great object model as well. Much more intuitive than C++, C#, Dynamic C, etc. Might be OK for games.
20:49:47 <regnirps> All the early arcade games were in Forth. Asteroids, Battlezone, etc.
20:50:11 --- join: ttmrichter (~ttmrichte@122.228.67.13) joined #forth
20:50:11 --- mode: ChanServ set +v ttmrichter
20:54:20 <Kumul> regnirps: is that for RodgerTheGreat ?
20:54:29 <regnirps> Yes.
20:54:44 <Kumul> regnirps: dont you have autocompletion?
20:55:03 <Kumul> regnirps: saying someone's name gets their attention, usually
20:55:06 <regnirps> Kumul:  yes
20:55:17 <regnirps> I just forget to add a space.
20:55:57 <regnirps> RodgerTheGreat:  Try Win32Forth for Windows. Then you get a great object model as well. Much more intuitive than C++, C#, Dynamic C, etc. Might be OK for games.
20:56:45 <regnirps> black_13 ducked out. I had an answer on his nest/unest issue.
20:57:59 <RodgerTheGreat> I had no idea arcade games were written in forth. Do you have a source on that?
20:58:25 <regnirps> It is just the run-time code for : and ; and usually called DOCOL. In the source he saw, it was nest and unest.
20:58:57 <regnirps> Yesh. Atary games were writen by.....Nolan Bushnel? And.....it weill come to me.
21:01:18 <RodgerTheGreat> I suspect you may be fibbing
21:01:53 --- join: jyfl987 (~jyf@unaffiliated/yunfan) joined #forth
21:01:54 --- mode: ChanServ set +v jyfl987
21:02:57 <regnirps> http://www.atariarchives.org/c1bag/page108.php
21:03:02 <regnirps> third paragraph
21:04:28 <RodgerTheGreat> it mentions forth, yes, but that paragraph is the only reference to it, and that paragraph is only suggesting that you *could* write games in forth, which is obviously true
21:12:39 <regnirps> I'm not finding anything except Midway games. It was a big deal at the time. They told everyone they used assembly and Forth was their secret weapon for high productivity. I only knew because National Semi licensed a Forth through Mountain View Press to put in ROM for a special processor module for Atari.
21:14:44 <regnirps> Don Draper, AKA "Captain Crunch" would call and wake me up in the middle of the night when he was programming in Hawaii and always with goofy Forth problems from not reading the next page of the docs.
21:17:59 <RodgerTheGreat> you mean John Draper?
21:20:10 <regnirps> Right. John. Rhymes with Don.
21:20:26 <regnirps> Totsl whackjob.
21:20:29 <regnirps> total.
21:20:38 <RodgerTheGreat> you've been watching too much Mad Men, presumably
21:20:59 <RodgerTheGreat> and yes, Captain Crunch certainly sounds like a character from what I've read
21:21:17 <regnirps> When in SIlicon Valley he wold come buy and get one of every new publication and disk on FOrth.
21:21:32 <regnirps> Atari's coin-op division used Forth for many arcade games. They believed that the fastest path to high-performance code was to write it in Forth and recode the innermost loops in assembler. 
21:21:40 --- quit: Onionnion (Quit: Leaving)
21:21:42 <regnirps> from here: http://dec.bournemouth.ac.uk/forth/forth.html#14
21:21:50 <regnirps> Still not definitive.
21:22:32 <RodgerTheGreat> better, though
21:22:48 <RodgerTheGreat> it also suggests that infocom's Z-machine interpreters were written in forth, which is neat
21:23:46 <RodgerTheGreat> and the T-1000 sfx were done using forth-based software. spiffy.
21:24:36 <regnirps> http://www.pcmag.com/encyclopedia_term/0,1237,t=FORTH&i=43420,00.asp
21:25:28 <regnirps> I'll ask John Bumgarner. He worked on all that and I need to talk to him anyway.
21:26:18 <RodgerTheGreat> I like how that example uses both fall-through rather than a loop and the implicit newline-as-terminator behavior of the built in parsing words to make the code shorter
21:27:01 <regnirps> Looks like a piece of C. Moore code. Or Rather. It's from Forth Inc.
21:27:55 <RodgerTheGreat> much more illustrative of forth style than you'd think from the problem statement
21:28:58 <regnirps> Picture caption
21:28:59 <regnirps> http://www.jupiter-ace.co.uk/Forth_general_personal_computer_news_0136.html
21:30:37 <RodgerTheGreat> given the secrecy of arcade game manufacturers at the time, the only really definitive answer would be seeing a disassembly of an arcade ROM that was clearly structured like forth
21:30:45 <RodgerTheGreat> I'm guessing
21:30:47 <regnirps> Editors could never get FOrth code samples right. The white space made no sense to them.
21:30:53 <RodgerTheGreat> or source for something if possible
21:31:25 <regnirps> There is source for Ms GORF but it was never built.
21:31:29 <RodgerTheGreat> regnirps: I blame variable-width fonts
21:31:32 <regnirps> Just GORF.
21:31:58 <regnirps> Could be. They should have set all the code in courier.
21:32:47 <regnirps> Thats called proportianal 8-0
21:33:32 <regnirps> I worked with Jef Raskin and Scott Kim, so we gotta get the terminology right ;-)
21:34:02 <RodgerTheGreat> in that case we really ought to call them typefaces
21:35:38 <regnirps> Yeah, maybe. I wold have to look back. Kim got the first PhD in Digital Typography from Stanford and worked with Donald Knuth and Adobe Postscript sprang out of that area.
21:36:33 <regnirps> Whats his name at Adobe claimed to have never seen Forth. Have you seen Postscript? Duplicate instead of DUP, Exchange instead of SWAP, etc.
21:36:48 <RodgerTheGreat> I wrote a forth in postscript. :)
21:37:10 <regnirps> Don lancaster would be proud.
21:37:17 <RodgerTheGreat> https://github.com/JohnEarnest/Four.Ps/blob/master/four.ps
21:37:52 <RodgerTheGreat> looking back on it some aspects are rather crude
21:37:55 <RodgerTheGreat> I could do better
21:39:20 <regnirps> Yes. Do you think he never saw Forth? And he lived near the FIG meetings? And presentations at the Home Brew clib?
21:39:52 <regnirps> Warnock. I knew it would come to me. Jim I think.
21:40:01 <RodgerTheGreat> there are a large number of very significant differences between PS and Forth though, to be fair
21:40:18 <regnirps> He had to be FP to get the fine scaling is the main thing.
21:41:50 <regnirps> ANyway, teaming up with Jobs on the Laserwriter with Postscripts and support from MacWrite/Macdraw/MacPaint blew everyone away.
21:49:12 --- quit: SplinterOfChaos (Remote host closed the connection)
22:06:38 <RodgerTheGreat> 'night folks
22:11:21 --- quit: RodgerTheGreat (Ping timeout: 265 seconds)
23:11:36 --- quit: fantazo (Remote host closed the connection)
23:19:54 --- quit: jyfl987 (Quit: leaving)
23:20:20 --- join: jyfl987 (~jyf@unaffiliated/yunfan) joined #forth
23:20:20 --- mode: ChanServ set +v jyfl987
23:49:27 --- quit: Monevii (Remote host closed the connection)
23:58:50 --- quit: Kumul (Quit: gone)
23:59:59 --- log: ended forth/12.06.10