IRC channel logs

<old>asking something completely irrelevant to Guile, feel free to not answer

<old>Is there a standard for something like XML schema but in S-exp?

<old>Something that can easily be emit and parse in a few line of C

<old>I think what I'm looking for is a Document type definition but in S-exp

<mfiano>I see too many implementations of a non-standard in this space. Wish there was. Also interested in an answer, though not hopeful.

<mfiano>Also hi again everyone!

<old>mfiano: long time no see!

<mfiano>Heya old! How's code and life and such?

<old>Great. not doing much Scheme/Lisp for the last weeks :-(. Doing a lot of C

<old>what about you?

<mfiano>Nice, I see! I'm doing better. I needed a long break from coding, but I'm back, and narrowly-focused on Guile again :)

<old>I see! Leaving common lisp for good? :-p

<old>Wish for a break too

<mfiano>Yeah that ship sailed a while ago. I prototyped a couple things in Julia, because I'm insane like that, but I now know better

<old>no vacation in my first year of work tho :-/

<old>oh neat. I heard great stuff about Julia

<old>never tried tho

<mfiano>flatwhatson has been helping me with the dreaded tooling and getting up and running again, and I'm not bugging him yet.

<mfiano>I think I'm pretty much set now though on that front. thanks bud :)

<mfiano>julia is different, but i wouldn't depend on it for long term code that runs in future

<mfiano>nice for quick experiments that need to be fast, or for plotting things (lots of nice ways to manipulate tables and such) for rendering data concisely.

<mfiano>or for a 'math repl' with its concise math-like syntax.

<mfiano>but i wouldn't depend on it for serious use unfortunately.

<mfiano>good for throwaway code mostly

<mfiano>Let there be a Scheme specification forever!

<old>So kind of like Python

<mfiano>Pretty much, minus the speed part.

<old>I always look new programming language -- although julia is like 13 years old -- with a skeptical eye

<old>someting that was not battle test in production and industry is worth not much IMO

<old>same for Rust. Might looks cool on paper, but only time will tell

<mfiano>Yes, same. They are all tools that are good at a small corner of general-purpose programming, but trade away a lot of Lisp's flexibility.

<old>except for like you said, experiment and throway code

<mfiano>I like some other languages, if they are better at a certain task.

<mfiano>But most of the time Lisp is perfect

<old>For me, C and Lisp are the best tools in my box

<mfiano>I won't argue with that choice!

<Arsen>half of that sucks ;)

<old>Yet, some peoples do have to write the C that support the whole world ;-)

<Arsen>makes me worried for the foundation

<old>we can not just Rustify everything

<old>I mean, the code is battle tested, at least at the kernel level

<mfiano>Little known fact: Most point-of-sale devices (registers, credit card readers, etc) run Java, or outdated UNIX-derivatives, like AIX.

<old>I won't say the same for userspace program

<mfiano>s/or/on/

<old>mfiano: I heard that once from a colleague in Germany

<old>Say somethin along the line: Java run your Visa card

<mfiano>I repaired them for some major retailers (in US) for a few years

<old>now I understand the proverb: Java run 3 billions of devices

<old>But I think that there's some form of embedded Java in the credit card itself

<mfiano>Yes. It's pretty much Java all the way down

<mfiano>Except beyond the VM :)

<old>just thinking about it makes me nauseous

<mfiano>Yeah.

<old>never liked it

<mfiano>There is one benefit

<mfiano>If you have to repair them, and wait for them to cons all the memory in the world to do their startup sequence, you get paid a lot :)

<old>Creating job for ever

<old>that sound great

<mfiano>does luid felipe come here?

<mfiano>luis*

<rlb>wingo: is the meaning of the vm-engine.c annotations described somewhere, i.e. dst:12 proc:12, etc.?

<rlb>Just wondering if "call-u32<-scm dst:12 a:12 IDX:32" would be right...

<rlb>...and maybe we'd need a new SP_REF_U32, SP_SET_U32, etc.?

<rlb>Assume the op will need to be 167.

<ArneBab>old: I will think Rust battle-tested once Rust code is legacy code, and people don’t curse worse about it than about Java today.

<mwette>julia uses multiple dispatch: all functions are generic and code is in methods; and much of the parser/compiler is written in scheme: https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm

<sneek>Welcome back mwette, you have 1 message!

<sneek>mwette, rlb says: currently not in the public C apo, or on the scheme side (regarding some ascii? predicate), but on the C side you can find out pretty cheaply by comparing the char len to the byte len of the relevant region, since getting the offsets is fairly fast via the sparse index.

<mwette>rlb: thanks

<mwette>rlb: wrt assembler syntax, have you looked at https://www.gnu.org/software/guile/manual/html_node/Bytecode.html

<old>ArneBab: maybe in 30 years

<rlb>mwette: thanks - I realized this was telling me what I wanted to know, I just wasn't listening :) https://www.gnu.org/software/guile/manual/html_node/Bytecode.html

<mfiano>mwette: The entire parser is written in scheme, but was rewritten in Julia recently.

<mfiano>And not all operators are generic, but close to all

IRC channel logs

2023-06-28.log