00:00:00 --- log: started forth/16.01.18
00:47:25 --- join: ASau (~user@netbsd/developers/asau) joined #forth
00:49:43 --- quit: proteusguy_sat2 (Ping timeout: 255 seconds)
01:27:26 --- join: xyh (~cicada@111.50.93.123) joined #forth
01:48:27 --- quit: atommann (Ping timeout: 245 seconds)
01:51:43 --- quit: xpoqp (Changing host)
01:51:43 --- join: xpoqp (~xpo@unaffiliated/xpoqz) joined #forth
01:58:39 --- join: atommann (~atommann@210.3.149.230) joined #forth
02:17:28 --- quit: atommann (Ping timeout: 240 seconds)
02:35:38 --- quit: ASau (Ping timeout: 240 seconds)
03:57:13 --- join: proteusguy_sat2 (~proteusgu@180.183.100.16) joined #forth
04:30:12 --- join: atommann (~atommann@222.248.65.23) joined #forth
05:03:51 --- quit: atommann (Quit: Leaving)
05:24:29 --- quit: proteusguy_sat2 (Ping timeout: 256 seconds)
05:56:37 --- quit: xyh (Ping timeout: 260 seconds)
06:09:45 --- join: ASau (~user@netbsd/developers/asau) joined #forth
06:31:10 --- join: xyh (~cicada@111.50.93.123) joined #forth
06:45:32 --- quit: xyh (Quit: ChatZilla 0.9.92 [SeaMonkey 2.39/20151206235742])
06:46:09 --- join: xyh (~xieyuheng@111.50.93.123) joined #forth
07:14:37 --- join: Kumool (~kumool@adsl-64-237-238-1.prtc.net) joined #forth
07:43:54 --- join: Mitzelflick (6c07ef0d@gateway/web/freenode/ip.108.7.239.13) joined #forth
07:44:03 --- join: proteusguy_satri (~proteusgu@ppp-110-168-230-73.revip5.asianet.co.th) joined #forth
07:44:30 <Mitzelflick> http://colorforth.com/haypress.htm
07:44:43 <Mitzelflick> This blog will document my experience with GreenArrays' Evaluation Board. It has 2 GA144 multi-computer chips, each with 144 f18a computers. Total of 288 computers running at 650 Mips or 194 Gips.
07:45:02 <Mitzelflick> does this mean the haypress if equivalent to 194Ghz cpu?
07:45:19 <Mitzelflick> s/if/is
07:47:51 <Mitzelflick> 194Ghz cpu seems fast
07:48:10 <Mitzelflick> wow
08:36:10 --- join: little_bit (~tomkl@unaffiliated/tomkl) joined #forth
08:58:17 --- quit: ASau (Remote host closed the connection)
08:58:35 --- join: ASau (~user@netbsd/developers/asau) joined #forth
10:02:00 --- join: Zarutian (~zarutian@168-110-22-46.fiber.hringdu.is) joined #forth
10:21:59 --- nick: xyh -> xyh-sleeping
11:15:07 --- join: true-grue (~true-grue@176.14.216.104) joined #forth
11:31:18 --- join: suppi (~suppi@unaffiliated/suppi) joined #forth
11:48:03 --- quit: true-grue (Read error: Connection reset by peer)
12:18:41 --- nick: xyh-sleeping -> xyh
12:46:28 <xyh> hi friends, see this :: https://github.com/cicada-language/threaded-code-interpreter
12:51:54 --- join: impomatic_ (~digital_w@79.16.114.87.dyn.plus.net) joined #forth
13:19:06 --- quit: impomatic_ (Quit: http://corewar.co.uk)
13:55:51 --- quit: asagk (Ping timeout: 276 seconds)
14:02:40 <Mitzelflick> things have to be better in forth
14:04:17 <xyh> Mitzelflick: to me ?
14:05:59 <Mitzelflick> hi
14:06:12 <Mitzelflick> interesting link, but no I was just saying
14:06:20 <Mitzelflick> ocaml eh?
14:06:29 <Mitzelflick> sen rmox? csp operating system?
14:06:41 <Mitzelflick> occam-pi
14:07:48 <xyh> sen rmox? csp ?
14:08:19 --- join: asagk (~asagk@i59F6A41F.versanet.de) joined #forth
14:08:28 <xyh> must be german typo
14:09:30 <Mitzelflick> seen
14:09:45 <Mitzelflick> http://rmox.net/
14:15:36 <xyh> looks cool :)
14:30:28 <Mitzelflick> makes me wana learn occam-pi
14:30:35 <Mitzelflick> but I don't even know basic programming
14:30:45 <Mitzelflick> I have so lttle time and so many things I want to do
14:37:05 --- quit: suppi (Quit: Leaving)
14:41:43 <xyh> you can start forth first :: http://www.forth.com/starting-forth/sf1/sf1.html
14:41:58 <little_bit> you can learn Forth in a half hour. :P
14:42:28 <little_bit> Mitzelflick: if you want literature, Starting Forth and Thinking Forth are good reads, even if you don't have a Forth interpreter in front of you.
14:43:02 <little_bit> Mitzelflick: if you want a Forth interpreter without installing one, you can use repl.it
14:43:15 <little_bit> or ideone.com
14:47:47 --- join: vsg1990 (~vsg1990@pool-74-110-57-203.bflony.fios.verizon.net) joined #forth
14:47:58 --- quit: Zarutian (Quit: Zarutian)
14:56:07 <Mitzelflick> can forth be used for business software? web?  I was reading a awesome for dynamic website page and lost the link.  The guy said he basically computed based on urls
14:56:12 <Mitzelflick> url strings
14:56:26 <Mitzelflick> and once he got doing that it all became ez
14:56:33 <Mitzelflick> but I lost the damn page link
14:56:36 <Mitzelflick> fffaak
14:57:11 <little_bit> Mitzelflick: yeah, it can. I'm utilizing Forth to write literate procedure files for a product test suite
14:57:17 <little_bit> easy to maintain, easy to write..
14:57:31 <Mitzelflick> awesome
14:57:49 <little_bit> I'm also hoping to replace my existing toolset for webdev with a Forth-based one.
14:58:00 <Mitzelflick> yeah?
14:58:01 <Mitzelflick> awesome
14:58:16 <Mitzelflick> so forth dev is speedy once you get the hang?
14:58:29 <little_bit> forth dev is slow once you get the hang, but not for the reasons you expect.
14:58:34 <Mitzelflick> bash kicks my ass when I need math
14:58:43 <Mitzelflick> moving files n rewriting config files easy in bash
14:58:52 <Mitzelflick> oh?
14:58:58 <little_bit> sure, it's easy to load up gforth, hack something out then move it to a file and invoke the interpreter.
14:59:27 <little_bit> but writing maintanable code, and being able to do that in a timeframe that's acceptable is what Forth is also about.
14:59:46 <little_bit> you'll spend more time thinking about the problem than writing about it.
14:59:50 <little_bit> and that is a good thing.
14:59:51 <Mitzelflick> !
15:00:07 <Mitzelflick> I read Jeff Fox the forth methodology applied 
15:00:11 <Mitzelflick> was so inspired
15:00:23 <little_bit> think about what you have here: you have a language which allows you to bend the syntax to your whim. you're forcing a simple beast to do your work.
15:00:30 <Mitzelflick> I see java at my owrk using many gig to accomplish little
15:00:42 <Mitzelflick> and lots money spent to see in web graphs what java is doing
15:00:43 <Mitzelflick> sad
15:00:46 <little_bit> don't knock Java, it has its uses. every language has its place, as they are tools.
15:00:55 <Mitzelflick> hmm
15:00:56 <Mitzelflick> ok
15:01:01 <little_bit> always analyze the problem domain before you attack the language.
15:01:07 <Mitzelflick> it seems glue between proprietary stuf
15:01:17 <Mitzelflick> Im in medical image regulated apps
15:01:22 <little_bit> fun!
15:01:22 <Mitzelflick> ops side
15:01:38 <little_bit> I'm in manufacturing management for large-scale aerospace.
15:01:41 <Mitzelflick> basically moving xrays over wire in nice regulation friendly way
15:02:01 <Mitzelflick> I wish aerospace tek wouild mass produce houses
15:02:07 <Mitzelflick> end need for mortgages
15:02:10 <little_bit> lol.
15:02:34 <little_bit> but, back on Forth, the reason why it's a treat to use is that its targeted problem domain is both nonexistant and mutable.
15:02:52 <little_bit> don't like something? find a certain syntax confusing? replace it.
15:03:14 <little_bit> there was a lisp programmer who wanted to try Forth but really hated the fact that we couldn't use parentheses.
15:03:23 <little_bit> I looked at him, deadpan, and said "sure you can!"
15:03:32 <Mitzelflick> :)
15:03:50 <little_bit> : ( ; : ) ; ( ( 3 4 + ) ( 2 3 + ) + )
15:04:10 <little_bit> we went on further to discuss behaviors like (+ 1 2 3 4 5 6 7 8 9 10)
15:04:23 <little_bit> which involved us redefining +.
15:04:28 <little_bit> it was a magical evening.
15:04:35 <little_bit> and that's the fun.
15:05:21 <Mitzelflick> heh
15:05:27 <little_bit> the fact that you can take this construct of legos, composable elements of a program, and make something entirely new that suits -you-... that's something that makes me smile when I use Forth.
15:05:28 <Mitzelflick> mind blowing freedom
15:05:53 <Mitzelflick> I mean to me most web apps are simple sorts based on a few inputs.
15:05:53 <little_bit> friends call me the "forth knight". I talk far too much about it.
15:06:01 <Mitzelflick> find me my product x on amazon
15:06:04 <Mitzelflick> at y price
15:06:12 <Mitzelflick> z shoe size
15:06:18 <Mitzelflick> no way
15:06:19 <Mitzelflick> talk more
15:06:22 <Mitzelflick> blog all day
15:06:25 <little_bit> most web apps have complex interactions between their data store and the interface to it. really, it can be equated to an outer interpreter.
15:06:44 <little_bit> we just plug in a different interpreter depending on what kind of app we want to make. :P
15:06:58 <Mitzelflick> find me this! here are some factors! search, list in order..
15:07:16 <Mitzelflick> true that
15:07:31 <little_bit> it's funny because that's a major component of the "web boom".
15:07:43 <little_bit> "I have a vision of what I want my result to look like. here it is."
15:07:52 <little_bit> and you just fill out the rest of the nitty gritty.
15:07:57 <little_bit> well, Forth's been doing that since the 70's.
15:08:21 <little_bit> an emphasis on top-down design, sketching out and thinking of the final product before going back and carefully dismantling it into small pieces and inspecting them.
15:08:32 <little_bit> Forth could very well fit into the web space.
15:12:38 <little_bit> it's funny, I mainly talk in ##programming about this stuff.. this channel is fairly dead. :P
15:53:32 --- quit: Mitzelflick (Quit: Page closed)
16:24:42 --- quit: Kumool (Ping timeout: 245 seconds)
17:16:03 --- quit: asagk (Ping timeout: 276 seconds)
17:18:33 --- join: asagk (~asagk@i59F6A41F.versanet.de) joined #forth
17:44:42 --- quit: karswell (Ping timeout: 245 seconds)
18:15:01 --- join: karswell (~user@135.18.198.146.dyn.plus.net) joined #forth
18:24:25 <bluekelp> little_bit: yeah we've slowed down even in the time i've been here
18:24:30 <bluekelp> ebbs and flows
18:25:13 <little_bit> heh.
18:25:16 <bluekelp> i'm interested to hear more from people who consider forth apropos for high-level domains - i consider it almost exclusively for low-level use
18:26:04 <little_bit> bluekelp: something like a more feature-complete Redis would be nice.
18:26:52 <yunfan> bluekelp: i am always tring to use forth at high-level domain
18:27:09 <little_bit> Forth fits pretty well in higher-level domains. the problem is trying to re-use something like gforth.
18:27:17 <yunfan> little_bit: thise redis idea is one of mine, i have send it to mailling list
18:27:33 <little_bit> great for small things, that one, but I'd rather write my own Forth for my problem domain.
18:27:35 <bluekelp> interesting. i guess because i never bothered to implement things like hashtables/etc. i didn't try high level stuff - the stuff we do at work in java
18:28:01 <little_bit> I like it because at any point I can choose to extend rather than go back and modify.
18:28:05 <bluekelp> i tried writing my own forth. failed :) but that's on me and in this case my asm skills more than anything, i think
18:28:21 <little_bit> ahh, lame! I recently wrote an inner interpreter in x86 assembly.
18:28:21 <yunfan> bluekelp: try again :D
18:28:31 <little_bit> never did x86 before, so it was nice.
18:28:33 <bluekelp> when i have time, i'd like to
18:28:57 <yunfan> yesterday i decide to learn some mips asm for tring again to implemnt my own forth
18:29:11 <bluekelp> i have a jonesforth port (x86, different assembler style) and one arm in progress
18:29:11 <little_bit> really, though, it's not about the low-level stuff.
18:29:29 <little_bit> I've been wanting to implement a proper Forth in javascript.
18:29:35 <bluekelp> right. but i need to basics to work then i can play with the more fun stuff :)
18:29:48 <yunfan> jonesforth is too long to me, also x86 asm is too complex campared to mips/arm
18:29:51 <little_bit> give it access to the DOM.
18:30:09 <little_bit> have primitives oriented towards a valid HTML DSL.
18:30:14 <yunfan> little_bit: there is forth in javascript, check jeforth.com
18:30:28 <bluekelp> i pared down jones once - not sure if it's public. was trying to see how small i could get it and then see how small it would be
18:30:35 <yunfan> they just showed many demos which they manipulate canvas using forth
18:30:40 <bluekelp> also for conceptual reasons - simpler = easier to grok
18:30:44 <little_bit> yunfan: bring me.. to nowhere, not found. :P
18:30:51 <yunfan> little_bit: hold on
18:31:06 <little_bit> I've also had a great idea for a Forth IDE.
18:31:15 <yunfan> little_bit: http://www.jeforth.com/
18:31:16 <little_bit> (that also behaves well in the terminal)
18:31:34 <little_bit> yunfan: yeah, and it just displays a black dotted background, a blue bar saying "jeforth.com".
18:31:34 <yunfan> little_bit: also this https://github.com/yapcheahshen/jeforth
18:31:39 <little_bit> and some chinese letterings.
18:31:47 <little_bit> I think he lost the domain lmao.
18:31:57 <yunfan> little_bit: yep, that's why i gave you the github address
18:32:33 <little_bit> yunfan: does it have access to the DOM? can I play with it WYSIWYG style and append DOM elements at runtime?
18:32:37 <yunfan> little_bit: anyway, we all agree forth could be use to made a redis like service and made it more powerful , isnt it?
18:32:54 <yunfan> little_bit: of cause it can do that if you have checked its code
18:32:59 --- join: Kumool (~kumool@adsl-64-237-237-65.prtc.net) joined #forth
18:33:08 <little_bit> 'course. I'm using Redis right now for a large-scale manufacturing management program.
18:33:14 <little_bit> forth's also great for literate programming.
18:33:37 <yunfan> little_bit: me too, they use lua for complex task in redis, which i think is too heavy
18:33:48 <yunfan> and forth is the right language in this case i think
18:34:00 <yunfan> just send forth code via redis protocol
18:34:06 <little_bit> to me it's the right language in any case. :)
18:34:13 <little_bit> fluid, mutable, rewritable.
18:34:26 <yunfan> well i am not only use one language
18:34:31 <yunfan> i also use clojure :D
18:34:33 <little_bit> if I could, I would.
18:34:49 <little_bit> I remember the old days where I was implementing Forths on Heathkit trainers.
18:34:52 --- quit: vsg1990 (Quit: Leaving)
18:34:58 <little_bit> byte by byte.
18:35:22 <yunfan> little_bit: what do you use redis for?
18:35:26 <bluekelp> yeah jeforth.com seems to be owned by a domain parker
18:35:35 <yunfan> bluekelp: what?
18:35:40 <little_bit> yunfan: right now, tracking inventory, user/capabilities, time clocks, logging...
18:35:44 <little_bit> yunfan: just about everything
18:35:52 <little_bit> tried postgreSQL, sucks.
18:36:00 <little_bit> mainly because of the interoperability between it and LibreOffice.
18:36:05 <little_bit> we need to be able to edit the DB.
18:36:14 <little_bit> so, Redis Desktop Manager is pretty light.
18:37:01 <yunfan> little_bit: what about sqlite? it has a vm design in low-level 
18:37:25 <yunfan> maybe you could bring your meta compiler for sqlite in your forth :D
18:37:27 <little_bit> I'd love to use SQLite, but again, interoperability.
18:37:37 <little_bit> ha! I'd love it, if I had the time.. need to deploy this in 2 weeks.
18:37:44 <little_bit> so I'm drawing up some clear and concise code in Node.js
18:38:00 <yunfan> little_bit: also check ssdb which use harddisk as the storage
18:38:14 <yunfan> and gain less performance lost compared to redis
18:38:22 <little_bit> yunfan: I've been worried about Redis' persistence model.
18:38:41 <yunfan> little_bit: it do has problem, we have met that serveral times
18:39:30 <little_bit> but honestly, if we fall victim to a power outage, I hope the snapshot finished in time.
18:39:36 <yunfan> little_bit: redis used to have a single thread design, and for interal dumping, they have to use a background thread for that
18:39:45 <little_bit> yeah.
18:39:46 <yunfan> but still it will hung while doing that
18:40:26 <yunfan> and for a 30G data, it will hung for seconds , which is unacceptable for us in server case
18:40:53 <little_bit> this is a local production system, so it's not that bad.
18:40:58 <little_bit> what I _do_ worry about is queries.
18:41:06 <little_bit> we're doing inventory.
18:42:00 <yunfan> oh, i got it, that's  the one reason they import lua
18:42:11 <little_bit> yeeeeah...
18:42:12 <yunfan> you need nested query one by one
18:42:29 <little_bit> unfortunately I think I need to write a query system by myself based on what the company needs.
18:42:32 <yunfan> and redis's design is one command per time
18:42:45 <little_bit> yeah, and I kinda like that.
18:43:10 <little_bit> thankfully I have like 32GB worth of RAM.
18:43:16 <little_bit> and we can order more if needed.
18:43:20 <yunfan> but you still need complex support , maybe you could try to made a tree type for it
18:50:23 <bluekelp> how much data were you trying to put in postgesql? it's pretty robust
18:50:39 <bluekelp> if it can't handle it, sqlite and/or ssd aren't the answer, i suspect
18:52:58 <yunfan> little_bit: does your inner interpreter in x86 asm public?
19:03:48 --- join: atommann (~atommann@210.3.149.230) joined #forth
19:14:08 <little_bit> yunfan: sadly, no.
19:14:25 <little_bit> yunfan: oh! actually, yeah, I can post the source if you like.
19:14:37 <little_bit> bluekelp: no no, it's not postgresql handling it.
19:14:51 <little_bit> bluekelp: it's the fact that LibreOffice Base sucks.
19:15:01 <little_bit> and it's what the clerks are gonna use.
19:16:03 <little_bit> bluekelp: but, Redis Desktop Manager can handle what we need, and I can organize queries..
19:16:55 <little_bit> I might swap back to PostgreSQL.
19:17:30 <yunfan> little_bit: yes i want to check it
19:17:53 <little_bit> bear in mind, it's not ITC, or really even DTC..
19:18:10 <little_bit> nor does it have any dictionary functions.
19:18:20 <little_bit> I've been writing it in my spare time.
19:18:36 <yunfan> dont worry, just want to learn something from small code
19:18:41 <little_bit> http://pastebin.com/kxSw0FH9
19:19:44 <little_bit> notice, I don't use the hardware stack for return addresses.
19:21:01 <yunfan> ok
19:22:28 <little_bit> I actually don't have any codewords or dedicated parameter spaces: I mix code with data.
19:23:06 <yunfan> is it ok on linux?
19:23:22 <little_bit> yuh. gcc <your file>.s && ./a.out
19:23:26 <little_bit> it's 64-bit.
19:24:19 <yunfan> you use %rax, so its 64bit 
19:24:24 <little_bit> yup.
19:24:59 <yunfan> little_bit: i think such lengh code is useful for me to understand
19:25:08 <yunfan> only 200+ lines :D
19:25:25 <little_bit> heh, have you written your own Forth before?
19:25:46 <yunfan> little_bit: a pyforth 
19:25:56 <little_bit> ah! I think I actually read your source then.
19:25:56 <yunfan> which i dont know if its itc or dtc
19:26:03 <little_bit> eh.
19:26:06 <yunfan> that's why i want to implement a forth in asm
19:26:13 <little_bit> honestly, I don't think it matters.
19:26:13 <yunfan> little_bit: really?
19:26:23 <little_bit> I like mixing code with data, because I can do some weird shit.
19:26:42 <little_bit> gives me a platform for A: optimization (I'm not spending time crawling through the dictionary for primitives)..
19:26:55 <little_bit> and B: more optimization! (dedicated words for list of secondaries.)
19:27:29 <little_bit> yunfan: yeah!
19:28:06 <yunfan> little_bit: yes, if you dont need meta compiling and other advanced features, my pyforth works well and its extreme tiny
19:28:14 <yunfan> but i do want advanced features :D
19:28:24 <little_bit> yunfan: oddly enough "advanced features" aren't really all that advanced.
19:28:29 <little_bit> even metacompilationis pretty easy.
19:28:35 <little_bit> *metacompilation is
19:28:41 <little_bit> just allow your Forth to access the input stream.
19:29:03 <yunfan> little_bit:  and those compling time words
19:29:25 <little_bit> yunfan: again, just add some annotations to the dictionary and write your "compiler" in the inner interpreter. :P
19:29:58 <yunfan> also if else is not easy for python implementation, but it could be implement if i use runtime generated function
19:30:08 <yunfan> i knew there are some libraries doing this
19:30:48 <little_bit> I suggest just making into branching structures.. you're just operating on lists of addresses, branching can be relative.
19:31:36 <yunfan> little_bit: this remind me the minimal forth design
19:31:43 <little_bit> in fact in my forth a naive relative branch can be expressed by : branch ip @ + ip ! ;
19:31:46 <yunfan> which use lua as the implementation language
19:42:29 <yunfan> little_bit: why you have a execution body address in the header of each word since the address is just the follow 
19:42:50 <little_bit> yunfan: I don't expect that to be the case in the final product.
19:43:09 <little_bit> yunfan: I expect to have a dedicated data segment for headers and another for code.
19:44:36 <yunfan> ok
19:45:20 --- join: Kumool_ (~kumool@adsl-64-237-237-65.prtc.net) joined #forth
19:45:34 --- quit: Kumool (Ping timeout: 264 seconds)
19:51:45 <yunfan> little_bit: ok i got it, you have a indepand ip , and for each code word, they should finally jump to next at the end, and for non code words, they should be called after a enter words and have a exit words at the end of its definition
19:52:01 <little_bit> exactly.
19:52:15 <little_bit> yunfan: this way, I spend less time in "enter" and combing through the dictionary. I can just inline the call.
19:52:43 <little_bit> it also makes assembly easier because I don't have to create an anonymous dictionary entry, I can just use some of the scratch data
19:52:53 <yunfan> and the enter/exit words just do the works like c's  function call pre/post jobs
19:53:10 <little_bit> exactly.
19:53:34 <little_bit> yunfan: the downside is that every subroutine call is now 8 bytes longer.
19:54:08 <little_bit> yunfan: so averaging 16 bytes at 32 calls per word at 1024 words gives you half a megabyte worth of instructions.
19:54:21 <little_bit> that's assuming _every single one of those things isn't a primitive_ like dup.
19:59:58 <yunfan> little_bit: finally got it, that address you use to add to the words' definition, so you dont need to do really execution body addres finding in `enter`
20:00:10 <little_bit> yunfan: exactly.
20:00:12 <yunfan> you just jump to the real address
20:00:31 <little_bit> yup. you can consider it all to be a sort of bastardized ITC implementation where you always docol.
20:01:35 <yunfan> little_bit: then i am courious how would DTC do ?
20:02:29 <little_bit> yunfan: ITC and DTC are two sides of the same coin. one contains a pointer to the codeword's code, the other is just a direct jump to that codeword
20:02:38 <little_bit> yunfan: so where you'd see .quad <codeword>
20:02:51 <little_bit> yunfan: you would then see, with DTC, "jmpq <codeword>"
20:04:14 <yunfan> so DTC increase the size of definition but reduce the the number of extra instructments
20:04:39 <little_bit> it decreases the indirection amount.
20:05:03 <little_bit> you essentially jump to that place in the dictionary, hit the "jmp" where the codeword was supposed to be, and ride it to the codeword's assembly.
20:05:13 <little_bit> instead of having to load that into a register and do an indirect jump.
20:07:20 <yunfan> get it, want to implement my own now
20:07:28 <little_bit> go ahead! :D
20:07:30 <little_bit> dirt simple.
20:09:58 <yunfan> little_bit: why dont you use "call <codeword>" in DTC?
20:10:08 <little_bit> yunfan: you can.
20:10:30 <yunfan> if you just use jumpq, should you do push ip action in the begining of that codeword?
20:10:38 <yunfan> just like c's function
20:11:44 <little_bit> honestly? jumping to the codeword and letting it handle the return stack stuff is better.
20:12:40 <yunfan> got it, it just then increse ip, and jump back to it
20:12:43 <yunfan> no need to use ret
20:14:47 <little_bit> exactly.
20:15:59 <yunfan> and i think this could be used to implement tail-rescue
20:16:38 <little_bit> it can. .quad jump .quad <this routine's address>
20:17:54 <yunfan> yes
20:19:01 <yunfan> https://gist.github.com/AndrewTsao/4425791
20:19:20 <yunfan> according to this data, i think forth is better to use in redis to replace lua
20:19:32 <yunfan> if you need to do complex querying
20:19:40 <little_bit> honestly, I'd just build a Redis out of something like Gforth.
20:20:30 <yunfan> little_bit:  i have writed a article about that years ago. but its written in chinese, 
20:20:57 <yunfan> little_bit: i think redis is just some data structure hosting service
20:22:30 <yunfan> so you could use a vm design , which only handle io operation like paring request and responsing job , also handle storage read/write
20:23:14 <yunfan> then throw all the other jobs to the inside task which runs on vm
20:23:54 <yunfan> or if you want to optimizing , you could implement different storage backend, and provide a service to the vm
20:25:16 <little_bit> honestly, I'd just extend the dictionary vocabulary to support ACID.
20:25:27 <little_bit> make forth's dictionary the data store. :P
20:27:09 <yunfan> little_bit: i want to use sophia or wiredtiger as the storage backend , and provide a redis like service, so that you could use the same interface but get support to store peta bytes of data, which is redis cant do right now
20:27:50 <little_bit> aye, simply because it's RAM-limited...
20:30:40 <yunfan> yep
20:30:50 <yunfan> and recently people get used redis's interface
20:31:48 <little_bit> honestly, if I can come up with my own method of dumping data from Redis and then versioning it out incrementally, I can "page" redis.
20:32:50 <yunfan> well , i think such job could handle to professional people like sophia db team and wiredtiger team which i mentioned
20:34:20 <yunfan> i got to go for lunch (not launch :)
20:35:09 <little_bit> cheers! :)
20:35:20 <little_bit> btw, if you ever want to catch me in a more active setting, join ##programming
20:37:58 <yunfan> little_bit: well , we have privmsg in irc ;]
20:38:13 <little_bit> true!
20:41:22 --- quit: proteusguy (Ping timeout: 264 seconds)
20:41:23 --- quit: proteusguy_satri (Ping timeout: 265 seconds)
20:53:32 --- join: proteusguy_satri (~proteusgu@ppp-110-168-229-132.revip5.asianet.co.th) joined #forth
20:54:12 --- join: proteusguy (~proteusgu@ppp-110-168-229-132.revip5.asianet.co.th) joined #forth
20:54:13 --- mode: ChanServ set +v proteusguy
21:06:41 --- quit: Kumool_ (Read error: Connection reset by peer)
21:53:33 --- quit: little_bit (Ping timeout: 260 seconds)
23:00:11 --- quit: proteusguy_satri (Ping timeout: 250 seconds)
23:59:59 --- log: ended forth/16.01.18