#guile
I have a software tool that I use at $dayjob quite a bit. I'm impressed in general with its capabilities, but I don't like that it has it's own bespoke programming language and read-eval-print-loop. I would much rather it provide its features in the form of an embedded domain-specific language inside #guile e.g. so that I don't have to recall its syntax quirks or jump through strange hoops to do what is natural in a Real Programming Language™.
Currently contemplating whether to jump down that rabbit hole...
anyone having trouble with guile packages like artanis not being available for import?
both guile and artanis have been installed via guix and i have the "art" command readily available in my terminal, but the moment i drop into a guile repl i don't get to "use-module" the library. (just an error that there is no module)
Let’s get back into it! Learning all that #Guile tech and grinding matchups🫡
@ramin_hal9001 @louis @screwtape
fwiw I'm looking at the #guix #ECL installation rn, and running
$ guix shell ecl
[env]$ cd $GUIX_ENVIRONMENT/bin
[env]$ du -h ecl
4.0K ecl
thats extremely impressive. I don't know if thats because the ecl binary primarily calls libraries (perhaps for fine grain modularity), or if its actually that small.
fwiw, with all it's deps included:
[env]$ cd $GUIX_ENVIRONMENT
[env]$ du . -h
20K ./lib/pkgconfig
180K ./lib
48K ./include
24K ./share/info
24K ./share/doc
20K ./share/man/man3
24K ./share/man
76K ./share
8.0K ./etc
-------------------------
320K .
in comparison:
$ guix shell chez-scheme
[env]$ cd $GUIX_ENVIRONMENT/bin
[env]$ du -h scheme
308K #scheme
[env]$ cd $GUIX_ENVIRONMENT
[env]$ du . -h
312K ./bin
8.0K ./etc
776K ./lib/csv9.5.8/examples
3.3M ./lib/csv9.5.8/ta6le
4.0M ./lib/csv9.5.8
4.0M ./lib
12K ./share/doc/chez-scheme-9.5.8
12K ./share/doc
12K ./share/man/man1
12K ./share/man
24K ./share
4.4M .
and the #guile binary is tiny, but its dynamically linked & the full install is ~55MiB on guix
When @spritelyinst closes in on their work on #Guile's wasm compiler (maybe later this year?!), it'll certainly become the easiest way to target optimized #wasm. Tree-IL has gotta be the simplest intermediate language to compile to, and you get all the optimizations Guile offers for free.
Considering Robin Templeton, the author of Guile's #elisp compiler, is one of the engineers behind it, I can't help but speculate that this will put #emacs in the browser within reach. If I can handle my org-agenda online by 2025, I will cry.
It's called #Scheme because it allows just a few friends to plot a CONSpiracy to build amazing things.
A new #Debian stable is out soon, and I should be upgrading. Since I'll be upgrading anyway, I'm also pondering - yet again - about switching to #NixOS.
While I'm not a fan of the nix language, and would much prefer #Guix's #Guile, I am dependent on systemd, and am not going to part with that.
Maybe I'll have another go at trying to figure out how to make nixos do the things I want to do.
Tonight a few friends sent me a message that #rde is on a front page of Hacker News. Is it something good?
Guile is coming closer to web assembly. Impressive results.
https://spritely.institute/news/scheme-to-wasm-lambdas-recursion.html
How does guile-fibers make it possible to send non-string data via its channels, like in the slightly adapted example code of https://notabug.org/ZelphirKaltstahl/guile-examples/src/76b36632323ef6f66548c7e8659f530685cd18bb/fibers/send-non-string-data.scm ? Is dark magic at work, transferring pointers to memory regions? Does fibers somehow automatically find a suitable serialization format and serializes data and deserializes it later?
Yes, I have completed a (smaller) project without going to the internet. → https://medium.com/p/dfe9e44ee555
(followed by: I call BS on your call of BS ☺ — but only for those tools that actually *ship* good documentation, and those are rare.)
Preparing the last stream in the series related to scheme static sites generators:
@zwol @civodul ... well NixOS set out explicitly to do something New And Different, ... Guix merely approached it better #Guile
Arrgh, I hope people arent feeling bad. OS developers and packagers have to do lots of patient and arduous work and yet its the bits above these layers which get all the shiny toys and then get to complain.
Its all ants and grasshoppers, really. If people arent happy with how their operating system is working they should shop around or step up and fill leadership gaps
rde Meetup #3 is [re]scheduled for May 27.
We plan to explore guile and rde future work plans, meow and modal editing, project documentation.
https://lists.sr.ht/~abcdw/rde-announce/%3C871qjmjaow.fsf%40trop.in%3E
Join IRC/matrix for more interesting talks:
https://trop.in/rde/manual#Chat
I'm just now catching Andrew Whatson's talk on #PreScheme from #fosdem this year, and I just can't get over the fact that he was able to implement a working, reasonably fast systems programming language with Hindley-Milner type inference in his free time over the course of a few months. And I was in the #GuileSteel irc when the discourse first started, it was probably less than a month before he got it working. I even try it then and it seemed great for something that went up that quick. What other programming languages make rapid prototyping #compilers feasible without relying on massive frameworks like #LLVM or #Truffle/#Graal?
And even then...
There’s a paid internship offer with the Greens in Brussels that needs #Guix and #Guile skills: https://www.greens-efa.eu/en/get-involved/work-with-us — I thought you may be interested. Deadline for application: 31 May, 23:59 CET — info about needed skills is from an email of a green elected: Internal toolchain development, debugging or maintenance, using Guile Scheme, Guix, PHP (Drupal / CiviCRM), bash, postgres, sqlite and similar technologies #job
Today I'm spending some time writing up an outline for a new guide and video series about Guile Scheme!
The goal is to teach anyone (even programming beginners, if possible) how to use Scheme as a language for building personal tools (scripts, etc) and managing their system via Guix. Guix itself won't be covered in depth, but the features of the language used commonly in Guix will be!
What would you like to see covered in such a series?
Fun fact: #guilescript's .gs file extension stands for "Gerry Sussman"
Tomorrow I continue to explore Haunt (Static Site Generator by @dthompson written in Scheme), will migrate my current pages to it and make a foundation for the blog:
Dryads Sun came in at position 7 in the #game #jam for #blind gamers! https://itch.io/jam/games-for-blind-gamers-2/rate/2043845
All games in the jam: https://itch.io/jam/games-for-blind-gamers-2/results
#Guile #scheme #wisp #rpg #webdev #freesoftware #FOSS
If you want to write a game like Dryads Sun yourself, just clone https://hg.sr.ht/~arnebab/dryads-sun — the game is free licensed under AGPL and the tooling under LGPL (so unfree games are possible, though that’s not what I write).
I think the tags I put on this imgur business day should be seen. #guile $fgc #shermieneko #shermie #shermieorochi
Kotaku: Street Fighter 6 Comic Confirms Ken Is A Crypto Bro, Bad Father https://kotaku.com/street-fighter-6-ken-udon-comics-ps5-crypto-meme-xbox-1850409082 #gaming #tech #kotaku #videogamesdevelopedinjapan #videogamecharacters #johannpetrovich #streetfighter6 #streetfighterv #streetfighter #creativeworks #videogaming #finalfight #kenmasters #kendallroy #themasters #ansatsuken #spitfire #kenearly #capcom #eliza #guile #luke #ken #mel
🔴 Today on #SystemCrafters Live, we'll experiment with a Wayland compositor called `dwl-guile` which is meant to be used with GNU Guix and configured with Guile Scheme!
Do we now have a modern, REPL-hackable window management experience built on Wayland? Let's find out!
Join us on YouTube or Twitch:
- https://youtube.com/live/wHbH0VGJ6TQ
- https://twitch.tv/SystemCrafters
Stream time in your time zone: https://time.is/compare/1800_in_Athens
@w96k And if you add doctest-style (just write the test at the top of the function), then test-driven development becomes the natural thing to do.
For #Guile #Scheme: https://hg.sr.ht/~arnebab/wisp/browse/examples/doctests.scm
@nilmethod sbcl is generally faster than most schemes (but chez certainly gives it a run for its money), but #guile and #chez are incredibly fast in terms of start up and compile times. I read somewhere that chez bootstraps #idris in about 2 minutes, for example (I think #haskell took over 20 minutes when it was the implementation language).
"I tried #SBCL, and something I noticed was that for any simple function, #lisp takes a moment to compile, which isn't acceptable for a #shell"
- Ilya Sher, author of #NGS ("next generation shell") on #InferencePodcast
Is this really the case?? Doesn't sound right at all.
Do someone with Guile FFI experience want to help me to get started with guile-tree-sitter? (:
Just share some FFI best practices and/or highlight overall direction/approach will be enough.
@PaniczGodek oh really? to me they are like the bread and butter. when you build good records and structure your programs around them, your flexibility increases dramatically as you have these quasi-"intermediate representations" that are extensible and easy + performant to handle. many schemes use records as their fundamental underlying data representation, including #guile and I believe #chez as well. and I think #r6rs record protocols make them both extremely extensible and parametric, as well as #guix's define-record-type* lazy records which serve a similar purpose with a lot less cognitive overhead.
lots of cool record systems out there, I'm interested in understanding the tradeoffs of #gauche's approach in particular, which is to implement records within a #clos-like object system, which seems to allow you to work with generic methods on record-types (which is something that GOOPs is not very good at, for example). what approach did you go with for your record system?
I don’t think I had ever mixed #ATS and #Guile before in a way where the program actually starts in ATS. It took me a while to figure out that I had to put a call to scm_init_guile() in the garbage collection initialization function. Alternatives exist, but this seems the best of them, short of actually starting in straight C or Scheme.
@cwebber Congratulations on the progress with the guile port of terminal-phase! It's always exciting to see advancements in free software development. Keep up the great work! #freesoftware #guile #terminalphase
🚀 New chapter added to the Guile Hacker Handbook ! 🚀
This is a book to learn Guile in a #TestDrivenLearning style 👽
⬇️ Check it out ⬇️
🇫🇷 🇬🇧 jeko.frama.io
The Guile app tutorial is making a new step forward.
How do you feel about the « Fix it! » experiment ?
#gnu #guile #scheme #lisp #testDrivenDevelopment #tdd #fuctionalprogramming #learnToCode #CodeNewbie #100DaysOfCode
@rgb @t73fde There are at least two systems that use s-expression-based markup coupled with an s-expression-based programming language:
- Scribble: https://docs.racket-lang.org/scribble/
- Skribilo: https://www.nongnu.org/skribilo/
Skeemed throught Scheme Primer.
Good introductionary material by @cwebber: easy to read, practical, no bs, covers all necessary fundamentals, shows how to implement Scheme evaluator in Scheme.
Well this is good news
@wingo to lead Guile → WASM project!
I guess during last a few weeks my Lisp preference list changed from:
Clojure, Scheme, Common Lisp, Emacs Lisp.
to
Scheme, Clojure, Common Lisp, Emacs Lisp.
I still find Clojure much more pleasant and elegant out of the box, but Scheme seems more and more future-proof to me.
Is #guile cross platform? The docs only mention using it on Linux, and I only see official binaries for Linux...?
🔴 On today's #SystemCrafters stream we'll discuss how we might improve the experience of getting started with Guix Home!
I have a few ideas for improvements I'd like to investigate, but I'm more interested to hear your thoughts if you've tried Guix Home already!
Join us LIVE at 4PM UTC on YouTube or Twitch:
- https://youtu.be/zZCfDXlbkXo
- https://twitch.tv/SystemCrafters
Good idea, opens a lot of possibilities but will it be up-streamed to gnu
🔴 On today's #SystemCrafters stream, we'll take a look at the Sway compositor for Wayland and discuss the benefits of using it.
We'll also spend some time writing a Guile Scheme library that will enable us to configure Sway interactively at the REPL!
Join us LIVE at 4PM UTC on YouTube or Twitch:
- https://youtu.be/zx_wItkicKE
- https://twitch.tv/SystemCrafters
#emacs #guix #guile #gnu #linux #freesoftware #sway #wayland
🔴 On today's #SystemCrafters stream, we'll attempt to build a custom Guix distribution with a pre-configured desktop environment.
We'll try it out by building a VM image that enables you to boot directly into the default configuration!
Join us LIVE at 4PM UTC on YouTube or Twitch:
- https://youtu.be/yiPC4GotNXA
- https://twitch.tv/SystemCrafters
@aconchillo And the generated #Javascript actually looks sane! #guile @daviwil
🔴 On today's #SystemCrafters stream, we'll experiment with a workflow for hacking Guix Home services in the Guile REPL!
I'll be working on a home service to deploy my Emacs configuration with per-machine customizations, should be fun!
Join us LIVE at 4PM UTC on YouTube or Twitch:
- https://youtu.be/KNXOZtbfslY
- https://twitch.tv/SystemCrafters
Anyone know if there's been work done to compile #Guile apps for the browser via Emscripten or WASM?
I've had a lot of fun working on my own Scheme compiler this year but I'm starting to wonder if my time would be better spent hacking on #Guile #Scheme instead.
The compiler and runtime are mature and battle-tested, the tooling is excellent (#Guix, Geiser), lots of useful libraries, and the community is filled with smart, creative people.
I'm now considering spending a couple of months experimenting with Guile to see if I can quickly accomplish some of the things I had in mind with Mesche...
Today (actually, yesterday) I release Guile Probá 0.2.0, a set of testing tools for GNU Guile projects with SRFI 64-based test suites.
https://luis-felipe.gitlab.io/guile-proba/
It comes with a command-line interface that allows you to run test suites with test discovery:
$ proba run TESTS_DIR
It is also a library with helpers for testing.
You can install it on any GNU/Linux device using GNU Guix.
I hope you find it useful.