00:00:00 --- log: started forth/20.03.27
00:05:50 --- join: lisbeths joined #forth
00:18:48 --- quit: lisbeths (Ping timeout: 240 seconds)
00:22:48 --- quit: dddddd (Ping timeout: 250 seconds)
00:39:36 --- quit: gravicappa (Ping timeout: 264 seconds)
00:44:03 --- join: xek__ joined #forth
01:43:05 --- quit: WickedShell (Remote host closed the connection)
02:07:22 --- join: gravicappa joined #forth
02:13:48 --- join: hinicetomeetyou joined #forth
02:14:02 --- part: hinicetomeetyou left #forth
03:06:33 --- join: proteus-guy joined #forth
04:00:00 --- join: xek_ joined #forth
04:02:51 --- quit: xek__ (Ping timeout: 256 seconds)
04:25:50 --- quit: iyzsong (Ping timeout: 256 seconds)
04:36:25 --- quit: _whitelogger (Remote host closed the connection)
04:39:29 --- join: _whitelogger joined #forth
04:40:32 --- join: iyzsong joined #forth
04:54:19 --- quit: iyzsong (Quit: ZNC 1.7.1 - https://znc.in)
04:54:48 --- join: iyzsong joined #forth
06:39:03 --- quit: iyzsong (Quit: ZNC 1.7.1 - https://znc.in)
06:54:50 --- join: dddddd joined #forth
07:16:24 --- quit: tabemann (Ping timeout: 256 seconds)
08:47:19 --- quit: proteus-guy (Ping timeout: 256 seconds)
09:00:09 --- join: proteus-guy joined #forth
09:40:51 --- quit: dave0 (Quit: dave's not here)
10:19:11 --- quit: jsoft (Ping timeout: 256 seconds)
10:24:32 --- quit: Zarutian_HTC (Read error: Connection reset by peer)
10:24:40 --- join: Zarutian_HTC joined #forth
10:48:46 --- join: jsoft joined #forth
11:28:31 --- join: xek__ joined #forth
11:31:29 --- quit: xek_ (Ping timeout: 258 seconds)
11:52:23 --- quit: jsoft (Ping timeout: 265 seconds)
12:43:26 --- quit: Bunny351 (Ping timeout: 260 seconds)
12:43:35 --- join: Bunny351 joined #forth
12:45:35 --- quit: cartwright (Ping timeout: 240 seconds)
12:45:35 --- join: fiddlerwoaroof_ joined #forth
12:46:02 --- quit: fiddlerwoaroof (Ping timeout: 265 seconds)
12:52:20 --- join: cartwright joined #forth
13:14:45 --- join: mtsd joined #forth
13:36:41 --- join: Zarutian_HTC| joined #forth
13:37:14 --- quit: Zarutian_HTC (Read error: Connection reset by peer)
14:02:51 --- quit: mtsd (Quit: Leaving)
14:47:09 --- join: reepca joined #forth
14:51:18 --- quit: gravicappa (Ping timeout: 260 seconds)
14:55:55 --- quit: djinni_ (Quit: Leaving)
15:05:02 --- join: djinni joined #forth
15:22:09 --- quit: reepca (Ping timeout: 265 seconds)
15:41:55 --- join: reepca joined #forth
16:59:42 --- join: crab1 joined #forth
17:01:04 <crab1> Evening, forth boys
17:21:23 --- join: dave0 joined #forth
17:35:27 --- join: iyzsong joined #forth
17:44:13 --- quit: reepca (Ping timeout: 252 seconds)
17:51:55 --- join: rdrop-exit joined #forth
17:52:43 <rdrop-exit> good morning Forthwrights
17:53:16 <tp> moning Zen Forth Guru!
17:53:26 --- join: jsoft joined #forth
17:53:30 <tp> how goes the quarantine ?
17:53:37 <rdrop-exit> hello Forth Master Technician (tm)!
17:53:54 <rdrop-exit> all good so far, thanks
17:55:01 <tp> good to hear
17:55:08 <rdrop-exit> yourself?
17:56:01 <tp> similar, as SARS-CoV-19 spreads here most biz is shut down, many thousands let go from their jobs etc
17:56:47 <tp> our infection graph is much like the USA in terms of increase
17:57:33 <tp> forthwise progress proceeds at my usual snails pace
17:57:34 <crab1> I haven't seen a whole lot of layoffs around my area, most jobs seem to be keeping people through everything
17:57:46 <crab1> mostly the people losing jobs are choosing to in these parts
17:58:47 <tp> tabermann has discovered a new hobby called 'interrupts' on cortex-m4, it's a lot of fun he says ;-)
17:59:00 <rdrop-exit> hi crab1
17:59:13 <crab1> Evening
17:59:28 <crab1> I would say night, but it doesn't really work as a greeting
18:01:24 <rdrop-exit> My wife is focused on getting face shields to health care people
18:02:35 <rdrop-exit> I've been focused on reorganizing all my home storage
18:03:09 <rdrop-exit> going through all my boxes of books and such
18:04:42 <crab1> how many books are you stashing?
18:05:21 <rdrop-exit> I have thousands of books, magazines, and boardgames
18:05:41 <rdrop-exit> All my shelves are full, the rest are in boxes
18:07:30 <crab1> I only have 30+-5 books :(
18:08:13 <tp> reorganisation is good, my workshop needs it badly
18:08:17 <rdrop-exit> You're probably young, nowadays physical books aren't necessary with ereaders and such
18:09:26 <rdrop-exit> Each time we moved countries I purged a portion of my library
18:09:50 <rdrop-exit> It's time I do a big purge
18:10:10 <crab1> I am young, but I prefer textbooks and pleasure reading to come in physical copies
18:10:31 <crab1> If I need to read a paper I'm gonna probably print it if I can
18:12:19 <rdrop-exit> I prefer paper too, but it's not very practical nowadays, the more you have, the longer it takes to find something on your shelves, or dig up an old tome from your boxes
18:14:06 <rdrop-exit> Not to mention the yellowing of some of the old high acid papers
18:17:30 <rdrop-exit> A good portion of my technical books are outdated now
18:19:48 <rdrop-exit> e.g. I just found 3 books on Unix typesetting and document formatting with troff
18:19:58 <crab1> Some things won't become outdated though
18:21:04 <rdrop-exit> Yes, and some forgotten approaches can become relevant again as technology tradeoffs change
18:25:21 <crab1> I wonder how many use forth regularly
18:25:26 <rdrop-exit> I even found a bunch of books on nomography, some published before I was born
18:25:33 <crab1> I also wonder why forth seems to have a terrible reputation
18:25:59 <rdrop-exit> Probably a few hundred at most\
18:26:06 <crab1> nomography could be fun
18:26:41 <rdrop-exit> and slide rule design
18:27:07 <rdrop-exit> Forth is different
18:27:28 <crab1> how you mean forth is different
18:27:54 <rdrop-exit> Different from what people are used to and comfortable with
18:28:14 <crab1> I'm not sure forth is for me
18:28:18 <rdrop-exit> Very open-ended
18:28:25 <crab1> I think I need some modification of it
18:29:18 <crab1> open ended is good and I like the similarity to combinators
18:30:03 <crab1> but I don't particularly like the existence of parsing words as they don't compose, some other things like that rub me backwards
18:30:47 <rdrop-exit> what parsing words?
18:31:08 <crab1> And I can't seem to find a looping mechanism I'm satisfied with
18:32:03 <crab1> parsing words as a whole I do not like. I don't like `:` because it does not take arguments from the stack
18:32:50 <rdrop-exit> Why do you need it to?
18:34:41 <crab1> purity I suppose
18:37:45 <rdrop-exit> any practical reason?
18:40:08 <rdrop-exit> You can have both, just make a : variant when you run into a use case where you actually have a practical need for it
18:41:30 <crab1> It is easier to reason about a language that works in a consistent way
18:42:41 <rdrop-exit> But Forth is open-ended, you can extend or change as your actual needs dictate
18:42:48 <crab1> and yeas forth works in a consistent way, but behind a veil(though a smaller veil than other languages)
18:45:00 <crab1> And I would like to retain the open-endedness and extensibility, I just want a language where the words of the language always operate on the words (or results of those words) immediately before them
18:45:12 <rdrop-exit> I don't think of Forth as a fixed language, or even as a language, I can adapt it to my needs of the moment, so I don't worry about it
18:52:45 <rdrop-exit> When you need something radically different, you can always metacompile or target compile a new Forth from one of you're older ones
18:52:55 <rdrop-exit> * your
18:54:30 <rdrop-exit> That's more efficient than doing meta stuff at runtime
18:54:47 <crab1> wdym doing meta stuff at runtime
18:56:40 <rdrop-exit> very abstracted manipulations at runtime, such as functional programmers seem to crave
18:57:37 <crab1> highly abstracted manipulation at runtime would not be something I'd want
18:58:17 <crab1> If anything I'd like to simplify more
19:02:29 <rdrop-exit> can you give a practical example?
19:02:42 <crab1> Of how I want forth simplified?
19:02:47 <rdrop-exit> yes
19:05:48 <tp> I'm definitely an Imperative programmer
19:06:28 <rdrop-exit> Me too, I use lots of exclamation points in my code ;-)
19:07:56 <tp> I want all the information and I don't want to hide it
19:08:32 <tp> I dont have to look at it all at once but I want everything easily available
19:08:35 <rdrop-exit> I find that most surface simplifications people crave actually increase the overall complexity of the implementation
19:09:17 <tp> I find that most surface simplifications exclude vital information required to understand whats happening
19:09:45 <rdrop-exit> exactly, too much abstraction rots the brain
19:10:15 <tp> in the 1800's when I went to school, if I solved a equation without showing how I got there, the teacher was very unhappy and would fail me
19:11:26 <rdrop-exit> Most libraries and APIs drive me nuts
19:11:42 <tp> my teachers would be very unhappy nowadays trying to read functional examples people give when showing their code
19:11:57 <tp> same here
19:13:50 <tp> when I wrote my Forth LMT-01 temperature sensor project I looked for code examples online, there was understandably nothing for Forth, but I was surprised to find only two examples in C, lots of C user problems getting the sensor working, and nothing for Arduino
19:14:33 <tp> both online projects used the lame Ti reference example which is a single sensor running continuously
19:15:22 <tp> the sensor is in fact incredibly simple, but many simple things, it's not that easy to use well
19:15:29 <tp> +like
19:15:45 --- join: reepca joined #forth
19:15:56 <tp> so the C and Arduino world just stopped right there
19:17:08 <tp> they continued with the horrific and ancient/obsolete Dallas Semi DS18B sensor which someone had written code for many years ago
19:17:10 <rdrop-exit> they don't crave understanding, it's rare to find people who grok what they're using, which is dangerous
19:18:46 <tp> it's a world of 'code reuse' and 'libraries' of which both terms are just a joke to me
19:19:38 <crab1> I want a language with a compiler that matches this pseudocode: `: source->xt (source--xts) first-token dup in-dict? if get-xt endif ; : compile source->xts opt to-machine ;` so if something is not in the dictionary, then it is a literal, and its xt is itself, to-machine creates a call to each xt in the dictionary and that's your program
19:20:08 <crab1> idk if that's entirely illogical, I'm trying to voice a vague and unclear concept that floats around my head sometimes
19:22:07 <crc> Good evening
19:22:14 <crab1> evening sir
19:22:19 <rdrop-exit> hi crc
19:23:01 <rdrop-exit> crab1, so you want a pure compiled language?
19:23:56 <crab1> Maybe, I'm not certain on that point
19:24:07 <crab1> but the one I describe is pure compiled, yeah
19:24:53 <crab1> I think that I would one one or the other though, either pure compiled or pure interpreted
19:25:00 <crab1> want one or the other*
19:25:40 <tp> g'day crc 
19:27:11 <crab1> tp: does arduino use C?
19:27:38 <rdrop-exit> Pure compiled, you lose Forth's interactivity and overall simplicity, pure interpreted you make the system impratically slow
19:28:58 --- quit: dave0 (Quit: dave's not here)
19:29:05 <rdrop-exit> In Forth you normally try to hit a sweet spot between the extremes
19:29:45 <rdrop-exit> it's one reason for the different threading schemes
19:29:59 --- quit: xek__ (Ping timeout: 256 seconds)
19:30:39 <crab1> wasn't colorforth set up compile only?
19:31:02 <rdrop-exit> no
19:32:30 --- join: WickedShell joined #forth
19:34:08 --- join: tabemann joined #forth
19:41:57 <crc> crab1: http://christophe.lavarenne.free.fr/ff/ was an attempt at a compile only forth system
19:42:39 --- join: boru` joined #forth
19:42:41 <rdrop-exit> Wasn't strongForth also compile-only, I don't remember
19:42:42 --- quit: boru (Disconnected by services)
19:42:45 --- nick: boru` -> boru
19:43:09 <rdrop-exit> There have been a few attempts, but I find them futile
19:44:06 <rdrop-exit> In ColorForth the editor is made smarter so the interpreter/compiler can be simpler/faster
19:44:38 <crc> rdrop-exit: not as I remember it
19:45:21 <crc> strongforth still has STATE and immediate words
19:45:36 <rdrop-exit> crs, thanks, my memory is hazy, I only read about it
19:45:53 <rdrop-exit> * crc
19:48:30 <crab1> can you do interpret only if you have a word compile and can call pre-compiled words that you've made with compile?
19:48:59 <crc> Interpret only would be *slow*
19:49:43 <rdrop-exit> The extreme of interpret-only is an interactive macro processor
19:51:03 <rdrop-exit> I wrote one once, forth-like, all parameters were strings, all outputs were strings
19:51:24 <rdrop-exit> TeX is kinda like that in a way
19:52:06 <rdrop-exit> crab1, I don't understand your question
19:54:12 <crab1> interpreted forth with a word compile and a word execute, where compile produces machine code and execute executes machine code. Almost like forth is your shell, and you have a compiler program and a means to execute compiled programs
19:55:50 <rdrop-exit> that's how most subroutine threaded Forths work if I understood you correctly
19:58:40 <rdrop-exit> In a subroutine threaded forth with inlining,
19:58:54 <rdrop-exit> : foo ( -- ) do-this do-that ;
19:59:05 <rdrop-exit> lays down machine instructions
19:59:31 <rdrop-exit> and interactively typing foo executes those machine instructions
20:01:07 <crab1> but then any interpret-only language with compile() and a call instruction to the start of that compiled program can run compiled programs with the call instruction as the only overhead
20:02:42 <rdrop-exit> compiling the whole program every time you want to run it?
20:07:07 <crab1> not necessarily, you only need to do it once, you could do `program compile dup dup call call call` (where : compile (source--address))
20:07:43 <crab1> and if you have a place to store the binary permanently then you just need to know where it is
20:08:52 <crc> `:noname ... ;  dup dup execute execute execute`
20:10:11 <crab1> none of that retro nonsense
20:10:23 <rdrop-exit> that's ANS, not retro
20:10:40 <crab1> oh yeah they do the prefix on that word
20:10:53 <crc> Retro would be `[ ... ] dup dup call call call`
20:11:09 <rdrop-exit> I've never needed :NONAME
20:11:21 <crab1> I've become used to seeing `:foo ... ;` and thinking retro
20:12:38 <rdrop-exit> crab1, you seem to be intent on making hoops to jump through
20:12:53 <crab1> wdym?
20:13:16 <rdrop-exit> whay not just do
20:13:27 <rdrop-exit> : program ( -- ) ... ;
20:13:36 <rdrop-exit> program program program
20:15:41 <crab1> that requires an infrastructure that both compiles and interprets by default, all I was trying to say is that an interpreted only language can gain the advantages of compilation without a huge cost
20:16:55 <crc> The infrastructure to handle compiling doesn't need much
20:18:04 <crab1> and all the interpreted language needed was call and a compiler
20:18:07 <rdrop-exit> a pure interpret-only language can't be compiled unless you constrain what it's allowed to do during interpretation
20:19:10 <crab1> what constraints do you need?
20:19:49 <rdrop-exit> the compiled version can't have the same semantics as the interpreted version unless you constrain what the interpreted version is allowed to do, if that were not so, then you're compiler would have to completely simulate your interpreter
20:23:55 <rdrop-exit> basically the spectrum of interpretations, goes from pure direct interpretation (of strings), through compilation of various intermediate codes, all the way to pure overall compilation to native code
20:25:01 <rdrop-exit> most of the range is covered by the various intermediate codes, except for the two extremes
20:25:24 <tabemann> hey guys
20:25:30 <crab1> Hello
20:25:32 <tabemann> I got interrupts working for USART2
20:25:40 <rdrop-exit> pure direct interpretation is like having a string-based CPU
20:26:21 <rdrop-exit> it basically does macro expansion
20:26:57 <rdrop-exit> hi tabemann
20:27:02 <tp> tabemann, awesome!
20:27:07 <tabemann> now I need to get sleeping working
20:27:34 <tabemann> tp: the tricky part was that it was occasionally doubling characters
20:27:48 <tp> oh!
20:28:17 <tabemann> I fixed that by only reading one character per interrupt, and by making my circular buffers interrupt-disabling-free
20:29:00 <tabemann> so I had to figure out an algorithm for circular buffers that could be simultaneously accessed by the interrupt handler and the task code
20:29:07 <tp> yah the old stm32 is pretty fast
20:30:55 <rdrop-exit> crab1, Part 1 of "Interpretation and Instruction Path Coprocessing" by Dabaere & Van Campenhout has good overview of the spectrum of possibilities
20:31:43 <rdrop-exit> it discusses various interpretation schemes and their intermediate codes
20:32:07 <rdrop-exit> (including Lisp, Forth, Basic, etc...)
20:33:12 <rdrop-exit> (published in 1990)
20:34:49 <crab1> can't find it on libgen
20:36:02 <rdrop-exit> https://www.amazon.com/Interpretation-Instruction-Coprocessing-Computer-Systems/dp/0262041073
20:37:12 <rdrop-exit> the first 100 or so pages talk about interpretation, the rest of the book is about using hardware to assist interpretation
20:38:39 <crab1> I am unfortunately not in the financial position to be buying books
20:38:50 <Zarutian_HTC|> rdrop-exit: what of self partial reconfiguring cpld/fpga of (part of) the datapath?
20:39:36 <Zarutian_HTC|> rdrop-exit: as the next level after machine instructions and microcode
20:40:13 <rdrop-exit> the rest of the book is about putting a coprocessor on the instruction path
20:41:56 <Zarutian_HTC|> sort of lambda-ish definition of coprocessors embedded in the instruction stream
20:43:52 <rdrop-exit> crab1, it's an old book you might be able to find an online version
20:44:28 <crab1> I looked, but did not see one
20:44:31 --- quit: WickedShell (Remote host closed the connection)
20:45:10 <Zarutian_HTC|> now that is an idea. hmm.
20:47:52 <rdrop-exit> II will try my google-fu
20:51:31 <rdrop-exit> archive.org has an online version that can be borrowed
20:51:39 <rdrop-exit> https://archive.org/details/interpretationin00deba
21:11:40 --- quit: Keshl (Read error: Connection reset by peer)
21:11:57 --- join: Keshl joined #forth
21:16:10 <pointfree> How is everyone? Hello forth crew
21:16:23 <rdrop-exit> hi pointfree!
21:16:50 <pointfree> o/ rdrop-exit!
21:18:25 <rdrop-exit> all ok here, my wife and I are quarantined at home, and our kids are each quarantined in their respective homes
21:18:26 <pointfree> How are you holding up in this mysterious virus quarantine? 
21:19:06 <rdrop-exit> haven't run out of espresso and cigarettes yet, so ok
21:19:29 <rdrop-exit> yourself?
21:23:24 <proteus-guy> rdrop-exit, that's an excellent book. Definitely gives me ideas for fpga design of a forth-based stack processor.
21:23:47 <rdrop-exit> cool, glad you like it
21:36:10 <pointfree> I decided to try psychogeography myself. I went on the Foster City bay trail by apartment and to get lost deliberately. The tech campuses are ghost towns. It's kinda spooky. WIldlife is reclaiming the parking lots. I guess that's what it looks like to be the last man on earth.
21:36:10 <pointfree> I'm assembling the gigatron https://gigatron.io/ I bought from Ken Boak on Forth Day. I got some grab bags of discrete components from amazon before they went out of stock.
21:37:13 <rdrop-exit> wow, that's neat!
21:39:12 <tabemann> back
21:40:00 <rdrop-exit> 8-bit RISC architecture, his own ISA?
21:45:03 <pointfree> I like that I can have a forth desktop computer with video output, keyboard, etc with discrete components. It makes it easy to change things as needed and I don't depend on electronics IC supply chain.
21:46:24 <tabemann> okay, I'm baffled
21:46:33 <tabemann> my code a moment ago didn't work
21:46:45 <tabemann> then I added some test code, then removed all the test code
21:46:47 <tabemann> and now it works
21:46:47 <rdrop-exit> looks like a fun project pointfree
21:47:21 <rdrop-exit> tabemann, must be gremlins
21:47:50 <tabemann> zeptoforth is kinda funky at times
21:48:16 <tabemann> for instance, if you erase the flash when basic.fs hasn't been loaded yet, it reboots fine
21:48:24 --- quit: jsoft (Ping timeout: 256 seconds)
21:49:01 <tabemann> if you've loaded all the recommended code, though, erasing the flash causes it to lock up, but only after it has erased the flash - so if you press the reset button it works fine
21:49:20 <tabemann> except under some circumstances I do not gather the nature of, even that is not true
21:49:39 <tabemann> and you need to use something like st-flash or openocd to reflash the device to unwedge it
21:50:32 <tabemann> I did get interrupt-driven IO working
21:50:58 <tabemann> and it should be sleeping when it's not doing anything now
21:59:10 <rdrop-exit> cool
22:03:37 <tabemann> aha
22:03:46 <tabemann> that's why my systick was so damn fast
22:04:00 <tabemann> the TENMS calibration field is for the default clock of the processor
22:04:03 <tabemann> 8 MHz
22:04:25 <tabemann> but it doesn't take into account the fact that I bumped the clock up to 45 MHz
22:11:04 --- quit: Zarutian_HTC| (Ping timeout: 256 seconds)
22:18:25 <tabemann> *48 MHz
22:42:33 --- join: gravicappa joined #forth
22:59:29 --- quit: dddddd (Remote host closed the connection)
23:04:49 --- join: jsoft joined #forth
23:05:24 --- quit: jsoft (Max SendQ exceeded)
23:05:52 --- join: jsoft joined #forth
23:06:12 --- quit: jsoft (Max SendQ exceeded)
23:06:39 --- join: jsoft joined #forth
23:52:42 --- quit: crab1 (Quit: WeeChat 2.7.1)
23:59:59 --- log: ended forth/20.03.27