Live data from Hacker News

Svelte is a language

gist.github.com

11–20 of 95 posts

Re: Svelte is a language

#11
post #5

Earlier quoted context omitted.

Or maybe one day people will realize render functions explicitly listening to event emitters is actually a better pattern than implicit reactivity.

I think it is a shame that the Observable proposal [1] still seems somewhat stuck in Stage 1. It's a better idea than just raw event emitters because of composability (if no other reason). Making Observables "first class" could go a long way to unifying a lot of reactivity patterns in various frameworks, in theory at least. To be fair, Observables and especially Observable composition has a rough learning curve and m…

I really, really love Observables as an imperfect solution in an imperfect world, but I don't think they will solve reactivity.

The main issue is, that it becomes a nightmare to transmit and compose meta-information. An example would be the fetchStatus of ReactQuery [1].

I way too often end up in situations like this:

  .map {
    unwrapMetaData
    ...
    rewrapMetaData
  }
  ...
  .map {
    unwrapMetaData
    ...
    rewrapMetaData
  }
  .switchMap {
    // unwrap metadata and wrap it in an observable
    combineLatest(...) // have fun juggling an array of nested monads :)
  }
I wonder if it is possible to create a mixture between React hooks and async/await. Since you tend to work in one big scope, you could ignore the meta-info until you need it.

  async live function() {
    const { value, meta } = observe getValue(...) // suspends when loading, throws on error
    // work with values
    const multipleValues = observe Observe.all(...map(i => ...))
    // more work
    // evaluateMetadata
  }
[1]: https://tanstack.com/query/v4/docs/react/guides/queries#fetc...

Re: Svelte is a language

#13

Earlier quoted context omitted.

I think it is a shame that the Observable proposal [1] still seems somewhat stuck in Stage 1. It's a better idea than just raw event emitters because of composability (if no other reason). Making Observables "first class" could go a long way to unifying a lot of reactivity patterns in various frameworks, in theory at least. To be fair, Observables and especially Observable composition has a rough learning curve and m…

I really, really love Observables as an imperfect solution in an imperfect world, but I don't think they will solve reactivity. The main issue is, that it becomes a nightmare to transmit and compose meta-information. An example would be the fetchStatus of ReactQuery [1]. I way too often end up in situations like this: .map { unwrapMetaData ... rewrapMetaData } ... .map { unwrapMetaData ... rewrapMetaData } .switchMap…

You can already combine hooks with something like Rx using the useSyncExternalStore hook.

I’ve worked on very complex Rx code bases. I like Rx, but it gets it be a huge pain the debug when you have very complicated chains. I haven’t used hooks too much, but from what I’ve seen the default behavior is to “do the wrong thing” which makes them very annoying to work with. The implementation of hooks is also very hacky. Like you can’t create a hook inside an if statement. That’s crazy.

Re: Svelte is a language

#14

Earlier quoted context omitted.

I think it is a shame that the Observable proposal [1] still seems somewhat stuck in Stage 1. It's a better idea than just raw event emitters because of composability (if no other reason). Making Observables "first class" could go a long way to unifying a lot of reactivity patterns in various frameworks, in theory at least. To be fair, Observables and especially Observable composition has a rough learning curve and m…

I really, really love Observables as an imperfect solution in an imperfect world, but I don't think they will solve reactivity. The main issue is, that it becomes a nightmare to transmit and compose meta-information. An example would be the fetchStatus of ReactQuery [1]. I way too often end up in situations like this: .map { unwrapMetaData ... rewrapMetaData } ... .map { unwrapMetaData ... rewrapMetaData } .switchMap…

I've had some success with writing Async Generator functions in mixed RxJS/IxJS pipelines.

  async *function someMapOperation() {
    const { value, meta } = await getValue(…)
    doSomething(meta)
    yield value
    for await (const { value, meta } of AsyncIterableX.from(mergeAll(…).pipe(takeUntil(…)))) {
      doSomething(meta)
      yield value
    }
    // …
  }
(I've done similar things in C#, as well, with its Rx/Ix pair.)

You are right, there are still good cases where being able to write the "state machine" of a complex flow as an async (generator) function makes it a lot easier to reason with. The nice thing is that Observables work well with AsyncIterables and a pipeline doesn't have to be just one or the other.

Re: Svelte is a language

#15
The really exciting thing about svelte is getting rid of the virtual Dom. Having everything just be explicit JavaScript code that modifies the Dom manually makes for really readable code. If you have not tried it, got to the svelte tutorial and look at the output code. It's awesome.

Re: Svelte is a language

#16
post #15

The really exciting thing about svelte is getting rid of the virtual Dom. Having everything just be explicit JavaScript code that modifies the Dom manually makes for really readable code. If you have not tried it, got to the svelte tutorial and look at the output code. It's awesome.

I haven't used Svelte beyond a couple toy tutorials, but, for me, the infrastructure adapters [1] are the most exciting thing. I love the idea of being able to build using Svelte and auto-magically deploy to something like Cloudflare Pages without completely giving up the potential to deploy somewhere else.

1. https://kit.svelte.dev/docs/adapters

Re: Svelte is a language

#17
Using the label and block syntax for this was a stroke of genius.

Two great things about this "thinking inside the box" approach are:

1. You're encouraged to use native APIs because they're highly unlikely to clash with the framework.

2. You can a legible stack trace. After all, the only thing the compiler does to your JavaScript is add some instrumentation here and there.

Re: Svelte is a language

#18
post #16
post #15

The really exciting thing about svelte is getting rid of the virtual Dom. Having everything just be explicit JavaScript code that modifies the Dom manually makes for really readable code. If you have not tried it, got to the svelte tutorial and look at the output code. It's awesome.

I haven't used Svelte beyond a couple toy tutorials, but, for me, the infrastructure adapters [1] are the most exciting thing. I love the idea of being able to build using Svelte and auto-magically deploy to something like Cloudflare Pages without completely giving up the potential to deploy somewhere else. 1. https://kit.svelte.dev/docs/adapters

I've got mixed feelings about this and I'm sure I'm in the minority. Those adapters are usually supported by the commercial company that wants you to use them. But, for example, the static or node adapters often don't work great with the important parts of svelte kit like SSR, and feel like second class citizens.

I love svelte but I'm having a hard time getting the same development ergonomics out of svelte kit. It's probably just me.

Re: Svelte is a language

#20
Give a quick glance to Svelte. Help me understand, how this syntax {#if expression}...{:else if expression}...{/if} can be seriously invented in our... more civilized age?
Post reply on HN