2023-10-18 00:33:33 <KipIngram   > Hey, anyone heard of Clevo?
2023-10-18 00:33:55 <KipIngram   > https://clevo-computer.com/en
2023-10-18 00:34:42 <KipIngram   > Maybe next time I upgrade computers I'll take a look at them - looks like there's a degree of "configurability" in there offerings.
2023-10-18 00:48:54 <thrig       > probably you'd need a Universal Configurability Standard so cross vendor bits fit
2023-10-18 00:53:47 <KipIngram   > Wow - expensive stuff.
2023-10-18 00:54:22 <KipIngram   > Maybe I won't be buying my next computer from them.  :-)
2023-10-18 00:57:04 <thrig       > that's the other problem, aimed at rich folks who have the means
2023-10-18 00:57:17 <thrig       > if only there was some standard like MIDI or USB...
2023-10-18 00:58:23 <KipIngram   > Yeah, I'd say that's a "boutique business."
2023-10-18 00:58:35 <KipIngram   > Hmmm.  Maybe I oughta start a boutique business.
2023-10-18 00:59:20 <KipIngram   > Wonder if they designed their own motherboard or found one somewhere?
2023-10-18 00:59:29 <KipIngram   > Lot higher barrier to entry if you try to do it yourself.
2023-10-18 01:00:38 <KipIngram   > For something like that to "go," though, you'd need to be able toffer something that was flat out better than could be gotten anywhere else.  Or at least that you could convincingly MARKET as better than what could be gotten anywhere else.
2023-10-18 02:12:51 <KipIngram   > You know, the other possibility on this console interface front would be separate input and output windows.
2023-10-18 02:13:11 <KipIngram   > The only reason they're normally mixed is because that was effectively the only way to do it back in the tty days.
2023-10-18 02:14:29 <KipIngram   > And that model actually "ports to graphical" - AutoCAD used to have a command input window and then the main window was where you saw your (graphical) results.
2023-10-18 02:15:25 <KipIngram   > It's also a model I've used before with LaTeX.  I had to kind of roll my own toolchain, but I'd normally set up with a vim window on the left and a PDF window on the right.
2023-10-18 02:15:51 <KipIngram   > Edit my LaTeX on the left, and hit a hotkey - it would save that and render it to the PDF file, which would update in place.
2023-10-18 05:07:52 <KipIngram   > Oh, great.
2023-10-18 05:08:07 <KipIngram   > Amazon has created something they call "Alexa Presentation Language."
2023-10-18 05:08:24 <KipIngram   > So guess what's starting to show up in searches re: APL the programming language?
2023-10-18 05:16:27 <thrig       > only so many TLA
2023-10-18 05:27:22 <KipIngram   > What does that have to do with top loading artillery?  ;-)
2023-10-18 05:28:04 <KipIngram   > Once when I was quite a lot younger and the web wasn't very old yet, I wanted to study up on transformer design.
2023-10-18 05:28:13 <KipIngram   > All I could find was the cartoon.
2023-10-18 05:28:49 <KipIngram   > That seems like something that AI should help with eventually.
2023-10-18 05:29:00 <KipIngram   > I'm a 13 year old kid - tell me about transformers.
2023-10-18 05:29:02 <KipIngram   > ^ cartoon
2023-10-18 05:29:13 <KipIngram   > I'm an electrical engineer - tell me about transformers.
2023-10-18 05:29:20 <KipIngram   > ^ electromagnetic device
2023-10-18 05:29:29 <KipIngram   > That should be EASY.
2023-10-18 05:30:17 <KipIngram   > BTW, I don't know if there's even such a thing as top loading artillery.  Likely not.  I was just smarting off.
2023-10-18 05:30:33 <KipIngram   > Or, rather, trying to show in a cute way that I understood you.
2023-10-18 05:30:39 <KipIngram   > Three letter acronym, right?
2023-10-18 05:31:18 <KipIngram   > I guess there are 17576 of them, actually.
2023-10-18 05:32:16 <KipIngram   > Re: the AI, you wouldn't really even have to explicitly tell the thing those first sentences - it should be able to glean that much from your browsing history.
2023-10-18 05:33:58 <thrig       > ... probably they're instead trying to figure out how to stuff as many ads in front of your eyeballs
2023-10-18 05:34:05 <KipIngram   > No kidding.
2023-10-18 05:34:58 <KipIngram   > I think sometimes about trying to write an AI tools.  What I'd like is something that would sift online news sources for me.  Gradually learn what sort of thing I found useful.
2023-10-18 05:35:07 <KipIngram   > And I'd only trust it if I wrote it myself.
2023-10-18 05:36:43 <KipIngram   > Back when Stanford first started wanting to get into online education, it offered an artificial intelligence course for free - they wanted a trial audience for their machinery.
2023-10-18 05:37:04 <KipIngram   > it was pretty good - the professor was one of the guys that ran the Google self-driving car project.
2023-10-18 05:37:35 <KipIngram   > So now when I watch our little Roomba gadget cruise around and learn the house, I feel like I could write that code if I really needed to.
2023-10-18 05:38:00 <KipIngram   > There's actually not a whole lot of rocket science in those algorithms - it's fairly straightforward.  Just applied to a LOT of data.
2023-10-18 05:38:15 <KipIngram   > Lots of stuff involving Bayes Theorem.
2023-10-18 05:40:19 <KipIngram   > P(A|B) = P(B|A)*P(B)/P(A)
2023-10-18 06:13:45 <KipIngram   > Aha.  I've finally learned my way around these SDL2 event structures.
2023-10-18 06:14:02 <KipIngram   > Uses a union of a bunch of diferent structure types under the hood.
2023-10-18 07:26:37 <KipIngram   > Well, there's a disappointing bit of news.
2023-10-18 07:27:03 <KipIngram   > It looks like Wayland doesn't provide any functionality for packages like SDL2 to move windows natively.
2023-10-18 07:27:32 <KipIngram   > If I decorate the window with a titlebar, I can grab that and drag the window around - that works.
2023-10-18 07:27:45 <KipIngram   > But I assume that's Wayland doing the moving, not SDL2.
2023-10-18 07:28:01 <KipIngram   > If the window doesn't have a titlebar it seems I can't move it at all.
2023-10-18 07:28:19 <KipIngram   > I was planning to tile several windows onto the screen, with each one a separate SDL2 window.
2023-10-18 07:28:38 <KipIngram   > But it looks like instead I'm going to have to open a window fullscreen (that works) and tile it up manurally.
2023-10-18 07:28:51 <KipIngram   > This was a "security decision" on wayland's part.
2023-10-18 07:28:53 <KipIngram   > Of couse.
2023-10-18 12:24:56 <veltas      > KipIngram: Even in X you shouldn't be moving the window really, that's the window manager's job; right?
2023-10-18 15:38:30 <KipIngram   > That seems to be the reasoning driving the Wayland guys.
2023-10-18 15:39:07 <KipIngram   > Then why does SDL2 offer a function SDL_SetWindowPosition()?
2023-10-18 15:39:35 <KipIngram   > What it means at the very least is that I have to learn another system, link another library, etc. in order to be able to do it some other way.
2023-10-18 15:40:31 <KipIngram   > If I indeed do it that way - there is a possible workaround where I just open a full screen window initially and then use the SDL_CreateRGBSurfaceFrom() call.  Apparently that lets you  make a surface entity which "peers into" a parent surface.
2023-10-18 15:40:37 <KipIngram   > That may be good enough.
2023-10-18 15:41:33 <KipIngram   > I'll have a full screen surface and then a set of window surfaces that tile that parent surface.
2023-10-18 15:42:06 <KipIngram   > I haven't tried it yet, so I don't know what gotchas may be involved.
2023-10-18 15:44:54 <KipIngram   > I found the whole discussion of it online annoying - just another instance where someone makes some decision and then ridicules people who aren't happy with it.  Arrogance - like even wanting to do something they decided you can't do is a sign of stupidity and ignorance.
2023-10-18 15:45:07 <KipIngram   > I find arrogance terribly unappealing.
2023-10-18 15:55:25 <KipIngram   > But there seems to be an enormous amount of it in online software discussions.
2023-10-18 16:31:01 <veltas      > KipIngram: I believe that's how apps do custom window borders, by simulating it all themselves
2023-10-18 16:31:18 <veltas      > In Wayland I suspect they have a special interface for doing this specifically
2023-10-18 16:31:24 <KipIngram   > Yes.
2023-10-18 16:31:45 <KipIngram   > See, "more special interfaces" is exactly what i want to avoid.
2023-10-18 16:31:46 <veltas      > Allowing apps to set their position allows a lot of bad behavior... but honestly an app can be bad other ways
2023-10-18 16:31:53 <KipIngram   > I'm swallowing this SDL library pill.
2023-10-18 16:32:00 <KipIngram   > I don't want to also swallow another one.
2023-10-18 16:32:21 <veltas      > I think my suggestion of developing your own interface is best here
2023-10-18 16:32:37 <veltas      > Because the interface can be far simpler than what SDL etc does
2023-10-18 16:32:54 <veltas      > Why are you supporting custom window borders anyway? Is that the goal?
2023-10-18 16:33:03 <KipIngram   > no, not really.
2023-10-18 16:33:05 <veltas      > Or is it just incidental?
2023-10-18 16:33:11 <KipIngram   > I don't really want borders at all.
2023-10-18 16:33:30 <KipIngram   > I just want to tile windows on the screen, but I want to put them exactly where I want them.
2023-10-18 16:33:43 <KipIngram   > The problem is being able to move the window around.
2023-10-18 16:33:55 <KipIngram   > SDL2 has a call for that, but it doesn't work under Wayland.
2023-10-18 16:34:28 <KipIngram   > I can't move it, and I can't just tell it where I want it when I create it.
2023-10-18 16:34:39 <KipIngram   > Well, I can, but it doesn't change anything.
2023-10-18 16:34:56 <KipIngram   > This subsurface thing may take care of me, though.
2023-10-18 16:35:12 <KipIngram   > I've got something to try.
2023-10-18 16:35:46 <KipIngram   > Opening a full-screen window works fine.
2023-10-18 16:36:21 <KipIngram   > Then I can create subsurfaces that match up with portions of that main surface.
2023-10-18 16:36:49 <KipIngram   > I just don't want to ONLY be able to regard it as one big surface, because then I'd have to handle all the window clipping myself.
2023-10-18 16:37:10 <KipIngram   > But subsurfaces will have "boundaries" that match where I want them on the screen.
2023-10-18 16:39:08 <KipIngram   > If I do decide I want "decorations" on those tiles (there will at least be boundary lines), I'm fine with drawing those on the main surface myself and then set the subsurfaces to be inside those.
2023-10-18 16:40:15 <KipIngram   > I'm not really a fan of too much decoraton, though.  First thing I do when I set up terminator on a system is turn off the title and scroll bars.
2023-10-18 16:40:43 <KipIngram   > I just have one-pixel lines between my tiles and the whole rest of the screen is all business.
2023-10-18 16:54:53 <veltas      > To set window positions you'd need to write a window manager for wayland probab;y
2023-10-18 16:55:30 <veltas      > The problem with things like wayland is eventually someone finds a reason they didn't think of, or just doesn't care about their argument, and adds a separate protocol for moving windows.
2023-10-18 16:55:39 <veltas      > And now wayland doesn't work without that extra protocol
2023-10-18 16:55:45 <veltas      > And we have X11 all over again
2023-10-18 16:56:51 <KipIngram   > Yeah.  Darn people.  Always wanting to do think in a way that makes sense to them.  :-)
2023-10-18 16:57:00 <KipIngram   > s/think/things/
2023-10-18 16:59:21 <KipIngram   > Ok, let's say this is how things are.  I think what should have been done is that the SDL guys should have written SDL_SetWindowPosition() so that it did that for me through Wayland, instead of just punting.
2023-10-18 16:59:30 <KipIngram   > Otherwise they don't really "work" under Wayland.
2023-10-18 16:59:54 <KipIngram   > If you have a function in your library, it needs to work everywhere you claim to be able to run.
2023-10-18 17:00:26 <KipIngram   > Maybe they don't claim to run fully under Wayland, but... lame.
2023-10-18 17:00:36 <Zarutian_iPad> and this is why I do gfx and such via vnc/rfb
2023-10-18 17:01:12 <KipIngram   > Anyway, now I'm just complaining for the sake of it - I think I know what to do to get what I want.
2023-10-18 17:01:14 <KipIngram   > o
2023-10-18 17:01:25 <KipIngram   > I'm fine with this subsurface approach, if it works the way I think it will.
2023-10-18 17:02:27 <KipIngram   > But I think the idea that they've plugged some security hole is silly - why couldn't I just open an invisible FULL SCREEN window instead of a window on top of someone's password box?
2023-10-18 17:02:45 <KipIngram   > Seems to me I could still try to play the same trick, in spite of them narrowing down the ways of doing it.
2023-10-18 17:03:18 <KipIngram   > Kind of like how my company turned off our ability to write USB sticks to 'protect IP' but didn't turn off the ability to burn DVDs via USB.
2023-10-18 17:03:34 <KipIngram   > Maybe I can't write IP to a stick, but I could merrily burn it to DVDs.
2023-10-18 17:03:41 <KipIngram   > That gets it out the door just as well.
2023-10-18 17:03:53 <KipIngram   > So they imposed a massive inconvenience and accomplished... NOTHING.
2023-10-18 17:04:04 <KipIngram   > Except the had the ability to tell their bosses "we did something."
2023-10-18 17:05:44 <Zarutian_iPad> checkbox-compliance kind of thing
2023-10-18 17:06:13 <KipIngram   > Yes>  I think "we took action" drives a huge percentage of corporate processes.
2023-10-18 17:24:37 <KipIngram   > If you think about it, it's predicated on their boss not knowing enough about the issue to see that their action wouldn't fully solve the problem.
2023-10-18 17:26:10 <KipIngram   > I think it'd be funny if the first thing their boss said was "what about DVD drives?"
2023-10-18 17:26:31 <KipIngram   > but the boss probably doesn't know that DVD drives still work.
2023-10-18 17:37:13 <KipIngram   > I guess we could call that "managing upward."
2023-10-18 17:37:27 <KipIngram   > Important skill, I guess.  :-)
2023-10-18 17:43:38 <KipIngram   > So, what do you guys think about these two ways of re-using earlier commands?  The "bash way," where you cursor up and old lines appear on the line you're typing, or the "APL way" where you actually move back up the screen into the previously typed stuff and make modifications there?
2023-10-18 17:44:04 <KipIngram   > Those modification don't stick - the earlier stuff returns to its previous value.  Either way the  FINISHED new line appears down at the bottom, just as though you'd typed it.
2023-10-18 17:44:22 <Zarutian_iPad> bash way because the other gives me therac-25 vibes
2023-10-18 17:44:27 <KipIngram   > One advantage of the APL way is that you can modify several lines, and it will send all of them out one by one.
2023-10-18 17:44:48 <KipIngram   > I'm having to look that up...
2023-10-18 17:45:01 <KipIngram   > Oh.  Cool.
2023-10-18 17:45:30 <KipIngram   > I'm leaning APL way at the moment, but still fretting over it.
2023-10-18 17:46:05 <KipIngram   > Another advantage (if you think of it as advantageous) of the APL way is that you can use OUTPUT lines that way too.
2023-10-18 17:46:12 <KipIngram   > I.e., you can turn them into new input.
2023-10-18 17:46:18 <KipIngram   > I don't know how often that would be useful.
2023-10-18 17:50:51 <KipIngram   > As far as I can tell, any of the lines back up the screen that you actually TYPE something on - even just a space - get flagged for issue as new input.  And they just go in order top to bottom.
2023-10-18 17:51:23 <KipIngram   > The modified lines get echoed down at the bottom and the edits up-screen get reverted out.
2023-10-18 17:51:33 <thrig       > didn't plan9 have something that you could edit code anywhere
2023-10-18 17:51:41 <KipIngram   > Yes, acme.
2023-10-18 17:51:52 <KipIngram   > And maybe other things - acme is just the one i've read about.
2023-10-18 17:52:19 <KipIngram   > Basically you could type a command string anywhere, and then if you clicked on it with the mouse it got executed.
2023-10-18 17:52:27 <KipIngram   > So you could hand craft your user interface that way.
2023-10-18 17:52:59 <KipIngram   > It's an interesting idea - lets you kind have a little "scratch pad" menu type system.
2023-10-18 17:53:23 <thrig       > don't misclick that rm -rf ?
2023-10-18 17:53:36 <KipIngram   > Indeed.
2023-10-18 17:54:14 <KipIngram   > I once did a rm -r *<something> once and inadvertently got a space between * and <something>>  :-(
2023-10-18 17:54:30 <KipIngram   > Killed a source file I'd worked on for about two weeks.
2023-10-18 17:55:02 <KipIngram   > I got lucky that day, though; some clever grep on raw disk sectors found 99% of it for me.
2023-10-18 17:55:14 <KipIngram   > I was able to remember my last couple of edits well enough to write the grep search string.
2023-10-18 17:55:29 <KipIngram   > I copied out the right stuff and only had to make a couple of minor mods to get it back.
2023-10-18 17:55:49 <KipIngram   > Grep was a very good friend that day.
2023-10-18 17:56:12 <thrig       > Apple used to name disks "Macintosh HD". then they started writing unix scripts for the iTunes installer
2023-10-18 17:56:33 <KipIngram   > That's already worrisome.
2023-10-18 17:56:49 <KipIngram   > Spaces are always suspect.
2023-10-18 17:57:17 <thrig       > many bothans (files) died, etc
2023-10-18 18:05:44 <KipIngram   > Very sad.
2023-10-18 18:06:03 <KipIngram   > Entire crops were lost.
2023-10-18 18:28:57 <KipIngram   > Still have in the back of my mind how to do hash tables, with the table doubling thing.
2023-10-18 18:32:44 <KipIngram   > I'm leaning toward having a packed array of counted strings at the bottom of the RAM region.  Then the hash table proper at the top, and its entries will contain a 16-bit offset into that packed array for name checking.  The "real" payload could go either place - either in the hash table itself or adjacent to the names.
2023-10-18 18:33:47 <KipIngram   > To look an entry up you'd hash the name, find the name string offset, and check it.  If it matches, great.  If it doesn't, you'd just advance to the next slot and check again (must have had a collision at some point).  You'd need to reach an "empty" slot in order to know that the string was not there.
2023-10-18 18:34:40 <KipIngram   > It would be possible to delete entries - you'd remove the name string from the packed array, and shift everything else down.  Then you'd have to o through the hash table and adjust everyone that affected.
2023-10-18 18:35:08 <KipIngram   > Deletion probably would not be O(1), but inserts and lookups would be, at least in an amortized way.
2023-10-18 18:38:16 <KipIngram   > I kind of like the notion of putting the payload with the name strings - it means the hash table can just be 16-bit items and the code to manage that would be un-influenced by changes to what you were using the table to store.
2023-10-18 18:38:46 <KipIngram   > For dictionary purposes that payload will be the address of the word's implementation.
2023-10-18 19:00:38 <KipIngram   > The next question then becomes, "Do I write the low-level hash table code using my virtual machine language (portability)?  Or in native assembly (performance)?"
2023-10-18 19:02:26 <KipIngram   > I think it will be a fairly modest amount of code - it might be worth implementing it in "native tongue" for whatever platform I'm interested in.
2023-10-18 19:10:42 <thrig       > I sometimes end up with scripts in perl for portability and also C for speeds on my more used platforms
2023-10-18 19:16:02 <KipIngram   > Yeah, same idea.  It helps to get this boiled down to some quite simple operation.  I'm more willing to do some porting work if it's not too onerous.
2023-10-18 19:17:41 <KipIngram   > Now I'm thinking of having two RAM regions.  One will just be packed entries of <value> <key> pairs.  The keys are counted strings.  So, that's something I could search linearly, with no more muss or fuss.  But then I can attach another RAM region to that with a hash-based "index."
2023-10-18 19:17:52 <KipIngram   > That would bring O(1) performance to the table.
2023-10-18 19:18:19 <KipIngram   > If I want to look an item up while I'm in the middle of a table doubling or halving operation, I could fall back to a linear search.
2023-10-18 19:19:13 <KipIngram   > The table itself will just store in a plain vanilla variable - a pointer to the <value>, <key> table.  Then a few cells at the beginnin of that region will point to the index.
2023-10-18 19:19:37 <KipIngram   > I may not be making it very clear, but it looks simple and easy.
2023-10-18 19:21:31 <KipIngram   > I think with a couple of well-chosen "management" variables I can make the mechanism flexible across different sorts of payload, different types of keys, etc.
2023-10-18 19:22:58 <KipIngram   > I.e., I'd be able to use it anywhere in applications where a dictionary type thing would be useful.
2023-10-18 19:24:41 <KipIngram   > The main reason I'd be deleting items, at least for "Forth purposes," would be to support .: / .wipe.  But if delete is going to be O(N), then it might be smarter for me to just open a new table for temporary names and then throw the whole thing away on .wipe.
2023-10-18 19:24:53 <KipIngram   > I see no reason that wouldn't work fine.
2023-10-18 19:25:21 <KipIngram   > I'll normally be searching a list of vocabularies anyway - that would just mean one additional one whenever temporary names existed.
2023-10-18 19:26:08 <KipIngram   > It would be a vocabulary that sat permanently as the first item in the search order.  Usually it would be empty, but .: words would go there and .wipe would empty it.
2023-10-18 19:27:21 <KipIngram   > And it's kind of nice knowing that the first item will never change - it means I'd not have to "special case" adding a vocabulary to the "start" of the search order (which otherwise would mean updating the variable pointing to the list0.
2023-10-18 19:40:16 <KipIngram   > I'm looking at winding up with this:
2023-10-18 19:40:26 <KipIngram   > : set  ( value key table --) ... ;
2023-10-18 19:40:41 <KipIngram   > : get  ( key table -- value) ... ;
2023-10-18 19:41:04 <KipIngram   > Then perhaps clr for deletion.
2023-10-18 19:51:45 <KipIngram   > Actually I recall now that deletion is also O(1) - what they do is just look the item up and mark as dead.  The entry actually gets swept out on next table double / halve.
2023-10-18 19:56:47 <KipIngram   > So,
2023-10-18 19:56:55 <KipIngram   > : clr  ( key table --) ... ;
2023-10-18 19:59:05 <KipIngram   > Guess I'll need words for creating an empty table and throwing a table completely away.
2023-10-18 19:59:54 <KipIngram   > And it might be nice to be able to "erase" a table (for .wipe).
2023-10-18 20:00:22 <KipIngram   > That will actually be clr - I'll use del for deleting an item.
2023-10-18 20:04:30 <KipIngram   > https://pastebin.com/hAE1bRtM
2023-10-18 20:05:13 <KipIngram   > The "types" referred to there will default on 0 0 to value type = integer, key type = counted string.
2023-10-18 20:05:31 <KipIngram   > And to do anything else will require type support and will come later.
2023-10-18 20:13:41 <KipIngram   > I may go ahead and define the first few type values, even though they won't be explicitly used. 0 = cell, 1 = half, 2 = word, 3 = byte, 4 = counted string, 5 = null terminated string.
2023-10-18 20:14:28 <KipIngram   > I guess that's really more about "size" than type, since it pays no regard to things like signed / unsigned, etc.
2023-10-18 20:14:58 <KipIngram   > Might should include float.
2023-10-18 20:36:39 <KipIngram   > I was thinking of having the hash table be just a table of 16-bit values, based on the notion that every vocabulary gets its own, and 64kB would be plenty big for any single vocabulary.  But... if I want it to be a general purpose tool, maybe I should make those 32-bit values.  Applications may arise where I want to have larger tables.
2023-10-18 20:39:08 <KipIngram   > This is really starting to edge over into database thinking - we've got a table of records and an index into it.  Hash index is appropriate for certain types of keys; other key types might use a different sort of index structure (like an array).
2023-10-18 20:40:22 <KipIngram   > I mentioned using well-chosen management variables to make it flexible - that could also allow me to extend it into disk block stored tables.