IRC channel logs


back to list of logs

<dsmith>mark_weaver, Yeah, should work. For now, there are only 4 kinds of .go files.
<ArneBab_>comparison: a hello wornd server in guile scheme - and in wisp, processed to guile scheme: scheme: — wisp:
<ArneBab_>I rewrote the hello world server and wanted to share it :)
<ArneBab_>it shows nicely that wisp and lisp are equivalent, but that wisp looks much less intimidating to newcomers.
<DerGuteMoritz>what's wisp? is it one of the indentation based srfis?
<DerGuteMoritz>OTOH it's been 2 or 3 months since the last project of this kind has been announced so it is probably time for another one :-)
<ArneBab_>DerGuteMoritz: jepp:
<ArneBab_>DerGuteMoritz: the other project is readable. We collaborated on both, but there are differences in philosophy: wisp tries to stay really simple while readable tries to make the code more readable at the expense of having more complex rules
<ArneBab_>DerGuteMoritz: essentially I decided to write my own intentation-based lisp when readable introduced $, \\\\ and <* *> as syntax.
<ArneBab_>DerGuteMoritz: (but the current version of the parser itself is from March 2013)
<DerGuteMoritz>ArneBab_: what I mean is that there are dozens of these and every few months a new one pops up
<DerGuteMoritz>I think it is a bit pointless and in fact have never seen anyone actually use one of those
<DerGuteMoritz>but YMMV
<ArneBab_>For me it’s something I would like to have, and having it as preprocessor ensures that my code won’t be bound to that syntax: I can always convert it to lisp and keep working there :)
<ArneBab_>But I think to take off, it would require lots of infrastructure: editing-modes with syntax highlighting and completion, a real wisp console (readable has that, using guile as backend), etc.
<ArneBab_>I don’t know whether I’ll be able to provide those (maybe if I should be stuck alone on an island with only IRC and some scheme books to accomodate me)
<nalaginrut>oh~my, another sweet-expression
<ArneBab_>but it’s fun and I like the result :)
<nalaginrut>anyway, it could be added into Guile as a front-end
<ArneBab_>nalaginrut: though I won’t ask for that, yet.
<ArneBab_>nalaginrut: before I do, I want to rewrite the parser in wisp itself.
<nalaginrut>yeah, that's the reason why Lisp became Lisps
<ArneBab_>how that? (pointer to history?)
<nalaginrut>all, just joke
<taylanub>Sweet-expressions had my attention until 1) I discovered paredit, 2) they introduced all that silly $ and <* *> stuff.
<taylanub>Since I've gotten comfortable with paredit (just requires a couple hours if not minutes, IMO), I've lost all motivation in any alternative s-expression representation, and think plain sexps are actually *superior* to any other syntax.
<YoungFrog>huh, fsbot is gone ?
<YoungFrog>oh, we're not in #emacs.
<DerGuteMoritz>taylanub: word
<ArneBab_>taylanub: the main thing disturbing me with sexps is that they look alien when I’ve not worked with lisp for some time.
<taylanub>One exception might be languages where you need lots and lots of details in code for type-annotations, fine-grained memory control, etc. .. I might attempt at some point to make a clean sexp syntax for Rust to see how far one can go.
<taylanub>ArneBab_: Hrm, how much/often have you been writing Lisp so far ?..
<ArneBab_>taylanub: paredit felt very strange to me. Good to hear that if I should once have the chance to do bigger work than a few hundred lines of code, paredit will reduce the pain.
<ArneBab_>taylanub: I mostly use it to hack my emacs: every few weeks a few hours.
<taylanub>That's not enough! :P
<ArneBab_>it keeps me fresh enough that I understand why it looks so alien to newcomers :)
<ArneBab_>(fresh as in unexperienced)
<taylanub>I think after reaching a certain level of comfort with s-expressions, your issues will fade away .. maybe try to get into paredit properly. The advantages one gets in the end vastly pay off for the learning curve IMO.
<ArneBab_>my problem with that is, that I want to use a language which is accessible to non-developers.
<ArneBab_>Even as it is now, I have a hard time showing others my code.
<ArneBab_>(as in “they do not understand it”)
<ArneBab_>and that’s with python
<ArneBab_>my goal with wisp was to retain all properties of sexps, but make it possible to just print the code and show it so a non-dev.
<ArneBab_>we have many scientists around who only use code as an unloved tool
<ArneBab_>(around me there are…)
<ArneBab_>for them, python is acceptable. Lisp looks too strange, though. I hope wisp could change that: Get rid of the gut reaction “I can never understand that”
<YoungFrog>ArneBab_: wouldn't it help to give a more lightly coloured face to parentheses ?
<ArneBab_>it helps a bit, but only a bit.
<taylanub>I think a 2-minute explanation could actually be enough to explain how sexps represent code.
<ArneBab_>I think not, because that would not have been enough for me 5 years ago.
<ArneBab_>I first had to develop a new way of seeing code - essentially of ignoring paretheses most of the time.
<YoungFrog>ArneBab_: I'm under the impression that C-u C-M-q (pretty print sexp) + lighter colour = half work done.
<ArneBab_>M-x rainbow-delimiters-mode
<ArneBab_>that should help newbies a lot.
<ArneBab_>But for example for python they do not need that: They can write it without tool support. (but note my quote on the wisp-page: lisp has a power and simplicity I miss in python)
<ArneBab_>so I don’t just want half the work done…
<ArneBab_>I’d like to have a language which is easily readable for newcomers and has all the power of lisp underneath.
<ArneBab_>besides: If anyone ever tells you that python does not have a compilation phase and a runtime phase: that’s not quite correct if you use decorators defined in an external module…
<ArneBab_>it’s just not explicit
*ArneBab_ believed that python had no phase separation up until this monday
<ArneBab_>taylanub, YoungFrog, DerGuteMoritz: Do you know a short, self-contained piece of code, which you perceive as being really well-written scheme? (about 1 to 2 pages of code ~ 100 lines)
<ArneBab_>preferably one which works with guile :)
<taylanub> Full of personal coding-practice preferences and probably lack-of-experience too but I really strained myself to make it as clean as possible.
<ArneBab_>I went through the Adventures of a Pythonista in Schemeland¹, but I still miss having a feeling for really well-written scheme. ¹:
<taylanub>Maybe look into Guile's source, for some Real World Quality Code™. :P
<ArneBab_>my problem there is that I fear that I can’t really judge the quality of scheme code: I can’t get my python-lenses off :)
<ArneBab_>(even worse: I don’t know when I have them on)
<ArneBab_>taylanub: do you mean the readme or the actual implementation?
<taylanub>Both ...
<YoungFrog>ArneBab_: I won't answer because I'm not a scheme user. All I know about lisp is in fact emacs lisp. You could ask why I'm here, then... well, probably because of someone advocating guilemacs in #emacs :)
<taylanub>Dehehe. /me looks away guiltily.
<taylanub>I am in fact using Guile Emacs right now. It runs anything normal Emacs runs, so I'm using my usual Emacs configuration, including Circe for IRC.
<taylanub>(eval-scheme "(begin (use-modules (ice-9 control)) (let/ec return (return \\"Hello!\\")))") => Hello!
<taylanub>I really inserted that Hello! by hitting C-u C-x C-e !!
<YoungFrog>does your C-u C-x C-e inserts " => " also ? I usually do that manually
<taylanub>Nope, that was manual.
<taylanub>(eval-scheme "(let/ec return (return \\" => Hello!\\"))") => Hello! :P
<taylanub>(The `use-module' call's effect persisted, it affected the embedded libguile instance running inside Emacs.)
<YoungFrog>taylanub: never insert that => manually again, please ;)
<taylanub>Neato .. though I think I'd just advise my `eval-last-sexp'.
<ArneBab_>taylanub: what’s the current performance of guile emacs?
<ArneBab_>taylanub: then I’ll try to dig a bit into procedural.scm (since the examples seem to require it). It’s 500 lines, though…
<taylanub>ArneBab_: I'm using it over remote X11 so far so the display is the biggest bottleneck, and I can't sense any performance difference yet.
<taylanub>ArneBab_: procedural.scm only has about 200 lines of "framework" code, and the rest just creates the built-in types via the same facilities user-provided code could; I should actually separate those into different files.
<ArneBab_>ah, ok - then I should be able to read it nicely. Thanks!
<ArneBab_>taylanub: Guile Emacs then allows you to run elisp and scheme - but with all optimizations of guile?
*ArneBab_ did not know that guile emacs is actually a reality nowadays
<ArneBab_>ah, that’s a current GSoC project which intends to *finish* the work:
<ArneBab_>and emacs xwidgets!
<ArneBab_>(I’m eagerly awaiting that)
*nalaginrut wrote main-site of Artanis with hyde of Chicken on github, nice try
<ArneBab_>nice site!
<ArneBab_>nalaginrut: where did you get that font? (is it free?)
<brendyn>nalaginrut: would you recommend using artanis for a blog, or hyde :P?
<DerGuteMoritz>brendyn: depends on whether you want a dynamic site or not
<DerGuteMoritz>you could also use both
<brendyn>i guess comment sections could be useful. dunno though
<DerGuteMoritz>I think PLT_Hulk's advice with regards to hackernews comments applies here, too
<DerGuteMoritz>so I prefer no dynamic comment section but just a good old "email the author" link
<taylanub>Did I ping timeout ? I think Guile Emacs just died somehow. :\\ Might've been the X11 connection though.
<ArneBab_>taylanub ( hat das Netzwerk verlassen (Remote host closed the connection)
<taylanub>Maybe I accidentally hit C-x C-c. :P
<taylanub>ArneBab_: I think it doesn't compile Elisp yet, but uses libguile's data-types, control-flow mechanisms, etc. in the old Elisp interpreter, so it's easy to define an `eval-scheme' subr for example, which evaluates Guile Scheme, and gets a return-value that can just be used from Elisp as-is.
<taylanub>(+ 3 (eval-scheme "2")) => 5
<taylanub>Let's see what it does for fancy Scheme types like records .. (eval-scheme "(make-test-rt 42 \\"test\\")") => #<:test-rt foo: 42 bar: "test">
<taylanub>Now let's try putting it into a variable ...
<taylanub>OK, I have an SRFI-9 record in an Elisp variable now .. but I wonder what I can do with it other than print. :P
<DerGuteMoritz>cook it in a pot!
<taylanub>I think it should be trivial to allow Scheme procedures to reside in the function-slot of Elisp symbols; then the module system could somehow be used to automatically put many Scheme procedures into many Elisp symbols, and one could easily use Guile modules from Elisp.
<taylanub>If my brain isn't fried by the evening, I might try to make a patch for that, at least the scm-procedures-in-elisp-symbol-function-slots part, I imagine it *should* be easy ...
<davexunit>Someone posted about emacsy on r/scheme:
<davexunit>the comments thus far are just guile 1.8 vs 2.0 things, though.
<taylanub>Typical. :\\
<davexunit>I think the user aim2free is the same person that posted to the mailing list awhile ago
<davexunit>about guile 2.0 being slower than 1.8
<taylanub>Wasn't that for a specific functionality only ? Generalizing it is surely wrong ?
<taylanub>I was about to say "seems like a credible person and not a troll or so" up until: "Now I'm developing the next generation customer driven innovation portal [...]" aww come on. :P
<davexunit>yeah, he did like 3 "benchmarks"
<davexunit>I don't want to discount his claims, because I don't have the backgrounnd, but I told him to talk to the guile maintainers about it to get some real answers.
<davexunit>since he doesn't understand the VM that came with guile 2.0
<wingo>woohoo, i have some scheme finally compiling to rtl
<davexunit>wingo: is that the next step after the new VM?
<wingo>the vm is written, this is the compiler
<davexunit>I should have typed: is that the next step now that there is a new VM? :)
<davexunit>very cool news, wingo.
<taylanub>davexunit: Answered em as well, in case you're interested.
<davexunit>taylanub: will read.
<davexunit>taylanub: when using the REPL, the interpreter is used, right?
<taylanub>davexunit: I think it compiles .. especially if you just (define (foo) ...), I'm pretty sure you get a compiled procedure ?
<davexunit>ah, okay. so I guess when does the interpreter actually get used?
<taylanub>"Never." :P
<davexunit>s/so I guess/so/
<davexunit>so how the hell is this guy using it? via eval or something?
<taylanub>You can invoke it manually, somehow ... it could also be that I'm totally wrong and it's used in a couple big places, but I doubt that.
<davexunit>I'm becoming more convinced that this guy doesn't really know what he's talking about.
<taylanub>That's my impression as well, but let's wait for that report I guess.
<davexunit>general question: my knowledge of interpreters/compilers is weak. can anyone recommend a good book or something to help me learn?
<davexunit>I really like Guile, but I feel like I don't have the background to make a meaningful contribution.
<wingo>davexunit: abdul aziz ghuloum (sp?)'s paper, "incremental compiler construction"
<davexunit>wingo: thank you, wingo.
<davexunit>I gather that making a toy lisp interpreter would be worthwhile.
<davexunit>taylanub: btw, you can format reddit comments using markdown
<wingo>hoo, this is great
<davexunit>the new VM and compiler are for Guile 2.2, yes?
<davexunit>you've done some exciting work for us Guile users.
<wingo>we'll see, still quite a bit more to do...
<taylanub>The new VM mainly gives us a speed boost, is that right ?
<wingo>yep, should improve startup time and memory usage as well
<wingo>native compilation will be not difficult after this
<taylanub>Neat! :)
<davexunit>native compilation is *very* exciting
<taylanub>How can I make a Scheme list from a C array of Scheme objects ?
<taylanub>Ah, scm_call_n is what I really was looking for.
<taylanub>(setf (symbol-function 'test) (eval-scheme "+")) (test 1 2) => 3
<taylanub>Couple lines of code .. is probably unstable though.
<hellekin>hi there. I'd love to see a "Learn Guile The Hard Way"
<davexunit>I don't know what people think of Zed Shaw here.
<davexunit>I think you should read SICP and the Guile manual. :)
<youlysses>davexunit: Or simply scheme -> sicp -> guile manual.
<davexunit>but in general I agree that something targeted directly at Guile would be cool.
<youlysses>That being said, I do see value in having a general introductory text, aimed at guile, and for individuals with no intent of becoming master hackers. :^P
<youlysses>Name it something so horribly punny, like 10 readers will get it -- like "Guile Learn GNU Good!"...
<youlysses>As-in "I'll learn you good", something traditionally heard in the midwest to south of the US -- before getting some-sort of punishment. :^U
*youlysses suspects that he's to good at naming things so-punny that they hurt....
<taylanub>That went a megameter over my head.
<youlysses>taylanub: The "pun", or?
<hellekin>that would be a nice project to throw in for the GNU Development Network :]
<youlysses>taylanub: It's a saying around here in the midwest to southern areas I've frequented (US). Much-more often than not it's so archaic that it's said in-jest, but it's more-or-less a saying that's in-reference to someone doing something stupid or wrong. Like leaving something out to spoil, and one's mother saying "I'll learn you good, boy!". :^P
<youlysses>hellekin: Sounds like a fun text to write, to throw someone into the very basics of programming in-general.
<taylanub>Hrm, why does my REPL server spam me with "fport_fill_input: Interrupted system call" :(
<taylanub>I think that's been fixed upstream though.
<hellekin>youlysses: indeed. I wish I would have that time (and the skills to write the Guile one)
<hellekin>maybe crowdfunding it would work...
<hellekin>I'm sure the FSF could throw in complementary money. Should be proposed... Gotta run. Will read backlog addressed to me ;o)
<youlysses>hellekin: It's probably something I could throw together in a years-time, though it'd probably be ideal to have some-sort of application that one could easily script in-order to help nail down a lot of these points.
<davexunit>youlysses: sort of like "Learn you a Haskell for great good"?
<davexunit>I've been meaning to at least blog about Guile. some small tutorials. it's no book, but it could be useful.
<youlysses>davexunit: Pretty-much.
<youlysses>I could even do stupid little doodles too. :^)
<davexunit>Be Guiled or Die Trying
<youlysses>davexunit: Or just, "Guile hard, Or Die Trying". :^)
<davexunit>if only we could incorporate Guile from street fighter:
<youlysses>davexunit: We could make the meme reference that like "guile's theme goes with anything" so-too does guile itself.
<davexunit>heh yeah
<youlysses>AFK, for the next 2-3 hours. o/
***fds_ is now known as fds