i'm not entirely sure if this is on you because i believe the problem is in the version number of the old nuget (2020.2.6) that is greater than the one on nuget.org (1.0.7). what i'd like to know is, where i got this from.

i've got these nuget feeds:

Registered Sources:
  1.  nuget.org [Enabled]
      https://api.nuget.org/v3/index.json
  2.  vvvv teamcity [Enabled]
      http://teamcity.vvvv.org/guestAuth/app/nuget/v1/FeedService.svc/
  3.  Microsoft Visual Studio Offline Packages [Enabled]
      C:\Program Files (x86)\Microsoft SDKs\NuGetPackages\
  4.  Stride [Enabled]
      https://packages.stride3d.net/nuget
  5.  Stride Dev [Enabled]
      C:\Users\Matthias\AppData\Local\Stride\NugetDev

In reply to @gregsn:matrix.org
Had the same issue and removed the vvvv feed

Simply put: yes.
When we look at them in detail however: no.

This is a bit confusing, but maybe it's just some details that don't really matter often. You be the judge. The details where they differ are:

intro to s & r
s & r nodes in beta were ensuring - via lazy evaluation - that everything above a s node gets computed before the r node consumes the value. why? Well, beta was all about lazy evaluation and we wanted that s & r nodes could be imagined simply as invisible links.

In gamma we don't have lazy evaluation, but we stuck with the idea that s & r should behave very much like an invisible link. why? Because you probably come from a dataflow oriented thinking when using s & r nodes. There is one data source (the sender) and then potentially many invisible links to data sinks (the receivers).

Thus

• you can't have many senders on the same "channel". You'll get a warning. This is coming from dataflow oriented thinking. You can have one value source, but many sinks.
• you get a warning if a receiver reads before a sender has written to the channel. (We can't easily enforce execution order, but we can make you aware when something seems to be off)
• you also get a warning when no sender exists at all.

Those warnings are meant to tell you that the invisible link in your head doesn't match what's actually happening.

But other then that: yes a sender just writes to a globally available memory location, accessible via some key.

The mental model of global channels:

Sure, again you make values globally available via some key. So of course from a distance this sounds very familiar.

You could even compare this basic idea to global fields/properties/variables in other languages.

However, the main difference to s & r nodes is the mental model regarding data source / data sink.
The Channelness is basically what's different to the s & r idea.

What's a Channel?

A channel allows to think in shared data streams. The mental model is that different contributors get access to a data stream and may modify and listen at will. This is more a jam session now not a performer/listener relationship...

• Channels can inform every subscribers asap (known from Observable<T>)
• Channels have operators for syncing different channels, many of them doing bi-directional binding: GetSlice (Channel), Select (ByPath)... Pushing a value on a channel will sync all bound channels. When using those operators you won't get into situations where channels keep on firing events to each other in an endless manner.
• Channels have a non-generic view onto them. Without knowing the type at compile time, you can build programs that push objects to Channels, whose type only becomes clear at runtime.

All in all

• Channels simplify scenarios where you have back & forth communication needs (e.g. a UI shall show the current model, but also be able to modify it).
• I like to think of a channel as some atomic entity, which just happens to show up here and there. Like variable in math.
• Channels simplify scenarios where you want to think of something that shall be shared.

Now obviously sharing gets a lot easier with global channels.

Disclaimer: Global Channels don't come with any logic for frame synced data. And don't warn you like the r node. This area could get some overhaul

• e.g. frame-synced global channels could be global channels that only in the next frame inform the subscribers of the new value. This could be an option on a global channel. [ ]
• warnings when reading from an uninitialized channel (...)