2023-08-17 03:24:49 <veltas      > Would be good to document it a bit more vms14, but I might take a look tonight
2023-08-17 03:25:04 <veltas      > Opportunity to read some Perl at the very least, I'm not that familiar with it
2023-08-17 03:25:08 <veltas      > I'm more of an awker
2023-08-17 03:38:51 <vms14       > The lang hasa fake  awk
2023-08-17 03:39:01 <vms14       > Don't remember how to use it
2023-08-17 03:43:03 <vms14       > Oh you give it a string and code
2023-08-17 03:43:26 <vms14       > The code will have available the 0 1 2 3... variables
2023-08-17 03:48:12 <vms14       > I have to go to work
2023-08-17 03:48:25 <vms14       > Ill look the awk word later and explain it
2023-08-17 05:31:41 <xelxebar    > Is there a standard word for listing all defined words in the dictionary?
2023-08-17 05:32:43 <veltas      > WORDS lists what's in current wordlist
2023-08-17 05:32:59 <veltas      > Which usually lists 'everything' except what's in editor, assembler, hidden etc
2023-08-17 05:33:31 <xelxebar    > Perfect. Thanks.
2023-08-17 05:36:07 <veltas      > If you're using gforth you might want to INCLUDE more.fs first
2023-08-17 05:36:12 <veltas      > This pauses after screenfuls
2023-08-17 05:36:50 <xelxebar    > Oo. gforth's dictionary is probably huge.
2023-08-17 05:36:52 <veltas      > I would guess most Forths have some way of doing this, it's quite a common need for interactive terminals
2023-08-17 05:37:16 <xelxebar    > For now I'm just poking along with SmithForth.
2023-08-17 05:37:23 <veltas      > What's convenient is SEE WORDS  or  LOCATE WORDS  tends to give you a clue how the dictionary is laid out
2023-08-17 05:37:33 <veltas      > Or starts you down the rabbithole
2023-08-17 05:38:19 <veltas      > That and  ' SOME-WORD 32 - 64 DUMP
2023-08-17 05:40:23 <veltas      > The best way to poke around a Forth is inside the Forth!
2023-08-17 05:41:04 <xelxebar    > Cool!
2023-08-17 05:42:02 <xelxebar    > DUMP's nice. Need to know header layout, I guess.
2023-08-17 05:45:25 <veltas      > Might want to inspect FIND and >BODY as well
2023-08-17 05:46:05 <veltas      > And QUIT and : to see how the interpreter and compiler work
2023-08-17 06:08:24 <xelxebar    > veltas: Well, I've been reading through the implementation of SmithForth, so I'm familiar with basic dictionary layout, compilation, etc.
2023-08-17 06:08:41 <xelxebar    > Really want to read implementation of SEE now!
2023-08-17 07:41:01 <KipIngram   > xelxebar: Yes, GForth is kind of a "kitchen sink included" Forth.
2023-08-17 07:42:42 <KipIngram   > The implementation of SEE will depend a lot on the design of your particular Forth.  It's most straightforward in direct and indirect threaded Forths - in those, each cell of a definition, for the most part, is the CFA of some word.  So it will just loop through and pick those up, run some little operation to migrate from the CFA address to the NFA (name field address), and print the counted string that it
2023-08-17 07:42:44 <KipIngram   > finds there.
2023-08-17 07:43:19 <KipIngram   > Has to watch out for literals, etc. - if it finds LIT, then the cell after isn't a CFA but rather is just a number.  There are other things to watch out for too, like ." and so on, but it's all fairly straightforward.
2023-08-17 07:43:43 <KipIngram   > The main issue is that things like IF ... THEN and loops and so on have been rendered into a form that just uses conditional branches.
2023-08-17 07:44:02 <KipIngram   > How extensively SEE reverses those effects is really a matter of "how smart" it is.
2023-08-17 07:44:19 <KipIngram   > Most straightforward thing to do is just to print it out in the conditional branch form.
2023-08-17 07:45:09 <KipIngram   > In a code threaded Forth it's a similar process, except instead of a list of addresses it's a list of call instructions interpersed with other machine code.
2023-08-17 07:45:39 <KipIngram   > But one way or another it's about understanding how the dictionary is structured and being able to find the name fields.
2023-08-17 07:53:30 <KipIngram   > Here's my implementation of WORDS, btw:
2023-08-17 07:53:32 <KipIngram   > https://pastebin.com/btYDyyAE
2023-08-17 07:58:56 <KipIngram   > Ugh.  Should have [ instead of ; at the end of the middle line, line 26.
2023-08-17 07:59:14 <KipIngram   > I really need to smarten up ; so it just handles that.
2023-08-17 07:59:28 <KipIngram   > me is an unconditional jump, so compiling a return there is wateful.
2023-08-17 07:59:33 <KipIngram   > wasteful
2023-08-17 08:06:11 <xelxebar    > Oh cool. That's really compact. Thanks for sharing the code.
2023-08-17 08:06:28 <xelxebar    > What are the {} brackets doing?
2023-08-17 08:06:48 <xelxebar    > And is .: a special kind of definition?
2023-08-17 08:12:18 <veltas      > I believe that means the word is removed from search at some point
2023-08-17 08:12:29 <veltas      > So essentially a 'private' word
2023-08-17 08:15:11 <veltas      > If I remember right  { ... n } makes it so that there are only the top n items on the stack above where stack was at { after executing }
2023-08-17 08:16:28 <veltas      > I'm sure Kip will explain it soon though. Yeah his Forth is optimised for structuring definitions as one-liners
2023-08-17 08:17:04 <xelxebar    > Ah, okay, so .: is sugar for setting a flag on the definition. That's cute. Probably something similar for immediate defs?
2023-08-17 08:17:40 <xelxebar    > The braces thing is nifty. Wonder *which* n items stick around.
2023-08-17 08:28:15 <KipIngram   > I have a register I call the frame pointer.  { saves the current FP on the return stack and copies SP into FP.  Then, inside the { ... } I can access stack cells by indexing off of FP.
2023-08-17 08:28:53 <KipIngram   > } undoes that, which puts the stack back the way it was on {, but it also drops an additional number of stack items specified by }'s parameter.
2023-08-17 08:29:15 <KipIngram   > So I use it to be able to do that accessing into the stack, but also to clean the stack up for me sometimes.
2023-08-17 08:29:40 <KipIngram   > In this case I don't use the stack indexing for anything - it's there to help me tidy up the stack.
2023-08-17 08:29:59 <KipIngram   > If you study that code you see that there are multiple paths out of the lower code, and they leave different amounts of stuff on the stack.
2023-08-17 08:30:14 <KipIngram   > } lets me "clean up" without having to know how much is there to clean up.
2023-08-17 08:30:58 <KipIngram   > And yes, .: does exactly the same thing as : does, except it sets a bit in the header.
2023-08-17 08:31:34 <KipIngram   > I have a word .wipe that will run through the current search order and "unlink" any words that have that bit set, removing them from the searchable word list.
2023-08-17 08:32:36 <KipIngram   > In this case print and  .words are just "temporary" - I don't need them long term, once word is compiled.
2023-08-17 08:32:59 <KipIngram   > I just find that mechanism so much simpler and easier than mucking about with vocabularies to hide "helper" words.
2023-08-17 08:33:42 <KipIngram   > And if you really try to adopt Forth philosophy and factor your code into short definitions, you wind up with a LOT of words like that that you don't need long term.
2023-08-17 08:34:18 <KipIngram   > In a prior implementation I did that in a way that let me recover the RAM the helper word names and links had occupied.  In this one, though, I don't bother - I just remove them from the linked list.
2023-08-17 08:34:35 <KipIngram   > One advantage of that is that the names are still there for decompiling (SEE).
2023-08-17 08:35:10 <KipIngram   > SEE can still find those words; it's just that FIND can't anymore.
2023-08-17 08:36:26 <KipIngram   > me just jumps back to the most recently named point in the code.  So where I have me in .words, it's equivalent to typing .words and letting tail optimization turn that into a jump.
2023-08-17 08:37:01 <KipIngram   > Having a special word for it, though, lets me have conditional versions of the same idea - e.g., 0=me etc.
2023-08-17 08:38:15 <KipIngram   > All of those me words require an offset following them, just like any jump does.  There's a bit in the header for that too - the compiler checks when it compiles a word if that bit is set, and if it is it compiles the offset back to the most recent labeled point.
2023-08-17 08:38:40 <KipIngram   > Kept me from having to have me be immediate and then a (me) runtime for it and so on.
2023-08-17 08:39:22 <KipIngram   > Because I probably have a few dozen conditional me words, and I'd have had to do that immediate dance for each one of them otherwise.
2023-08-17 08:39:52 <KipIngram   > If I wanted to compile a new word foo that needed an offset after it, I'd say
2023-08-17 08:39:56 <KipIngram   > : foo ... ; LOOP
2023-08-17 08:40:34 <KipIngram   > LOOP sets that "compile an offset" bit.
2023-08-17 08:41:45 <KipIngram   > And to get the offset I say HERE CURR @ @ PFA -
2023-08-17 08:41:53 <KipIngram   > Or something pretty close to that.
2023-08-17 08:43:48 <KipIngram   > You know, I've never written a code-threaded Forth, but this pseudo-F18A system is effectively going to be one.
2023-08-17 08:59:31 <xelxebar    > Ah, the implementation of { } makes so much sense.
2023-08-17 09:01:07 <xelxebar    > } also has to also restore the FP, right? Otherwise the return stack would have trash on top.
2023-08-17 09:52:14 <KipIngram   > Yes, they were VERY simple primitives.
2023-08-17 09:52:37 <KipIngram   > I added that feature to get the ability to index into the stack in a way that didn't "change" everytime I added or removed something from the stack.
2023-08-17 09:52:52 <KipIngram   > Once I open a frame, all my stack cells are accessible in a fixed and consistent way.
2023-08-17 09:53:11 <KipIngram   > The "clean up leftovers" aspect was an unexpected fringe benefit, but now I often use frames just for that.
2023-08-17 09:56:43 <KipIngram   > Instead of IF ... THEN etc., I use my conditional returns for control flow manipulations.  I have both conditional single level return and conditional double level return, so fairly I often I find I have multiple ways up and out of a call structure.  I wind up back at the top level with an uncertain amount of stuff on the stack.  Or, rather, it's OKAY if that happens, because just by using a stack frame
2023-08-17 09:56:44 <KipIngram   > around that call I can guarantee proper cleanup.
2023-08-17 09:56:51 <KipIngram   > Regardless of which path out I followed.
2023-08-17 09:57:54 <KipIngram   > So it makes the code in those structures simpler, since all the different pieces don't have to fret over creating a stack situation that's consistent with all the other paths.
2023-08-17 10:00:06 <KipIngram   > It creates some restrictions too, though - obviously, you can't return from inside a stack frame.
2023-08-17 10:00:39 <KipIngram   > The { and } have to be in the same definition, and once you run { you have to run }
2023-08-17 10:01:12 <KipIngram   > xelxebar: I have another variation of that theme - {| and |}.
2023-08-17 10:01:28 <KipIngram   > That one lets me return from arbitrarily deep in a call structure.  Like so:
2023-08-17 10:01:44 <KipIngram   > : foo  {| call |} ;
2023-08-17 10:01:50 <KipIngram   > <lots of call levels here>
2023-08-17 10:02:00 <KipIngram   > : bar  ... |} ;
2023-08-17 10:02:57 <KipIngram   > If bar executes |}, then when it executes it's ; it's tantamount to executing the ; in foo.
2023-08-17 10:03:11 <KipIngram   > its
2023-08-17 10:03:48 <KipIngram   > Control goes back to foo's caller - all those intervening layers are just "leapt over."
2023-08-17 10:03:58 <KipIngram   > I only use it in one place in my code - in FIND.
2023-08-17 10:04:12 <KipIngram   > For the case when I actually find the word, way down deep in nested loops.
2023-08-17 10:06:38 <KipIngram   > https://pastebin.com/P9YeQfqK
2023-08-17 10:07:38 <KipIngram   > All those middle lines are for looping over a vocabulary list, looping over words in a vocabulary, and doing all the individual name match checks.
2023-08-17 10:07:52 <KipIngram   > If I DON'T find the word, those loops run through and return up in the standard way.
2023-08-17 10:08:57 <KipIngram   > But if I DO find the word, all the way down there in .chrs - well, then I want out as fast as possible.  Instead of having to percolate that success back up, and have all the middle laters be able to deal with that, the |} in .chrs causes the next return to return from FIND itself, where the upper |} is.
2023-08-17 10:09:32 <KipIngram   > To be clear, |} itself doesn't cause a return - I still execute the ; in .chrs
2023-08-17 10:09:45 <KipIngram   > But the return stack has been fixed up so that that is a return from FIND.
2023-08-17 10:11:04 <KipIngram   > In this case the simplification to the code (which is significant) is that the middle layer words don't have to be smart enough to handle the success case.
2023-08-17 10:11:19 <KipIngram   > That's a pretty big simplification.
2023-08-17 10:32:12 <KipIngram   > I think a theme in these topics is that Forth offers some very unique "opportunities" for doing things in ways that you can't do in other languages.  IF ... THEN is really just kind of mimicking control flow offered by other languages.  But these conditional returns represent a way of doing things that other languages just can't do, and in some cases it makes for simpler solutions.  I think in general
2023-08-17 10:32:14 <KipIngram   > tinkering with the return stack is the source of most of these things.
2023-08-17 10:32:35 <KipIngram   > Even words like COMPILE wind up using the return stack in clever ways.
2023-08-17 10:33:56 <KipIngram   > I was fretting quite a lot one night about how to implement compile because I was overlooking that - one of you guys pointed it out to me, and then it was just immediately done because it became easy.  And I felt silly for having overlooked it.
2023-08-17 12:28:29 <KipIngram   > I'm giving thought to the idea of caching the top of the return stack in a register, as well as the top of the data stack.
2023-08-17 12:28:51 <thrig       > maybe not on a register starved system
2023-08-17 12:32:03 <KipIngram   > In the F18A, the ex instruction  (execute) is implemented by just swapping the instruction register and the top of return stack.
2023-08-17 12:32:19 <KipIngram   > I.e., it "executes" from the *return* stack instead of from the data stack.
2023-08-17 12:32:46 <KipIngram   > And we know  Chuck *used* to do it from the data stack, so he must have thought about that change and had a reason for it.
2023-08-17 12:34:00 <KipIngram   > It's kind of neat - sometimes depending on your system design execute takes at least a bit of tinkering, but it doesn't get much easier than an xchg instruction.
2023-08-17 13:32:11 <KipIngram   > thrig: I agree; I won't be trying in my x64 system.  I'm already close enough to using up all the regs.  I think this one's going to take less, though, due to it's altered architecture.
2023-08-17 13:38:14 <KipIngram   > So, that would be four regs for stacks; two pointers and two top items.  We need an IP (5), and in this design I will need an IW (instruction word) (6).  Then I have my special pointers, FP and EP, so (8).  Then I will need A and B address regs (10).  I have to have at least one scratch register to run the VM (11).  I will need a "tick" register for my multi-threading (12).  And I may want a "system base"
2023-08-17 13:38:16 <KipIngram   > pointer; depends on how things go.  So 13.  I think that's it; the processor has 16 registers, so that's three spare.
2023-08-17 13:38:48 <KipIngram   > Oh, I'll need an active thread pointer, so 14.
2023-08-17 13:39:18 <KipIngram   > On the one hand, getting too close to nothing left doesn't seem good, but on the other hand, part of me figures if I have good uses for them that promote  performance, then why not?
2023-08-17 13:39:34 <KipIngram   > I mean, why leave them sitting around unused?
2023-08-17 14:00:00 <vms14       > veltas: I've had a posix adventure some time ago because I was reinstalling netbsd when the router died, so I was stuck with what I had in base
2023-08-17 14:00:19 <vms14       > I've played a bit with awk and saw a lot of potential, specially when mixed with sh
2023-08-17 14:00:45 <vms14       > I see both can generate programs for the other, and this kind of metaprogramming can be nested several levels
2023-08-17 14:01:06 <vms14       > awk has a lot of potential, but needs sh or something more as a glue
2023-08-17 14:01:25 <vms14       > I wanted to use both to create something, but I've realized that something is perl
2023-08-17 14:02:35 <vms14       > actually that's what larry wall seems to have wanted when he created perl, as perl is awk, sh and sed
2023-08-17 14:03:11 <vms14       > still, I thought it was cool for my lang to have a word named awk, that does what awk does
2023-08-17 14:03:55 <vms14       > for example we can get the output from a shell command on the stack by using the 'command' word
2023-08-17 14:04:32 <vms14       > " ls -l" command
2023-08-17 14:04:52 <vms14       > I have an awk word that expects a string and code from the stack
2023-08-17 14:06:36 <vms14       > " ls -l" command [ .*\.oh [ 0: .cr ] ] awk
2023-08-17 14:07:00 <vms14       > it expects a list of regex and code, you can put several pairs of regex and code
2023-08-17 14:07:28 <vms14       > [ [ regex [ some code ] other-regex [ more code ] ... ] awk
2023-08-17 14:07:52 <vms14       > I have an awk* word that works the same, but also expects a separator to use instead of space, for splitting the lines
2023-08-17 14:08:11 <vms14       > the code will have available the variables 0, 1, 2, 3...
2023-08-17 14:08:48 <vms14       > I think this is the whole functionality of awk
2023-08-17 14:09:06 <vms14       > well I was missing something but I don't remember what xd
2023-08-17 14:13:15 <vms14       > it's broken on the file I gave, I'm fixing it
2023-08-17 14:13:16 <KipIngram   > vms14: I think it's interesting comparing our "ways of focusing."  You like taking these sophisticated tools and mashing them up with one another - I like to get down as absolutely close to the metal as I possibly can, with as little reliance on the work of others as possible.
2023-08-17 14:13:32 <vms14       > KipIngram: yeah, it's the day and the night
2023-08-17 14:13:41 <vms14       > I cheat and go as dirty as possible
2023-08-17 14:14:17 <vms14       > but I focus on being practical, as perl is
2023-08-17 14:14:32 <vms14       > or better said, to steal the features of perl that make it practical
2023-08-17 14:15:13 <vms14       > and I'd like types, but I'd also like to have oop blended with perl's oop as much as possible
2023-08-17 14:16:05 <vms14       > I had something that made perl classes and they were available from the perl side
2023-08-17 14:16:29 <vms14       > but I think this is for the next rewrite, doing this stuff I realized I don't have to write the words like I do now
2023-08-17 14:16:59 <vms14       > I can automate a lot of parts of their definitions, like define words that take 1 element and return one element
2023-08-17 14:17:32 <vms14       > does not matter how many elements they take or return, I just need to take that number as parameter to a function
2023-08-17 14:17:55 <vms14       > and a lot of those words are bindings to a native perl function, this can also be automated
2023-08-17 14:18:04 <DKordic     > KipIngram, vms14: Perlisism 58.
2023-08-17 14:18:20 <vms14       > in a way that I just need to type the names and the bindings will be generated
2023-08-17 14:18:27 <KipIngram   > I'm a hardware guy by training, and am interested in building hardware things - I want to be able to work well with them, and I won't have an OS or anything like that to help me.
2023-08-17 14:18:42 <vms14       > KipIngram: I'd like to get to that side some day
2023-08-17 14:19:03 <vms14       > for now I'd like to explore a bit more the "high level"
2023-08-17 14:19:10 <vms14       > and get a bit better
2023-08-17 14:19:25 <vms14       > but I always wanted to learn about hardware
2023-08-17 14:19:38 <vms14       > and I have a strange love for embedded devices
2023-08-17 14:20:09 <KipIngram   > I'm very infatuated with the MAX32655 right now.  Nice and easy to mount on a larger circuit board, and for just $30 it packs an amazing array of peripherals and functions.
2023-08-17 14:20:12 <vms14       > also the electronic components and wires look like gold to me xD
2023-08-17 14:20:45 <KipIngram   > What I've got planned is to do the work to support those peripherals just once, on that little small board, and then have it ready to roll, whereever I "drop it in."
2023-08-17 14:20:48 <vms14       > KipIngram: how can make you a serial programmer to program a chip?
2023-08-17 14:20:56 <KipIngram   > Heh heh.
2023-08-17 14:21:07 <KipIngram   > I used to be VP of Engineering for a programmer manufacturing company.
2023-08-17 14:21:16 <KipIngram   > So I can tell you a little about that.
2023-08-17 14:21:17 <vms14       > :0
2023-08-17 14:21:31 <KipIngram   > It's pretty easy these days - most parts that are programmable will almost let you just write the data in.
2023-08-17 14:21:53 <KipIngram   > Back in those days there were delicate timing requirements, and in many cases you had to generate rather precisely controlled voltage and current waveforms.
2023-08-17 14:22:08 <KipIngram   > That was what the hardware of our programmers did.
2023-08-17 14:22:28 <KipIngram   > And we had a custom programming language for controlling it.  A high level language we wrote our proramming algorithms in.
2023-08-17 14:22:52 <KipIngram   > That way when we did a new model prorammer, we could just change the code generator in the compiler for that language, and all of our algorithms would then run on that new programmer.
2023-08-17 14:23:06 <KipIngram   > We had support for somewhere around 11,000 parts at the time I left.
2023-08-17 14:23:51 <vms14       > so it was more like a config lang?
2023-08-17 14:24:07 <vms14       > like set this time rate, set this voltage, etc
2023-08-17 14:25:40 <vms14       > I have to learn from the start about everything first
2023-08-17 14:25:58 <vms14       > I just have a very basic general idea
2023-08-17 14:26:16 <vms14       > I'm hungry and there's no food, so I'll go buy
2023-08-17 14:26:20 <vms14       > see you :D
2023-08-17 14:27:25 <KipIngram   > It was similar to C, but with operators and constructs chosen to suit the programming task.
2023-08-17 14:27:38 <KipIngram   > We called it DPL.  Device Programming Language.
2023-08-17 14:28:01 <KipIngram   > I had a whole crew of guys that did nothing but write DPL code for one device after another.
2023-08-17 14:28:44 <KipIngram   > The a group of hardware guys, who did the prorammer electronics and also the pick and place machines we built from scratch for out automated programmers.
2023-08-17 14:29:15 <KipIngram   > And then the "regular software" guys who wrote the GUI that ran it all and the embedded code that was sort of the "programmer OS."
2023-08-17 14:29:39 <KipIngram   > It was nice diverse work - on the PnP side there was motion control, machine vision, etc.
2023-08-17 14:30:05 <KipIngram   > I wrote most of the machine vision stuff myself.
2023-08-17 14:30:32 <KipIngram   > I was very "hands on" and involved, but I had the perk of being able to cherry pick what pieces of the work I wanted to do.
2023-08-17 14:31:27 <KipIngram   > I enjoyed the motion control and vision parts, and on the hardware side I kept to "non-analog" work, because there were better guys there to do that than me.
2023-08-17 14:33:50 <KipIngram   > I'm not entirely ignorant about analog stuff, but I'm definitely nO "master."
2023-08-17 14:34:06 <thrig       > humans are pretty digital
2023-08-17 14:35:00 <KipIngram   > I do think of myself as at least near "master level" on digital.  Perhaps out of practice, though, and behind the times.
2023-08-17 14:35:24 <KipIngram   > I'd stopped doing that kind of work to a large extent by the time Verilog came along, and that's pretty much how it's all done these days.
2023-08-17 14:35:34 <KipIngram   > I've known a couple of guys I regard as analog masters, though.
2023-08-17 14:35:58 <KipIngram   > The guy who owned that programmer company was the best I've ever seen, but a guy on my team at a seismic company later was right up there too.
2023-08-17 14:38:15 <KipIngram   > I was hired as VP of Engineering at the seismic company too.  Politics there were brutal, though - my predecessor was still there, and he was at war with the CEO.  He had a lot of pull with the board, and eventually he beat the CEO down, and that was kind of it for me there.
2023-08-17 14:38:34 <KipIngram   > I left after a while to manage the software engineering team at the company that IBM bought shortly after I hired on.
2023-08-17 14:39:03 <KipIngram   > And that turned out to be a great move, because I made a nice wad of money on that deal with IBM.
2023-08-17 14:39:29 <KipIngram   > Which I needed to pay for some expensive medical care for one of my daughters, so... funny how things work out sometimes.
2023-08-17 14:40:10 <KipIngram   > If I *hadn't* made that move and gained access to that acquisition payoff, I don't know if we could have afforded that care.
2023-08-17 14:40:34 <KipIngram   > So it's funny how even things that seem like negatives at first can turn out to be exactly best.
2023-08-17 14:41:16 <KipIngram   > Ah, looks like LK-99 is NOT a superconductor.
2023-08-17 14:41:32 <KipIngram   > https://www.nature.com/articles/d41586-023-02585-7
2023-08-17 14:41:45 <KipIngram   > How embarrassing.
2023-08-17 14:42:06 <thrig       > Captain Hook, meanwhile, is less digital
2023-08-17 15:13:38 <vms14       > 
ACTION has food now

2023-08-17 15:22:22 <KipIngram   > Food is a good thing to have.
2023-08-17 15:22:36 <KipIngram   > FOOD @ MOUTH !
2023-08-17 15:27:12 <vms14       > XD
2023-08-17 15:27:21 <vms14       > But now I don't have money
2023-08-17 15:27:41 <vms14       > And I have to survive with 40 euros until day 30
2023-08-17 15:28:59 <vms14       > Actually I should do something to win money trough programming
2023-08-17 15:33:25 <KipIngram   > Oh man.  That's nearly two weeks.
2023-08-17 15:33:39 <KipIngram   > I see ramen in your future...
2023-08-17 15:34:12 <KipIngram   > I had a number of ramen and spam periods in college.  :-|
2023-08-17 15:36:32 <thrig       > food desert, food dessert
2023-08-17 15:38:25 <KipIngram   > Back then you could get a ramen pack for a dime.
2023-08-17 15:42:18 <thrig       > and, somehow, adult onset diabetes
2023-08-17 15:42:50 <thrig       > which is happening to 295 pound 11 year olds these days
2023-08-17 15:49:08 <KipIngram   > Well, kids "play" hunkered over a computer instead of outside with the grass under their scurrying feet.  Go figure.
2023-08-17 15:54:00 <gordonjcp   > heh
2023-08-17 15:54:26 <gordonjcp   > I remember watching some terrible TV programme, it was long enough ago that the tail end of it was at the start of something I'd taped off-air on real VHS tape
2023-08-17 15:54:38 <gordonjcp   > some hellish show like "Britain's Fattest Toddlers"
2023-08-17 15:54:58 <gordonjcp   > and they were on about this wee lad who was 3, same age as my son is now, I guess he'd be in his 20s now? maybe 30s
2023-08-17 15:56:59 <gordonjcp   > anyway they were making a lot of the fact that he weighed about 40kg, roughly twice the average weight of a 3-year-old
2023-08-17 15:58:07 <gordonjcp   > what they didn't point out was that he was roughly 1/3 as tall again as the average 3-year-old and bigger than most 6-year-olds
2023-08-17 15:58:52 <gordonjcp   > and his mum and dad were massive, like his dad was about 6 foot eight tall wide and deep and his mum was about 6'4" and looked like a fucking Valkyrie
2023-08-17 16:05:18 <KipIngram   > Yeah, that sounds a little "less than fully fair."  Volume goes as the cube of scale, so (4/3)^3 is 64/27, which is going on 2.5x.  So if he was double the average weight of a three year old, then he was actually on the light side.
2023-08-17 16:49:12 <KipIngram   > Wow.  Apparently tennis adds more years to the average person's life than any other sport they can engage in.
2023-08-17 16:49:24 <KipIngram   > An extra 9.7 years, for active players.
2023-08-17 16:49:53 <thrig       > competitive volcano diving, meanwhile,
2023-08-17 16:49:57 <KipIngram   > Somehow that makes sense to me.  It moves you around enough to qualify as aerobic, so you get that, but then also pings you fast twich muscles and so on.
2023-08-17 16:51:14 <KipIngram   > your
2023-08-17 16:51:39 <KipIngram   > twitch
2023-08-17 16:52:29 <KipIngram   > Lot of older folks aren't active enough to keep their legs in good enough shape to safely  hold them up - eventually they start falling and so on.  Tennis would help in all kinds of ways for that.
2023-08-17 16:52:59 <KipIngram   > I mean, I could see it helping for that in a way that just steady jogging didn't.
2023-08-17 16:54:33 <thrig       > swinging the racket probably activates more core body muscles
2023-08-17 16:59:40 <KipIngram   > Yes.
2023-08-17 17:00:30 <KipIngram   > I've been thinking heavy bag workouts would probably be awfully good to.  You can get your whole body into that too, and if you do good footwork it also gets aerobic pretty darn fast.
2023-08-17 17:00:46 <KipIngram   > And engages explosive upper and lower body work.
2023-08-17 17:01:26 <KipIngram   > Plus it might happen to help you if you ever needed to get someone to stop harassing you.
2023-08-17 17:01:47 <AndyAndyBoBandy> In Factor, I'm looking at math.combinatorics, but not finding a way to generate k-tuples, or permutations with repetition. Anyone know if/where/what?
2023-08-17 17:02:03 <KipIngram   > My guess is that most guy don't really know how to land a solid punch.  I don't, but I think I could improve that with practice.
2023-08-17 17:02:19 <KipIngram   > Juts the timing of it all; pushing your shoulders and body into at just the right time and so on.
2023-08-17 17:02:28 <KipIngram   > guys
2023-08-17 17:03:08 <KipIngram   > Heck, just having your fist at the right angle, so you don't break your hand or something.
2023-08-17 17:03:51 <KipIngram   > I just don't see someone getting all that together on the fly withoug having worked at it.
2023-08-17 17:04:00 <KipIngram   > Especially under pressure.
2023-08-17 17:05:10 <KipIngram   > I bet that if you took a random sampling of guys off the street and somehow "measured" their punching effectiveness, and then took another group that had just a single month of regular training, there would be a huge difference.
2023-08-17 17:05:56 <KipIngram   > And if you wanted to rule out just strength improvement, you could take another group that had spent the mongh lifting weights.
2023-08-17 17:06:19 <KipIngram   > That sounds like worthy paper - wonder if anyone's ever done that?
2023-08-17 17:26:02 <veltas      > If I had 40 euros for food I'd buy pasta and cans of tomato and have some boring meals
2023-08-17 17:26:39 <veltas      > Not too bad though, if you've got spices or herbs
2023-08-17 17:26:52 <veltas      > And water and fuel to heat water.....
2023-08-17 17:32:59 <thrig       > lentils!
2023-08-17 17:33:14 <thrig       > also you can do pasta in cold water, it just takes longer, etc
2023-08-17 17:40:41 <veltas      > Yeah lentils, oats
2023-08-17 17:42:45 <veltas      > Beans on toast can be quite cheap
2023-08-17 17:42:53 <veltas      > Now we're eating British lol
2023-08-17 17:42:59 <veltas      > Bread sandwich
2023-08-17 18:05:13 <KipIngram   > Yeah, if you know how to sling some spices around you can get by with a modicum of style.
2023-08-17 18:05:38 <KipIngram   > A reasonable degree of cooking skill is a good thing to have on tap.
2023-08-17 18:05:47 <KipIngram   > Impresses the ladies too.
2023-08-17 18:06:03 <thrig       > some rather prefer to have the beer on tap
2023-08-17 18:06:12 <KipIngram   > Stable job AND you can cook?  Box checked...
2023-08-17 18:06:43 <KipIngram   > I actually get around in the kitchen better than my wife does.  :-)
2023-08-17 18:07:19 <KipIngram   > I scooped her up when she was just 22, during her last semester of college - she didn't have time to build those skills "out in the world."
2023-08-17 18:08:00 <KipIngram   > I was 33, and I'll admit I was insufferably smug about the whole thing.
2023-08-17 18:08:05 <thrig       > or norms have broken down so old grannies are giving the family cookbook to the man instead
2023-08-17 19:27:22 <KipIngram   > Soeaking of cooking, I made a thing tonight called "Cajun Cabbage Skillet."  Chicken sausage, cabbage, onions, and apples spiced an skillet sauteed.  I haven't had mine yet, but my wife said it was good and went back for seconds.
2023-08-17 19:27:41 <KipIngram   > https://www.foodnetwork.com/recipes/food-network-kitchen/cajun-cabbage-skillet-7995934
2023-08-17 19:28:18 <KipIngram   > And it was easy.  I pre-cut everything this afternoon, off and on in between work stuff; when it came time to cook it it went really fast and only involved the one pot.
2023-08-17 20:28:06 <xelxebar    > Lol. SmithForth's return stack is rsp, so EXIT is implemented with literally just a single-byte opcode.
2023-08-17 20:29:05 <xelxebar    > Figuring out what standard Forth words mean by simply reading the source is actually turning out to be quite fun.
2023-08-17 20:51:21 <xelxebar    > Don't understand this, though:
2023-08-17 20:52:13 <xelxebar    > : #IN  1 1C LSHIFT ; / quad at 0x10000000
2023-08-17 20:52:27 <xelxebar    > : stack)  #IN ;
2023-08-17 20:54:26 <xelxebar    > Why the extra indirection? Anywhere you use "stack)", wouldn't it be better to just use "#IN"?
2023-08-17 20:54:55 <xelxebar    > For example:
2023-08-17 20:55:24 <xelxebar    > : DEPTH  SP@ stack) SWAP - 3 RSHIFT ;
2023-08-17 21:08:02 <unjust      > just for the sake of clarity/readibility, i'd guess. and you could also ask why : #IN 1 1C LSHIFT ; and not : #IN 10000000 ; ?
2023-08-17 21:11:50 <xelxebar    > Oh! Duh. Yeah, The stack grows down from #IN, so it's just an alias for documentation or whatever.
2023-08-17 21:12:47 <xelxebar    > Is the trailing ")" a common idiom? KipIngram mentioned above some convention about parenthesized and unparenthesized pairs of words.
2023-08-17 21:16:39 <unjust      > not sure about trailing ) sorry, but it's not uncommon to see words that have names wrapped in parentheses and from what i've gathered they often implement the logic behind an unparenthesized facade
2023-08-17 21:19:36 <unjust      > i think this is the concept i'm getting @ https://www.complang.tuwien.ac.at/forth/gforth/Docs-html/Deferred-Words.html
2023-08-17 21:21:54 <KipIngram   > xelxebar: First, the trailing ) doesn't "do" anything - it's just a character in the name.  The name chars have no effect on functionality at all in Forth.
2023-08-17 21:21:57 <KipIngram   > But...
2023-08-17 21:22:14 <KipIngram   > Sometimes compiling a features requires "custom actions" that the compiler doesn't know to do.
2023-08-17 21:22:22 <KipIngram   > Like IF ... THEN
2023-08-17 21:22:31 <KipIngram   > That actually gets compiled as conditional jumps.
2023-08-17 21:22:50 <KipIngram   > IF and THEN are 'immediate' words that execute at compile time, regardless of being inside : ... ;
2023-08-17 21:22:59 <KipIngram   > Their action is to compile the necessary stuff.
2023-08-17 21:23:06 <KipIngram   > Kind of a "custom compiler extension."
2023-08-17 21:23:16 <KipIngram   > Sometimes you have words like ." and (.")
2023-08-17 21:23:31 <KipIngram   > ." is immediate, and it compiles everything needed to get the right function at compile time.
2023-08-17 21:23:47 <KipIngram   > That includes compiling a call to (.") followed by the counted string to be printed.
2023-08-17 21:23:59 <KipIngram   > Then at runtime (.") prints the string and jumps the IP over it.
2023-08-17 21:24:27 <KipIngram   > It's just a mild "convention" in some cases like that to have <word> be the immediate compile time word and (<word>) to be the runtime that gets compiled.
2023-08-17 21:24:40 <KipIngram   > It's just a "pseudo-convention."
2023-08-17 21:24:44 <KipIngram   > Not "official" or anything.
2023-08-17 21:28:49 <KipIngram   > That convention isn't followed by IF.  The runtime isn't (IF) (though it could be and maybe is in some systems).  It's usually 0JMP or something like that.
2023-08-17 21:29:34 <KipIngram   > I don't remember actually talking about this before in a general way, though I might have done some examples where I followed the convention.
2023-08-17 23:24:02 <xelxebar    > Clear as day. Thanks. Interesting that the "primary" (read shorter) form is the immediate one.
2023-08-17 23:25:36 <xelxebar    > I'd guess that means these word pairs tend to be mostly used when defining words, so runtime usage is relegated to the longer (..) form.