00:00:00 --- log: started forth/10.03.01
00:01:25 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
00:03:40 --- quit: crc (Ping timeout: 268 seconds)
01:32:20 --- join: crc (~charlesch@71.23.210.149) joined #forth
01:34:38 --- quit: crc_ (Ping timeout: 245 seconds)
01:48:41 --- join: sunwukong (~vukung@business-80-99-161-225.business.broadband.hu) joined #forth
02:20:03 --- quit: crc (Ping timeout: 252 seconds)
02:25:02 --- join: crc (~charlesch@71.23.210.149) joined #forth
03:08:53 --- join: dinya_ (~Denis@94.51.198.98) joined #forth
03:33:23 --- quit: ygrek (Ping timeout: 245 seconds)
03:44:30 --- join: TR2N (email@89.180.200.170) joined #forth
03:53:25 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
03:54:32 --- quit: crc (Ping timeout: 260 seconds)
04:11:32 --- join: crc (~charlesch@71.23.210.149) joined #forth
04:12:33 --- join: tripFantastic (1000@c-68-56-68-122.hsd1.fl.comcast.net) joined #forth
04:12:40 --- quit: crc_ (Ping timeout: 258 seconds)
04:13:02 <tripFantastic> anyone play with Fig models often?
04:14:09 <tripFantastic> i remember back a few years ago (maybe alot) that I once came across a tarball that had a c-coded tool within which pre-processed a forth-written kernel.
04:14:26 <tripFantastic> i cant remember anymore than that and I'd like to find that c-src
04:15:24 <ASau```> No, don't play with them.
04:15:45 <tripFantastic> your loss :>
04:15:56 <ASau```> It is 30 years old stoned shit.
04:16:04 <tripFantastic> so are you apparently :)
04:16:17 <tripFantastic> wth are you doin here?
04:16:21 <tripFantastic> if you dont like forth?
04:16:33 <ASau```> Who are you?
04:16:38 <tripFantastic> this is me!
04:16:42 <tripFantastic> i'm here
04:16:47 <tripFantastic> (chest thumping)
04:16:49 <tripFantastic> me!
04:16:57 <ASau```> Another wannabee?
04:17:05 <tripFantastic> wow, you aint nice at all
04:17:43 <ASau```> Oh, you consider yourself nice!
04:17:54 <tripFantastic> we're not discussin me
04:18:18 <ASau```> You started that.
04:18:29 <tripFantastic> you evidenced it yourself first
04:18:51 <ASau```> I didn't, that bullshit is your own.
04:19:23 <tripFantastic> you wrote "old stoned shit" about Figforth.
04:19:35 <ASau```> It is true.
04:19:59 <tripFantastic> you're not nice.
04:20:03 <tripFantastic> you lack love.
04:20:07 <tripFantastic> you lack honor
04:20:12 <ASau```> I don't love old stoned shit.
04:20:12 <tripFantastic> you lack respect.
04:20:21 <ASau```> And I don't respect old stoned shit.
04:20:50 <tripFantastic> you are unworthy 
04:21:35 <ASau```> That bullshit is your own.
04:38:29 --- quit: crc (Ping timeout: 276 seconds)
04:40:47 --- join: crc (~charlesch@71.23.210.149) joined #forth
04:50:15 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
04:57:07 <schme> ...ok
05:10:53 --- quit: mathrick (Read error: Connection reset by peer)
05:11:34 --- join: mathrick (~mathrick@users177.kollegienet.dk) joined #forth
05:22:16 --- quit: crc (Ping timeout: 260 seconds)
05:26:20 --- join: crc (~charlesch@71.23.210.149) joined #forth
05:34:13 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
05:35:05 --- quit: crc (Ping timeout: 258 seconds)
05:50:16 --- join: crc (~charlesch@71.23.210.149) joined #forth
05:51:36 --- quit: crc_ (Ping timeout: 265 seconds)
05:52:19 --- join: crcx (~crc@li125-93.members.linode.com) joined #forth
06:09:47 --- quit: gnomon (Read error: Operation timed out)
06:10:07 --- join: gnomon (~gnomon@CPE0022158a8221-CM000f9f776f96.cpe.net.cable.rogers.com) joined #forth
06:24:30 <KipIngram> Ah.  I'm sure people here know about this already, but I've never seen a really in-depth coverage of the Mup21 before: http://www.eforth.com.tw/academy-n/chips/Mup21/Mup21_0.htm
06:40:01 <ASau```> Funky paper.
06:40:07 <ASau```> http://boole.stanford.edu/pub/lingol.html
06:40:24 <ASau```> It reminds about "CAT EAT MICE" :D
06:43:56 <ASau```> What's the most annoying in it, is the timestamp.
06:44:15 <ASau```> It's the same year as FIG Forth.
06:44:43 <ASau```> Compare what FIG Forth can do, and what this LINGOL does.
06:58:07 --- join: jeremy_c (jeremy@cowgar.com) joined #forth
07:15:03 --- quit: ygrek (Ping timeout: 245 seconds)
07:27:05 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
07:34:50 --- join: madwork (~madgarden@204.138.110.15) joined #forth
08:07:17 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
08:07:22 --- quit: crc (Ping timeout: 264 seconds)
08:13:05 --- quit: sunwukong (Quit: ERC Version 5.3 (IRC client for Emacs))
08:26:18 --- quit: ygrek (Ping timeout: 245 seconds)
08:28:52 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
08:38:03 --- join: crc (~charlesch@71.23.210.149) joined #forth
08:40:09 --- quit: crc_ (Ping timeout: 245 seconds)
08:55:09 <KipIngram> Well, whatever.  I'm designing a *Forth* processor, not a "some other language" processor.  That's why I'm talking about it here on this channel. ;-)
08:55:18 <KipIngram> Here's the instruction set I'm going with:
08:55:33 <KipIngram> NOP, RET, CALL, JMP, JZ, JCZ, LIT+, LIT-
08:55:46 <KipIngram> DUP, DROP, SWAP, OVER, >R, R>,R@, LASTX
08:55:58 <KipIngram> <<, >>, NOT, AND, OR, XOR, +, +N
08:56:13 <KipIngram> A@, A!, @, @+, !, !+, RDN, RUP
08:56:44 <KipIngram> LASTX, RDN, and RUP are the "HP calculator style" words I made reference to the other day.
08:57:33 --- quit: ygrek (Ping timeout: 245 seconds)
08:57:34 <KipIngram> Some of the others I took from the MuP21 instruction set (the use of an A register, with autoincrement capability, etc.)
08:58:12 <KipIngram> I may change things later, but this is the kind of thing I can get bogged down thinking about, so I figured I'd pick something and go with it.
09:01:08 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
09:02:16 --- join: tgunr__ (~tgunr@cust-66-249-166-11.static.o1.com) joined #forth
09:11:41 --- join: kar8nga (~kar8nga@jol13-1-82-66-176-74.fbx.proxad.net) joined #forth
09:17:14 --- quit: tgunr__ (Quit: tgunr__)
09:17:42 --- join: davec (~davec@cust-66-249-166-11.static.o1.com) joined #forth
09:18:10 --- nick: davec -> Guest83661
09:22:51 --- join: ASau (~user@83.69.227.32) joined #forth
09:25:25 --- join: qFox (~C00K13S@5356B263.cable.casema.nl) joined #forth
09:39:23 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
09:42:13 --- quit: crc (Ping timeout: 264 seconds)
10:15:34 --- quit: ASau (Remote host closed the connection)
10:16:26 --- join: ASau (~user@83.69.227.32) joined #forth
10:20:24 <Deformative> KipIngram: Have you looked at the seaforth opcodes?
10:21:44 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
10:25:24 <KipIngram> No, I haven't.  I'll take a look.  As I said, I don't necessarily consider these final at all; it wouldn't surprise me if I iterate on them quite a bit.
10:26:23 <Deformative> The seaforth-20 had a cool set of opcodes.
10:26:25 <Deformative> 32 or something.
10:26:35 <Deformative> But I think intellasys took them off their website.
10:26:41 <Deformative> There is still one from the other chips.
10:27:37 --- quit: Guest83661 (Quit: Guest83661)
10:36:43 --- quit: ASau (Ping timeout: 245 seconds)
10:37:16 <Deformative> KipIngram: Also, http://www.colorforth.com/inst.htm
10:46:11 --- join: tgunr_ (~davec@cust-66-249-166-11.static.o1.com) joined #forth
10:46:17 --- quit: tgunr_ (Excess Flood)
10:46:35 --- join: tgunr_ (~davec@cust-66-249-166-11.static.o1.com) joined #forth
10:47:20 --- nick: tgunr_ -> tgunr
11:18:05 --- join: forther (~forther@207.47.34.100.static.nextweb.net) joined #forth
11:18:18 <forther> hi, all!
11:20:50 --- join: crc (~charlesch@71.23.210.149) joined #forth
11:22:33 --- quit: crc_ (Ping timeout: 240 seconds)
11:31:42 --- quit: proteusguy (Ping timeout: 252 seconds)
11:43:56 --- join: proteusguy_ (~proteusgu@zeppelin.proteus-tech.com) joined #forth
11:49:55 <KipIngram> I don't like that A register that the MuP21 used.  It's something that has to be preserved before it can be reused.
11:50:05 <KipIngram> Completely out of kilter with the stack approach.
11:51:47 <KipIngram> Instead, I'm inclined to have @ and ! work in the usual fashion, and have @+ and !+ (the "auto-increment" words, which I do like) use the top element of the return stack as the address.
11:52:06 <KipIngram> That way if you wanted to have an auto-indexing register you'd set it up on the return stack and go to town.
11:52:14 <forther> KipIngram, do you know, that in F21 Chuck used top of the return stack as the address pointer?
11:52:25 <KipIngram> Ah, well there you go.
11:52:39 <KipIngram> Maybe I did know that somewhere deep down which caused me to "think of it."
11:52:47 --- join: Maki (~Maki@dynamic-78-30-167-37.adsl.eunet.rs) joined #forth
11:52:50 --- quit: Maki (Client Quit)
11:53:00 <KipIngram> Thanks -good to know there's reliable precedence for that.
11:53:05 <forther> still he removed this form his c18 design
11:53:24 <KipIngram> So he has neither in the C18?  No address pointer at all?
11:53:30 --- join: Maki (~Maki@dynamic-78-30-167-37.adsl.eunet.rs) joined #forth
11:53:40 <forther> he has A and B
11:53:51 <KipIngram> Oh, he went back to stand-alone registers?
11:54:00 <forther> B is write only and no postincrement
11:54:10 <forther> yes
11:54:36 <KipIngram> So if B is write-only how can you use it if there's the possibility that other code up the call chain has used it?
11:54:43 <KipIngram> Just "don't do that," I guess.
11:55:15 <forther> B itself is write only
11:55:33 <forther> but you can read and write whenever B points to
11:55:33 <KipIngram> What does it do?
11:55:38 <KipIngram> Got it.
11:55:52 <forther> he has 3 ops related b! @b and !b
11:55:55 <forther> ok
11:56:23 <KipIngram> So that means it's "one use per code realm," or whatever you want to call it.  If I set B then no one below me can use it, because there is no way for them to restore it.
11:56:34 <KipIngram> That means (for sure) that interrupt service routines can't use it.
11:57:01 <KipIngram> Did he ever motivate his decision to not use the return stack for this?  It seems like a natural fit.
11:59:02 <forther> he said R became overloaded with r@+ r!+
11:59:54 <KipIngram> Ok.  I haven't tried to make it work yet, but I can see the signal pathways mounting up.  
12:00:05 <forther> Chuck is hardware centric. Hi cut out everything, what can't be implemented simple way
12:00:45 <KipIngram> Yes, he's down and dirty about how the tracks make their way through the chip.
12:01:37 <KipIngram> I may do it anyway; my system's speed is gated by the RAM access time, which is fast since it's on chip but not nearly as fast as the logic.  Therefore I can get away with some slight "uncleanliness" in the logic.
12:01:51 <KipIngram> Having those capabilities strikes me as pretty valuable in terms of overall program speed.
12:01:53 <KipIngram> We'll see.
12:02:02 <KipIngram> That's the nice thing about FPGAs, it's easy to try stuff out.
12:02:45 <forther> if your final design will be clocked or asynchronous?
12:03:23 --- join: ASau (~user@83.69.227.32) joined #forth
12:06:04 <Maki> forther: FPGA tools dosn't support async design.
12:06:41 <forther> I know, I presume KipIngram will not stop at just FPGA prototype
12:07:10 <Maki> Ah.
12:23:40 <KipIngram> Well, actually I probably will.  I don't have in-company resources to do a custom IC.
12:24:21 <KipIngram> And the expense of such a step goes beyond my typical "hobby budget." :-)
12:25:05 <KipIngram> Unless someone here knows about particularly cheap ways to spin a chip.
12:26:32 <Deformative> Does anyone here know something about Stacker?
12:27:02 <KipIngram> As far as optimizations go I will probably go to unequal state durations.  My design has three basic states (call 'em 1, 2, 3).
12:27:13 <KipIngram> Instruction cell fetch always happens in 1.
12:27:50 <KipIngram> 2 and 3 are for processing the 2nd and 3rd opcodes packed in a cell.
12:28:06 <KipIngram> So 2 and 3 don't need to be as long as 1 because no RAM fetch is required.
12:28:30 <KipIngram> Although, if the *data* side is doing RAM access then we're back to needing that length of time, so deploying such an optimization will be a bit tricky.
12:29:23 <KipIngram> But probably not so hard as to not be worth it.  Sort of a "if this operation requires ram access, then spend six cycle in this state; if not, spend two" or something like that.
12:40:52 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
12:42:58 --- quit: crc (Ping timeout: 245 seconds)
12:45:03 --- quit: ygrek (Ping timeout: 245 seconds)
12:50:10 <KipIngram> On the Spartan 6 each logic cell has a six-input LUT on the front end.  That exactly fits a four-input mux (four inuts, two control lines).
12:50:41 <KipIngram> So when loading the top of the return stack it's no more expensive in terms of logic or time to select any of four sources than it is to select any of two.
12:51:15 <KipIngram> So I can have those be 1) top of data stack, 2) second element on return stack, 3) incremented of itself, and 4) ???
12:51:43 <KipIngram> So it looks like using the top of the return stack as the pointer register is the way to go given a Spartan 6 implementation.
12:53:46 <KipIngram> Older Spartan families, though, have four-input luts, so a four-input mux is considerably more expensive than a two-input mux.
12:57:34 <Deformative> So many fascinating compiler technologies. x.x  I am overwhelmed.
12:59:07 <Deformative> I think I might roll my own vm just for fun.
12:59:57 --- join: crc (~charlesch@71.23.210.149) joined #forth
13:01:01 <KipIngram> I think I've finished the control logic for all instructions that affect the sequencer or the return stack.
13:01:51 --- quit: crc_ (Ping timeout: 240 seconds)
13:02:39 --- quit: mathrick (Read error: Connection reset by peer)
13:04:36 --- join: mathrick (~mathrick@users177.kollegienet.dk) joined #forth
13:33:25 --- join: crc_ (~charlesch@71.23.210.149) joined #forth
13:35:32 --- quit: crc (Ping timeout: 260 seconds)
13:44:41 --- quit: Maki (Quit: Leaving)
13:46:58 --- nick: gnomon -> new_hardware
13:47:05 --- nick: new_hardware -> gnomon
13:56:56 --- quit: qFox (Quit: Time for cookies!)
14:14:06 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
14:23:04 --- quit: kar8nga (Remote host closed the connection)
14:26:16 --- quit: tgunr (Remote host closed the connection)
14:26:47 --- join: tgunr (~davec@cust-66-249-166-11.static.o1.com) joined #forth
14:35:12 --- join: crc (~charlesch@71.23.210.149) joined #forth
14:37:03 --- quit: crc_ (Ping timeout: 252 seconds)
14:58:05 --- quit: madgarden (Ping timeout: 256 seconds)
14:58:33 --- join: madgarden (~madgarden@CPE001d7e527f89-CM00159a65a870.cpe.net.cable.rogers.com) joined #forth
15:22:54 --- quit: crc (Ping timeout: 265 seconds)
15:25:50 --- join: crc (~charlesch@71.23.210.149) joined #forth
15:44:16 --- quit: ncv (Quit: KVIrc Insomnia 4.0.0, revision: , sources date: 20090520, built on: 2009/06/08 23:52:48 UTC  http://www.kvirc.net/)
15:47:05 --- quit: crc (Ping timeout: 248 seconds)
15:52:05 --- join: crc (~charlesch@71.23.210.149) joined #forth
16:40:25 --- quit: forther (Quit: Leaving)
16:41:54 --- quit: flash (Ping timeout: 252 seconds)
17:06:05 --- join: foxes (~flash@61.149.172.1) joined #forth
17:22:43 --- quit: proteusguy_ (Quit: has left the planet!)
17:23:01 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
17:52:47 --- quit: proteusguy (Ping timeout: 276 seconds)
17:55:04 --- part: tripFantastic left #forth
18:18:33 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
19:16:27 --- join: alex4nder (~alexander@wsip-72-215-164-129.sb.sd.cox.net) joined #forth
19:16:30 <alex4nder> hey
19:20:31 <Deformative> Hi.
19:22:35 <alex4nder> how's it going?
19:25:15 <Deformative> Eh, ok.
19:25:17 <Deformative> Yourself?
19:27:48 <alex4nder> good.  trying to figure out how to fix a hardware design, by replacing the contents of the FPGA.
19:27:48 <alex4nder> FPGAes
19:28:40 <Deformative> That's cool.
19:28:50 <Deformative> I have spent most of the day reading about compiler technologies.
19:29:06 <alex4nder> what kind of compilers?
19:31:59 <Deformative> Mostly VMs.
19:32:20 <Deformative> Been looking into designing a language.
19:32:51 <Deformative> And it is important for me to have runtime generation of code, but it is difficult with non-VM compilers.
19:33:03 <Deformative> So I was either going to make my own VM or look into things like neko and llvm.
19:34:57 <Deformative> Perhaps i will look more into Dalvik too.
19:35:18 <alex4nder> oh
19:35:20 <alex4nder> werd.
19:35:53 <Deformative> What's weird?
19:36:02 <alex4nder> nothing, I said werd.. like 'word'.. 
19:36:06 <alex4nder> like 'cool'
19:36:23 <Deformative> Oh, I see.
19:36:38 <alex4nder> have you used a native-code generating forth,.. like something with an optimizer and subroutine threaded code?
19:36:57 <Deformative> Yep.
19:37:20 <alex4nder> you can use the native code forth as a compiler for your language.
19:37:20 <Deformative> Well, perhaps not an optimizer.
19:37:28 <alex4nder> it's a quick and easy way to prototype language features.
19:38:12 <Deformative> Yeah, though I am looking for C calling convention.
19:38:29 <Deformative> It will be rather javascript-like. :/
19:38:49 <alex4nder> you can do C calling conventions with a Forth-based compiler.
19:39:23 <Deformative> I suppose.
19:41:10 <alex4nder> you just get the code generation 'for free', and you get to work on your language.
19:41:24 <alex4nder> well, as long as you can parse it easily in Forth. ;)
19:41:54 <Deformative> Yeah, not really what I am looking for.
19:43:16 <alex4nder> but honestly, you end up having to write a parser in something.. it's not like anything is going to be 'free'
19:43:26 <alex4nder> even if you use a generator, life tends to suck.
19:44:02 <Deformative> I am looking to make a C derivative with a Forth-style dictionary and Forth-style metaprogramming, but I want to stay away from "words" all together.
19:44:11 <Deformative> If that makes sense, which I know it doesn't.
19:44:24 <Deformative> I want to have a single call stack.
19:44:58 <Deformative> No return/parameter stack.
19:45:07 <alex4nder> yup,. that's pretty straight forward to do.
19:45:34 <Deformative> Howso?
19:46:46 <alex4nder> well I can see how you could make a single stack language with 'functions' instead of words, that would be dynamic.
19:47:01 <alex4nder> I don't know what your metaprogramming syntax would look like, but I can see how the code would be structured under the hood to support that.
19:47:14 <Deformative> Ah, yes.
19:47:28 <Deformative> I thought you meant that it would be straightforward to implement in Forth.
19:47:35 <Deformative> Which I don't see how it would be.
19:48:10 <alex4nder> it would be pretty straight forward to do in Forth
19:48:19 <alex4nder> the real shitty part is going to be developing your syntax.
19:48:33 <alex4nder> ... and then dealing with parsing crud
19:48:43 <alex4nder> but the mechanics of doing the actual language is pretty straight forward.
19:49:06 <Deformative> Yeah, I figured the syntax would be easier to do in C, and since syntax is the bulk of the bootstrap in C.
19:49:20 <Deformative> s/bootstrap/bootstrap, might as well do it
19:49:47 <Deformative> I have never done a parser generator before.
19:50:00 <Deformative> I have been thinking about how I could make my parser.
19:50:02 <alex4nder> I don't think the syntax would be easier in C
19:50:11 <alex4nder> just off the top of my head, I think it'd be easier in Forth
19:50:33 <Deformative> I have done parsers before for other languages I made, been going over ideas in my head for this one.
19:50:35 <alex4nder> like, with C you could go the Lex -> Yacc route,. but in Forth you can just create a DSL for parsing your language.
19:51:59 <alex4nder> also if you start by modeling the concepts rather than focusing on the syntax, you can test out your ideas using Forth's interpreter.
19:52:13 <Deformative> I have been thinking of doing some fooling around with finite state machines.
19:52:24 <alex4nder> and then once your syntax is figured out, you augment or throw away the Forth interpreter and put in your own.
19:52:49 <Deformative> I see your point.
19:53:35 <Deformative> Instead of having immediate words, I was going to implement what I call "meta functions"
19:53:42 <Deformative> All = would result in a dictionary entry.
19:53:56 <Deformative> := would be assignment within the scope
19:54:17 <alex4nder> hmm
19:54:22 <Deformative> Still thinking very abstract though.
19:54:47 <Deformative> Taking a lot of inspiration from Forth, D, Javascipt, Lisp, and C.
19:55:10 <alex4nder> see I'd say one of the best parts is that you can totally throw away the C-style boilerplate.
19:55:54 <Deformative> Well, I want blocks and C-style functions.
19:55:58 <Deformative> That is for sure.
19:56:22 <alex4nder> what are C-style functions going to give you that's different than Forth?
19:56:34 <alex4nder> er,. sorry.. I should say: what's the improvement?
19:56:50 <Deformative> I am fascinated by how static C manages to be, and I want to preserve the staticness in the compiled code, but I want powerful metaprogramming like forth provides.
19:57:27 <Deformative> Well, the general public understands C functions, and there is that whole compatibility without an FFI thing.
19:57:32 <alex4nder> is C really that static?
19:57:47 <alex4nder> you mean the ABI of C is pretty much the same?
19:57:52 <alex4nder> (over years and years)
19:58:16 <Deformative> I mean, the generated code is static.
19:58:29 <Deformative> Nothing about code which C generates is dynamic.
19:58:35 <Deformative> Except the data passing through it.
19:58:37 <Deformative> That fascinates me.
19:58:43 --- join: |dinya_| (~Denis@188.16.77.93) joined #forth
19:59:02 <alex4nder> oh haha
19:59:14 <alex4nder> the output of your assembler is just as static
19:59:21 <Deformative> Indeed.
19:59:24 <alex4nder> I mean C is just a big macro assembler.
19:59:46 <Deformative> But with an assembler, you can generate machine code at runtime without violating the rules.
19:59:49 <Deformative> Not so with C.
20:00:22 <alex4nder> wait, how?
20:00:48 <alex4nder> because I can do the same thing with C that I can with my assembler.
20:01:20 <Deformative> You cannot (properly) memcpy a function in C.
20:01:27 <Deformative> Not in a portable way anyway.
20:01:52 <Deformative> Code isn't really treated as data in C.
20:01:55 <Deformative> The way I look at it.
20:02:02 <alex4nder> I guess that depends on what you consider portable.
20:02:03 --- quit: dinya_ (Ping timeout: 240 seconds)
20:03:05 <alex4nder> the only reason you can copy a function with assembly is because you use markers to know the position and length of your assembled code.
20:03:10 <alex4nder> you can do the same thing with C.
20:03:14 <Deformative> void foo(){int x=3; printf("%i",x);}  duplicate(foo); change first line to x=9;  cannot be done in C.
20:03:30 <alex4nder> it can be done as easily as it can be done with an assembler.
20:03:39 <alex4nder> i.e. you have to understand what's in memory.
20:03:39 <Deformative> Yeah.
20:04:02 <Deformative> Yeah, true.
20:05:34 * Deformative ponders.
20:07:49 <Deformative> Hmm... I suppose all languages are relatively static.
20:08:04 <Deformative> Perhaps lisp and forth aren't.
20:08:32 <Deformative> But really, the line between metaprogramming and runtime programming are quite blurred.
20:15:03 <Deformative> I suppose I am trying to make them more distinct or something.
20:19:32 <Deformative> alex4nder: Does that make sense?
20:20:03 <Deformative> I suppose it is a bad plan really, because I am getting close to the realm of preprocessor vs compiler.
20:20:09 <Deformative> And that is NOT where I want to be.
20:20:37 --- quit: alex4nder (Ping timeout: 264 seconds)
20:27:04 --- quit: segher (Quit: This computer has gone to sleep)
21:05:23 --- part: TR2N left #forth
21:30:09 --- quit: proteusguy (Ping timeout: 264 seconds)
21:42:53 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
21:47:28 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
23:36:33 --- join: alex4nder (~alexander@68-27-112-81.pools.spcsdns.net) joined #forth
23:46:44 <ASau```> KipIngram: it would be nice to have at least multiplication step.
23:47:23 <ASau```> Better both, multiplication and division steps.
23:57:45 <alex4nder> hey
23:59:59 --- log: ended forth/10.03.01