I've been working on a small stack language for the BEAM in my free time called 'Xlerb'.

I read Starting Forth and thought it would be interesting to see if you could send messages to other stacks etc, and the BEAM seemed like a great fit.

Xlerb is a small leex/yecc grammar and a simple-ish compiler that takes Forth-ish code and turns it into regular BEAM modules.

The modules it produces just export functions from stack to stack, so there's a good interop story with Elixir/Erlang (if you'd ever want to do that?).

I've the syntax a bit beyond a 'strict' forth with pattern matching, that makes it feel a bit more natural of a BEAM language (with different function heads etc). It was a fun exercise translating that into the Erlang primitives of case, send, receive etc.

I've got a website at https://xlerb.wtf with a bit more, and you can get the code/compiler/repl at https://github.com/shawa/xlerb

Let me know what you think!

Comments URL: https://news.ycombinator.com/item?id=46091455

Points: 6

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=45943846

Points: 23

# Comments: 4

https://www.erlang.org/doc/apps/stdlib/ets.html

Essentially system-global state under named tables.

Have/did you consider having named `env` instances? This would allow for say, feature flags to be kept in a `features` set of relations.

You could also draw from Erlang's 'match specs' and query with a predicate over the keys.

The BEAM's grown up along with Erlang and so the culture and optimisations are built up all around function application, list processing, recursion, and pattern matching etc.

https://github.com/llaisdy/beam_languages is a decent list of the diverse languages that have been implemented on it, but nothing quite like 'regular for and while loops'.

The BEAM itself is a plain aul register machine though, so it could be done!

https://www.erlang.org/blog/a-brief-beam-primer/

It comes with some tradeoffs compared to fully client-side state, but it's a really comfortable paradigm to program in, especially if you're not from a frontend background, and really clicks with the wider Elixir/Erlang problem solving approach.

https://hexdocs.pm/phoenix_live_view/js-interop.html#handlin...

Hooks let you do things like have your DOM update live, but then layer on some JS in response.

For example you could define a custom `` component, which is inserted into the DOM with `data-points=[...]`, and have a hook then 'hydrate' it with e.g. a D3 or VegaLite plot.

Since Phoenix/LiveView is handling the state, your JS needs only be concerned about that last-mile JS integration; no need to pair it with another virtual DOM / state management system.

https://hexdocs.pm/phoenix_live_view/js-interop.html#client-...

https://hexdocs.pm/tidewave/mcp.html

> - Host on a piece of infrastructure that's so big that you can't effectively block it without causing a major internet outage (think: S3, Cloudflare R2, etc).

How can one bounce VPN traffic through S3? Or are you just talking about hosting client software, ingress IP address lists, etc?

Likely right up your street!

https://acko.net/blog/how-to-fold-a-julia-fractal/

I’d definitely be really grateful for help with that! I’m not planning to publish to the Mac App Store, but it would be great to have the build step a bit more compliant with current practises.

https://docs.ankiweb.net/deck-options.html#learning-steps Details what _actually happens_ when you pick again/hard/good etc. I much prefer understanding this to the vibes-based approach of “did you pause before answering”.

Secondly turns out you can indeed very easily set up type-to-answer in a deck by editing the front template and adding

{type:Field}

where field is the answer part of the card’s data.

So… I’m actually using Anki again. I’m still very happy I did this, it was a fun little journey!

Comments URL: https://news.ycombinator.com/item?id=44540724

Points: 73

# Comments: 32

Using `midiex` for Elixir I’ve written a fully fledged driver for Ableton Push, letting me use it as essentially a 4-deck version of Pioneer’s DDJ-XP2 sub controller with Rekordbox.

It implements basic statefulness so that the rotary encoders can be used, as well as a paging system so the 64 performance pads can be mapped to different functions. It also supports track browsing and loading, which is helpful if you want to use say DVS with an external mixer and don’t want to be hunched over a laptop dragging tracks around.

It’s also got some additional capabilities which I’ve not seen on other hardware like dedicated faders for stem separation levels.

It’s been a great exercise in combing two hobbies, learning about MIDI as well as being able to personalise my setup for my own use. I haven’t open sourced any of it just yet whilst I’m still tweaking things but I’d be interested in collaborating with anyone who also has one of these devices and has programmed it. I’m looking to use the display on it next, whose protocol Ableton have some (albeit scant) documentation for.

https://youtu.be/aXfTgCCsRSg (T=4:30)

The emulating different lenses part is that with this setup you can parametrically collect specific rays bouncing off the object (presumably the angle of the mirror with respect to radius), and the resulting image will be the same as you’d get from a lens with those parameters.

Generally I’d say Elixir’s lack of “hard” static typing is more than made up for what you get from the BEAM VM, OTP, its concurrency model, supervisors etc.

That said if you’re interested in leveraging the platform whilst also programming with types I’d recommend checking out Gleam (https://gleam.run), which I believe uses an HM type system.

    x-apple-health://HearingAppPlugin.healthplugin/HearingTest

1: https://www.reddit.com/r/AirpodsPro/comments/1gftyqo/is_the_...

One of the draws to Prolog is its immensely simple syntax: A.R:B = true in your case would be represented as simply r(A, B).

It looks like you've elevated some set theory properties to syntax, and have added some neat sugar over chained relations. Have you found areas where this really shines as compared to writing more standard Prolog/Datalog queries? I'm afraid I couldn't see many examples on first look at your Github.

Just some additional commentary too - I think this post quite misrepresents it with some of the comparisons.

Prolog at its core is SLD Resolution [1] (a form of search) over Horn Clauses [2] (first order logic). Queries posted to the runtime are attempts to find a set of values which will satisfy (cause to be true) the query – whilst SQL is founded on relational algebra which more closely aligned with set theory.

Whilst there's probably some isomorphism between satisfying/refuting a logical predicate, and performing various set operations, I'd say it's a bit of a confusion of ideas to say that SQL is based on 'a subset of Prolog'. The author might be thinking about Datalog [3], which is indeed a syntactic subset of Prolog.

[1]: https://en.wikipedia.org/wiki/SLD_resolution [2]: https://en.wikipedia.org/wiki/Horn_clause [3]: https://en.wikipedia.org/wiki/Datalog

    git config core.commentchar 

https://www.metalevel.at/prolog

The Power of Prolog is an extremely in depth, comprehensive introduction that starts right from fundamentals, and goes into some pretty advanced topics. It’s a really great resource, with well-produced accompanying videos, and leans into properly grokking the language and the “Prolog way” of problem solving.

I’d make a meta point that learning Prolog and forcing yourself to solve problems the “prolog way” serves as a great exercise in understanding the importance of using the right tool for the job, and working with, rather than in spite of , your tools.