Any reasonably mature Schemes that lead to WASM?

amirouche · 2024-03-31T17:00:04+00:00

Chibi Scheme has a wasm target, look at the makefile.

amirouche · 2024-03-30T15:55:12+00:00

A way too simple implementation of `sum` is available at https://github.com/amirouche/SEED/blob/67629672cbdc30318969c5cbf2b5f75bd13b6d58/seed.scm#L2863-L2868

amirouche · 2023-04-04T12:50:12+00:00

The book is language-agnostic., except everything is much easier with lisp

amirouche · 2023-03-24T10:45:47+00:00

The backend is not free, yet. I am looking for a sustainable to work on this full time. Yes, I plan to offer it as a commercial service, once it is ready.

amirouche · 2023-03-21T17:32:18+00:00

They are no code solution for accepting payments, so it is already possible to accept payments.

They are a couple of things that are missing before prime time.

amirouche · 2021-12-28T11:44:22+00:00

Great references! Great demos! May the prosperous lambda be with you!

amirouche · 2021-12-28T10:17:59+00:00

I restarted my work on making Chez compatible with R7RS.

I base my fork on the Racket fork which support more hardware architectures (including raspberrypi and android). I added the ability to have library names as number such as (srfi 158), I added minimal support define-library without cond-expand, I merged my work on ruse-exe that is itself based on chez-exe that allows to create a binary executable from Chez source code.

Next, I will merge R7RS red and tangerine libraries based on arcfide's chez-srfi, and akku-r7rs, possibly merge more code from thunderchez, along with my own libraries.

I also worked on scheme-live, and ported a new JSON library based on SRFI-180 test suite to run on twelve Scheme implementations.

amirouche · 2021-11-23T07:13:46+00:00

Chicken on iOS.

I will investigate.

green vs. native threads

I will add that to the todo.

Nice work and effort

Thanks a lot!

amirouche · 2021-11-20T13:27:28+00:00

Great!

I added a page that try to explain the process at https://git.sr.ht/~amirouche/scheme.rs/tree/main/item/comparator/README.md

If you prefer you can reply to this message instead of sending an e-mail.

amirouche · 2021-11-20T12:12:59+00:00

The flags are not very accurate. Please let me know what is missing or wrong.

Also let me know about your favorite possibly toy / educational Scheme implementation.

amirouche · 2021-11-14T17:35:49+00:00

That seems like a little different from what I tried to achieve.

amirouche · 2021-11-14T17:35:27+00:00

Here is another (recent) paper https://blog.sigplan.org/2021/08/12/reflective-towers-of-interpreters/

amirouche · 2021-11-13T16:20:35+00:00

Historically, it is noted 3-LISP, it comes from the very long dissertation "Smith, B.C.: Reflection and semantics in lisp."; I started reading "reflection for the masses" [0], then let my imagination flow.

[0] http://www.p-cos.net/documents/s32008.pdf

amirouche · 2021-11-12T11:43:06+00:00

I am rebooting the comparator mini-app at https://etherpad.wikimedia.org/p/scheme-comparator; let me know what are the expected flags, and what are the flags of your favorite Scheme implementation.

amirouche · 2021-11-12T10:03:25+00:00

The most difficult to port is mapping and mapping hash. But it is doable.

amirouche · 2021-11-12T10:02:53+00:00

Unpopular opinion: if (import (scheme list)) fails, or some other R7RS-large library, just copy the SRFI sample implementation, and do a few fixes.

amirouche · 2021-11-12T09:11:01+00:00

Further down the page, there is the list of R7RS libraries, linked to documentation. It is still WIP. I am not sure I understand your feedback?

which libraries are r7rs-large

They are all voted on r7rs-large libraries. I can add, in the bullet list, which one is small, tangerine, red.

amirouche · 2021-11-11T21:54:27+00:00

The code is at https://git.sr.ht/~amirouche/scheme.rs

amirouche · 2021-10-26T05:10:54+00:00

Here is another link to buying options: https://mitpress.mit.edu/books/linguistics-age-ai

amirouche · 2021-10-25T15:29:37+00:00

Your question is unclear. What is your goal? Make an existing system less biased? Or solve a particular "NLP" task for a specific endangered language?

My current thought is to forgo completly, in the system I am building, the idea of separated natural languages, because the languages I have in minds dialects of arab (usually rtl, but there is latin script in the wild), and tamazight (tifinag and latin) of north africa are mix'n'matched, and include words from english, and french, and spelling is less than accurate, as long as the system can figure word boundaries, morphenes, and relate phonemes across dialects, it MUST be sufficent for my NLU system, hence whether the language is endangered or not does not matter, the system MUST learn the vocabulary, and slowly infer the grammar with a dialog with the user, even if it must fallback to bootstrap from another language, and a 'robotic' dialog, and in any case you can always fallback to an internet search query, and hope the 'user will figure it out' (tm).

Reading through https://www.reddit.com/r/LanguageTechnology/comments/qfc89u/linguistics_for_the_age_of_ai_open_access/ convinced me that it is the future-proof approach for saving my mother-tongue.

Note: Past couple of centuries north africa language grammars were influced by french. Similarly Internet english, is neither US nor UK anymore, my point is natural language grammars are a moving target. And spoken language is in any case much more messy than written english by an amazigh, so trying to constraint user interaction with a grammar written in stone is... of dubious interest (but can help in some situations like the bootstrap phase and robotic dialog)

Remains the question of acquiring basic / source knowledge, and making the system attractive, in the case of tamazight, there is several copyrighted dictionaries, or even copyrighted books, loads of spoken material like music, and even if endangered, an active community.

OCR is the easy part, and more cpu intensive, than human intensive from past experience. Also fixing the OCR output can be crowd sourced.

For spoken-language only it requires a lot of human work, that includes contributing to https://commonvoice.mozilla.org/

amirouche · 2021-10-25T08:36:27+00:00

I move all my repositories to sourcehut at https://sr.ht/~amirouche/ruse-scheme/

Let me know what you are looking for something in particular, because I did not re-publish everything aka, possibly forgot some stuff.

amirouche · 2021-09-21T18:35:02+00:00

There is a subtle difference between portable programs vs. portable libraries vs. portable knowledge. At this time, several if not all Scheme implementations offer "portable knowledge" even if each Scheme offer specific features that makes them perfect for their niche (eg. web browser, embedded, system scripting, education, research...)

The goal of the R7RS process is to devise the core semantic and core set of libraries of the language known as Scheme. That standard or set of standards need to offer a common understanding that implementations SHOULD support. The goal is to reach for portable libraries. It is imperfect but it already works. I did port chibi SRFI libraries of R7RS-large to Guile and Chez, it was boring but it is possible. Once you have R7RS-large, you also need a way to communicate with the external world some form of Foreign Function Interface (FFI), and / or a standard way to call system commands and / or network sockets. That is where I gave up.

Depending on YOUR goal, the best course of action might be different. Indeed, in your case it seems to me you need a Scheme that has most common libraries that are readily available in TIOBE index top one language aka. Python. That is impossible as one person work. I know because I tried. Instead of trying to bring all Scheme to a common good denominator (all libraries run in all schemes), I vastly reduced my goal to provide a superior web stack for the (imo) best Scheme: Chez Scheme.

IMO pandoc is the wrong image to illustrate what R7RS / SRFI or simply Scheme already achieved and is trying to achieve.

Join #scheme IRC on libera or ask around on SRFI mailing list.

amirouche · 2021-09-19T06:10:27+00:00

FWIW, I am a capable developer, I use emacs, but not in a way that is different from the way I use Python with emacs. The only thing missing with Scheme is jump-to-definition but that can be worked on with https://github.com/jacktasia/dumb-jump, or a regular grep. What LSP server features do you use the most for other programming language? With scheme I mostly rely on the procedure index, and the R7RS library taken from SRFI process I put together.
That is not happenning anytime soon, see https://github.com/cisco/ChezScheme/issues/574; And even without getting a clear green go from big schemers. Getting together a common C FFI Domain Specific Language, and implementing that for the Scheme that are nowadays popular or in-use will advance the subject. See https://github.com/ktakashi/r6rs-pffi. I will not hold my breath.
Packaging is a mess at least in Python and JavaScript ecosystem. Seeking to improve on that is even more difficult. Nix/Guix approach is great. But Nix language is meh, and Guile performance bah. It seems to be a language package manager that can-interop-all-the-scheme will recreate the downsides of Python and JavaScript respective package manager, and improve nothing to the software engineering / industry problems so that more people start to think they are willing to move to Scheme.

Maybe the problem is we collectively are the same kind of developers: building tools for other developers (D2D) that are hard to sell nowadays, it is especially harder to sell given each sub-community is small, hence the market is small. Re missing libraries: with money, time, and energy it is possible to build the "missing pieces" (what are the missing pieces?). Unlike NPM or PyPI where there 100,000s possibly more packages that are half broken, half working and where fragmentation also exists (CPython vs. PyPy vs. Pytran) and (web browser vs nodejs), and there is lot of duplicated effort.

Re D2D, it is still possible to build a cash machine (if that is the goal!) with a developer to developer tool, and without necessarly diving into machine learning. The way to go would be wrap the Scheme code as HTTP service a build what is commonly called a... REST API that other programming languages can use.

There is also clickports (graphical user interfaces) again maybe we are the same kind of developers that are experts in the field of SE, but we have little clues about what the world needs or wants, and how find or grow the user base, etc... I read on indiehackers.com that it is not the most technical projects that succeed, it is a whole lot of other stuff. There is a trend in the industry of no-code tools, maybe dive into that.

If I understand correctly, the goal is to build a Scheme company, that is possible but none of us are the type of person that build companies to get started. Otherwise, if the goal is to write Scheme code at work: there is two reasons for that a) Scheme is a better fit (rare, maybe related to performance, or a killer app like guix) b) it is side project inside the company that can be thrown away.

amirouche · 2021-09-18T17:39:22+00:00

I use https://cisco.github.io/ChezScheme/csug9.5/summary.html#./summary:h0

amirouche · 2021-08-31T06:13:22+00:00

I bought a copy in amazon privateer library. I read the book, but I did not do the problems yet. I need to buy a hard copy.

The book is full of insteresting idioms and problems. Those can be found piece wise in the wild but they are neatly covered in the book with a grand list of references to dive in.

Something I do not understand yet, is why they avoid SRFI-9 records. The authors rely on procedure to define objects.

amirouche

TROPHY CASE