2023-04-26 04:07:30 <veltas      > And that's why systemd is a lot faster except when it isn't
2023-04-26 04:08:34 <veltas      > I swear I've not gained any performance improvements because they've been wiped out by occasionally having to wait 120 seconds for an unplugged ethernet port to connect
2023-04-26 04:08:56 <veltas      > Or occasionally it refuses to shutdown without wasting 120 seconds waiting for something
2023-04-26 04:09:12 <veltas      > I'd rather have something simpler that's a little slower starting/stopping
2023-04-26 08:39:51 <veltas      > I often look at compiler output when trying to write assembly, to see what possible optimisations they could suggest
2023-04-26 08:40:19 <veltas      > It works well a lot of the time, especially with the basics, but I am starting to run into situations where both GCC and clang output inoptimal code
2023-04-26 08:40:23 <veltas      > And completely different code too
2023-04-26 09:43:30 <vms14       > guys what's your favourite forth implementation?
2023-04-26 09:44:18 <vms14       > I only have tried pforth and gforth
2023-04-26 09:44:54 <vms14       > I had a look at tile forth, I liked a feature it had to bind values from the stack
2023-04-26 09:45:23 <vms14       > https://github.com/cstrotm/tile-forth
2023-04-26 09:46:04 <vms14       > : 2swap { a b c d } c d a b ;
2023-04-26 09:46:06 <vms14       > for example
2023-04-26 09:46:19 <vms14       > the { } does the binding
2023-04-26 09:46:30 <vms14       > it's supposed to be internal to that word
2023-04-26 09:50:01 <hello-operator> That's also implemented in gforth, it's a common feature for Forth implementations that implement locals.
2023-04-26 09:50:41 <veltas      > In Forth 200x standard it's {: and :}
2023-04-26 09:50:53 <veltas      > There are ANS implementations of that and { / } about
2023-04-26 09:51:18 <veltas      > There's a "locals" wordlist for ANS but it's not very good
2023-04-26 09:51:40 <veltas      > It's a controversial feature, some swear by locals, some refuse to use them
2023-04-26 09:52:50 <veltas      > It can make some words easier to write, but it also makes many words more verbose. It's definitely easy to get quickly away from a 'forthy' style with it
2023-04-26 09:55:10 <KipIngram   > gordonjcp: Yeah, systemd looks pretty nice.  It's just my first time working with it, and the machine in question is fairly hard to get an OS installed on - I super duper don't want to have to repeat that process.
2023-04-26 09:56:21 <veltas      > To answer your actual question vms14, I use gforth because it's easy to get on Linux. I don't actually like it much though
2023-04-26 09:56:29 <vms14       > KipIngram: I think you're the first person I see saying systemd is nice
2023-04-26 09:56:44 <KipIngram   > vms14: Those are the same two I have much experience with.  I've used pforth in consulting gigs back in the day; gforth I've mostly just "had around" to toy with.  Most of what I've done with Forth has been using imps I've written myself.
2023-04-26 09:57:01 <veltas      > gforth have not done a proper release in many years, so I think the team has some philosophical failings there
2023-04-26 09:57:04 <vms14       > KipIngram: forth consulting? :0
2023-04-26 09:57:26 <veltas      > And also the attitude of gforth team is pretty much "who cares about memory", "use C stack as much as possible" etc
2023-04-26 09:57:37 <vms14       > what kind of programs did you sell?
2023-04-26 09:57:57 <veltas      > I will one day move away from gforth permanently, most likely
2023-04-26 09:58:05 <KipIngram   > I've not looked very much at all at applying "computer sciencey" ideas to Forth.  To me "bind" means "make a variable have a certain value," and in Forth that says ! to me.  I don't think of it using a fancy word like "bind," though.  It's just a "store."
2023-04-26 09:58:27 <veltas      > That's a functional programming thing to call it binding
2023-04-26 09:58:35 <KipIngram   > I've never put locals into any of my systems, though I have thought a little about how I'd probably do it.
2023-04-26 09:58:39 <veltas      > At least I only see functional programmers say that
2023-04-26 09:58:39 <vms14       > it's a store, but a one that will disappear once the word finishes execution
2023-04-26 09:58:55 <veltas      > It's called scope in procedural languages
2023-04-26 09:58:59 <KipIngram   > In one system I do have words that will index the stack - I figure for locals I'd use stack effect comments to associate names with those words temporarily.
2023-04-26 09:59:50 <vms14       > I have a design flaw on my not so forth abomination I don't know how to fix
2023-04-26 10:00:02 <KipIngram   > vms14: Well, I did use pforth in that particular job.  I modified it to work over a network socket instead of the usual console and used it as a scripting language for a system I wrote to run a pick and place machine.
2023-04-26 10:00:25 <vms14       > there's no compiling at all, and the dictionary it's a hash table, so a word can only have one definition
2023-04-26 10:00:31 <KipIngram   > I chose it because it was easy to recompile it.
2023-04-26 10:00:51 <KipIngram   > And because I could see what was going on in the source code well enough to make the changes I wanted to make.
2023-04-26 10:00:53 <vms14       > the problem is when a word is using another words, if one of those words gets redefined it will use that new definition instead
2023-04-26 10:01:13 <vms14       > some sort of compiling would solve that, but I'd like to retain the feature of being able to modify a word behavior
2023-04-26 10:01:23 <KipIngram   > Yeah, that means you're modifying the original CFA field of the word.
2023-04-26 10:01:34 <KipIngram   > Instead of just adding a new word with the same name.
2023-04-26 10:01:52 <KipIngram   > Or that's what it would mean, in a typical Forth design.
2023-04-26 10:01:53 <vms14       > if it was a linked list, then it would kind of work
2023-04-26 10:02:12 <vms14       > as the old definition would have some sort of pointer to the old definition
2023-04-26 10:02:23 <veltas      > It's been said before that there aren't any good 'standard' C forths, which is bad because lots of people could probably plug those in to embedded problems, or places where they need scripting in an app
2023-04-26 10:02:26 <KipIngram   > In traditional Forth when you "redefine" a word all you're really doing is adding a new word that will now get found before the old one when you do a word search.
2023-04-26 10:02:27 <vms14       > but I'd like to be able to choose when a word will use newer definitions and when not
2023-04-26 10:02:40 <KipIngram   > So NEW definitions will use the new one.  But stuff that's already compiled isn't affected at all.
2023-04-26 10:02:44 <veltas      > If you can write a decent C-based forth that's somewhat standard then you've got a niche
2023-04-26 10:02:55 <KipIngram   > But if you go plug a new value into the original word's CFA field, then that changes everything.
2023-04-26 10:03:06 <vms14       > some sory of compiling would also solve that, even when the dictionary is a hash table
2023-04-26 10:03:20 <vms14       > but then I loose the ability to modify the behavior of an existing word
2023-04-26 10:03:31 <KipIngram   > See, the point is that an already compiled word doesn't have to search the dictionary for its component words.
2023-04-26 10:03:37 <KipIngram   > It has pointers to them already in place.
2023-04-26 10:03:50 <veltas      > Being a hash table doesn't actually preclude the old behavior
2023-04-26 10:03:50 <KipIngram   > That's the difference between "compiled" and "interpreted" in Forth.
2023-04-26 10:03:53 <vms14       > I somehow like to be able to make that word use newer definitions when I want to
2023-04-26 10:03:55 <veltas      > Just use closed buckets
2023-04-26 10:04:12 <vms14       > but having this feature as a default it's a bad choice
2023-04-26 10:04:14 <KipIngram   > vms14: I think what you're doing is always searching for each word, every time.
2023-04-26 10:04:18 <veltas      > Your issue is you didn't even implement the hash table :P
2023-04-26 10:04:22 <vms14       > KipIngram: yeah XD
2023-04-26 10:04:26 <KipIngram   > Which means you're actually always interpreting.
2023-04-26 10:04:28 <vms14       > there's no compiling
2023-04-26 10:04:41 <vms14       > a colon word is just an array
2023-04-26 10:04:49 <vms14       > I can even modify that array
2023-04-26 10:04:58 <vms14       > and they can have words names and even values directly
2023-04-26 10:05:08 <vms14       > the interprter would push values or interpret word names
2023-04-26 10:05:43 <vms14       > but the problem is even if I make a new package and define words there, if I'm on that package the interpreter will start looking there
2023-04-26 10:06:10 <vms14       > I suppose I can just get rid of this "feature" and get some sort of compiling
2023-04-26 10:06:22 <vms14       > I wouldn't be able to modify an existing word, but meh
2023-04-26 10:06:54 <vms14       > the problem it gives me does not balance the ability to modify existing words by just making a new word
2023-04-26 10:06:59 <veltas      > IMO your style of forth has been highly influenced by the choice of environment i.e. Perl
2023-04-26 10:07:07 <vms14       > yes
2023-04-26 10:07:11 <KipIngram   > Well, compiled words in Forth ARE just arrays.
2023-04-26 10:07:15 <veltas      > If you had written in C or assembly would probably have been more like a traditional forth
2023-04-26 10:07:17 <KipIngram   > it's just a matter of what the array elements are.
2023-04-26 10:07:23 <vms14       > it makes no sense to have memory allocation, nor even a call stack, I already have that
2023-04-26 10:07:32 <vms14       > that's why it will never be a real forth
2023-04-26 10:07:37 <vms14       > not even close to it
2023-04-26 10:07:52 <KipIngram   > Yeah, a Forth trait is the way it exposes the return stack.
2023-04-26 10:08:29 <vms14       > but I always wonder what if I stick more to a real forth
2023-04-26 10:08:42 <KipIngram   > Lets you do all kinds of nasty disapproved of things.  ;-)
2023-04-26 10:08:57 <vms14       > I love the colon words and for me forth's syntax is super nice
2023-04-26 10:09:04 <thrig       > danger power tools may sever limbs
2023-04-26 10:09:14 <vms14       > you just name the words to execute them
2023-04-26 10:09:14 <KipIngram   > Damn straight.
2023-04-26 10:09:43 <vms14       > the only drawback I see is not having optional parameters, it forces me to use lists
2023-04-26 10:09:47 <KipIngram   > Yes, exactly - the key thing compiling accomplishes is that you're now working with code addresses instead of word "identifiers."
2023-04-26 10:10:00 <vms14       > and stack juggling, which I can solve with temporary bindings
2023-04-26 10:10:13 <KipIngram   > But not all languages let you know what those addresses are.
2023-04-26 10:10:17 <Zarutian_iPad> question regarding use of byte pair encoding in Forth to ‘name’ words being entered
2023-04-26 10:10:42 <Zarutian_iPad> good idea or just bad?
2023-04-26 10:10:59 <KipIngram   > Example?
2023-04-26 10:11:05 <KipIngram   > Not sure what you mean by that, exactly.
2023-04-26 10:15:16 <vms14       > maybe I'll try to do it in the right way
2023-04-26 10:15:33 <vms14       > mainly faking some sort of memory allocation and a call stack
2023-04-26 10:16:01 <Zarutian_iPad> KipIngram: maybe it was just a brain burp
2023-04-26 10:16:35 <KipIngram   > You could, but even better would be to do it with a tool that really lets you do it right.  Which to me means either assembly or C (gcc, probably).
2023-04-26 10:16:47 <vms14       > but I wonder if I really have to
2023-04-26 10:17:01 <KipIngram   > :-)  You don't have to do anything.
2023-04-26 10:17:03 <vms14       > yeah, you're right KipIngram
2023-04-26 10:17:16 <vms14       > assembly is just the best choice to make a forth
2023-04-26 10:17:28 <vms14       > C is not as nice, but nicer than the other high level languages
2023-04-26 10:17:29 <KipIngram   > I'm a fan of assembly these days, but you CAN write a Forth in C that is in every respect a properly operational Forth.
2023-04-26 10:17:38 <KipIngram   > At least you can using gcc and the extensions it gives you.
2023-04-26 10:18:02 <KipIngram   > And it's pretty fast, too.
2023-04-26 10:18:02 <vms14       > the labels as values extension
2023-04-26 10:18:12 <veltas      > That's almost what gforth do
2023-04-26 10:18:13 <KipIngram   > Yes - pointers to labels, specifically.
2023-04-26 10:18:17 <vms14       > when I write C code I get even more stupid
2023-04-26 10:18:31 <vms14       > I start to worry about stuff I should never worry about
2023-04-26 10:18:56 <vms14       > like for example I dislike unions a lot cause they make every element of the union use the memory of the biggest element
2023-04-26 10:19:14 <KipIngram   > Zarutian_iPad: When I read that it struck me as implying that as you read each word you made a table that associated a 16-bit index with it.
2023-04-26 10:19:19 <vms14       > then I use perl which who knows how much memory uses for an element and I don't care
2023-04-26 10:19:40 <vms14       > but in this case it's me implementing it so I start to get picky with everything
2023-04-26 10:19:43 <KipIngram   > Yeah, and it probably won't tell you where in memory that element "really" is.
2023-04-26 10:20:04 <vms14       > I wanted a stack able to get any kind of type
2023-04-26 10:20:09 <KipIngram   > On the other hand, in C foo is at &foo.
2023-04-26 10:20:13 <vms14       > I ended having several stacks + a type stack
2023-04-26 10:20:15 <vms14       > xD
2023-04-26 10:20:42 <KipIngram   > Type stack is non-standard and to some extent "not Forthy," but that doesn't necessarily make it stupid.
2023-04-26 10:20:43 <vms14       > I like the fact the stacks do not exist until you actually put something there
2023-04-26 10:20:55 <vms14       > KipIngram: stupid is the way I did
2023-04-26 10:20:59 <vms14       > one stack is enough
2023-04-26 10:21:12 <vms14       > be it a void* stack or a union type stack
2023-04-26 10:21:27 <vms14       > but I disliked both ways
2023-04-26 10:21:42 <KipIngram   > Well, stacks can be "empty" in Forth, so we could have a metaphysical debate about whether such a stack "exists" or not.  But the RAM you're going to have it occupy exists.
2023-04-26 10:21:43 <vms14       > a void* stack forces me to allocate memory for every item, including integers
2023-04-26 10:21:48 <vms14       > then I have to free them all
2023-04-26 10:22:08 <veltas      > vms14: Maybe try writing C and not caring about these things, write dumb C code. C was actually designed originally as a dumb easy systems language
2023-04-26 10:22:13 <vms14       > a union type stack will use the memory of the biggest element for every cell, which I dislike too
2023-04-26 10:22:18 <KipIngram   > That's just a dynamic memory stack, and isn't inherently a bad thing.  Just not going to be as performant as an array of ints stack.
2023-04-26 10:22:26 <vms14       > yeah, that's why I say I get even more stupid
2023-04-26 10:22:35 <vms14       > cause I shouldn't be worrying about this
2023-04-26 10:22:40 <veltas      > Stupid code is fine though
2023-04-26 10:22:54 <KipIngram   > So the way you're really deviating from Forth there is by supporting types in the first place.
2023-04-26 10:22:55 <vms14       > not stupid decisions
2023-04-26 10:23:03 <veltas      > Or write bad code and ask other people with more experience "what would you change" and start there
2023-04-26 10:23:14 <KipIngram   > But... if it's what you want to do, there's nothing wrong with that.
2023-04-26 10:23:25 <vms14       > KipIngram: yeah, I want a stack able to get any kind of type
2023-04-26 10:23:27 <veltas      > Don't just ask anyone, ask someone (arrogantly) like me who actually has real world C experience
2023-04-26 10:23:39 <vms14       > but I could just have a normal stack and pointers to memory
2023-04-26 10:23:44 <KipIngram   > You're exploring territory, and I think that's almost always a worthwhile thing to do.
2023-04-26 10:24:07 <vms14       > veltas: I usually come to ##c or alike to ask about something
2023-04-26 10:24:10 <vms14       > I show the code
2023-04-26 10:24:21 <veltas      > A lot of people on ##c don't know what they're talking about
2023-04-26 10:24:23 <vms14       > then they start answering everything except what I asked
2023-04-26 10:24:43 <veltas      > Just because someone knows the standard well doesn't mean they have C experience, for example
2023-04-26 10:25:05 <veltas      > Or someone who hangs out on ##c doesn't necessarily have experience or even know the standard well
2023-04-26 10:25:10 <veltas      > Or what the point of the language is or anything
2023-04-26 10:25:32 <veltas      > The actual standards committee editor doesn't even like C and wants it to fail, he has said so in his blogs
2023-04-26 10:25:34 <vms14       > I think I would have more fun with assembly than C
2023-04-26 10:25:43 <KipIngram   > That's the way I feel about StackExchange.
2023-04-26 10:25:48 <vms14       > but I mainly want to have stuff like sockets, db, etc
2023-04-26 10:25:53 <vms14       > so C it is
2023-04-26 10:25:57 <KipIngram   > People mostly seem to want to show how superior they are to everyone else.
2023-04-26 10:26:09 <KipIngram   > It's like Sunday School.
2023-04-26 10:26:14 <vms14       > I asked once in stackoverflow, I won't do it again
2023-04-26 10:26:17 <KipIngram   > Lot of posturing.
2023-04-26 10:26:20 <veltas      > Unfortunately there's no way to tell difference between people with good or bad advice
2023-04-26 10:26:40 <veltas      > Like I can say I will give good advice, sound arrogant, but really you can't know without also having that experience if I'm full of it
2023-04-26 10:26:55 <vms14       > a guy started editing my question, and I refused to accept the changes, then he started editing it again every time I refused it
2023-04-26 10:27:12 <vms14       > I sent a mail to that guy telling him to stop and that I don't need CSS on my question
2023-04-26 10:27:17 <KipIngram   > Sure; I get that.  But it's just rude to start out demeaning someone. (Not saying you do that - but a lot of folks do).
2023-04-26 10:27:30 <vms14       > he put my mail on a stackoverflow thread and they blocked my question
2023-04-26 10:27:31 <vms14       > XD
2023-04-26 10:27:49 <veltas      > Nice
2023-04-26 10:27:58 <veltas      > Yeah wikipedia is like that too
2023-04-26 10:28:14 <KipIngram   > I should try to be fair, though - maybe the experience a lot of sensible people have had there is that the place will get overrun by idiots if they're not careful.
2023-04-26 10:28:32 <KipIngram   > Maybe it's difficult to find balance.
2023-04-26 10:28:56 <veltas      > Any community with a low bar gets overrun with bad quality eventually
2023-04-26 10:29:55 <KipIngram   > Yeah.  I help moderate a reddit community on a fiction series.  Lots of posts get made that are basically "Memes," which we have a category for, or fan casting suggestions (which we have a category for).  And there are definitely "serious" people who just lose their shit over that - they don't want to see it.
2023-04-26 10:30:00 <veltas      > Also I feel communities tend to get saturated with increasingly toxic people over time
2023-04-26 10:30:06 <KipIngram   > It's like they want it to be a serious place for serious discussions only.
2023-04-26 10:30:25 <KipIngram   > So we wound up making those categories precisely so people who don't want to see that content can filter it out.
2023-04-26 10:32:17 <veltas      > And I don't give advice on Forth because I am not experienced enough. I'll give my two cents but never say "DON'T do this", "DON'T do that" etc because I know I don't know
2023-04-26 10:32:30 <veltas      > I'll chime in when I do actually understand things, in the limited areas I do
2023-04-26 10:35:26 <KipIngram   > Yeah, I think "don't" doesn't really have a place in Forth.
2023-04-26 10:35:45 <KipIngram   > It's kind of a freedom oriented language, right down to its origins.
2023-04-26 10:36:20 <KipIngram   > Of course, various things come with hazards.
2023-04-26 10:37:49 <thrig       > dukes of hazards
2023-04-26 10:37:54 <KipIngram   > thrig's remark about power tools above definitely applies.
2023-04-26 10:38:43 <KipIngram   > I used to chat with a guy who disliked it for that reason alone - he felt a language should offer more protection to its user.
2023-04-26 10:39:19 <thrig       > some don't like 10,000 compiler warnings and will uninstall haskell or whatever
2023-04-26 10:40:02 <KipIngram   > I guess it's a "wrong" vs. "unwise" kind of thing.
2023-04-26 10:40:37 <vms14       > if lispers and perl devs are necromancers
2023-04-26 10:40:42 <vms14       > what forthwrights are?
2023-04-26 10:41:04 <KipIngram   > How are those people necromancers?
2023-04-26 10:41:11 <vms14       > using dead languages
2023-04-26 10:41:19 <vms14       > but forth isn't even considered dead
2023-04-26 10:41:23 <vms14       > it's just unknown
2023-04-26 10:41:34 <KipIngram   > Oh.  Well, heck, you might say that about Forth too.  It's  not "dead," but it's a pretty small niche.
2023-04-26 10:41:59 <vms14       > if I say forth to an average programming he will say "you mean fortran?"
2023-04-26 10:42:05 <KipIngram   > I think that's because of its grassroots origins.
2023-04-26 10:42:06 <vms14       > programmer*
2023-04-26 10:42:19 <KipIngram   > It didn't come out of some high and mighty group like Bell Labs, or some big university.
2023-04-26 10:42:20 <Zarutian_iPad> depends
2023-04-26 10:43:19 <Zarutian_iPad> if the guy came into programming from electronics pre pic and pre avr then the answer would be: chuck moores thing?
2023-04-26 10:43:19 <KipIngram   > I suspect most people who encounter it are immediately frightened off by it being RPN.  They probably never even learn about it beyond that.
2023-04-26 10:43:56 <KipIngram   > If they do keep learning about it, then they encounter "no types," "no well-established package library," and that kind of thing.
2023-04-26 10:43:57 <vms14       > for me rpn is nice, I always do everything in a reverse way
2023-04-26 10:44:04 <vms14       > so at least forth does understand me
2023-04-26 10:44:19 <KipIngram   > I used an HP calculator in college, so RPN was the thing that sucked me IN instead of driving me away.
2023-04-26 10:44:19 <veltas      > vms14: There are lots of older programmers aware of Forth and respect it as a sort of "this language will show you how the computer really works" magical thing
2023-04-26 10:44:23 <thrig       > C was a somewhat unapproved project at bell, and unix was sold as "not a new OS"
2023-04-26 10:44:26 <KipIngram   > Then later I began to see the other beauties of it.
2023-04-26 10:44:46 <KipIngram   > Didn't it have something to do with supporting a text processing operation?
2023-04-26 10:45:01 <KipIngram   > Patent library, or something like that?
2023-04-26 10:45:07 <vms14       > I just love colon words
2023-04-26 10:45:12 <KipIngram   > Unix I mean.
2023-04-26 10:45:37 <veltas      > C is just B with types because B doesn't fit nicely on a byte addressed system
2023-04-26 10:45:45 <KipIngram   > It was something along those lines they called out as the "payoff" for buying the machines they wound up doing Linux on.
2023-04-26 10:45:48 <KipIngram   > Unix.
2023-04-26 10:46:08 <KipIngram   > They promised to deliver something specific.
2023-04-26 10:46:15 <thrig       > probably it was in https://www.youtube.com/watch?v=EY6q5dv_B-o
2023-04-26 10:46:52 <vms14       > in my case people told me forth was what I was looking for xd
2023-04-26 10:46:55 <KipIngram   > And just didn't mention that they were using an experimental OS.
2023-04-26 10:47:06 <vms14       > I just didn't listen it too much
2023-04-26 10:47:09 <KipIngram   > Good for them.   :-)
2023-04-26 10:47:32 <veltas      > BCPL was a barebones CPL, which was better than CPL for most things (and actually existed unlike CPL)
2023-04-26 10:47:39 <veltas      > UNIX was a barebones MULTICS
2023-04-26 10:47:58 <KipIngram   > Yeah, MULTICS had left a bad taste in some managerial mouths, I believe.
2023-04-26 10:48:28 <veltas      > MULTICS was actually a failure but the design work helped develop UNIX
2023-04-26 10:48:34 <KipIngram   > Right.
2023-04-26 10:48:41 <KipIngram   > Failure as a project.
2023-04-26 10:49:29 <KipIngram   > I know Unix is still around, but for me the big payoff of the whole history is Linux - we actually have a sound operating system that's not owned by some corporation.
2023-04-26 10:49:38 <KipIngram   > And that is a good thing.
2023-04-26 10:49:56 <KipIngram   > It may have soft spots, but it's still nice to have it around.
2023-04-26 10:51:45 <vms14       > 
ACTION uses NetBSD instead

2023-04-26 10:51:49 <KipIngram   > I really feel that way about Forth too.  Sure, it's not a "does everything for everybody" language, but it still offers probably the simplest way to get something fairly powerful onto a new machine.
2023-04-26 10:52:01 <KipIngram   > Something a single person can build in a reasonable amount of time.
2023-04-26 10:52:32 <KipIngram   > And something that is EXTREMELY resource frugal.
2023-04-26 10:53:23 <KipIngram   > I saw a comparison between Unix and Plan9 a while back.  It looked like it had some fairly nice new wrinkles too.
2023-04-26 10:54:01 <KipIngram   > I got the impression that its big emphasis was distributed computing.
2023-04-26 10:54:19 <KipIngram   > Which is certainly a worthwhile thing to focus on.
2023-04-26 10:55:48 <KipIngram   > Nice idea for an internet culture.  ipfs is similarly interesting.  Someone here mentioned blending ipfs and Forth blocks a few months ago, and that seemed like an interesting idea.
2023-04-26 10:56:13 <KipIngram   > Very straightforward way to share info among different Forth systems.
2023-04-26 11:05:01 <KipIngram   > Anyway, re: the systemd stuff, I just want to set up a "final entry" in the chain of things done that runs a script I've tucked away somewhere.  Initially I'll just have that script append a timestamp to a file or something, so that I can confirm it's been run.  Then I have a couple of pci related commands I want to tuck in there.
2023-04-26 11:05:10 <KipIngram   > Currently I'm running them manually each time I boot the system.
2023-04-26 11:58:00 <veltas      > NetBSD is pretty hardcore IMO, maybe it's easier going now
2023-04-26 11:58:12 <veltas      > OpenBSD is probably just as hardcore if not more so
2023-04-26 12:30:18 <veltas      > What is lxf? I keep seeing it referenced
2023-04-26 12:30:28 <veltas      > It's some forth implementation with good assembly output for locals
2023-04-26 12:30:39 <veltas      > I can't find it with google
2023-04-26 12:37:01 <crc         > veltas: forth.works/temp/lxf-ntf.zip ad forth.works/temp/lxf-ntf2017.zip
2023-04-26 12:37:17 <veltas      > Thanks, but what even is it? Who wrote it?
2023-04-26 12:38:37 <crc         > NTF/LXF is a Forth system developed by Peter Fälth; it's an ANS model (mostly?) for Windows & Linux
2023-04-26 12:39:00 <veltas      > Is there a website for it?
2023-04-26 12:39:13 <veltas      > Is it just distributed on mailing lists or something?
2023-04-26 12:40:16 <crc         > no websites I can recall; I think I found it in a directory off one of the gforth sites
2023-04-26 12:41:05 <veltas      > That is so old-school
2023-04-26 12:41:23 <veltas      > Will have to try it out some time
2023-04-26 12:41:28 <veltas      > Thanks again
2023-04-26 12:42:08 <veltas      > It's just quite annoying that I watch a video about different forths, and the one with the best output I can't even find online anywhere, even though it seems to be shareware at the very least
2023-04-26 12:42:29 <veltas      > Forth is all magic scrolls tucked away in shady libraries
2023-04-26 12:45:38 <veltas      > And I am so tired of explaining the gforth release situation to people as well
2023-04-26 12:45:57 <veltas      > Why am I attracted to such an esoteric ecosystem?
2023-04-26 13:02:56 <crc         > looks like my copies of lxf came from https://www.complang.tuwien.ac.at/forth/
2023-04-26 13:04:16 <veltas      > No license for it
2023-04-26 13:08:29 <crc         > nope :(
2023-04-26 13:09:07 <veltas      > It's quite possible nobody's actually asked him for a license but I don't know if the source code is even available
2023-04-26 13:09:14 <veltas      > so might be he doesn't want to be open source
2023-04-26 13:13:24 <crc         > I've not looked into it much. There is some source in the blocks, but I dont'
2023-04-26 13:13:51 <veltas      > Creative strings grepping hasn't illuminated
2023-04-26 13:13:52 <crc         > don't remember seeing anything like a metacompiler in them when I had last looked
2023-04-26 13:14:08 <veltas      > The blocks file is small, it's not got most of the code in it
2023-04-26 13:43:48 <MrMobius    > veltas: any interesting examples from GCC and clang output?
2023-04-26 13:44:10 <MrMobius    > at least for X86, you get some non intuitive output sometimes that actually is faster
2023-04-26 13:47:19 <veltas      > What I'm finding for one thing is that -Os gives the most intuitive result, but whether it's faster is quite random
2023-04-26 13:49:43 <veltas      > This is the most recent thing I've looked at which has some minor differences between clang and gcc https://godbolt.org/z/zoG6v749o
2023-04-26 13:51:01 <veltas      > Actually change the top shift to 8, and GCC does a really bad job
2023-04-26 13:51:17 <veltas      > Because I think it gets confused by a being 'int'. If you make it unsigned it fixes its code
2023-04-26 13:51:55 <veltas      > Even though semantically there's no difference, obviously this doesn't fit well with GCC's IR
2023-04-26 13:53:29 <veltas      > This is related to the code for ilo's inner loop which needs to decode the four bytes in each instruction word as opcodes
2023-04-26 14:04:42 <veltas      > Monthly reminder that GCC still freaks out when you use an array unless it's static const https://godbolt.org/z/6fz3K16dj
2023-04-26 14:05:01 <veltas      > This code works just as well either way on clang, so congrats to clang
2023-04-26 15:10:28 <KipIngram   > Arrays not working in C?  That's pretty bad.  Such a fundamental thing.
2023-04-26 16:44:02 <veltas      > KipIngram: They work, the issue seems to be GCC fails to recognise a 'constant' array is constant without saying so, in the way that a 'constant' unchanging variable shouldn't need 'const' to be optimised as such
2023-04-26 16:44:53 <veltas      > And I appreciate why that is but it's 2023 and clang handles it, and it's a pretty common thing now to use arrays like that and everyone expects the compiler to "just work" so I think they should try and recognise that
2023-04-26 16:45:24 <veltas      > I don't really mind, I know how to work around it
2023-04-26 16:46:20 <veltas      > But it's a point that compilers aren't *quite* as smart as people say they are. The user still needs to look at assembly occasionally and understand what the output's doing if performance is critical in a function
2023-04-26 16:46:31 <veltas      > THe rest of the time bad assembly output is more useful than having to write the assembly myself
2023-04-26 20:22:13 <MrMobius    > veltas: not sure what you mean re Os. Isn't the point to sacrifice speed for space? Or do you mean it produces larger than necessary code
2023-04-26 20:23:24 <thrig       > Big O: the shape your mouth makes when you figure out what your code did to the $250,000 CnC mill
2023-04-26 20:26:35 <MrMobius    > also, it doesn't bother me that the compiler didn't guess that an array was static without the keyword. there's all kinds of stuff compilers don't guess bc it's not that useful. I can't imagine ever leaving off the static const for something like that but maybe it's bc I mostly use microcontrollers
2023-04-26 20:27:41 <MrMobius    > I thought about rewriting one of my emulators in C to see if the compiler would figure out it can assign registers to the emulated registers but never tried since that would be a very odd thing for the compiler to figure out itself
2023-04-26 20:28:08 <MrMobius    > since it's a very niche use case
2023-04-26 20:29:11 <thrig       > some folks have fiddled with register priority to cut down on various attacks