Search posts, tags, users, and pages
I think you misunderstood the point of SSR too. One of the main reasons why people want SSR is for better SEO. Since it is well known that search engines like Google's will only execute synchronous Javascript when crawling pages, the search engines could miss the content loaded from ajax and worsen the SEO. This is the main reason why we want SEO.
Anyways, nobody is trying to force you to use Virtual DOM and you are free to develop your app anyway you wish. If you think your way is better, prove it to people. To me, the only valid point you have made so far is how directly doing DOM manipulation is faster, which is obvious and trivial. I won't agree that the "equivalent" imperative version of the app you wrote is simpler, and it is obvious to me that it is much harder to scale and maintain.
I feel that your arguments to Virtual DOM has been like: "Using integration to find the area under the curve is stupid when we can just draw the curve to measure the area manually." or "Higher order functions is absolutely making things overly complicated while we can just define the function directly." You just don't seem to be able to appreciate any level of abstraction and prefer doing things in a low-level way. Perhaps you should consider writing your future webapps directly in webassembly because the interpreter behind javascript is so complicatedly written. LOL
I think you misunderstood the point of SSR too. One of the main reasons why people want SSR is for better SEO.
I don't think you're understanding me... ONE of the reasons, sure, but do you know WHY that's one of the reasons and why SSR works for such?
Because it means the server is spitting out flat HTML and using normal page loads. Hopefully, if all goes well, that HTML will be semantic, logically structured, and accessible to as many users as possible -- since again, what did Matt Cutts tell us over a decade ago that still holds true when it comes to on page SEO?
Write for the user, not the search engine
That's what!
On page SEO is an extension of semantic markup and graceful degradation, aka basic accessibility. A well crafted web page should function scripting off, CSS off, images off, it should even make a degree of sense if you just strip-tags it; because every single fancy bit you layer on top of the content should be an optional enhancement, not base functionality. That's why CSR is an epic /FAIL/ if used on websites, and really should be limited to full stack applications where you have no plans to run in on the web in a normal browser; limiting yourself to a single parser, renderer, and JS engine. (like Blink+V8)
EXCEPT when CSR is used as an enhancement atop SSR, which is entirely possible just to avoid those "evil pageloads" so many scripting fanboys run around screaming about and use as justification for telling users with accessibility needs where to stick it.
There are dozens of valid user-agents a well written web page -- the target of SSR only or enhanced SSR -- should be working for; screen readers (software that reads the page aloud), braille readers (like the one I'm using on and off as my vision worsens), teletype, tty, puffers... and most of them are near impossible to use with scripting-only pages, or presentational markup, or failure to separate presentation from content, or any of the dozen other things that mean jack to them. They don't have eyes, so things like layout and colours mean nothing... and remember the joke: Search engines don't have eyeballs. They too could give a flying purple fish about layout, colours, borders, or any of that -- and honestly the Goog making ANY efforts to pay attention to scripting (or style) apart from checking for abuse is a colossal mistake on their part. It's letting too many sleazy fly-by-night dirtbags rip out their handicapped ramps, park in the blue marked spaces, and push over the little old lady with the walker who's in their way.
So, if for accessibility reasons -- of which SEO is part -- you should be using SSR, which by definition means you should be outputting markup... and as accessibility is the actual reason for it you should also have a separation of presentation (CSS and other presentation) from Content (markup/semantics/actual flipping content)... That means you should on the server side be outputting semantic HTML...
So again, if that's what you're supposed to be outputting, why the blazes are you creating a server-side DOM?!? Abstraction is ok, abstraction for nothing is just taking the simplest thing -- outputting HTML -- and turning it into a convoluted mess wasting massive amounts of code on nothing of value.
Though you are right to a degree, I do prefer the low-level way assuming one can call just outputting HTML "low level" which I most certainly would not. Far too many of these abstractions result in more code, more bloat, and make the simplest of things as insanely difficult as possible. Much like the idiocy of HTML/CSS frameworks, enfeebled scripting frameworks like jquery, utter gibberish wastes of time like SCSS, and so forth end up making people write two to ten times the code they need using a library that's twenty times the code they should have.
How that is simpler, easier, better, "aids in collaboration" or "when working with teams" is utterly and completely beyond my comprehension -- and as I've said several times the only way I could see interpreting any of this stuff as useful is if they simply do not know enough HTML and CSS to be working on anything that actually outputs HTML.
A suspicion that gets a lot of confirmation from the code examples people vomit up for these things. I can't even get through React's tutorial -- that tic tac toe example? -- without walking away thinking "These clowns aren't qualified to write a single blasted line of HTML!"
Hence said example needing them to write 6k of code to deliver 9.6k of code that relies on 800k+ of bloated library files to do the job of 5.5k of code written in a sane and rational manner without their BS.
But tell me again how that's magically "easier", or "better", or even worth doing.
You find this virtual DOM stuff useful, good luck to you. From where I sit I swear you're making ten times as much work out of it, and making it thousands of times more complex. If it seems "simpler" thanks to the abstraction, that's the illusion of false simplicity. It "looks" simpler probably because you don't know HTML as well as you think you do.
Though I'll freely admit, I probably don't know JavaScript as well as I think I do. Probably because much like with HTML/CSS frameworks most of my work with it involves ripping it out wholesale from places where it's screwing over the site owner and their customers. A lot of the new ECMAScript 6 stuff just leaves me screaming "WHY?!?" Who thought this was a good idea?!?"
Oh, and could you clarify:
Decoupling the real DOM from the application. Allowing application to be rendered in a different environment; e.g. server-side rendering.
What does that even mean and/or why is that even desirable. The application server-side shouldn't give a flying purple fish about the DOM -- an inherently client-side concept -- on the server side. It has one job, to output HTML. If you're working in SSR that's it, that's all you should care about... because that's what the accessible output for a website should be.
Enabling developers to write their application declaratively instead of imperatively.
That is a "career educator" distinction I've always found to be pedantic nonsense in application. Well, that's not entirely fair, it's just that for some reason people automatically favor one to the complete exclusion of the other ; which in cases like this amounts to nothing more than hammering a square peg into a round hole. Again, is it REALLY so hard to write server side code that just outputs HTML? All those folks who've spent decades writing websites using PHP, Perl, Java, etc, are pointing their fingers and laughing at that one.
It's like the minute people started using JavaScript on the server, they instantly ignored the easiest and most obvious solution. Probably why they had to give what every other language that's ever been used to build conventional websites the fancy "server side rendering" name; like a cut rate bargain basement marketing slogan.
... and that's the real laugh of it. Until people started AJAXing in content to avoid those "evil" pageloads -- because... reasons? -- everything was SSR. With languages where your example -- as SSR without the interval update since that's a CSR only concept -- would simply be:
<?php
echo '
The current count is ', $count = mt_rand(0, 10);
while ($count--) echo '
<img
src="media.giphy.com/media/cuPm4p4pClZVC/giphy.gif"
alt="describe this, alt is not optional"
>';
?>
But tell me again how you need a DOM for that server-side. I don't buy it -- it's exactly the type of "pointless convoluted bloat for nothing" that seems to rule this industry right now. -- that again my day job freelancing the past seven or eight years has involved grabbing onto in a senstive spot and ripping it out with great passion and ferocity.
How is writing ten times the code that relies on 10 to 100 times the code you should have in total in pointless libraries/includes/modules/frameworks/whatever "easier" or "better"? What possible point does this entire "virtual DOM" business have other than creating a second DOM on the server that has to be turned back into plain Jane simple HTML to be used for SSR? How is that convoluted mess of code "easier" than just writing a fraction the code in flat plain Jane HTML?
That it has become synonymous with how so many node.js apps are written should be sending anyone even remotely familiar with using HTML properly running and screaming away from it. Pennywise? Pinhead? Freddy? Annabelle? Weeping Angels? Amateurs compared to the "Virtual DOM" when it comes to absolute horror.
To the point I think the only thing scarier might be Showgirls.
Jason Yu
This example actually illustrates why I find much of the new ECMAScript to be pointlessly cryptic and needlessly bloated; and why I find this whole "Virtual DOM" thing to be complete nonsense based on nothing more than lies and disinformation.
There seems to be this paranoid unfounded claim being circulated that working directly on the DOM is 'slower' or that there's some sort of 'render' overhead. If you do it RIGHT there is no such thing since the browser's rendering engine does not render changes to the DOM until scripting execution is released!.
If anything, by creating and maintaining a "virtual DOM" -- or as it should be called and was for the first decade and a half of JavaScript in the browser a "document fragment" -- means doubling down on memory use (since you have two copies), doubling down on processing and render time since you have to make the live and the copy, and in general taking something ridiculously simple -- DOM Manipulation -- and making it as painfully difficult to do as possible.
... and over what? A bald-faced LIE about some sort of fantasy-land render overhead that you're going to have anyways since you have to copy it to the live DOM sooner or later?
This is part of what I meant a year or so ago when I asked "Are people just afraid of the DOM?" Even when they "use it" they don't really use it, or understand it...
I mean... well let's use your example. Rather than maintaining a second "virtual" copy (aka a document fragment), you build it on the DOM, and when you want to change values you do so on the DOM. Element.removeChild isn't rocket science, nor is textNode.data anything too complicated to deal with. If you made the count as its own text node, all you'd have to write is the count to textNode.data. If you have more than your new count in images truncate the difference from the end. If your new count is more than the number of live images, just appendChild that many images. It WILL be faster than all that pointless "diff" nonsense and "Virtual DOM" waste that just introduces overhead for nothing.
Let's start with three simple little helper functions, treat them as equivalent to your various dependency hell 'include'.
function make(tag, parent, attr, content) { tag = d.createElement(tag); if (attr) for (var i in attr) tag.setAttribute(i, attr[i]); if (content) node_add(tag, content); if (parent) parent.appendChild(tag); return tag; } function node_add(e, newNode) { return e.appendChild( 'object' == typeof newNode ? newNode : d.createTextNode(newNode) ); } function node_stripEnd(e, count, from) { if (!from) from = e.lastChild; while (from && count--) { var next = from.previousSibling; e.removeChild(from); from = next; } }"make" just makes elements applying and placing them as needed. (way gutted down from my 'proper' make routine which is far more powerful). "node_add" is just a shorthand for appendChild that lets us not worry or think about if we're adding a new DOM node or just plain text. "node_stripEnd" lets you strip children off the end of an element, or working upwards from (and including) a starting element. We don't need that latter functionality, but this is a straight cut and paste from my cheatsheet.
Then our actual logic:
var count = 0, appDIV = make('div', d.body, { id : 'app' }, 'The current count is '), countText= node_add(appDIV, count), cloneIMG = make('img', false, { src : 'media.giphy.com/media/cuPm4p4pClZVC/giphy.gif' }); function updateApp() { var newCount = Math.floor(Math.random() * 10); if (newCount < count) { node_stripEnd(appDIV, count - newCount); count = newCount; } else while (count < newCount) { count++; node_add(appDIV, cloneIMG.cloneNode()); } countText.data = count; } updateApp(); setInterval(updateApp, 1000);No goofy hard to follow arrow functions, no need for let/const (at most I'd wrap it in a SIF / SEF / IIFE / PickANameForItAlready) since lifting actually reduces the memory thrashing, etc, etc.
We set our count to zero so we can track it, make a DIV#app directly on BODY (since it's a scripting only element it has no business in the markup) with "The current count is " text already attached. Then making the countText its own independent textNode lets us just "countText.data=" when it comes time to update the count. Finally we create an image node to clone since for now we're just using all the same image.
The update function as a standalone can be called directly and timeout, giving us our initial render of counted elements and the interval refresh. All it needs to do is pick a new count and if there are less new ones than old ones we strip off the excess, otherwise we add the difference. Finally just update the count shown in the textNode to match.
Call updateApp to draw some children on initialization, set the timeout to update, done.
A fraction the code and logic, dozens of times easier to follow, runs way faster, and works all the way back to IE 5.x
Live demo here:
cutcodedown.com/for_others/jasonYu
That is why I find this whole "Virtual DOM" thing to be pointless, wasteful, and based on lies. I fail to understand -- apart from broken/bad methodology and/or a complete failure to grasp how browser render engines and JS interact -- how this fairy-tale nonsense about "render time" comes into it, how directly working with the live DOM is somehow magically "Bad", what people mean when they talk about "Side effects" since in most cases what they are talking about is stuff I expect to happen, want to happen, and as such aren't side effects it's what they're flipping for, etc, etc, etc.
I'm either missing something painfully obvious, or my way of looking at solving problems is radically different from RoW. (rest of world)
Though I really think if JS app developers spent more time thinking like website developers, they'd realize how foolish so many of these approaches to doing things are.