kal
starfx
kal | starfx | |
---|---|---|
2 | 6 | |
396 | 75 | |
- | - | |
10.0 | 9.2 | |
almost 10 years ago | 15 days ago | |
JavaScript | TypeScript | |
MIT License | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
kal
-
Internals of Async / Await in JavaScript
It's obsolete now, but before async/await was part of JS proper I worked on a compile-to-JS language that handled this by compiling to callbacks: https://github.com/rzimmerman/kal
It included try/catch support and fancy stuff, like loops. The source may be interesting for anyone interested in compilers: https://github.com/rzimmerman/kal/blob/master/source/generat...
The Kal compiler is written in Kal, but it's supposed to be easy to read. Surprisingly the browser demo still works: http://rzimmerman.github.io/kal/demo.html
- Please Put Units in Names
starfx
-
FastUI: Build Better UIs Faster
Ah! A real criticism of FE development, I agree with your problem statement.
When you jump into the world of single-page applications, things get complex pretty quickly, because the use case for needing an SPA pushes the web app into a full desktop application.
Ultimately, for a highly interactive and dynamic "desktop-class" user experience, there is added complexity. I think that's why so much movement within the FE world has moved away from "SPA for everything" and into these mixed dynamic apps. Islands, React Server Components, NextJS, they all help create a middleground between a document-based website with no dynamic elements with a full blown desktop app experience. They all have real tradeoffs, in particular adding an entirely new backend service to serve the front end.
For many projects, react + react-query is probably enough.
Having said that, my argument from https://bower.sh/dogma-of-restful-api still stands: when you build an API that is RESTful (1:1 mapping between endpoint and entity) you are unknowingly pushing the complexity of data synchronization to the FE, which requires a well thought out ETL pipeline.
This probably doesn't help my case but I've been building a simplified middle-layer for react to bridge the gap between react-query and full blown SPA: https://starfx.bower.sh
- Show HN: Starfx – A modern approach to side-effect and state management in UI
-
Effection 3.0 – Structured Concurrency and Effects for JavaScript
`redux-saga` maintainer here.
I've been using `effection` to build a replacement for `redux-saga` over at https://github.com/neurosnap/starfx
Effection has demonstrated to me how truly powerful delimited continuations are and why structured concurrency is an incredible asset for anything that requires async flow control -- basically everything in TS/JS.
I know sometimes it's hard to imagine why someone would need structured concurrency or care about delimited continuations for a front-end application, but this is a game changer in terms of expressing async flow control.
Some things to note about Effection:
- API surface area is small https://github.com/thefrontside/effection/issues/851
- It tries to stay as close to JS constructs as possible so it will feel very familiar
- Resource cleanup is automatic (when a function passes out of scope all descendent tasks are shut down automatically)
- End-user doesn't need to think about delimited continuations
The only leap users need to "deal with" coming from async/await is the syntax.
import { main, call } from "effection";
-
Internals of Async / Await in JavaScript
- https://github.com/thefrontside/continuation
- https://github.com/thefrontside/effection/tree/v3
- https://github.com/neurosnap/starfx
The last one intends to replace redux-saga using DCs.
Here’s a presentation I gave recently talking about DCs in typescript: https://youtu.be/uRbqLGj_6mI?si=XI0JNMKMoO2VHMvM
-
Philosophy of Coroutines
A couple of us have been experimenting with deliminited continuations and I think it’s gonna take off soon:
https://youtu.be/uRbqLGj_6mI?si=kgKKjpCnehJ9bpIG
https://github.com/neurosnap/starfx
-
Observable API Proposal
I feel the same way which is why I decided to help maintain the project. Async flow control is very tricky even in js–land. Having watchers live inside of a while-loop is a powerful construct that lends itself to interest flow control patterns.
I'm also in the process of rebuilding redux-saga but without the redux part: https://github.com/neurosnap/starfx
It's still in alpha stage, but it is very reminiscent of redux-saga.
What are some alternatives?
NodaTime - A better date and time API for .NET
effection - Structured concurrency and effects for JavaScript
phpmnd - PHP Magic Number Detector
proposal-async-iterator-helpers - Methods for working with async iterators in ECMAScript
SI - A header only C++ library that provides type safety and user defined literals for physical units
libcommon - Library of reusable C++ code
durationcheck - Go linter to detect erroneous multiplication of duration values
continuation - Delimited Continuations for JavasScript
assembly - assembly projects
Unchained - A fully type safe, compile time only units library.
observable - Observable API proposal