It's basically impossible to get started with D3 without using the Observable online playground, I find it so frustrating.
It's basically impossible to get started with D3 without using the Observable online playground, I find it so frustrating.
1. There are multiple online/physical books about D3, online tutorials/courses on YouTube/udemy/etc., blog-posts, blockbuilder.org (deprecated but still useful), and the d3 documentation itself, all of which aren’t tied to observable.
2. I do agree that observable is a bit difficult to use when you first try it, but if the issue is porting a d3 example to an index.html, you need only remove a few lines of observable scaffolding to do so. This is a far cry from, “basically impossible.”
I know it's hard to refute your first point as you could point to any example, but if I'm just trying to follow the happy, well-trodden path it's hard.
Eg. I go to D3 website [1], I click "documentation" link [2] in header which takes me to the Github, I click the first link "introduction" and the page is actually hosted on Observable [3].
If I click on the "examples" link on the Github or website...it takes me back to observable.org gallery!! [4]
This forum thread (on Observable) summarised exactly what I was thinking: "I want to learn D3. I don`t want to learn Observable. Is that ok?" [5]
One person asks "Why can we not simply download vanilla code examples without any “Observableness” in them?"
The reply by Mike is dismissive of their viewpoint and basically says learning D3 outside of Observable isn't supported:
> We recognize that this is a change and a disruption: a new thing to learn. And we need to do a better job of helping you learn Observable (and explaining why you should bother).
> Yet despite our shortcomings, we fundamentally believe that Observable is a better way to code 2: easier to understand, easier to tinker, easier to adapt and reuse, easier to collaborate and share.
Maybe basically impossible isn't the right description, but they don't make it easy to get started without using Observable.
On your second point, here is a HN discussion [6] on why Observable isn't JS. Observable has a _whole standard library_ [7]. Porting from Observable to vanilla JS is not just "removing a few lines of observable scaffolding".
[1]: https://d3js.org/ [2]: https://github.com/d3/d3/wiki [3]: https://observablehq.com/@d3/learn-d3 [4]: https://observablehq.com/@d3/gallery [5]: https://talk.observablehq.com/t/i-want-to-learn-d3-i-don-t-w... [6]: https://news.ycombinator.com/item?id=20184181 [7]: https://github.com/observablehq/stdlib/blob/master/README.md
Let’s be clear, D3 is an open-source library. In no way, shape, or form is Mike required to support and produce tutorials for the language. The fact that what he has been kind enough to produce was done so using Observable has no bearing on your issue of “getting started with D3” when non-Observable tutorials abound. If you just google “D3 tutorial” you’ll see that all links but one point to non-Observable resources.[0]
The article in Point 2 is a great one, but I'm not sure why you're linking it here. The implementation details are wholly unrelated to a) our discussion and b) whether or not it’s easy to port example D3 code to vanilla.js. It’s like someone arguing that porting Jupyter notebooks to Python scripts (something fairly chill to do) is difficult because of some unrelated implementation detail in Jupyter’s core code - the detail is irrelevant.
To make sure I’m not just talking out of my ass, I just went through a few of the initial "learn D3 Observable" Google results that came up, and in literally all of them all you need to do is 1. remove any enclosing brackets (if they exist) and remove 2. remove calls to svg.node() and boom - you can paste everything into a script tag.
Is that obvious to someone who doesn’t know D3 or Observable? Honestly, probably not. It can be clearer and I agree it should be spelled out somewhere (if it is, I don’t see it).
Is it obvious to someone who writes JavaScript for a living? Shouldn’t be too hard to figure out in the context of what is a literal tutorial.
Does the Observable environment make learning D3 difficult to learn? They’re fundamentally unrelated to the D3 concepts, so no.
And finally, if you (understandably) find the concepts of D3 to be confusing, especially when presented via Observable, should you complain that it’s basically impossible to learn because the author (the same dude who wrote and continues to update the library for free) chooses to host his examples using unrelated software he also helped author? No, probably not. Unless you want to contribute (get it!?) to the worst bit of open-source: complaining.
I agree that an open source project does not owe anyone detailed tutorials in their preferred format.
I'll consider contributing to a vanilla JS D3 tutorial in future.
It simply is not “tightly coupled”. It is very straightforward to get started without using Observable.
Observable does exist, it is related to D3. It is “loosely coupled” in metaphorical terms because there are no dependencies in the code.
It seems like a useful tool. Is the nature of your complaint that the team provided a learning environment alongside D3? That they recommend their learning & collaboration platform as well as their vis library?
These strike me as good things to do. I’ve certainly thought of other people’s Observables as valuable resources.
Or maybe it is simple but it's not intuitive unless you are familiar with Observable. So perhaps the solution is to have a page that describes how to move the examples from Observable to an HTML page? eg. where to put the scripts and where to put the HTML.
Similar frustations are aired in a forum post: "I want to learn D3. I don`t want to learn Observable. Is that ok?" [5].
[1]: https://observablehq.com/@d3/learn-d3 [2]: https://observablehq.com/@d3/gallery [3]: https://d3js.org/ [4]: https://github.com/d3/d3/wiki [5]: https://talk.observablehq.com/t/i-want-to-learn-d3-i-don-t-w...
The fact that they’ve made the effort to add a playground by leveraging a fairly easy to use tech should not be held against the open source maintainers!
Besides, all those examples are trivially reproducible locally, the way you would have to do it for the vast majority of languages which don’t give such fancy interactivity in their tutorials.