2023-02-09 11:05:13 <KipIngram   > joe9: It would certainly be worth getting familiar with the interface you suggest, though - I will be crafting a Forth lexicon for accessing hte functionality, and I might get ideas from such a review.
2023-02-09 11:05:52 <joe9        > are you talking about the gui?
2023-02-09 11:06:06 <KipIngram   > Yeah.
2023-02-09 11:06:24 <KipIngram   > or, well, about the "graphics interface."
2023-02-09 11:06:38 <joe9        > http://man.9front.org/3/draw
2023-02-09 11:06:39 <KipIngram   > I don't necessarily plan a full blown conventional gui.
2023-02-09 11:06:57 <KipIngram   > To some extent I still want something that can "work like a console."
2023-02-09 11:07:04 <joe9        > http://man.9front.org/2/draw
2023-02-09 11:07:09 <KipIngram   > But I want to be able to draw stuff in that window as well.
2023-02-09 11:08:51 <joe9        > check out the terminal window of a rio http://man.9front.org/1/rio . It is a lot better than the traditional terminal window.
2023-02-09 11:09:37 <KipIngram   > That looks interesting; thanks.
2023-02-09 11:13:42 <KipIngram   > That looks like it fits what I have in mind fairly well.
2023-02-09 11:19:38 <Stalevar    > So, what character is the Enter key on the keyboard supposed to send, CR or LF or CRLF anyway?
2023-02-09 11:19:53 <KipIngram   > That varies with OS.
2023-02-09 11:20:39 <thrig       > and in unix, depending on about 20 termios flags
2023-02-09 11:20:40 <KipIngram   > On my system KEY returns 13 on Enter.
2023-02-09 11:20:44 <KipIngram   > Yes.
2023-02-09 11:20:57 <KipIngram   > I've adjusted my termios.
2023-02-09 11:21:58 <Stalevar    > KipIngram, a keyboard is supposed to send some kind of scan code which only depends on the keyboard
2023-02-09 11:22:09 <Stalevar    > and it's probably same between all USB keyboards say
2023-02-09 11:22:21 <Stalevar    > Even fancy ones meant for Mac and things
2023-02-09 11:22:36 <thrig       > the SDL docs indicate some portability fun for scancodes
2023-02-09 11:23:08 <Stalevar    > What if we go for IBM PC compatibles? Hm...
2023-02-09 11:24:36 <Stalevar    > thrig, I got a line printer. I have found out that if I cat a file to the serial port it's printed fine. The file is of course LF-only. However if I do picocom /dev/port then printer won't advance the paper unless I hit ^J
2023-02-09 11:25:10 <KipIngram   > Yeah, and I'm sure mine does, but I have no idea how to "expose" that layer of things (i.e., read scan codes).
2023-02-09 11:25:23 <KipIngram   > Actually I think we should be given time-stamped press and release codes.
2023-02-09 11:25:40 <KipIngram   > The OS attempts to "simplify" that interface, and it's hard to get to that bottom layer.
2023-02-09 11:25:45 <Stalevar    > KipIngram, usbhid-dump
2023-02-09 11:26:03 <Stalevar    > Should give you the bottom layer if your keyboard is usb
2023-02-09 11:26:04 <KipIngram   > I saw in the SDL documentation yesterday, that it does indeed return time-stamped "keyboard events."
2023-02-09 11:26:07 <KipIngram   > Both press and release.
2023-02-09 11:26:37 <Stalevar    > But it will also make you unable to use the keyboard to break out of it
2023-02-09 11:26:40 <Stalevar    > Ooops, yeah
2023-02-09 11:26:41 <KipIngram   > Yeah, I think I was vaguely aware of that, but what I meant was I wasn't sure how to make a "single event" call that could serve as a Forth word like KEY.
2023-02-09 11:27:30 <Stalevar    > I guess I need to try this on and see what keys send when pressed, I can use SSH to terminate usbhid-dump, or there was some timeout feature
2023-02-09 11:28:04 <Stalevar    > Also replugging the kb should work
2023-02-09 11:28:14 <KipIngram   > SDL also tells you which window the event was associated with, so it looks like I don't have to explicitly track that myself.
2023-02-09 11:28:44 <KipIngram   > I've always wished that the shift keys were delivered explicitly too.
2023-02-09 11:28:57 <KipIngram   > Just tell me when they're pressed and released and let me keep up with what to do with that.
2023-02-09 11:29:45 <KipIngram   > The Linux "cooked" tty is quite well-cooked indeed.
2023-02-09 11:30:05 <Stalevar    > But picocom makes it raw
2023-02-09 11:30:22 <KipIngram   > I made mine "mostly raw," but yet  not all the way to the scan code level.
2023-02-09 11:30:31 <KipIngram   > I still don't have independent access to shift key state, for example.
2023-02-09 11:30:44 <KipIngram   > But I do get each keystroke individually, instead of a whole line.
2023-02-09 11:30:48 <Stalevar    > Why does Enter key make a CR when in raw mode and LF when in "cooked" mode?
2023-02-09 11:31:02 <KipIngram   > Because they coded it that way (if it's like that).
2023-02-09 11:31:14 <KipIngram   > There were a lot of kind of arbitrary choices made in that cooking.
2023-02-09 11:31:37 <thrig       > stty -a | egrep 'nl|cr'
2023-02-09 11:33:57 <KipIngram   > Obviously someone involved figured they knew what was good for everyone.
2023-02-09 11:34:19 <Zarutian_iPad> I am going to quote that
2023-02-09 11:34:53 <KipIngram   > Heh.
2023-02-09 11:36:23 <Stalevar    > That mess comes right from ASCII standard
2023-02-09 11:36:32 <KipIngram   > Ok.
2023-02-09 11:36:41 <Stalevar    > They probably shouldn't have assigned CR and LF to different codes
2023-02-09 11:36:45 <KipIngram   > I doubt I've ever actually looked at the ASCII standard.
2023-02-09 11:37:00 <KipIngram   > That had to do with the mechanics of old teletypes, right?
2023-02-09 11:37:23 <Zarutian_iPad> Stalevar: needed to as the functionality of teletypes required it
2023-02-09 11:37:25 <KipIngram   > Turn the cylinder, vs. move the carriage back over?
2023-02-09 11:37:34 <Zarutian_iPad> precisely
2023-02-09 11:37:35 <Stalevar    > I am not certain, those teletypes were probably already ancient by that time ASCII was introduced
2023-02-09 11:38:01 <KipIngram   > Well, just depended on the age and "era" of the people who controlled the process.
2023-02-09 11:38:25 <KipIngram   > Some folks have a hard time recognizing that what as useful yesterday isn't still useful today.
2023-02-09 11:38:29 <Zarutian_iPad> oh no, ASCII was introduced in two stages. Uppercase was the only case available
2023-02-09 11:39:44 <Stalevar    > Anyway, if the terminal was previously ASCII incompatible, since it existed before ASCII standard, it means that it already has some codes for CR and LF, while if terminal was built to support ASCII, it could have been built with single line terminator character in mind
2023-02-09 11:40:06 <KipIngram   > Could have been.
2023-02-09 11:40:31 <Stalevar    > So I don't think it was necessary to create the CRLF mess in the first place
2023-02-09 11:40:44 <KipIngram   > They could have made each generation of microprocessor the best they could make it, too, without doctoring it for backwards compatibility with earlier code.
2023-02-09 11:40:47 <KipIngram   > But they didn't.
2023-02-09 11:41:19 <KipIngram   > Huge swaths of modern microprocessor design are driven by compatibility with C code written in the 70's and 80's.
2023-02-09 11:41:20 <Stalevar    > Imagine, the standard is 60 years old and we still have to figure out various problem when same key produces CR or LF depending on the context...
2023-02-09 11:41:28 <KipIngram   > Yep.
2023-02-09 11:41:34 <Stalevar    > Same to BS and DEL
2023-02-09 11:41:48 <KipIngram   > PDP11 compatibility - that was a big factor.
2023-02-09 11:41:52 <Zarutian_iPad> or ESC
2023-02-09 11:42:08 <KipIngram   > Stalevar: There's a neat paper floating around out there called "C is NOT a Low Level Language."
2023-02-09 11:42:13 <KipIngram   > Goes through the history of all this.
2023-02-09 11:42:23 <KipIngram   > C *was* a low level language when it was designed.
2023-02-09 11:42:29 <KipIngram   > But it's far from it these days.
2023-02-09 11:42:36 <KipIngram   > C fit on the PDP11 very neatly.
2023-02-09 11:42:52 <Stalevar    > I have a 86rk like thing, when you hit ЗБ (backspace?) and read the key you get DEL, however you have to print BS to make the cursor go backward. DEL prints a pseudograpic rectangle
2023-02-09 11:43:09 <KipIngram   > Yes.
2023-02-09 11:43:17 <KipIngram   > I waded through all of that.
2023-02-09 11:43:24 <KipIngram   > It's a pain in the ass.
2023-02-09 11:43:37 <KipIngram   > This is part of why EXPECT is such a voluminous monster.
2023-02-09 11:43:46 <Stalevar    > And then they only added to the mess introducing C1 control codes
2023-02-09 11:44:13 <Stalevar    > 80 to 9F or something
2023-02-09 11:44:38 <Stalevar    > Finally, a code for New line..
2023-02-09 11:44:45 <Stalevar    > yet nobody uses it, I guess?
2023-02-09 11:45:09 <KipIngram   > I'm planning a custom character set right now.  0-0x7F will be "standard," but I'm assigning what I want to 0x80-0xFF.
2023-02-09 11:45:34 <KipIngram   > Some of them will be the characters an APL keyboard will generate, and some of them will be those old fashioned "box drawing" characters.
2023-02-09 11:45:40 <KipIngram   > Maybe, at least on the box chars.
2023-02-09 11:45:48 <Stalevar    > https://imgs.xkcd.com/comics/standards.png
2023-02-09 11:45:48 <KipIngram   > I may decide that I just draw boxes graphically.
2023-02-09 11:46:16 <KipIngram   > but I want to hide the multi-byte nature of the APL chars inside my keyboard interface.
2023-02-09 11:46:53 <KipIngram   > And I won't need to deal with that anymore on output, since I'm printing my own characters from a font map anyway.
2023-02-09 11:47:35 <KipIngram   > Printing a char will just be copying a rectangle from the font bitmap to the screen; there's an SDL2 call to do that.
2023-02-09 11:50:29 <KipIngram   > I also want some of the 0x80-0xFF codes to change color and attribute settings on the console, so that that control can just be embedded in strings as I like.
2023-02-09 11:52:19 <KipIngram   > The setup I'm picturing would "work" for a system like Chuck's ColorForth, but I really doubt I'll ever actually try to "go there."
2023-02-09 11:52:37 <KipIngram   > I'm just too used to the standard Forth way of doing those things.
2023-02-09 11:52:57 <KipIngram   > Though you certainly can't accuse Chuck of not "thinking outside the box."
2023-02-09 11:53:14 <KipIngram   > He's gotten up to some wild escapades over the years.
2023-02-09 11:53:29 <KipIngram   > Stalevar: At one point he went to a seven-key keyboard.
2023-02-09 11:53:49 <Stalevar    > Unix system is not that bad in general, but there is one thing bothering me
2023-02-09 11:54:00 <Stalevar    > $ echo -en '\03\02\01\00\01\02\03' | od -An -tx1
2023-02-09 11:54:01 <Stalevar    >  03 02 01 00 01 02 03
2023-02-09 11:54:01 <KipIngram   > And he frequently arranged things so that his mouse wheel scrolled through his opcodes, so he'd change a word in his source by just clicking on it and spinning the wheel.
2023-02-09 11:54:12 <Stalevar    > Works fine... You see the 00 byte in the middle, right?
2023-02-09 11:54:16 <KipIngram   > And then all of that was stored in some highly compressed format.
2023-02-09 11:54:25 <Stalevar    > $ echo -n $'\3\2\1\0\1\2\3' | od -An -tx1
2023-02-09 11:54:26 <Stalevar    >  03 02 01
2023-02-09 11:54:28 <KipIngram   > Yes, I see the \00
2023-02-09 11:54:33 <Stalevar    > Oops... where is 00?
2023-02-09 11:54:43 <KipIngram   > Yeah.
2023-02-09 11:54:51 <KipIngram   > Null char doesn't "do" anything.
2023-02-09 11:54:56 <thrig       > echo ain't portable
2023-02-09 11:55:03 <Stalevar    > It's not echo problem
2023-02-09 11:55:09 <KipIngram   > By the way, on my keyboard (not by deliberate intent) ctrl-space generates a null key code.
2023-02-09 11:55:23 <KipIngram   > Try 0 emit on a Forth.
2023-02-09 11:55:26 <KipIngram   > You'll see the same.
2023-02-09 11:55:41 <Stalevar    > Yes, it does
2023-02-09 11:55:45 <thrig       > https://thrig.me/tmp/worksforme.png
2023-02-09 11:55:47 <KipIngram   > Cursor doesn't move for me.
2023-02-09 11:56:01 <KipIngram   > 32 emit prints ok one char further over on the screen than 00 emit does.
2023-02-09 11:56:10 <Stalevar    > thrig, try echo $'...'
2023-02-09 11:56:17 <thrig       > unportable bash shit
2023-02-09 11:56:29 <Stalevar    > Then echo `echo -en ... `
2023-02-09 11:56:41 <Stalevar    > or echo $(echo ...)
2023-02-09 11:57:11 <Stalevar    > It's not bash or echo, it's fundamental Unix flaw
2023-02-09 11:57:14 <KipIngram   > Anyway, when you inspect all this stuff you are not seeing the behavior of an elegant, highly consistent system.
2023-02-09 11:57:29 <KipIngram   > You're seeing a whole mess of unilateral decisions people made and then deliberately implemented.
2023-02-09 11:58:26 <Stalevar    > thrig, the thing is that a command line parameter containing ^@ will be only read until that null character. The rest of it is going to be lost
2023-02-09 11:58:48 <Stalevar    > That's why echo -n $'\3\2\1\0\1\2\3' fails
2023-02-09 11:58:53 <KipIngram   > Well, null is a string terminator.
2023-02-09 11:59:06 <Stalevar    > And that's a fundamental Unix flaw
2023-02-09 11:59:17 <Stalevar    > Because with null as terminator you can't have null within a string
2023-02-09 11:59:34 <Stalevar    > And it hurts universality
2023-02-09 11:59:55 <KipIngram   > Yes, and this is one of the reasons "binary" files are distinct from "text" files.
2023-02-09 11:59:59 <KipIngram   > I hear what you're saying.
2023-02-09 12:00:23 <KipIngram   > Different but related issue.  I set my keyboard up so ctrl-<letter> gives me the codes 1-26.
2023-02-09 12:00:30 <KipIngram   > And ctrl-space gives me 0.
2023-02-09 12:00:42 <KipIngram   > So I'm really in a position to be able to type almost any byte from the keyboard.
2023-02-09 12:00:42 <Stalevar    > Which is bogus. Why filenames can contain every byte but ^@ and / ?
2023-02-09 12:00:44 <KipIngram   > But...
2023-02-09 12:00:57 <KipIngram   > some of them get intercepted.  Like ctrl-m which does the same thing as Enter.
2023-02-09 12:01:07 <KipIngram   > And with the stock tty interface there's no good way around that.
2023-02-09 12:01:14 <Stalevar    > there is
2023-02-09 12:01:16 <Stalevar    > stty raw
2023-02-09 12:01:17 <KipIngram   > Whereas at the scan code level ctrl-m and Enter are totally different things.
2023-02-09 12:01:38 <KipIngram   > The point, though, is that SOME ctrl-letter key is going to send the same thing Enter does.
2023-02-09 12:01:48 <Stalevar    > Ctrl-2 also works as ^@
2023-02-09 12:01:49 <KipIngram   > And even with stty raw, you can't distinguish between those.
2023-02-09 12:02:16 <Stalevar    > because keypress is not the same thing as typed character
2023-02-09 12:02:23 <KipIngram   > To do so, you need to go all the way to the scan code level.
2023-02-09 12:02:30 <Stalevar    > For example Shift-F is not same thing as F
2023-02-09 12:02:53 <Stalevar    > You can't also distinguish between say F pasted or typed
2023-02-09 12:02:55 <KipIngram   > Well, whether or not the same thing gets sent depends.
2023-02-09 12:03:20 <KipIngram   > If caps-lock is on, then F and shift F will send the same code (usually - I've seen systems where shift took you to lower case when capslock is engaged).
2023-02-09 12:03:22 <Stalevar    > But anyway it's a different problem
2023-02-09 12:03:48 <KipIngram   > Oh, actually mine does go back to lower case for that.
2023-02-09 12:03:50 <KipIngram   > Ok.
2023-02-09 12:03:55 <Stalevar    > Yes, usually shift sents to lower case in that case. YOU CAN sEE it HERE.
2023-02-09 12:03:56 <KipIngram   > I never use capslock for the most part.
2023-02-09 12:04:08 <KipIngram   > Right - that's what mine does too.
2023-02-09 12:04:16 <KipIngram   > I have seen a case or two over the years, though, where it didn't.
2023-02-09 12:04:27 <KipIngram   > "capslock" meant "caps only."
2023-02-09 12:04:31 <KipIngram   > Which seems wrong to me.
2023-02-09 12:04:51 <Stalevar    > But why you can't pass arbitrary binary data via command line parameters?
2023-02-09 12:05:00 <Stalevar    > Isn't it a flaw?
2023-02-09 12:05:16 <Stalevar    > You can pass just about anything but null byte
2023-02-09 12:05:27 <KipIngram   > Well, I guess that depends on what the design specification says.  I think it would be useful to be able to do that.
2023-02-09 12:05:35 <KipIngram   > I think there should be SOME way.
2023-02-09 12:05:40 <Stalevar    > Actually, yeah, all other bytes 1 to FF will work
2023-02-09 12:05:52 <Stalevar    > KipIngram, nope, no way
2023-02-09 12:06:21 <KipIngram   > Well, the response you might get if you tried to open an issue is "it's working as designed."
2023-02-09 12:06:30 <KipIngram   > We can disapprove of that design, if we wish.
2023-02-09 12:06:40 <Stalevar    > Do you know how it works on machine code level? Command line parameters are put into memory and pointers are pushed to the stack, then number of parameters is pushed
2023-02-09 12:06:54 <KipIngram   > Ok.
2023-02-09 12:07:07 <KipIngram   > No, I'm not familiar with Linux internal mechanics at that level.
2023-02-09 12:07:13 <KipIngram   > I'd just assume it's done in some sensible way.
2023-02-09 12:07:50 <Stalevar    > So the program pops the number of parameters and then pops pointers to parameters. Each of them is terminated with zero byte. Only way to bypass this would be to pass amount of bytes in next parameter with other parameter
2023-02-09 12:08:07 <KipIngram   > I totally hear what you're saying, though - as an embedded guy I can think of plenty of situations where it would be nice to push arbitrary binary data from the keyboard.
2023-02-09 12:08:13 <KipIngram   > It would be useful.
2023-02-09 12:08:25 <Stalevar    > bin-process -n 7 $'\3\2\1\0\1\2\3'
2023-02-09 12:08:51 <Stalevar    > so say bin-echo -n 7 $'\3\2\1\0\1\2\3' could perhaps produce 7 bytes on output
2023-02-09 12:08:54 <KipIngram   > Well, you could just say
2023-02-09 12:09:05 <KipIngram   > bin-process -n 7 3 2 1 0 1 2 3
2023-02-09 12:09:09 <KipIngram   > and let bin process convert.
2023-02-09 12:09:31 <Stalevar    > Yes, but the idea was to put arbitary bytes into command line parameters
2023-02-09 12:09:38 <KipIngram   > I know.
2023-02-09 12:10:01 <KipIngram   > But what does it say in the design documents?  That may just not be a supported functionality.
2023-02-09 12:10:19 <KipIngram   > Is it a flaw?  Yeah, I think that's fair.  But is it a BUG?  Likely not.
2023-02-09 12:10:27 <Stalevar    > But ofc you can do that too. And my idea is flawed in a way, since you can use -n 100500 $'' and then get the program to segfault or to spit unrelated memory out
2023-02-09 12:10:50 <KipIngram   > Now that sounds like a bug.
2023-02-09 12:11:05 <KipIngram   > I'd think the shell should protect you from segfaults.
2023-02-09 12:11:16 <Stalevar    > So you still cannot pass arbitrary binary data via command line parameter securely (if you convert it to hex it won't be arbitrary binary data anymore)
2023-02-09 12:11:21 <KipIngram   > Whereas the Forth interpreter shouldn't, necessarily, unless it does so by catching the fault signal.
2023-02-09 12:11:50 <KipIngram   > The Forth interpreter should lay the functionality of your machine bare.
2023-02-09 12:12:02 <Stalevar    > Yet, I should try to implement binary echo
2023-02-09 12:12:08 <Stalevar    > I'm wondering what it will do
2023-02-09 12:37:49 <KipIngram   > joe9: I do like the general rio description quite a lot.
2023-02-09 12:40:15 <KipIngram   > joe9: Does plan9 have a command history buffer, and if so how does it work?
2023-02-09 12:41:32 <KipIngram   > I generally favor command histories, and have had them in some of my systems.  In the past, though, I've had a dedicated RAM region to keep that in - my latest thinking there is that it should just accumulate in a disk buffer and get saved to disk long term.
2023-02-09 12:42:35 <KipIngram   > The same with a history of the output, and I'm thinking I'd like to timestamp that information, so that it would be possible to go back and review what transpired at some point in time.
2023-02-09 12:42:52 <KipIngram   > Which you'd get by using the timestamps to interleave the stdin and stdout histories.
2023-02-09 12:43:18 <KipIngram   > Might be in one stream, with the records labeled as to device.
2023-02-09 12:49:09 <Stalevar    > $ ./bin-echo 7 $'\3\2\1\0\1\2\3' | od -An -tx1
2023-02-09 12:49:10 <Stalevar    >  03 02 01 00 53 48 45
2023-02-09 12:49:13 <Stalevar    > Hm...
2023-02-09 12:49:31 <KipIngram   > That's quite interesting.
2023-02-09 12:49:49 <KipIngram   > What did it do that made the second instances of \1 \2 \3 behave differently?
2023-02-09 12:51:42 <thrig       > print more and see if it's reading into the **environ list
2023-02-09 12:59:46 <Stalevar    > https://bpa.st/raw/WJ2LY
2023-02-09 13:00:04 <Stalevar    > thrig, it is 53 48 45 is SHE
2023-02-09 13:00:39 <thrig       > SHELL= is a common thing to find in the environment list
2023-02-09 13:00:54 <Stalevar    > So bash didn't pass the bytes after null
2023-02-09 13:01:41 <Stalevar    > ksh does the same
2023-02-09 13:01:58 <Stalevar    > $ ksh
2023-02-09 13:01:58 <Stalevar    > u@h:w$ ./bin-echo 0x7 $'\3\2\1\0\1\2\3' | od -An -tx1
2023-02-09 13:01:58 <Stalevar    >  03 02 01 00 5f 3d 2a
2023-02-09 13:02:14 <Stalevar    > thrig, also it means that $'..' isn't just bash
2023-02-09 13:02:44 <thrig       > portability of the construct is dubious
2023-02-09 13:03:31 <Stalevar    > zsh and tcsh do the same
2023-02-09 13:04:07 <Stalevar    > thrig, if it's portable between bash, ksh, zsh and tcsh... I'd say it's quite portable
2023-02-09 13:04:28 <Stalevar    > check what happens in OpenBSD please?
2023-02-09 13:05:06 <thrig       > it's not portable to ksh on OpenBSD, and anyways it's more typing than printf '\3\2\1\0\1\2\3'
2023-02-09 13:05:58 <thrig       > and echo is hilariously unportable, to the point of POSIX going... yeah... use printf.
2023-02-09 13:08:16 <Stalevar    > $ ./bin-echo 7 $(printf '\3\2\1\0\1\2\3') | od -An -tx1
2023-02-09 13:08:16 <Stalevar    > -bash: warning: command substitution: ignored null byte in input
2023-02-09 13:08:16 <Stalevar    >  03 02 01 01 02 03 00
2023-02-09 13:08:19 <KipIngram   > I think I'm at least beginning to home in on the beginnings of a portable instruction set that ought to work well on x64 and ARM.
2023-02-09 13:08:45 <KipIngram   > Generally I'm focusing on things I can do with one instruction on x64.  There's there will be more or less a one-to-one correspondence.
2023-02-09 13:08:55 <KipIngram   > One portable instruction --> one x64 instruction.
2023-02-09 13:09:04 <KipIngram   > But possibly several ARM instructions, since it's  RISC.
2023-02-09 13:09:46 <KipIngram   > For loading a register, so far I've got three different operations.  Load immediate, load from a RAM location with no fancy additions, and load from a RAM location with an offset and a multiplier.
2023-02-09 13:10:12 <KipIngram   > That last one would be akin to x64 mov <reg> [addr+scale*index]
2023-02-09 13:10:33 <KipIngram   > Which you can do in one shot, for specific values of scale.
2023-02-09 13:10:48 <KipIngram   > 1, 2, 4, and 8, I expect.
2023-02-09 13:11:03 <KipIngram   > But to do that on ARM will require allocation of a "scratch' register.
2023-02-09 13:11:20 <KipIngram   > Though I could probably use the register I'm loading, so maybe not.
2023-02-09 13:12:25 <KipIngram   > mov <reg>, index; shl <reg>, scale; add <reg>, addr; mov reg, [reg].
2023-02-09 13:14:01 <KipIngram   > the equivalent store operation would need a scratch reg, though.
2023-02-09 13:14:19 <KipIngram   > Though I might wind up not needing that.
2023-02-09 13:14:35 <KipIngram   > To implement Forth, tha tis.
2023-02-09 13:16:27 <KipIngram   > Wow - are RISC processors really able to execute that many instructions in a time comparable with the x64 executing the one?  I did hear a couple three years ago that ARM was overtaking Intel in the overall performance chase.
2023-02-09 13:17:16 <Zarutian_iPad> pretty much iirc
2023-02-09 13:17:58 <KipIngram   > That's pretty cool.
2023-02-09 13:18:34 <Zarutian_iPad> the isdue is that x86_64 ISA is rather complex
2023-02-09 13:18:38 <KipIngram   > My tendency is to want to just count instructions and figure "fewer is better," but that's definitely not the case across platforms like that.
2023-02-09 13:18:56 <KipIngram   > I'm hobbled a little here by having pretty much zero ARM experience in my background.
2023-02-09 13:19:11 <KipIngram   > And yet I'm TRYING to prepare sensibly for it.
2023-02-09 13:19:36 <Zarutian_iPad> what one should do is to count the operations and not the instructions
2023-02-09 13:19:45 <KipIngram   > Yes.
2023-02-09 13:19:51 <KipIngram   > You're totally right.
2023-02-09 13:20:50 <Zarutian_iPad> an CISC ISA with quite a few addressing modes actually performs quite a few operations per instruction
2023-02-09 13:21:22 <KipIngram   > Yes, but I'd like to hope that it performs some of them in parallel.
2023-02-09 13:21:26 <Zarutian_iPad> but the data depency delay in CISC can be huge
2023-02-09 13:22:15 <Zarutian_iPad> what I like about excamera J1 is how low that data dependency delay is
2023-02-09 13:22:45 <KipIngram   > And I don't like counting that scale*index operation, because it's just a shift.  And you don't actually have to SHIFT something before using it - you just take your input from different bits.
2023-02-09 13:23:29 <Zarutian_iPad> because TOS and NOS feed into various arithmetic and logic ops units your answer is often ready whilist the instruction is still being fetched and decoded
2023-02-09 13:23:56 <KipIngram   > There's actually a ton of parallelism opportunity in docol.
2023-02-09 13:24:31 <KipIngram   > Which you could seize if you were designing hardware to do the thing.
2023-02-09 13:31:12 <Zarutian_iPad> I have been watch some youtube videos on how to write shaders, bot vertex and fragment
2023-02-09 13:31:31 <Zarutian_iPad> both*
2023-02-09 13:31:33 <KipIngram   > I've been interested in that GPU stuff too recently.
2023-02-09 13:32:07 <KipIngram   > I think when I say "SDL2" in the context of this new system, I mean "SDL2+OpenGL."
2023-02-09 13:32:12 <Zarutian_iPad> so a vertex shader is run for every vertex of the mesh the shader is applied to
2023-02-09 13:32:30 <KipIngram   > Seems that's a common combo used.
2023-02-09 13:33:07 <Zarutian_iPad> and it returns an to be Interpolated result
2023-02-09 13:34:05 <Zarutian_iPad> the interpolation is via kind of a lerp but over the area of a triangle the vertex is part of
2023-02-09 13:35:21 <Zarutian_iPad> these are then fed into the fragment shader as arguments and it returns a colour.
2023-02-09 13:35:41 <KipIngram   > Sort of hardware computed "shape functions"?
2023-02-09 13:36:16 <Zarutian_iPad> usually something called uv or uv map is used to give the fragment shader a sense of location on the mesh it is being rendered on
2023-02-09 13:36:23 <KipIngram   > Shape functions as in finite element analysis; you have values at nodal points, and the interpolation gives you values for in the region they govern.
2023-02-09 13:36:46 <Zarutian_iPad> fragment shader is short for texture fragment shader
2023-02-09 13:37:09 <Zarutian_iPad> think so
2023-02-09 14:15:30 <KipIngram   > Wow; rio's handling of input text is "interesting."
2023-02-09 14:16:27 <KipIngram   > It looks like it allows you to suspend program input while you edit several lines of text - when you're ready you can "unsuspend."
2023-02-09 14:17:18 <KipIngram   > In this case I'm ok with input being "line oriented," since I'll still have control of the code that works at the individual key level.  It just won't be in the application program.
2023-02-09 14:17:58 <KipIngram   > I recall an old IBM system I ran across at one point where you could move around in a whole screen of text, adjusting various fields until you were happy with it, and then submit the whole screen in one shot.
2023-02-09 14:18:13 <KipIngram   > That might have been preparation of a database operation or something like that.
2023-02-09 14:19:22 <KipIngram   > The equivalent of that here would be for the application program to specify a text buffer and block until it's been "filled.'  All the editing around in the field and on-screen would be handled by "system" code, and the calling process would be unblocked when one  hit Enter on that field.
2023-02-09 14:26:13 <KipIngram   > This rio man page really goes into deep detail about what all the keys do and so on.  Someone clearly put a lot of thought into designing this.
2023-02-09 14:26:37 <thrig       > must be why it's not popular, someone wrote documentation for it
2023-02-09 14:26:39 <KipIngram   > Interestingly, auto-scrolling is off by default.
2023-02-09 14:27:00 <KipIngram   > You can turn it on.  Normally, though output process blocks when it reaches the bottom of the screen.
2023-02-09 14:27:38 <KipIngram   > Of the window, rather.
2023-02-09 14:28:10 <thrig       > hmm, 1992 is a bit late for blocking when input is full because 300 baud is slow
2023-02-09 14:28:28 <KipIngram   > I get the impression that you can go back up and edit prior stuff on the screen, which seems odd to me.
2023-02-09 14:28:41 <KipIngram   > In a "console" window I regard that stuff as history, which should be immutable.
2023-02-09 14:29:09 <KipIngram   > Plus it's a combination of input and output, so it's a bit hard to see what use there is for editing how it looks on the screen.
2023-02-09 14:29:44 <KipIngram   > When I say "command history," yes, I scroll back to stuff I've typed before, but I still regard that as preparation for a new line of input.
2023-02-09 14:30:05 <KipIngram   > In fact, bash seems to misbehave in that regard - it is possible to change prior commands.
2023-02-09 14:30:28 <KipIngram   > If you scroll back to a prior command line and edit that line and then SCROLL AWAY without hitting Enter, that actually changes the history record.
2023-02-09 14:30:36 <KipIngram   > I regard that as a flaw.
2023-02-09 14:30:48 <KipIngram   > And I make sure mine doesn't do that.
2023-02-09 14:31:50 <KipIngram   > If you edit a past line and DO hit enter, then the original line remains in the history, as you'd expect - you just get a new copy as the current command.
2023-02-09 14:38:42 <KipIngram   > Oh, I'd been figuring I'd set that tick counter to a million or so; that was based on getting to my keyboard monitoring code often enough to get accurate timing on the keystroke events.  But I wonder if maybe I should set it quite a bit smaller.
2023-02-09 14:39:43 <KipIngram   > Obviouslly the smaller it is the more overhead, but I did a little thinking about how much code would probably be involved with a thread switch, and I think even if the counter is set to a couple of thousand or something like that the overhead has been brought way down under 1%, and faster cycling around threads will make for smoother operation.
2023-02-09 14:40:17 <KipIngram   > Obviously I want it to "feel like" all of these threads are running continuously and concurrently.
2023-02-09 14:41:21 <KipIngram   > And I do intend to have a per-thread counter as well, so that threads can choose to actually "take" just one out of every N opportunities to run.
2023-02-09 15:05:19 <KipIngram   > So I'm planning to deal with escape by having the keyboard handler not return anything when it receives that char unless a little timer expires without receiving anything else.  If it does expire, I'll return the escape.
2023-02-09 15:05:31 <KipIngram   > Otherwise I'll take what comes after and map it to a special key.
2023-02-09 15:06:05 <KipIngram   > Some of my special keys seem to return six or seven bytes, if hit with ctrl down.
2023-02-09 15:14:51 <KipIngram   > That was fun.
2023-02-09 15:15:06 <KipIngram   > I was just testing out returned key bytes and managed to terminate my whole console session.
2023-02-09 15:20:11 <KipIngram   > So, joe9, all this stuff described in the rio man page.  What IS this exactly?  Is this meant to be an editor window, or a command console, or what exactly?
2023-02-09 15:20:34 <joe9        > it is a window manager.
2023-02-09 15:20:36 <KipIngram   > It has such a rich set of features, but I'm not quite getting how it all "comes together" into a coherent environment.
2023-02-09 15:20:46 <KipIngram   > Ok.
2023-02-09 15:21:02 <joe9        > try 9front in a vm. It will give you an idea.
2023-02-09 15:21:12 <joe9        > I suspect you will like it.
2023-02-09 15:21:32 <joe9        > Once you explore it, the ideas will stick with you as forth  has.
2023-02-09 15:22:28 <KipIngram   > Ok.  I don't have a vm setup on my system right now, but I can install one.
2023-02-09 15:24:13 <KipIngram   > Where would I pick up this 9front?
2023-02-09 15:25:02 <joe9        > try fqa.9front.org
2023-02-09 15:25:05 <joe9        > or, 9front.org
2023-02-09 15:25:30 <joe9        > It is an interesting system and once you explore it, working with X11 will feel like prostitution.
2023-02-09 15:26:05 <KipIngram   > Heh, don't knock the working girls.  They gotta get by too.  :-)
2023-02-09 15:26:34 <KipIngram   > I'm joking, but on the other hand I have legitimately always wondered why we have that outlawed.
2023-02-09 15:26:40 <joe9        > It is hard work to do what they do.
2023-02-09 15:26:50 <KipIngram   > Yeah, I agree.
2023-02-09 15:27:19 <KipIngram   > I think of it as one of those " victimless crimes," and I suspect that a lot of the evils that arise out of it are BECAUSE it's illegal, and they thus have no legal recourse when they're wronged.
2023-02-09 15:28:05 <joe9        > I agree.
2023-02-09 15:30:34 <KipIngram   > 9front.org is an... odd website.
2023-02-09 15:35:53 <joe9        > yes
2023-02-09 15:36:02 <joe9        > it will get you though over time.
2023-02-09 15:36:14 <joe9        > and #cat-v is the irc channel where they hang out.
2023-02-09 15:36:30 <joe9        > That channel can get real catty too.
2023-02-09 15:37:04 <joe9        > try this http://harmful.cat-v.org/ .
2023-02-09 15:37:18 <joe9        > Have you read unix haters book?
2023-02-09 15:37:39 <KipIngram   > No
2023-02-09 15:37:54 <joe9        > a must read, imho.
2023-02-09 15:38:06 <joe9        > there is a pdf of it floating around too.
2023-02-09 15:38:14 <joe9        > if you search hard enough.
2023-02-09 15:39:45 <joe9        > http://harmful.cat-v.org/software/
2023-02-09 15:41:06 <joe9        > I think most forthers will appreciate it.
2023-02-09 15:53:42 <MrMobius    > Definitely getting some Time Cube vibes from this 9front website
2023-02-09 15:53:42 <KipIngram   > Harmful thing = autoconf, cmake, etc. ; less harmful = "... plain makefiles"
2023-02-09 15:53:44 <KipIngram   > AMEN
2023-02-09 15:54:10 <KipIngram   > I've long felt that the make process has done nothing but gone downhill.
2023-02-09 15:54:31 <KipIngram   > I assume the people who've created the modern stuff think it's better - FOR THEM.  But i don't think it's better for us.
2023-02-09 15:54:53 <KipIngram   > It's become such a science that I can't look at it and plainly see what is going on anymore.
2023-02-09 15:54:59 <KipIngram   > And yeah, I'm sure I could learn.
2023-02-09 15:55:15 <KipIngram   > But that would involve devoting time to it, and I've got other things I want to put my energy into.
2023-02-09 15:55:34 <KipIngram   > Make made so much sense when I first encountered it.
2023-02-09 15:55:41 <thrig       > except for the tabs thing
2023-02-09 15:57:56 <KipIngram   > MrMobius: Yes, I like the "traditional" look of the website, and the crisp performance that comes with it.
2023-02-09 15:58:21 <MrMobius    > a lot of things are frustrating and generate hatred if you already have a way to do it and the new thing doesn't work like you like
2023-02-09 15:58:52 <MrMobius    > ie a lot of "____ is trash" would not exist if the person had learned that thing first
2023-02-09 15:59:16 <MrMobius    > in which case they thing they currently love would be trash
2023-02-09 16:01:15 <joe9        > 13:58 < MrMobius> ie a lot of "____ is trash" would not exist if the person had learned that thing first -- have you looked at the size of the linux man pages?
2023-02-09 16:02:07 <KipIngram   > Hmmm.
2023-02-09 16:02:13 <KipIngram   > I like the distributed nature of this.
2023-02-09 16:02:40 <KipIngram   > That's an idea I hadn't really given any thought to, but perhaps I should consider how I might bind several machines running this new Forth together into a distributed environment.
2023-02-09 16:02:58 <KipIngram   > SDL2 will bring me networking, so... why not?
2023-02-09 16:03:37 <joe9        > SDL2 will waste your time...
2023-02-09 16:04:35 <joe9        > if someone is paying you for this, sure, great idea. One can milk a lot of money going that route.
2023-02-09 16:04:58 <KipIngram   > :-)
2023-02-09 16:05:15 <KipIngram   > No, this is just a desire on my part to have some sort of nicely canned graphics capability.
2023-02-09 16:05:30 <KipIngram   > An awful lot of folks have used it, for it to be a complete time waste.
2023-02-09 16:05:37 <KipIngram   > It looks fairly straightforward.
2023-02-09 16:05:49 <joe9        > A lot of folks use linux too..
2023-02-09 16:06:06 <KipIngram   > I wrote a couple dozen lines of code last weekend or so and had characters from a font map showing up on the screen.
2023-02-09 16:06:08 <joe9        > just kidding, you will be fine either fine.
2023-02-09 16:06:13 <joe9        > way
2023-02-09 16:06:30 <joe9        > good luck.
2023-02-09 16:06:33 <KipIngram   > It's really more than I set out to find; it brings in more than just graphics.
2023-02-09 16:06:48 <KipIngram   > Well, this is looking interesting so far; I think I've got some reading to do tonight.
2023-02-09 18:38:57 <KipIngram   > Wikipedia on Plan9 not "taking over" against Unix/Linux: "the most dangerous enemy of a better solution is an existing codebase that is just good enough.
2023-02-09 18:39:03 <KipIngram   > "
2023-02-09 18:40:13 <KipIngram   > joe9: So, am I getting this right?  Using the tools in this system, one can connect one's own console to a process running on a remote computer?
2023-02-09 18:40:58 <KipIngram   > On your end you interact with something that looks like a local process but in fact is a comm utility, and on the other in the process thinks its dealing with a local console, when in fact it's dealing with a comm utility too?
2023-02-09 18:41:12 <KipIngram   > Except this "utility" actuall is just the os - it's what the os "does"?
2023-02-09 18:53:08 <KipIngram   > MrMobius, was it you that suggested a couple of weeks ago integrating ipfs into a Forth block system?
2023-02-09 18:53:42 <KipIngram   > That's also around the idea of extending reach beyond one centralized system.
2023-02-09 19:12:13 <joe9        > process running on a remote computer? -- yes. but, it is not the comm utility.
2023-02-09 19:12:23 <joe9        > the transport is part of the os.
2023-02-09 19:17:15 <KipIngram   > Yes, that's what I meant by "this 'utility" actually is just the os"
2023-02-09 19:17:40 <KipIngram   > Well, VirtualBox went in without any trouble.
2023-02-09 19:31:31 <joe9        > http://plan9.stanleylieber.com/_books/comp/plan9/Introduction.To.OS.Abstractions.Using.Plan.9.From.Bell.Labs.draft.2007.pdf relevant intro book
2023-02-09 20:02:41 <KipIngram   > Wow - that really starts at an elementary level.  :-)
2023-02-09 20:03:05 <thrig       > collecting silicon for a foundry?
2023-02-09 20:05:52 <KipIngram   > :-)  Not quite that elementary.
2023-02-09 20:06:03 <KipIngram   > But it begins as though the reader has never used a computer before.
2023-02-09 20:08:50 <thrig       > "our first goal will be to cause a supernova; eventually this will aggregate into a system of planets, and then we can ...
2023-02-09 20:09:42 <KipIngram   > It does appear this thing lets you edit almost anywhere.  They just mentioned editing a menu item, I think.
2023-02-09 20:10:41 <KipIngram   > Or maybe what's going on here is that you can click on any word on your screen, and it tries to interpret it as a command?
2023-02-09 20:11:04 <KipIngram   > So if you add a word somewhere and click it, that gets treated as a command.  It's like you can edit the gui.
2023-02-09 20:11:04 <thrig       > misclicks might get fun
2023-02-09 20:11:22 <KipIngram   > Yeah, I'm not immediately convinced it's good, but we'll see.
2023-02-09 20:11:35 <KipIngram   > It's got good pedigree - some quite well known names seem associated with it.
2023-02-09 20:11:51 <thrig       > some quite well known names are associated with Go
2023-02-09 20:12:07 <joe9        > thrig> misclicks might get fun -- try colorforth..
2023-02-09 20:12:32 <KipIngram   > Rob Pike, for example.
2023-02-09 20:23:31 <joe9        > KipIngram: I am impressed that you are still persisting. It is hard to learn.
2023-02-09 20:28:06 <KipIngram   > Well, I haven't really gotten to anything new and unfamiliar.
2023-02-09 20:41:33 <MrMobius    > KipIngram: not me. I am anti-block
2023-02-09 20:41:35 <MrMobius    > 
ACTION hides