Design Meeting Notes, 11/9/2022

Post-Modules Follow-up

Semantic Lints

#51456

• The last semantic rules we have are few.
• Getting rid of all semantic rules would speed our lint time up a lot.
• No unnecessary assertions takes up a decent amount of time - but it seems arguably good to have.
  • Getting rid of assertions over time helps improve quality of the code.
  • Switching to rely on narrowing is better because assertions left alone can get stale. Then future changes to a type may be masked by the stale assertion.
• Maybe we should have “no unnecessary assertions” in the compiler itself?
• What does it mean to be “unnecessary”?
  • Lint rule says “textually identical”.
  • User could be thinking “up-casts”.
  • We could make it better with our view of structurally identical.
    • Could see this as a --strict rule; however, as we start to think about “what is slow to run”, it is hard to imagine more modes where we say “do more checking for the 99% of cases where this will succeed”.
    • Though identity is usually pretty fast.
• Why is this so important?
  • Linting in the editor is slow with semantic rules.
• Conclusion?
  • Revisit.

Remove ts.Map and ts.Set

#51439

• Objections?
  • None.

Bundle Splitting our Executables

#51440

• tsc.js and tsserver.js are not usefully importable - can switch those into ESM if we want!
• Why?
  • esbuild (our new bundler) makes it easy to do bundle splitting if your output target is ESM.
• If we ship tsc.js and tsserver.js as CJS wrappers that invoke import("tsc.mjs") and import("tsserver.mjs"), both tsc.mjs and tsserver.mjs can share lots of the same guts.
• Shaves off 7MB from our package size.
• Feels like it may be difficult to work with over time, has caveats.
• Have to drop Node 10 support.
• Feels like an “uncomfortable yes”

Diagnosing Expensive Types

• People often ask how to “debug” types - especially types that are expensive.
• There’s types that “pull” on a thread that goes deep in its own self-instantiation, and then there’s types that are kind of “executable”, that cause a lot of work to be done.
• Today we have instantiation limiters
  • Depth limiters - how deep instantiation is going (kind of like a call stack)
  • Type creation limiters - how many instantiations of any type has occurred during instantiations.
• These are hard limits - “blunt force instruments” - that cause an error; but we don’t tell tell you about types that get close to those limits.
• What if we had --typeDiagnostics that could provide a table of the most expensive types?

[RyanCavanaugh]

refactoring away from classes into functions that get composed out of functions directly action able?

The type checker doesn’t use classes.

the usage of Readable Writable stream for the processing?

What does this even mean? A stream of what ? Which processing step? You can’t just say “Use streams” at a project based on a global analysis model and expect that to be understood as a coherent proposal.

I just want to state this plainly so there is no confusion: If you don’t stop posting comments which don’t make any apparent sense (I’m setting a very low bar here; you have enough technical sense to understand what this means), you’ll be blocked from the repo, because it’s derailing too many conversations and creating too much noise.

[lemanschik]

@DanielRosenwasser was

• refactoring away from classes into functions that get composed out of functions directly action able?
• the usage of Readable Writable stream for the processing?

i had also no better place to bring that up as the issue tracker in fact that is the most best place to put that up when you iterate on that. At last that is my opinion but i get the pattern. So your development flow is more important then the overall result correct? I mean if you would design your code more simple you would not even need this iteration styles and guard rails development with the test stack. If you guess posting here is fun for me that is not the case.

i do it because it is needed to not waist years and also not waist my money.

the fact that i popup all that issues should also indicate that there is something inherently wrong i am one of the biggest brains in terms of Computing that exists on earth and is still alive. I have better things to do then fixing other people’s code. So i try to tackle the issue at the core it is education out of my view and that is not your fault your only fault is when you ignore this facts now. I am that kind of person that can easy charge up to 3000 per hour that is possible because i get payed based on value not on time…

and as you maybe see i try to improve the language and wording incremental. And i hope that i soon as sayed come up with some better communication formats. But at present this is what we both got today.

the post are also only as noisy because you give no constructive feedback other then change wording change information format. Change PR style. All this does not solve anything. It is not Productive.

i even try to compress the reasoning as much as possible to make it more simple to think about that. Maybe i compress to much i do not see the direct failure.

A answer like frank maybe your correct you did 30 years of research into fundamentals and your language implementer you implement nativ code into v8 and design overall chromium engineering processes. would help a little bit. Then you start simply experimenting via applying that refactoring to small parts of the code base and then directly feel that you did the right thing. I understand VM’s and the V8 Engine including the details.

All in your team will see the results it will incremental reduce the amount of chor commits to near zero as your fundamentals will not change your a compiler.

Streams are by the way simple forms of Iterators Generators so they represent the concepts of a Observable including locking so they abstract the notion of time. It simply gets done when it should get done. Refactoring to streams would mean turn all parser methods into independent modules or functions and then start connecting them via event based streams that you can compose via a chain i will supply a final pr in some month so you can simply see the result and call it day. so it means drop everything that is not a const or function also the interfaces and all that namespaces

classes are in fact only pure namespaces.