00:00:00 --- log: started forth/19.09.09
01:01:08 --- join: dys (~dys@2003:5b:203b:100:a64c:c8ff:fef4:13a6) joined #forth
01:09:13 --- join: logiqub (524066ec@gateway/web/cgi-irc/kiwiirc.com/ip.82.64.102.236) joined #forth
01:59:54 --- part: reepca left #forth
02:02:08 --- join: reepca (~user@208.89.170.37) joined #forth
03:04:38 --- quit: proteusguy (Ping timeout: 258 seconds)
03:15:50 --- quit: mtsd (Ping timeout: 245 seconds)
03:17:43 --- join: proteusguy (~proteusgu@180.183.129.114) joined #forth
03:17:43 --- mode: ChanServ set +v proteusguy
04:10:49 --- quit: proteusguy (Ping timeout: 245 seconds)
04:18:30 --- quit: X-Scale (Quit:  HydraIRC -> http://www.hydrairc.com <- Like it?  Visit #hydrairc on EFNet)
04:55:07 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
05:03:20 --- join: mtsd (~mtsd@94-137-100-130.customers.ownit.se) joined #forth
05:34:35 --- quit: ryke (Ping timeout: 245 seconds)
05:39:09 --- quit: deesix (Ping timeout: 245 seconds)
05:39:37 --- quit: dddddd (Ping timeout: 244 seconds)
05:41:15 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
05:45:14 --- join: deesix (~dddddd@unaffiliated/dddddd) joined #forth
06:15:47 --- quit: nullnullnull (Quit: Leaving)
06:17:51 --- quit: MrMobius (Ping timeout: 244 seconds)
06:21:29 --- quit: dys (Remote host closed the connection)
06:39:06 --- quit: tabemann (Remote host closed the connection)
06:45:32 --- quit: mtsd (Quit: Leaving)
07:15:12 --- join: dys (~dys@2003:5b:203b:100:a64c:c8ff:fef4:13a6) joined #forth
08:15:44 --- quit: logiqub (Remote host closed the connection)
08:18:36 --- join: nullnullnull (~alaa@bzq-79-181-113-191.red.bezeqint.net) joined #forth
09:01:38 --- quit: jedb (Remote host closed the connection)
09:22:05 --- quit: nullnullnull (Ping timeout: 245 seconds)
09:22:44 --- quit: dave9 (Ping timeout: 246 seconds)
09:29:36 --- join: dave9 (~dave@069.d.003.ncl.iprimus.net.au) joined #forth
09:31:14 --- quit: gravicappa (Ping timeout: 245 seconds)
09:34:39 --- quit: dys (Ping timeout: 250 seconds)
09:45:41 --- join: gravicappa (~gravicapp@h109-187-24-48.dyn.bashtel.ru) joined #forth
09:54:10 --- quit: dave9 (Ping timeout: 245 seconds)
10:00:05 --- join: dave9 (~dave@069.d.003.ncl.iprimus.net.au) joined #forth
10:23:50 --- quit: gravicappa (Ping timeout: 264 seconds)
10:25:32 --- join: DKordic (~user@178-222-28-243.dynamic.isp.telekom.rs) joined #forth
11:09:04 --- join: WickedShell (~WickedShe@159-118-128-145.cpe.cableone.net) joined #forth
11:26:49 --- join: wildtrees (~wildtrees@unaffiliated/wildtrees) joined #forth
11:27:47 --- quit: wildtrees (Max SendQ exceeded)
11:28:34 --- join: wildtrees (~wildtrees@unaffiliated/wildtrees) joined #forth
11:54:09 --- join: wildtrees_ (~wildtrees@unaffiliated/wildtrees) joined #forth
11:56:55 --- quit: wildtrees_ (Max SendQ exceeded)
11:57:18 --- quit: wildtrees (Ping timeout: 244 seconds)
11:57:28 --- join: wildtrees_ (~wildtrees@unaffiliated/wildtrees) joined #forth
12:54:16 <WilhelmVonWeiner> hello forth
13:01:06 <`presiden> hello
13:02:08 <WilhelmVonWeiner> hows it going `presiden 
13:42:55 --- part: wildtrees_ left #forth
14:02:54 --- join: ryke (~Thunderbi@mail.homecaregiverstn.org) joined #forth
14:22:02 --- quit: ryke (Ping timeout: 264 seconds)
15:09:07 --- quit: chunkypuffs (Quit: ZNC 1.7.1 - https://znc.in)
15:17:50 --- join: chunkypuffs (~chunkypuf@static.203.112.216.95.clients.your-server.de) joined #forth
15:18:17 --- join: dave0 (~davezero@069.d.003.ncl.iprimus.net.au) joined #forth
15:57:46 --- join: jedb (~jedb@185.128.24.51) joined #forth
16:04:59 --- quit: cheater (Ping timeout: 245 seconds)
16:12:27 --- join: cheater (~cheater@unaffiliated/cheater) joined #forth
16:25:14 --- quit: dave0 (Quit: dave's not here)
16:43:36 --- join: ryke (~Thunderbi@71-9-169-152.dhcp.jcsn.tn.charter.com) joined #forth
16:56:31 --- join: tabemann (~tabemann@rrcs-162-155-170-75.central.biz.rr.com) joined #forth
17:34:46 <`presiden> fine I guess
17:35:06 <`presiden> no new forth news
17:36:50 <tp> I have Forth news, it's exciting to me, but probably not to you guys
17:37:13 <tp> like so much Forth, another persons Forth is another persons Forth ...
17:43:05 <tabemann> hey `presiden, tp
17:44:01 <`presiden> o/
17:47:40 <tp> hey folks
17:48:59 <tp> we are all on our make a better Forth quest or in my case "make a better development system for the Forth I use" as Im a tech and make hardware using forth, I dont make the Forth itself
17:53:38 <tabemann> making a Forth isn't hard!
17:54:29 <tp> have you finished your Cortex-M Forth yet, does it load to ram or flash as required ?
17:54:55 --- join: dbucklin (~dbucklin@ec2-18-221-180-137.us-east-2.compute.amazonaws.com) joined #forth
17:55:04 <tp> is it written in assembler ?
17:55:06 <`presiden> there are two kind of forth programmer
17:55:20 <`presiden> forgot that quote
17:55:23 <tp> the right kind and the wrong kind ? ;-)
17:56:17 <tp> Id rather work on a fast and error free Forth user development system, thats where my interest lays
17:56:25 <tabemann> tp: nah, I haven't ported hashforth to Cortex M yet
17:56:43 <tabemann> I need to learn more about the target architecture first
17:56:58 <tabemann> down to simple stuff like how to configure interrupt vectors
17:57:05 <tp> tabemann, I doubt that doing so will be trivial, which will be fun for you, but Id rather build hardware
17:57:58 <tp> tabemann, I've been learning the hardware in Cortex-M since 2014, I love the 2000 page technical reference manuals, hardware is my thing
17:58:35 <tp> my interest is building hardware to solve problems
17:58:43 <tabemann> once I get this working I probably won't have a cluse as to what to do with it
17:58:49 <tabemann> *clue
17:59:02 <tp> I'm the opposite, I have a 100 projects waiting
17:59:50 <tp> one I started last night is a 'continuity beeper' to replace the one I designed and built in 1985 and thats still working perfectly
18:00:34 <tp> that original beeper unit was the critical part in a job that made $30,000 AUD in three months back then
18:00:50 <tabemann> well, one project I will have to implement is a flashing LED
18:01:01 <tabemann> that's like the first project
18:01:11 <tp> the hardware equivalent of "hello world" :)
18:01:36 <cmtptr> just use an rc timer and call it a day
18:01:37 <tabemann> but not just any flashing LED, but one where I can still interact with the Forth REPL
18:02:29 <tabemann> okay, I've gotta go now - bbl
18:02:44 <tp> cya
18:03:36 --- quit: ryke (Ping timeout: 240 seconds)
18:03:44 <tp> cmtptr, you mean r&C with a ne555 or a two transistor multivibratoe ?
18:04:32 <tp> cmtptr, thats fine for learning some construction, but otherwise a waste of time imho
18:06:22 <cmtptr> it was a joke because obviously this is a software channel and he was talking about learning to write software
18:06:48 --- quit: tabemann (Ping timeout: 240 seconds)
18:07:12 <tp> oops, right over my head :)
18:07:30 <tp> is this a software channel ?
18:07:42 <cmtptr> this is #forth
18:07:53 <tp> Forth has always been traditionally closely tied to the hardware it runs on
18:08:00 <cmtptr> that's true
18:08:41 <tp> If this was a C channel Id fully agree with you
18:08:58 <tp> or Lisp or Perl etc
18:09:15 --- quit: dddddd (Remote host closed the connection)
18:10:08 <tp> so blinking a led in Forth is a traditional 'hello world' for a Forth programmer
18:11:22 <tp> what use is a Forth with no hardware I/O ? if a person here doesnt use any hardware I/O with Forth, then he is probably much more on the software side
18:11:58 <tp> and there are plenty of those for sure in the Forth world ... Forth purists and developers etc
18:13:06 <WickedShell> So I've been loitering here recently after a recent kick to look at Forth. How commonly is still used commercially? I just had trouble finding any recent examples of that, and the old books claiming to be more efficent code generated then C hasn't held up in the simple tests I've done of stuff like the project euler problems (although I could just be badly doing the forth code ofc :) )
18:13:49 <tp> hi WickedShell welcome to #forth :)
18:13:50 <WickedShell> (I get that for the wide variety of embedded boards out there it's a lot easier to beat/be consistent with the C compiliers, particularly in generated code size)
18:14:37 <tp> WickedShell, that's a interesting question and of course a very complex one to answer
18:15:48 <tp> some issues affecting the results are, what type of forth, how good is the Forth sourcecode for the test 
18:16:24 <WickedShell> I dumped it through the eval version of swiftforth but that may have been a bad target. I have gforth sitting here as well but didn't time it there
18:17:35 <tp> I can say that Forth executes about 3 times slower than compiled C on the same device in my tests, but code size is similar or less compared to C for a fully self contained bootable binary on hardware via a "tethered forth"bootable
18:17:35 <WickedShell> And to be fair the forth code was reading, compiling, and running the source from disk, rather then just being an object file, so I don't have a good baseline of the overhead on that, even though it was a small program :)
18:18:44 <tp> WickedShell, as i see it, the main forth advantage is in development because it is interactive 
18:18:58 <tp> interactive on the actual embedded target
18:20:10 <WickedShell> I'm actually in a debate of do I want to do Ada stuff on embedded or Forth atm :D ada has the appeal of type safety/static analysis which for what I'm doing is nice, but I've also had the rather dynamic enviorment of clojure which was nice for developing quickly
18:20:20 <tp> C requires the use of a separate debugger ie GDB over jtag or SWD, and when it comes to embedded hardware, debugging is the major area
18:20:23 <WickedShell> But the lack of typing has been leaving me feeling really burned when I got to refactoring :/
18:20:52 <WickedShell> Very very burned when it comes to refactoring :D
18:23:19 <tp> lack of Forth typing ?
18:23:45 <tp> Im not a real programmer, so I ask for your indulgence here
18:24:58 <tp> to me when a C programmer criticises Forth for not having any typing I see it as akin to criticising icecream for not having and cadmium
18:25:10 <tp> and = any
18:27:10 <cmtptr> how could you write it without typing???
18:27:17 <WickedShell> Typing is really nice when it comes to proving that the code you are trying to run at least has a chance to work. A stricter type system then C is really valubale though
18:27:24 <WickedShell> C lets you still do crazy stuff :)
18:27:54 <WickedShell> But when you start changing the interface a strong type system ensures that everything that's calling something has the expected argument count/type etc
18:28:11 <WickedShell> Which catches error in advance without relying on having a runtime test that crosses the code path
18:28:29 <WickedShell> It's an acknolwedged weakness with Lisp that refactoring is hard because of that
18:28:43 <WickedShell> But a lot of people feel that the speedup in intial writing was worth it
18:29:49 <tp> cmtptr, hahah
18:30:03 <WickedShell> I was in that boat, and have been frustrated recently, once I got stuff crossing the 10k LOC in clojure it was getting hard to change interfaces due to missing all the call sites/various places that used the results
18:30:21 <WickedShell> Particularly things that didn't crash, but just always took one path on a branch :)
18:31:11 <tp> WickedShell, concerning "typing' as no one actually writes programs in Forth, but rather uses Forth to develop a Problem Definition Language by adding to the language, how can you have typing ?
18:32:07 <WickedShell> tp frankly I'm not really sure you actually can. I'm more curious with how you deal with changing the number of things a word is expecting/leaving on the stack?
18:32:39 <WickedShell> IE I'm guessing the assumption is that if I change how many things a word I made is going to use/leave then I should be responsible enough to manually find/tweak all my call sites?
18:32:56 <WickedShell> (apologies if call sites is a bad term for Forth)
18:34:35 <tp> WickedShell, we have some really experienced Forth writers here, hopefully one of them may jump in and help here as Im a hardware guy, but I can explain from my own experience writing Forth solutions on embedded ?
18:35:05 <WickedShell> Sure, I'm just intersted in how people handle it :)
18:35:41 <tp> firstly the stack manages itself, Im always checking I dont inadvertently leave anything on the stack that isnt supposed to be there
18:36:09 <tp> when I started with Forth in 2014 leaving things on the stack was one of my main problems
18:36:22 <tp> but it's easy to check with a ".s"
18:36:48 <tp> I soon started using ".s" after every new Word I made
18:37:19 <tp> I dont now as it's 5 years later and Ive developed much more expertise
18:37:55 <WickedShell> I get that, but I don't think that really addresses what I'm getting at.
18:38:26 <tp> right now I can handle 3 nested parameters on the stack, but beyond that I feel I'm straining my mental horsepower
18:38:59 <WickedShell> lets say you reload a program you defined that included a word FOO that expected 2 numbers on the stack, and left 1 number on the stack. How do you handle change FOO when you are editing to now return 2 parameters. How do you handle checking that everything that invokes FOO is now ready for the extra parameters?
18:39:37 <WickedShell> I'm hoping there's a better answer then what I've come up with thus far :)
18:40:27 <tp> thanks for the elaboration, thats a fun question and one I think I can answer
18:40:33 --- join: dave0 (~davezero@069.d.003.ncl.iprimus.net.au) joined #forth
18:41:21 <tp> firstly the "stack comment" for your word should show what was expected and returned ( in -- out )
18:44:12 <WickedShell> Sure. But I still need to go adjust everything that uses the word FOO now, the comment is just that a comment (I think?)
18:45:17 <tp> secondly if you dont get enough expectede parameters, or return more than you are expecting, Forth will error
18:45:28 <WickedShell> Right. I'm looking to avoid runtime errors :)
18:45:40 <WickedShell> My stuff has a tendency to be flying, and runtime errors can be... expensive
18:45:53 <tp> Forth wont silently let you connect any words not meant for each other
18:46:45 <tp> your questions are awesome, any problem if I sanitise them and use on my own Forth site in my Q&A section ?
18:46:49 <WickedShell> When you say connect words not meant for each other you mean as a runtime error, or as something it checks when compiling the word definitions?
18:47:10 <WickedShell> feel free
18:47:16 <tp> thanks :)
18:47:24 <cmtptr> i also don't know what he means.  when i use forth, it lets me type whatever the hell i want whether it makes sense or not
18:47:28 <WickedShell> Probably needs a lot of sanatizing :)
18:47:38 <cmtptr> which can lead to segfaults or fire and meyhem
18:47:43 <tp> well when it runs it's going to use Words that are compiled so thats the same thing ?
18:48:30 <cmtptr> WickedShell, you should approach forth the way you would approach assembler with respect to safety
18:48:47 <tp> cmtptr, Forth wont let me type whatever I want, it errors or warns whenever I do anything wrong
18:49:04 <cmtptr> what forth are you using?
18:49:10 <WickedShell> cmtptr yeah that was my thought. Which would imply I just shouldn't and should use something that brings a lot stricter level of protection and assurance :(
18:49:14 <tp> mecrisp-stellaris on cortex-m
18:50:01 <tp> WickedShell, how can you do that to a language youre extending as you write your program ?
18:51:36 <WickedShell> tp, you can have strict type systems in languages which have let you have first class macros/code. (IE OCaml) I admit I don't know of any ocaml for an embedded board.
18:52:14 <WickedShell> In the embedded context I'm mostly looking at moving into Ada at this point which can prove at compile time a wide range of stuff can never happen at runtime (excepting a hardware fault, or a fault in the prover)
18:53:14 <WickedShell> I'll probably continue to experiment with forth for small/non critical projects, but probably not on anything that is gonna fly, unless I can find a better way to reduce the runtime error handling
18:53:40 <dave0> what about lisp ?
18:54:15 <dave0> from what i read it's extensible too
18:54:31 <WickedShell> It is, but it has the same problem with not catching errors until runtime
18:54:47 <dave0> Forth got me onto extensible languages
18:54:57 <WickedShell> (I actually brought it up originally as the example of something that's been biting me once I got to having a large program and wanting to refactor it)
18:55:44 <tp> WickedShell, those that write code for stuff that does fly dont use ADA
18:56:20 <tp> WickedShell, they use their own special PITA certified critical code stuff
18:56:52 <tp> they wont even use ADA as it's not able to provide the safety they want in aerospace
18:57:09 <WickedShell> tp, uh... Where are you getting that from? Aerospace is one of the main users of Ada at this point :)
18:57:32 <WickedShell> And apparently transporation in general has been on the rise with it.
18:58:01 <WickedShell> But one of the appeals of Ada is there are some rigerous static analyzers for it (Spark for example)
18:58:20 <tp> a guy who workes in aerospace in europe
18:58:41 <WickedShell> So what does he say they're using?
18:59:16 <tp> have a read of https://www.eevblog.com/forum/  and look for user "legacy"
18:59:32 <tp> hes really informative about all this
19:00:57 <WickedShell> :/ can't find posts on eevblog by a user without having an account apparently :(
19:01:06 <tp> so get a account ?
19:01:09 <tp> it's free
19:01:24 <tp> it's australian (like me) and not really commercial
19:01:53 <WickedShell> Oh I'm familiar with eevblog watch some stuff, but would rather not have yet another account to a site I won't actually be posting on :)
19:02:01 <tp> lot of noise and idiots and mainly C, but there are also posters like 'legacy' who are very informative
19:03:44 <tp> anyway, that where my info came from
19:04:02 <tp> I thought ADA was it until reading his posts also
19:04:39 <WickedShell> Uh as far as I can tell on posts thus far he's arguing in favor of using Ada for these things...
19:06:49 <tp> maybe, but he doesnt use it himself
19:06:56 <tp> hes not allowed to
19:09:30 <WickedShell> He has posts which state that he's done avionics ethernet switches entirely in Ada :)
19:09:43 --- join: rdrop-exit (~markwilli@112.201.170.86) joined #forth
19:10:10 <WickedShell> Soooo I'm gonna disregard that conclusion. Internal arguing with a company about Ada vs C is definetly a thing, and some are ofc picking the easier to hire programmer enviorment
19:11:32 <rdrop-exit> Good morning Forthwrights :)
19:11:45 <tp> he has a post where he also says that the language they use is not ada, he gave the name but I cant recall it 
19:11:53 <tp> hey rdrop-exit 
19:12:13 <tp> WickedShell, rdrop-exit is 1000% more expert her ethan me
19:12:14 <rdrop-exit> Hi tp
19:12:28 <tp> maybe 10,000% :)
19:12:43 <rdrop-exit> No way
19:14:08 <tp> WickedShell, 'legacy' also talks about their 'testing ?' dept which is full of mathematicians who prove all software designs mathematically before they can even code it, it's very interesting
19:14:19 --- join: ryke (~Thunderbi@71-9-169-152.dhcp.jcsn.tn.charter.com) joined #forth
19:14:26 <rdrop-exit> Formal methods
19:15:01 <tp> WickedShell, and recently 'legacy' even asked if I knew for a Forth for his old Motorola 68hc11 board :)
19:15:08 <tp> rdrop-exit, thanks :)
19:15:19 <rdrop-exit> Z notation, Petri Nets, etc...
19:15:22 <WickedShell> tp, yeah thats something you can do with some stuff like Spark (an Ada variant)
19:15:44 <WickedShell> It only proves some properties ofc, but it saves you from the kinda thing I was asking about here :)
19:16:00 <tp> WickedShell, most of the things 'legacy' talks about are well above my pay grade
19:17:27 <tp> WickedShell, it seems to me that aerospace is locked up tight to prevent errors by using all the latest methods and the brightest minds
19:18:17 <WickedShell> You may need to follow the risk factor for us more :) You need to be able to prove that you aren't going to kill people, particularly when they are stuck relying on electronics
19:18:28 <rdrop-exit> You can't
19:18:54 <WickedShell> Oh, in now way can you fully prove, I don't disagree, but you can signficantly reduce the risks of things happening
19:19:51 <tp> reducing risk seems to be the thing, my use of 'prevent' was poor
19:20:36 <tp> so in aerospace there are so many levels to reduce risk
19:21:38 <tp> WickedShell, you may also be aware that Forth has been used in aerospace since the very beginning and was even on the Philae lander ?
19:22:36 <tp> Forth isnt used in whichever branch of aerospace 'legacy' works in which I think is military
19:23:02 <WickedShell> tp sure. but complexity budget has grown as well, and I'm not seeing how you can use Forth (among others) to reduce problems associated with refactoring and proving that you don't have a major runtime error in advance
19:23:37 <rdrop-exit> The problem of formal methods is that they focus on the map not the territory
19:23:49 <WickedShell> Again, I'm just coming at this from the perspective of, I'm intrested in Forth, but I've also been intrigued in Ada/Spark recently as something that can reduce the pains I've experienced with trying to refactor large programs in a dynamic language
19:24:10 <WickedShell> rdrop-exit care to expand on that? I don't disagree per se, just not sure I followed you
19:25:08 * tp watches eagerly
19:26:24 <rdrop-exit> The Forth approach to reducing risk is to reduce complexity, which IMO is the most effective way
19:26:55 <rdrop-exit> There's been a lot of work done in safety critical with Forth
19:27:30 <tp> WickedShell, as a sidenote, I never refactored when I used assembly or C for embedded, but Forth has driven me to refactor and refactor until I have the simplest solution ... it's hard to explain, but Forth seems to do that to people
19:28:10 <WickedShell> rdrop-exit so the specific scenario I've been most frustrated with recently in something like Clojure was managing refactoring/interface changes. (IE ensuring that when I change the signature of what FOO does to the stack how do I ensure I'm handling that everywhere else other then programmer responsibility)
19:29:13 <WickedShell> tp, honestly I'd recommend playing with lots of languages, theres usually something to be gained by everything :) pretty much everytime I've played with a new language has informed/improved code I'm writing now
19:29:34 <WickedShell> IE doing work with Lisp/OCaml has improved my C/C++ code
19:29:53 <WickedShell> Even though I don't have feature parity/can't do some of the stuff I want to do in it and vice versa
19:30:24 <tp> WickedShell, agreed, Im learning Lisp and I like Ocaml but havent spent any time on it. Im a hardware guy, not a programmer
19:30:27 --- join: MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
19:31:15 <tp> WickedShell, Forth is like a magnet to me, I've barely scratched the surface and every day I find new ways to do things, new techniques
19:31:49 <rdrop-exit> The question doesn't make sense to me
19:31:54 <tp> C now seems massively bloated, complex and restrictive to my hardware solutions compared to Forth
19:33:06 <WickedShell> rdrop-exit fair enough :) I've changed the return signature on methods, and I didn't catch one of the places that was calling it before running it and it was not on a commonly hit code path, so I didn't find it till it crashed at a much later time.
19:34:18 <rdrop-exit> Why are you making changes in isolation, that's not refactoring
19:34:31 <WickedShell> I was trying to do it everywhere, I missed one spot by accident
19:34:47 <WickedShell> Human in the loop remember :)
19:35:19 <rdrop-exit> Forth is not going to do any thinking for you
19:35:36 <rdrop-exit> if that's what you're expecting
19:36:12 <rdrop-exit> It's not a parsed language with a formal grammar
19:36:16 <WickedShell> I'm not really. I'm pretty sure I knew the anwser was just "don't screw up the refactor" which I'm familiar with, but was wondering if I missed anything it was offering there
19:36:18 <rdrop-exit> It's clay that you shape
19:37:19 <WickedShell> The initial question that started this was more a question of "is Forth still being used commercially?" mostly the examples I could find in the industries I work in/care about are quite old, and it seems that its no longer actively used in these areas
19:39:02 <tp> WickedShell, https://wiki.forth-ev.de/doku.php/events:ef2018:forth-in-that  details a implantable sever spinal pain device using Forth
19:39:10 <tp> severe
19:40:24 <WickedShell> tp, cool will watch that in a bit
19:40:58 <rdrop-exit> Forth is mostly under the hood
19:41:00 <tp> WickedShell, there is also the fact that commercial companies don't usually tell people what they use. Does your washing machine fun Forth ? How about the controller in your $39 portable induction cooker form Aldi ?
19:41:48 <rdrop-exit> It's not a language in the traditional sense
19:42:08 <WickedShell> tp, yeah I realize that. The opposite way is you can usually find some notable public examples either way :) (usually from a book author or a compilier vendor using it to promote it)
19:43:01 --- quit: dave0 (Quit: dave's not here)
19:43:17 <tp> rdrop-exit, whats your opinion of 'typing' for Forth, does it need it, does 'static or dynamic typing' even apply ?
19:43:18 <rdrop-exit> Most Forths are in-house proprietary
19:43:31 <WickedShell> tp I don't think it applies for the record :)
19:43:44 <WickedShell> But I don't really know well enough to actually state that :)
19:43:53 <tp> rdrop-exit, will 
19:44:05 <WickedShell> You could retro fit it, but it'd look really different at that point/not be the same I'd imagine
19:44:05 <rdrop-exit> Typing is diffuse in Forth
19:44:10 <tp> WickedShell, I'm in the same boat
19:44:43 <tp> wow, how Zen is that reply!
19:47:03 <rdrop-exit> Typing is implicit in the words you write
19:48:29 <rdrop-exit> You decide the preconditions and postconditions of a word
19:48:40 <rdrop-exit> That's the only typing
19:49:06 <tp> is this related to 'typing' ?
19:49:08 <tp> : test2 if ." blah" then ." foo" ;  ok.
19:49:08 <tp> : test1 if ." blah" ;  Stack not balanced.
19:49:22 <tp> in the case of test2 everything is ok
19:50:01 <tp> but test1 does not have a matching "then" for the "if" and so a error is raised
19:50:43 <rdrop-exit> It's no different from assembly language, if you meet the reprequisites of the instruction you get guarantees on the output
19:50:57 <tp> the compiler knows the stack isnt balanced, but this was a result of a incomplete "if then" use
19:51:21 <rdrop-exit> My compiler doesn't care
19:52:06 <rdrop-exit> The spec of the word describes its expectations and its guarantees
19:52:25 <rdrop-exit> Usually it's pretty obvious what those are
19:53:05 <tp> my system prints any error message in red text on the terminal, beeps the terminal bell and can halt the source upload at the actual line (if the toggle switch enables it)
19:53:37 <rdrop-exit> In Forth you can specify those for the compile-time behavior, for the interpretation behavior, for the execution behavior, for metacompilation behavior, etc, etc...
19:53:49 <rdrop-exit> Types are between your ears
19:54:36 <tp> rdrop-exit, to a expert programmer yes, but to a noob like me, when I started Forth I had no idea what was wrong
19:54:45 <WickedShell> Yeah. About what I expected. Was mostly checking if I had missed something when I started looking into Forth recently :)
19:55:33 <tp> WickedShell, as we say 'when you know one Forth ... then you have learned ONE forth"
19:55:50 <tp> WickedShell, theyre all different
19:56:07 <rdrop-exit> tp, a system can include an overlay vocabulary for catching common coding errors, but it should be only that, an optional overlay vocabulary
19:56:40 <rdrop-exit> A safety net, you can use if you wish to
19:56:56 <tp> rdrop-exit, Im glad I have a safety net being a hardware guy
19:57:18 <tp> but even then the safety net was very thin and sparse when i started
19:57:41 <tp> errors would fly up the terminal screen and I'd miss them
19:57:52 <rdrop-exit> How much of a safety net has an assembler ever provided you?
19:58:23 <tp> I thought a lot when it came to my poor code
19:58:35 <rdrop-exit> Most attempts at high-level language-like assemblers have never caught on for the same reason
19:59:10 <tp> assembly has  the perfect 'typing' system imho ... when *anything* is wrong the target is just ... dead ;-)
19:59:32 <WickedShell> tp I'm gonna have to disagree with that. Depends highly on what you get wrong :D
20:00:03 <rdrop-exit> Forth's hallmarks are interactivity with the target and extreme incrementalism.
20:00:43 <tp> exactly, Forth will still be very vocal with most source errors because of it's interactivity
20:01:10 <tp> WickedShell, how long since you hand assembled a blinky on a mcu ?
20:01:50 <rdrop-exit> The most important thing to understand is that Forth is not a language
20:02:01 <tp> I agree
20:02:02 <WickedShell> Last time I did any assembly was ~10 years ago at univeristy :)
20:02:16 <rdrop-exit> at least in the sense most programmers expect
20:02:32 <tp> WickedShell, then you may have forgotten that the slightest problem with result in no blinks ?
20:03:30 <tp> rdrop-exit, would you agree that 'most Forth programmers don't program in Forth, they use Forth to create a problem definition language' ?
20:03:36 <WickedShell> ... I don't want to get into an argument about this, but load a constant wrong and you can still get blinks but get different behaviour/enable stuff you didn't want, and when you get to something larger then just an LED blinking you can just always jump to the wrong target for example
20:04:04 <WickedShell> Lots of ways in which it doesn't blink as well :)
20:04:42 <rdrop-exit> That's one traditional description but I think the term language is too limiting
20:04:56 <tp> I'm versed in quite a few of the ways to use Assembly to not make a blinky blink :)
20:05:12 --- join: X-Scale (~ARM@178.67.166.178.rev.vodafone.pt) joined #forth
20:05:24 <tp> rdrop-exit, thats cool, I struggle with the terminology 
20:06:56 <tp> WickedShell, I had a interesting period competing with the architect of the Forth I use to make the smallest binary sized blinky on 2 different MCU's, naturally he annihilated me
20:07:20 <rdrop-exit> I think the view that you develop a custom solution on top of Forth is wrong
20:07:31 <tp> he ended up making a 14 byte blinky for MSP430 and a 28 byte one for stm32-f0
20:08:21 <rdrop-exit> That description is more oriented to vendor Forths
20:08:39 <tp> rdrop-exit, I think i see where youre going there
20:09:26 <rdrop-exit> There is no set in stone Forth on top of which you develop your solution
20:09:41 <tp> rdrop-exit, do you mean that the custom solution is unique in that it uses Words that are not part of the initial base Forth Words ?
20:10:29 <tp> (whatever they may be)
20:10:31 <rdrop-exit> I mean that nothing prevents you from developing a custom Forth
20:10:36 <tp> oh
20:10:54 <tp> except the programming skillz ;-)
20:11:37 <tp> seriously tho, if anything prevented people from developing a custom Forth then there wouldnt be 10,000 Forths already :)
20:11:38 <rdrop-exit> Like for example a Forth for specific to smartcard solutions
20:12:02 <tp> yeah I get that
20:12:48 <tp> even a Forth using a tethered smartcard Forth ?
20:13:03 <rdrop-exit> Whatever you need :)
20:14:06 <rdrop-exit> Forth is more a collection of know-how for architecting and developing a custom low-floor high-ceiling technology stack
20:16:25 <rdrop-exit> Anyone who just tries to pigeonhole Forth as just another programming language doesn't get Forth IMO.
20:16:39 <rdrop-exit> They're missing the point.
20:17:21 <tp> It took me at least a year to get that point
20:18:01 <tp> before the 'aha' appeared over my head like a light bulb
20:19:42 <tp> I only persisted because I remembered the enthusiasm of programmers on Govt Forth projects where I had built the hardware for them
20:20:23 <tp> Department of Defence stuff for which I had a 'secret' clearance
20:21:14 <rdrop-exit> As soon as you try to pigeonhole Forth into a standardized programming language you make it into just another programming language.
20:21:20 <tp> one won't read about Forth use in *those* projects on the internet or in literature either ;-)
20:22:00 <tp> rdrop-exit, great point
20:22:57 <tp> rdrop-exit, A c++ guy had great enthuiasm for the Forth I use about 2 years ago, and started a 'system' called 'embello'
20:23:17 <tp> based on the infamous 'blue pill' $2 board from china
20:24:21 <tp> he put tons of work into building 'libraries' and Words that I thought imitated Arduino methods for configuring MCU GPIOS
20:25:32 <tp> at some point he found that he needed the Forth changed in some way to accommodate his needs and pleaded with the author of Mecrisp-Stellaris to do so
20:26:08 <tp> the author of Mecrisp-Stellaris flatly refused and this guy just dropped everything and went off on some other venture
20:26:44 <tp> all his psuedo C++ Forth code is now unmaintained, the early adopters stranded
20:27:31 <tp> it seems that Forth just doesnt make a great C++ for some reason
20:28:43 <rdrop-exit> So much effort is put in by newbies in trying to make a Forth that will appeal to the general programming public
20:29:20 <rdrop-exit> It's wasted effort by definition
20:29:52 <tp> i think this guy had hopes of geerating the same interest (and sales) for 'embello' as there was for 'arduino'
20:30:47 <tp> recently I was asked for assistance on my site with Mecrisp-Stellaris, the user had only ever made gear with basic and arduino
20:31:52 <WickedShell> So while you guys are here, can I intrigue you in crituqing a forth solution I did for one of the  Project Euler problems? (I tend to do these when playing with a new language for the first time)
20:32:04 <WickedShell> I'm curious how off I am from idiomatic forth :)
20:32:19 <WickedShell> https://projecteuler.net/problem=5 <- problem https://pastebin.com/uNZgYfUB <- my solution
20:32:32 <tp> he actually seems to be progressing well, but the difficult thing for me is that Forth is so massive, I can only feed him the tiniest forth things or it is utterly alien to him and he cant comprehend
20:33:15 <tp> rdrop-exit, he is months away from 'getting Forth I fear
20:34:22 <tp> WickedShell, sorry that's well beyond my pay grade, I left school at 16 years of age
20:35:02 <WickedShell> No worries :)
20:35:16 <rdrop-exit> WickedShell, I would just make the solution a constant, sorry :)
20:35:31 <WickedShell> rdrop-exit, well yes, but you do have to find the solution the first time :)
20:35:38 <WickedShell> Which is sorta the point of the program
20:43:45 --- join: gravicappa (~gravicapp@h109-187-24-48.dyn.bashtel.ru) joined #forth
20:45:56 <rdrop-exit> Sure, but it's a toy problem, I don't need arbitrary numbers, there's always a specific context driving the need, I would probably search the OEIS
20:46:58 <rdrop-exit> for the appropriate sequence
20:47:45 <WickedShell> Sure it's a toy problem. Most things for learning a language are a toy problem. But you can still have idiomatic solutions.
20:47:58 <WickedShell> Heck all the forth stuff I've read thus far has been toy problems...
20:48:41 <rdrop-exit> That is the idiomatic Forth solution, you determine the value any way you want and define a constant for it.
20:50:09 <WickedShell> I don't think thats a fair or realistic anwser. That'd hold true for every programming language/computer program ever. It also ignores how you got to the solution the first time
20:50:32 <tp> WickedShell, I fed your solution into my 48Mhz 32 bit Cortex-M0 and it's still .... thinking
20:50:33 <WickedShell> But whatever, I don't actually need feedback, was just curious
20:51:33 <WickedShell> tp takes ~1.6 seconds on my machine, the anwser is 232792560
20:51:41 <tp> WickedShell, my Forth apps are for hardware based solutions, the most recent was a mobility scooter motor control board
20:52:44 --- quit: DKordic (Quit: ERC Version 5.3 (IRC client for Emacs))
20:52:58 <tp> WickedShell, this is a tiny 5x5 mm chip, it's going to take a LOT longer than a pc
20:53:31 <tp> if I add a "." to your loops for visual feedback it will take ages longer
20:53:44 <WickedShell> tp, yeah, basically I was trying to point out I'm not expecting it to go that fast :) I've been doing stuff on STM32F4's for awhile now
20:54:23 <tp> I know you were, this is a 6 core/6 thread watercooled i7
20:54:43 <tp> with 12TB raid1 ZFS
20:54:52 <tp> running freebsd
20:56:55 <tp> i did some Benchmark: Calculate The Greatest Common Divisor For 0 to 200 for some different forths and mcus a while back 
20:57:20 <tp> https://mecrisp-stellaris-folkdoc.sourceforge.io/benchmarks.html?highlight=benchmark#benchmark-calculate-the-greatest-common-divisor-for-0-to-200
20:57:31 <rdrop-exit>  : pi ( -- numerator denominator )
20:57:31 <rdrop-exit>    $ 24baf15fe1658f99  $ bb10cb777fb8137 ;
20:58:49 <tp> WickedShell, the STM32F4 is a lot faster than my lil stm32f051
20:59:15 <rdrop-exit> Fixed point pi, for use with a 64-bit scaling operator that uses a 128-bit intermediary product
20:59:41 <rdrop-exit> bbiab
21:00:41 <tp> I just use 3.20 ... it's so much easier 
21:00:58 <tp> same here, bbl
21:24:05 --- quit: ryke (Ping timeout: 244 seconds)
21:41:07 --- quit: X-Scale (Quit:  HydraIRC -> http://www.hydrairc.com <- s0 d4Mn l33t |t'z 5c4rY!)
21:50:12 --- quit: WickedShell (Remote host closed the connection)
22:21:27 --- join: [1]MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
22:24:28 --- quit: MrMobius (Ping timeout: 246 seconds)
22:24:28 --- nick: [1]MrMobius -> MrMobius
22:49:35 <tp> "Is Forth used today?" well I used Forth today :)
22:50:47 <tp> and after about 2 hours my little cortex-m0 running Mecrisp-Stellaris Forth spat out ... find-lowest-div . 232792560
23:02:55 --- quit: deesix (Ping timeout: 245 seconds)
23:05:01 --- join: deesix (~dddddd@unaffiliated/dddddd) joined #forth
23:06:07 <tp> a physicist friend of mine just got a position with BECCAL (Bose-Einstein Condensate and Cold Atom Laboratory) in Germany. Apparently his love of algorithms and his Forth bare metal expertise was what got him the job to develop space based hardware :)
23:57:20 --- join: proteusguy (~proteusgu@mx-ll-180.183.129-114.dynamic.3bb.co.th) joined #forth
23:57:20 --- mode: ChanServ set +v proteusguy
23:59:59 --- log: ended forth/19.09.09