Confrontation anxiety / low work self-esteem friendly summary 
:
The gains don’t out-weight the losses.
- Template literals are very modular and compose nicely. Typed cells don’t.
- Template literals empower the community and promote experimentation and collaboration.
- Having to write
~~~ instead of ``` is a non issue.
- Additional keyboard shortcuts and mouse operations introduce friction.
- They don’t play nicely with copy and paste.
- More UI means less interoperability.
- This adds more maintenance burden on an obviously overworked team.
Thanks for trying tho 
!
Frustration fuelled rant 
:
Oh god, no please!
Not having the hassle of typed cells is one of the major features of Observable!
I’ve used other notebooks with typed cells like nextjournal and starboard, typed cells plain suck.
-
They are super inflexible, loose modularity, and don’t compose: Typed cells are a closed set. You want to write a new markup formatter for say ReStructured Text? Tough luck. Unhappy with the Markdown renderer used by observable? Tough luck.
JS template literals that emit DOM nodes allow you to do all of this and more. They nest and compose nicely, it’s super easy to create first class alternative markup types, and it’s something that really helps community building and collaboration.
-
They solve a non issue: Let’s be real, how often do you REALLY have to do ``` to escape code that you don’t want to run? The whole point of observable is to have an environment of runnable cells, so most of your code will go into those anyways. Also if you want to show stuff like command line input you can just write your own literal for that and get much nicer visuals. And as @keystroke points out, there’s also ~~~.
-
They introduce a lot of friction to the workflow. Setting the type of a cell once might be ok, but doing it over and over and over again is just annoying flow breaking tedium. Creating and changing cell types is probably one of the most performed operations.
-
It breaks copy paste. On long notebooks it’s often easier to simply copy a cell and paste it somewhere else, instead of having to drag the bloody thing to the moon and back. With typed cells you not only have to paste the cell, but also set the cell type. URGH…
-
They further paint observable into a platform corner, where everything has to be done through a UI with no hopes of properly integrating with proper development tools. Text is love!
-
They completely miss the target audience: “Yeah those plot Marks, Scales, Transforms and Facets are easy peasy, but you know what I really struggle with!? having to type * to make my words bold.” - no one ever
And here’s the real kicker! Stuff like this adds to the dumpster fire that you have to maintain. Before this could have been nicely delegated to the community. Ask around who wants to maintain the template literals for specific markup languages, I’m 100% positive that someone would take over as a maintainer. I’d gladly do it if it prevents you from wasting resources like this, and gives you some space to address the ton of bugs that give me misery.
But now it’s within the proprietary boundary of “the editor”, which means it’s another thing on your plate.
Isn’t the prettier fork, the in house diff view, the custom version control management system, the javascript transpiler, the custom dataflow engine, the full text code search, the social media stuff, distributed eventually consistent text editing, an old testament amount of bugs and everything in between enough?
Do you really have to add the insanity inducing madness that is contenteditable and WYSIWYG a problem so nasty that even facebook with it’s billions of dollars and thousands of engineers (including the creators of React), just couldn’t get it half way bug free?
If you’re into suffering that much may I instead recommend wearing a really scratchy undergarment.
The lack of feel for what’s really great about observable (and what isn’t) makes me loose confidence in observables leadership and loose hope that the team will get its priorities straight at least some day.
Who judges and approves those long term maintenance costs while ignoring all the fundamental existing quality issues? Doth thy hubris have no bounds?
Observable notebooks are the closes thing I’ve seen to a bicycle for the mind,
yet observable the company insist on it being a rickshaw. The barrier of entry is already low enough, use the community as a force multiplier by giving it better tools, not flashy features that only look nice as a mockup.
So please. Kill it with fire.
Something that would have made the entire system more powerful and more flexible would have been the ability for self modifying cells. By adding a replaceContent(newValue) to the standard library we’d not only have gotten the ability to write our own WYSIWYG editors for markdown and HTML, but also for all kinds of custom data types, like tables, lists, and the ability to have code and interactions that persistently reflect in the notebooks without the need to connect to some external service or database, something which I’ve needed countless times.
Better syntax highlighting. No more fussy escaping. It’s not just Javascript!
Markdown?