#scheme
fuzzing isn't only for the #kernel, you can fuzz your programs, too. particularly useful if your program is a programming language that is also an operating system written in the language that it hosts, like with #loko scheme (project of the weinholt, the author of this blog)
"Fuzzing #Scheme Code with #AFL++"
https://weinholt.se/articles/fuzzing-scheme-with-aflplusplus/
Continuations Brief Summary. Studied the topic a bit and brought you a write-up. Should be interesting for people related to programming, and especially for scheme and lisp users.
https://trop.in/blog/continuations-brief-summary
#programming #scheme #lisp #clojure #commonlisp #callcc #continuation
I read the post but I'm only now catching the video:
Live Demonstration of Time-Travel Debugging in @spritelyinst Goblins
I remember watching a talk about some fancy REPL-related stuff (probably not about REPL itself, but it was extensively used in the demo) by a girl doing some R&D in this topic, but I don't remember the name and don't know how to find it :/
Share a link, please, if you accidentially know what am I talking about.
SEmacs, a multi-threaded emacsen, written in Chez #Scheme
I’m trying to install Haunt (https://dthompson.us/projects/haunt.html) on an M2 Mac, but it keeps failing to make. Has anyone managed to do this? I thought that it could be a fun way to teach myself scheme… #Haunt #Scheme
so in sum: join a #scheme and propagandize for it with a vengeance
also, the wise advice of not getting too attached to your favorite programming language doesn't apply to #scheme. this advice is wise primarily because your favorite programming language may develop a toxic community that you're powerless to change, but with scheme there are always other implementations to get involved in, and if you're driven to, you're free to start your own implementation. This applies to most dialects of #lisp, but to a lesser extent than scheme.
So after working in #scheme for the #lispgamejam, I find that I tend to think in terms of lisp on my day job now (which doesn't involve lisp)... I'm contaminated!
#California sued the state of Nevada for #patientdumping in 2013. The case made national news & Nevada was guilty as hell.
FL & TX are sending
#migrants to California & other states in a way that is similar to the patient dumping #scheme & the states on the receiving end should sue them.
Additionally, an atty in California represented several patients who were "dumped" in a #classaction lawsuit & won.
Migrants are being dumped. Someone should stand up for them
https://www.nbcnews.com/healthmain/san-francisco-sues-nevada-over-patient-dumping-8c11126850
Woah chez-scheme is made by Cisco? :O i didnt expected this #scheme
My personal lisp game jam entry is now up on itch.io! https://davexunit.itch.io/super-bloom
It's a silly little game about protecting a growing flower from dirt balls that look more like meatballs actually. I had very little time to make this and it shows but I'm glad I was able to submit something!
Spritely's submissions are incoming. Stay tuned!
Centre asks states to get MGNREGS workers to switch to Aadhaar-based payment method
Activists have been resisting the move, saying that several of the workers under the employment scheme are not eligible for the payment method.
#MGNREGS #aadhaar #DigitalDivide #employment #labour #welfare #scheme #DataProtection #security #UIDAI #india
λ Directly compiling Scheme to WebAssembly: lambdas, recursion, iteration!
➥ Spritely Institute
"we can now compile various Scheme procedures directly to WebAssembly. Let's clarify that: by compiling directly to WebAssembly, we mean they compile and run without any intermediate virtual machine. No C, no Rust, no Zig: Hoot outputs pure WebAssembly. It's early, but Hoot compiled programs are starting to work... and they're fast!"
#Scheme #WASM #GNUGuile #Lisp https://spritely.institute/news/scheme-to-wasm-lambdas-recursion.html
@alex I have actually written an extensible implementation of the ed text editor which allows defining custom editor commands through a #Scheme API. Using this API, I have also implemented a | command for ed to avoid writing to a temporary file for formatting purposes.
See https://hachyderm.io/@nmeum/110134377992047881 for a demo.
@noracodes chez scheme! It's super crafty, malleable, minimal and powerful. It was only made open source a few years ago, so has a bit of a sparse community, but you'll get performance that will often rival rust if not outpace it, while producing teeny little statically linked native binaries that are extremely fast and start up in snap. Plus it can handle all but the lowest level programming tasks; its the perfect language whether you need to do scripting or write a compiler or even an operating system kernel. You're restricted to small set of powerful tools that others seem to "fall out the bottom of" once you get the hang of it. It takes time to learn how to grok but once you get it down, its a trip.
Also if you find you really like it but you don't like the (lack of) community, there are countless (good, fast, powerful, user friendly, etc) #scheme implementations with their own niche communities, so you're never locked in to a power structure of people you don't like, just because you like the language. Diversity of implementations is good in many ways, with fragmentation as the downside.
Custom UI Animations and Handling Control Scheme Changes | Unity Tutorial
Discussions: https://discu.eu/q/https://youtu.be/u3YdlUW1nx0
@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.
Tonight a few friends sent me a message that #rde is on a front page of Hacker News. Is it something good?
Is there is a good reason to have multi-value return in #Scheme? It seems returning a vector does the trick quite well. Am I missing something?
Compiling #Scheme to WebAssembly
https://spritely.institute/news/scheme-to-wasm-lambdas-recursion.html
Exciting times!
Hoot: a Guile #scheme -> #wasm compiler
https://spritely.institute/news/scheme-to-wasm-lambdas-recursion.html
Guile is coming closer to web assembly. Impressive results.
https://spritely.institute/news/scheme-to-wasm-lambdas-recursion.html
wow, the #Chez #Scheme implementation of the #Shen #Prolog logic programming system[1] performs 4x faster than the #SBCL #Lisp implementation[2].
It seems like Mark Tarver, the author of Shen who reported these results, authored both implementations.
[1] https://shen-language.github.io/
[2] https://groups.google.com/g/chez-scheme/c/vTyTn_yh9vg/m/D8t-jooBGAAJ
Just finding out that #OpenCog, a framework for #AI research used by #Huawei and others is primarily written in #Scheme
Seems like the project is being discontinued, but lots of interested examples are there for reference: https://github.com/opencog/opencog
#PureScript getting a Chez #Scheme backend
https://github.com/purescm/purescm
Lisp & Scheme recap for week 21/2023
https://discu.eu/weekly/lisp/2023/21/
#clojure #lisp #programming #racket #scheme
Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium
@amcooper #Clojure has the most modern style docs and package management, but #Scheme is a better language IMO.
That said the choice does not matter -- it might be worth just grabbing a copy of The Little Schemer and just picking any Scheme impl you can find. Anything beyond the basics will either be specialized to some particular impl or will be abstract enough that you can take it to any Lisp.
The Lisp Game Jam has begun! 60 registered participants! This is a 10 day jam so still plenty of time to join in if you want! https://itch.io/jam/spring-lisp-game-jam-2023 #lisp #scheme #gamejam #gamedev #lispgamejam
The Lisp Game Jam starts on Friday! Would be real cool if we got 50+ parenthetical jammers! At 49 now, just need one more. https://itch.io/jam/spring-lisp-game-jam-2023 #lisp #scheme #gamejam #gamedev
Yeah, I suppose if the thread library is something like the CHICKEN #Scheme implementation of SRFI-18 that’s different, because it operates in just one processor thread. At least if it takes care of things like processor pauses for you. But using multiple processor threads? You have to be kidding me? :)
Preparing the last stream in the series related to scheme static sites generators:
great lecture on first-class continuations from Kristopher Micinski
https://www.youtube.com/watch?v=DW3TEyAScsY
@daviwil @PaniczGodek but in all fairness, I think interest in Scheme has been growing due to #Unison's adoption of Chez for their primary backend and 470x performance increase they saw as an immediate result.
The average person seems to think that scheme is a slow toy language for learning how to implement programming languages, which is just incredibly wrong as demonstrated by projects like #idris, #guix, #goblins and countless others. #scheme is C among functional languages.
The SICP-inspired book "Software Design for Flexibility: How to Avoid Programming Yourself into a Corner" seems interesting but abstract.
Do the software design techniques it presents have practical applicability and value in ordinary programming? Have you read the book? What do you think?
https://mitpress.mit.edu/9780262045490/software-design-for-flexibility
We are now 2 weeks away from the next Lisp Game Jam! If you've ever typed a parenthesis (open, close, or both) and thought "ooh, that felt good!" then join up here: https://itch.io/jam/spring-lisp-game-jam-2023 #lisp #scheme #gamedev #gamejam
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?
Cue quarterly #Haskell community meltdown
To be fair, I think Haskell will continue to fill the niche it filled ~10 years ago, around the time it started to get mainstream hype. Small teams of skilled devs delivering robust products that would normally require much larger teams to maintain will continue to prevail. Purely functional lazy programming was never bound for world domination in an economy which is antagnostic to curiosity, creativity and truths.
On the other hand, I have the feeling that we're going to see more and more Haskellers-turned-Rustaceans come to realize that #Rust does little to alleviate the primary barrier to Haskell's wider success -- fast and predictable turnaround time for projects developing cutting-edge technologies -- and will wind up going the same route as some major Haskell projects such as #Unison and #Idris have in recent years, which is to try #Chez Scheme, only to discover that it allows them to release blazing fast functional programs on a generic foundation where major breaking changes are practically non-existent, providing incredible flexibility while significantly reducing dependencies by dint of the ad-hoc tooling that falls out of the bottom of #scheme. Not to mention the joys that come from near-instant startup times, some of the fastest compile time you've ever encountered, fully-customizable interactive development and a surgical #debugger that rivals Haskell in scheer fun. Yesterdays naysayers will become tomorrow's enthusiastic bootstrappers. Or a at least a boy can dream.
That said, in all seriousness I don't think Scheme will ever reach the heights of Haskell's moderate commercial success. But I do think that projects built on Scheme, like Unison, will get a leg up and eventually surpass it, and interest in #lisp will only grow.
I was just good enough to post to #RosettaCode my #Scheme implementation of the #SVD --
https://rosettacode.org/wiki/Singular_value_decomposition#Scheme
It’s the Golub-Reinsch algorithm, as improved for EISPACK. (I have a printed copy of that volume with the ALGOL in it, BTW, though you can get the preprint online. But the FORTRAN code has numerical-stability improvements.)
Now I did the same task in #R7RS #Scheme --
Another stupid little ‘monad’ example in #ATS, for #RosettaCode --
https://rosettacode.org/wiki/Monads/List_monad#ATS
IMO writing loops is simple enough in some languages -- including ATS and standard #Scheme -- that there really isn’t that huge a need for such a thing as this ‘list binding’ operator. But in some languages it’s just effing hard to write a loop.
Hiya, guess who just made https://octodon.social their new fedi-home? 👋
A good chance to re-introduce myself: I'm Fabio, a software engineer and... "technologist", I guess? I tend to maintain a critical stand towards technology and to care about its social/political/ethical aspects as much as or more than the purely technical ones.
I'm interested in #FreeSoftware, especially community-led projects - in other words, "free" as in "open/distributed governance" more than "simply open source".
My tech stack is in large part #Emacs, #Guix, and various other #GNU projects. I love programming languages of the #Lisp and #Scheme family.
Pronouns: they/them. #Vegan, #London-er.
Some more info on myself on the terribly outdated https://fabionatali.com.
🔴 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
G-exps, derivations, creating your own file-like objects and much more. Another great post from unmatched-paren. If you into #guix, I highly recommend this series for better understanding of internals.
https://guix.gnu.org/en/blog/2023/dissecting-guix-part-3-g-expressions/
"I don't know if any of you have really seriously dived into #DeepLearning, but it is a truly massive and unwieldy zoo of extremely abstract, seemingly tailored concepts that appears almost impossible to get to the bottom of. There is certainly no foundational, theoretical treatment of the field that would allow for it to be approached with the sort of global understanding with which we treat programming languages... so that that is what I want to expose in the book, how can build up this tower of abstractions from nothing but the simplest functions, elucidating what has been obscured in the production process."
— Anurag Mendhekar on his new book with Dan Friedman, the 800 page tour de force The Little Learner
I'm convinced that this is the most important rule in all of #ComputerScience
Dan Friedman:
"#Lisp had an operator called map, and you'd give it a function,
(map f _)
and so we decided we wanted to give it a bunch of functions, like...
(map (f1 f2 ...) _)
...and so for each of these functions we would give it a list, like:
(map (f1 f2 ...) (l1 l2 ...))
Now we started to run into trouble bcs some of these guys were of different sizes.
Some of them would be like this:
/\
\/
and some of them would be like this:
/------\
|------|
|------|
\------/
or like this...
[....]
[....]
[....]
...and so on.
So we came up with a rule to manage that.
That rule was called the #GuillotineRule
The Guillontine Rule stated that everybody loses their head...
------/------\---------
/oo\ |-o o--| [.0 0.]
———————————————————————
\--/ |------| [.....]
------\------/--[.....]
...when they run out of values."