2023-08-14 00:19:13 <KipIngram   > Well, I seem to be arriving at a newfound appreciation for Bohm's version of quantum theory, particularly as "packaged" by John Bell.
2023-08-14 00:19:27 <KipIngram   > It really does remove a lot of the "woo factors."
2023-08-14 00:20:24 <KipIngram   > The common objection to it is that it doesn't extend to relativistic circumstances, but Tim Maudlin says it will - that all you need is to impose a "foliation" on spacetime (some way of slicing it up into planes).
2023-08-14 00:20:32 <KipIngram   > I need to dig into that, though.
2023-08-14 00:21:28 <KipIngram   > The initial criticism of the theory (known as pilot wave theory) was that it was non-local.  But Bell showed in the 1960's that any theory that reproduces the predictions of mainstream quantum theory is non-local, so we're stuck with that no matter what.
2023-08-14 00:21:57 <KipIngram   > The experiments confirming Bell's work won last year's Nobel prize.
2023-08-14 00:28:22 <KipIngram   > Wow - season 4 of Magnum PI sure has a lot of "fluff" episodes.
2023-08-14 05:00:42 <xelxebar    > Dang. SmithForth's dictionary contains about 400 definitions.
2023-08-14 05:02:22 <xelxebar    > Looks like it implements the full Forth 2012 core dictionary.
2023-08-14 05:41:59 <next4th     > xelxebar: oh, that's cool!
2023-08-14 05:47:19 <next4th     > i think i got what 'cmp al, 60' (graphic?) means in SmithForth; for last 7 bits, an inline compile/exec word will have [32:127], while a new word definition will have [0:31]...
2023-08-14 05:51:53 <xelxebar    > next4th: Yeah, it's a whole lot to ingest. Having to take it slowly.
2023-08-14 05:56:36 <xelxebar    > next4th: You talking about the A8 60 bytes at the beginning?
2023-08-14 05:57:16 <next4th     > no, it's 3c60 in bi
2023-08-14 05:57:58 <next4th     > ah, you're right, it's a680..
2023-08-14 05:58:26 <veltas      > vms14: It wasn't literally nothing it was like £260
2023-08-14 05:58:46 <next4th     > um, a860, i must tired of the work!
2023-08-14 05:59:21 <veltas      > vms14: I use without keyboard, a keyboard would make it much better probably
2023-08-14 05:59:56 <xelxebar    > Yeah, at that point in the code we've just parsed a 99 byte, right?
2023-08-14 06:00:09 <vms14       > Ah, i thought you mean for nothing in the sense of you didn't use it at the end
2023-08-14 06:00:20 <vms14       > That's cool
2023-08-14 06:00:43 <xelxebar    > And the 99 byte has 2 different meanings: 1. define a new word, or 2. execute an existing word.
2023-08-14 06:02:02 <xelxebar    > That test effectively disambiguates between the two usages. As you noticed, for all printable (i.e. graphic) ascii characters, the 0110 0000 bits are set.
2023-08-14 06:03:05 <xelxebar    > Otherwise, we interpret the byte as a string length, which that test implicitly limits to 31 characters long.
2023-08-14 06:04:59 <xelxebar    > I finally understood the implementation of EXEC.
2023-08-14 06:05:31 <next4th     > yes, that's not clear to me before today :)
2023-08-14 06:06:34 <xelxebar    > SmithForth uses rsp as the return stack, which is why it EXEC trampolines through a call written to 0x7ffffff8.
2023-08-14 06:06:50 <xelxebar    > Right?
2023-08-14 06:07:42 <next4th     > i don't know, haven't reach that point..
2023-08-14 06:09:04 <xelxebar    > next4th: How are you coming along with the x86-64 opcodes? Find any other nice mnemonics or patterns?
2023-08-14 06:12:46 <xelxebar    > Generic Forth question: Is there a convention on which words have commas appended to them?
2023-08-14 06:13:30 <xelxebar    > I'm not grokking why things like "COMPILE," have the trailing comma.
2023-08-14 06:13:31 <next4th     > um, try to memorize mod-reg-r/m and sib, and i think i forget some opcodes, only 00-3F, B0-BF, C3, 48, 66 i can come up now..
2023-08-14 06:14:35 <next4th     > i think comma is for put data at HERE, and inc HERE
2023-08-14 06:14:55 <xelxebar    > Oh, nice. Solid progress.
2023-08-14 06:15:07 <xelxebar    > Oooo... That's interesting. Thanks.
2023-08-14 06:15:17 <xelxebar    > Argh... Gotta run.
2023-08-14 07:35:48 <KipIngram   > xelxebar: I'd expect a trailing comma to indicate that the word ticks something into the dictionary.
2023-08-14 07:36:15 <KipIngram   > That's what a stand-alone , word does; it takes the value to add to the end of the dictionary from hte stack.
2023-08-14 07:37:15 <KipIngram   > next4h's answer was more precise, I think.
2023-08-14 07:38:48 <KipIngram   > Just to be a little pedantic, HERE usually isn't itself a variable, so technically you're not incrementing it.  I've usually seen that the variable is called DP, and then you have : HERE  DP @ ;
2023-08-14 08:46:44 <dave0       > KipIngram: i learned that HERE and ALLOT are like they are ... not variables .. in case someone uses a register to point to the memory
2023-08-14 08:47:56 <dave0       > so here could be like    push r11    and allot could be     pop r0 ; add r11,r0
2023-08-14 08:48:19 <KipIngram   > Hi dave0 - haven't seen you in a while.
2023-08-14 08:48:51 <KipIngram   > That makes sense.  Seems like an odd thing to use a register for, but sure.
2023-08-14 08:49:24 <KipIngram   > ALLOT is overtly a verb, though - it has a decisive action associated with it, so it clearly can't itself be a variable.
2023-08-14 08:49:44 <KipIngram   > HERE behaves more like a constant, though.
2023-08-14 08:49:55 <KipIngram   > (a constant that changes, of course).
2023-08-14 09:20:13 <veltas      > Other reasons HERE is not a variable is probably just efficiency / brevity of writing HERE instead of HERE @
2023-08-14 09:20:26 <veltas      > In a lot of old Forths HERE is : HERE H @ ;
2023-08-14 09:21:15 <veltas      > In newer Forths often HERE is a VALUE
2023-08-14 09:23:56 <veltas      > And also modifying HERE without the correct dictionary words is extremely dodgy, ALLOT might do bounds checking or request an allocation for a desktop forth
2023-08-14 09:26:27 <veltas      > And then also in multi-tasking forths HERE might access a USER variable
2023-08-14 09:52:20 <KipIngram   > Yeah, just that convenience of being able to say HERE is what has always seemed like the primary advantage to me.
2023-08-14 09:53:11 <KipIngram   > And yeah again - you certainly need to know what you're doing when you go manually do that stuff.
2023-08-14 10:01:41 <vms14       > Any tip to write clean forth code?
2023-08-14 10:02:32 <vms14       > My toy lang is not a forth, but it's also concatenative and I kind of worry about the readability
2023-08-14 10:02:54 <vms14       > I had some scripts written in my own lang that were hard to understand with the time
2023-08-14 10:03:56 <vms14       > My lang is mostly a lisp in disguise
2023-08-14 10:03:59 <vms14       > https://termbin.com/o21r2
2023-08-14 10:04:08 <vms14       > This is some shitty cgi I made
2023-08-14 10:06:59 <vms14       > Magic.hash is a persistent hash table that uses the berkeley db underneath
2023-08-14 10:10:31 <veltas      > vms14: That code looks fine
2023-08-14 10:10:56 <vms14       > https://www.reddit.com/r/Forth/comments/2a4zi4/examples_of_great_forth_code/
2023-08-14 10:11:50 <veltas      > The WASHER example there I've got on a mug
2023-08-14 10:12:06 <veltas      > One way of making Forth nice is to turn it into plain english like that
2023-08-14 10:13:38 <vms14       > Yeah I saw some examples trying to mimic pseudocode
2023-08-14 10:14:11 <vms14       > But for example my lang has a lot of funny symbols
2023-08-14 10:14:26 <vms14       > And I think the next time I'm going to add types
2023-08-14 10:14:43 <vms14       > I do weird things with strings because I don't have a string type
2023-08-14 10:15:12 <vms14       > And sometimes I take them as word names and some times as a string
2023-08-14 10:15:51 <vms14       > [ " oh" ` oh` ] eval
2023-08-14 10:16:31 <vms14       > Both quote forms will add a string on that list, but [ does different stuff depending on which one is
2023-08-14 10:16:53 <vms14       > " oh" inside a list is to evaluate a string
2023-08-14 10:17:22 <vms14       > ` oh` inside a list would get evaluated as the word oh
2023-08-14 10:17:29 <KipIngram   > vms14: I think it's something that just comes with practice.
2023-08-14 10:17:52 <KipIngram   > I try to keep my words very short - order of 40-50 characters per def.
2023-08-14 10:18:09 <KipIngram   > But, I tend to use short word names too - if I used verbose names then the defs would be longer.
2023-08-14 10:18:32 <vms14       > I like verbose names because they help making it more descriptive
2023-08-14 10:18:49 <KipIngram   > Yeah, different strokes.
2023-08-14 10:18:53 <vms14       > A nd can avoid some confusion on the reader
2023-08-14 10:19:17 <KipIngram   > Probably better to say I try to keep definitions down to a "short term memory" number of words in the def.
2023-08-14 10:19:20 <vms14       > I've learned short code has nothing to do with names, but with algorithm
2023-08-14 10:19:23 <KipIngram   > 7-10 words.
2023-08-14 10:19:43 <vms14       > Anyways I didn't even learned how to use my lang properly
2023-08-14 10:19:50 <vms14       > But I like it
2023-08-14 10:19:52 <KipIngram   > I want to be able to easily look at a definition and hold the whole thing in my mind at once.
2023-08-14 10:20:02 <vms14       > I've stolen what I like from forth and lisp
2023-08-14 10:20:09 <vms14       > Colon words stack concatenative
2023-08-14 10:20:16 <vms14       > Lexical scope, macros
2023-08-14 10:20:40 <vms14       > It's a weird mix
2023-08-14 10:21:25 <vms14       > Kipingram did you make that editor?
2023-08-14 10:22:09 <vms14       > I think i could end needing to make one
2023-08-14 10:22:44 <vms14       > I want a phone with keyboard, I know of one which has a qwerty keyboard  but I don't think it will have alk the keys
2023-08-14 10:22:45 <KipIngram   > Yeah, I always write some kind of editor.  My current one is more of a line editor than a screen editor, but I've done screen-oriented ones in the past.
2023-08-14 10:23:04 <vms14       > Kipingram did you add ythat feature to jump to comments and alike?
2023-08-14 10:23:08 <KipIngram   > I have a quick command to re-print the block, and then I can select and edit lines.
2023-08-14 10:23:16 <KipIngram   > Oh, no - nowhere near that yet.
2023-08-14 10:23:26 <KipIngram   > I'm at a pretty basic level right now.
2023-08-14 10:23:50 <vms14       > But it's being written in your own language
2023-08-14 10:24:00 <KipIngram   > Yes; it's written in my Forth.
2023-08-14 10:24:09 <vms14       > :D that's super cool
2023-08-14 10:24:28 <vms14       > I get a lot of joy using my toy lang
2023-08-14 10:24:54 <vms14       > Still have to document it
2023-08-14 10:25:06 <KipIngram   > https://pastebin.com/GDppzVyX
2023-08-14 10:25:07 <vms14       > It would help me to realize some stuff also
2023-08-14 10:26:02 <vms14       > Looks like some kind of assembly
2023-08-14 10:26:12 <KipIngram   > :-)
2023-08-14 10:26:38 <KipIngram   > It leverages the guts of my EXPECT word, which was written with future editor leveraging in mind.
2023-08-14 10:27:17 <KipIngram   > In line 12 you see a call to the word edit.
2023-08-14 10:27:34 <KipIngram   > EXPECT calls edit, with things setup for an empty initial buffer.
2023-08-14 10:27:50 <KipIngram   > But edit is capable of working on an already filled buffer, and that's what it does in this editor.
2023-08-14 10:28:09 <KipIngram   > You can give it an initialized buffer and a starting cursor column.
2023-08-14 10:28:38 <vms14       > Your forth is an advanced one
2023-08-14 10:28:41 <KipIngram   > That cursor column feature was included to set up for moving arund vertically in a block under edit.
2023-08-14 10:28:54 <KipIngram   > Not terribly - it just has some non-standard words.
2023-08-14 10:29:07 <KipIngram   > It's really just a very straightforward indirect threaded Forth.
2023-08-14 10:29:19 <vms14       > But you have to learn forth properly to understand your lang
2023-08-14 10:29:38 <vms14       > And get the way things are done in forth
2023-08-14 10:29:44 <KipIngram   > Yes, you'd need to be familiar with Forth and then know about hte little different words I've added.
2023-08-14 10:29:56 <KipIngram   > Like my { ... } - that's not a standard feature at all.
2023-08-14 10:30:15 <vms14       > Because your forth seems to rely on the forth way of doing things
2023-08-14 10:30:19 <KipIngram   > And those conditional return and recurse words are non-standard.
2023-08-14 10:30:20 <veltas      > vms14: Normal approach for source code jumping is to store the source block number with a dictionary entry and just list that block when the user LOCATE's it
2023-08-14 10:30:25 <vms14       > Word by word
2023-08-14 10:30:27 <KipIngram   > Well, I hope it does.
2023-08-14 10:31:03 <KipIngram   > It was very much intended to be a *Forth*.
2023-08-14 10:31:05 <veltas      > With a file-based Forth you'd have to store the filename, line number, and list the source line and surrounding lines
2023-08-14 10:31:16 <veltas      > That's a lot more, the block approach is obviously ideal here
2023-08-14 10:31:42 <vms14       > veltas kipingram wants to separate comments from the source code
2023-08-14 10:31:56 <KipIngram   > vms14: I intend to use a b*tree for that.
2023-08-14 10:31:59 <veltas      > I'm doing that with shadow blocks
2023-08-14 10:32:03 <vms14       > But to somehow annotate the lines of the code so you can see the comments in another window or alike
2023-08-14 10:32:06 <KipIngram   > Nothing in the headers or anything for it.
2023-08-14 10:32:15 <KipIngram   > Right - that's the idea.
2023-08-14 10:32:33 <KipIngram   > When I'm editing a block, I will obviously know what block I'm editing and where I am in it.
2023-08-14 10:32:42 <KipIngram   > The b*tree will store links, that are easy to search.
2023-08-14 10:33:15 <veltas      > vms14: Shadow blocks are just the same block numbers at a large offset, i.e. shadow block for block 200 might be 1200. PolyForth can display a block with shadow block side-by-side
2023-08-14 10:33:20 <KipIngram   > The editor will just continuously check that b*tree to see if the cursor is in a linked region, and if it is it will follow the link and open a window with the region at the other end of the link in it.
2023-08-14 10:33:39 <vms14       > Veltas its like a memory page?
2023-08-14 10:33:43 <veltas      > vms14: For instance the TRIAD command if you want to look it up in the polyforth manual
2023-08-14 10:34:06 <veltas      > Not really like a memory page, not sure what you mean by that
2023-08-14 10:34:27 <vms14       > Like virtual memory faking contiguous space
2023-08-14 10:34:54 <veltas      > The comparison's not meaningful to me
2023-08-14 10:35:05 <vms14       > Why do you need a shadow block?
2023-08-14 10:35:17 <veltas      > So your source blocks can be contiguous
2023-08-14 10:35:34 <veltas      > With documentation far away, but each source block has an associated documentation block
2023-08-14 10:35:38 <veltas      > in its shadow block
2023-08-14 10:36:09 <vms14       > And this shadow block is to store additional info?
2023-08-14 10:36:11 <veltas      > Because you have commands like 200 210 THRU that load a range of blocks, or --> that loads the 'next' block contiguously
2023-08-14 10:36:25 <vms14       > So it's like a reserved region of memory for every block?
2023-08-14 10:36:54 <veltas      > Yeah but the source code is in low block numbers, so not 'every' block.
2023-08-14 10:37:09 <veltas      > It might be that most of your blocks have no shadow
2023-08-14 10:37:46 <veltas      > e.g. |Source blocks...|Regular blocks...............................................|Shadow blocks..|
2023-08-14 10:37:53 <veltas      > possible layout picture
2023-08-14 10:38:46 <vms14       > Oh now I get it
2023-08-14 10:39:06 <veltas      > e.g. in a 1MB disk, source could be in blocks 1-199, shadow of source in 801-999
2023-08-14 10:39:42 <veltas      > And you could put an image in 200-299, and database in 300-800
2023-08-14 10:40:19 <vms14       > I never had to reserve memory, in my world memory is infinite
2023-08-14 10:40:27 <vms14       > :D
2023-08-14 10:40:39 <veltas      > To alternate between source and shadow block you just compare SCR against 800 and then add or subtract 800
2023-08-14 10:40:42 <vms14       > I just create objects and that's all
2023-08-14 10:40:56 <veltas      > Well Forth is a very practical language, as I've said before
2023-08-14 10:40:58 <vms14       > I can always add more stuff on them
2023-08-14 10:41:05 <vms14       > But you have to manage every bit
2023-08-14 10:41:16 <veltas      > It doesn't make sense in abstract, it's meant to *do* stuff right away like writing programs and storing/retrieving data
2023-08-14 10:41:41 <vms14       > I wonder how a forth gc would be
2023-08-14 10:41:57 <vms14       > You need some sort of scope
2023-08-14 10:42:22 <vms14       > But for example it could free the data that goes out from the stack, as long as there's no more binding
2023-08-14 10:42:46 <vms14       > The data on the stack would be a pointer
2023-08-14 10:43:13 <veltas      > I don't know if you've noticed but a 'block' in Forth is 1024 bytes, so 'block' is really a KiB... as well as something sort of like a 'small file'.
2023-08-14 10:43:29 <vms14       > In forth does not make sense
2023-08-14 10:43:40 <vms14       > Forth was designed to be tiny and powerful
2023-08-14 10:43:49 <veltas      > Tiny and powerful on a real machine
2023-08-14 10:44:00 <vms14       > To use only the bytes you need
2023-08-14 10:44:04 <veltas      > Whereas your language is meant to be tiny and interesting in a scripting language
2023-08-14 10:44:24 <vms14       > Mine is a toy lang, it cares about having fun
2023-08-14 10:44:57 <vms14       > But it keeps improving
2023-08-14 10:45:05 <vms14       > I want it to keep evolving
2023-08-14 10:45:42 <vms14       > I'd like to have it in a more correct and well defined way
2023-08-14 10:45:54 <vms14       > Still being a prototype
2023-08-14 10:46:24 <vms14       > But it has almost a year
2023-08-14 10:59:30 <vms14       > Actually the kind of stuff you guys make with forth is quite amazing
2023-08-14 10:59:44 <vms14       > The kind of stuff is made with a forth
2023-08-14 11:00:08 <KipIngram   > vms14: It's just an easy way to remember where you put the documentation for the code in a block.  Just know what number to add.
2023-08-14 11:00:20 <vms14       > It's remarkable how can achieve a lot of stuff using very few resources
2023-08-14 11:00:40 <vms14       > And the freedom it has
2023-08-14 11:00:42 <KipIngram   > Forth typically has no gc - it just linearly allocates RAM as you  need it.
2023-08-14 11:00:51 <KipIngram   > But I think that's somewhat of a limitation.
2023-08-14 11:00:59 <vms14       > Yeah, but there are a lot of tricks from there
2023-08-14 11:01:00 <KipIngram   > I intend to have some memory management in future systems.
2023-08-14 11:01:30 <vms14       > And the way you can choose how to represent the data in memory or on the stack
2023-08-14 11:01:36 <vms14       > You can't do that in C
2023-08-14 11:01:42 <vms14       > You can only in assembly
2023-08-14 11:02:09 <vms14       > But forth is not assembly
2023-08-14 11:02:17 <vms14       > Its more like a macro assembler
2023-08-14 11:02:54 <vms14       > You can add a lot of abstraction
2023-08-14 11:03:04 <vms14       > That's why it's so cool
2023-08-14 11:03:13 <vms14       > You start from 0 and make an empire
2023-08-14 11:03:27 <vms14       > Everything built by you, from piece to piece
2023-08-14 11:05:48 <KipIngram   > More or less, yeah.
2023-08-14 11:06:00 <KipIngram   > It is like a macro assembler, but it's quite a lot more than that too.
2023-08-14 11:06:44 <KipIngram   > The basic idea is that it's whatever you want it to be.
2023-08-14 11:06:45 <Zarutian_iPad> 
ACTION is currently using js as a macro assembler

2023-08-14 11:14:56 <vms14       > could you say most of your programs in forth end having a dsl?
2023-08-14 11:16:56 <veltas      > Pretty much nobody here would say that
2023-08-14 11:17:09 <veltas      > Although it's often how Forth is described
2023-08-14 11:17:18 <veltas      > It just doesn't work out that way for most programs
2023-08-14 11:17:41 <veltas      > Whether it's a good ideal is hard to say, it certainly is nice when it works out that way
2023-08-14 11:17:53 <vms14       > yeah, that's why I asked
2023-08-14 11:18:14 <vms14       > I only made little scripts so they don't get time to have a dsl
2023-08-14 11:18:29 <vms14       > I just add whatever I need to the language directly as a builtin xD
2023-08-14 11:18:42 <veltas      > I will say that it's easier to make Forth act like a DSL when you use more globals and less stack state
2023-08-14 11:18:48 <vms14       > that's how it evolves, I use it, I want something I add it
2023-08-14 11:19:01 <vms14       > more globals?
2023-08-14 11:19:07 <vms14       > I have lexical variables
2023-08-14 11:19:12 <vms14       > and some sort of globals I guess
2023-08-14 11:19:15 <veltas      > And that's true of all languages I've used actually, there's something about global state that makes a language more 'DSL-like'
2023-08-14 11:19:19 <vms14       > I never used globals
2023-08-14 11:19:27 <veltas      > Well Forth is also 'lexical' in that sense, actually
2023-08-14 11:19:34 <veltas      > Because new definitions hide old ones
2023-08-14 11:19:34 <vms14       > my $root = { name => 'root', words => {}, variables => {}, temporary_variables => {}, parent => undef };
2023-08-14 11:19:40 <vms14       > but the environments have space for them
2023-08-14 11:19:48 <veltas      > And you can get back to the old definitions too
2023-08-14 11:19:53 <vms14       > temporary variables is what I use
2023-08-14 11:20:02 <vms14       > they die when the word ends
2023-08-14 11:20:16 <vms14       > so no globals, just variables and temp variables
2023-08-14 11:20:29 <vms14       > but as it's lexical scope they can act as globals if defined on the root env
2023-08-14 11:20:44 <veltas      > So they are essentially like Forth globals
2023-08-14 11:20:54 <vms14       > every word has it's own environment
2023-08-14 11:21:11 <vms14       > and they can inherit the environment of another word if they're defined inside
2023-08-14 11:21:23 <vms14       > : oh : meh 1 2 3 ; meh ;
2023-08-14 11:21:32 <vms14       > meh does not exist on the root environment
2023-08-14 11:21:41 <vms14       > only on the environment of the word 'oh'
2023-08-14 11:21:58 <vms14       > if you execute oh, oh will enter its own environment and then execute meh
2023-08-14 11:22:21 <vms14       > variables and words are inside those environments so the scope acts the same for both
2023-08-14 11:22:44 <vms14       > but meh is defined before oh
2023-08-14 11:23:09 <vms14       > : creates an environment for the new word and sets it as the current environment
2023-08-14 11:23:28 <vms14       > when it finds an immediate word like another : it just executes it
2023-08-14 11:23:31 <veltas      > You can do this in Forth with FORGET or MARKER
2023-08-14 11:23:47 <vms14       > but we're already inside of the environment the previous : created
2023-08-14 11:24:02 <vms14       > so the next : will create the word inside that environment
2023-08-14 11:24:27 <vms14       > I mainly rely on perl's lexical scope
2023-08-14 11:24:35 <vms14       > I do the same when reading the source cod
2023-08-14 11:24:40 <veltas      > You can do it exactly the same way with quotations and locals but you can get all the functionality with just variables, regular colon defs, etc + FORGET/MARKER
2023-08-14 11:25:34 <vms14       > I have to play more with my lang
2023-08-14 11:26:00 <vms14       > I didn't tested properly the scope and all this stuff
2023-08-14 11:26:08 <vms14       > it seems to work correctly
2023-08-14 11:26:30 <vms14       > except with the fake compile, I have to learn when I have to enter an environment
2023-08-14 11:27:18 <vms14       > fake compile returns functions, but they have to work in the correct environment
2023-08-14 11:27:50 <vms14       > on some cases I take the environment at compile time and save it for the function, making it a closure
2023-08-14 11:28:28 <vms14       > when the function executes, it will use that environment, but it's a mess
2023-08-14 11:29:18 <vms14       > anyways the fake compile will be removed, I just have to assume my lang is extremely slow
2023-08-14 11:29:30 <vms14       > if I want performance I need to make a transpiler
2023-08-14 11:30:19 <vms14       > if the language has eval I can have the source code of a word in a string, then make a function by evaluating that string
2023-08-14 11:30:48 <vms14       > that way the function is available at compile time as I have a function and I can write that when generating code since I have the string
2023-08-14 11:31:37 <vms14       > but it's hard to transpile for me
2023-08-14 11:36:56 <KipIngram   > It doesn't surprise me a lot - you've built this on top of an existing system in order to make certain things easy for yourself - it's not surprising that some other things become hard and cumbersome.
2023-08-14 11:37:13 <KipIngram   > A real Forth is designed from the ground up to make everything turn out utterly simple.
2023-08-14 11:37:29 <KipIngram   > That's the goal from the ground floor all the way up.
2023-08-14 11:37:55 <KipIngram   > Given how you approached this you just can't expect everything to dovetail beautifully into place.
2023-08-14 11:39:24 <vms14       > yeah, it's like I saw the philosophy of forth and understood everything in a reverse way
2023-08-14 11:39:28 <vms14       > :D
2023-08-14 11:40:11 <vms14       > actually I never really learned forth properly
2023-08-14 11:40:51 <vms14       > just saw some of its surface and liked a lot of stuff, but when I knew I was able to make my own lang by stealing forth concepts I couldn't resist
2023-08-14 11:41:04 <vms14       > and the abomination became
2023-08-14 11:41:56 <vms14       > it has grown a bit, but it needs to keep evolving until it becomes a big monster able to horrorize everyone
2023-08-14 11:42:09 <vms14       > for now only few people cry
2023-08-14 11:50:10 <KipIngram   > Well, I think the value in what you've done isn't the result you've built so much as it is the things you've learned.
2023-08-14 12:16:25 <vms14       > I didn't build much because I couldn't stop rewriting, for now I can play a bit, but I'll have to rewrite it soon to add more stuff and do things differently
2023-08-14 12:17:15 <vms14       > I'm trying to make a simple cgi that is able to log a user
2023-08-14 12:17:47 <veltas      > Finally bothered writing my block serialisation utility
2023-08-14 12:17:57 <veltas      > Well the input part anyway, I need to write the output part
2023-08-14 12:18:05 <veltas      > And finish my starting forth editor
2023-08-14 12:20:24 <veltas      > I'll get that on github and share tonight :S
2023-08-14 12:20:41 <veltas      > I got a vim PR resurrected today, seems like things are a bit chaotic over there
2023-08-14 12:21:09 <veltas      > I will say it's been quite nice seeing the whole internet be 'nice' about what's happened here, amazing that people are capable of an amount of respect these days
2023-08-14 12:21:51 <veltas      > vim definitely deserves it because software aside there was a charity at the core of it for years that's seemingly done good work in Uganda and without much overhead at all
2023-08-14 12:25:00 <vms14       > 
ACTION remembers he has to stop using emacs some day

2023-08-14 12:26:00 <veltas      > I think all those fellow people with way too much time on their hands owe it to themselves to learn vi and emacs at the very least
2023-08-14 12:26:44 <veltas      > If you really love yourself learn ed too
2023-08-14 12:27:01 <vms14       > I always think a bit before learning something and I won't unless I see a reason
2023-08-14 12:27:06 <thrig       > ed is a good git commit editor, but ex filters are spiffy
2023-08-14 12:27:20 <veltas      > ex is grown-up ed
2023-08-14 12:27:20 <vms14       > the major benefit of learning vi was that it's supposedly part of posix
2023-08-14 12:27:49 <vms14       > the reality is posix compliant systems lie
2023-08-14 12:27:50 <thrig       > ed is the standard editor, even if linux systems are doing posix violations and leaving it off
2023-08-14 12:28:10 <vms14       > posix violations :0
2023-08-14 12:28:22 <veltas      > I use ed regularly for terminal-heavy work where I want "what I just did" on-screen while editing
2023-08-14 12:28:39 <veltas      > Like git commit editing as you say
2023-08-14 12:28:50 <veltas      > That's just one of many places I use it
2023-08-14 12:29:16 <thrig       > maybe it was ubuntu I eventually fought to a draw by installing busybox and using the not-too-terrible vi of busybox
2023-08-14 12:29:30 <veltas      > If I'm building and I see something 'obvious' like a typo, I'll fix it in ed
2023-08-14 12:29:54 <vms14       > in netbsd there's nvi, but you thrig used openbsd I guess, I'm not sure if we have the same nvi
2023-08-14 12:30:19 <vms14       > The nex/nvi replacements for the ex/vi editor first appeared in 4.4BSD.
2023-08-14 12:30:41 <thrig       > openbsd (famously) split from netbsd so it's probably the same Version 1.79 (10/23/96) The CSRG, University of California, Berkeley.
2023-08-14 12:30:51 <vms14       > still I'm waiting to see if I can use a phone for programming
2023-08-14 12:31:16 <vms14       > if I can live with that I don't need a computer anymore
2023-08-14 12:31:24 <veltas      > Reading the drama surrounding the split is interesting although I have no way to know 'who's in the right' this far down the road
2023-08-14 12:31:40 <vms14       > veltas: you mean when they kicked theo?
2023-08-14 12:31:45 <veltas      > Yeah
2023-08-14 12:31:56 <vms14       > do you see futurama?
2023-08-14 12:32:03 <veltas      > I've seen Futurama
2023-08-14 12:32:05 <vms14       > there's a chapter that represents it nice
2023-08-14 12:32:14 <vms14       > when bender is kicked from the moon park
2023-08-14 12:32:19 <veltas      > lol
2023-08-14 12:32:24 <veltas      > I've seen that
2023-08-14 12:32:26 <vms14       > and he says he will make his own casino
2023-08-14 12:32:30 <vms14       > that was theo
2023-08-14 12:32:32 <veltas      > That's the first (or second?) episode if I remember
2023-08-14 12:32:44 <vms14       > I'll make my own distro, with security and hookers
2023-08-14 12:32:51 <veltas      > lol
2023-08-14 12:33:01 <veltas      > Well OpenBSD is great, I don't use it and I already know that
2023-08-14 12:33:48 <vms14       > https://www.theos.com/deraadt/coremail.html
2023-08-14 12:33:56 <veltas      > Yeah I've read through that
2023-08-14 12:34:05 <vms14       > then you know why they kicked him
2023-08-14 12:34:28 <vms14       > he had bad behavior with other users and was scaring people away
2023-08-14 12:35:19 <vms14       > the other guys told him this behavior can't represent netbsd
2023-08-14 12:35:36 <vms14       > and that he could stay contributing, but not represent netbsd anymore
2023-08-14 12:41:46 <veltas      > I am a highly sceptical person
2023-08-14 12:42:09 <veltas      > I've seen enough of this behaviour up-close to know it's never as simple as it looks
2023-08-14 12:42:33 <veltas      > I don't want to judge anyone involved based on the limited info I have
2023-08-14 12:43:22 <thrig       > some highly competent people are assholes, though. Beethoven called his singers cattle and asses when they complained about some high notes in some symphony
2023-08-14 12:52:55 <vms14       > veltas: I also saw him fighting vs the plan9 guys
2023-08-14 12:53:08 <vms14       > I think he just likes to be rude
2023-08-14 12:53:43 <vms14       > the plan9 guys bullied him a bit xd
2023-08-14 12:54:02 <vms14       > and they even made a fortune with him
2023-08-14 13:00:00 <vms14       > veltas: anyways you're right, the guy that had a fight vs theo was an asshole
2023-08-14 13:00:22 <vms14       > or that's what I think, as on the mails they kind of tell him
2023-08-14 13:00:46 <vms14       > but still it does not serve as excuse to do whatever he did
2023-08-14 13:01:51 <vms14       > I'm an asshole too, but I don't tend to pick a fight
2023-08-14 13:02:06 <vms14       > I just live my life :D
2023-08-14 13:12:08 <veltas      > Well just know if you're ever in a drama I'm not going to pick sides :P
2023-08-14 13:12:46 <thrig       > this Macbeth guy seems to know what he's doing
2023-08-14 13:13:24 <vms14       > my only dramas are when code does not do what I want
2023-08-14 13:13:45 <vms14       > the drama now intensifies cause no one knows the language I use
2023-08-14 13:14:18 <KipIngram   > I think a lot of people like to be rude, and the internet has just made it easier.
2023-08-14 13:14:26 <KipIngram   > You're "out of reach" online.
2023-08-14 13:14:44 <vms14       > yeah, they can't punch your face
2023-08-14 13:15:01 <KipIngram   > Exactly.
2023-08-14 13:15:24 <KipIngram   > It's a bit like that old cliche from the old West in America - "an armed society is a polite society."
2023-08-14 13:16:19 <vms14       > you won't pick a fight with some one who has a gun
2023-08-14 13:17:17 <thrig       > I recall lots of disagreements in the Westerns
2023-08-14 13:17:26 <thrig       > plenty of fights picked
2023-08-14 13:17:35 <vms14       > cause both had a gun
2023-08-14 13:17:58 <thrig       > and tricky things where they would burn the other guys out
2023-08-14 13:18:01 <veltas      > I've seen videos of people picking fights with guns, it just escalates the capacity for stupidity for some people
2023-08-14 13:18:41 <vms14       > human stupidity has no end and we are all included
2023-08-14 13:18:57 <vms14       > I also do stupid things
2023-08-14 13:19:15 <vms14       > mostly*
2023-08-14 14:03:41 <veltas      > Yeah I'm not exempt, stupid things I've engaged in while driving my car for example
2023-08-14 15:13:03 <vms14       > I don't have globals lol
2023-08-14 15:14:42 <vms14       > I can't set stuff on the outer scope either
2023-08-14 15:15:25 <vms14       > oh, I think I had this behavior already
2023-08-14 15:16:39 <vms14       > yeah, I have temp variables which is what I use always, they won't set a value of an existing temp variable
2023-08-14 15:16:49 <vms14       > but "normal" variables will
2023-08-14 15:17:16 <vms14       > temp vars die when the word finishes execution
2023-08-14 15:18:19 <vms14       > this is a line from execute_word: $word->{environment}->{temporary_variables} = {};
2023-08-14 15:19:08 <vms14       > 24 :oh  sets a temp variable named 'oh'
2023-08-14 15:19:15 <vms14       > 24 ::oh  sets a normal variable
2023-08-14 15:20:25 <vms14       > inside a word definition you can't change the value of existing temp variables, it creates a new temp in this scope, but normal variables will modify an existing variable
2023-08-14 15:22:07 <vms14       > : meh 3 ::oh 3 :oh ;   oh: oh::
2023-08-14 15:23:11 <vms14       > when executed 'meh' oh:: will return 3 but oh: 24
2023-08-14 15:24:42 <vms14       > seems to work fine
2023-08-14 15:24:57 <vms14       > I like lexical scope
2023-08-14 15:31:16 <vms14       > should I use ::: for globals? xd
2023-08-14 15:31:23 <vms14       > 24 :::oh
2023-08-14 15:33:00 <veltas      > If you want a serious suggestion, rewrite the full WASHER program from Thinking Forth (available free online) in your language, it's a good example
2023-08-14 15:33:10 <veltas      > I've done that for a language I've designed
2023-08-14 15:34:46 <vms14       > veltas: the full program?
2023-08-14 15:34:57 <vms14       > I only saw that line
2023-08-14 15:36:51 <vms14       > : WASHER WASH SPIN RINSE SPIN ; : RINSE FAUCETS OPEN TILL-FULL FAUCETS CLOSE ;
2023-08-14 15:36:59 <vms14       > hmm
2023-08-14 15:37:41 <thrig       > NEEDS-WHACK-WITH-BROOM
2023-08-14 15:37:49 <vms14       > veltas: there's no way I can get a link of the full program?
2023-08-14 15:38:00 <KipIngram   > I don't see WASHER in the book's list of programming examples.
2023-08-14 15:38:47 <veltas      > vms14: it's in Thinking Forth, which is available free online
2023-08-14 15:38:53 <vms14       > : wash " I'm washing stuff, please wait" .cr ;
2023-08-14 15:38:59 <thrig       > or it's in Starting Forth
2023-08-14 15:39:14 <KipIngram   > There are seven examples listed, though - any of them would probably be interesting.
2023-08-14 15:39:22 <veltas      > The full one is in THinking Forth I think
2023-08-14 15:39:32 <KipIngram   > That's what I'm looking at.
2023-08-14 15:40:12 <vms14       > 
ACTION stealing...

2023-08-14 15:41:10 <veltas      > Oh I've found it, it's in Forth Programmer's Handbook
2023-08-14 15:41:19 <veltas      > Page 44
2023-08-14 15:41:21 <veltas      > My bad
2023-08-14 15:42:05 <veltas      > That's also free online
2023-08-14 15:42:21 <veltas      > You might find a PDF standalone but it's also in the SwiftForth evaluation download
2023-08-14 15:42:30 <vms14       > I'm downloading a pdf
2023-08-14 15:42:42 <vms14       > or trying to :/
2023-08-14 15:45:24 <vms14       > oh it's cool
2023-08-14 15:45:43 <vms14       > I just need to assume a memory address is the hardware
2023-08-14 15:49:33 <vms14       > so this is the whole program?
2023-08-14 15:49:39 <vms14       > https://termbin.com/wgs7
2023-08-14 15:58:21 <vms14       > veltas: what output should do?
2023-08-14 15:58:29 <vms14       > I don't have that word
2023-08-14 15:58:35 <vms14       > I assume is what touches the pins
2023-08-14 15:58:47 <vms14       > so a dummy word?
2023-08-14 16:04:53 <vms14       > it's a bit weird
2023-08-14 16:05:11 <vms14       > https://termbin.com/jj80
2023-08-14 16:05:29 <vms14       > ah ms actually does sleep
2023-08-14 16:08:16 <vms14       > it's a bit sad to write that program if I start faking stuff
2023-08-14 16:08:41 <vms14       > I can sleep, but I don't have a input/output word
2023-08-14 16:10:54 <vms14       > but it's cool how for example add is a general purpose word
2023-08-14 16:11:59 <vms14       > or maybe not, it's only used once
2023-08-14 16:12:00 <KipIngram   > You could write an emulation for the missing hardware.
2023-08-14 16:12:09 <vms14       > yeah, I was thinking about that
2023-08-14 16:12:17 <vms14       > this would make the exercise fun
2023-08-14 16:12:26 <vms14       > but a lot of work
2023-08-14 16:12:38 <vms14       > I'll go to eat instead :D
2023-08-14 19:15:42 <veltas      > There we are https://raw.githubusercontent.com/Veltas/forth/main/to-blocks.4th
2023-08-14 19:15:50 <veltas      > Nighty night
2023-08-14 23:24:30 <KipIngram   > Man, Magnum PI just really took a turn down in season 4.  I'm almost halfway through the season, and with the possible exception of the season premier episode it's been nothing but lame episode without any real serious adversarial plots.
2023-08-14 23:24:58 <KipIngram   > And Magnum himself is getting considerably less screen time.
2023-08-14 23:29:59 <thrig       > maybe the actor got too expensive for the series