00:00:00 --- log: started forth/15.08.08
00:09:57 <Quiznos> +mornin
00:21:32 --- quit: xyh (Remote host closed the connection)
00:31:28 --- quit: fantazo (Ping timeout: 260 seconds)
00:45:13 --- join: true-grue (~grue@95-27-143-90.broadband.corbina.ru) joined #forth
00:57:46 --- quit: ehaliewi` (Ping timeout: 264 seconds)
02:38:31 <Quiznos> anyone awake?
02:51:12 --- join: xyh (~xyh@14.150.213.59) joined #forth
03:02:20 --- quit: xyh (Remote host closed the connection)
03:26:45 --- join: fantazo (~fantazo@213.129.230.10) joined #forth
03:38:40 --- join: xyh (~xyh@14.150.213.59) joined #forth
05:10:22 --- quit: beretta (Quit: Leaving)
05:25:41 --- join: mrm (~user@94.41.237.13.dynamic.ufanet.ru) joined #forth
05:25:59 --- quit: mrm (Remote host closed the connection)
06:19:05 <sbp> hi Quiznos
06:19:26 --- join: xyh- (~xyh@14.150.213.59) joined #forth
06:21:46 --- quit: xyh (Ping timeout: 264 seconds)
06:23:13 --- nick: xyh- -> xyh
06:38:21 --- quit: proteusguy_ (Quit: Leaving)
06:38:41 --- join: proteusguy (~proteusgu@ppp-110-168-229-95.revip5.asianet.co.th) joined #forth
06:38:41 --- mode: ChanServ set +v proteusguy
06:43:50 <Quiznos> hi
06:45:32 <xyh> hiya Quiznos :)
06:45:52 <Quiznos> hi
06:59:43 --- join: mrm (~user@94.41.237.13.dynamic.ufanet.ru) joined #forth
07:00:49 --- part: mrm left #forth
07:09:43 --- quit: defanor (Ping timeout: 245 seconds)
07:18:31 --- join: defanor (~defanor@2a02:7aa0:1619::ca46:4831) joined #forth
07:25:10 --- join: Zarutian (~Adium@46.22.110.168) joined #forth
07:57:11 --- quit: fantazo (Quit: Verlassend)
08:08:32 --- join: gnooth (~gnooth@2602:306:cf96:8b60:53c:80e6:6bd8:f902) joined #forth
08:15:14 --- nick: xyh -> littlt-big-littl
08:15:20 --- nick: littlt-big-littl -> littltbiglittle
08:15:30 --- nick: littltbiglittle -> littlebiglittle
08:47:38 --- nick: littlebiglittle -> xyh
09:30:39 --- quit: Zarutian (Quit: Leaving.)
09:52:51 --- join: fantazo (~fantazo@089144230088.atnat0039.highway.a1.net) joined #forth
10:07:39 --- quit: xyh (Remote host closed the connection)
10:15:22 --- join: Zarutian (~Adium@168-110-22-46.fiber.hringdu.is) joined #forth
10:40:13 --- quit: darkf (Ping timeout: 244 seconds)
11:37:18 --- join: Mat4 (~claude@ip5b40b95e.dynamic.kabel-deutschland.de) joined #forth
11:37:21 <Mat4> hello
11:37:43 <Zarutian> h'lo Mat4
11:37:54 <Mat4> hi Zarutian
11:39:31 <Quiznos> hi
11:40:42 <Mat4> I will write the dictionary routines for my language implementation today and found it interesting that the call pattern for words is mostly simple. The last defined words are practical the most called ones
11:40:45 <Mat4> hi Quiznos 
11:42:05 <Mat4> this lead me to think that full hashing can be avoided and implementing dictionaries as classic binary trees in addition to a word cache is sufficient for ensuring dfast dictionary searches
11:42:20 <Mat4> ^fast
11:42:43 <Quiznos> you're working on a modern multi-gigahertz machine
11:42:48 <Quiznos> quite thinking about speed.
11:43:27 <Quiznos> i'm just doing a plain, unoptimised single linked list for my forth
11:43:39 <Quiznos> i have billions of cycles to burn
11:45:10 <Mat4> wel, if you have large sources than this little detail will matter
11:46:04 <Mat4> ^well
11:46:41 <ASau> Pf!
11:46:51 <ASau> Get those legendary large sources first. :)
11:47:17 <Quiznos> ASau: you quit me prematurely yesterday. i wanted to thank yu for your criticisms and insight.
11:47:20 * Mat4 found it personally inacceptable to waste ressources in any kind
11:47:57 <ASau> So you prefer to waste your time instead of machine time. :)
11:48:15 <ASau> Why not learn calculating in memory instead of using computer?
11:50:09 <Quiznos> ASau: dont ignore the compliment!
11:50:44 --- quit: Zarutian (Quit: Leaving.)
11:51:39 <Mat4> ASau: Thanks for your concerns. I can reassure you that 1. I have enough large sources to convert and process, 2. your argument is irrational as ever
11:52:44 <Quiznos> ASau: wth is wrong with you that you cant accept a compliment?
11:52:51 <Quiznos> damn man.
11:53:33 <Mat4> anyhow, I hope someone here have some experiences with hashed dictionaries for discussing advantages and disadvantages (beside memory demands)
11:54:19 <Quiznos> Mat4: i dont but i've already posted my position.  but i'll haggle with you about it 
11:54:25 <ASau> They make implementing redefinitions in Forth sense tricky.
11:54:42 <ASau> They make support of markers tricky.
11:55:08 <ASau> Not such a big deal, though.
11:55:17 <Quiznos> Mat4: for me, i think an esy way to hash forth words to signed cpu address 
11:55:30 <ASau> Not supporting any of said features make it feel more conventional language.
11:55:48 <Quiznos> bc that is the range for all usable memory, 0x08 to 0x0c-1
11:56:00 <Quiznos> including kernel space
11:56:39 <Quiznos> another simpler hashing, would be to create a new list of CFAs and sort by MRU
11:56:53 <Quiznos> like a bubble sort but incrementally.
11:57:11 <Quiznos> so then you use an index to pick the CFA in the list[]
11:57:19 <Quiznos> more indirection.
11:57:21 <ASau> If you don't care of markers, you can just lift words as you search through your SLL.
11:57:37 <Quiznos> dont lift names; use CFAs
11:57:59 <Quiznos> that could be a runtime opt to test.
12:00:37 <Mat4> ASau: That's one reasion why I want to avoid hashing. However adding a field to the entry headers which points to a linked list of redefinations should be a simple way for support. I think the real problem are markers
12:00:48 <Mat4> ^reason
12:01:45 <Mat4> memory wise I'm not sure if a binary tree would need less memory than a hashed dictionary
12:01:58 <ASau> It would.
12:02:04 <ASau> (Yes, the biggest problem is markers.)
12:02:47 <Mat4> Quiznos: Can you please explain your idea more precicly ?
12:07:54 <Quiznos> ill try
12:08:31 <Quiznos> build a std dict. then during runtime, a word can be called, to build a dynamic list[] of CFAs 
12:08:37 --- quit: zhiayang (Quit: snooze.)
12:08:51 <Quiznos> i'm thinking it could be provide a kind of runtime token-threading.
12:09:21 <Quiznos> so that words could be defined using smaller byte or 16b token CFAs
12:09:48 <Quiznos> but in that caase, the list would have to be static for stable indices
12:10:34 <Quiznos> then a new next() woud be needed to do a double load before jmp [ebx]
12:11:32 <Quiznos> so, forget anout being dynamic in the bubble sorted way
12:12:29 <Mat4> ok. If the entry size is half the word width for example then more as one entry can be compared in one iteration (just my intuitive thought by reading)
12:14:07 <Quiznos> maybe but thats not the point.  keep it simple
12:16:46 <ASau> (...And if you build perfect hash function, you can avoid multiple comparisons altogether.)
12:19:44 <Quiznos> i'd skip all that in the name of simplicity.
12:21:28 <Quiznos> forth is not supposed to be complicated
12:23:37 <ASau> If it isn't, why does it require support for "forget" or markers?
12:31:09 <Quiznos> bc forget is a natural function to apply to a linked list.
12:31:38 <Quiznos> altho and i do agree, it is comlicated
12:31:53 <Quiznos> and there are other complicated words too that arent factored well
12:31:57 <Quiznos> as you well know
12:33:32 <ASau> Even when you structure your wordlist as linked list, your dictionary is not a linked list still.
12:33:42 <ASau> It isn't a DAG even.
12:34:13 <Quiznos> why not a list?
12:35:07 <ASau> variable a : m2 ; ' m2 a !
12:35:19 <ASau> Now it isn't a DAG even, let alone list.
12:37:24 <ASau> : m1 ; variable a : m2 ; ' m2 a ! forget m2 ( this leaks memory usually )
12:45:14 <Quiznos> k
12:45:54 <Quiznos> but lfa only links names, not cfa's
12:46:48 <Quiznos> an cfa is always a member of Word's struct; i call it the Symbol, as represented by CFa.
12:47:23 --- join: vsg1990 (~vsg1990@cpe-67-241-148-119.buffalo.res.rr.com) joined #forth
12:47:53 <Quiznos> so, to your 2d examp., better gc has to be done.
12:48:05 <ASau> Whatever weasel words you write, either you leave a dangling pointer, or leak memory, or you implement proper garbage collector.
12:48:13 <Quiznos> ya
12:49:07 <Quiznos> that's not too difficult
12:49:13 <ASau> Which part?
12:49:19 <Quiznos> gc
12:49:23 <ASau> Leaking memory isn't difficult, sure.
12:49:34 <Quiznos> sure
12:49:43 <ASau> Garbage collector will require a lot of effort that is normally considered "overcomplicated" in Forth community.
12:51:07 <ASau> Note that you cannot implement reference counting and be done.
12:51:28 <ASau> (Not to mention that reference counting isn't considered garbage collection nowadays.)
12:52:31 <fantazo> but still people love to include reference counting for "performance". 
12:57:02 <Mat4> ASau: Garbage collection is avoided mostly because in embedded environments its procedere *can*  affect real time responsity
12:57:21 <Mat4> for hosted systems and dependent of the applications in mind it should be of no problem
12:57:43 <Mat4> ^it procedere
12:57:59 <Mat4> or responsivity?
12:58:55 <Quiznos> perhaps but i;m not willing just yet to close the book on it.
12:59:06 <Quiznos> nor am i redy to fully discuss the subject.
12:59:57 <ASau> Mat4: "embedded" <> "real-time".
13:00:13 <ASau> For start.
13:00:28 <ASau> Second, all this is bullshit.
13:01:05 <ASau> It only says that Forth programmers are so knowledgable that they don't know about RT GC algorithms.
13:03:05 <Mat4> you can bet there know such algorithms quite well. If you study proper, you will notice that such algorithms either can't grant real-time safety or are restricted to specific application scenarios
13:04:16 <Mat4> also please not that the term 'real-time' is somewhat generic. You can at least differentiate between soft and so called hard real-time demands
13:06:38 <fantazo> again an ASau day
13:07:30 <Mat4> if you count in addition requirements for failure security (which I think is a common case) than GC is a no go in my opinion 
13:07:32 <ASau> Sure, I know that a lot of people use the term "real-time" to denote that you are allowed miss "some" deadlines and nothing bad will happen.
13:08:04 <ASau> If you count in requirements for failure security, GC becomes mandatory.
13:08:50 <Mat4> for sure not, there exist better alternatives for that applications
13:09:04 <ASau> Like what?
13:09:25 <ASau> Like leaving dangling references?
13:12:11 <Mat4> mainly ensuring by 'speculative' compilation in combination with runtime simulations that memory leaks can't occur
13:13:12 <ASau> Oh, if you mean certified code that hardly applies to Forth with its incoherent semantics.
13:14:32 <Mat4> if this Forth is based on a virtual machine this can be done easily
13:14:49 <ASau> Bullshit.
13:15:13 <ASau> It doesn't depend on whether it is virtual machine or real one.
13:15:20 <Mat4> what a precise argument!
13:16:29 <ASau> If your machine allows mixing references and integers, you'll have big problems certifying your code irrespectively of that.
13:16:47 <Mat4> I don't need to discuss further to you. There are many satellites fore example circulating around the earth which you can take as example by demand
13:16:56 <ASau> (This again demonstrates how knowledgable Forth programmers are.)
13:17:43 <ASau> Launching sattelite doesn't require bug-free code.
13:17:48 <Mat4> you donÄt need to certificating a Forth program. All needed is to monitor memory accesses!
13:18:41 <Mat4> and there are plenty of settelites out there which whole software environment is based on Forth
13:18:47 <ASau> How does it prevent writing a random integer instead of valid address at valid location??
13:19:20 <ASau> There're plenty of web sites running PHP. So what?
13:20:18 <Mat4> because memory accesses are registered and type verificated (independent of the VM which executes the Forth program)
13:20:43 <Mat4> (This again demonstrates how knowledgable ASau is)
13:21:08 <ASau> How does it prevent from writing valid yet wrong address instead of correct one?
13:23:27 <Mat4> find it out for yourself. You can find the sources for some of the operating engines on the net (of course not actual used examples). A Hint: Forth code is easily parsable. It can be patched - or an exception handler can be run a maintenance routine
13:23:36 <ASau> If you manage to implement your great idea, I suggest that you publish it ASAP.
13:24:17 <ASau> I think, you'll get your Turing Award or Fields Medal.
13:25:02 <Mat4> *lol*
13:25:04 <ASau> Now you have only one small step to do: implement it.
13:25:27 <Mat4> already done (not be me)
13:25:37 <ASau> ORLY?
13:25:51 <Mat4> I have here a programming project. I spend better some time for it
13:25:52 <Mat4> ciao
13:26:06 --- quit: Mat4 (Quit: Verlassend)
13:26:07 <ASau> Has he got his Turing Award for breaking one of the most famous problems of the century?
13:26:35 <ASau> Pf!
13:27:34 --- join: Zarutian (~Adium@168-110-22-46.fiber.hringdu.is) joined #forth
13:39:22 <Quiznos> interesting thread
13:47:06 <Zarutian> Quiznos: re multi gigahertz machine: what if you intend to specify in BLIF an dual stack machine and it is intended to be run in an Secure Multi Party Computation ?framework/nodesetup/whathaveyou? and must keep its memory usage and circuit complexity to minimum yet gaining some usable speed?
14:01:25 <Quiznos> Zarutian: i cannot answer bc i am not famiar with terms: BLIF, "secure mutiparty computation".  splain?
14:01:31 <Quiznos> familar
14:12:02 <Zarutian> Berkley Logic Interchange Format
14:13:15 <Zarutian> secure multiparty computation is a way for few people or parties to perform joint computation on senstive data and get results they can use without revealing aforesaid data to the others in the computation.
14:15:40 <Zarutian> BLIF is a way to specify boolean logic circuits btw
14:16:25 <Quiznos> ok that has nothing to do with either the design of forth nor its implementation.
14:17:19 <Zarutian> Quiznos: it only pertains to how crappy speed and memory size as a platform for Forth or its implementations.
14:18:32 <Quiznos> my comment about modern machines was that the current technology mitigates must of the concern for needing to design fast and optimised implementations from the get-go.
14:18:46 <Quiznos> must/much
14:19:36 <Zarutian> mitigates in wrong directions.
14:19:50 <Quiznos> disagree
14:20:25 <Zarutian> I think due to pipeline stalls and cache subsystem issues that Forth code runing on an Apple ][e is actually faster than on modern machines
14:20:47 <Quiznos> there are no such elements in a R6502
14:20:53 <Quiznos> or c02
14:20:55 <ASau> Do you have code to prove the statement?
14:21:20 <Quiznos> mere logic and knowledge from those days is applicable and evident
14:21:39 <Quiznos> pipelining and caching is a post-90s thing
14:21:40 <Zarutian> ASau: nope but that isnt my point here. My point is that most modern machines are made with the assumption of running mostly straightline machine code.
14:22:05 <ASau> Sure.
14:22:15 <ASau> Yet I don't see why that must be bad.
14:22:19 <Zarutian> Quiznos: also pipelining costs die space and energy to run.
14:22:34 <Quiznos> i know that
14:22:56 <Quiznos> but native forths are small and fasat.  suitable for fitting within a icachekine
14:23:04 <Zarutian> which mostly results in shorter battery life and cooked laps
14:23:06 <Quiznos> fs
14:23:09 <Quiznos> fast
14:23:30 <Zarutian> indeed Forths fit into caches easily
14:23:47 <Quiznos> there is al awful lot of reasoning to mitigate against Forthing.
14:24:05 <Zarutian> if you are not running anything else on the hardware (and I count out hypervisors to)
14:24:09 <Quiznos> complicate hw doest need cocmplicate sw.
14:24:19 <Quiznos> plicated*
14:24:40 <Zarutian> complicated hardware because old software was slow.
14:24:40 <ASau> Alright, Forth implementation fits cache size, indeed.
14:24:49 <Quiznos> and besides, forth can translate down to bits if so designed
14:24:53 <ASau> What about other software?
14:25:12 <Quiznos> if they are staticly designed, then no, they are stuck
14:25:21 <Quiznos> or staticly compiled
14:25:32 <Quiznos> ie, high-level languages
14:25:43 <Quiznos> ie, gcc
14:25:49 <Zarutian> What I want you to consider is never saying again that 'you shouldnt have issues with choosing illfitting datastructures or algorithms because todays hardware is so fast anyway' or anything of that affect.
14:26:17 <Zarutian> otherwise someone who keeps Knuth in high regard might come after you with an ackerman function.
14:26:41 <Quiznos> on ancient hw with single digit Mhz speeds, redesigning Forth engines, and other sw's too, required ingenuity to increase speed.
14:26:49 <ASau> Ackerman's function is irrelevant.
14:27:07 <Quiznos> will gigahertz machines, tha need for speed can be set aside
14:27:27 <ASau> Today you have plenty of data that become a lot easier to process when you organize them in anything more complex than linked lists.
14:27:38 <Quiznos> i'm nt talking about elegence
14:28:02 <Quiznos> List is the egelent ADT
14:28:08 <Quiznos> elegant
14:28:16 <ASau> It is very ineffective at the same time.
14:28:28 <Quiznos> so what?
14:28:33 <ASau> So that!
14:28:38 <Quiznos> we've got a billion cycles plus
14:28:39 <Zarutian> ASau: indeed. I just dislike the dismissive talk like that afore quoted sentence portraus.
14:28:45 <Zarutian> portrays*
14:29:01 <Quiznos> it's not dismissivr in light of modern tech.
14:29:10 <Quiznos> let the tech be complicated, not the sw.
14:29:21 <Zarutian> Quiznos: see! exactly this thinking is why software today is bogging down hardware so much.
14:29:25 <ASau> Quiznos: there're plenty of examples lying on surface where replacing lists with, say, balanced trees, improve on time and IT IS VISIBLE.
14:29:43 <Quiznos> ok...
14:29:52 <Quiznos> leme see if i can refrase
14:30:02 <ASau> Do you understand that 30 sec and 1 sec is noticable change?
14:30:18 <Quiznos> yes
14:30:37 <ASau> On Intel QuadCore CPU.
14:30:39 <Quiznos> but that would obvly be an io bound process
14:31:05 <ASau> No.
14:31:07 <Zarutian> ASau: even that 300 ms and 1 ms is a noticable change in hard real time systems
14:31:34 <ASau> Zarutian: lets' ignore RT systems for now.
14:31:35 * Zarutian wants to note that not all Forths run on Intels power hungry processors
14:31:58 <ASau> Slower processes will make it even more visible.
14:32:08 <Quiznos> it's not that i am trying to dismiss ingenuity in sw diesng, but at the gHz speeds we'ew discussing, it does largely become ireelevent (bell curve-wise)
14:32:26 <Quiznos> diesng/design/
14:32:44 <ASau> Get it from 2 GHz to 700 MHz and it will be 90 sec vs 3 sec.
14:33:04 <Quiznos> slowness actually comes predominently form ring switching, libc calling, task switching, etc
14:33:19 <Quiznos> libc/any lib/
14:33:28 <ASau> You think so.
14:33:31 <Quiznos> layers upon layers between the user code and the hw
14:33:40 <Quiznos> it's all related
14:33:42 <ASau> Reality is a lot worse.
14:33:47 <Quiznos> no doubt
14:34:05 <ASau> In reality, the most processing time is in applications.
14:34:21 <Quiznos> but coding isnt real, it's just manipulatin of electrical patterns.
14:34:30 <ASau> And a lot of applications use ineffective programming techniques.
14:34:39 <Quiznos> and the percieved delay of activity reported by sw
14:34:47 <ASau> E.g. threading code vs. optimized native code.
14:34:49 <Quiznos> agreed
14:35:07 <Quiznos> but the space differential is absolutely mesurabl
14:35:08 <ASau> And linked lists vs. appropriate data structures.
14:35:48 <Quiznos> what better ist adt is there that a forth-dict can use?
14:36:00 <Quiznos> or be implemented using?
14:36:19 <Quiznos> ist/List
14:36:41 <Zarutian> ASau: hmm but with linked lists shadowing comes free no?
14:37:02 <ASau> Zarutian: the question is whether you really need it.
14:37:29 <Quiznos> in five seconds i'll accept your silence as an unanswered acquiesence. ;]
14:37:40 <ASau> Quiznos: If you stop clinging to some Forth properties, you can use more effective data structures than linked list.
14:37:58 <Quiznos> but yu cant tell me what that would be.
14:38:10 <Quiznos> i am a continuous student
14:38:17 <ASau> I can suggest several options.
14:38:22 <Quiznos> pls
14:38:34 <ASau> First, the most obvious is hash table.
14:38:55 <ASau> Second, less obvious is some balanced tree.
14:39:05 <ASau> Third, even less obvious: prefix tree.
14:39:19 <ASau> Fourth, even less obvious: splay tree.
14:39:51 <ASau> You can choose between them depending on what you optimize for.
14:39:56 <Quiznos> so one or more of those would be only applicable to hasing a symbol's name and its lfa. 
14:40:03 <Quiznos> cnt do that to the Body
14:40:30 <ASau> If you stop clinging to rigid representation you have picked up from FIG model,
14:40:48 <ASau> you'll understand that you don't actually need to keep everything in single record.
14:40:55 <Quiznos> and i'm not seeing any mention of a smart find that properly short-circuits on name]0] mismatch.
14:41:11 <ASau> Prefix tree.
14:41:17 <Quiznos> k
14:41:17 <ASau> Balanced tree.
14:41:55 <ASau> Both options give you fast way to distinguish symbols by first characters.
14:41:57 <Quiznos> ok so, for me, then, the question is how to do that elegantly in asm with macros.
14:42:06 * ASau shrugs.
14:42:14 <Quiznos> now were talking about implementation.
14:42:19 <Quiznos> dont shrug, it's rood
14:42:23 <ASau> The whole point of high-level languages is to help writing complex programs.
14:42:34 <Zarutian> Quiznos: with prefix tables you can just do repeated calculated loads.
14:42:43 <Quiznos> but i want a forth in asm, then in forth.
14:42:49 <Quiznos> metacompile forth.
14:42:50 <ASau> Yes, implementing red-black trees is more complex than implementing single-linked lists.
14:43:00 <Zarutian> Quiznos: bootstrapping Forth?
14:43:10 <Quiznos> Zarutian: ya
14:43:14 <ASau> That's the point: you implement more complex algorithm that makes your program run faster.
14:43:48 <Quiznos> ok but not initially; those HL words need to be devrleoped within the forth environ then carried over through metacompile
14:44:02 <Zarutian> Quiznos: then tries/Patricia tree/prefix tables are what you might want to look into.
14:44:04 <Quiznos> T1 -> T2 -> T3
14:44:17 <Quiznos> Zarutian: kl i'm familar with trie
14:44:28 <Quiznos> at least by name to lookup
14:44:54 <ASau> http://en.wikipedia.org/wiki/Tree -> computing -> all the rest.
14:45:01 <Quiznos> ya
14:45:22 <Quiznos> i'm familar with that thread
14:45:28 <ASau> Or just go to you library and pick up Knuth's book.
14:45:38 <Quiznos> right
14:45:54 <Quiznos> but this is just for Find.
14:46:03 <Zarutian> implementing the simplest ones in macro assembler shouldnt be that hard.
14:46:06 <Quiznos> not much usage for this complexity outside of find
14:46:24 <ASau> If all you do is writing toy Forth, sure.
14:46:39 <Quiznos> no; i want to develope a significant forth
14:46:41 <ASau> Otherwise, there's a hell lot of applications for red-black trees.
14:46:51 <Quiznos> k
14:46:54 <Zarutian> Quiznos: then you do want to look into tries by using repeated lookups.
14:47:02 <Quiznos> k
14:47:13 <Quiznos> but now right now
14:47:13 <ASau> In fact, you can choose any other balanced tree.
14:47:23 <ASau> AVL, AA, whatever.
14:47:33 <Quiznos> i still need to write the cold word :) and warm.
14:47:34 <ASau> LLRB.
14:47:40 <Quiznos> what's that?
14:47:44 <Zarutian> ASau: but here is a question: how often is find invoked outside of source parsing and compilation?
14:48:00 <Quiznos> llrb?
14:48:23 <Quiznos> inkedlist red-black?
14:48:26 <ASau> Zarutian: the question is whether he wants to use it anywhere outside "find".
14:48:42 <ASau> "Left leaning red-black tree."
14:48:47 <Quiznos> oh
14:49:09 <Quiznos> brb
14:49:49 <ASau> There exist even exotic data structures that still fit the problem.
14:49:54 <ASau> E.g. skip list.
14:50:07 <ASau> "More exotic."
14:50:48 <ASau> Or Huffman trees.
14:51:06 <ASau> Again, it all depends on what you optimize for.
14:51:14 <Zarutian> ASau: oh those are fun! Esplecially in encoding/decoding!
14:54:25 <ASau> Well... Huffman tree is a sort of prefix tree...
14:54:27 <ASau> Whatever.
14:55:28 <ASau> There's still a damn lot of data structures that implement associative mapping.
15:02:53 <Quiznos> ok; so for all this thread, i'd classify the mentioned ADTs as future possibilities.
15:03:23 --- quit: dys (Read error: Connection reset by peer)
15:23:24 --- quit: ASau (Ping timeout: 250 seconds)
15:23:29 --- quit: true-grue (Read error: Connection reset by peer)
16:50:18 --- quit: Zarutian (Quit: Leaving.)
17:14:52 <protist> I haven't used symbols in FORTH
17:15:29 <protist> when I implement symbols I make it so that I can intern them...once I intern I get some sort of symbol typed thing
17:15:40 <protist> if the symbol already exists, I return the existant one
17:15:50 <protist> otherwise I make one, add to table, and return the new one
17:16:05 <protist> for comparison then of symbols I can just compare the number within them
17:16:14 <protist> first symbol might have the number 0 in it
17:16:33 <protist> so unless you are talking about the intern part, then no mapping is needed for symbol comparison
17:16:43 <protist> just a pointer comparison
17:16:51 <protist> symone symtwo = if ...
17:17:45 <protist> you can make an immediate form of intern for word definitions
17:18:04 <protist> intern goes from string to symbol
17:18:44 <protist> if you aren't making new symbols from external sources at runtime, then all the slow part is at compile/read time
17:19:15 <protist> and that is if you are naive and use an association list of some sort for linear lookup
17:23:50 <protist> if the forth-dict yahl were talking about is the one for finding a execution pointer from a string of a word...then that is compile time so most people don't care to make the lookup sublinear
18:25:07 --- quit: TodPunk (Read error: Connection reset by peer)
18:25:45 --- join: Tod-Autojoined (Tod@50-198-177-186-static.hfc.comcastbusiness.net) joined #forth
18:27:32 <Quiznos> protist: i'm not familar with "intern" splain further?
18:28:07 <protist> Quiznos: intern is the function in Lisp languages that takes a string and returns a symbol
18:28:23 <protist> Quiznos: if you intern the same string twice, the symbols are considered equal
18:28:29 <Quiznos> ok i do know the source of the word
18:28:37 <Quiznos> but not its use
18:29:03 <protist> Quiznos: (intern "this") -> '|this|
18:29:06 <Quiznos> how familiar are you with forth internals?
18:29:14 <protist> I wrote a FORTH in x86 asm
18:29:17 <Quiznos> k
18:29:29 <Quiznos> briefly, in my forth;
18:29:31 <protist> what exactly were you trying to do?
18:29:42 <protist> ok show me...but I can't promise my FORTH isn't rusty :p
18:29:45 <Quiznos> struct Sumbol {char name[]; *nfa, *lfa, *cfa, pfa[] }
18:29:59 <Quiznos> nfa is a true pointer now
18:30:07 <protist> nfa points to what?
18:30:08 <Quiznos> and my forth is ITC
18:30:13 <Quiznos> name[]
18:30:26 <Quiznos> a counted asciiz string
18:30:33 <protist> write full names so I can see what this thing is
18:30:34 <protist> :P
18:30:36 --- nick: Tod-Autojoined -> TodPunk
18:30:47 <Quiznos> indirect threading
18:30:55 <Quiznos> (*fp)() is CFA
18:31:01 <Quiznos> *CFA
18:31:03 <protist> I would prob just do struct symbol{char *name;int val;};
18:31:23 <Quiznos> that's not enuf for a proper word structure with head and body
18:31:42 <protist> maybe oh you are defining a word there?
18:32:18 <Quiznos> the struct is the whole symbol with separare code and data sections on hostlinux 32 bit
18:34:08 <Quiznos> so tell me more about intern?
18:34:48 <Quiznos> it is the storing of a name in a searchable way?
18:38:57 <protist> : intern dup symboltable lookup dup if swap drop else here swap , symbolcount @ , 1 symbolcount +! dup symboltableinsert then ;
18:39:45 <protist> I was assuming the string was represented as one pointer Xp
18:39:51 <protist> but that is the idea
18:40:10 <protist> and that lookup was a symboltable lookup that just compares the string
18:40:36 <Quiznos> from *CFA, the addr of NFA can be derived and getted
18:40:53 <Quiznos> ok so it is the same with different wroding.
18:40:59 <protist> I still don't know what NFA is
18:41:04 <Quiznos> name field addr
18:41:15 <Quiznos> whose value is a ptr to the stringz
18:41:24 <protist> I'm basically making a symbols table as an array of 2-tupes [(name,id),...]
18:41:25 --- quit: vsg1990 (Read error: Connection reset by peer)
18:41:46 <protist> don't need the id actually
18:41:51 <protist> can just compare the locations
18:41:55 <Quiznos> ya, and in stdforth, id is link field addr, LFA, which points to previous word in dict list.
18:42:03 <protist> because a symbol with a given name should only exist in one place
18:42:18 <protist> or need only exist in one place*
18:42:34 <Quiznos> and, LFA-cellsize -> NFA c@ produces count byte of name
18:43:26 <protist> why define symbols in C?
18:43:39 <Quiznos> easier to send to kernel for service
18:43:48 <protist> whatever works :p
18:43:50 <Quiznos> not C, just a final null
18:43:56 <Quiznos> ya
18:44:09 <protist> symbols can be just like a string except if they have the same name they have the same location
18:44:14 <protist> that is how I like to write them
18:44:26 <Quiznos> all print names eventually are sent to kernel for display
18:44:37 <Quiznos> k
18:44:43 <protist> interning a string just finds the one already existant if it does exist...otherwise returns the old pointer
18:44:56 <protist> then for symbol equality just compare pointers
18:45:08 <Quiznos> but it's easier in forth to keep all struct fields together
18:45:29 <protist> in my interpreters I just have an enum type {symbol,int...} field....symbols just like strings except for type field set to sym
18:45:31 <protist> bol
18:45:34 <Quiznos> after compiing a colon def, strings arent compared
18:46:11 <protist> yeah intern in immediate mode and shove it into the code however you will
18:46:55 <protist> [ s" thissymbol" intern ] literal
18:47:33 <protist> do your interns at compile time...if you need a real-time intern...then you may want a smart lookup
18:49:39 --- join: vsg1990 (~vsg1990@cpe-67-241-148-119.buffalo.res.rr.com) joined #forth
18:57:58 <protist> what do you want these symbols for?
18:58:23 <protist> I guess enums are like the poor man's symbols
18:58:28 <Quiznos> the symbol is the structure that makes up each word defined.
18:58:28 <protist> symbols are nice :D
18:58:47 <Quiznos> then, the symbol, after compile, is represented by its CFA
18:58:58 <Quiznos> nfa is the prname
18:59:11 <protist> if you use abbrevations I won't understand :P
18:59:19 <Quiznos> lfa is link add to previous defined symbol
18:59:38 <protist> so you are just using symbols for word lookup?
18:59:42 <Quiznos> you said you wrote a forth of your own.  these are std names that i use.
18:59:57 <protist> https://github.com/GordianNaught/FORF
19:00:05 <Quiznos> heh
19:00:08 <Quiznos> clever name
19:00:09 <protist> :p
19:00:12 <protist> thanks haha
19:00:31 <Quiznos> be here in 6hm i have to sleep now.
19:00:35 <Quiznos> 6h,
19:00:43 <protist> I did do something kinda odd with typetages on code....can be handled better
19:00:47 <Quiznos> we can argue semantics then
19:00:51 <protist> kk cya
19:00:57 <Quiznos> ty gn
19:01:00 <Quiznos> afk
19:01:04 <protist> gn :)
19:04:14 --- join: zhiayang (~zhiayang@bb219-74-68-213.singnet.com.sg) joined #forth
19:06:58 --- quit: zhiayang (Client Quit)
20:05:03 --- join: darkf (~darkf___@unaffiliated/darkf) joined #forth
20:16:58 --- quit: proteusguy (Ping timeout: 264 seconds)
20:20:58 --- quit: vsg1990 (Quit: Leaving)
20:29:06 --- join: proteusguy (~proteusgu@ppp-110-168-229-47.revip5.asianet.co.th) joined #forth
20:29:06 --- mode: ChanServ set +v proteusguy
22:32:34 --- join: xyh (~xyh@14.150.213.59) joined #forth
23:59:59 --- log: ended forth/15.08.08