Excuse me but I have it from a very reputable source that the saying goes "fool me once…

Shame on… Shame on you.

Fool me-- can’t get fooled again"

deleted by creator

I dont think it has any place on a developer tool/workplace platform. Algorithmic feeds are the first step towards enshittification. If they had a “trending repos” page, it’d be fine, but they’re hijacking people’s work flows to show (potential) ads.

Ah thank you, that makes more sense.

I can agree with the goal but sadly the corporations have already got their claws deep in the tech stack.

Facebook control React. Google has its hands around Chromium, Android, Go, Angular and I’m sure dozens of others. Then of course Microsoft now own npm, GitHub etc. You’re making your life very difficult if you entirely avoid corporate entities.

If we don’t give corporations credit when they do run projects well then there’s no incentive for them to not go full on capitalist greed and destroy them.

var foo = {};
foo.bar = 42;

Perfectly valid, and extremely commonly used, coding pattern in JavaScript - it’s essentially the normal way to do an associative array or hashmap in JavaScript. It’s also one of the commonly used ways to (poorly) simulate OOP in JavaScript.

In TypeScript, it fails. You can’t treat an object as an arbitrary key/value pair. That’s a good thing… but still, it means TypeScript is not a superset of JavaScript.

AFAIK that source code will be accepted by the TypeScript compiler if the file has a *.js extension, but that’s an ugly workaround and it also means you can’t copy/paste code between files. You have to rewrite the code.

Type annotations. It can be as simple a adding any in front of parameters, but there are other edgecases too, and when you have a really big codebase it can be a pain to convert.

I didn’t say C++ was a superset of C, I said “if I take my c code and add a cpp extension it works”. Believe me, I am painfully aware of the not-a-superset problem between C and C++. My point is Typescript doesn’t even meet the very loose “its practically a superset” relationship that C++ has with C.

Aaand just to top of the cake with some cherry, here’s a blog post from someone who’s been paying a keen eye to what MS has been doing.

https://ghuntley.com/fracture/

I thought the .NET controversy with dotnet watch was many years ago and turns out it was pretty recent.

In any case, and I think I wrote this in my other comment, just because a project is FLOSS, doesn’t mean it’s all fine and dandy. FLOSS is just the means to an end, and while the community attaches a noble motivation behind it, FLOSS is just a method. The article mentioned that FLOSS is being used as a Venus fly trap, and I honestly couldn’t agree more.

Just to play the Devil’s Advocate here.

FLOSS is provably insufficient as a token of certainty for longevity and fairness. Licenses can change — we’ve seen this with MongoDB, and even Terraform. Sure, you can fork them, but who’s to say if the ecosystem will follow suit? Most of the time, the ecosystem doesn’t move to the new FLOSS fork.

And I don’t think C# is a good example. C# runs on .NET, which is Microsoft’s own framework. TS compiles to JS (technically ECMAScript) and runs on V8, both of which aren’t “owned” by Microsoft. There’s ample room for Microsoft to take advantage of the popularity of TS to wedge their influence into the ECMAScript standard and the V8 engine, e.g. by extending TS with features not available or performant in JS, pull themselves ahead of the rest, and become the de facto standard. It’s a common playbook by large tech companies — Amazon takes FOSS projects, modify them, and put them up as services on AWS and eventually gain significant market share and influence; Google is doing something similar with the Web API Standards.

It sounds like to me that you’ve taken your knowledge of your commonly used languages for granted, and assumed a new language would be just as easy. But if you watch a developer who is dipping their toe into that ecosystem for the first time you’ll find them making mistakes and running into footguns you didn’t know were possible.

Regardless of the language, not having a proper guide leaves devs susceptible to the incorrect blogospam that’s out there, where engagement is rewarded over correctness.

Ignore all of the blogospam.

The two things you need to know:

1. C/C++/Java/Go/Python have all gone through changes, growth and churn just like JS.
2. Knowing the history of the ecosystem will go a long way towards helping you. If you understand why things have changed, then you’ll know how to ignore the bad advice out there.

Here’s my shortened version of number 2.

The beginning:

• JS starts as a scripting language embedded into a browser
• Different browsers try to copy each other but put in their own “features” pulling the language in different directions.
• The amorphous blob that is JS starts to congeal and language standards are solidified. This standard is known as ECMAScript (named for legal reasons). ES1 is the first version, followed by ES2 and ES3, each adding useful features.
• ES3 (released in 1999):
  • This is what you could consider the first long term stable baseline widely supported version of the language, where you can make anything you want.
  • Almost everything you can make in future versions of the language can be backported to ES3.
  • If you want to go by analogy, you can think of ES3 as javascript’s C99.

The false start:

• Work starts on ES4 with a massive feature list (including static typing, classes, modules, algebraic data types, generators, embedded xml/xhtml known as JSX/TSX today, etc…). It fails due to political infighting, and for basically being too ambitious in a single version.
  • This sucks up years of progress between released versions.
  • This version is commonly seen as being poisoned by 90’s/00’s Micro$oft and the dark ages of Internet Explorer
  • But the spirit of ES4 was released spread out over future versions anyway.

The resumption:

• The v8 JS engine is released, making JS really fast and worth programming in. This is used in Chrome and Node.
• ES5 (released in 2009):
  • Adds native json support, reflection, and a strict mode to avoid some footguns with ES3
  • Think of this as C11
  • Some developers being experimenting with a more consise syntax in CoffeeScript that compiles down to ES5.
• 2012: Typescript is released adding an optional and gradual typing system to JS (inspired by C# and ES4) designed for both Humans and Computers.
  • In effect, this brings IDE-style support for JS
• ES6 (released in 2015):
  • With the lessons learned from CoffeeScript, a whole bunch of syntactical sugar is added to make the language more pleasant to write in.
  • With the lessons learned from community made modules, an official module spec is released and added to the language.
    • Known as ESM (EcmaScript Modules)
    • The community starts moving away from unofficial modules (CJS, AMD, UMD)
  • Babel is created to allow any developer to create and share their their own language extensions.
    • The faster feedback cycle from Babel allows for smaller and more frequent language updates.
    • Javascript moves to a yearly release cycle and ES6 is renamed ES2015
• ES2016
  • Adds block scoping as an alternative to hoisting
• ES2017
  • Adds async/await/Promise() syntax sugaring, to make asynchronous programming easier
• ES2018
  • Adds ... (rest/spread operator) syntax sugaring, to make destructuring and variadic functions easier
  • Ryan Dhal (creator of Node) releases his famous 10 Things I Regret About Node.js talk. Announces his intention to create a “modern reset” of Node known as Deno.
• ES2019
  • Minor changes
  • Deno is released
• ES2020
  • Adds ?? Nullish coalescing operator syntax sugaring
• ES2021
  • Adds ??=/&&=/||= Logical assignment syntax sugaring
• ES2022
  • Adds top level await, making asynchronous programming easier
  • Adds private field syntax sugaring
• ES2023
  • Minor changes

The current state of things

• Language-wise

  • Javascript has added a whole bunch of syntactical sugar since 2009 making it really pleasant to code in.
  • Typescript adds some really nice IDE support to Javascript and the vast majority of all libraries and frameworks are written in it giving that IDE support to Javascript developers.
  • Babel allows developers to create their own language extensions, which are frequently put forwards at for other developers to give feedback on. Useful proposals are added to the language on a yearly basis.

• Runtime-wise

  • Node is considered the older slow-moving most-stable release of running JS outside of the browser
    • Think Debian
  • Deno is considered the friendly Node, coming with all the tools a developer needs (linter, bundler, tester, ts support, etc…). In the last 5 years it has reached almost complete feature parity and compatibility with Node.
    • Think Ubuntu
  • Bun is a brand new kid on the block prioritising speed over compatibility.
    • Think nightly linux

• Standard workflow

  • Write in typescript
  • Let your editor check your typescript while you’re typing live so you don’t need to go through a compile cycle
  • Let your project’s stack compile your typescript for you.
    • If you’re writing a new project from scratch, Deno will run typescript for you.
    • If you want to build a new stack from scratch with no assistance, use the typescript project itself to check and compile your code into js, or use esbuild to strip out the typescript types to turn your typescript into js. (most developers elect to strip types since your editor/ide should be live checking your typescript anyway allowing you to skip a redundant compile check cycle)
    • If you’re using an existing stack, your build tools will compile/strip-out typescript for you.

• Tooling wise

  • Most projects use Vite / rollup / and other “zero-config” tools to build and bundle their applications. Some older projects still use Webpack (which does the same thing, but with a more complicated config file).
  • Everyone uses ESM modules now, almost no one uses the older modules.

For your simple fibonacci example:

1. Create your fibonacci module that exports your fibonacci function
2. Import module
3. Call function in module
4. Pick your endpoint:

• Browser endpoint: Output result in console.log() and see result in browser’s console.
• Server-side endpoint: Output result in Deno.serve() and see result in network requests/responses
• CLI endpoint: Output result in console.log() and see result in terminal