00:00:00 --- log: started forth/20.01.18
00:39:57 --- join: ryke joined #forth
02:29:04 --- join: gravicappa joined #forth
02:41:40 --- join: dddddd joined #forth
03:20:08 <dddddd> hi
03:22:59 <tpbsd> g'day dddddd
03:58:43 <dddddd> proteus-guy, do you know by any chance (one of those meetings) the rationale for "scramble" immediate bits in RISC-V? Sure it makes harder for generating instructions, so I guess there's some good reason...
04:02:03 <tpbsd> proteusguy, I don't know about the lcd screen yet, it's tiny and loosely stuck to the top of the mcu with some double sided tape
04:16:29 <tpbsd> proteusguy, the board has a 0.96inch 160x80 IPS RGB LCD
04:26:33 <proteusguy> dddddd, I don't.
04:27:10 <proteusguy> tpbsd, pretty cool for such a tiny board to come with a display. happy with the board so far?
04:27:18 <tpbsd> proteusguy, the info for the longan-nano $5 pcb is very scant
04:27:39 <dddddd> OK, thanks anyway proteusguy (and for your comment about the halting problem).
04:28:08 <tpbsd> proteusguy, some of it is just plain wrong, copy and pasted for the STM32F103 into the GD32VF103 docs incorrectly
04:28:56 <tpbsd> proteusguy, yeah, I got my two units given to me by a new Forth user I assisted online
04:30:40 <tpbsd> proteusguy, but the chip and RISC-V are quite interesting, I think it has a bright future, and besides, millions of RISC-V chips have been made and deployed already anyway
04:44:57 --- quit: iyzsong (Ping timeout: 272 seconds)
04:53:56 --- join: crab2 joined #forth
04:54:10 <crab2> Hi there forthboys
04:55:13 <tpbsd> g'day crab2 
04:55:29 <crab2> I'm talking to you from 9front now :)
04:57:19 <tpbsd> cool
04:57:57 <crab2> still a good bit to do until it's a good daily driver for me though
05:23:25 <tpbsd> proteusguy, you have to provide your own font data
05:30:39 <rdrop-exit> dddddd, the scrambling is to maximize the commonality of bit positions across instructions (even the compressed ones)
05:35:48 <rdrop-exit> "The immediate fields are scrambled in the instruction formats instead of in sequential order so that as many bits as possible are in the same position in every instruction, thereby simplify- ing implementations. For example, immediate bits 17—10 are always sourced from the same instruction bit positions. Five other immediate bits (5, 4, 3, 1, and 0) have just two source instruction bits, while four 
05:35:55 <rdrop-exit> (9, 7, 6, and 2) have three sources and one (8) has four sources."
05:37:49 <tpbsd> rdrop-exit, sounds like a efficient idea, and hey the user software can sort it all out. Thats gotta be a million times easier than doing it in silicon ?
05:39:08 <rdrop-exit> right, less mux-ing about
05:40:27 <tpbsd> i mean, we have already sorted one GD32VF103 one silicon bug in software, namely the DFU code had a bug
05:40:41 --- quit: crab2 (Ping timeout: 272 seconds)
05:41:11 <tpbsd> has a bug that won't get fixed until they do a new batch I guess
05:43:01 <tpbsd> rdrop-exit, in your RISC-V project so far, have you come across any chip register 'reset to default' info ?
05:44:02 <tpbsd> for instance, cortex-m has a command to reset all the peripheral registers to default, and that same info is in the gd32vf103 chip info, however it's not actually implimented
05:45:25 <tpbsd> thats one of the main hassles so far, bad documantation, not that it's especially worse than all the other chip mfrs (even Ti etc) first runs of docs
05:46:01 <tpbsd> the usual chip makers errata can be quite voluminous
05:48:09 <rdrop-exit> The specs don't cover peripherals
05:54:45 <tpbsd> the chip has some peripherals of it's own, so it will cover those
05:54:57 <tpbsd> such as the interrupt and sysclock
05:55:52 <dddddd> rdrop-exit, I see. Thank you very much! Not great for simple software but it's soft (:
05:57:57 <rdrop-exit> tpbsd, yes
06:00:14 <rdrop-exit> dddddd, I did not find the scrambling to be a big issue, there are only a few instructions where special casing was needed
06:04:01 <rdrop-exit> tpbsd, I would assume the DFU bug is Gigadevices specific
06:05:01 <tpbsd> correct
06:05:16 <tpbsd> some silicon bug I guess
06:05:33 <dddddd> rdrop-exit, well... I guess our use-case is a bit special (and our tools did fine until we attacked AArch64; RISC-V would need the same workarounds).
06:06:04 <tpbsd> I dont know enough about the implimentation but can testify it doesnt work as it should because I lost a couple of hours discovering it
06:06:48 <tpbsd> it's one of those nasty bugs that don't complain as theyre not doing what they should
06:07:52 <rdrop-exit> dddddd, it does lead to some Forth words in the assembler that are longer than I'm normally comfortable with, 6 lines each IIRC, but at least they follow a repetitive pattern.
06:07:57 <dddddd> It's a long history and quite off-topic, so I shouldn't enter in the details now, here
06:08:57 <rdrop-exit> dddddd, e.g. this is one of the two giant words:
06:09:03 <rdrop-exit>  : +j.sx[20:0] ( sx[20:0] 32b -- 32b' )
06:09:05 <rdrop-exit>    over 21 2's-imm  over 1 lowimm0s
06:09:05 <rdrop-exit>    over    20 bit      31 bit  scramble
06:09:05 <rdrop-exit>    over 19 12 bits  19 12 bits scramble
06:09:05 <rdrop-exit>    over    11 bit      20 bit  scramble
06:09:06 <rdrop-exit>    swap 10  1 bits  30 21 bits scramble ;
06:10:13 <rdrop-exit> but since the pattern is vlear to the eye, it doesn't bother me as much
06:10:20 <rdrop-exit> * clear to the eye
06:11:38 <rdrop-exit> That's the word that handles the 21 bit immediate of J-TYPE instructions
06:11:59 <tpbsd> definitely a bit of scrambling going on
06:14:10 <rdrop-exit> Ooh, wait, the worst case is actually in one of the compressed instruction formats. Just a sec.
06:14:36 <rdrop-exit> 10 lines!!!
06:14:46 <rdrop-exit>  : +cj.sx[11:0] ( sx[11:0] 16b -- 16b' )
06:14:47 <rdrop-exit>    over 12 2's-imm  over 1 lowimm0s
06:14:48 <rdrop-exit>    over   11 bit       12 bit scramble
06:14:48 <rdrop-exit>    over   10 bit       8 bit  scramble
06:14:48 <rdrop-exit>    over 9  8 bits  10  9 bits scramble
06:14:48 <rdrop-exit>    over    7 bit       6 bit  scramble
06:14:51 <rdrop-exit>    over    6 bit       7 bit  scramble
06:14:53 <rdrop-exit>    over    5 bit       2 bit  scramble
06:14:56 <rdrop-exit>    over    4 bit      11 bit  scramble
06:14:58 <rdrop-exit>    swap 3 1 bits    5  3 bits scramble ;
06:15:06 <tpbsd> rdrop-exit, as yours is a tethered Forth the size of the Words doesnt matter really, apart from possible brain scrambling ?
06:15:29 --- join: crab1 joined #forth
06:15:34 <crab1> yoyo
06:15:49 <rdrop-exit> That format is used by two instructions:
06:15:56 <rdrop-exit>  : c.j,   ( sx[11:0] -- ) $ a001 cj-type, ;
06:15:57 <rdrop-exit>  : c.jal, ( sx[11:0] -- ) $ 2001 cj-type, ;
06:16:57 <rdrop-exit> tpbsd, it's against my religion to have a word that long, with two exceptions, loops and words that have a readily eyeball-able pattern
06:17:28 <tpbsd> I understand
06:17:43 <crab1> how long? (excuse my butting in)
06:17:57 <rdrop-exit> (warning, none of the above code has been tested, it's just notes I took while I was reading along in the spec)
06:18:14 <tpbsd> crab1, 10 lines
06:18:29 --- join: Labu joined #forth
06:19:07 <rdrop-exit> The bulk of my words are normally 1-3 lines long, including stack picture
06:19:12 <tpbsd> rdrop-exit, that doesnt matter, your Forth is as non standard as anyones and only you know it anyway
06:19:19 --- quit: deesix (Ping timeout: 260 seconds)
06:19:39 <tpbsd> rdrop-exit, which is the recommemded Word length anyway
06:19:59 --- quit: dddddd (Ping timeout: 265 seconds)
06:20:34 <rdrop-exit> Chuck normally does one to two lines long
06:20:52 <rdrop-exit> but he uses short word names
06:21:40 <tpbsd> when I started learning Forth I was trying to keep my Words to three lines, check out this horror
06:21:43 <tpbsd>   10 constant sieve-size	    \ Reject variations of less than 10 
06:21:43 <tpbsd>   0 variable oldinput
06:21:43 <tpbsd>  : sieve ( newinput -- output only if newinput = oldinput +- sieve-size  )
06:21:43 <tpbsd>    dup oldinput @ sieve-size - <= if 0 >r else 1 >r then
06:21:43 <tpbsd>    dup oldinput @ sieve-size + >= if 0 >r else 1 >r then
06:21:43 <tpbsd>    r> r> and if drop oldinput @ else dup oldinput ! then
06:21:45 <tpbsd>  ;
06:22:05 <tpbsd> I still use it tho
06:22:06 <tpbsd> hahah
06:22:22 --- join: deesix joined #forth
06:23:16 <tpbsd> it's my "low noise" alternative to averaging 
06:23:31 <tpbsd> also a lot faster
06:23:41 <crab1> I don't like stack signatures like that
06:23:41 <rdrop-exit> 64 byte lines (i.e. a block row)
06:24:02 <crab1> "output only if newinput = oldinput =- sieve-size"
06:24:20 <crab1> I like to always have an output
06:24:30 <crab1> but that's the functional programmer in me
06:24:38 --- join: dddddd joined #forth
06:26:08 --- quit: rdrop-exit (Remote host closed the connection)
06:26:46 <tpbsd> crab1, thats the awesome thing about Forth, you don't have to use stack signatures like that :)\
06:27:19 --- join: rdrop-exit joined #forth
06:27:54 <crab1> But another, arguably more awesome thing about forth, is that I get to laugh at the buffoons that do use stack signatures like that
06:28:18 <rdrop-exit> You should always have a stack picture
06:28:37 <crab1> good words have good stack pictures though
06:29:08 <rdrop-exit> ok
06:30:27 <crab1> where his was confusing because newinput is smashed into one word but then on the other side he has a full space delimited sentence and now you ask, if the left is not space delimited but the right is, does that mean that each term of that sentence is output to the stack? well obviously not, but the conventions used there are noticably inconsistent
06:34:58 <crab1> ( newinput -- [if newinput = oldinput +- sieve size, output, else nothing] ) would be better I think, or leave it at ( newinput -- [maybe output]) and the definition should make it clear when there is/is not an output
06:35:01 <dddddd> Sorry, I missed some conversation because power went off. Are you talking about that hypotetical "typed stack" using stack signatures?
06:35:30 <crab1> no I'm just insulting a stack signature tpbsd wrote when he was new to forth lol
06:36:57 <rdrop-exit> Stack picture should be fairly concise, explanation should go in other comments, or a shadow block
06:37:00 <dddddd> ooook. Poor us, newbies :D
06:37:40 <crab1> that's why I offer the ( newinput -- [maybe output] ) option
06:37:48 <crab1> I think that one is the best
06:38:18 <rdrop-exit> ( x -- x'| )
06:38:33 <crab1> what is x'|
06:39:02 <rdrop-exit> the | shows that either x' or nothing is output
06:39:42 <rdrop-exit> x is a cell
06:39:56 <crab1> I disagree with that option, you need to be in the know on extra notation and I don't like that
06:40:34 <rdrop-exit> It's the notation in most style guides, it's not something unique to me
06:41:11 <crab1> but I don't even like @ or ! I rather just have a word so I may be extreme
06:41:19 <crab1> even : is an ugly thing to me
06:41:38 <rdrop-exit> this is SPARTA!!!
06:41:53 <crab1> woa where did sparta come from
06:42:07 <rdrop-exit> You never watched the movie 300
06:42:09 <rdrop-exit> ?
06:42:37 <crab1> I get the reference, I just don't get how it relates to the conversation lol
06:43:04 <rdrop-exit> "even : is an ugly thing to me"
06:43:15 <rdrop-exit> just kidding around
06:44:13 <rdrop-exit> I have no problem with : @ ! as these are very frequently used words
06:44:38 <crab1> ah I gotcha now
06:45:15 <tpbsd> 300 was a good film, some interesting film devices were used
06:45:38 <crab1> but yeah I understand why people have no problem with : @ ! but it's one more thing an outsider needs to know to understand your program, and I want to be understood by anyone that knows english when I write
06:45:39 <rdrop-exit> Forth doesn't have that many unusual one-symbol names, unlike APL for example
06:46:12 <crab1> it doesn't have many, but it COULD have none :)
06:47:30 <rdrop-exit> I wouldn't want that
06:47:36 <crab1> why?
06:47:56 <rdrop-exit> I'm as used to @ and ! as I am + and -
06:48:51 <rdrop-exit> there would be no gain for me
06:49:07 <crab1> I'm fine with some, but I like them to be already familiar for a regular english reader
06:49:23 <crab1> as in a definition could be:
06:49:49 <rdrop-exit> COBOL tried the english-like route, it was a disaster
06:51:35 <crab1> define dog
06:51:46 <crab1> define dog 68 79 71 .
06:51:56 <crab1> sorry for weird formatting issues not used to my irc client
06:52:14 <rdrop-exit> postscript uses "define" IIRC
06:52:37 <crab1> scheme uses define, that is what made me think of it
06:53:15 <crab1> you could use something like "call 68 79 71 dog ." as well but that is not as good plus call is a word that forths already tend to make use of
06:53:43 <crab1> also just because COBOL did it wrong don't mean it can't be done right :(
06:54:31 <rdrop-exit> too much forward expectation on the input, not for me.
06:55:04 <crab1> another reason I prefer define
06:55:15 <crab1> but regardless
06:55:40 <crab1> define word definition .
06:55:42 <crab1> I like
06:57:11 <crab1> except my english wants to define dog (as) 68 79 71 . But that's not good either.
06:57:41 <crab1> But look! then we can talk about/in programs real nicely :)
06:58:54 <rdrop-exit> I think Forth hits the sweet spot for me, not as extreme as either APL or COBOL
06:59:46 <rdrop-exit> but I'm so use to it that : dog ... ; seems perfectly natural to me
07:01:31 <rdrop-exit> crab1, in Forth you can have it your way, that's the beauty
07:03:56 <crab1> ( Forth makes dealing with ascii easy. We can simply ) define d 68 , define o 79 , ( and then ) define g 71 . ( Now we can put the fines ascii creature on our stack as easy as ) g o d
07:04:09 <crab1> Hmm idk about that (these are experiments)
07:05:05 <crab1> You'd definitely put some effort into structuring that better in a real program
07:05:36 <crab1> plus that gives , and . the same meaning
07:06:38 <crab1> maybe define d 68, o 79, ( and ) g 71 .
07:07:25 <crab1> anyway we'll see, I'm still getting after constructing my own forth and I'm pretty sure that will bring about plenty of discovery
07:07:35 <rdrop-exit> I like the way Forth uses a comma for laying down things
07:10:07 --- quit: X-Scale (Ping timeout: 268 seconds)
07:11:04 <crab1> yeah the standard use of comma is already good. But seeing that stuff, how forth already uses words analogous to punctuation, that's part of what inspires me to take that to its natural end.
07:12:40 <rdrop-exit> you seem to be trying to make Forth closer to a parsed language
07:13:15 <crab1> no, I am not wanting to take forth any direction that it does not already go, I think
07:14:12 <rdrop-exit> Your "define d 68, o 79, ( and ) g 71 ." has more parsing then Forth
07:14:30 <rdrop-exit> in particular your use of commas
07:15:00 <rdrop-exit> * than Forth
07:15:51 <rdrop-exit> Doesn't seem like comma is a word
07:18:16 <crab1> The actual program would be "define d 68 , o 79 , g 71 ." where we all know what define means, and try replacing each comma with ". define", I think that this word , is not that crazy.
07:18:39 <rdrop-exit> It's getting late, gotta go. Keep on Forthin'
07:18:48 <crab1> toodleoo, fair friend
07:18:51 --- quit: rdrop-exit (Quit: Lost terminal)
08:08:53 --- quit: remexre (Ping timeout: 258 seconds)
10:10:00 <crc> crab1: so something like this?
10:10:04 <crc> : (,) , does> @ ;
10:10:05 <crc> : define create ;
10:10:05 <crc> : , (,) create ;
10:10:05 <crc> : . (,) ;
10:35:11 --- join: remexre joined #forth
11:07:22 --- quit: dave0 (Quit: dave's not here)
11:10:45 --- quit: crab1 (Ping timeout: 265 seconds)
11:17:37 --- quit: ryke (Ping timeout: 240 seconds)
12:01:55 --- join: dys joined #forth
13:34:57 --- join: X-Scale joined #forth
14:03:30 --- quit: gravicappa (Ping timeout: 265 seconds)
15:09:05 --- quit: proteus-guy (Ping timeout: 268 seconds)
15:12:10 --- quit: dys (Ping timeout: 268 seconds)
16:04:09 --- quit: reepca (Ping timeout: 268 seconds)
17:00:54 --- join: tabemann joined #forth
17:02:09 <tabemann> hey guys
17:08:07 <crc> Hi tabemann
17:14:53 <tabemann> I should hack on zeptoforth some more
17:15:06 <tabemann> but hacking in assembly is hard :(
17:17:03 <crc> it certainly can be
17:20:09 <crc> Which architecture is zeptoforth for?
17:24:20 <tabemann> back
17:24:29 <tabemann> ARM Cortex-M3/4
17:26:39 <crc> It's been too long since I tried ARM assembly :(
17:27:16 <tabemann> this is Thumb
17:28:11 <tabemann> Thumb-2 to be exact
17:29:12 <crc> I've never tried using thumb or thumb2
17:29:49 <tabemann> thumb is essentially ARM but 16-bit; thumb-2 is thumb but with some 32-bit instructions added in again
17:31:08 <tabemann> e.g. 16-bit load instructions, to enable loading a 32-bit value into a register with two instructions rather than the whole string of instructions needed for thumb
17:31:44 <tabemann> (MOV 16-bit immediate and MOVT 16-bit immediate)
17:56:37 --- quit: tabemann (Ping timeout: 272 seconds)
18:48:59 --- join: rdrop-exit joined #forth
19:05:29 --- join: dave0 joined #forth
20:02:58 <rdrop-exit> Hello Forthwrights c[]
20:05:35 <tpbsd> g'day Zen Forth Guru !
20:05:58 <tpbsd> rdrop-exit, comments ?
20:06:56 <rdrop-exit> Hi Forth Master Technician (tm)
20:07:58 <tpbsd> re RISC-V 
20:08:01 <tpbsd> Since instructions can only be aligned to 4 bytes, or 2 bytes for compressed instructions, the 12-bit offset actually encodes an offset that is in multiples of 2 bytes, which is clever, so the range is +/-4096 bytes. 
20:08:59 <rdrop-exit> yes, makes sense
20:09:11 <tpbsd> I had read that the conditional branches range is +/-2048 bytes but a poster said the above, I'm wondering if you can coomment please ?
20:09:38 <rdrop-exit> let me check my assembler code, brb
20:09:38 <tpbsd> thanks
20:09:43 <tpbsd> thanks
20:10:09 <rdrop-exit> You're asking about the compressed or the regular branch instruction?
20:10:31 <tpbsd> I'm *guessing* regular
20:10:37 <tpbsd> it wasnt mentioned
20:10:48 <rdrop-exit> ok, brb
20:11:13 --- join: tabemann joined #forth
20:12:49 <rdrop-exit>  : +b.sx[12:0] ( sx[12:0] 32b -- 32b' )
20:12:50 <rdrop-exit>    over 13 2's-imm  over 1 lowimm0s
20:12:50 <rdrop-exit>    over    12 bit      31 bit  scramble
20:12:50 <rdrop-exit>    over    11 bit       7 bit  scramble
20:12:50 <rdrop-exit>    over 10  5 bits  30 25 bits scramble
20:12:52 <rdrop-exit>    swap  4  1 bits  11  8 bits scramble ;
20:13:26 <tpbsd> hang on let me decode that
20:13:40 <rdrop-exit> conditional branches take a 13 bit offset, whose low bit has to be 0
20:14:22 <rdrop-exit> (assuming my draft code buggy)
20:14:32 <tpbsd> hmm different again
20:14:38 <rdrop-exit> * isn't buggy
20:15:37 <tpbsd> I now have the gd32vf103 running at 72 MHz and 460800 baud, fast, next stop is 108 mhz
20:15:50 <rdrop-exit> let me check the spec
20:16:19 <tpbsd> ill have to wait a while for the programmers to agree on the actual conditional branches range tho I guess
20:16:26 <rdrop-exit> The offset is signed
20:16:31 <tpbsd> it's only for my online doc notes
20:17:12 <rdrop-exit> so +/- 4k
20:17:42 <tpbsd> for 16bit or 32 bit ?
20:17:51 <rdrop-exit> 32 bit
20:18:01 <tpbsd> ta!
20:18:55 <rdrop-exit> For the compressed it's a sign extended 9 bit offset (low bit=0)
20:19:38 <tpbsd> these two choices make it all a bit confusing
20:19:47 <tpbsd> for documentation
20:19:58 <rdrop-exit> If you discover I've misinterpreted the spec in my code, please let me know, these words are just drafts I coded on the fly while reading the spec
20:20:16 <tpbsd> I'm more likely to hear from others
20:20:47 <tpbsd> I doubt I'll be doing much rv32 assembly for a while
20:22:13 <rdrop-exit> I jusrt wrote up an overview of the target controller for the tether using the nomenclature of the RISC-V spec.
20:22:16 <tpbsd> already the Forth code is a mess with Matthias using his personal STM32F register naming instead of the totally different GD32VF103 official register naming 
20:22:46 <rdrop-exit> Want to give me feedback on the description?
20:22:53 <tpbsd> Ive decided to use the official GD32 register naming
20:23:18 <tpbsd> sure. fwiw 
20:23:22 <rdrop-exit> https://pastebin.com/zBeXq1m1
20:23:28 <rdrop-exit> there you go
20:23:33 <tpbsd> looking
20:25:05 <tpbsd> looks like a tether commection description using JTAG :)
20:26:05 <rdrop-exit> yes, the devil is in the details of all the stuff beyond the target JTAG TAP
20:26:28 <tpbsd> yes, I bet this is the simplest of the pages to come
20:27:04 <tpbsd> the problem with writing doc is that one must understand the topic first ;-)
20:29:54 <rdrop-exit> right, specs have a way of describing simple things in a very roundabout way
20:30:34 <tpbsd> I'm convinced that good doc is a artform like painting or music
20:30:44 <tpbsd> take the stm32 docs
20:31:09 <tpbsd> theyre voluminous, but the subject is incredibly complex
20:31:48 <tpbsd> and it has often given rise to a phenomenon I haven't yet found a name for
20:33:04 <rdrop-exit> Standards such as this one are a pain because of all the optional stuff that might or might not be there.
20:33:17 <tpbsd> which is; I may read the description of a complex operation but find it ambiguous and have to run some interactive tests
20:33:37 <rdrop-exit> trust but verify
20:34:17 <tpbsd> the outcome reveals the facts BUT next time I re read that same doc, the ambiguity is gone ...
20:35:40 <tpbsd> Im willing to attribute this fairly rare occurrence on my own buffoonery, but I do wonder, is it just me ?
20:35:52 <rdrop-exit> No it's not
20:36:31 <tpbsd> I suspect it's not because perfect doc doesnt exist any more than perfect "anything else"
20:37:04 <tpbsd> and the 'quality' of everything is tied to time and money. Less of each means less quality
20:37:20 <rdrop-exit> What's perfect for one reader could be incomprehensible to another
20:37:26 <tpbsd> yes
20:38:03 <tpbsd> which leads me to my next conclusion, namely that "doing" is essential because 'reading' only takes one so far
20:38:08 <rdrop-exit> After a few months it can become incomprehensible to the author even
20:38:23 <tpbsd> hahah, I can believe that
20:39:21 <rdrop-exit> That's why my notes always include draft code
20:39:32 <rdrop-exit> helps me grok
20:40:19 <tpbsd> people often said that "windows codebase became huge, and coupled with the compartmentalisation brought about by microsofts secrecy paranoia, no one actually knew how it worked anymore"
20:40:48 <tpbsd> and one cant fix, what one doesnt understand
20:41:14 <rdrop-exit> that's a problem with all huge codebases
20:41:46 <tpbsd> the same applies to modern computer chips. With billions of transistors, the time any one engineer actually understood the whole thing, has long passed
20:42:54 <rdrop-exit> small is beautiful
20:43:17 <tpbsd> it may become obvious to everyone ... eventually that the Forth philosophy of breaking problems and solutions down into tiny manageable bits, all working together is in fact the only way forward ?
20:44:28 <tpbsd> it seems that once again, massive monoliths may be facing extinction
20:44:30 <rdrop-exit> Not for mainstream stuff
20:44:57 <tpbsd> well mainstream stuff isnt doing so well I think
20:45:30 <tpbsd> it's a bit like 'the kings new clothes' imho
20:46:26 <tpbsd> we often get people here telling us how Python is a Forth alternative, and they really believe it is. Of course they have never used Forth before
20:47:26 <tpbsd> the fact that python requires a minimum 250kB for it's core compared to a average 19kB on the same MCU for Forth just doesnt register with them
20:47:55 <rdrop-exit> Forth is very demanding on the programmer, Python I assume is not
20:48:01 <tpbsd> monoliths have become so common now
20:48:30 <rdrop-exit> Forths are monolithic but small
20:48:43 <tpbsd> I dont do python anymore, I wrote a program with it once about 2001
20:49:23 <rdrop-exit> I still haven't even cracked a book or watched a video on Python, I'm totally clueless about it
20:50:05 <tpbsd> it's just another language 
20:50:35 <tpbsd> and of course, just like every non Forth language, Python will always look like Python
20:50:38 <rdrop-exit> Usually when a paper, book, or video starts talking about object-oriented this, or functional that, I tune out
20:50:46 <tpbsd> yeah me too
20:51:28 <rdrop-exit> Forth has the word
20:51:32 <tpbsd> in the same way that C will always look like C
20:51:38 <tpbsd> and so on
20:51:55 <tpbsd> well in the beginning was the Word ...
20:52:01 <tpbsd> :)
20:52:58 <rdrop-exit> With Forth words I can do whatever I need
20:53:34 <rdrop-exit> I don't require more abstractive power than that
20:53:56 <tpbsd> one thing that embedded 'micropython' or 'circuit python' has that's is very cool, is a full screen editor, but it has to flash the chip to update the source
20:54:42 <rdrop-exit> It stores the source on the target?
20:54:45 <tpbsd> I imagine it's a bit like your system as the editor is very smooth
20:55:04 <tpbsd> no, it has to compile it
20:55:22 <rdrop-exit> My system is only fit for an aging caveman
20:55:46 <tpbsd> at 65 most here are kids to me ;-)
20:56:36 <tpbsd> the whole embedded python thing is very pretty and cool, but I'd never get anything done with it
20:56:58 <tpbsd> much of the usability is a illusion
20:57:13 <tpbsd> a cool illusion tho
20:57:49 <rdrop-exit> Chuck mentions in one of his talks the concept of the User Illusion
20:58:08 <tpbsd> summary ?
20:58:12 --- quit: dddddd (Remote host closed the connection)
20:58:33 <tpbsd> or url, as I hate asking anyone to do my work for me
20:58:33 <rdrop-exit> I'll see if I can find the quote, brb
20:58:37 <tpbsd> cool
20:59:41 <rdrop-exit> "This is the illusion that computers themselves are actually the abstractions which they implement"
21:00:23 <tpbsd> that makes my head hurt
21:00:39 <rdrop-exit> That's a quote from another guy discussing Chuck, I have the PDF, let me find a link
21:01:02 <tpbsd> you have a great reference system or brain
21:01:14 <rdrop-exit> http://www.ultratechnology.com/forththoughts.htm
21:01:26 <tpbsd> thaat the olf geoff * site ?
21:01:29 <tpbsd> old
21:01:44 <rdrop-exit> search for "User Illusion" on that page
21:02:12 <tpbsd> it looks very interesting THANKS for the link
21:02:20 <rdrop-exit> no sweat
21:02:56 <rdrop-exit> "The goal of such an effort appears to be to mask the increasingly complex underlying technology with a layer of abstraction which is intended to give the user the impression that the machine is less complex than it actually is."
21:03:18 <tpbsd> it's too juicy to search for one part I'll have to savour it
21:03:24 <rdrop-exit> cool
21:04:05 <tpbsd> the goal of abstracting everything seems to be working at least in the Arduino and C arenas
21:04:58 <rdrop-exit> Forth has abstractions but their all leaky as you're assumed to understand your technology stack inside out.
21:05:07 <rdrop-exit> * they're all leaky
21:05:29 <tpbsd> it seems to have also engendered new excuses such as "forth is no good because it has no libraries", or "I'm too busy to read a 1000 page STM32 technical reference"
21:06:19 <rdrop-exit> Forth demands a lot from the programmer
21:06:48 <rdrop-exit> The simplicity of Forth is not casual surface simplicity
21:07:07 <tpbsd> both of which have lead to interesting outcomes such as "does anyone have a led blinky library" or "what is a systick?"
21:07:45 <tpbsd> If have said that "Forth offers the programmer everything his heart desires"
21:07:50 <tpbsd> I'd
21:08:23 <tpbsd> at least as a technician, Forth allows me to do anything my heart desires
21:08:34 <rdrop-exit> Most programmers are just looking for the easy way out
21:08:49 <tpbsd> I mean can you get more abstract than "wash-cycle" ?
21:09:18 <tpbsd> or just "wash" ?
21:09:39 <rdrop-exit> I'm the same way when it comes to certain things, text processing for example, I'm very happy to just use AWK and not worry about the underlying details
21:10:19 <tpbsd> I admit Ive been looking at Forth text processing lately, mainly Forth source to HTML
21:10:36 <tpbsd> once I would have absolutely looked at Perl for that
21:11:04 <rdrop-exit> I once wrote a general purpose text macro processor that was Forth-like, all RPN
21:11:23 <tpbsd> and Ive found Forth HTML solutions quite common, Retro, Gforth, even amforth and some others
21:12:18 <tpbsd> so it seems I'm slowly being pulled into the PC Forth area now, something I thought would never happen
21:15:11 <rdrop-exit> I have no interest in Web related programming, so I'm spared having to deal with any of that
21:15:54 <tpbsd> same here, my only interest is for HTML doc for my Forth site
21:16:17 <tpbsd> which is my own notes anyway
21:17:14 <rdrop-exit> I prefer PDF for my docs, or plain text for notes to myself
21:18:01 <tpbsd> I love PDF's as well but theyre usless for web pages
21:18:49 <tpbsd> I once used to convert PDF's and LaTeX to html, but theyre just not well suited
21:19:21 <tpbsd> the page ends up looking like an academic text 
21:19:25 <rdrop-exit> When I save a web page to disk, I save as PDF
21:19:46 <tpbsd> HTML is too different, to make it readable different methods are needed
21:20:10 <tpbsd> well your system of referencing obviously works well
21:20:22 <tpbsd> do you by any chance use RECOLL ?
21:20:51 <rdrop-exit> I'm on a Mac, I just use the search bar on finder to search through all my PDFs
21:21:12 <tpbsd> hahah MAC the ultimate abstractor!
21:21:27 <rdrop-exit> Earlier I just searched for "User Illusion" in all my PDF's
21:21:38 <rdrop-exit> ironic isn't it
21:21:41 <tpbsd> sounds like it's using "recoll"
21:21:48 <tpbsd> yeah
21:21:58 <tpbsd> there is a place and time for abstraction
21:22:20 <tpbsd> how long did the search take in that case ?
21:22:28 <rdrop-exit> seconds
21:22:45 <tpbsd> ok, so it's all indexed, I'll bet it's using recoll
21:23:03 <tpbsd> unless you only have 10 pdfs ?
21:23:08 <rdrop-exit> The mac indexes the contents in the background
21:23:30 <tpbsd> yeah, recoll can do that or use a cron job
21:23:34 <rdrop-exit> I think it uses a Mac specific thingie
21:23:59 <tpbsd> is all your doc indexed or just pdfs ?
21:24:18 <rdrop-exit> I think it does everything, but I limit my search to PDFs
21:24:24 <tpbsd> word docs, ps docs etc
21:24:56 <tpbsd> doesnt matter anyway, whatever works
21:25:20 <tpbsd> when I upgrade this box I'll be reinstalling recol to index everything
21:25:30 <tpbsd> it's a fabulous resource
21:27:39 <rdrop-exit> https://en.wikipedia.org/wiki/Spotlight_(software)
21:30:50 <rdrop-exit> bbiab
21:32:00 <tpbsd> yeah spotlight looks different to recoll https://en.wikipedia.org/wiki/Recoll
21:32:03 <tpbsd> no problemo 
21:36:05 --- part: Labu left #forth
21:47:58 --- join: gravicappa joined #forth
22:00:11 --- join: smokeink joined #forth
22:31:45 <jsoft> tpbsd, mate, I am moving this sv
22:31:55 <jsoft> Cheers for egging me on
23:31:13 --- join: proteus-guy joined #forth
23:59:59 --- log: ended forth/20.01.18