marianoguerra

There's a proposal for effect handlers that allows for continuatios, coroutines and others.

> effect handlers as a unifying mechanism to enable efficient compilation of control idioms, such as async/await, generators/iterators, first-class continuations, etc.

https://wasmfx.dev/

You can parse many things from this file, what are you trying to extract?

https://github.com/WebAssembly/spec/blob/main/document/core/...

If you are interested in learning about wasm instructions you may like https://wasmgroundup.com/

> This book takes a hands-on, bottoms-up approach: you'll go from hand crafting bytecodes to writing a real compiler for a simple programming language.

disclaimer: I'm the co-author

An Extensible Conversational UI for Interactive Components[1][2], current use case is a Personal Productivity Assistant for structured data.

The stack is simple, preact in the fronted with a custom framework on top and bun on the backend calling OpenAI, I may port it to rust in the future.

I plan to try local LLMs when I have some free time.

For now each users runs the application locally with their own keys[3].

[1] https://www.youtube.com/watch?v=nS1wsif3y94

[2] https://www.youtube.com/watch?v=f-txlMDLfng

[3] Alpha software, check the readme: https://gloodata.com/download/

Check https://github.com/josevalim/erl_phoenix

> Writing Phoenix controllers, templates, plugs, and live views from Erlang

If you are interested in this type of approach you may like https://wasmgroundup.com/

> This book takes a hands-on, bottoms-up approach: you'll go from hand crafting bytecodes to writing a real compiler for a simple programming language.

disclaimer: I'm the co-author

> And then people go "but you can use ESM in browsers without a build step!", apparently not realizing that that is an utterly useless feature because loading a full dependency tree over the network would be unreasonably and unavoidably slow - you'd need as many roundtrips as there are levels of depth in your dependency tree - and so you need some kind of build step anyway, eliminating this entire supposed benefit.

Not true, I have developed 3 systems with plain ESMs loading them in the browser with no build step (> 100K lines of code for each project, too many modules to count :)

Update: I bundle for release

if you read the keywords (defn, cond, let) it would be a coincidence if it wasn't a lisp in xml clothes :)

Great idea. I will try it

No, I wanted to try the DOMParser API and build a programming language that was valid HTML and would be closest to the HTML spirit, that's why I built the expressions as a stack language, to avoid introducing syntax for arithmentic, comparison and boolean expressions. It would be much concise with custom syntax for that but further away from HTML

I found some references here:

"Custom elements cannot be self-closing because HTML only allows a few elements to be self-closing"

https://developers.google.com/web/fundamentals/web-component...

It seems only void elements are allowed to be self closing:

https://html.spec.whatwg.org/multipage/syntax.html#void-elem...

The trailing U+002F (/) in a start tag name can be used only in foreign content to specify self-closing tags. (Self-closing tags don't exist in HTML.) It is also allowed for void elements, but doesn't have any effect in this case.

https://html.spec.whatwg.org/multipage/parsing.html#parse-er...

it seems the DOMParser doesn't allow custom self closing tags, I tried and it didn't work

not particularly :)

if it has functions, variables, lexical scoping, loops and conditionals is it a template engine? :)

the "an extension to HTML" part was too long for the submision, that's why I added the "is/as" part, to make it clear that it wasn't HTML itself.

I'm working on that :)

Instadeq: A Live Programming Environment for End User Data Analysis and Visualization

Video: https://www.youtube.com/watch?v=mTEkYqnGICE Slides: https://marianoguerra.github.io/presentations/2021-live/

Thanks for your comment :)

Another one I forgot, transcribing video tutorials into a written guide.

The most recent one which I'm currently working on is to take notes on the structure of SaaS product intro videos (the one you find on the landing page, usually above the fold)

Another one I had in the past that it will make easier is to add time marks on the video description (youtube segments the timeline and adds a section list to jump between the marks)

I think it can also be useful for people taking online classes or learning from videos

More Improvements:

- Grouped shortcuts

- Consistent left to right order

- Moved note to the bottom to make more shortcuts visible on smaller screens

- Added icons to make each easier to find at a glance

- Simplified shortcut descriptions

I'm working on a version of this: https://instadeq.com/

Would really like to know what's your theory on why component based software failed in those cases and if Web Components learned/solved those problems.

The only transformations done are to make the resulting Elixir more idiomatic, otherwise it tries to preserve the original intent.

I plan to add some extra transformations but most will be ideomatic ones, like mapping from Erlang modules to equivalent Elixir ones (maps -> Map, lists -> Enum and so on).

The target language is really simple and all the tooling for the erlang compiler itself is in the standard library.

so it's easy to get started, easy to get something usable quick and easy to see how it's used in real stuff.

If you are interested follow the commits here from oldest to newest to build a language o the beam: https://github.com/marianoguerra/otl/commits/master?after=bd...

slides from a presentation I gave: http://marianoguerra.org/talks/beamba-buenos-aires-meetup/#/...

depends on the segment the application is in, in data visualization/dashboards it matters a lot more.

List of additional resources here: http://marianoguerra.org/posts/riak-core-on-partisan-on-elix...

what do you mean by "forget pivot tables, email notifications and pdfs that look good".

they don't work? are expensive? hard to use? limited?

Write lexers and parsers for data formats, JSON and EDN are two good starting points.

write a forth or lisp lexer, parser and interpreter.

then write a small language that compiles to a target, like js, make sure your language is close in semantics to the target language to avoid headaches.

There's a talk here: https://www.youtube.com/watch?v=wU17sNGs_qA&feature=youtu.be

Another comment linked to the tool