Deno in 2021
deno.com
deno.com
Does anyone else have a better solution shared Typescript code?
Still a hack, but perhaps symlinks could be a little simpler?
Server sends data as JSON to the client. Client parses JSON. Both now have the exact same data shape. Shared TS types let you use the same representation for the same data no matter where.
If your client and server both treat field "temperature" as a string for protocol version 1, and then the client upgrades to protocol version 2 and temperature is now a float, the server has to be modified anyway, type system or no type system, because otherwise it'll break.
If anything, the type system helps to expose the fact that the client and server now disagree about the type of a field, which is helpful.
Because the client and server now share a code base. The client requires the server to run.
> If your client and server both treat field "temperature" as a string for protocol version 1, and then the client upgrades to protocol version 2 and temperature is now a float, the server has to be modified anyway, type system or no type system, because otherwise it'll break.
If the data interchange format changes then yes both the client and server need to change. But if either the client or the server wants to coerce temperature to a different type they are free to do so. As long as the conform to the interchange format the internal representation of the data is irrelevant to third-parties.
In a world where types are shared, updates to the server necessitate updates to the client even if the client doesn't want to change (and vice-versa).
> If anything, the type system helps to expose the fact that the client and server now disagree about the type of a field, which is helpful.
The coupling should receive the credit not the type system. Regardless this undoubtedly true. Two isolated pieces of code don't know what the other is doing. You need to test and you need to write design docs.
This isn't true. Types aren't "a code base", they're an interface - without which it is impossible for a client and server to talk with each other anyway.
> The client requires the server to run.
Not relevant. Nothing about a typed interface prevents the client from running without having a running server - it won't be very useful without something to exchange data with, but you can still run it, unless you've coded otherwise.
> But if either the client or the server wants to coerce temperature to a different type they are free to do so.
No, type coercions are bad engineering. They're brittle and only work in a very tiny number of situations - nothing approaching the general case.
> As long as the conform to the interchange format the internal representation of the data is irrelevant to third-parties. Type coercions at the interface level are a hack that is not acceptable for anything beyond hobbyist work.
An interchange format is a set of types. Types are not internal representation - they're a mathematical concept used in type-checking. Types happen to be used in the process of generating an internal representation of data, but that's not what they are. You're falsely equating the two, and your point is invalid without that equivalence.
> In a world where types are shared, updates to the server necessitate updates to the client even if the client doesn't want to change (and vice-versa).
This is false. If the server is changed, the client only needs to change if the interface between the two also changes. If the server makes a change to its internal data storage format, then that has nothing to do with the client, and so the interface stays the same, and so the shared type declarations/schema stay the same.
If the interface changes, then you already have to update both client and server, so the tiny overhead of maintaining an explicit type schema dwarfed by the amount of effort you spent changing the rest of the code anyway, and more than made up for by the compile-time detection of warnings when you change the interface code for the server, compile, and then get an error that the client no longer compiles.
> The coupling should receive the credit not the type system.
A type system will detect type errors at compile-time. A tightly-coupled system with type coercion and no types will detect errors at run-time, if at all. It's obviously better to detect errors at compile-time. Therefore, even if coupling is correlated with the usefulness of a type system, type systems are still obviously beneficial to include.
Regardless, it doesn't make any sense to talk about "credit" in this case. I think that you misunderstand the purpose (and utility) of type systems, but I'm not sure what to suggest to you so that you can understand.
I enjoy writing code in typed languages. I am in full agreement that they have purpose and utility.
> No, type coercions are bad engineering.
The opposite is true. Your job as a software engineer is to coerce types. I don't mean calling `float64(unsafeString)`. That's certainly type coercion but, as you said, its brittle and probably not the best design.
Consider a database. It stores its data on disk as something (ignore implementation). It loads that data into memory where it is coerced to a type (probably in the C-language). Its filtered, grouped, whatever else. Serialized to something and sent over the wire. Your Python server receives that something and coerces it to a Python type. That Python type is serialized to something and sent over the wire. Your Javascript front-end loads the data and represents it as a Javascript type.
Nothing about this process is bad or ugly or brittle. It would be infinitely worse to maintain the something type across all these different boundaries. Imagine pickling types whenever we want to save something to disk or share it over the network. Imagine being forced to write application code in the same language as your database!
> Type coercions at the interface level are a hack that is not acceptable for anything beyond hobbyist work.
Representing a value in the database as an enum and as its string name in the interchange format is not hobbyist work. I'm certain if you have worked professionally you've used enums and not marshaled their underlying value.
> If the server is changed, the client only needs to change if the interface between the two also changes.
You are advocating for type coercion. The server and client store internal representations and must marshal an interface type to communicate. That's a form of type coercion (I should say "casting" since its explicit but I've mistakenly used coercion so far so we'll roll with it).
---
I think you're too tunnel visioned on the types argument. Types are great. I love them. But coupling your database to your server to your client just to share types between the three is obviously not a good idea. There are greater concerns at play. Extend the argument all the way. Separate your client from your server.
> I enjoy writing code in typed languages. I am in full agreement that they have purpose and utility.
My apologies, that was a bit uncharitable of me.
And, you're right, I didn't quite understand the meaning of "coercion" - I misinterpreted it to mean "implicit coercion". So, my intention was to say that "implicit type coercion is bad engineering" - you're correct in that in general, it's not bad, and necessary.
However, you still don't understand my point, which is that adding types don't introduce any more coupling than what actually had to exist in order to make the program run in the first place.
Let's ignore implicit type coercions, because they are bad engineering, and not relevant to the following point. In a language without implicit type coercions, programs must be well-typed to run correctly. In dynamic languages, even though the code might not contain type annotations, the above principle must still hold. If you pass a string to a function expecting an integer, then your code will break, and all that dynamic typing does is push the error from compile-time to whenever in run-time that you hit that code path.
This is equally true for a client-server interface. If your client and server do not agree on their interface, which includes types (alongside packet header, and field length and order), they will break. If you do not explicitly state what those types are in some formal spec, the types still have to line up in the program! The types are still there, even if you don't explicitly state or check them.
> It would be infinitely worse to maintain the something type across all these different boundaries.
This isn't true; you already maintain types between the boundaries formed between functions in a single program, there are far more of those than inter-program boundaries, and after you set up the tooling for checking network communication schemas, it's only a little more work than maintaining "normal" types between functions.
> Imagine pickling types whenever we want to save something to disk or share it over the network.
I don't understand - "pickling types" is redundant because the pickle format already includes types automatically. Unless you mean building a schema for the pickle and machine-checking that the loading code and the saving code match? In which case, if you're in an engineering context, I absolutely advocate for this, because a mismatch means a runtime error at best, and data loss or corruption at worst. The argument for doing so in a client-server setup is even stronger, however, because data saving and loading code are colocated with each other (making errors easier to manually spot) far more often than sending and receiving code in a client-server codebase.
> Imagine being forced to write application code in the same language as your database!
There's absolutely nothing about type schemas that forces you to use a single language - most schemas are language-independent, like JSON Schema[1] (which is a schema (including types) for JSON data that is in JSON, so you already have a parser for it, and you write it once and then check it everywhere) and ASN-1.
> coupling your database to your server to your client just to share types between the three is obviously not a good idea
The point is that there's no more coupling than what exists in the first place. Programs must be well-typed to run correctly (if there's implicit type coercion, which is bad practice, the program must still be well-typed - you just now automatically insert type-level logic for the coercions) - that means the types are there, even if you don't write them, so the coupling is also there, even if you don't want it.
If your database sends a string to your server when it was expecting an integer, then either your program will crash, or there's implicit coercion - bad practice, but then either the program is well-typed, in which case it's actually technically expecting either a string or an integer (with runtime detection - also bad practice), or the program is not well-typed, in which case you'll get a runtime error.
You're welcome to disagree but I'm having a hard time following the conversation.
My point is "there's no more coupling [from using an explicit shared type schema] than what exists in the first place." for which I provided a logical argument in the comment you replied to.
This was in response to your earlier statement "At the expense of coupling which is not a trivial concern."
Do you have any additional arguments for why adding a type schema introduces additional coupling that were not covered above?
That and a Node/Deno backend. Which is what the OP is talking about.
No, not really. Clients are loosely coupled, but they must comply with a contract.
And guess what: contracts define types, and REST focuses almost exclusively on types.
Under the architecture I describe, no, clients and servers do not couple to one another. The client and server couple to a data interchange format.
> contracts define types
Yes, the interchange format defines the types for the interchange. But a string can be represented as an enumeration or a float or an integer or a boolean. The type of the data is dependent on context.
> REST focuses almost exclusively on types
In a sense yes, but it also focuses on decoupling clients and servers. The types are really more of an implementation detail. The type of interchange can be XML, HTML, JSON, bytes, text, etc. The fields in a JSON document can all be strings for the purposes of interchange but may be parsed to integers and floats for the purposes of rendering the data to the user. The server may parse those fields differently.
Its not relevant to the client or the server how the other chooses to interpret the data. All that matters is that the interchange format is maintained.
Does it type check templates yet?
Webstorm now properly supports template type checking too https://blog.jetbrains.com/webstorm/2021/11/webstorm-2021-3/...
Vue 3 looks a lot better than Vue 2 but honestly it's just playing catch up to React. I don't know why you'd choose it.
React is not the end-all, nor will it ever be, as long as there are interesting new projects coming out, and neither is Vue or Svelte. My website uses React, but personally I would rather use Vue or Svelte in the future.
> Wikipeida chose Vue
Yeah their reasons look very much like dubious attempts to justify the choice someone has already made.
1. You can use it without a build step.
Sure, but only if you're not using Typescript, which would be mad. A build step is a mild inconvenience. Not something that should cause you to choose a worse solution (though they do also use PHP so they're probably used to bad tech).
2. Vue.js may enable us to rely on fewer libraries as dependencies.
Ha! When I added Vue and its required CLI stuff to our package.json it pulled in around 1000 dependencies. React has like 4.
3. The official Vue libraries are evolving in a stable and predictable fashion.
You can still use React classes if you want to. They're not deprecated. It's unlikely they ever will be.
4. Vue.js development is not led by a single corporation whose goals may diverge from those of the WMF.
I mean... come on.
To each their own, but I think life's too short to be adding types to your view logic and your templates. It adds so much complexity for so little gain. Maybe it'll get better at some point where it will change my mind, in particular when using something like Deno.
I think what you are missing is that, if you use TypeScript in Deno, the extension is .ts. What's confusing is the way Node.js+TypeScript does it, which means using TypeScript with .js extensions.
"They" dropped Angular altogether: https://blog.angular.io/finding-a-path-forward-with-angularj...
One solution is to use an import map on the Deno side to map your extensionless imports to the corresponding files, but this only works when you control the Deno command line arguments (so not for libraries you plan to publish for others to use).
It’s unfortunate because, other than this huge problem, Deno is the best TypeScript runtime I’ve found.
I may be nitpicking here, but Deno isn't a typescript runtime, is it? In the usual case, does it not transpile typescript to JavaScript and run the code from there?
Is Node really a JavaScript runtime? V8 converts the JS to an AST. Would that make Node an `AST runtime`?
Why yes, you can run directly Typescript code in Node (well, at least just as direct as Deno, as it transpiles TS to JS) with the likes of ts-node.
One of the first lines in the deno docs is:
> Deno has no "magical" module resolution.
Which, as an implementor of module system rules, seems incredibly far from the truth of the matter (where deno has the most complex resolution rules of any runtime currently in use). I think maybe there were simple goals at the start, but that came crashing against reality and xkcd 927 executed in full force.
We have been adding a Node.js compatibility mode, but I am not sure that qualifies as "_very_ custom module resolution".
Both the triple-slash reference and @deno-types were solutions to problems to not have opaque type resolution with TypeScript. They do not impact the runtime resolution, only the type check resolution. Instead of opaquely searching for these by reading the `package.json` and probing the file system like `tsc`, Deno is explicit.
I would be glad to work with you to explore how we can figure out how to resolve your implementor concerns. The door has been open for a long time, and I have mentioned it in passing to Daniel a couple times. Let me know if you would like to talk.
Then they had "url" imports, but now they're adding npm compatibility. At that point people will just keep publishing on npm, so I don't see why I should go to the trouble of switching to Deno.
- Testing framework
- Linter
- Bundler
- Formatter
It’s like having Cargo or Go’s CLI for JavaScript/TypeScript. It eliminates so much fiddling and breakage, gets everyone in the ecosystem on the same page, etc. Even for a solo project it’s been a dream to use, compared with the hodgepodge of a Node project.
As a frontend dev by day, trying to write services/scripts in Node is constantly frustrating. Simple things like base64 encoding or making http requests have me heading off to the documentation and trying to remember "the Node way".
The other large part for me is the lack of npm. The npm ecosystem is one of my largest sources of daily frustration. I look forward to ESM everywhere.
Now, I see another new app for a different purpose being started and I hoped to push for a modern way of building it, but no they just won't give-up using java and JSF.
Nothing wrong with java, it's just java and jsf crowd is hard to be converted to something else.
I gave up after searching around for a few minutes and learning that for now I'd need to use VS Code to write Deno code, if I want those features.
1) The documentation for the standard APIs is extremely wanting. The main, and weirdest, problem is that it seems almost impossible for search engines to index (or at least DDG). I can search for very very specific things, and still get kicked to the home page and have to manually navigate to the part I’m looking for (and the navigation is also pretty difficult; I often can’t find the thing at all and have to rely completely on editor hover-overs for documentation). It can also be confusing- some things like certain standard APIs appear to have multiple conflicting reference-manuals? And it can be hard to know which one is current or correct. Even getting past all the obfuscation, the docs are just ok. They often leave out deeper details (this last part is less of a problem and more understandable, this being a young project).
2) The VSCode extension still needs work. It’s usable, and better than nothing, and it’s better than it used to be, but (ordered from most to least significant):
- When I open certain files - usually bundles or something; maybe files outside of the project directory? - the language server crashes over and over and over, each time popping the terminal back up to show the output and distracting from what I’m trying to look at. This doesn’t happen with my normal, in-project Deno files at least.
- It doesn’t have auto-import as you’re typing like normal TypeScript does; you can auto-import by clicking the lightbulb, so I assume it’s a relatively short hop to plug that in. Makes a significant difference in flow.
- It chokes on absolute import-paths in Windows. Thinks they’re malformed remote URLs.
- It has caching issues sometimes. I’ll change some type in one file and other files won’t get the updated type until I close and re-open them, or sometimes the whole editor. This is uncommon so it’s not a huge deal.
I list these criticisms because I want to see Deno succeed. Switching from using TypeScript on Node (with the build steps/configuration, ad-hoc testing and linting, and Node’s pathological legacy APIs) to Deno was a huge quality of life improvement, even with all these problems. Brought to its full potential, I think Deno could be a revolution.
Leaving out details, for the most part, is the right approach for now, I think. Only Node/JavaScript veterans should probably be using Deno for the time being. But I definitely hope Deno can eventually take over and make Node obsolete.
> 2) The VSCode extension still needs work. It’s usable, and better than nothing, and it’s better than it used to be, but (ordered from most to least significant)
At this point, I've kind of given up on VS Code language/runtime extensions in general. Virtually none of them work with the slightest variation in toolchain configuration, whether it's C++ or Typescript or even ESLint. You're lucky if they don't slow the heck down over time. Import paths are the worst! Somehow that's something I inevitably run into, again, no matter the language.
I kinda want to blow all this stuff up and start over. Maybe Deno is a part of that equation. haha
Inventing Node before Deno. Creating a compatibility mode in Deno to run Node scripts instead of a tool to port Node scripts to Deno. They even maintain a tool to convert Deno scripts to Node. You really can’t get it more backwards!
I sometimes look at his GitHub issues and PRs and wrong ideas are not rare. Thankfully he assembled a good team that double checks him and catches most of those wrong ideas. But they can only catch so many, and it’s likely more difficult for the executive decisions of the Deno company since money is directly involved like creating a Node compat mode.
The backend market is already leaned toward Go. It's the best language for microservices. We also have WASM entering the scene on the frontend side, which allows mixing other languages, especially Rust. Hell, I heard some people ported a whole C++-based UI engine to make it cross-platform. We're already entering the next generation.