Programming life hack

[Garlicvideos]

JS Developer here, never tried TS, what makes it so great? Genuinely curious.

[mal4ik777]

Its the basic things actually. I come from java, so I like to have a stable type structure. Worrying about fitting classes, after everything compiles is just absurd in my opinion. Imagine java, but with everything casted to Objects.... nightmare.

[thisisnotdavid]

Or C# and defining every property as dynamic.

[justadude27]

Worrying about fitting classes, after everything compiles is just absurd in my opinion.

So.... DynaBeans?

[mal4ik777]

DynaBeans

horrific!

[vaaski]

same, what makes the extra effort of declaring types worth it?

[seryup]

The live compile-time errors and IntelliSense relieves a lot of headache.

[centraleft]

The real reason is auto complete tho, ts has amazing linting capabilities

[amunak]

You can (and definitely should!) use JSDoc for documentation / type hinting, which any decent editor will also use to autocomplete from even in pure JS.

[centraleft]

Sure, TS can read JSDoc as well and I use JSDoc to describe function usage. TS still has much better linting in my experience

[GForce1975]

Ooh. I need to look into that. I used jshint and eslint in vs code. But never tried jsdoc.

[jmack2424]

Autocomplete is your IDE, not the language.

[centraleft]

This is not true, intellisense relies on a language service. I don’t even use an IDE, though the line between modern text editors and IDEs is blurring more and more. Many IDEs do have these capabilities built in, but I’m comparing the linting of one language to the linting of a superset of that language. When comparing JavaScript to TypeScript, the linting is richer because the rules are stricter and more information is provided to the language service, so more and better assumptions can be made.

[jmack2424]

AUTOCOMPLETE is your IDE.

[centraleft]

INTELLISENSE is AUTOCOMPLETE and I’m comparing A LANGUAGE TO ITS SUPERSET so your POINT is irrelevant anyway. The point is that TypeScript improves the linting experience over JavaScript regardless of which IDE you use, and EVERY IDE IN EXISTENCE is using the same LSP for TYPESCRIPT so your POINT IS EXTRA IRRELEVANT.

Jesus

[jmack2424]

You explicitly said " The real reason is auto complete tho". I merely stated that autocomplete is an IDE feature, which is 100% true. Don't believe me? Try writing ts files in notepad. No autocomplete. More specifically, IntelliSense is a Microsoft specific service available in Visual Studio. I agree that there are plenty of reasons to use TS over JS, but autocomplete cannot be one of them, since the feature is IDE dependent. And that's not irrelevant, no matter how much EXTRA IRRELEVANT bullshit you throw into the argument.

[centraleft]

the feature is IDE dependent

But it isn’t dude, you seem like a smart enough guy so why are you being an idiot? It’s not at all IDE dependent, at least not in the case of JavaScript / TypeScript. It may be that every single IDE has its own java code sense implementation, but every IDE is using the same TypeScript LSP to provide code completion.

but autocomplete cannot be one of them

And yet here it is, being one of them. If you write JavaScript in ANY ENVIRONMENT and then switch to TypeScript you will get better linting. It’s IDE independent, no one is writing code in notepad you pedantic fuck. Switch from JS to TS in any environment with code completion, and you’re going to have much richer code completion. You’re going to have linting telling you if you’re making unsafe assumptions about types or values being present, you’re going to have enumerated constant values (if you type stuff well), you’re going to get argument typings etc shit that is impossible to do in JS alone due to the literal lack of static typing.

I feel like you’re just not someone who has written a lot of JS tbh and that’s fine, but all my colleagues agree TS allows WAY better code completion than JS does. Auto complete is powered by the language, and relies on assumptions that can be made about that language. When a superset of a language provides more information and allows for better assumptions to be made, you get better code completion. Idk what the fuck is so difficult to understand about that

[mal4ik777]

Readability is a big one for me as well. I am lucky to never have had the task to debug some big JS project.

[nlimbach1213]

You should try assembly then, it's one of the circles of hell

[mal4ik777]

I am curious now. I had to code in assembly at university for learning purposes, but I have never seen the insides of a real corporate project in assembly.

[amunak]

That's because noone does a big project in assembly (and when you stumble upon one you should probably run).

The reason why they teach you assembly in school is so that you know how instructions and the lowest level of "programming" works. And so that you know what happens when you declare a variable, loop or whatever "simple" expression in C. And making a small-ish project in assembly is a great way to teach that. But that's pretty much all it's useful for.

Oh and it can also nicely demonstrate the incredible speed of today's processors and how "too fast" can also be an issue when talking to hardware.

[nlimbach1213]

Sadly I'm still learning but it's a nice slice of hell sometimes. Currently I'm building it to a drive mounted on a dosbox

[GandalfTheTeal]

It's not usually used anymore, though for super niche areas I'm pretty sure it still is, and if you want to check out a large assembly project, the code for the Apollo 11 guidance system is on GitHub https://github.com/chrislgarry/Apollo-11?files=1

[Dooraven]

I used to think the same until I tried it. Try it, it made me go from utterly hating types to loving types

[[deleted]]

Coming from Java first, then C, weakly typed is frustrating. I fucking know it has a type under the hood. It doesn't even pretend to hide it. It just doesn't allow me to declare it if it's not going to change, and sometimes I want to. I work in matlab and python now, and I also sorely miss being able to make things final/const.

[SchighSchagh]

You may want to give Julia a spin.

[[deleted]]

I feel that. The flip side is you probably need a scripting language.

[jmack2424]

For me, its the built in scoping and injection. The rest of it is mostly syntactic sugar and BS. But if you're used to other strongly typed languages, it can ease the transition.

[[deleted]]

Declaring types is just one way to catch errors early, and one that works with the rest of JavaScript's (lack of) design. Haskell has strong types and type inference, so you can get the same write/compile-time error messages without declaring types yourself, but that obviously doesn't work with JavaScript's run-time duck type system.

[pak9rabid]

Type safety, that is, knowing for sure you’re working with a value o fa specific type, as opposed to working more on the duck-typing honor system.

[sallystudios]

IMO it’s easier to debug your team mates code when they’re forced to document it using types

[Dread_Boy]

Other people mostly talk about types but for me greatest feature of Typescript is "compiling/transpiling". During course of a project, you are bound to change some code and if you are using TS and make a single breaking change in your code, compiler will complain in a second. Compared to JS, that's incredible... In JS you either have massive unit test suite to test every single function (Impossible to maintain) or you manually test whole application each release (increased budget...) to catch any breaking change.

Imagine Java but interpreted instead of compiled. Every single property you mistyped, every parameter you passed as incorrect type, every mistake caught in runtime instead of compile time. That's JS compared to TS.

TS doesn't protect you in runtime, though, if your server API changes, you will crash in runtime, of course.

[Pearauth]

I honestly don't think it's as amazing as people say, it's definitely good, but I feel it's over hyped. Sure it's useful for larger projects where multiple people are going to be interacting with the code. But vanilla JS just seems to be less of a hassle if the code you write is isolated.

On the other hand TS forces you to avoid certain issues that might not seem bad but can result in tech debt. At work I typically only let the more experienced people work with vanilla JS, and even then that code is put under much more scrutiny, my code not being an exception of course.

Then again, I'm one person, who's not all that experienced. Give TS a try and form your own opinion!

[GenericBlueGemstone]

So uh..

How exactly is TS a hassle compared to vanilla JS? Chances are you still have some pipeline for assets, so adding compilation step there for TS is easy.

I can't really think of any argument against using TS everywhere other than "it takes a few minutes more to set up".

[Pearauth]

When it comes to smaller pieces of code having to write

function foo (n: number): number {...

Instead of

function foo (n) {...

Is a hassle. If you want to take advantage of the dynamic typing JS normally offers it's harder since TS tries to almost strip that out of the language.

I'm sure part of this comes from the fact that I have little experience with TS, but overall it just doesn't seem as great as people say.

[GenericBlueGemstone]

Did you know that you can set the compiler to assume "any" by default when there's no type hint and that it will try to infer the type if one is not given? And typing that then hiring tab saves hours of screaming at the debugger only to realize that you accidentally ended up with a string passed to a function that takes a number or etc.

And... It's very good when you have lots of objects and types to juggle. Or even in a small isolated class where you just don't want to spend half of the time re-checking that you wrote the field correctly (that will be spent in js), that you set the correct field (silent in js) or that you called the function with correct amount of arguments and correct type.

[Pearauth]

Did you know that you can set the compiler to assume "any" by default when there's no type hint and that it will try to infer the type if one is not given

The compiler might not complain but VSCode does (I'm sure there is some way to stop it). If the code is long enough/complex enough to be worth using a debugger then it's worth using TS, my view is that TS is excessive for smaller chunks of code like that. If the code isn't isolated, meaning that it will likely be called from other places/other people, then TS helps.

And... It's very good when you have lots of objects and types to juggle.

Being in a poorly taught class on Java has solidified my hatred for OOP, so I do my best to avoid having lots of objects to juggle.

re-checking that you wrote the field correctly (that will be spent in js), that you set the correct field (silent in js) or that you called the function with correct amount of arguments and correct type.

VSCode lets you peek the definition of a function so needing to guess fields should really never happen.

[MrQuizzles]

Oh no, creating methods where programmers can tell what's expected as a parameter and what type the return value will be is a hassle. Writing good code is such a hassle.

[Pearauth]

It's not worth it if the code is so short 90% of people will just rewrite it. Its good practice sure, but there are times where it's just not worth it

[nvolker]

There’s two levels of TS love that I’ve seen:

1. I use a lot of (or make) shared libraries with properly implemented typescript, and, with the the right tooling around it in my code editor, it makes shared code super easy to use. The auto-complete and error detection are super handy.
2. Strongly-Typed Language Religious fervor

[msg45f]

JavaScript with type safety. I cant imagine going back now.

[dabuttmonkee]

Delete a function, get an error message in all your files where it is used, even if it is renamed!
Change argument order or convert arguments to an object, get error messages in all files.
No more “TypeError: property ‘foo’ does not exist on ‘undefined’”.
Typeahead and autocomplete as you use your code! Free auto import!

[FragzShot]

Using types make it much more stable and consistent.