Hacker News Reader

The industry is cyclical and to be forward thinking all you have to do is describe what's already happened and assume it will happen again. ;-)

The things being done with JavaScript today are not new, nor is the idea that a server and client would coordinate to run interactive apps. That fundamental concept has been reimplemented in many different ways until we've landed on the current rube goldbergian monstrosity that are web apps.

It shows that the desire to have users interact with a service in particular ways will not go away. The technology used to do that is mostly irrelevant.

I'm not surprised that the architecture isn't new, I'm surprised that web apps were already being talked about this way using JS specifically. JS's early design flaws are often written off as, "well it was never intended to be a real programming language like it is today". But from reading this, that doesn't sound to be the case.

I don't so much think of them as flaws... the first use case was form validation, and most of the fuzzy type coercion makes a ton of sense through that lens, where ''. 0, etc. coercion to falsy is easy for dealing with user input. It's also why it's one of my favorite options for ETL workloads.

It's just a matter of understanding the langauge. That said, it's been my favorite language since well before the "good parts" book.

I use JS every day; I would say I like it. I would even say that in 2020, if you know what you're doing, it's a pretty good language on the whole.

But I don't think it's controversial to say that the following were objectively bad decisions (in hindsight, of course, but still):

- Automatic casting behavior between the core types (you're the only person I've ever heard suggest that this might be a good thing)

- Automatic semicolon insertion

- A core Date object that lacks basic control over time-zones and reasoning about time-zones

- Assigning to an undeclared variable silently creates a global

- Allowing duplicate function parameter names where later ones just hide the earlier ones

- Distinction between undefined and null (this one might have a few defenders)

Some of these are now prevented by "strict mode". Others have been patched-over, for example by the addition of === which prevents casting behavior for comparisons at least. Others can be bridged by libraries (Moment.js) or by best-practices (use foo == null to smooth over the null/undefined distinction, never use a value's implicit falsiness in a conditional, etc).

But the point is that JavaScript has this giant asterisk that will never go away, of things you need to do/avoid/utilize in order to get the most basic behaviors right.

I would suggest that today, you're best off using TypeScript for anything more complex in terms of applications development. Will probably play around more with Deno bundling if I get the time, though currently using Parcel, which is nice enough, but slow.

I didn't like TS at first, but using the most recent version has been relatively pleasant and working with less experienced devs has been almost required in order to do further refactors. I killed a month trying to do a complex refactor ad-hoc, in circling around, I was able to convert the entire project to TS in a couple days, introduce typing for core state and a few other areas which allowed me to do the rest of the refactor in a couple days. That sold me on TS, as long as I don't HAVE to type everything, or jump through the hoops as I did on my first experience with TS, which was combined with Angular projects.

The casting behavior is definitely a foot-gun, but it's powerful as I mention for validation and ETL type workflows. The "falsy" values list is literally my guide marker in interviews for JS devs. It's usually a pretty good benchmark for how well a developer understands the language itself..

Totally agreed on the Date object. Absolutely horrible, and moment, while useful was huge and most other hacks aren't all that great either. The Date object really should be extended as probably the next major bump in usability in the system. Even if it was just extended enough for parity for what C#/.Net offers for their DateTime/DateTimeOffset then other libraries could flush it out and be much smaller.

One useful thing to know, is that assigning an object property to undefined will skip that property as part of json serialization and is faster than delete on the property I'll often do something like return JSON.stringify(Object.assign({}, original, {propToHide: undefined}) in node APIs. This is about the only useful bit from undefined I can think of off hand.

Global variable assignment by default is definitely a flaw.

> Automatic casting behavior between the core types

This is (mostly) awesome for quick/light glue scripting and a (almost entirely) a horrible pain for most other programming. As the scale of JS apps has gone up, this has gone from probably being a net win from the way JS was used early on on the web to being a net harm.

> Distinction between undefined and null

This existence of this distinction is, IMO, a very good thing, but there's some big ergonomic issues with the implementation. (The rest of your list I agree with.)

Netscape 2.0:

    "foo" - 1
    //raises "is not a numeric literal"
    "" == false
    //raises "is not a numeric literal"

    "foo" + new Object()
    //"foonull"
    "foo" + new Array()
    //"foonull"

    0 + true
    //1
    0 + false
    //0

    1 + new Array()
    //raises "null is not a number"
    new Object + new Object
    //raises "null is not a number"

    true.foo
    //raises "true has no properties"
    1..foo
    //raises "1 has no properties"

Ten days language was not that silent.

TypeScript makes almost all of those asterisks go away.

I think JS' early design flaws were a result of being written in a day more than anything to do with a specific purpose (I exaggerate but not by much). Though it is true that most people at the time used JS (if they used it) for much simpler tasks than described in the article.

I think in some ways the problems people have experienced come back to a language design that is fairly ambitious.

Specifically the inclusion of a prototype OO system is confusing if you aren't aware what that is and have only been exposed to Java-like OO programming. But in fact it's very powerful and not so hard to learn once you realize you have to.

As with other web technologies, it's simple at first glance but the learning curve gets steeper at some point.

It was written in 9 days, which is astounding. I suspect that the project was given a week to complete and it came 2 days late. In any case it seems unlikely that it’s problems would go away if given another 5 days. A lot of the wired things in a scripting language only become obvious at scale.

> already happened and assume it will happen again

So say we all!

Under appreciated BSG reference. Well done!

Yes for sure..I worked as a corporate contractor for AT&T in 1990's and I was doing client/server apps using MSVC++ that are basically identical to React-type wideweb dev...

Indeed, your absolutely correct in saying it was obvious where webapps had to go, and that HTML and CSS just wasn't going to get us there.

Nitpick: "...and that HTML just wasn't going to get us there" (CSS came out in 1996).

And CSS wasn’t widely used until a few years into the ‘00s. Only then did more consistent layout engines finally make it viable for stuff other than just styling text.

Damn...I've forgotten more about the timelines of this stuff then most people know.

Me too. But your comment surprised me as I remember hearing about this new thing "JavaScript" waaaaay earlier than about CSS. I didn't actually know they came out this close together.

I agree with your basic premise. However, in this particular instance, what would have been the historical equivalent ("already happened") of scripts sent by the server to the client during the request response cycle, which could perform layout and logic in the client?

If you're simply referring to code that could run on both client and server, your point is clearer to me.

AJAX is part of the request response cycle?

Let's face facts...AJAX is the real secret sauce with JS and what makes it truly useful.

Long before the term "AJAX" was coined, we used hidden iframes to do the same thing.

Display PostScript[1] maybe? Developed by NeXT in 1987.

Or NeWS[2], also based on PostScript.

[1] https://en.m.wikipedia.org/wiki/Display_PostScript

[2] https://en.m.wikipedia.org/wiki/NeWS

Philip Greenspun has a great review of Netscape LiveWire from the time.

https://philip.greenspun.com/wtr/livewire.html

You can see that the current JavaScript tooling complains are nothing new under the sun:

  So what used to be a few keystrokes in Emacs or Netscape     
  Gold now requires three steps:

    edit the .html file
    recompile the .web file
    restart the LiveWire app from the appmgr

This quote is adorable considering the size of most pages today:

"This approach has several disadvantages, the first of which is speed. You are gratuitously transporting potentially many kilobytes of data back and forth across the network."

I was there, kB were an issue. We had 56 kb/s modems vs (let's say) 56 Mb/s fiber now. We gained a x1000 factor and we're dealing with many MB now instead of many kB back then. Page size grew x1000 too.

But loading pages was really slow, mainly because browsers were slow. No parallel loading of images, no progressive rendering. Those were the first optimizations.

I think you underestimate the effects of high bandwidth. There was a sweet spot in the late 90's when some people had broadband (early cable modems, generally 3 megabits, or DSL.) I had an ISDN line from 1996 through 1998, then a cable modem after that. The web was fast because it was built for dial up. As broadband gained more and more market-share, the bloat increased.

Working with LiveWire was incredibly painful. Often the server would crash during the restart phase (this was under WinNT 4.0 back in 1997.)

Server side JS had to write():

    <HTML>
    <HEAD> <TITLE> Hello World </TITLE> </HEAD>
    <H1> Hello World </H1>
    <P>Your IP address is <SERVER>write(request.ip)</SERVER>

But client side JS had to write() too (there was no DOM), and so we have

    'foo'.link('http://example.com')
    // "<a href="http://example.com">foo</a>"
    'bar'.bold()
    // "<b>bar</b>"

http://web.archive.org/web/19961115040956/http://developer.n...

ASP, the original one before .net, had a language called jscript that ran the ie js engine on the server. https://en.wikipedia.org/wiki/JScript

Yes, I coded in JScript happily for about 3 years. Even better, using Windows Scriptlets let me write dynamically-compiled COM components in JavaScript that I would call from the web pages. As a result, I could launch updates independently in a microservice-like fashion, share the same libraries (like validation) on client and server, and use the same COM components in crons. Not bad at all! Also, because we had COM components, we could now use Window's built-in message queue MSMQ for async processes like payment transactions. I started doing this in 2003 - looking back, that was a pretty good developer experience.

Running the same logic and the same technology in the server and the client was mandatory for realtime multiplayer games since the 1990s. See this article from Valve [1] for a briew overview of how client side prediction works. You should also have the server process the data to avoid cheating by modificating the client app.

[1] https://developer.valvesoftware.com/wiki/Latency_Compensatin...

Wait a minute here...I was writing realtime multiplayer games for Galacticomm's MajorBBS in thr late 80's and we just pushed ANSI and made VERY interactive games without the need for a rich client...altho we did envy AOL's bitmapped graphic capabilities at times...

Pei-Yuan Wei created the ViolaWWW browser in 1991.

His browser had many features, including:

- Stylesheets, similar to CSS

- Scripting support, using a scripting language (like JavaScript).

- The equivalent of Iframes

Pei-Yuan Wei is the man.

> Edit: Apparently they already ran JS on the server! I had no idea

Hmm, I started work as a web developer back in 2000, and I don't remember ever coming across such a notion. The first time I heard of JavaScript being used server-side was NodeJS many years later.

Didn't visual basic support some kind of client side code?

IE (3? 4?) let you specify vbscript instead of JavaScript as the language in your script tags.

Edit: introduced in IE3 (1996) apparently. https://en.m.wikipedia.org/wiki/Internet_Explorer_3

IE 3 does support VisualBasic as another script language. Later IE versions simply supports any scripting language that is provided by the underlying platform (including javascript). People tend to regard the whole IE4/Windows 98/"Desktop enhancement package" thing as Microsoft being anticompetitve and trying to kill Netscape, but the whole thing has solid technical background. Well, the whole "PWA" concept existed at the time except it wasn't called that.

> a la React in hybrid-mode

Isomorphic app?