00:00:00 --- log: started forth/18.10.18
00:44:52 --- quit: wa5qjh (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
00:49:23 --- join: ncv (~neceve@2a02:c7d:c5c9:a900:6eaf:6ef7:3b81:d5f6) joined #forth
00:49:23 --- quit: ncv (Changing host)
00:49:23 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
01:51:36 --- join: dave9 (~dave@90.20.215.218.dyn.iprimus.net.au) joined #forth
02:03:11 --- quit: ashirase (Ping timeout: 268 seconds)
02:08:05 --- join: ashirase (~ashirase@modemcable098.166-22-96.mc.videotron.ca) joined #forth
02:20:44 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
03:05:28 --- quit: rpcope (Ping timeout: 268 seconds)
03:06:24 --- join: rpcope (~GOTZNC@muon.copesystems.com) joined #forth
03:12:39 --- quit: wa5qjh (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
03:27:14 --- quit: nighty- (Quit: Disappears in a puff of smoke)
04:23:59 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
05:27:26 <siraben> KipIngram: Bad news.  My target is beginning to break.
05:27:45 <siraben> Something's faulty with the ROM, I did a system check and it said "ROM failed", perhaps mechanical shock at some point during handling?
05:27:59 <siraben> Who knows.  I'll try to get it fixed.
05:28:21 <KipIngram> Ah, BUMMER.  That calculator is still available, though, isn't it?
05:28:31 <KipIngram> If not officially, likely on eBay.
05:28:44 <siraben> Yeah
05:28:49 <KipIngram> I'm about to drive - back in a bit.
05:28:50 <siraben> I found out because I was doing some calculations today, as I have done a million types
05:28:53 <siraben> times*
05:29:20 <siraben> Typed -3/-5 and it crashed!  Did it on a friend's calculator and they handled it fine.
05:29:22 <Zarutian> siraben: which product id is it? TI- something right?
05:29:30 <siraben> Ti-84
05:29:34 <siraben> TI-84 Plus
05:29:50 <Zarutian> you handle it roughly sometimes?
05:29:50 <siraben> (which is weird because there was no original TI-84)
05:30:02 <siraben> Well it's in my bag.
05:30:18 <Zarutian> and it has an slide cover right?
05:30:38 <siraben> Been working great for the past, what, 6 years?
05:30:39 <siraben> Yes.
05:30:42 <siraben> So could be internal.
05:30:45 <siraben> I'll try to see if re-flashing the OS would fix it.
05:30:47 <Zarutian> hmm.. do you know of any electronics technicians or repair shops?
05:31:02 <Zarutian> oh, you can reflash it? the 'ROM'?
05:31:32 <siraben> That's what I'm wondering,  it's "ROM" but I'm not sure exactly what that means, in TI terms.
05:31:50 <siraben> There's a tech repair department at my school, so I'll try to ask them first.
05:31:53 <Zarutian> it is probably a flash chip of some kind
05:32:04 <siraben> But they service computers, not calculators AFAIK.
05:32:22 <siraben> I'm interested to know what this "ROM" is.  The OS can be reflashed
05:32:26 <Zarutian> ask them anyway, they can probably point someone out
05:32:29 <siraben> Even with a third-party one, like KnightOS
05:32:31 <siraben> Right
05:33:56 <Zarutian> btw, have you been writing on this TI-84 Plus a lot to non-volatile storage?
05:34:37 <siraben> No.  I do that only when I have a "good" version of my interpreter and do something called a GROUP which backs up variable contents (like programs)
05:34:47 <siraben> And writes to the archive, i.e. non-volatile memory.
05:34:52 <Zarutian> it could simply be that the flash chip is 'worn out' and needs replacement
05:35:48 <Zarutian> the going about replacing it might cost much more than the calculator in terms of cost.
05:36:23 <siraben> Right.  If I do need to buy a new calculator I'll get the newer TI-84 CE ones.
05:36:28 <siraben> Which are much faster.
05:36:42 <siraben> And I'd have to rewrite my interpreter, so that would be fun.
05:36:59 <Zarutian> but try reflashing the 'ROM' before you go and do anything drastic
05:37:24 <siraben> In fact, my younger brother recently had to get a calculator for school as well, and it's the CE model.  I downloaded an assembly Pacman clone and it blew me away.
05:37:31 <siraben> Higher resolution, color, fast sprites.
05:37:47 <siraben> From what I've skimmed the assembly language is nicer too.
05:38:18 <Zarutian> if you buy a new one then dont throw the old one away, write a short note of what is wrong with it tape that to the calculator and give it to a competent hackerspace.
05:38:58 <siraben> Yeah. Sounds good.
05:39:05 <Zarutian> then someone might have some fun repairing it. I hate indiscriminate e-waste.
05:40:41 <Zarutian> talking about targets
05:42:09 <Zarutian> I see that ATMEGA32-16PU (the one used in Arduino and is in PDIP package) has features that supports subroutine call thread forths nicely
05:42:26 <Zarutian> threaded*
05:43:02 <siraben> https://education.ti.com/en/products/calculators/graphing-calculators/ti-84-plus-ce?category=specifications#specifications
05:43:12 <siraben> "154KB of available RAM memory", wow!
05:43:35 <siraben> Ah there is the "ROM" "3 MB FLASH ROM memory for data archive and storage of Apps"
05:43:38 <siraben> It's not really ROM, then.
05:43:44 <siraben> Just non-volatile storage.
05:44:01 <siraben> ^that's the newer model
05:44:02 <Zarutian> I am using registers r26&r27 which is also indirect register X for datastack pointer
05:44:24 <Zarutian> noice
05:45:36 <siraben> There's also an emulator for this model for Macs, so debugging would be faster
05:45:37 <siraben> https://github.com/CE-Programming/CEmu
05:45:55 <siraben> In fact, this is not such a bad idea after all.  I'd expect rewriting it to take around half as long as the first time because I know what I'm doing.
05:48:16 <siraben> Just did a full reset "RAM + ROM" on my TI-84, let's see.
05:48:19 <dave9> Zarutian: i have used a small atmel mcu before, does your ATMEGA have 3 address registers X,Y,Z ?
05:48:30 <siraben> Nope.  It still crashes :( 
05:48:32 <Zarutian> dave9: yeah
05:49:05 <Zarutian> siraben: then most likely some memory cell in the flash might become unusable.
05:49:58 <dave9> Zarutian: i found Y best for variables
05:50:00 <Zarutian> siraben: but look at the bright side! You can get that newer one and donate the old one to a hackerspace. (They might repair it, the might steal the lcd for some other project)
05:50:41 <siraben> Could be a fun disassembly project, right?
05:51:09 <Zarutian> dave9: what do you mean variable? Like pointing to user variables (which DOUSE or equiv do indexing into)?
05:51:47 <dave9> Zarutian: nah this was before i knew of forth, i used atmel long ago in assembly
05:52:11 <Zarutian> siraben: if you have the correct tools and know how to take the thing apart without breaking anythting.
05:52:42 * siraben has never disassembled anything before
05:53:24 <siraben> Well, successfully or putting it back together again
05:53:30 <dave9> Zarutian: forth is very different to any code i used to write, in assembly or C
05:53:43 <Zarutian> dave9: yeah, I am programming it in assembly but in such a way to use a datastack and returnstack (X and SP registers as their pointers)
05:53:54 <siraben> dave9:  It's wonderful :)
05:54:06 <siraben> dave9:  What do you normally write?  ASM and C?
05:54:25 <Zarutian> not having to keep track of which temp registers get clobbered is real nice
05:54:26 <dave9> siraben: C
05:54:48 <Zarutian> I found C compilers for MCUs generally produce crappy code
05:55:10 <siraben> Ah, so you're new to the idea of programs writing programs, meta-compilation and a language that can change its own semantics?
05:55:20 <Zarutian> too big, too slow and not all or majority of the instruction set is utilized
05:55:24 <siraben> I love how IF is defined in Forth itself, most languages can't do that.
05:55:58 <dave9> siraben: yep, and i like that it is interactive... C is definitely not and i see that as a weakness of C
05:56:17 <siraben> Most definitely.  Interactive languages make learning great.
05:56:38 <siraben> Also, implementations support the SEE word which is a good way to see how the language is defined in terms of itself.
05:57:51 <Zarutian> siraben: well you can use the SK calculus to fake it in Scheme and in Tcl: proc if_ {cond conseq altern} { uplevel 1 [lindex [list $altern $conseq] [uplevel 1 [list expr $cond]]] }
05:58:19 <Zarutian> (the uplevel is pretty much 'eval in the callers variable scope')
05:59:09 <siraben> Tcl?  Never heard of it before.
05:59:23 <siraben> Zarutian:  Right.  All you need are lambda expressions.
05:59:37 <siraben> But that's a very abstract model of computation, Forth makes it dead imperative.
05:59:42 <Zarutian> Tool Command Language, with Tk it is quite handy to use to throw together some GUI for some small utilities
06:00:16 <Zarutian> also many design tools I use are scriptable with it
06:01:22 <Zarutian> I like Forth for how small and minimalistic its requirements are
06:01:57 <Zarutian> I like Tcl as a more consistient shell than bash
06:02:09 <siraben> So do you use it?
06:02:51 <Zarutian> yeah but then again I am rather multilingual programming language wise
06:03:19 <siraben> Are you much of a Haskeller?
06:03:35 <siraben> I've been learning that too, mind-bending.
06:03:40 <Zarutian> nope, to me Haskel looks like Overly Extended Backus Noir notion
06:04:06 <siraben> Wait tell you see Coq ;)
06:04:07 <siraben> Till*
06:04:28 <Zarutian> I grok pure functions, immutability and Meely machines but monads in general elude me
06:05:03 <siraben> Syntax is a touchy topic. Forth gets around that by having none at all
06:05:06 <siraben> Meely machines?
06:05:26 <siraben> Monads are a general concept. I finally "understood" them when I was reading papers on monadic parsing
06:05:32 <Zarutian> Tcl doesnt have syntax, just a few quoting rules.
06:05:59 <Zarutian> could be Mealy machines. I never recall how the guys name is spelled.
06:06:31 <siraben> In the same way that functors represent a "lifting" of elements (i.e. mappings between categories in category theory), monads do some lifting as well
06:06:42 <Zarutian> basically a Meely machine is a function that takes two arguments, inputs and old_state, and returns outputs and new_state
06:06:43 <siraben> The best way to get it is to read some papers, I think
06:06:56 <siraben> Ah, so it makes a monad
06:07:34 <siraben> Run :: (Data, State) → (Data, State)
06:07:46 <Zarutian> could be? do not know. Anywhat that is how one can model and think of one cpu fetch&execute cycle.
06:08:06 <siraben> What if you have a function that takes data and returns data and state?
06:08:31 <siraben> f :: Data → (Data, State)
06:08:37 <Zarutian> that is some other machine related but I dont recall the name of the guy
06:09:05 <siraben> So the bind operator (>>=) can compose these thing s
06:09:23 <Zarutian> and there is one other that takes in (Data, State) and returns just (Data)
06:10:00 <siraben> (>>=) :: Data a → (a → Data b) → Data b
06:10:02 <Zarutian> siraben: heard about evolutionary/genetic cartesian programming or even just ROM logic?
06:10:17 <siraben> Where Data is some sort of type constructor
06:10:29 <Zarutian> the latter basically implements a Mealy machine cheaply in hardware.
06:10:46 <siraben> It's pretty interesting what State monads can do, model mutation in a pure manner.
06:11:05 <siraben> I've heard about and done some genetic programming
06:11:10 <Zarutian> siraben: sorry, but I have heard the word type used in so many conflicting ways in the real of computer science that the word has lost all saliency for me
06:11:11 <siraben> In Mathematica.
06:11:54 <siraben> Basically, Data Integer may represent that the machine is holding an Integer with some state
06:12:05 <siraben> Data is a functor
06:12:25 <siraben> Do you write Scheme?
06:15:20 <siraben> By the way, the State and Parser monads are somewhat simple. What is really mind-melting (and I fail to understand this completely) is the Continuation monad. M
06:15:58 <siraben> Zarutian: ROM logic?
06:16:31 <Zarutian> ROM logic: you have a register (a series of D flipflops or JK flipflops) to keep state. You feed the output of that plus any external inputs to the address port of a ROM. You feed some of the data lines into the register and some are the outputs.
06:17:43 <siraben> Functional programming is my go-to for quick hacking on things/new concepts.  I go imperative for performance or because I just want to "do" things without needing extra abstraction.
06:18:04 <siraben> Zarutian:  Ah, so like a state machien.
06:18:06 <siraben> machine*
06:18:20 <Zarutian> yes, a very simple one.
06:18:35 <siraben> Add the ability to perform read/write to memory and some branching and voilá you have a Turing complete model.
06:18:59 <Zarutian> heck, many old keypad locks were implemented in this way.
06:20:19 <Zarutian> (three by four 'phonepad' was used. # was used as an 'code-ender' to prevent attacks via De Bruin sequences)
06:21:02 <Zarutian> and the rom? well, it was an EPROM iirc.
06:24:03 <Zarutian> recently I thought of a way to hand make a ROM cheaply from newspaper paper, aluminum foil, conductive glue (mix kid safe hobby glue with metal filings dust) and a pick'n'place tape-roll of cheapest rectifier diodes avialable.
06:24:39 <siraben> Would that work?
06:24:53 <siraben> Why not just buy a chip?  Seems cheaper.
06:25:04 <Zarutian> (the diodes are needed to go from the selector lines to data lines)
06:25:32 <Zarutian> well, depends. For a long while I was trying to eliminate the need for the diodes
06:26:48 <Zarutian> this is usefull for when you want to be sure that some programmer-device didnt put something else in your flash than you thought
06:26:51 <KipIngram> siraben, dave9: As a fun exercise, you might try writing your uown SEE.
06:26:57 <KipIngram> It's straightforward.
06:27:12 <siraben> dave9: Try to read jonesforth, it's a good place to start
06:27:19 <siraben> KipIngram:  I have!
06:27:29 <Zarutian> dave9: I also recommend eForth
06:27:29 <siraben> It's great.  And best of all when you type "SEE SEE"
06:27:45 <siraben> Reflashing the OS, 36% done.
06:27:53 <siraben> Fingers crossed.
06:27:59 <KipIngram> siraben: Moore and Mealy machines (not our Moore) are terms you encounter primarily in digital hardware design.
06:28:23 <KipIngram> :-)  Sometimes a couple of you guys get more computer-sciency than I do re: Forth.
06:28:25 <dave9> i've been looking at this.. bare metal forth for 6502... https://github.com/scotws/TaliForth2
06:28:26 <siraben> Looking at the wikipedia article for Mealy machines right now.
06:28:34 <KipIngram> Forth: Telling the computer what to do.  :-)
06:28:42 <KipIngram> Pretty much end of story for me.
06:29:05 <siraben> Oh wow, reflashing is failing.  I can't even turn on the target anymore :(((
06:29:10 <siraben> Well I can but it says "Please install operating system"
06:29:15 <KipIngram> Moore machines have output a function of state only - inputs don't directly affect outputs.
06:29:21 <KipIngram> They affect output indirectly via causing state changes.
06:29:25 <siraben> *"Please install operating system now."
06:29:28 <siraben> Ah, right.
06:29:36 <siraben> So a finite state transducer.
06:29:42 <KipIngram> There's a formal procedure for converting between Moore and Mealy.
06:29:57 <KipIngram> Which is probably rarely used - generally you design one or the other from the ump.
06:29:59 <KipIngram> jump
06:30:07 <siraben> I love these theory of computation ideas, very concise definitions.
06:30:35 <siraben> Zarutian:  Yeah I think the flash has had its time.
06:31:09 <Zarutian> siraben: yeah also, that arts-and-crafts ROM is handy for when you have quite a small rom like in that keypad lock.
06:31:24 <siraben> Right.
06:31:45 <siraben> Hm.  I doubt this machine could be repaired.  I really have to get a new one.
06:32:13 <siraben> Argh, sad day.
06:33:33 <KipIngram> I think one of the nicest things about Forth is that you're not locked in to any of these "formal concepts."  You can just do anything you want.
06:33:52 <Zarutian> heck I even seen pictures of these kind of keypad locks were to rom is a piece of punched paper card
06:34:24 <KipIngram> And package it as nicely as you want.
06:35:09 <Zarutian> it gets clamped between a 'ball-grid' and a 'circle-grid'.
06:35:54 <KipIngram> Neat.
06:36:02 <KipIngram> Simple.
06:37:23 <Zarutian> (the circles are connected in rows and are the data lines, while the balls are the kathode-ends of the diodes connected to the 'word' select lines)
06:38:41 <Zarutian> that keypad thing was quite handy for semi-publicly-accessible places where the code needed to change every two weeks
06:39:09 <Zarutian> btw, does bi-weekly mean every two weeks or twice a week? ;-Þ
06:41:41 <Zarutian> this was from way before eeproms, MCUs or such were cheap enough to take over
06:47:12 <KipIngram> twice a week
06:47:27 <KipIngram> every two weeks is semi-weekly
06:47:54 <KipIngram> Which is very similar to bi-monthly
06:48:06 <KipIngram> but not quite
07:06:02 --- join: nighty- (~nighty@s229123.ppp.asahi-net.or.jp) joined #forth
07:14:18 --- quit: tabemann (Ping timeout: 260 seconds)
07:22:31 <siraben> Looks like I stumbled upon a community of TI hackers.  They're writing their own operating system "KnightOS".
07:22:35 <siraben> There hasn't been any Forths for it, so I think I should attempt to port mine
07:22:40 <siraben> Just the system calls will need to be replaced.
07:26:27 <KipIngram> I'm waiting for you to decide to go for bare metal.  :-)
07:26:32 <KipIngram> Your Forth could *be* the OS.
07:27:19 <siraben> Ah, right of course.
07:27:44 <siraben> I'll stick around that community as well and see how they do their OS development and glean a thing or two
07:28:16 <siraben> Funnily enough, they said that they don't use their calculators for numerical computation, just for hacking
07:28:37 <siraben> This also means that if I am to continue development on this I should just get another same model TI-84 and not worry about the new-fangled CE
07:28:47 <siraben> Because they already have quite a bit of experience with this black and white display one.
07:29:02 <siraben> Can't wait to go bare metal :)
07:48:50 --- join: moony (moony@unaffiliated/moonythedwarf) joined #forth
07:49:07 <moony> thing this is cool
07:51:54 <siraben> moony is a Forth enthusiast I found in #powder-subframe :) 
07:52:07 <KipIngram> Hi moony.  Welcome.
07:52:09 <moony> "enthusiast" is a overstatement
07:52:41 <moony> i'm just someone who loves challanges, like codegolf. Forth is a fun thing to do that in sometimes :P
07:53:06 <moony> that, and its easy to implement on obscure hardware
07:53:24 <siraben> I'm porting to a calculator
07:54:04 <moony> I'm working on a emulator for the MC88100 so i can probably do things with it. FORTH likely included :P 
07:54:35 <moony> glad i got the manual in paperback, it'd be a pain to navigate in PDF form
07:55:32 <moony> i can see why this CPU failed tho >_> Integer and Floating Point registers are in the same file
07:55:32 <moony> so it can't do them simultaniously
07:56:10 <moony> the 31 registers + zero ro register design is nice tho
08:04:17 <moony> ...i wonder
08:04:31 <moony> would it be possible to make a FORTH interpreter in Dwarf Fortress?
08:04:44 <moony> I mean, it is, the game's turing complete, but could you do it with only a 16x16 world space 
08:05:10 <nerfur> if it has something like controllable 0 and 1 than yes I guess ) 
08:05:44 <moony> it does. Someone made a space invaders clone in DF, so it certainly can do that
08:06:00 <moony> https://www.youtube.com/watch?v=j2cMHwo3nAU
08:06:42 <siraben> Has someone made a Forth interpreter for the Turing Machine?
08:06:44 <siraben> The ultimate computer, no?
08:07:01 <moony> siraben, too much math
08:07:11 <siraben> Has interesting technical challenges such as not being addressable directly (it's an infinite tape)
08:07:38 <siraben> I've written programs for the turing machine, for instance, palindrome and multiplying numbers.
08:13:50 <moony> You'd need a lot of states
08:14:21 <KipIngram> siraben: I wouldn't use the word "ultimate."
08:14:31 <KipIngram> It's more the "logically simplest" computer.
08:14:48 <siraben> Then again, I suppose the lambda calculus is simpler.
08:14:54 <KipIngram> It's really an academic device more than anything else.
08:14:58 <siraben> There's a lot of "turing equivalent models", they're all the same.
08:15:12 <siraben> Right.  Real machines don't work that way.
08:15:15 <KipIngram> Right - mathematically equivalent.
08:15:52 <siraben> That's why I prefer the lambda calculus, it's a lot like Lisp.
08:15:58 <siraben> The latter is inspired by the former.
08:16:08 <siraben> Much easier to reason about programs in it than the Turing machine
08:16:32 <siraben> There's also typed variants so you want prove type-checking algorithms, like the Hindley-Milner system used in Standard ML.
08:17:15 <KipIngram> I'm not terribly familiar with any of those thing.
08:17:27 <KipIngram> Processor is a functional block - I can tell it what to do and so solve problems.
08:17:41 <KipIngram> I'm a hardware guy at heart.
08:18:02 <Zarutian> siraben: Hindley-Milner? Wasnt it prooven that type systems written with that are interminable?
08:18:30 <siraben> What do you mean?
08:18:53 <siraben> I think it was that programs checked by that type system _cannot_ give type errors at runtime.
08:25:41 <WilhelmVonWeiner> very active channel today
08:28:21 <siraben> This channel seems to have been more so in the past month or two, right?
08:29:06 <WilhelmVonWeiner> Yep
08:30:09 <siraben> Good, good.
08:30:15 <WilhelmVonWeiner> quick! we need a web3.0 website!
08:36:02 <Zarutian> siraben: I mean that determining if a program giving a type system that follows Hindley-Miler is equiv to trying to solve the halting problem.
08:38:09 <siraben> Of course.  You're talking about equivalences of type systems.
08:38:20 <siraben> That's undecidable. 
08:38:38 <siraben> It's like saying "are these two programs the same?" impossible to say in general
08:38:59 <siraben> Hindley-Milner is a good start, but it doesn't allow for much abstraction.
08:39:12 <siraben> I'm not sure what Haskell's type system is based on, but I like the idea of typeclasses
08:39:24 <siraben> And, more recently, dependent types.
08:39:31 <siraben> (which I still have yet to learn)
08:39:46 <WilhelmVonWeiner> you know one of my programming pet peeves? variables named "creat" or "strng" or "cnt". This isn't 1980. You can spare the 1,2 extra characters
08:40:21 <siraben> Yeah.
08:40:30 <siraben> There are languages that do that?
08:40:37 <siraben> Plus, it shouldn't even matter because it gets tokenized anyway.
08:40:45 <WilhelmVonWeiner> There are people who do that.
08:41:00 * siraben wonders if he is one of those people
08:41:10 <siraben> I hope I'm not.
08:41:17 <Zarutian> what I have come to realize it is much better to forget about the whole compile-time/run-time type checking distinction and distinction of types from say guards. One is better of starting with a interpreter and then do Futamura transformations and partial evaluation to get an increasingly specialized program.
08:41:36 <WilhelmVonWeiner> Ken Thompson said it best:
08:41:41 <WilhelmVonWeiner> "Ken Thompson was once asked what he would do differently if he were redesigning the UNIX system. His reply: "I'd spell creat with an e." "
08:41:55 <siraben> Especially so for the definition of words themselves.  For internal program usage in assembly, my naming practice can vary quite a bit.
08:42:20 <WilhelmVonWeiner> if I have to name something parse_incoming_data(), I damn well will
08:42:54 <siraben> I just named a theorem in Coq recently this: "a_and_b_implies_a_implies_b"
08:43:00 <WilhelmVonWeiner> some uber-coder might name that prs_datai()
08:43:06 <siraben> Verbose?  Yes.  Unambigious?  Rightly so.
08:43:13 <siraben> Naming is hard.
08:43:26 <WilhelmVonWeiner> siraben: that would be "ab_im_a_im_b" 
08:43:58 <siraben> Yeah, I need to get better at naming in Coq.
08:44:09 <siraben> Reading Coq source code is so intimidating.
08:44:11 <WilhelmVonWeiner> or to save space abimaimb
08:44:55 <siraben> I suppose, but theorem names don't affect anything but how they read.
08:45:27 <WilhelmVonWeiner> exactly, and reading is GOOD! Code was designed to be read!
08:46:17 <WilhelmVonWeiner> Personally, "a_and_b_implies_a_implies_b" is a good name
08:48:46 <siraben> Other names: demorgan1 demorgan2
08:51:34 <dave9> in forth you could call it   a/\b->a->b   except in unicode for the proper math symbols!
08:52:21 <siraben> Do you guys do theorem proving?
08:54:29 <WilhelmVonWeiner> dave9: never thought about that
08:54:44 <WilhelmVonWeiner> just use unicode to use real mathematic and logic symbols
08:57:11 <dave9> WilhelmVonWeiner: yes!
08:57:40 <dave9> you could use proper × and ÷
08:58:10 <dave9> a language that can use ÷ for divide... who would have thunk it? :-)
09:56:40 <WilhelmVonWeiner> I think ISO ÷ divides the left half of the equation by the right half.
10:57:11 --- quit: ncv (Remote host closed the connection)
12:12:52 --- join: dys (~dys@tmo-080-79.customers.d1-online.com) joined #forth
12:34:57 --- quit: groovy2shoes (Ping timeout: 276 seconds)
12:45:07 --- quit: dddddd (Ping timeout: 244 seconds)
12:47:08 --- quit: dave9 (Quit: dave's not here)
13:53:49 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
14:41:25 --- join: wa5qjh (~quassel@175.158.225.202) joined #forth
14:41:25 --- quit: wa5qjh (Changing host)
14:41:25 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
15:08:06 <moony> 18<dave918> in forth you could call it   a/\b->a->b   except in unicode for the proper math symbols!
15:08:21 <moony> 1 × 2 ÷ 3 → 4 Compose key ftw
15:38:33 --- join: olopierpa (4f12eaf7@gateway/web/freenode/ip.79.18.234.247) joined #forth
15:41:57 --- join: dlyund (~marksmith@ip-62-235-65-225.dsl.scarlet.be) joined #forth
15:42:28 <dlyund> Does anyone know if it's possible to silence gforth warnings e.g. "redefined word"?
16:01:22 --- quit: wa5qjh (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
16:10:57 <WilhelmVonWeiner> run it with "gforth 2> /dev/null" maybe?
16:11:21 <WilhelmVonWeiner> redirect stderr to null usually works. It works on Lina
16:11:41 <KipIngram> Yes, I just tried that and it works.
16:12:09 <KipIngram> I've always found GForth errors/warnings excessively verbose.
16:12:27 <WilhelmVonWeiner> "warnings off" at the start of your session probably does it, too
16:16:05 <KipIngram> Oh, that's better, because it retains actual ERRORS.
16:16:24 <KipIngram> Unfortunately, "backtrace off" doesn't seem to work.
16:16:29 <KipIngram> That's the part that really bugs me.
16:19:49 <WilhelmVonWeiner> the best debugging for errors is a segfault. You should be counting the number of times you executed ." ERRROR!!!!!" and backtracking through your code from that.
16:20:17 <WilhelmVonWeiner> or forward-tracking(?) through the number of calls to `." Working here just fine" CR`
16:22:10 <Zarutian> WilhelmVonWeiner: curiously enough I use this method sometimes with MCUs and use a led instead of ." " CR
16:23:28 <WilhelmVonWeiner> I think it was Brian Kernighan who said something along the lines of: "The best debugging tool is careful thought, and judiciously placed print statements."
16:23:51 <WilhelmVonWeiner> ...emphasis on the latter.
16:34:31 --- quit: Zarutian (Ping timeout: 244 seconds)
16:35:58 <WilhelmVonWeiner> After switching to Lina forth I feel like my Forth code has improved
16:36:44 <WilhelmVonWeiner> it has less words than gforth, but it means I am not constantly searching for things to do X
16:37:09 <WilhelmVonWeiner> I mean, look at the glossary: http://home.hccnet.nl/a.w.m.van.der.horst/ci86.lina.html
16:37:49 <WilhelmVonWeiner> This is what Chuck means when he means Forth, 100-200 words that let you build your program, or build a vocabulary with which you write your one-liner program
16:40:58 --- join: Zarutian (~zarutian@173-133-17-89.fiber.hringdu.is) joined #forth
17:08:57 --- quit: nighty- (Quit: Disappears in a puff of smoke)
17:50:30 <dlyund> WilhelmVonWeiner: "warnings off" was exactly what I was looking for :-) thanks for all the suggestions guys.
18:15:39 --- join: [1]MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
18:18:11 <moony> WilhelmVonWeiner, my screen is too big for that site. First world problems
18:18:39 <moony> +240% zoom™
18:19:10 --- quit: MrMobius (Ping timeout: 272 seconds)
18:19:10 --- nick: [1]MrMobius -> MrMobius
18:32:30 --- quit: dlyund (Ping timeout: 245 seconds)
19:45:27 --- join: teach_me_x86 (18e4a485@gateway/web/freenode/ip.24.228.164.133) joined #forth
19:45:41 <teach_me_x86> Hello all.
19:47:09 <teach_me_x86> Just finishing up the "starting forth" book and am on chapter 11 (extending the compiler); I am confused about its explanation of postpone.
19:49:38 <teach_me_x86> I understand that when the word to the right of postpone is immediate, its address is compiled into the dictionary entry instead of being executed. But what about when the word is not immediate? From the explanation it seems to be a no op.
19:54:17 --- quit: olopierpa (Quit: Page closed)
19:54:25 <yunfan> what do you guys call those binaries that could be run on different cpu?
19:55:22 <jn__> polyglots
19:59:15 <teach_me_x86> I've been staring at the postpone word explanation on and off for 2 days and am not sure what to conclude.
20:00:42 --- quit: dddddd (Remote host closed the connection)
20:09:20 --- join: dave9 (~dave@90.20.215.218.dyn.iprimus.net.au) joined #forth
20:10:00 <dave9> hi
20:12:24 --- join: tabemann (~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net) joined #forth
20:23:31 --- join: rdrop-exit (~markwilli@112.201.162.180) joined #forth
20:28:04 <rdrop-exit> Hello Forthwrights
20:28:15 <rdrop-exit> :)
20:31:23 --- nick: dave0 -> dave42
20:31:36 --- nick: dave9 -> dave0
20:31:54 --- nick: dave42 -> dave9
20:33:31 <teach_me_x86> I think I understand postpone now.
20:33:44 <rdrop-exit> Excellent
20:34:06 <teach_me_x86> :]
20:36:41 <teach_me_x86> I've written down some topics to ask the room over the week since I'm hyped on trying to implement a dtc forth on x86 as soon as I finish the book this weekend.
20:36:54 <rdrop-exit> Which book?
20:37:30 <teach_me_x86> starting forth
20:38:04 <teach_me_x86> Read it a few times in passing but didn't do a deep dive until now
20:38:45 <rdrop-exit> Is this a revised online version of Starting Forth, POSTPONE didn’t exist when SF was written, just COMPILE and [COMPILE].
20:39:27 <teach_me_x86> The online version was revised some time ago, and the site seems to have been updated a year or 2 ago (looks great now)
20:41:20 <rdrop-exit> They must have ANS-ified it. The last edition of SF I read was the 2nd edition, which was based mostly on the Forth-83 standard.
20:41:40 <rdrop-exit> Great book.
20:41:51 <teach_me_x86> Superb book imo
20:41:52 <rdrop-exit> Thinking Forth is even better.
20:42:00 <rdrop-exit> Same author.
20:42:08 <teach_me_x86> As concise and short as the language itself
20:44:15 <rdrop-exit> I’ll have to check out the ANS-ified version, see what they changed.
20:45:55 <teach_me_x86> I have here written "ask #forth about the issue of register renaming, out of order execution, maintaining pipelining. Ask if 'caching TOS' means storing TOS value or pointer to TOS' "
20:48:05 <rdrop-exit>  Caching TOS means caching the TOS value in a register.
20:48:56 <rdrop-exit> This is a common optmization when running Forth on register machines.
20:50:07 <teach_me_x86> Thanks, I wasn't sure if I were to store the value itself in eax or have esi hold its address.
20:51:34 <rdrop-exit> You’re implementing on x86. It’s been ages since I’ve done any x86 assembly.
20:53:10 <teach_me_x86> I'm open to using another architecture like ARM since I have not begun implementation just yet. It's vaporware
20:54:00 <rdrop-exit> If you’re running on an FPGA-based stack machine, you can put the stacks in SRAM, effectively making the whole stack register equivalent.
20:59:42 <teach_me_x86> Unfortunately I've never programmed an FPGA
21:04:29 <teach_me_x86> Not sure where to even start with that, purchase one, learn verilog would seem proper
21:10:27 <rdrop-exit> There’s an old FPGA tutorial book that uses a Forth processor as one its examples, unfortunately the  board it uses is probably no longer made, and the Verilog is from before System Verilog.
21:17:04 <teach_me_x86> How did you begin learning fpga programming; I presume you had relatively high low-level knowledge prior? I ask that I may perhaps emulate the steps you took so I do not get lost.
21:24:27 --- quit: dave0 (Quit: dave's not here)
21:26:39 <rdrop-exit> My previous digital design knowledge was acquired from university courses in the 80’s, most of it was long forgotten. I basically read a pile of books on digital design with FPGAs, chip design, and Verilog/System-Verilog.
21:29:51 <rdrop-exit> You’re best starting point would depend on whether you already know the basics of digital design and are learning FPGAs and Verilog, or if you’re starting from scratch.
21:32:16 <teach_me_x86> Almost from scratch, I could read very simple toy schematics, such as a few SRAM cells and such, but even that requires me to strain my eyes and furrow my brow.
21:35:01 <rdrop-exit> In that case the best starting point is probably a digital design textbook that uses Verilog as the HDL for the examples, or an FPGA primer that covers the basics of digital design as well.
21:37:35 <rdrop-exit> I think some digital design textbooks come in two versions, one using VHDL for the examples,  the other using Verilog for the examples.
21:41:43 <rdrop-exit> Some of the Verilog specific books on my shelf are:
21:42:18 <rdrop-exit> - RTL Modeling with SystemVerilog for Siimulation and Synthesis by Stuart Sutherland
21:42:47 <rdrop-exit> - Advanced Chip Design with Practical Examples in Verilog by Kishore Mishra
21:43:09 <rdrop-exit> - Logic Design and Verification using SystemVerilog
21:44:28 <rdrop-exit> - Advanced FPGA Design, Architecture, Implementation, and Optimization by Steve Kilts
21:46:29 <teach_me_x86> From name alone, it seems I should begin with the third
21:47:54 <rdrop-exit> This one is not Verilog specific: Sequential Logic Analysis and Synthesis by Joseph Cavanagh
21:51:49 <rdrop-exit> Aha, here’s the most general and textbooky one I have: Digital Design by Morris Mano
21:52:17 <teach_me_x86> That sounds perfect hahaha.
21:53:21 <rdrop-exit> IIRC it was an older edition of that book that was used at university in the 80s
21:53:47 <teach_me_x86> In terms of hardware, what should a beginner acquire (including peripherals like wires, display, chipset of some sort, etc.)
21:53:55 <rdrop-exit> There are probably better general textbooks out there
21:55:03 <teach_me_x86> If possible include a time machine to the 80's so I may follow along with the old book
21:55:16 <rdrop-exit> :)
21:55:59 <rdrop-exit> A FPGA demo board is the place to start
21:58:39 <teach_me_x86> A search for "fpga demo board" returned an advertisement reading "Buy Fpga Programmer at amazon."
21:59:24 <rdrop-exit> Try Evaluation Board, gor example Terasic makes boards with Altera FPGAs
21:59:33 <rdrop-exit> *for
22:01:45 <rdrop-exit> … or Development Kit
22:02:26 <rdrop-exit> My Google-fu sucks
22:03:41 <rdrop-exit> The various FPGA manufacturer sites will have links to eval board suppliers
22:04:29 <rdrop-exit> Gotta break for lunch, see you around.
22:05:44 <teach_me_x86> Thanks for the discussion/help
22:08:03 <teach_me_x86> I'll drop by the room with various names (don't like the idea of registering, I have enough accounts to remember). Anyways I'm off to sleep; thanks again and see you around
22:08:17 <rdrop-exit> Take care :)
22:08:33 --- quit: teach_me_x86 ()
22:49:25 --- join: dave0 (~dave@90.20.215.218.dyn.iprimus.net.au) joined #forth
22:49:45 <dave0> re
23:27:05 --- quit: nerfur (Ping timeout: 245 seconds)
23:28:25 --- join: nerfur (~nerfur@broadband-95-84-184-13.ip.moscow.rt.ru) joined #forth
23:52:58 --- quit: dys (Ping timeout: 260 seconds)
23:59:59 --- log: ended forth/18.10.18