Skip to content

Latest commit

 

History

History
59 lines (45 loc) · 4.88 KB

TAGS.md

File metadata and controls

59 lines (45 loc) · 4.88 KB
Raw

Tags

This document aims to provide reasoning why config.json contains the "tags" it contains.

It uses as a basis the JavaScript's TAGS.md because anything that JavaScript does can be done with TypeScript, being a transpiled language, and adds/modifies with the perks TypeScript brings on top of it.

Paradigms

  • paradigm/declarative: mostly popularised by libraries and frameworks such as React, Vue, etc.
  • paradigm/functional: there is a lot of support for functional programming, including various defactor libraries in the ecosystem providing functional programming patterns.
  • paradigm/imperative: It retains JavaScript's script and DOM's manipulation imperative programming, but the language design doesn't encourage it.
  • paradigm/logic: whilst it is possible to write DSL or patterns that' allow for logic-based programming, JavaScript doesn't inherently support it.
  • paradigm/object_oriented: becomes a main feature of the language compared to JavaScript, along with static type checking and a rich type system.

Typing

  • typing/static: Will check types at compile time for any part of the code which has its types stated.
  • typing/dynamic: At runtime all TypeScript's type information is stripped. Runtime type checking can also be manually achieved, as well.
  • typing/strong: TypeScript adds a rich type system, that is checked at compile time if used.
  • typing/weak: TypeScript allows for explicit (strong) typing, inferred (weak) typing, deferred (computed / conditional) typing, opt-out (using any) of typing, and forced run-time (using unknown) typing.

Execution mode

  • execution_mode/compiled: TypeScript transpilation (transpilation via tsc, or stripping types and then compiling using @babel/preset-typescript) compiles the code to a certain version of JavaScript. This includes in-memory compilation using tools such as ts-node, however due to the in-line nature and REPL like support, it might be considered interpreted.
  • execution_mode/interpreted: TypeScript can be interpreted Just-In-Time by stripping types, for example using @babel/preset-typescript.

Platform

  • platform/windows: popularised by Electron and Node
  • platform/mac: popularised by Electron and Node
  • platform/linux: popularised by Electron and Node
  • platform/ios: popularised by PhoneGap/Cordova, Ionic, React-Native
  • platform/android: popularised by PhoneGap/Cordova, Ionic, React-Native
  • platform/web: used in frontend frameworks like Angular

Runtime

  • runtime/standalone_executable: it doesn't. Any executable that exists packages Node, or requires Node or a Browser.
  • runtime/language_specific: it runs on Node
  • runtime/clr: it doesn't
  • runtime/jvm: it doesn't
  • runtime/beam: it doesn't
  • runtime/wasmtime: Just like JavaScript, it doesn't natively, but JavaScript can compile to WASM, and thus then run on wastime. It's a bit of a cheat, but probably what people will search for.

Used for

  • used_for/artificial_intelligence: popularised by TensorFlow
  • used_for/backends: popularised by Express
  • used_for/cross_platform_development: popularised by PhoneGap/Cordova, Ionic, React-Native, Electron and more
  • used_for/embedded_systems: It's possible to run the transpiled JavaScript on microcontrollers and IoT platforms, but the low-end nature makes it not a viable, professional, solution. Therefore this is not included.
  • used_for/financial_systems: Although it improves in the type safeness department, TypeScript being still JavaScript makes it too slow for fintech.
  • used_for/frontends: Most TypeScript usage is with Frontend frameworks.
  • used_for/games: probably one of the most popular replacements for browser-based games.
  • used_for/guis: same reason as frontends, which is more and more interesting as libraries such as React can now also render to less common/expected displays, such as terminals (and thus be used to build GUIs), not requiring CSS or other ways to provide styling.
  • used_for/mobile: yep, see platform
  • used_for/robotics: it's possible. Things like Johnny-Five help a lot. However, it's not a go to language to provide robotics programming, so it's not included.
  • used_for/scientific_calculations: possible, and not uncommon especially for visualisation (for example d3), but not a go to language to do scientific calculations, so it's not included.
  • used_for/scripts: You could still transpile your TypeScript files, but is usually not worth the hassle, so is not used for scripting at all compared to JavaScript
  • used_for/web_development: yes