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?
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
Mi legis The heart of Spritely, kaj mi nun komprenis la hype. Mi ne povas atendi por uzi libre transakcioj kaj tempvojagxoj en mia guile projektilo, hall. Dankon, gxin estas tre mojosa.
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?
#Lisp(s) are the only programming environments that enable a prototype-to-production development cycle for non-trivial projects in a way that is predictable.
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:
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).
Is this a mistake in the "." parsing syntax? It seems that this form being treated as a list with no head, so instead of creating a cons cell it just returns the form after the "." delimiter? Is it supposed to work this way?
@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).
Question for anyone familiar with #Scheme programming, and in particular #Guile (@wingo): how hard would it be to port GOOPS to other Scheme implementations like #Chez, #Gauche, Gerbil, or Chicken? I know that other Scheme implementations provide their own #OOP systems (e.g. Chicken COOPS), but what if I want my library written in Guile to be more portable, could I still use GOOPS and try to move the code over to some other platform?
Or has this already been done? Is there a portable GOOPS, akin to a large Scheme library such as SLIB?
Which reminds me — I still haven't tried #guile#ggolf yet (going through serious gui allergies as of late), but I saw on the g-golf mailing list that it runs on mobile? Wonder how much work it would be to get the tooling together to make it easy to target Android in a predictable & uniform manner. Emaxxing the mobile experience is certainly on my mind often, but in general the ecosystems of mobile development, which in my mind is mostly Java, is the pits.
@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?
"The focus of my research is applying #fp, in particular #chez#scheme, to low-level problems — the type of situations that usually call for #rust or #c"
— highly recommended talk on programming with serialized data from @vollmerm @ #ELSconf
@theruran@vollmerm I increasingly think that #TypedRacket's approach is the ideal amount of types, but my scheme addiction keeps taking me lower and lower in terms of the minimal base I want to be working with (#Racket → #Guile → #Chez)
@rml@theruran@vollmerm
I love how the minimal #Chez interpreter (without the compiler) on x86_64 Linux is only 346800 bytes. That is small and minimal. But the Chez compiler is best-in-class, producing the among the fastest and smallest binaries of any Lisp.
That said, Guile's #GPL licensing and it's use in #GuixOS, and it's extensive collection of libraries and SRFI support, make #Guile a superior choice for practical applications (IMHO). Also now I know of someone working on porting the "PreScheme" compiler from Scheme48 (a Scheme subset with no garbage collector) to Guile for use in building low-level performance binaries: https://gitlab.com/flatwhatson/guile-prescheme
> "I promise I'll convince everyone here that types are good by the end of this talk"
As a Haskeller, I do not need convincing at all. One thing that got me to even pay attention to #Scheme however was a conversation with a friend, William Byrd -- by the way, who's dissertation is in relational logic programming from the University of Indiana under Dan Friedman, same school as the presenter in this video -- explained to me that the power of Scheme comes from both it's minimalism, but also it's macro system which you can use to implement any type system you might want. Byrd told me he is frustrated by the world kind of gravitating toward the Hindley Milner type checking algorithm used by OCaml, F#, Haskell, Typed-Racket, Coalton, Carp, and PreScheme, as if it is the end-all-be-all of type systems.
So anyway, Will Byrd convinced me how cool it is being able to use any type system at all in Scheme. Hindley-Milner, CSP, Pi Calculus, Calculus of Constructs, Separation Calculus, Location Calculus (which I just now learned about!), or maybe even more exotic constraints systems modeled on physics -- use whatever is best for your problem domain.