2023-01-17 00:36:36 <vms14       > KipIngram: do you use some kind of array data in your forth?
2023-01-17 00:36:55 <vms14       > I'm going to do some of the https://www.ic.unicamp.br/~meidanis/courses/mc336/problemas-lisp/L-99_Ninety-Nine_Lisp_Problems.html
2023-01-17 00:37:04 <vms14       > it's taken from prolog I guess
2023-01-17 00:37:20 <vms14       > but being lisp problems it's quite focused on lists
2023-01-17 00:38:10 <vms14       > I think is good for me in my case, as I'll end with a lot of words to operate with lists
2023-01-17 00:38:19 <vms14       > and lists are my main data type
2023-01-17 00:38:53 <vms14       > colon words are lists, and most of the words expecting code can also take lists as code
2023-01-17 00:40:02 <vms14       > mainly a word expecting code will call evaluate() which evaluates lists or strings, if it's something else it just pushes it on the stack
2023-01-17 00:40:27 <vms14       > so for example [ 1 2 3 ] [ . ] do.list  can also be [ 1 2 3 ] '. do.list
2023-01-17 00:41:04 <vms14       > the string has to be an atom, not an arbitrary string of code
2023-01-17 00:42:30 <vms14       > https://termbin.com/xw3na
2023-01-17 00:42:41 <vms14       > [[d],[c,d],c]
2023-01-17 01:00:56 <KipIngram   > No, I've no array support in particular at this time.
2023-01-17 01:01:33 <KipIngram   > I eventually intend to have an ability to have arrays, lists, and so on, but I'll view that as an element of an "application" rather than as part of the native Forth system itself.
2023-01-17 01:01:52 <KipIngram   > That'll involve those 64-bit "typed entity" items I've talked about.
2023-01-17 01:01:56 <vms14       > well in a real forth an array can be as simple as using the comma
2023-01-17 01:02:49 <KipIngram   > Sure, loading one via the interpreter.
2023-01-17 01:03:06 <KipIngram   > Rudimentary arrays aren't hard to add to Forth.
2023-01-17 01:03:23 <vms14       > still for me I think is good to do those exercises as I focus a lot on lists
2023-01-17 01:03:36 <KipIngram   > You could easily write support for something like
2023-01-17 01:03:45 <KipIngram   > <array> <index> []
2023-01-17 01:03:56 <KipIngram   > which would leave the address of array[index] on the stack.
2023-01-17 01:04:00 <vms14       > for example now I have to do the palindrome predicate for a list
2023-01-17 01:04:10 <vms14       > which means I'll end with a way to compare lists
2023-01-17 01:04:52 <vms14       > yeah, and do like counted strings, having the len as the first element or whatever
2023-01-17 01:05:22 <vms14       > then is easy to start adding iterators and alike
2023-01-17 01:06:37 <KipIngram   > Possibly, yeah.
2023-01-17 01:07:25 <KipIngram   > I plan (eventually) to store arrays within a ropes data structure.  Iterators will know how to walk those structures.  Smalla arrays, that fit in one ropes page, you'll be able to use usual methods, if you want.
2023-01-17 01:14:18 <vms14       > : list.palindrome dup reverse list.equal ;
2023-01-17 01:14:19 <vms14       > [ 1 2 3 2 1 ] list.palindrome  => 1
2023-01-17 01:15:51 <vms14       > but list.equal sucks so much
2023-01-17 01:16:04 <vms14       > can only compare lists with numbers or strings
2023-01-17 01:16:25 <vms14       > I should change it
2023-01-17 03:42:27 <veltas      > Ugh what is it with libera.chat / old-freenode staff and their announcements, loudest mods on any IRC network by far
2023-01-17 03:43:08 <decay       > turn wallops off.
2023-01-17 03:43:14 <veltas      > I don't actually care if nickserv will stop working temporarily, I'll know if it happens. Send maybe a single message to people subscribed to wallops, don't send like 3
2023-01-17 03:43:55 <veltas      > It's worth having them on I just think it's really bizarre how they're the only network with this kind of wallop culture
2023-01-17 05:22:24 <MrMobius    > KipIngram: ya stack of pointers to any type of data is a great idea. Have you played with any of the 48/49 calculators? Lots of awesome ideas there
2023-01-17 07:22:50 <KipIngram   > My wife uses a 48GX.  She came along ten years after me, so it's just what was current when she was in school.
2023-01-17 07:23:32 <KipIngram   > I've only played with it a little.
2023-01-17 07:23:49 <KipIngram   > Kind of interesting "directory structure" like setup.
2023-01-17 09:18:53 <KipIngram   > Ah, DM-41x is now in the Houston area.
2023-01-17 09:27:49 <KipIngram   > MrMobius: I think it's a slick idea too.  A "real" Forth system is designed to be a very low level thing, for poking at hardware and things like that, so in that case the standard integer stack is the way to go.  But it seems pretty clear to me that for a more "application level" environment, where you're wanting to do serious analytical computations, a stack that can hold more abstract items is preferable.
2023-01-17 09:28:11 <KipIngram   > A Forth aimed at providing a calculator OS would be such a case.
2023-01-17 09:28:58 <KipIngram   > Which certainly doesn't mean that it couldn't be running on top of an integer stack base Forth system.  I'm talking only about the "visible" stack at the application level.
2023-01-17 10:07:13 <KipIngram   > Seems to me that approach opens all possibilities up.  Your stack items could be any kind of numeric structure (arrays, etc.), but they could also be general data structures that represented, say, a symbolic expression, so you could do CAS stuff too.
2023-01-17 10:37:03 <KipIngram   > On this WP34S emulator, quite a few shifted key functions open "catalogs."  Then you use up and down arrow keys to scroll around in those, and when you find what you want you can hit the XEQ key, which will either execute it or insert it into a program, depending on what you're doing.
2023-01-17 10:38:17 <KipIngram   > I think on a touch-screen calculator that's not really a good use of key space.  I think I'd instead have a double-tap open a catalog list.  You could roll it up and down with your fingers, and when you tapped an enttry it would open that catalog and you'd do the same there to get your selection.
2023-01-17 10:38:33 <KipIngram   > Then all of the keys themselves could be reserved for things that "run right now."
2023-01-17 10:38:57 <KipIngram   > Specific operations, rather than access to an "operation selection" process.
2023-01-17 10:39:39 <KipIngram   > I haven't counted, but I imagine that the entire list of catalogs would fit on the screen all at once, so you probably wouldn't need to scroll the catalog list.
2023-01-17 10:40:10 <KipIngram   > And you also probably wouldn't need to scroll many of the catalog content lists either - most of them aren't THAT long.  A couple are.
2023-01-17 10:51:34 <KipIngram   > Also, the keys on this emulator are the same size as the keys on the calculator.  There's a good bit of space in between keys that's used for function callouts.
2023-01-17 10:52:05 <KipIngram   > I think on a touch screen calculator the keys should be as large as possible.  You're losing the tactile feedback, so anything you can do to make hitting the keys more reliably is a win, I think.
2023-01-17 10:52:33 <KipIngram   > So I think I'd have very small gaps between them, and any writing you wanted would be ON the keys.
2023-01-17 10:53:27 <KipIngram   > I'd write the primary function on top in larger font, and the shifted functions on line two in a smaller, color-coded font.   Then when you hit a shift key the  keys would re-label so that the function that went with that shift was on the top line and in the larger font.
2023-01-17 10:53:37 <KipIngram   > No writing at all in between keys.
2023-01-17 10:54:21 <KipIngram   > The caveat to all of this is that I did mention double tapping a minute ago, so there has to be some convenient place to do that - if the whole panel was covered with key space it would be hard to double tap.
2023-01-17 10:54:49 <KipIngram   > I also want to be able to use Grafitti to write characters, so a place to start those strokes is required too.
2023-01-17 10:55:33 <KipIngram   > Most calculators have a gap between the "upper keys rows" and the "lower key rows" - that might suffice for both of these purposes.
2023-01-17 10:57:35 <KipIngram   > The display could also be a double-tap point, though it's kind of high up on the screen.  It's not really good for grafitti, though, because some grafitti strokes start low and move high, and some start high and move low.  So  a "middle" starting point for that is preferable.
2023-01-17 11:02:50 <KipIngram   > Maybe a capacitive touch screen can differentiate between tap, double tap, and touch/slide without getting confused.  If so then it might be ok to double tap on top of a key and not activate that key.  Seems a little dicey, though.
2023-01-17 11:03:17 <KipIngram   > Well, distinguishing tap and doublel tap seems dicey.  Touch slide is probably pretty easy to discriminate.
2023-01-17 11:05:12 <KipIngram   > I guess if I really am hot to explore this stuff the obvious way to do it is to just use a phone app.
2023-01-17 11:05:23 <KipIngram   > I mean for trying out user interface ideas.
2023-01-17 11:05:38 <KipIngram   > Awful lot of platform work gets "done for me" that way.
2023-01-17 11:05:52 <KipIngram   > Anybody here done any Android dev?  I have no idea how hard it is to wade into.
2023-01-17 11:16:18 <KipIngram   > Well, this;
2023-01-17 11:16:20 <KipIngram   > https://linuxconfig.org/get-started-with-android-application-development-using-linux-and-android-sdk
2023-01-17 11:16:33 <KipIngram   > has instructions for installing a dev env called Android Studio.
2023-01-17 11:16:42 <KipIngram   > That went smoothly.
2023-01-17 11:58:01 <KipIngram   > Wow.
2023-01-17 11:58:20 <KipIngram   > Those "LCD keys" (keys with little built in screens) go for a bit over $40 a pop.
2023-01-17 11:58:22 <KipIngram   > :-)
2023-01-17 11:58:44 <KipIngram   > That would be a pricey calculator.  I expected them to be prohibitively expensive - I was just curious as to how much so.
2023-01-17 12:11:52 <Stalevar    > Which forth do you suggest for linux and why is it better than dc, which is there by default?
2023-01-17 12:13:21 <KipIngram   > dc isn't really a Forth.  It's a nice calculator, but it's hardly a complete Forth system.
2023-01-17 12:13:45 <KipIngram   > The "easy" answer here is gforth, just because it's pervasively available and very well known.
2023-01-17 12:13:47 <thrig       > gforth or pforth probably aren't terrible
2023-01-17 12:13:56 <KipIngram   > pforth is easy to build from source.
2023-01-17 12:14:18 <Stalevar    > Is there a forth implementation which can superse dc? I was disappointed because dc supports arbitrary number system  and arbitrary precision while forth doesn't
2023-01-17 12:14:23 <KipIngram   > But I can't resist putting in a plug for "one that you write.'
2023-01-17 12:14:43 <KipIngram   > Right -  Forth isn't a  numerical analysis package.
2023-01-17 12:14:55 <KipIngram   > It's really oriented toward embedded system work, control, and so on.
2023-01-17 12:15:11 <KipIngram   > A standard Forth stack holds integers, which you can use as integers or addresses, or whatever you like.
2023-01-17 12:15:25 <KipIngram   > gforth offers some f loating p oint support, but not arbitrary precision.
2023-01-17 12:15:40 <Stalevar    > Are any well known linux softwares written in Forth?
2023-01-17 12:15:47 <KipIngram   > We were just talking here last night about the mpmath package in Python, which is an arbitrary precision package.
2023-01-17 12:16:21 <KipIngram   > If you wrote your own Forth you could set arbitrary precision floating point as a goal, and perhaps could use the same libraries Python uses for mpmath.
2023-01-17 12:16:50 <KipIngram   > One of the great things about Forth is that it's well within one programmer's reach to build one, even from assembly language.
2023-01-17 12:16:53 <Stalevar    > is pforth hard to build from source?
2023-01-17 12:17:01 <KipIngram   > No, it's easy.
2023-01-17 12:17:09 <KipIngram   > I did it, though it was over 20 years ago.
2023-01-17 12:17:26 <KipIngram   > So... it WAS easy.
2023-01-17 12:17:47 <KipIngram   > Easy to modify too - I adjusted it so its interface was over a network socket.
2023-01-17 12:18:29 <KipIngram   > Out of the box it has a non-standard console interface (doesn't put ok at the end of the line like common forth does).  I modified that too.
2023-01-17 12:19:05 <KipIngram   > Hey guys - DM-41X is out for delivery today.  Woo hoo!
2023-01-17 12:22:48 <Stalevar    > Can you show some simple programs or console sessions in pforth and gforth for comparison?
2023-01-17 12:23:18 <thrig       > they would look more or less the same
2023-01-17 12:24:12 <Stalevar    > Then how do I pick one?
2023-01-17 12:24:19 <KipIngram   > Try them out.
2023-01-17 12:24:24 <KipIngram   > Make a choice.
2023-01-17 12:24:29 <KipIngram   > It's a personal taste thing anyway.
2023-01-17 12:24:32 <thrig       > or flip a coin
2023-01-17 12:25:22 <KipIngram   > thrig is right - they're not going to feel that different insofar as actually using them goes.
2023-01-17 12:25:59 <KipIngram   > What OS are you running, Stalevar?
2023-01-17 12:26:53 <thrig       > because this sentence could be a totally valid forth program
2023-01-17 12:27:33 <Stalevar    > Slackware
2023-01-17 12:28:37 <KipIngram   > Oh, ok.  I'm not really familiar with it.  Are gforth and pforth both available in your package manager?
2023-01-17 12:28:53 <Stalevar    > I don't think they are
2023-01-17 12:29:13 <crc         > Stalevar: there's a lot of differences in various forths. Some examples from mine are at https://retroforth.org/examples
2023-01-17 12:29:22 <KipIngram   > Ok.  I can't remember the last time I used a Linux that didn't have gforth available, but I've stuck mostly with the major distros.
2023-01-17 12:29:31 <crc         > (these will be noticable different from gforth or pforth)
2023-01-17 12:30:17 <Stalevar    > do I need unistd?
2023-01-17 12:30:58 <Stalevar    > is there forth for 8080?
2023-01-17 12:32:26 <vms14       > KipIngram: how did you implement nested words?
2023-01-17 12:32:41 <vms14       > are they kind of a dictionary?
2023-01-17 12:32:50 <crc         > Stalevar: http://forth.org/eforth.html has links to a Forth for 8080
2023-01-17 12:33:01 <vms14       > in my case I have 3 kinds of words, builtin, colon and value words
2023-01-17 12:33:21 <vms14       > builtin are just functions, colon are arrays and value anything else
2023-01-17 12:33:33 <vms14       > but I think I want nested word definitions
2023-01-17 12:34:18 <vms14       > sometimes I refuse to factor a word for not having random words defined, if they're "local" to an already existing word there's no reason to not define them
2023-01-17 12:34:23 <Stalevar    > That's CP/M
2023-01-17 12:34:38 <vms14       > in my case I'll make those kind of words a hash xD
2023-01-17 12:35:34 <vms14       > and make : look for the name of a word, for example if it's a : word::nested ... ; word will become a hash if it's not already and nested a word inside that hash
2023-01-17 12:36:10 <vms14       > then I just need to add an else if to the function that executes words
2023-01-17 12:36:52 <vms14       > but I guess I won't allow multiple nesting
2023-01-17 12:37:03 <vms14       > like word::nested::more
2023-01-17 12:40:16 <Stalevar    > KipIngram, ok, pforth is tried out and found unworthy. typing ? and enter entails segmentation fault
2023-01-17 12:40:39 <KipIngram   > :-)
2023-01-17 12:40:41 <KipIngram   > Ooops.
2023-01-17 12:40:48 <Stalevar    > also mkdir build; cd build; cmake ..; make -j3 doesn't work
2023-01-17 12:40:49 <KipIngram   > Well, it's been a LONG time since I tried it.
2023-01-17 12:41:10 <Stalevar    > because it expects to be built from root source directory
2023-01-17 12:41:18 <KipIngram   > This is what i get from ? <enter> on gforth:
2023-01-17 12:41:20 <KipIngram   > Gforth 0.7.3, Copyright (C) 1995-2008 Free Software Foundation, Inc.
2023-01-17 12:41:20 <Stalevar    > instead of some other directory
2023-01-17 12:41:22 <KipIngram   > Gforth comes with ABSOLUTELY NO WARRANTY; for details type `license'
2023-01-17 12:41:24 <KipIngram   > Type `bye' to exit
2023-01-17 12:41:26 <KipIngram   > ?
2023-01-17 12:41:28 <KipIngram   > :1: Stack underflow
2023-01-17 12:41:30 <KipIngram   > >>>?<<<
2023-01-17 12:41:32 <KipIngram   > Backtrace:
2023-01-17 12:41:34 <KipIngram   > $7F7F7E816C70 @
2023-01-17 12:41:45 <KipIngram   > That implies to me that ? is a word, but it expects something on the stack.
2023-01-17 12:42:01 <Stalevar    > Yes, but I thought it would give me some help
2023-01-17 12:42:07 <Stalevar    > because 'help' didn't work
2023-01-17 12:42:18 <Stalevar    > so pforth goes off my hd
2023-01-17 12:42:23 <KipIngram   > Well, "help" doesn't work either.
2023-01-17 12:42:33 <KipIngram   > Built in help isn't really a Forth thing.
2023-01-17 12:43:22 <crc         > ? normally fetches a stored value and prints it
2023-01-17 12:43:29 <KipIngram   > Ah.
2023-01-17 12:43:37 <KipIngram   > Ok, so it expected an address on the stack.
2023-01-17 12:44:02 <KipIngram   > variable alpha  ok
2023-01-17 12:44:04 <KipIngram   > 27 alpha !  ok
2023-01-17 12:44:06 <KipIngram   > alpha ? 27  ok
2023-01-17 12:44:37 <crc         > it's 15.6.1.0600 in the TOOLS wordset in ANS
2023-01-17 12:44:51 <KipIngram   > Stalevar, the usual recommendations here are the books Starting Forth and Thinking Forth.  That and the gforth docs should get you along quite well.
2023-01-17 12:45:12 <KipIngram   > Both of those books can be found as pdf files online.
2023-01-17 12:45:19 <Stalevar    > If I know dc, I should be able to work with forth too, I think
2023-01-17 12:45:37 <Stalevar    > except I need list of basic commands with one line description
2023-01-17 12:45:51 <Stalevar    > I don't want to read an entire book, I just want a cheatsheet
2023-01-17 12:46:09 <KipIngram   > I would say no - dc is not a Forth.
2023-01-17 12:47:13 <vms14       > Stalevar: you can look at the word descriptions on the ANS standard of gforth documentation
2023-01-17 12:47:21 <Stalevar    > gforth gforth-fast gforth-itc gforthmi   vmgen
2023-01-17 12:47:31 <vms14       > https://forth-standard.org/standard/words
2023-01-17 12:47:54 <KipIngram   > dc lets you create macros, but I don't know exactly how it does that.
2023-01-17 12:47:55 <vms14       > still some tutorial or alike to start should be nice
2023-01-17 12:48:44 <vms14       > also with gforth you can do a lot of stuff you couldn't in other forth implementations
2023-01-17 12:49:10 <KipIngram   > Well, Forth is simple to learn.  There aren't many "rules."  But there is at least a minor learning curve, and moreover, once you know all the mechanics it still takes work / practice to become a *good* Forth programmer.
2023-01-17 12:49:23 <KipIngram   > It involves a different mind set from other languages.
2023-01-17 12:49:25 <vms14       > like drawing a pixel :D
2023-01-17 12:49:39 <vms14       > https://rosettacode.org/wiki/Draw_a_pixel#Forth
2023-01-17 12:49:53 <crc         > gforth-fast is faster, but doesn't support accurate backtrace on error, gforth-itc uses indirect threading IIRC
2023-01-17 12:50:10 <KipIngram   > Oh, don't get me started, vms14.  It always annoys me how hard it is to turn on a little light on the screen from any Linux tool.
2023-01-17 12:50:35 <vms14       > KipIngram: well it's actually binding to c ffi
2023-01-17 12:50:38 <KipIngram   > Basically, most language environments give you a console, to which you can write characters.  And doing anything beyond that involves some mountain of libraries.
2023-01-17 12:50:45 <vms14       > but it's a quite nice ffi
2023-01-17 12:50:53 <KipIngram   > I still miss the old days when just poking the right ram bit lit up a dot on the screen.
2023-01-17 12:50:56 <vms14       > c-function sdl-init		SDL_Init		n -- n
2023-01-17 12:51:06 <vms14       > the stack notation defines the types of parameters
2023-01-17 12:51:19 <thrig       > you may not miss the old days of having to reboot the entire system because you poked... poorly
2023-01-17 12:51:21 <vms14       > and that's all needed to make a binding
2023-01-17 12:51:58 <KipIngram   > thrig: if that happened (ok, when...) it was my own fault.
2023-01-17 12:52:48 <vms14       > I'm not sure about nested words
2023-01-17 12:52:59 <vms14       > but I wonder about several times
2023-01-17 12:53:30 <KipIngram   > vms14: You're really not aware of nesting in Forth.
2023-01-17 12:53:38 <vms14       > what nesting?
2023-01-17 12:53:47 <KipIngram   > When you create a new Forth word, it's a list of existing Forth words.
2023-01-17 12:53:53 <Stalevar    > KipIngram, in dc you just save a string in stack and can execute it at will, string is made by [ ]
2023-01-17 12:54:07 <vms14       > yeah, sorry I meant a word that lives inside another word
2023-01-17 12:54:15 <vms14       > a "local" word inside another
2023-01-17 12:54:15 <KipIngram   > Some of those words may be lists of other words, etc. etc., but you can't tell the difference once a word is built whether it's a primitive word or a higher level word.
2023-01-17 12:54:35 <KipIngram   > Well, unless you pick it apart and check.
2023-01-17 12:54:41 <KipIngram   > Operationally you can't tell the difference.
2023-01-17 12:54:46 <vms14       > and I guess you had that feature
2023-01-17 12:55:06 <KipIngram   > No, that's actually not a routine Forth feature.
2023-01-17 12:55:09 <vms14       > your : word allows nested definitions
2023-01-17 12:55:15 <Stalevar    > dc -e '1[p1+d10!<a]dsax'
2023-01-17 12:55:16 <KipIngram   > No, not nested.
2023-01-17 12:55:24 <KipIngram   > It allows multiple entry points to a definition.
2023-01-17 12:55:35 <Stalevar    > This prints numbers from 1 to 10
2023-01-17 12:55:35 <KipIngram   > But I can't do this:
2023-01-17 12:55:44 <KipIngram   > : foo ... : bar ... ; ... ;
2023-01-17 12:55:51 <KipIngram   > Instead, I can do this:
2023-01-17 12:55:56 <KipIngram   > : foo ... : bar  ... ;
2023-01-17 12:56:03 <KipIngram   > That is one definition with two entries.
2023-01-17 12:56:19 <vms14       > but bar would "exist" outside foo?
2023-01-17 12:56:24 <KipIngram   > Yes.
2023-01-17 12:56:37 <KipIngram   > They're both completely similar labels.
2023-01-17 12:56:43 <KipIngram   > They just point to different places in the code.
2023-01-17 12:56:51 <vms14       > then what's the difference between : foo ... ; : bar ... ;  and : foo ... : bar ... ;
2023-01-17 12:56:58 <KipIngram   > For temporary names I'd do this:
2023-01-17 12:57:04 <KipIngram   > .: bar ... ;
2023-01-17 12:57:05 <Stalevar    > How do you print numbers from 1 to 10 in forth?
2023-01-17 12:57:11 <KipIngram   > : foo ... bar ... ;
2023-01-17 12:57:13 <KipIngram   > .wipe
2023-01-17 12:57:13 <vms14       > Stalevar: with LOOP
2023-01-17 12:57:24 <Stalevar    > can you write complete program?
2023-01-17 12:57:26 <vms14       > or BEGIN ... AGAIN
2023-01-17 12:57:27 <Stalevar    > dc -e '1[p1+d10!<a]dsax'
2023-01-17 12:57:29 <Stalevar    > This is for dc
2023-01-17 12:57:31 <KipIngram   > 10 0 do i . loop
2023-01-17 12:57:41 <KipIngram   > But that has to be compiled - it usually won't run from the  interpreter.
2023-01-17 12:57:41 <vms14       > Stalevar: yeah, also with gforth you can use fancy libraries
2023-01-17 12:57:54 <KipIngram   > : print-em 0 do i . loop ;
2023-01-17 12:57:58 <KipIngram   > 10 print-em
2023-01-17 12:58:02 <Stalevar    > 10 0 do i . loop
2023-01-17 12:58:03 <Stalevar    > :1: Interpreting a compile-only word
2023-01-17 12:58:07 <vms14       > KipIngram: so .wipe does remove those temp words
2023-01-17 12:58:20 <KipIngram   > Yeah - any word defined using .: will get unlinked from the list.
2023-01-17 12:58:32 <crc         > try:  :noname 10 0 do i . loop ; execute
2023-01-17 12:58:35 <KipIngram   > .: is just like : except it sets a flag in the header.
2023-01-17 12:58:36 <vms14       > Stalevar: yeah some implementations allow it outside a definition, but not the one you're using
2023-01-17 12:58:46 <KipIngram   > .wipe unlinks all words with that flag set, through the entire dictionary.
2023-01-17 12:59:06 <crc         > in most forth systems, flow control words are often only usable inside a definition
2023-01-17 12:59:08 <vms14       > but meh, it's almost the same as using forget
2023-01-17 12:59:09 <KipIngram   > Sometimes I might define a couple dozen 'helper words' with .:, just to eventually do one word with :
2023-01-17 12:59:15 <KipIngram   > My NUMBER is made that way.
2023-01-17 12:59:26 <KipIngram   > And then after I defined NUMBER I ran .wipe to get rid of all those helpers.
2023-01-17 12:59:42 <vms14       > then there's no difference between : foo : bar ; and : foo ; : bar ; ?
2023-01-17 12:59:45 <KipIngram   > Or rather to get them out of the dictionary - the *definitions* are still present and still get called.
2023-01-17 13:00:02 <KipIngram   > Yes, there's a difference.
2023-01-17 13:00:10 <KipIngram   > The first one has both labels pointing to the same s pot.
2023-01-17 13:00:15 <KipIngram   > The second one is two empty words.
2023-01-17 13:00:52 <KipIngram   > The first one compiles just one ; - the second one two.
2023-01-17 13:01:09 <KipIngram   > Your ; words are the only things that get compiled there.
2023-01-17 13:01:19 <KipIngram   > The : <label> just makes headers.
2023-01-17 13:02:44 <vms14       > hmm then makes sense to add a compile option and have temp words
2023-01-17 13:02:58 <vms14       > once I compile the word I can get rid of the auxiliar ones
2023-01-17 13:03:05 <KipIngram   > Well, that's what my .: vs. : does.
2023-01-17 13:03:12 <KipIngram   > .: defines a temporary word.
2023-01-17 13:03:23 <Stalevar    > so, we got 10 and 0 on the stack, then do does what? where is there a decrement?
2023-01-17 13:03:33 <KipIngram   > My opinion is that if you cook up some way to put definitions inside definitions then it's not quite Forth anymore.
2023-01-17 13:03:59 <vms14       > Stalevar: https://www.forth.com/starting-forth/6-forth-do-loops/
2023-01-17 13:04:04 <Stalevar    > dc -e '1 [ p 1+ d 10 !<a ] d sa x'
2023-01-17 13:04:26 <vms14       > limit index DO ... LOOP
2023-01-17 13:04:52 <vms14       > KipIngram: haha it was never a forth
2023-01-17 13:05:11 <vms14       > it's completely different
2023-01-17 13:05:20 <Stalevar    > 1 is put to stack, then printed with `p` without being pulled out, then added 1, then duplicated, if it's not more then 10, then macro a is executed. This code is duplicated, saved in register a, and executed with x
2023-01-17 13:05:23 <vms14       > also makes no sense trying to adhere to a real forth
2023-01-17 13:05:24 <Stalevar    > Quite easy
2023-01-17 13:05:52 <Stalevar    > KipIngram, do you understand dc -e '1 [ p 1+ d 10 !<a ] d sa x' ?
2023-01-17 13:05:56 <vms14       > Stalevar: dc has nothing to do with forth more than being rpn and stack based
2023-01-17 13:06:38 <Stalevar    > I thought forth is like dc, but made into real programming language instead of just a calculator
2023-01-17 13:07:20 <Stalevar    > dc can't parse strings at all, it can only print or execute them
2023-01-17 13:07:44 <vms14       > they're quite different I'd say
2023-01-17 13:08:09 <vms14       > also is cleaner than dc xD
2023-01-17 13:08:32 <vms14       > 10 0 do i . loop   vs the shit you posted
2023-01-17 13:09:10 <Stalevar    > I'd not say it shit, at least dc is understandable, since it has clearly defined decrement for instance
2023-01-17 13:09:51 <vms14       > in my shitty lang would be  '. 10 do.times*
2023-01-17 13:10:01 <vms14       > but this is from 0 to 9
2023-01-17 13:11:18 <vms14       > could also be 1 10 range '. do.list
2023-01-17 13:13:28 <Stalevar    > I didn't call forth shitty, but dc is somewhat good too
2023-01-17 13:13:32 <vms14       > then I guess I'll add a compile function which already had in the past and use temp words
2023-01-17 13:14:09 <vms14       > I could also add that word nesting stuff anyways
2023-01-17 13:14:57 <vms14       > I can't really compile everything, unless I make some compiling versions of some words
2023-01-17 13:15:58 <vms14       > for the effect of temp vars it would work, but for avoiding the interpreter not
2023-01-17 13:16:32 <Stalevar    > can you write loop from 1 to 10 using some explicit increment, such as with while-like loop?
2023-01-17 13:16:47 <vms14       > I mean definition would work even if temp words are not there, as my compiling process is to just make a list of functions
2023-01-17 13:16:51 <Stalevar    > dc doesn't have for-loop, so yeah, it's different
2023-01-17 13:16:54 <vms14       > Stalevar: LOOP+
2023-01-17 13:17:18 <vms14       > gave you a link that explains how to loop in forth
2023-01-17 13:17:38 <vms14       > there's also BEGIN ... AGAIN
2023-01-17 13:20:21 <vms14       > KipIngram: do you have a way to use a word not already defined in a colon definition?
2023-01-17 13:20:45 <vms14       > when compiling all words in the definition should exist
2023-01-17 13:21:37 <vms14       > if I find some word that does not exist, I put there a function that will use the compiled word
2023-01-17 13:22:30 <vms14       > it assumes when executed that word will exist, but would be kind of a fatal error if does not
2023-01-17 13:22:58 <Stalevar    > : stars 0 do '*' . loop ; redefined stars   ok
2023-01-17 13:22:58 <Stalevar    > 3 stars 42 42 42  ok
2023-01-17 13:23:15 <vms14       > haha that part is funny
2023-01-17 13:23:49 <vms14       > to print a star: 42 emit
2023-01-17 13:24:02 <vms14       > : star 42 emit ;
2023-01-17 13:24:33 <vms14       > : stars 0 do star loop ;
2023-01-17 13:24:37 <Stalevar    > : stars 0 do '*' emit loop ; redefined stars   ok
2023-01-17 13:24:37 <Stalevar    > 3 stars *** ok
2023-01-17 13:24:38 <KipIngram   > vms14: No, I don't, but it wouldn't be hard to do, because I POINT to definition lists from my words.
2023-01-17 13:24:59 <KipIngram   > So I could certainly define an empty label, and then go plug a def address  into it later.
2023-01-17 13:25:04 <KipIngram   > So maybe I should claim that.
2023-01-17 13:25:15 <KipIngram   > All I'd need to do would be to write a nice listtle word to do the plugging for me.
2023-01-17 13:25:23 <KipIngram   > Then I could just say
2023-01-17 13:25:27 <KipIngram   > : foo [
2023-01-17 13:25:44 <KipIngram   > And then later plug the address in that header.
2023-01-17 13:25:51 <vms14       > sometimes I do envy features from forth
2023-01-17 13:26:07 <KipIngram   > Let's see.
2023-01-17 13:26:10 <KipIngram   > : foo [
2023-01-17 13:26:13 <KipIngram   > ... stuff ...
2023-01-17 13:26:18 <KipIngram   > ... and then ...
2023-01-17 13:26:33 <KipIngram   > here ] ... definition ... ;
2023-01-17 13:26:46 <KipIngram   > ( address is on the stack now)
2023-01-17 13:26:51 <KipIngram   > ' foo plug
2023-01-17 13:27:01 <KipIngram   > I don't have a word plug yet.
2023-01-17 13:27:05 <KipIngram   > But the rest of that works now.
2023-01-17 13:27:23 <KipIngram   > Maybe it would be
2023-01-17 13:27:27 <KipIngram   > ' foo pfa
2023-01-17 13:27:32 <vms14       > does forth allow nested comments ( like ( this)) ?
2023-01-17 13:27:39 <KipIngram   > ' foo gives me the code field address, but that's not what needs plugging.
2023-01-17 13:27:50 <KipIngram   > the pfa operation could be in plug though.
2023-01-17 13:27:58 <vms14       > I have a ( word that will execute itself again if it finds a (
2023-01-17 13:28:16 <vms14       > nested comments don't need a space, only the first (
2023-01-17 13:28:30 <KipIngram   > ( is a comment opener for me.  It just uses WORD to toss everything up through the next ) on the floor.
2023-01-17 13:28:32 <vms14       >  ( like (this))
2023-01-17 13:29:03 <vms14       > I also have a #!/usr/bin/env word that acts as a line comment XD
2023-01-17 13:29:09 <KipIngram   > Though I hardly ever write comments.
2023-01-17 13:29:10 <vms14       > and # too
2023-01-17 13:29:19 <KipIngram   > I think they ugly up my source code.
2023-01-17 13:29:27 <Stalevar    > : box 0 do 10 emit dup stars loop ;
2023-01-17 13:29:38 <KipIngram   > Later when I get a more full-featured system I want to be able to store comments remote from my source code and have links.
2023-01-17 13:29:54 <KipIngram   > It would give me a hypertext type "link to documentation" system.
2023-01-17 13:29:59 <vms14       > oh, I was going to start documenting words
2023-01-17 13:30:09 <KipIngram   > Then I can comment to my heart's content without uglying up the source.
2023-01-17 13:30:11 <vms14       > I tend to forget the order they expect arguments sometimes
2023-01-17 13:30:28 <KipIngram   > Just put the cursor where I want and tap a key; it will open a new window I can put comments in.
2023-01-17 13:30:45 <KipIngram   > I'll be able to do the same thing in the comment - comments on comments, etc.
2023-01-17 13:30:53 <vms14       > :0 sounds cool
2023-01-17 13:30:55 <KipIngram   > Full documentation, accessible from anywhere in the source code I like.
2023-01-17 13:31:14 <KipIngram   > I've alrerady worked out how a b-tree based file system will support that; got notes  here somewhere.
2023-01-17 13:31:48 <KipIngram   > I'll use a b-tree to organize directories and map out my files, and a second b-tree that will store links, from anywhere on disk to anywhere on disk.
2023-01-17 13:32:10 <KipIngram   > Nothing will actually go in the source code - the b-tree will just identify that spot as a link origin.
2023-01-17 13:33:39 <KipIngram   > I actually LIKE commenting - I like explaining things in detail.
2023-01-17 13:33:57 <KipIngram   > But I really do balk at any significant amount of commentary mingled in with my source.
2023-01-17 13:34:13 <KipIngram   > And that's a cross-langugae thing for me - I feel that way when writing C or Python too.
2023-01-17 13:34:40 <KipIngram   > For one thing, I like having as much code on-screen as possible; the more I can actually SEE, the better I can keep it all in mind.
2023-01-17 13:34:45 <KipIngram   > Verbose comments spread it out.
2023-01-17 13:34:48 <vms14       > I can understand it
2023-01-17 13:35:02 <vms14       > it's like everything should have its own space
2023-01-17 13:35:15 <vms14       > code is code, documentation is documentation
2023-01-17 13:35:23 <vms14       > you just dislike them being mixed
2023-01-17 13:35:44 <KipIngram   > I do believe, though, that top-drawer Forth code needs less commenting.  There's something to the whole "self-documenting" thing.
2023-01-17 13:35:58 <KipIngram   > But to materialize it you need to be writing good short definitions.
2023-01-17 13:36:05 <vms14       > still comments in code are to help the reader ( even you) to understand the code
2023-01-17 13:36:07 <KipIngram   > And you need to name t hem well.
2023-01-17 13:36:15 <KipIngram   > Sure.
2023-01-17 13:36:29 <vms14       > but yeah, if you have that fancy feature, then is much better
2023-01-17 13:36:40 <KipIngram   > What I'd like in this link-based system is for that comment window to pop open, alongside the source window, whenever the cursor is on a link origin.
2023-01-17 13:36:50 <vms14       > just press a hotkey or whatever and see the comments for the code you are reading
2023-01-17 13:37:14 <KipIngram   > Yeah, though I'll probably have it open automatically, and then close again when the cursor moves off of the origin text.
2023-01-17 13:37:30 <vms14       > it's a good idea actually
2023-01-17 13:37:35 <KipIngram   > That's assuming I have a screen big enough for both windows.
2023-01-17 13:37:38 <vms14       > it's much cleaner that way
2023-01-17 13:37:45 <KipIngram   > I think so, and I particularly like the hierarchical nature of it.
2023-01-17 13:38:00 <vms14       > also you don't have to worry about lenghty comments and alike
2023-01-17 13:38:03 <KipIngram   > You can link direction to a brief comment, and then link from there to a "tech ref" type explanation.
2023-01-17 13:38:17 <vms14       > you can explain stuff in detail, make several points, etc
2023-01-17 13:38:19 <KipIngram   > That would probably describe a piece of the SYSTEM, rather than just the one word.
2023-01-17 13:38:44 <vms14       > it's cool, I like it
2023-01-17 13:38:53 <KipIngram   > I've got kind of a long wish list - if I can make it al l happen I'll have a nice tool.
2023-01-17 13:39:02 <vms14       > the sad part is it needs a dedicated reader/editor
2023-01-17 13:39:13 <KipIngram   > Yes, but Forth often does anyway.
2023-01-17 13:39:21 <KipIngram   > Unless you use some native OS file system.
2023-01-17 13:40:02 <KipIngram   > And I want this to all integrate with my debugging ecosystem, too.
2023-01-17 13:40:14 <KipIngram   > It'll be a true dev environment, if I get it all working.
2023-01-17 13:40:19 <Stalevar    > 0 0 do loop gives an infinite loop instead of zero-times loop, as expected...
2023-01-17 13:40:37 <KipIngram   > :-)  That's unfortunate.
2023-01-17 13:40:40 <Stalevar    > vms14, : \stars 0 do 10 dup emit i -1 do 32 emit loop stars loop ;
2023-01-17 13:40:45 <KipIngram   > But not entirely unexpected.
2023-01-17 13:40:53 <Stalevar    > i can't do skewed stars as because of that
2023-01-17 13:41:01 <Stalevar    > this is closest I came up with
2023-01-17 13:41:11 <KipIngram   > The problem is that the test in a DO LOOP is in the LOOP.
2023-01-17 13:41:26 <Stalevar    > Yeah so how do I print zero spaces?
2023-01-17 13:41:35 <KipIngram   > It has to run at least once -  you pass through it once and decrement the variable, and now it's a huge unsigned number so you continue.
2023-01-17 13:41:38 <KipIngram   > It's not infinite, of course.
2023-01-17 13:41:42 <KipIngram   > Just maximum.
2023-01-17 13:41:45 <Stalevar    > N spaces, where N could be zero
2023-01-17 13:41:51 <KipIngram   > It could.
2023-01-17 13:42:06 <KipIngram   > So it's easy to fix by wrapping it in a definition that checks for that case.
2023-01-17 13:42:17 <KipIngram   > I agree with you, though - it would be nice if the default beavior worked that way.
2023-01-17 13:42:37 <KipIngram   > I use conditional returns in my system, so I could just do this:
2023-01-17 13:43:10 <KipIngram   > : foo  .0=; 0 DO I . LOOP ;
2023-01-17 13:43:21 <KipIngram   > Actually this would be better:
2023-01-17 13:43:35 <KipIngram   > : foo  ?dup 0=; 0 do i . loop ;
2023-01-17 13:43:48 <KipIngram   > The first one would leave the 0 on the stack.
2023-01-17 13:44:02 <KipIngram   > That will not run in gforth, btw...
2023-01-17 13:44:11 <KipIngram   > My conditional returns are non-standard.
2023-01-17 13:45:16 <KipIngram   > My control flow stuff is entirely non-standard; I don't even have the conventional control flow words.
2023-01-17 13:45:32 <KipIngram   > So it wouldn't be unfair to say mine isn't "really Forth" either.
2023-01-17 13:45:46 <KipIngram   > But it's true to the "essence" of Forth enough to satisfy me.
2023-01-17 13:46:56 <Stalevar    > is there simple if then else in forth?
2023-01-17 13:47:05 <vms14       > Stalevar: you have to add an if for when it's 0
2023-01-17 13:50:02 <vms14       > : stars dup 0= if drop else 0 do star loop then ;
2023-01-17 13:50:20 <vms14       > though dup? existed :/
2023-01-17 13:50:27 <vms14       > thought
2023-01-17 13:50:44 <vms14       > ah lol is ?dup
2023-01-17 13:50:46 <vms14       > XDDD
2023-01-17 13:50:51 <Stalevar    > Alright, I feel fed up with forth for today at least. Thanks for your help. Maybe I will try more later
2023-01-17 13:51:00 <vms14       > : stars ?dup 0= if else 0 do star loop then ;
2023-01-17 13:51:14 <Stalevar    > what do you think of Factor?
2023-01-17 13:51:17 <vms14       > Stalevar: the if is a bit weird
2023-01-17 13:51:37 <vms14       > condition if code if true else code if false then
2023-01-17 13:52:02 <vms14       > Stalevar: I do not know about, but some people told me my lang resembles to it
2023-01-17 13:52:14 <vms14       > as I'm using lists as code and seems factor also does
2023-01-17 13:52:39 <vms14       > for example I'm trying to make the 99 lisp problems in my lang
2023-01-17 13:52:51 <vms14       > https://termbin.com/ae8h
2023-01-17 13:53:55 <vms14       > I have if and if.else instead of the forth way
2023-01-17 13:54:16 <vms14       > value [ " is true" ] [ " is false" ] if.else
2023-01-17 13:54:17 <vms14       > xD
2023-01-17 13:54:18 <KipIngram   > Stalevar: ...make flag... IF ...code... ELSE ...code... THEN ...
2023-01-17 13:54:25 <KipIngram   > also must be in a compiled definition.
2023-01-17 13:54:55 <KipIngram   > The ELSE is optional.
2023-01-17 13:55:36 <vms14       > Stalevar: did you try factor?
2023-01-17 13:55:59 <Stalevar    > : \stars 0 do 10 dup emit i dup 0= if drop else 0 do 32 emit loop then stars loop ;  ok
2023-01-17 13:56:09 <Stalevar    > yes, a long time ago
2023-01-17 13:57:01 <vms14       > Stalevar: what's cool about factor?
2023-01-17 13:57:06 <KipIngram   > Stalevar: I left things like IF THEN behind a while ago, because I wind up with shorter definitions with my conditional returns.
2023-01-17 13:57:13 <vms14       > had a quick look and didn't get interested
2023-01-17 13:57:21 <KipIngram   > But that approach does require me to put the conditional code in a definition of its own.
2023-01-17 13:57:32 <KipIngram   > Which doesn't feel like a bad thing to do to me.
2023-01-17 13:58:03 <KipIngram   > : (foo)  0=; ...conditional code... ;
2023-01-17 13:58:14 <KipIngram   > : foo  ...make flag... (foo) ... ;
2023-01-17 13:58:42 <KipIngram   > And (foo) would be a good candidate for the .: .wipe mechanism.
2023-01-17 14:00:43 <KipIngram   > A really PROPER implementation of .: / .wipe would use dynamically allocated temporary storage for the .: word headers.
2023-01-17 14:01:07 <KipIngram   > But in my current system I just remove those items from the linked list; they're otherwise just like other definitions and I can't get the space back.
2023-01-17 14:01:25 <KipIngram   > I did it dynamically in my next most recent implementation.
2023-01-17 14:01:42 <KipIngram   > Stalevar: thing is, most Forths don't offer any kind of dynamic memory management.
2023-01-17 14:01:51 <KipIngram   > It was an extra feature in that prior system.
2023-01-17 14:02:22 <KipIngram   > it's certainly easier to make .: .wipe work if you don't worry about recovering that space; there were some hoops to jump in the other system.
2023-01-17 14:03:06 <vms14       > haha my colon words are array references which means you can edit their contents at any time
2023-01-17 14:03:08 <KipIngram   > Gotta run to the dentist - back in a bit.
2023-01-17 14:03:27 <vms14       > : word 1 2 3 ; 'word contents pop  => now word is : word 1 2 ; XD
2023-01-17 14:04:08 <vms14       > unless they're compiled, then they're no longer "colon" words
2023-01-17 14:04:30 <vms14       > but didn't add a compile way yet like I had before
2023-01-17 14:04:44 <vms14       > if I run into performance problems then I'll do
2023-01-17 14:05:20 <Stalevar    > KipIngram, why? I didn't say anything about dynamic memory. Anyway.... I don't feel like more forthing. Starting Forth book is too verbose
2023-01-17 14:05:31 <Stalevar    > But standard is uncomfortable to read
2023-01-17 14:05:46 <vms14       > Stalevar: the images are fun
2023-01-17 14:05:51 <vms14       > I love the execution guy
2023-01-17 14:05:59 <Stalevar    > yeah. bit too much to read
2023-01-17 14:06:22 <vms14       > https://www.forth.com/starting-forth/9-forth-execution/
2023-01-17 14:07:01 <vms14       > there are several forth books anyways
2023-01-17 14:07:13 <Stalevar    > I only want basic things such as `a b do ... loop` means saving the ... stuff and executing it while warying i from b to a
2023-01-17 14:07:20 <vms14       > it's just the most common known are those, specially thinking forth
2023-01-17 14:07:48 <Stalevar    > so one paragraph per construction, so I can quickly see what it can do
2023-01-17 14:08:10 <vms14       > Stalevar: why are you interested in forth?
2023-01-17 14:08:59 <vms14       > it can do whatever a general purpose lang can, except maybe stuff regarding libraries, unless you use gforth
2023-01-17 14:09:20 <vms14       > gforth allows you to use ffi to C, so you can do almost whatever you want
2023-01-17 14:09:58 <vms14       > https://bernd-paysan.de/httpd-en.html  for example
2023-01-17 14:11:22 <Stalevar    > what is ?dup anyway?
2023-01-17 14:11:42 <Stalevar    > vms14, I can't say, until I learn it, but probably not
2023-01-17 14:11:46 <vms14       > dup duplicates an element from the stack
2023-01-17 14:11:52 <Stalevar    > yes, but ?dup ?
2023-01-17 14:11:55 <vms14       > ?dup only duplicates it if it's not 0
2023-01-17 14:12:00 <Stalevar    > ah, ok
2023-01-17 14:12:27 <vms14       > it's usually used with if, so you don't have to drop it
2023-01-17 14:13:30 <vms14       > Stalevar: I love the colon words from forth
2023-01-17 14:14:06 <vms14       > the fact : name definition ; creates a "function" and how it's expected to be built from little blocks
2023-01-17 14:14:44 <vms14       > also it can do some fancy stuff if you get to know it
2023-01-17 14:14:55 <vms14       > like metaprogramming for example
2023-01-17 14:15:03 <vms14       > and words can even read from the source code
2023-01-17 14:15:19 <vms14       > you can create immediate words that execute at compiling time
2023-01-17 14:15:35 <vms14       > also have words with "dual" behavior
2023-01-17 14:16:23 <vms14       > I did not get far with forth as I just took some concepts and make my own abomination, which is quite different from a real forth
2023-01-17 14:16:44 <vms14       > but it has features not many languages have, the sad part is foreign and unknown
2023-01-17 14:17:07 <Stalevar    > : fac ?dup 0= if 1 else dup 1 - fac * then ;
2023-01-17 14:17:38 <vms14       > idk if that's allowed, there's a 'recurse' word
2023-01-17 14:18:07 <veltas      > It's allowed but if fac was already defined, and would call the old fac, RECURSE as you say lets you call recursively
2023-01-17 14:18:07 <vms14       > have in mind words need to exist before you use them in a colon definition
2023-01-17 14:18:36 <vms14       > my lang just does not fucking care as it does not compile anything xD
2023-01-17 14:18:43 <Stalevar    > 7 dup 1 - fac * . 5040  ok
2023-01-17 14:18:43 <Stalevar    > 7 fac  ok
2023-01-17 14:18:44 <Stalevar    > . 2520  ok
2023-01-17 14:18:52 <Stalevar    > What the ...
2023-01-17 14:18:56 <Stalevar    > factorial works up to 7
2023-01-17 14:19:08 <Stalevar    > ah...
2023-01-17 14:19:16 <Stalevar    > veltas, where do you put recurse?
2023-01-17 14:19:41 <Stalevar    > at the end or after : or after fac ?
2023-01-17 14:19:58 <veltas      > RECURSE calls the function being defined
2023-01-17 14:20:00 <vms14       > Stalevar: where you would put 'fac'
2023-01-17 14:20:41 <veltas      > The name of the function/word you're defining goes after ':', and 'RECURSE' can be used anywhere in the word to call itself
2023-01-17 14:21:40 <Stalevar    > ah, got it, it's like `self` or `this` in other languages
2023-01-17 14:21:50 <vms14       > http://progopedia.com/example/factorial/253/
2023-01-17 14:22:05 <Stalevar    > : fac ?dup 0= if 1 else dup 1 - recurse * then ; redefined fac   ok
2023-01-17 14:22:07 <vms14       > in gforth seems to be allowed as long as you mark it as 'recursive' first
2023-01-17 14:22:34 <vms14       > I also have recurse and recursive xD
2023-01-17 14:23:16 <vms14       > recursive modifies a word to be a loop able to recurse forever without fucking the stack
2023-01-17 14:23:46 <vms14       > recurse actually just sets a flag that loop uses as the test value
2023-01-17 14:24:25 <Stalevar    > 24 fac . -7835185981329244160  ok
2023-01-17 14:24:32 <vms14       > I liked some stuff from tile forth
2023-01-17 14:25:22 <vms14       > hmm my lang dies with factorials
2023-01-17 14:25:23 <vms14       > xD
2023-01-17 14:28:26 <Stalevar    > Can I do something like dc -e with gforth? Like gforth -e '' : fac ?dup 0= if 1 else dup 1 - recurse * then ; 10 fac .
2023-01-17 14:28:36 <Stalevar    > "
2023-01-17 14:30:12 <Stalevar    > $ gforth -e ": fac ?dup 0= if 1 else dup 1 - recurse * then ; 10 fac . 10 emit bye"
2023-01-17 14:30:12 <Stalevar    > 3628800
2023-01-17 14:30:15 <Stalevar    > This works
2023-01-17 14:32:53 <Stalevar    > So my question stands. Is there a page on forth which defines all basic words and structures without tedious explanations, just one short paragraph per thing, or even just one line
2023-01-17 14:33:27 <Stalevar    > cond if do_if_false else do_if_true then
2023-01-17 14:33:36 <Stalevar    > For example this line to explain if thing
2023-01-17 14:33:48 <Stalevar    > dup  duplicates value on top of the stack
2023-01-17 14:34:01 <Stalevar    > ?dup duplicates value on top of the stack if it's not zero
2023-01-17 14:34:45 <Stalevar    > emit prints as character
2023-01-17 14:34:50 <Stalevar    > . prints as integer
2023-01-17 14:35:00 <Stalevar    > bye exits the interpreter
2023-01-17 14:36:05 <Stalevar    > a b do loop_body loop iterates from b to a going through loop at least once, the loop counter can be accessed as `i`
2023-01-17 14:44:50 <Stalevar    > KipIngram, but why forth interpreter prints stuff on same line where you enter it and not on next line as all other repls and shells do?
2023-01-17 14:45:06 <Stalevar    > and why ok?
2023-01-17 14:45:37 <thrig       > because that's what it was written to do
2023-01-17 14:53:46 <Stalevar    > but why?
2023-01-17 14:54:17 <Stalevar    > Anyway, I guess, gforth telling about stack underflow is better than pforth which segfaults
2023-01-17 14:54:29 <Stalevar    > what do you think?
2023-01-17 15:02:11 <thrig       > the English uses the articles a lot. and you are asking why the Russian does not the the a lot
2023-01-17 15:40:37 <KipIngram   > Stalevar: Because that's just one of the endearing features of Forth.  Youu have to go to considerable trouble to get it to do that too, because the "standard" read line routine that the OS's provide takes control of the keyboard until you hit Enter, and imposes that carriage return on you.
2023-01-17 15:40:53 <KipIngram   > You have to tinker with the termios settings to get it to work "per character."
2023-01-17 15:41:06 <KipIngram   > So, the answer to your question is "because they wanted it that way."
2023-01-17 15:41:22 <KipIngram   > And that's  no doubt because that's the way Chuck Moore did it when he first wrote Forths.
2023-01-17 15:41:41 <KipIngram   > I like it and go out of my way to implement it.
2023-01-17 15:41:57 <KipIngram   > "All the other systems" just take the default settings from the OS and roll with it.
2023-01-17 15:42:18 <KipIngram   > But that means you can't control anything that happens w hile the user is typing a line.
2023-01-17 15:42:32 <KipIngram   > Whereas I read KEYS and can do whatever I want with them, per key.
2023-01-17 15:42:43 <KipIngram   > I implement my own "line editing."
2023-01-17 15:43:08 <KipIngram   > And that turns out to be quite a bit of code; it's  probably the most involved section of code in my Forth.
2023-01-17 15:43:53 <KipIngram   > But I handle an assortment of line editing keys, handle UTF8 characters, and so on.
2023-01-17 15:44:16 <KipIngram   > In Forth KEY will get one keystroke from the kbd and return it's ASCII code on the stack.
2023-01-17 15:44:30 <KipIngram   > I.e., a byte.
2023-01-17 15:44:45 <KipIngram   > My KEY will respond to utf8 chars by returning all of the bytes of the character in that top stack element.
2023-01-17 15:46:38 <Stalevar    > Yet there is no such a clear distinction between user input and system output like that
2023-01-17 15:48:02 <Stalevar    > While say in bash, by line bash:~$ or something you can tell apart your commands from bash responses
2023-01-17 15:48:21 <Stalevar    > unless some command outputs 'bash:~$ ' just to confuse you
2023-01-17 15:53:09 <thrig       > actually having bash installed would be confusing
2023-01-17 15:53:54 <KipIngram   > I arranged for user input and system output to be in different colors.
2023-01-17 15:54:23 <KipIngram   > Error messages red, code output blue, etc.
2023-01-17 15:54:32 <KipIngram   > Winds up giving me some quite pretty screens.
2023-01-17 15:54:47 <KipIngram   > There is, though, as assumption in Forth that you know what you're doing.
2023-01-17 15:55:01 <KipIngram   > You can stub your toe thoroughly in Forth, and it does not protect you from that.
2023-01-17 15:55:03 <KipIngram   > At all.
2023-01-17 15:55:27 <KipIngram   > Most Forth systems will just segfault, for example, if you try to fetch from an invalid address, or if you divide by zero.
2023-01-17 15:55:32 <KipIngram   > Not all.
2023-01-17 15:55:37 <KipIngram   > But a lot of them.
2023-01-17 15:55:54 <KipIngram   > I went to a good bit of trouble figuring out how to catch signals so that i could have my own error handling respond to those.
2023-01-17 15:56:16 <KipIngram   > In mine any error restores the system to what it was before you started typing the line that contained the error.
2023-01-17 15:56:39 <KipIngram   > The idea being that later, when I have command history working, on an error I just cursor up, edit the error out, and hit Enter again.
2023-01-17 15:56:52 <KipIngram   > So any partial progress made on the line before the error happens gets discarded.
2023-01-17 16:02:07 <KipIngram   > DM-41X  is delivered and in my hands.  :-)
2023-01-17 16:02:14 <KipIngram   > Let the stroll down memory lane begin...
2023-01-17 16:03:21 <KipIngram   > It's an awfully lovely thing; feels nice and solid.
2023-01-17 16:03:55 <KipIngram   > No backlight, and I'm kind of spoiled by them.  Of course the original HP had no backlight either, so...
2023-01-17 16:04:39 <KipIngram   > The display is at least "e-ink-like"; it holds an image even when the thing is powered off.  There's a collection of images (that I can add to) that it cycles around.
2023-01-17 16:04:56 <KipIngram   > Shows all four stack elements, instead of just one.
2023-01-17 18:01:23 <veltas      > Stalevar: Forth is meant to be talkative, old Forth would say "hi" when it started, "ok" for success, and stuff like "X?" if it doesn't understand X
2023-01-17 18:01:43 <veltas      > It's quite minimal too, "hi", "ok", "?" are all short strings
2023-01-17 18:02:07 <veltas      > It's just meant to humanise an otherwise machine-friendly language
2023-01-17 19:25:06 <KipIngram   > Hey, I think the HP-41C family must have used single-precision math.  Or something akin to it.
2023-01-17 19:25:44 <KipIngram   > I did that trig^3 / inverse trig^3 test on it, and the mismatch from 9 at the end is considerably larger than it was on the WP34S, even in single precision model.
2023-01-17 19:25:46 <KipIngram   > mode
2023-01-17 19:25:56 <KipIngram   > And exactly matches what my HP-41 emulator gives.
2023-01-17 19:26:55 <KipIngram   > The Free42 HP-42S emulator appears to use quad precision by default.
2023-01-17 19:27:11 <KipIngram   > It gets the same 10^-29 residual that the WP34S gets in its "double" mode.
2023-01-17 19:29:19 <KipIngram   > I guess that's just a thing that evolved with time.
2023-01-17 19:39:58 <KipIngram   > Here we go:
2023-01-17 19:40:00 <KipIngram   > https://www.rskey.org/hp41c
2023-01-17 19:40:06 <KipIngram   > precision of 10 digits.
2023-01-17 19:40:21 <KipIngram   > It has no guard digits, and that was something it was criticized for early on.
2023-01-17 19:40:39 <KipIngram   > Well, it certainly got me through what I needed to get through.
2023-01-17 19:40:57 <KipIngram   > But obviously more is better on that front.
2023-01-17 19:44:01 <KipIngram   > From what I read, HP took the position that some imprecision was "unavoidable," which is a little odd given that their later replacement for the HP-41 (the HP-42S) went all the way to 34 digits.  :-)
2023-01-17 19:44:39 <KipIngram   > Strikes me that HP spin-doctored it at the time to protect their market, but meanwhile the engineers got told in no uncertain terms that it better get fixed next go round.
2023-01-17 19:45:21 <KipIngram   > Because I'd say that going from 10 digits to 34 digits in one product jump qualifies as "fixed."
2023-01-17 19:57:14 <KipIngram   > Oh, fun...
2023-01-17 19:57:48 <KipIngram   > Wikipedia:  The HP-41C was carried on early "Shuttle missions for the purpose of performing mundane but necessary calculations, such as calculating the change to the center of gravity due to fuel consumption. The HP-41C was also programmed to handle calculations usually performed by the main on-board computer, such as determining ignition times for re-entry, in the case of a main computer failure."
2023-01-17 19:58:45 <KipIngram   > I didn't realize I was using the machine that the shuttle astronauts were using.  :-)
2023-01-17 19:59:48 <KipIngram   > Ok, I take back what I said about the HP-42S being a big jump.
2023-01-17 19:59:57 <KipIngram   > I think Free42 just adds extra precision.
2023-01-17 20:00:24 <KipIngram   > I found a webpage that said the 42S gave 13-digit precision, 15 internally.
2023-01-17 20:00:49 <KipIngram   > So looks like HP just "nudged it," which actually makes somewhat more sense for a rolling product development program.
2023-01-17 20:01:15 <KipIngram   > Free42 seems like a pretty well thought of program.  It's not actually an emulator - it's a "work-alike" independent program.
2023-01-17 20:08:55 <KipIngram   > This is the library that Free42 "Decimal" uses:
2023-01-17 20:08:57 <KipIngram   > https://www.intel.com/content/www/us/en/developer/articles/tool/intel-decimal-floating-point-math-library.html
2023-01-17 20:09:04 <KipIngram   > That's quad precision 16-byte numbers.
2023-01-17 20:09:27 <KipIngram   > There is also a version, Free42 "Binary" that uses binary double precision.  Probably faster, but obviously less precise.
2023-01-17 20:09:50 <KipIngram   > You can also enable Free42 to use "NSTK" mode, in which case your stack depth is limited only by your memory.
2023-01-17 20:17:39 <KipIngram   > Looks like there's an enhanced version of Free42 called Plus42 which is something of a "hybrid" between the 42S and the 48G family.
2023-01-17 20:28:33 <KipIngram   > Free42 source is available here:
2023-01-17 20:28:35 <KipIngram   > https://github.com/thomasokken/free42.git
2023-01-17 20:30:38 <Zarutian_iPad> 
ACTION was watching https://www.youtube.com/watch?v=O669rW3nzxo and finally understod how slow to activate and slow to deactivate relay work and how that copper plug corrisponds to IEC symbols of the coil of the relay

2023-01-17 20:42:06 <KipIngram   > Isn't it nice when something "clicks" like that?
2023-01-17 20:43:27 <Zarutian_iPad> it was rather just, “oh that is why the symbol for slow to activate and the symbol for slow to deactivate is like that”
2023-01-17 20:45:02 <Zarutian_iPad> or in Icelandic (which I has to translate to English) “því er táknið fyrir seinn inn og táknið fyrir seinn út svona”
2023-01-17 20:47:27 <Zarutian_iPad> which is basically what I translate the usual thought soup in my head into before vocalizimg. (I do not “think” with a voice unless I am stringing together a vocalization)
2023-01-17 20:58:45 <KipIngram   > Now I don't want to turn my DM41 on; it's got a groovy picture of the starship Enterprise on the display and I have no idea how long it will take it to cycle back to it again.  :-)
2023-01-17 20:59:21 <Zarutian_iPad> the letter less on or the TNG one?
2023-01-17 20:59:29 <KipIngram   > Yeah, I'd e hard-pressed to describe how I "think."
2023-01-17 20:59:34 <Zarutian_iPad> s/on /one /
2023-01-17 20:59:45 <KipIngram   > No, it's the original series Enterprise.
2023-01-17 20:59:54 <KipIngram   > I.e., the coolest one.
2023-01-17 21:00:00 <KipIngram   > :-)
2023-01-17 21:00:14 <KipIngram   > I'm joking; I'm willing to let others like a different one better.
2023-01-17 21:00:56 <thrig       > this however may affect your performance review
2023-01-17 21:01:08 <KipIngram   > Hey,  have you ever seen that video of Leonard Nimoy and a bunch cute 60's style girls bouncing around singing a song about Bilbo Baggins?
2023-01-17 21:01:17 <KipIngram   > It's pretty outrageous.
2023-01-17 21:01:54 <KipIngram   > https://www.youtube.com/watch?v=BC35cQKHwzg
2023-01-17 21:02:02 <KipIngram   > Mention of Trek just made me think about it.
2023-01-17 21:02:11 <Zarutian_iPad> the TNG one turns out to be enormous
2023-01-17 21:02:51 <Zarutian_iPad> no wonder they have turbolifts
2023-01-17 21:03:16 <KipIngram   > Yeah; I caught onto that somewhere along the line.
2023-01-17 21:03:20 <KipIngram   > City in space, more or less.
2023-01-17 21:04:13 <KipIngram   > I never watched terribly much of TNG.
2023-01-17 21:04:25 <KipIngram   > Saw a few episodes I liked a good bit.
2023-01-17 21:04:42 <Zarutian_iPad> a small one though! Nothing like a O’Neal cyl
2023-01-17 21:04:49 <KipIngram   > I really enjoyed ST: Enterprise, though.
2023-01-17 21:05:28 <Zarutian_iPad> the one before there was a Starfleet?
2023-01-17 21:05:41 <KipIngram   > Well, before there was a Federation at least.
2023-01-17 21:05:58 <KipIngram   > Scott Bakula was the captain.  Jonathan Archer.
2023-01-17 21:06:43 <KipIngram   > The way they played the story out, Archer and the impressions he made for Earth on the aliens they encountered - that was all instrumental in bringing the Federation into being.
2023-01-17 21:06:44 <Zarutian_iPad> whose theme song starts with “Its been a long long while getting from there to here” which was describing the progression to space flight
2023-01-17 21:06:48 <KipIngram   > Yeah.
2023-01-17 21:06:51 <KipIngram   > Love that intro.
2023-01-17 21:07:04 <KipIngram   > I'd watch it every time instead of doing my usual fast forward.
2023-01-17 21:07:14 <KipIngram   > I thought it was inspirational.
2023-01-17 21:07:31 <Zarutian_iPad> the time lordish story arch was a bit nonsensical
2023-01-17 21:08:23 <KipIngram   > Oh, yeah, time travel usually winds up outlandish.
2023-01-17 21:08:32 <KipIngram   > There's really no way to make it make sense.
2023-01-17 21:08:55 <KipIngram   > Well, I guess there is, but only if there's a multiverse.
2023-01-17 21:09:06 <KipIngram   > But then when you go back in time you don't ever really CHANGE anything.
2023-01-17 21:09:22 <KipIngram   > You maybe set YOURSELF on a different line forward from the one you left behind.
2023-01-17 21:09:25 <Zarutian_iPad> btw in TNG Enterprise bridge meeting room there are brass models of every ship that bore thename Enterprise, including the Shuttle
2023-01-17 21:09:33 <KipIngram   > But say you went back and "saved the world."
2023-01-17 21:09:43 <KipIngram   > No, you didn't - you just dodged out of having to face the end of the world.
2023-01-17 21:09:50 <KipIngram   > All the folks you left behind still get burned.
2023-01-17 21:10:06 <KipIngram   > Somehow that makes it all a lot less dramatic.
2023-01-17 21:10:28 <Zarutian_iPad> some say that your time jump actually truncated that world line in a way
2023-01-17 21:10:33 <KipIngram   > If you try to play it where there's only one timeline, then all the paradox crap punches you in the face.
2023-01-17 21:11:07 <KipIngram   > Hmmm.  Well, I'd need to ponder that.
2023-01-17 21:11:14 <KipIngram   > That's kind of drastic.
2023-01-17 21:11:37 <KipIngram   > Anyway, I've just never seen it done really well, though I have enjoyed a few stories.
2023-01-17 21:11:43 <Zarutian_iPad> that or you have an eternalistic fourspace universe that jives with fate but not with free will and agency
2023-01-17 21:11:52 <KipIngram   > The original Trek episode The City on the Edge of Forver - that was a good episode.
2023-01-17 21:12:12 <KipIngram   > that's the one where McCoy gets drugged up and leaps through a time portal back to Depression era  America.
2023-01-17 21:12:27 <KipIngram   > Saves some random woman from dying in a car accident.
2023-01-17 21:12:39 <KipIngram   > And she goes on to do peace talks that foul up America's entry into WWII.
2023-01-17 21:12:43 <KipIngram   > So Hitler wins.
2023-01-17 21:13:06 <KipIngram   > Enterprise just blips out of existence up in orbit.
2023-01-17 21:13:24 <KipIngram   > But somehow the crew members that were down by the time portal DON'T blip out of existence.
2023-01-17 21:13:35 <KipIngram   > Leaving no explanation for how they got there.
2023-01-17 21:13:57 <Zarutian_iPad> Boltzman brain kind of thing
2023-01-17 21:14:05 <KipIngram   > Heh.  :_)
2023-01-17 21:14:07 <KipIngram   > :-)
2023-01-17 21:14:13 <KipIngram   > Anyway, I still enjoyed it.
2023-01-17 21:14:34 <KipIngram   > Joan Collins played the woman, and decades later she cited it as one of her fondest acting memories.
2023-01-17 21:15:07 <KipIngram   > I had a big time childhood crush on Yeoman Rand.
2023-01-17 22:09:43 <KipIngram   > You know, all of these HP style calculators have a really rich set of stack and memory operations.  You can store and recall, of course, but you can also do store+arithmetic (basic for operations), recall+arithmetic, and you can swap X (TOS) with stuff.  The target for all of those is any numbered register and any element of the stack.
2023-01-17 22:10:18 <KipIngram   > Oh, and it can be indirect, as well, though the ultimate target of that probably is only a numbered register.
2023-01-17 22:10:47 <KipIngram   > If you think about that, that's a pretty broad array of functionality.
2023-01-17 22:11:43 <KipIngram   > I guess Forth can do store and recall indirect x; that's basically what ! and @ are.
2023-01-17 22:15:59 <MrMobius    > KipIngram: you gotta upgrade up the 48  :) no numbered registers or anything. just objects you can put in folders if you like and stack is just however much memory there is
2023-01-17 22:21:42 <KipIngram   > Yeah; I'm a little familiar with it.
2023-01-17 22:21:57 <KipIngram   > But I've no fond memories of it.  :-)
2023-01-17 22:22:36 <KipIngram   > My wife likes her quite a lot, but I'm not sure how thoroughly she's ever used it for advanced things.
2023-01-17 22:23:09 <KipIngram   > It must be pretty good - it's got a great reputation.
2023-01-17 22:23:40 <KipIngram   > The Plus42 thing borrows a lot from the 48.
2023-01-17 22:24:53 <KipIngram   > It's got the directory structure and so on.
2023-01-17 22:25:26 <KipIngram   > Am I right in supposing that, at least generally, the soft keys take their meaning from objects in your current directory?
2023-01-17 22:28:28 <KipIngram   > Well, got a 9am appt tomorrow to have a wisdom tooth taken out.
2023-01-17 22:29:23 <KipIngram   > It involves light sedation, which I don't exactly love, but when I pressed the doc about it he said that that tooth is near a fairly important nerve, and he doesn't want me moving and causing him to damage it.
2023-01-17 22:29:33 <KipIngram   > I guess that's something I'd rather not have happen too.
2023-01-17 22:29:56 <KipIngram   > I asked him how it compared to the way I was anesthetized when I had my appendix out - he said "much less."
2023-01-17 22:30:21 <KipIngram   > It's not even clear to me that I'll completely lose consciousness.  We'll see I guess.