2023-10-26 04:41:19 <rendar      > KipIngram, crc, and all others: thanks for your feedback, it has been very important to me :)
2023-10-26 04:41:39 <rendar      > KipIngram, yes it's a kind of "help facility" i have for each word
2023-10-26 04:42:47 <rendar      > KipIngram, my idea of homoiconicity was "a stack as a type"
2023-10-26 04:43:03 <rendar      > a forth stack as a normal type you have in the stack!
2023-10-26 05:02:17 <olle        > Sounds like Smalltalk to me ;)
2023-10-26 05:02:29 <rendar      > :)
2023-10-26 05:02:39 <rendar      > smalltalk let you to do that?
2023-10-26 05:02:40 <olle        > I'm doing some pipeline-oriented programming in PHP, and yea I have nested pipes
2023-10-26 05:03:01 <olle        > rendar: Nah, just that "everything is an object" meaning a stack is an object, which could contain other objects (which could be stacks themselves)
2023-10-26 05:03:05 <rendar      > hmm i'm not so familiar with the concept of 'nested pipes'
2023-10-26 05:03:11 <rendar      > olle, oh i see
2023-10-26 05:24:36 <olle        > pipe(do_thing, do_other_thing, pipe(foo, bar)); // nested pipes
2023-10-26 05:25:00 <olle        > Both pipes and Forth has "implicit glue", as I call it :)
2023-10-26 05:25:03 <olle        > have*
2023-10-26 05:30:41 <veltas      > KipIngram: XOR is the same as + in 1-bit anyway
2023-10-26 05:31:02 <veltas      > So it makes sense and I would be confused by someone using + for something else
2023-10-26 05:31:11 <veltas      > In boolean algebra
2023-10-26 05:59:31 <olle        > Hm no channel for Factor?
2023-10-26 07:08:07 <KipIngram   > I know - that's part of Boole's original work being more closely connected to math.  The newer stuff uses + to represent inclusive or, which is a step away from that.
2023-10-26 07:50:03 <olle        > I want a configurable stack where the side-effects of writing to file/db/stdout/etc can be mocked during unit testing.
2023-10-26 07:50:15 <olle        > Maybe that can already be done with a vocabulary?
2023-10-26 08:12:35 <KipIngram   > What would an example of that  "mocking' be?
2023-10-26 08:15:58 <olle        > KipIngram: Replace a database call to fetch a user with a direct user object, for example.
2023-10-26 08:17:30 <GeDaMo      > I'm not sure where the stack would figure here, it would be about replacing the DB words
2023-10-26 08:18:13 <KipIngram   > Yes, I'm not immediately seeing that either.
2023-10-26 08:19:05 <KipIngram   > You mean that a word that would normally fetch something from a database gets a direct user interaction instead?  Interactive input?
2023-10-26 08:19:10 <GeDaMo      > You could use a separate vocabulary for the mocking versions of words
2023-10-26 08:19:34 <GeDaMo      > Switch to the mocking vocab then redefine the words which are being tested so they pick up on the mock versions
2023-10-26 08:19:35 <KipIngram   > Right - you'd just establish a different vocabularly list for the test run.
2023-10-26 08:21:03 <olle        > GeDaMo: That'd be more Forth-like I guess, yes :)
2023-10-26 08:22:32 <olle        > Maybe they do this in Factor already :d
2023-10-26 08:27:55 <KipIngram   > I'm just not getting how the "configurable stack" comes into it.
2023-10-26 08:31:15 <veltas      > I had assumed they meant 'stack' as in a layer of software rather than a 'stack' data structure
2023-10-26 08:31:43 <veltas      > But maybe they do want a stack, seems over-engineered if so
2023-10-26 08:33:03 <veltas      > olle: I think in microsoft's standard library and I assume others, the FILE objects have a secret overload parameter that's used to redirect I/O to buffers etc, so that i.e. vfprintf() can be the 'real' formatted printing function
2023-10-26 08:33:24 <veltas      > I think this is reasonable and would do the same, by wrapping the file I/O functions
2023-10-26 08:34:04 <veltas      > It's basically like polymorphism with the FILE* type, seems correct to me :)
2023-10-26 08:52:24 <KipIngram   > Oh, ok - that makes sense.
2023-10-26 08:52:35 <KipIngram   > I was trying to think of the Forth stack.
2023-10-26 08:52:58 <KipIngram   > Yeah, the question makes a lot more sense looking at it that way.  :-)
2023-10-26 08:53:49 <GeDaMo      > If you want to change the meanings of words without recompiling, you can use defer words
2023-10-26 08:58:40 <KipIngram   > I can do that to any word in my system, just as a consequence of the architecture.
2023-10-26 08:59:06 <KipIngram   > There's a level of indirection in there I can re-vector.
2023-10-26 08:59:40 <KipIngram   > It's just a consequence of separating headers and bodies.
2023-10-26 09:00:18 <KipIngram   > Compiled definitions have pointers into the headers, then they have pointers to bodies.
2023-10-26 09:00:39 <KipIngram   > The one I'm planning now won't have that.
2023-10-26 09:02:21 <KipIngram   > olle: If you have a "test vocabulary" that you can optionally compile with, then of course you're not really testing those words - you're actually testing the words that use those words.
2023-10-26 09:04:14 <KipIngram   > You could also have a separate test program that used the words under test within some special test harness.  So together those two things let you "test from below" and "test from above."
2023-10-26 09:06:52 <KipIngram   > :-) a "test sandwich."
2023-10-26 09:33:51 <olle        > KipIngram: Usually the goal is to split a test suite in two: one with mocking and one (slower) with fixtures
2023-10-26 09:37:03 <KipIngram   > "Fixtures" - you mean tooling to collect additional information?
2023-10-26 09:55:53 <olle        > KipIngram: A fixture is a dummy database or file setup, for example
2023-10-26 09:56:00 <olle        > Example data to be used by a test
2023-10-26 10:49:28 <rendar      > yeah a fixture is a virtual something, that instead of doing the action, it tells you that it *would* do that, printing something or even returning an error to debug
2023-10-26 10:49:35 <rendar      > like /dev/full
2023-10-26 10:51:00 <olle        > rendar: that might be more like a mock, I think
2023-10-26 10:51:07 <olle        > Or I have it mixed up a bit
2023-10-26 10:51:41 <rendar      > i was thinking:
2023-10-26 10:52:36 <rendar      > if we have this Forth: `"nasa.gov" get-url 2 2 +` it will pop the url and initiate the http request, but it won't calc 2 2 + until the url isn't downloaded
2023-10-26 10:52:49 <rendar      > how could we introduce async words in Forth?
2023-10-26 10:53:23 <olle        > rendar: Make a new word `async` that brances the process?
2023-10-26 10:53:28 <olle        > Oh
2023-10-26 10:53:32 <olle        > That's your question :)
2023-10-26 10:53:38 <olle        > Or?
2023-10-26 10:53:59 <olle        > You need a word that tells the system that the next words should be done concurrently or?
2023-10-26 10:55:07 <rendar      > even if i have an async word,  what would `"url.com" async get-url` result into the stack?
2023-10-26 10:57:05 <olle        > Hm
2023-10-26 11:02:45 <olle        > Maybe it would have to be multiple words, like a class def? `async foo and bar endasync` where `and` splits the things to do
2023-10-26 11:02:56 <olle        > runasync better
2023-10-26 11:06:41 <rendar      > wait
2023-10-26 11:07:12 <rendar      > olle, you mean that inside the async bloc foo and bar would run concurrently, but the execution will still block until 'endasync' ?
2023-10-26 11:08:25 <olle        > rendar: yea endasync is the await, sorry
2023-10-26 11:08:35 <olle        > but you can `and` any number of steps like that
2023-10-26 11:12:39 <rendar      > hmm
2023-10-26 11:13:15 <rendar      > so your basic idea is to always have a blocking "block" (sorry for the pun) but where you can put several things that will run concurrently
2023-10-26 11:13:27 <rendar      > and then push results into the stack
2023-10-26 11:13:32 <rendar      > when all concurrent jobs are done
2023-10-26 11:13:36 <olle        > Yea, feels natural to me :)
2023-10-26 11:13:42 <rendar      > yeah, good idea
2023-10-26 11:15:10 <olle        > But no idea about implementation details, and that each unit needs its own call stack etc
2023-10-26 11:20:15 <rendar      > yeah
2023-10-26 11:21:21 <KipIngram   > I see.
2023-10-26 11:21:53 <KipIngram   > My somewhat "hacky" software background is showing here.  :-)
2023-10-26 11:22:09 <KipIngram   > I'm really a hardware guy that has "putzed around" with software a fair bit.
2023-10-26 11:22:26 <KipIngram   > I have tried to read about some of the formal CS stuff, but that's all been strictly "self-study."
2023-10-26 11:25:23 <rendar      > KipIngram, i see.. speaking of hardware, i saw a presentation from Chuck Moore time ago, where he presented like a board.. with 177 computations units or something like that, all working with Forth
2023-10-26 11:25:33 <rendar      > what was that? a distributed computing card?
2023-10-26 11:25:35 <olle        > Hehe
2023-10-26 11:25:48 <olle        > pine64 has a board with 6 pine64 units on, max
2023-10-26 11:25:54 <olle        > but never found a use for it
2023-10-26 11:26:06 <rendar      > olle, but is that distributed Forth?
2023-10-26 11:29:32 <zelgomer    > rendar: you're talking about the GA144
2023-10-26 11:30:12 <rendar      > zelgomer, right!
2023-10-26 11:30:14 <rendar      > what's that?
2023-10-26 11:31:06 <zelgomer    > it's a microchip they've developed at green arrays with 144 cores and a very forthy ISA
2023-10-26 11:31:25 <zelgomer    > each core has something like 128 bytes of memory
2023-10-26 11:31:42 <zelgomer    > and at idle it consumes almost no power
2023-10-26 11:32:06 <zelgomer    > he was going on about how low power computing is going to be important for the future when we start injecting ourselves with nanoparticles which scares the absolute shit out of me
2023-10-26 11:32:37 <dzho        > "he"?
2023-10-26 11:32:55 <zelgomer    > Chuck Moore
2023-10-26 11:33:11 <zelgomer    > rendar> KipIngram, i see.. speaking of hardware, i saw a presentation from Chuck Moore
2023-10-26 11:33:11 <dzho        > I thought that was probably it but figured it didn't hurt to check
2023-10-26 11:33:32 <dzho        > 85 yo last month
2023-10-26 11:34:02 <rendar      > zelgomer, that's very interesting
2023-10-26 11:34:13 <rendar      > yeah i agree with you, the future belongs to ARM and RiscV
2023-10-26 11:34:31 <rendar      > but those 144 cores work independently?
2023-10-26 11:34:56 <zelgomer    > yes, and they can each communicate with their adjacent neighbors
2023-10-26 11:35:01 <rendar      > and, the cpu has an internal stack to achieve its 'very forthy ISA' ?
2023-10-26 11:35:28 <gordonjcp   > transputers were going to be the future
2023-10-26 11:35:55 <zelgomer    > it's not just the stack, but the instructions themselves are basically forth code words. dup and swap and so on, and you can encode like up to three operations in each instruction
2023-10-26 11:37:09 <rendar      > oh!
2023-10-26 11:37:16 <rendar      > so you have a forthy microcode
2023-10-26 11:37:32 <rendar      > that's very interesting, is this ISA described in some document?
2023-10-26 11:37:55 <gordonjcp   > there have been a few chips like that, RTX2000 and so on
2023-10-26 11:38:09 <GeDaMo      > https://www.greenarraychips.com/
2023-10-26 11:38:11 <gordonjcp   > wasn't one of the HP minis basically a 16-bit stack CPU?
2023-10-26 11:39:19 <zelgomer    > iirc i think there was like a partitioning to it. i.e., opcodes within a certain range were built-in instructions, opcodes above that were user-defined forth words
2023-10-26 11:39:37 <gordonjcp   > mmm
2023-10-26 11:39:39 <gordonjcp   > that makes sense
2023-10-26 11:39:58 <gordonjcp   > I guess you could do something like just have every memory cell be either an address or a literal value
2023-10-26 11:40:36 <gordonjcp   > and decide that the first 256 values were opcodes, so 0000h to 00ffh are opcodes and cannot be used as user word pointers
2023-10-26 11:41:17 <gordonjcp   > you could still use those memory addresses to store values, because 0000 @ would still work, but using 0000h as an "instruction" would call that opcode
2023-10-26 11:56:33 <KipIngram   > rendar: The GA144?
2023-10-26 11:56:39 <KipIngram   > Nice chip.
2023-10-26 11:56:42 <rendar      > yeah
2023-10-26 11:56:56 <KipIngram   > totally asynchronous design, which is exceptional all on its own.
2023-10-26 11:57:13 <rendar      > very cool that each core can communicate with its immediate neighbor
2023-10-26 11:57:14 <KipIngram   > And when you realize Chuck designed it completely using no "off the shelf" CAD, it's extra remarkable.
2023-10-26 11:57:18 <KipIngram   > Yes.
2023-10-26 11:57:31 <rendar      > wow
2023-10-26 11:57:44 <KipIngram   > Each core is very small; I feel like that changes "programming it" from the normal 'embedded experience' to more like doing a circuit design.
2023-10-26 11:57:47 <rendar      > wait, totally async design? can you elaborate on this? every instruction is async?
2023-10-26 11:57:56 <KipIngram   > There is no clock.
2023-10-26 11:58:02 <rendar      > oh!
2023-10-26 11:58:04 <KipIngram   > Signals just flow through the thing.
2023-10-26 11:58:12 <KipIngram   > And data exchanges use a back and forth handshake.
2023-10-26 11:58:24 <KipIngram   > The big payoff is that parts of the circuit where nothing is changing consume almost no power.
2023-10-26 11:58:28 <rendar      > data exchanges between cores
2023-10-26 11:58:36 <KipIngram   > Or within cores.
2023-10-26 11:58:45 <KipIngram   > It's TOTALLY asynchronous.
2023-10-26 11:58:54 <rendar      > that's incredible, that happens because there is no clock, right?
2023-10-26 11:58:58 <KipIngram   > Right.
2023-10-26 11:59:20 <rendar      > instead, with a clock, you'd need to loop over HLT instructions or something like that i guess
2023-10-26 11:59:25 <KipIngram   > By and large, "digital design" MEANS synchronous - it's very rare to find fully asynch stuff.
2023-10-26 11:59:38 <rendar      > yeah i agree
2023-10-26 11:59:44 <KipIngram   > With a clock it doesn't matter how the signals behave in between clocks - it's only their value at the clock edge that matters.
2023-10-26 11:59:52 <KipIngram   > Which solves a lot of dicey timing problems for you.
2023-10-26 11:59:59 <KipIngram   > It's easier to design synch logic.
2023-10-26 12:00:28 <KipIngram   > So not only did he undertake an incredible challenge - he actually made it work.
2023-10-26 12:00:47 <KipIngram   > And did it without any professional tools.
2023-10-26 12:00:47 <rendar      > indeed
2023-10-26 12:00:54 <rendar      > Chuck is incredible!
2023-10-26 12:00:54 <KipIngram   > I think it's more or less heroic.
2023-10-26 12:01:01 <KipIngram   > He really is remarkable.
2023-10-26 12:03:23 <rendar      > i agree
2023-10-26 12:03:41 <rendar      > and we can just imitate him! for where we can.. :)
2023-10-26 12:13:55 <KipIngram   > Yes - good role model.
2023-10-26 12:23:04 <olle        > Isn't he a crazy person?
2023-10-26 12:23:25 <olle        > Wait that's Charles H. Moore
2023-10-26 12:23:48 <olle        > Is he called chuck?
2023-10-26 12:25:43 <GeDaMo      > https://colorforth.github.io/index.html
2023-10-26 12:26:08 <GeDaMo      > "Chuck Moore's colorForth, OKAD and S40 Forth Multicomputer chip"
2023-10-26 12:26:35 <dzho        > dang, almost 10 years
2023-10-26 12:27:29 <dzho        > https://colorforth.github.io/Crispin.htm <-- yesterday was St. Crispin's day, for what it's worth
2023-10-26 12:37:29 <rendar      > olle, the name 'Charles' is often abbreviated as 'Chuck'
2023-10-26 12:39:33 <olle        > Got it
2023-10-26 12:40:05 <KipIngram   > Yes, Charles / Chuck.
2023-10-26 12:40:32 <KipIngram   > He's... "interesting."  Critics might call him crazy, due to his very hard core views on certain things.
2023-10-26 12:40:40 <KipIngram   > I think he's awesome, though.
2023-10-26 12:41:57 <KipIngram   > He's... "uncompromising."
2023-10-26 12:42:10 <GeDaMo      > He walks a different path :P
2023-10-26 12:42:17 <KipIngram   > And if you don't like his ideas, he really doesn't care.
2023-10-26 12:42:32 <KipIngram   > Right - he does, and you're free to follow if it suits you.
2023-10-26 12:44:28 <GeDaMo      > https://www.forth.com/resources/space-applications/
2023-10-26 12:55:15 <KipIngram   > I guess I just have a fondness for "mavericks."
2023-10-26 12:57:01 <KipIngram   > There's plenty of conformity in the world - we needs a few folks bucking the trend.
2023-10-26 12:59:52 <rendar      > core views on certain things?
2023-10-26 13:16:07 <KipIngram   > Yes, on specific things.  For example, one of the big ones is that he's very anti- "libraries."  As in software libraries.  He advocates solving precisely the problem you face, from scratch and with no "extra hooks" of any kind.
2023-10-26 13:16:21 <KipIngram   > He believes this gets you a substantially better solution.
2023-10-26 13:17:16 <thrig       > and sometimes you just want to call a sqrt without having to write it yourself
2023-10-26 13:17:19 <KipIngram   > He uses fixed point scaled arithmetic for everything - no floating point.  For example, in the process of designing the GA144 he wrote a CAD package that included a simulator for the silicon physics.  He did all of that in scaled integers.
2023-10-26 13:17:52 <KipIngram   > Well, he would note that you can't just go get the square root.  you get a ton of other baggage along with it.
2023-10-26 13:18:29 <KipIngram   > That sort of thing, rendar.  And as I said, in a very non-compromising way.
2023-10-26 13:18:47 <rendar      > i see
2023-10-26 13:19:21 <KipIngram   > There's some stuff written by Chuck that you can find out there, but there's also a lot "about" Chuck and his philosophy written by a guy named Jeff Fox.
2023-10-26 13:19:36 <KipIngram   > It's entertaining reading.
2023-10-26 13:19:48 <GeDaMo      > https://www.ultratechnology.com/
2023-10-26 13:20:03 <rendar      > i see
2023-10-26 13:20:03 <KipIngram   > I don't follow  Chuck religiously or anything - I admire his ideas in general, but I am willing to bend them.
2023-10-26 13:20:21 <rendar      > indeed, me too
2023-10-26 13:20:43 <KipIngram   > Like I'm  planning this system that will support types for numerical processing, array handling, and so on - he'd  probably rain all over that.
2023-10-26 13:21:08 <KipIngram   > He would tell me to make the specific array I needed when I needed it, and write the code for manipulating it in the necessary ways.
2023-10-26 13:21:16 <KipIngram   > Without any attempt at "generality."
2023-10-26 13:21:50 <KipIngram   > after all, in his point of view the only reason you'd want a "type" of any sort would be because you're thinking about using it later on other problems.
2023-10-26 13:22:17 <KipIngram   > He'd say those later problems would likely turn out to be just a little bit different, and the solution you build today likely won't be quite the perfect fit.
2023-10-26 13:22:29 <KipIngram   > And he may be right, but... I want to try.
2023-10-26 13:22:55 <KipIngram   > A file system is another such "generic solution."
2023-10-26 13:23:31 <KipIngram   > well, I finished all 14 and a half hours of Wildberger's Boolean algebra presentation.
2023-10-26 13:23:40 <KipIngram   > I'm counting that as CE at work.
2023-10-26 13:24:26 <KipIngram   > And given how core it is to my training, I'm counting it in the special "role based" category they want to see a certain amount of learning fall into.
2023-10-26 13:25:18 <KipIngram   > Generally you can count learning about almost anything, whether it has to do with your job or not.  But there's a sub-category for 'pertinent' stuff that you have to check off as well.
2023-10-26 13:41:34 <KipIngram   > I'm  probably going to watch through all of these again at some point - I think it's very valuable material.
2023-10-26 20:22:50 <Zarutian_iPad> I have a mathy question: what is it called when I have an angle represented by a number between 0 and 1? 0 being no rotation pointing up the x axis and 1 being full rotation and also pointing up the x axis
2023-10-26 20:23:34 <Zarutian_iPad> it is not radians as that involves pi or tau
2023-10-26 20:24:52 <Zarutian_iPad> it is not degrees 0 - 360˚ but similiar though (ditto with newdegrees)
2023-10-26 20:25:54 <Zarutian_iPad> this question sprung up from a title of a talk why you can not multiply two vectors together
2023-10-26 20:27:32 <Zarutian_iPad> a vector can be translated into three things, its origin, the length of the thing and an angle like I described above
2023-10-26 20:28:02 <thrig       > also an "Airplane" joke
2023-10-26 20:29:46 <Zarutian_iPad> re the angles: so 90˚ is 1/4 or 0.25, 180˚ is 1/2 or 0.5 and 270˚ is 3/4 or 0.75
2023-10-26 20:34:10 <Zarutian_iPad> here is how you might multiply two vectors together: first you multiply their lengths together
2023-10-26 20:36:13 <Zarutian_iPad> then you find the difference between the angle of one and the line from that ones origin that intersects the endpoint of the other vector
2023-10-26 20:37:13 <Zarutian_iPad> you multiply that with the angle of that second vector
2023-10-26 20:38:04 <Zarutian_iPad> is it useful? not in the fucking slightest but I am no mathematician
2023-10-26 20:42:10 <Zarutian_iPad> though now I am thinking about it in terms of a direction and steering of a SR04 or roomba like robot it makes sense of multiplying the vectors together more simply: the lengths are multiplied together and the angles are multiplied together
2023-10-26 20:43:30 <Zarutian_iPad> think of it like "go three times as far as the first one says and turn half times as the other one says
2023-10-26 20:44:10 <Zarutian_iPad> but then the vectors are not of the same "space"
2023-10-26 20:45:25 <Zarutian_iPad> an analogy: buy three times the number of eggs the recipie calls for
2023-10-26 20:46:50 <Zarutian_iPad> say the recipie calls for four eggs then the multiplier of three together with that produces a dozen
2023-10-26 20:50:30 <Zarutian_iPad> video in question https://www.youtube.com/watch?v=htYh-Tq7ZBI
2023-10-26 21:43:49 <zelgomer    > Zarutian_iPad: DooM encodes angles from 0 to 0xffffffff and calls it BAM - "Binary Angle Measure"
2023-10-26 21:45:22 <zelgomer    > as for what you call from 0 to 1: a turn
2023-10-26 21:45:39 <zelgomer    > (i'm no mathmetician either)
2023-10-26 21:45:44 <Zarutian_iPad> a turn! thanks