00:00:00 --- log: started forth/17.03.20
00:02:08 --- quit: luser1 (Ping timeout: 246 seconds)
00:10:56 --- join: gravicappa (~gravicapp@ppp83-237-169-225.pppoe.mtu-net.ru) joined #forth
00:17:10 --- quit: dograt_ (Ping timeout: 240 seconds)
00:25:58 --- join: dograt (~dograt@unaffiliated/dograt) joined #forth
00:38:43 <John[Lisbeth]> Yeah like my love for forth just is not going away
00:38:59 <John[Lisbeth]> Usually when I jump languages I completely abandone the previous one
00:39:13 <John[Lisbeth]> But when I jumped from forth to lisp I actually kept most of my respect for lisp and still feel it is a great language
00:41:21 <John[Lisbeth]> To me though I like forth better because when I see two things that are very similar I often go for the simpler one
00:41:24 <John[Lisbeth]> and forth is alot simpler
00:42:32 <John[Lisbeth]> My philosophy is that static typing is good because it makes your language faster but as soon as you leave your language you've got dynamic typing and you have to implement dynamic typing in a statically typed system
00:42:45 <John[Lisbeth]> so in a sense all typing is really dynamic even though static is faster
00:42:50 <John[Lisbeth]> In the same way
00:43:07 <John[Lisbeth]> Lisp is pretty much purely functional with no side effects
00:43:25 <John[Lisbeth]> but under the hood lisp still deals with a mutable stack on a mutable computer
00:43:44 <John[Lisbeth]> and above the hood people often create stateful things or create seemingly stateful systems immutably
00:44:30 <John[Lisbeth]> I have noticed that you can do immutable programming in just about any language that has constants. There is nothing really stopping you from doing it in imperative languages. People just encourage you to have state
00:45:03 <John[Lisbeth]> Immutable programming is not as obvious a think in imperative languages, and so many imperative programmers can not write programs by composing functions
00:45:07 <John[Lisbeth]> or rather do not know how
01:27:28 --- quit: proteusguy (Remote host closed the connection)
01:38:41 <John[Lisbeth]> I seem to be perfectly content with forth
01:38:49 <John[Lisbeth]> it seems to just do what I want unlike any other language
01:42:18 <z0d> John[Lisbeth]: Lisp is not purely functional
01:44:07 <John[Lisbeth]> Lol I knew somebody would get all uppity about that
01:44:12 <John[Lisbeth]> no it's not purely funcitonal
01:44:17 <John[Lisbeth]> you are correct on that
01:44:38 <John[Lisbeth]> But for all intents and purposes it is as close to purely functional as most people would need it to be
01:44:41 <John[Lisbeth]> plus scheme is even closer
03:05:40 --- join: proteusguy (~proteus-g@2405:9800:b408:bc31:4a51:b7ff:fe38:d966) joined #forth
03:05:41 --- mode: ChanServ set +v proteusguy
03:24:47 --- join: dual (~bonafide@subzeroup.core.rzwireless.net) joined #forth
03:24:56 --- join: dual_ (~bonafide@subzeroup.core.rzwireless.net) joined #forth
03:25:01 --- quit: dual_ (Read error: Connection reset by peer)
03:41:35 --- quit: dual (Ping timeout: 246 seconds)
03:43:30 --- join: dual (~bonafide@subzeroup.core.rzwireless.net) joined #forth
04:11:50 <John[Lisbeth]> I should learn macros
04:12:01 <John[Lisbeth]> But I wanna kind of see how far I can take the bare bones forth syntax
04:15:17 --- join: impomatic_ (~impomatic@host81-136-82-7.range81-136.btcentralplus.com) joined #forth
04:16:50 --- quit: impomatic (Ping timeout: 260 seconds)
04:16:57 --- nick: impomatic_ -> impomatic
04:20:45 --- join: impomatic_ (~impomatic@host109-149-158-236.range109-149.btcentralplus.com) joined #forth
04:21:30 --- quit: impomatic (Ping timeout: 260 seconds)
04:21:39 --- nick: impomatic_ -> impomatic
04:37:35 --- quit: gravicappa (Ping timeout: 256 seconds)
04:41:32 <zy]x[yz> "learn macros?"  they're exactly the same thing.  you kust write "immediate" after a definition
04:42:30 <zy]x[yz> seriously, lay off the weed, man.  you are picking this up at an absurdly slow rate
04:44:25 <zy]x[yz> particularly for someone who won't shut up about how much he loves forth
04:51:51 --- join: gravicappa (~gravicapp@ppp83-237-169-225.pppoe.mtu-net.ru) joined #forth
05:12:21 --- join: logiqub (~victor@AMontsouris-559-1-36-4.w90-24.abo.wanadoo.fr) joined #forth
05:21:33 <z0d> John[Lisbeth]: my opinion is purely function isn't the way to go in most cases. because it can make code very obscure if you do a lot of I/O or side-effects
05:21:43 <z0d> which is inevitable in some cases
05:26:10 <logiqub> Hi. I am looking for people with experience building a bare metal Forth on embedded ?
05:27:25 <logiqub> I am working on a project where I hope to remove the OS, but I am not sure where to start.
05:28:32 <z0d> logiqub: there are a few here, but please be patient
05:28:55 <z0d> you'll probably need to write a bootloader. what platform are you writing this for?
05:29:30 <logiqub> z0d: My website is http://logiqub.com
05:29:55 <logiqub> The short story is I am making an open app store to teach Forth and game design
05:30:23 <logiqub> And I plan to find a good tablet or small PC (Raspberry) to develop a small console
05:31:00 <logiqub> I hope to remove Linux on the device and go with a custom Forth vm
05:31:08 <logiqub> that I have already written
05:33:17 <nerfur> aren't ARM is pretty "vendor-locked" in terms of bootload?
05:33:17 <z0d> there are quite a few bare metal Forthes, https://github.com/jdinunzio/forthos is one
05:35:37 <logiqub> Thanks, I am checking the link
05:41:30 --- join: GeDaMo (~GeDaMo@212.225.82.133) joined #forth
05:54:39 <John[Lisbeth]> logiqub: well I can give you some advice though these gents claim that I do not know forth real well
05:54:55 <John[Lisbeth]> One thing you can do to help you is to pair down to a smaller os to begin with
05:55:00 <John[Lisbeth]> this will make the transition into no os easier
05:55:27 <John[Lisbeth]> going from a very large complex os like ubuntu and removing parts could be really hard whereas removing parts of busybox would be a less complex thing
05:56:18 <John[Lisbeth]> I think that any c program can be spun up into a forth if you first write a forth in c and then start rewriting functions in that forth
05:56:41 <John[Lisbeth]> though there will be some speed decreases most of the time
05:56:50 <John[Lisbeth]> you won't get quite as optimized code from the getgo
06:00:22 <John[Lisbeth]> There's probably forths written for rpi too
06:01:19 <z0d> I don't think it's reasonable to expect someone write a complex OS like Ubuntu Linux
06:01:31 <John[Lisbeth]> sure but I mean he asked to do it so what am I gonna do
06:01:36 <z0d> for starters, you just need to handle VGA and keyboard
06:01:41 <John[Lisbeth]> I think he wants more like an rtos type deal
06:01:45 <z0d> build from the bottom up
06:01:46 <John[Lisbeth]> though I could be wrong
06:02:50 <John[Lisbeth]> rebooting be back later
06:03:09 --- quit: John[Lisbeth] (Quit: Lost terminal)
06:05:13 <logiqub> z0d: You're right, I am building everything bottom up. I stopped using any C compiler
06:05:44 <logiqub> except when I am forced to interface glibc (ex: linux doesn't have kbhit function)
06:23:01 --- join: John[Lisbeth] (~user@13.91.60.159) joined #forth
06:23:11 <John[Lisbeth]> now in centos trying it out for the first time
06:23:31 <John[Lisbeth]> it is pretty snappy compared to ubuntu server surprisingly. Especially because this one is on hdd
06:33:15 --- quit: John[Lisbeth] (Remote host closed the connection)
06:36:04 --- join: John[Lisbeth] (~user@13.91.60.159) joined #forth
06:49:07 --- quit: smokeink (Ping timeout: 240 seconds)
06:49:58 <John[Lisbeth]> meh
06:50:02 <logiqub> John[Lisbeth]: I am basically doing a gaming console with online app store. I don't really need an OS to run a Forth game.
06:50:25 <John[Lisbeth]> sure if it's not run in forth you sort of don't, but it will help you to
06:50:47 <John[Lisbeth]> forth will have alot of room on an rpi even with linux
06:51:04 <John[Lisbeth]> and linux has some nice tools that will make that online app store easier to make
06:51:26 <logiqub> There is overhead with an operating system. Not necessary.
06:51:58 <John[Lisbeth]> sure that's true
06:52:03 <logiqub> Although, I start with Linux, I plan to do a bare metal version.
06:52:13 <John[Lisbeth]> You may at least want to keep the linux kernel plus a shell
06:52:47 <logiqub> Forth shell is the same or better than unix shells
06:53:06 <John[Lisbeth]> so unix shells are more integrated into unix but forth can be a shell if you program it to be
06:53:15 <John[Lisbeth]> although you can fit a shell into a very tiny space
06:53:36 <John[Lisbeth]> they make micro tools like the one that come with busybox that can help to reduce the size of your project
06:53:41 <logiqub> My VM is less than 20 KB.
06:54:20 <John[Lisbeth]> Have you ever worked on a machine without a kernel?
06:54:47 <logiqub> Not really. I am new to Forth but I can build my own VM from scratch.
06:55:10 <John[Lisbeth]> well to make a long story short all the kernel does is add support for your hardware, really, plus do a few things to make things easier
06:55:41 <John[Lisbeth]> the busybox distro only adds like 1 mb of files onto the linux kernel
06:55:54 <John[Lisbeth]> very minimal. IT will leave you with LOTS of room on the smallest of RPI
06:56:07 <logiqub> That's the point if I only need video + keyboard and maybe some usb device, why have a kernel ?
06:56:19 <logiqub> I rather stay in full Forth, no ?
06:56:21 <John[Lisbeth]> So if you remove the kernel your emove the keyboard support and etc
06:56:31 <John[Lisbeth]> you can rewrite hte keyboard support if you want
06:56:46 <John[Lisbeth]> the only thing the kernal does is makes sure your hardware can work
06:56:59 <John[Lisbeth]> its a very small file compared to the average storage on a pi
06:57:17 <John[Lisbeth]> but feel free to go find a forth for the rpi. THere are probably a few good ones
06:57:20 <John[Lisbeth]> see if you like it
06:57:36 <logiqub> Okay.
06:57:47 <John[Lisbeth]> Also if you are gonna play around with your hardware maybe keep a fire extinguisher handy
06:57:59 <logiqub> ???
06:58:04 <John[Lisbeth]> just in case
06:58:28 <logiqub> It's not needed is it ? I am positive it doesn't heat enough to require a fan
06:58:52 <John[Lisbeth]> It probably wont be needed but the kernel does things like tries to keep you from blowing up your hardware
06:59:31 <John[Lisbeth]> They also make smaller versions of the linux kernel. There may be a smaller version available for the pi
06:59:39 <logiqub> The CPU throttles back when overheating...
06:59:54 <John[Lisbeth]> I mean yes but is that built into the hardware? I am not sure that it is.
06:59:58 <John[Lisbeth]> I had thought the kernel does that
07:00:22 <logiqub> Hmm, you're right I don't know if it's in the BIOS or kernel
07:00:38 <John[Lisbeth]> so the bios on the rpi is controlled by the rpi makers I don't think you can change it
07:00:43 <John[Lisbeth]> the bios just turns on the kernel
07:01:17 <John[Lisbeth]> then the kernel turns on and hooks up all your hardware to one program
07:01:33 <John[Lisbeth]> and also puts you in a safe sandbox where it is harder to mess things up
07:01:43 <John[Lisbeth]> then lets you run whatever programs you want inside that sandbox
07:02:17 <logiqub> Well, I see. I'll have the option then.
07:02:59 <John[Lisbeth]> Busybox is probably the smallest useable distro you can get for the rpi unless you want to install gentoo
07:03:15 <John[Lisbeth]> otherwise you want to just find a forth that is made for the rpi
07:03:50 --- quit: dual (Ping timeout: 240 seconds)
07:04:02 --- join: smokeink (~smoke@175.22.22.13) joined #forth
07:06:25 <John[Lisbeth]> basically the standard microsd card at the store right now is 8 gigabytes
07:06:47 <John[Lisbeth]> now  busybox will take a teensy tiny fraction of that
07:06:53 <logiqub> Okay, but I am impressed. Busybox is 2 MB, and I certainly don't need that.
07:07:10 <John[Lisbeth]> I mean sure if that's what you want. Forth is here to do what you want really
07:07:15 <John[Lisbeth]> But I mean what is 2 mb out of 8 gigs
07:07:21 <John[Lisbeth]> do you think you will use all 8 gigs?
07:07:41 <John[Lisbeth]> in a few years they will sell the 16 gig ones at the same price and so on and so forth
07:07:55 <John[Lisbeth]> one day we'll be atlking about 2 mb out of 128 gigs
07:08:05 <logiqub> I understand, but if I told you I built the 20 KB vm on Windows 64 bits... you'll see what I am doing.
07:08:17 <logiqub> I remove the C library too.
07:08:44 <John[Lisbeth]> the linux kernel it's self id seigned to run c. If its' written in c for windows then it should run on top of the linux kernel with a little modification
07:08:51 <John[Lisbeth]> but I mean
07:09:32 <John[Lisbeth]> for your cheapest rpi at an 8 gig sd
07:09:48 <John[Lisbeth]> busybox is 0.00025% of the sd card
07:10:26 <logiqub> I understand that. But I am building a sort of JonesForth tutorial that goes further
07:10:40 <logiqub> and build games all in Forth so that people see how it's done
07:10:49 <logiqub> The less junk the better
07:11:12 <John[Lisbeth]> there is very little junk in the linux kernel and installing gento will remove like 98% of it
07:11:50 <logiqub> Anything larger than 100 KB is bloat already...
07:12:13 <John[Lisbeth]> well I mean 50 kb is the kernel, I beleive
07:12:39 <John[Lisbeth]> most of that is probably just drivers
07:12:44 <John[Lisbeth]> linux usually holds drivers for lots of devices
07:12:50 <John[Lisbeth]> with gentoo you can take those out
07:13:00 <John[Lisbeth]> people have already done most of the work for that on the rpi
07:13:02 <zy]x[yz> logiqub, you're probably best off /ignoring him
07:13:23 <John[Lisbeth]> zy]x[yz: doesn't like me
07:13:41 <John[Lisbeth]> I think they are just bitter that I enjoy forth more than they do
07:14:28 <logiqub> Well, forth is about freedom. You enjoy it this way, it's fine.
07:15:02 <John[Lisbeth]> you probably won't be completely free on the rpi. The rpi requires a proprietary binary to run. So if you want to be free as in freedom you must reverse engineer that binary
07:15:06 <John[Lisbeth]> and then you will be free
07:15:23 <zy]x[yz> it has nothing to do with that and everything to do with that he generates a lot of noise and doesn't actually know anything
07:16:01 <John[Lisbeth]> oh well who cares in a dead channel for a dead language anyway. I don't see you putting in much effort to answer his questions
07:16:28 <John[Lisbeth]> I could be doing other things with my time such as smoking the sweet ganja or watching star trek
07:16:42 <logiqub> zy]x[yz: it is true that he doesn't understand everything, but he will learn in time =)
07:16:53 <logiqub> I'll stop making noise too, forgive me.
07:17:13 <John[Lisbeth]> It's okay if you and I weren't talking the channel would be dead
07:17:26 <zy]x[yz> he asked for someone with experience building a bare metal forth.  do you have experience building a bare metal forth?
07:17:42 <John[Lisbeth]> If you want to step forth and provide your experience then do so.
07:18:11 <zy]x[yz> logiqub, oh, I don't have any problem with idle chat in a channel.  I just have a problem with people who don't know jack spewing shit as if they think they know what they're talking about
07:18:53 <John[Lisbeth]> I dunno I think I have a pretty intimate understanding of the inner workings of forth it's self. Though kernel writing I could not help you with.
07:19:15 <John[Lisbeth]> My level of abstraction for my research is shell level and above
07:19:35 <John[Lisbeth]> Plus I am 22 I am not exactly a vet here
07:19:45 <John[Lisbeth]> doesn't mean I shouldn't speak
07:19:57 <logiqub> It's okay, guys you gave me lots of info. I have a bit of work to do now ^^
07:20:10 <John[Lisbeth]> no problemo yo
07:20:27 <logiqub> Hopefully we will have a fun open store in a few months
07:20:55 <John[Lisbeth]> Look forwards to trying it on my pi
07:22:03 <nerfur> logiqub: you also can look at this http://www.forthos.org/
07:22:28 <nerfur> it is x86, but I think you can get some more info on building barebone from it 
07:23:00 <logiqub> nerfur, thx (bookmarked)
07:43:13 --- quit: logiqub (Quit: leaving)
07:44:14 <John[Lisbeth]> yes this immediate word is pretty interesting
07:44:18 <John[Lisbeth]> extra side effects super sneaky
07:44:49 <John[Lisbeth]> I guess that learns me half of how macros work
07:45:15 <John[Lisbeth]> yet other languages are not always designed to worry about space characters
07:53:11 <John[Lisbeth]> I mean
07:53:13 <John[Lisbeth]> on the one hand
07:53:25 <John[Lisbeth]> when I first started forth I was very afraid of the whole all data being ints thing
07:53:37 <John[Lisbeth]> but after I learned word pointers this completely escaped away from me
07:53:44 <John[Lisbeth]> and I had no more fear
07:54:04 <John[Lisbeth]> I don't really desire to change anything with the forth syntaxx
07:54:19 <John[Lisbeth]> forth syntax is really exactly how I want it
07:55:41 <zy]x[yz> that's great, now go do something productive with it
07:59:29 <John[Lisbeth]> I do not have to do productive things if I do not want to do productive things
07:59:49 <John[Lisbeth]> I like to talk about doing productive things and do them a little bit and then watch star trek
08:05:41 <John[Lisbeth]> I think if I had just started being productive with the first language I learned I would more or less still be programming with c++ right now
08:05:48 <John[Lisbeth]> but I really hate c++ so thats why I choose not to do that
08:05:56 <John[Lisbeth]> and so i choose bash because it was more of what I wanted than c++
08:06:05 <John[Lisbeth]> But I hate bash so I choose not to do that
08:06:22 <John[Lisbeth]> and so I choose haskell because it was more of hwat I wanted than bash
08:06:38 <John[Lisbeth]> but I don't like haskell very much so I chose not to do taht
08:06:49 <John[Lisbeth]> and then lisp did almost everything I wanted and forth does everything I want
08:08:55 <zy]x[yz> do you understand that nobody here is interested in this?
08:11:40 <bavier`> you can choose not to listen if you want
08:12:09 <zy]x[yz> or he can choose to go use a blog for his blogging instead of irc
08:14:54 <bavier`> indeed, that might be useful
08:20:08 --- join: Bunny351 (~Bunny351@p4FF18CA0.dip0.t-ipconnect.de) joined #forth
08:23:14 --- join: dual (~bonafide@cpe-74-75-153-119.maine.res.rr.com) joined #forth
08:24:32 <John[Lisbeth]> I dunno I just like talking to people with similar interestests and learning from them
08:27:35 <John[Lisbeth]> Being alone all the time is not very great. It's good to be with others to talk to them. It's healthy for you
08:28:41 <John[Lisbeth]> For you guys is a very old thing but for me forth is still a shiny new thing
08:28:55 <zy]x[yz> you were here when I joined this channel
08:29:26 <John[Lisbeth]> Interesting
08:29:50 <John[Lisbeth]> I guess you just learned it faster than me then, at least according to your claims
08:30:24 <John[Lisbeth]> I actually stopped learning ans forth after chapter 4 of starting forth because I figured out how to make my own forth after that and that kept me occupied for a while
08:39:34 <John[Lisbeth]> The thing is I was kind of looking for something like forth for four years and so I have spent quite alot of time thinking about the main concepts behind forth though not being able to find it for all that time
08:40:24 <John[Lisbeth]> For some people it may seem quite a strange thing or an ungly thing but for me it is like it is a language that was built perfectly just for me
08:40:48 <John[Lisbeth]> and so it feels really great to think about it. More satiating than thoughts of riches or women or any other puzzle on earth
08:44:11 <John[Lisbeth]> It is just beautiful how simple and powerful it is
08:44:41 <John[Lisbeth]> never in my wildest dreams had I thought I would discover such a gem in programming
08:49:14 --- join: neceve (~ncv@86.125.247.109) joined #forth
08:49:14 --- quit: neceve (Changing host)
08:49:14 --- join: neceve (~ncv@unaffiliated/neceve) joined #forth
08:49:50 <bavier`> Does anyone know of any implementations of other high-level language compilers in Forth?
08:50:14 <bavier`> e.g. a C99 compiler written in Forth
08:50:14 <John[Lisbeth]> any language in particular?
08:51:15 <John[Lisbeth]> I dunno about c99 specifically
08:51:23 <John[Lisbeth]> google doesn't give me much
08:56:20 <Bunny351> bavier`: there have been prolog implementations on top of forth, IIRC.
08:56:45 <bavier`> Bunny351: oh, cool
08:57:06 <John[Lisbeth]> yeah I mean you most definitely could make a c99 compiler for forth
08:57:25 <Bunny351> http://dl.acm.org/citation.cfm?id=19946
08:57:30 <Bunny351> paywalled, unfortunately
08:58:52 <Bunny351> find it here: http://soton.mpeforth.com/flag/jfar/vol4.html
09:02:11 <bavier`> Bunny351: excellent link, thanks
09:02:18 <Bunny351> np
09:22:33 --- quit: dys (Read error: Connection reset by peer)
09:34:22 --- join: true-grue (~true-grue@176.14.222.10) joined #forth
09:50:17 <John[Lisbeth]> so basically rite
09:50:22 <John[Lisbeth]> if I take a bunch of words
09:50:28 <John[Lisbeth]> and do ' to them to get their pointers
09:50:31 <John[Lisbeth]> and put that shit in an array
09:50:42 <John[Lisbeth]> the pointer and length of that array is a lambda
09:52:00 <GeDaMo> A lambda is basically a function without a name
09:52:36 <John[Lisbeth]> yes
09:52:53 <GeDaMo> Your array is more like a jump table
09:53:06 <John[Lisbeth]> all I need is a word that takes a pointer and an arraylength and executes each int in that array
09:53:32 <GeDaMo> Oh, you're constructing a threaded code sequence?
09:53:53 <John[Lisbeth]> no I am just sort of thinking about things
09:53:58 --- join: luser1 (~luser1@h69-21-248-248.crlbnm.broadband.dynamic.tds.net) joined #forth
09:54:54 <John[Lisbeth]> the problem with my design is nesting a lamdba within a lambda
09:55:22 <John[Lisbeth]> because each int in my array represents a word and a lambda by my own definition is two ints
09:57:45 <John[Lisbeth]> I could add a true or a false inbetween each value to let it know if it's going to be a word or a lambda but that adds a decent amount of bulk
09:57:55 <GeDaMo> In traditional threaded code Forth, word e.g. : square  dup * ; would be <header "square"><address of dup><address of *><address of next>
09:58:07 <GeDaMo> Which sounds a lot like what your describing
09:58:11 <John[Lisbeth]> sure though I am not working on threading
09:58:14 <John[Lisbeth]> just lamdbas
09:58:30 <GeDaMo> I don't see what the difference is
09:58:46 <John[Lisbeth]> lambdas are anonymous function. Threads are used to multitask
09:59:00 <John[Lisbeth]> they are related though not the same
09:59:34 <GeDaMo> In Forth terminology, thread has a different meaning
09:59:39 <John[Lisbeth]> oh
09:59:47 <GeDaMo> https://en.wikipedia.org/wiki/Threaded_code
10:02:02 <John[Lisbeth]> yes I suppose that's threading though I think I was not creating it for the reason fo condensing code
10:02:21 <John[Lisbeth]> having the code be condensed is just a happy accident of implementing lambdas that way
10:02:41 <John[Lisbeth]> of course the problem is I can not nest lambdas with my current design
10:02:50 <John[Lisbeth]> all of my designs add lots of bulk
10:06:48 <John[Lisbeth]> I suppose when I "thread" a word in forth by getting it's pointer, that is sort of a different stack type than the pointer to an array and the length of the array
10:07:04 <John[Lisbeth]> the array it's self is not designed to be an array of arrays
10:07:46 <GeDaMo> Remember that Forth doesn't really have types, everything is a call, it's up to you to apply the correct operations
10:07:53 <GeDaMo> s/call/cell/
10:18:50 --- quit: smokeink (Remote host closed the connection)
10:19:27 --- quit: neceve (Ping timeout: 240 seconds)
10:20:38 <John[Lisbeth]> yeah I mean sure there is not a type system
10:20:50 <John[Lisbeth]> But you can kind of infer sort of types
10:21:06 <John[Lisbeth]> like you can kind of keep in mind when you are writing it that one kind of pointer is very different in function than a different kind of pointer
10:21:50 <John[Lisbeth]> in factor they have a stack checker but in forth you can kind of eyeball it if you want
10:24:30 <John[Lisbeth]> the sort of key is once your pointer or whatever is on the stack you have no real way of knowing what it is, so you have to know it's gonna be there when you write the code
10:24:49 <John[Lisbeth]> and a stack checker/type system is literally just adding a marker to that data so you can identify what it is at runtime
10:27:09 <John[Lisbeth]> I don't necessarily want a checker
10:27:22 <John[Lisbeth]> I have never really put much faith into type systems
10:27:32 <John[Lisbeth]> but it would be nice to be able to get back a string that gives you an idea of what it is
10:30:29 --- join: Zarutian (~zarutian@168-110-22-46.fiber.hringdu.is) joined #forth
10:34:19 <John[Lisbeth]> I think that having the stack goof up is not so different than using bad typing in haskell and having a compiler error
10:34:40 <John[Lisbeth]> and I also think forth should make it very easy to test to see if functions behave if they should
10:34:55 <John[Lisbeth]> but you have to actually look and test
10:38:43 <John[Lisbeth]> not only must you test individual words but you must test how they go together as well
10:41:11 <John[Lisbeth]> what can become really difficult is when you have inadvertantly made a thick stack out of your words
10:42:02 <John[Lisbeth]> I think it really should be a goal to add as little to the stack as logically possible and remove as much from the stack as logically possible
10:47:12 <John[Lisbeth]> the stack can not be thought of as storage but merely a way to redirect the inputs and outputs of words
10:47:33 <John[Lisbeth]> There may be all kinds of things which go on in a function which have nothing to do with it's arguments and it's return value
10:51:25 --- join: karswell (~user@216.49.93.209.dyn.plus.net) joined #forth
10:59:34 --- quit: LeCamarade (Ping timeout: 260 seconds)
11:04:50 --- join: LeCamarade (~revence@139.59.111.106) joined #forth
11:12:52 <John[Lisbeth]> It's kind of like haskell
11:13:11 <John[Lisbeth]> I can make an array of pointers, or an array of arrays, but if I want to mix the types in an array, I've got to make some kind of flag somewhere to do that
11:18:14 --- quit: gravicappa (Ping timeout: 260 seconds)
11:27:59 --- join: dys (~dys@ip-109-40-3-231.web.vodafone.de) joined #forth
11:40:31 --- join: ACE_Recliner (~ACE_Recli@c-50-165-178-74.hsd1.in.comcast.net) joined #forth
12:22:37 --- join: gravicappa (~gravicapp@ppp83-237-173-243.pppoe.mtu-net.ru) joined #forth
13:03:51 <John[Lisbeth]> I am not sure how to write this word but it's sort of like ( arraysize -- )\ : make_array dup variable foo cells allot foo ! ;
13:04:21 <John[Lisbeth]> But I don't know how to capture the word name that goes where foo goes nor how to call it
13:05:23 <GeDaMo> What does make_array do?
13:05:56 <John[Lisbeth]> It makes an array by alloting to a variable but it stores the arraylength that was used at index 0
13:06:08 <John[Lisbeth]> That way I don't have to worry about the length of the array later
13:06:43 <GeDaMo> Oh, sorry, you're defining make_array, I thought you were calling it
13:07:06 <John[Lisbeth]> no I am making my own version of make array where at index 0 I store the size of the array
13:08:00 <GeDaMo> : make_array  ( arraysize "name" -- )  create dup , cells allot ;
13:08:14 <GeDaMo> 100 make_array test
13:09:49 <John[Lisbeth]> works like a charm
13:10:04 <John[Lisbeth]> I've got to figure out this create word and this , word
13:10:18 <GeDaMo> "nth" is a common word to define to access the nth cell in an array
13:10:38 <John[Lisbeth]> thanks
13:10:57 <GeDaMo> "create test" creates a new word in the dictionary called test with the default behaviour of returning the address of the cell after the header
13:11:23 <GeDaMo> "," stores the value on top of the stack at the net available cell in the dictionary
13:11:26 <GeDaMo> Next
13:14:08 <GeDaMo> John[Lisbeth]: sorry, I said "nth", the common word is "th" :/ http://forth.sourceforge.net/mirror/comus/index.html#th
13:15:25 <John[Lisbeth]> yeah I was like this aint working
13:15:33 <GeDaMo> Although yours would have to add 1 because you're storing the length at element 0
13:16:18 <John[Lisbeth]> Yeah I'll burn that bridge when I get to it
13:22:22 --- join: carc_ (~carc@2001:41d0:52:cff::f85) joined #forth
13:27:57 --- quit: gravicappa (Ping timeout: 240 seconds)
13:29:33 --- quit: carc (*.net *.split)
13:29:33 --- nick: carc_ -> carc
14:23:44 --- join: real-grue (~true-grue@176.14.222.10) joined #forth
14:26:49 --- quit: true-grue (Ping timeout: 240 seconds)
14:27:15 --- join: logiqub (~victor@AMontsouris-559-1-36-4.w90-24.abo.wanadoo.fr) joined #forth
14:32:05 --- quit: GeDaMo (Remote host closed the connection)
15:05:04 --- quit: real-grue (Read error: Connection reset by peer)
15:20:32 --- quit: ACE_Recliner (Ping timeout: 246 seconds)
15:22:59 --- join: ACE_Recliner (~ACE_Recli@c-50-165-178-74.hsd1.in.comcast.net) joined #forth
15:23:29 --- quit: LeCamarade (Ping timeout: 268 seconds)
15:29:40 --- quit: Zarutian (Quit: Zarutian)
15:41:09 --- join: LeCamarade (~revence@139.59.111.106) joined #forth
15:43:53 <logiqub> John[Lisbeth]: I just bought the rpi. I am doing an install, probably going with debian for now.
16:15:14 --- quit: sifbot (Remote host closed the connection)
16:43:36 --- part: luser1 left #forth
16:43:38 --- join: luser1 (~luser1@h69-21-248-248.crlbnm.broadband.dynamic.tds.net) joined #forth
17:53:16 --- quit: logiqub (Quit: leaving)
18:09:09 --- quit: Bunny351 (Ping timeout: 260 seconds)
18:09:39 --- join: Bunny351 (~Bunny351@p4FF18D0D.dip0.t-ipconnect.de) joined #forth
18:23:44 --- quit: X-Scale (Quit:  HydraIRC -> http://www.hydrairc.com <- IRC with a difference)
18:53:29 --- quit: ACE_Recliner (Ping timeout: 260 seconds)
19:13:04 <reepca> zy]x[yz: Ah, that makes more sense. But another weird thing: if you execute that code 3 times in a row, and then run 1 throw or something, the error reporting will look really messed up.
19:18:31 --- join: X-Scale (~ARM@214.20.108.93.rev.vodafone.pt) joined #forth
19:49:31 --- join: neceve (~ncv@86.125.247.109) joined #forth
19:49:31 --- quit: neceve (Changing host)
19:49:31 --- join: neceve (~ncv@unaffiliated/neceve) joined #forth
19:59:42 --- join: ACE_Recliner (~ACE_Recli@c-50-165-178-74.hsd1.in.comcast.net) joined #forth
20:05:19 --- quit: neceve (Remote host closed the connection)
20:06:56 <zy]x[yz> I can't speak to that one, as I actually haven't used a forth written by someone else
20:09:42 --- join: neceve (~ncv@86.125.247.109) joined #forth
20:09:43 --- quit: neceve (Changing host)
20:09:43 --- join: neceve (~ncv@unaffiliated/neceve) joined #forth
20:28:32 --- join: smokeink (~smoke@175.22.22.12) joined #forth
21:15:13 --- quit: neceve (Quit: Konversation terminated!)
21:41:20 --- quit: X-Scale (Ping timeout: 246 seconds)
21:44:18 --- join: X-Scale (~ARM@214.20.108.93.rev.vodafone.pt) joined #forth
22:28:50 --- quit: smokeink (Ping timeout: 260 seconds)
22:35:56 --- quit: proteusguy (Ping timeout: 246 seconds)
22:44:57 --- quit: ACE_Recliner (Remote host closed the connection)
22:56:09 --- quit: fiddlerwoaroof (Ping timeout: 260 seconds)
22:59:16 --- join: fiddlerwoaroof (~fiddlerwo@unaffiliated/fiddlerwoaroof) joined #forth
23:52:16 --- join: smokeink (~smoke@175.22.22.1) joined #forth
23:59:36 --- quit: luser1 (Ping timeout: 240 seconds)
23:59:59 --- log: ended forth/17.03.20