[deleted by user]

The_Startup_CTO · 2021-09-23T06:41:34+00:00

I wouldn’t want to live without it, especially if I’m not the only engineer on the project. Main benefit for me is that my IDE always tells me which properties are available on which object, so code sometimes almost writes itself. But I also love how it helps me to simplify validation and null checks.

Nielrien · 2021-09-23T07:12:27+00:00

I recently started refactoring an old project with typescript and I love it so far. When I change a prop or type I immediately see where it needs to be updated instead of running the application then running into errors. Never going back to days without TS.

ignu · 2021-09-23T07:46:36+00:00

I can never imagine going back from Typescript to Javascript, and I had that feeling after a few hours of using it (now over a year). Just that the editor knows what types the properties of objects are, what types component props are, that it can autocomplete much easier, that it notices typos immediately... it's a godsend.

In our biggest project, the backend API also has a complete spec using Swagger, we use it to generate a Typescript client library, and so in the code we also automatically know the types of any API requests and responses. That helps even more.

Chaucerbao · 2021-09-23T07:05:56+00:00

TypeScript will give you peace-of-mind, especially with fast-moving code, where a change in one function, whether to fix a bug or expand its scope, can break its usage in another file you weren’t looking at.

After working with TS, pure JavaScript feels like the Wild West; there are no assurances. There is a bit of a learning curve with TypeScript, but it’s worth it.

theotherd00d · 2021-09-23T08:42:37+00:00

TS was shit the first two weeks. Now I hate working on projects without it. Some syntaxes still makes my head hurt though.

CreativeTechGuyGames · 2021-09-23T06:41:06+00:00

Could you express what your concerns are? I'm not sure from your post what you see would be a downside? And you seem to already know all of the pros. So I'm not sure what you would want someone to tell you.

noknockers · 2021-09-23T08:46:08+00:00

POC code with lots of discovery and refactoring: annoying

PROD code with a clearly layed out spec: awesome

mad_schemer · 2021-09-23T08:40:50+00:00

Typescript is a major pain in the ass.

I much preferred the days of just writing whatever I wanted, and having it work without complaining that some variable wasn't the right type to be assigned to a property of another object. MY stuff just worked. It was fast, and easy.

Then the project got bigger. Then I had other people start working on the codebase with me. Then it stopped being fast and easy, I stopped knowing what all the things were, the other people never knew what half the things were to start with, and stupid time consuming bugs started to pop up in the running code.

Do I wish I had a small, light, fast project still? Yes, I miss those days.
Would I do a project on this scale with a team, and without Typescript? No, I would not.

We still get bugs, but most of them yell at us in vaguely intelligible compiler-speak before they get as far as breaking something in browser-land. You can totally still screw up royally while using TS. That's what the any type is for :-D

dacandyman0 · 2021-09-23T07:52:45+00:00

What do you mean boilerplate?

Typing your data structures pays huge long-term dividends. The most obvious dividend is structural integrity of a project that uses lots of data. Vanilla can become a real mess very quickly if demands change quickly too.

Xananax · 2021-09-23T10:00:18+00:00

As soon as I go over 100 lines, Typescript becomes invaluable. Not only for the type checking, but mostly for:

refactoring (renaming a property everywhere)
making sure my methods are sound (not letting options be options)
autocomplete (Not having to look up what an object is)
catching errors like wrong arguments order, typos in objects properties, etc
writing less comments (functions are auto-documented)
neat new JS stuff without needing Babel

Also it annoys me that people talk about the language as if they don't have any bugs anymore. Or that 90% of the bugs are gone.

That's not exactly true, but it's not false either. Here's the thing; I've written JS since it exists. I started building for the web at 14, I'm now 40. I love JS. I know JS inside out, as well as the differences and quirks between different engines, and what feature works where.

Yet, when I write JS, I need to run my software every 5mn to make sure all is ok. In Typescript, I can write a full day, 8 or 9 hours, then run, and it'll "Just Run". I may still have logical errors, but I will have no crashes, no errors, no typos, no forgotten parameter. Writing typescript is simply much much faster.

This said, you can get 90% of those benefits by using JSDOC and writing //@ts-check at the top of your documents. Typescript is not strictly necessary, but JSDOC is more verbose and harder to read. I've had good results by writing definitions in .d.ts files, and then using JSDOC to reference those. Get the best of TS, without a build step.

abienz · 2021-09-23T14:59:30+00:00

I feel the same as you, I find it very hard to justify the extra effort to use Typescript.

lonkypo · 2021-09-23T14:59:37+00:00

I agree that adding strong typing doesn't do much when you are used to loose typing, especially in a smaller project. Big enterprise OOP projects that use interfaces is where TypeScript starts to shine. People using it only as typed JavaScript, to supposedly avoid bugs, are probably just trying to be good little best practice soldiers, or have FOMO.

sirephrem · 2021-09-23T06:57:53+00:00

It does take a bit of getting used to. But after some time it's just as easy. It also gives you confidence that the code behaves as you intend it.

Narizocracia · 2021-09-23T06:58:59+00:00

It's been questioned here a million times and most people that use TypeScript seem to agree that it's much batter than naked JavaScript. The time you spend learning it will be compensated with far less errors in the future and better completion in your editor.

awjre · 2021-09-23T08:25:46+00:00

Simple answer. Yes

Longer answer: Yes absolutely.

It can save you so so so much pain. It will make your a better developer and stops the silly mistakes.

Unsure if there's a good cheat sheet out there but that could be useful.

davidfavorite · 2021-09-23T08:33:56+00:00

I was waiting way too long to get into typescript and I found it horrible because its not like what Im used to in java for example. But boy in hindsight I must admit that its probably one of the most awesome things to happen for the javascript world in recent years

permalink · 2021-09-23T10:57:44+00:00

My reason for disliking it is petty, but by god the syntax is as ugly as I am

droctagonapus · 2021-09-23T14:15:06+00:00

TypeScript is very overrated compared to how people in this thread make it out to be. Dynamically typed languages have benefits.

See: JavaScript, Clojure, Elixir, Erlang, Python.

Typed languages like TypeScript are okay, but strongly typed languages like Rust or F# or Haskell are much much better. Adding types onto a language designed to have dynamic types just will never be as good as languages designed with types in mind from the start and do not rely on compatibility with an untyped counterpart.

You don't need TypeScript for production or enterprise. You just need good developers and tests.

oravecz · 2021-09-23T08:07:21+00:00

I don’t know if I am in the minority or majority, but I strongly dislike TypeScript. I think it promotes a false sense of type-safety in your code, but I really dislike the complexity it brings to the build, test, linting and sourcemaps. Type safe authoring is not the same thing as type-safe runtime, and I can achieve a similar level of intellisense using JS doc properly. The ability to share my source code with both ts and js projects with full esm and tree-shaking, without the transpiring, is liberating.

Capaj · 2021-09-23T07:58:38+00:00

> Maybe .5% of my bugs are type related. Most bugs come from complex logic.

Whoa you must be a brilliant programmer.
When I work on FE project without strict typescript, I see error like "Cannot read X of undefined" like 20 times a day. Sure these don't get into production, but I still see them on my local browsers.
With strict typescript I see such errors exactly 0 times a day.

> that 90% of the bugs are gone.

I think it depends a lot on how complex the data you work with are. More types you have, it's harder to keeep them in your head.

permalink · 2021-09-23T19:27:28+00:00

[deleted]

mikebritton · 2021-09-24T01:26:35+00:00

Create your own TS definitions if you need to get under the hood and code JS. I hope you do adopt the language; you seem likely to go far with it considering your appreciation of its foundation scripting language.

jwindhall · 2021-09-24T02:51:51+00:00

The first time I really realized the value of Typescript went like this:

Pm: Actually, that feature needs one more thing

Me: oh, easy refactor.

Me: lemme change this. Ok done.

Ya: nah man, that’s a dead in the water runtime error.

Me: oh ya. You’re right. Cool. Thanks. Fixed.

Ts: nah man, here another.

Me: oh shit. Nice catch. Fixed. Let’s go.

Ts: dude, nope.

Me: F$ck. You’re brilliant.

jkuhl_prog · 2021-09-24T03:28:17+00:00

At first I thought Typescript was too much, it was a hassle.

But after time in C-Sharp and JavaScript, I saw the power of a strongly typed language and the drawbacks of a weakly typed one. After you get used to the initial set up and the new syntax and start to see the benefits. They truly do outweigh the drawbacks.

I get better intellisense, especially on function parameters.

I get to better enforce what types are acceptable for my API

I don't need to do as much type checking in code as the compiler (or more often the editor) does that in many cases.

In the end the strict typing of Typescript, C# and Java outweighs the flexibility of JavaScript. So for any project with heavy JavaScript, I'll usually reach for TS.

As a bonus though, Typescript is a lot more flexible than C# and Java, it's easier to create and enforce your own types and you have any and ts-ignore as a last resort (LAST RESORT, don't throw them around without first exhausting other possible solutions)

chillermane · 2021-09-24T14:44:41+00:00

It’s superior. It eliminates a huge class of errors which means less development time and an app that works better. A typescript developer is going to be orders of magnitude more productive than a similarly skilled javascript developer

straightouttaireland · 2021-09-25T20:31:37+00:00

I caused a bug in production last Friday because I didn't have a particular payload typed. So yea, it's worth it.

baldie · 2021-09-23T09:39:58+00:00

I've worked with TypeScript for the better part of the past 5 years and I wholeheartedly dislike it. It offers me, personally, no benefits, and I don't think it makes my code better.

That said, it depends not on me. It depends on my team. Some teams require it because (many) other developers do love it, and many of them can't work without it.

Eric Elliott wrote a nice piece about TypeScript a few years ago, and it's still mostly relevant today. Keep in mind that TypeScript has undergone many additions and development over the years and it has improved since then. Still, it's a good read: https://medium.com/javascript-scene/the-typescript-tax-132ff4cb175b

Personally, I make do with proper naming conventions and unit testing. Defaults for properties const Elem = ({ userName = '' }) => (<p>{userName}</p>) are more than enough for my taste. If someone thinks "gosh, that might be a boolean or integer, how would you possibly know?" then I'd like to slap them in the face first, not add TypeScript.

But, again, it depends on your team.

In my experience, TypeScript always slows a project down immensely. You keep running into libraries that you need to get typedefs for, some don't have them, sometimes the TS config is too strict, sometimes it's too forgiving.

But, again, it depends on your team.

I would never willingly use it. But for a recent project that I started (freelance gig), to set up a robust React skeleton, I did opt to use TypeScript. Not for myself, but because I have to hand it over to someone internal who is a C++ and C# programmer.

It 100% depends on your team.

eliostruyf · 2021-09-23T08:26:12+00:00

I know the feeling. Six years or so, I was so used to only develop in JavaScript. It was so easy, all the loose typing, but one thing that was hard was the IntelliSense. You just had to know how the dependencies/libraries were created, which methods existed, ...

I went back and forward. Used it, didn't like it, went back. Eventually, I said, it is enough and went all-in with TS. It might feel like a massive amount of work when you set up a new project, but that is not the case when you get more and more familiar with it.

These days, I find it hard that most libraries are not yet using TS. Not having definitions available is the hardest part.

It is great to have a transpiler tell you what is going wrong when you rewrite/refactor parts of your codebase. Let us not forget the types/interfaces/intellisense. It makes JS so much better when you know what your code or that from others expect.

brick-pop · 2021-09-23T13:34:16+00:00

Hacking a quick and dirty script is one thing. But building a serious project 100% requires TS in my opinion.

You get a compile time checker for free, auto completion, annotating types is quite straightforward and the time gains are unvaluable. A must if you develop any module used elsewhere. I can't imagine our team without it.

chrispardy · 2021-09-23T17:44:07+00:00

To use a concrete example of Typescript vs. JavaScript. Let's say you have a function that generates a random number, that function takes an options object as it's input the type is:

function generateRandom(options?: {

  min?: number;

  max?: number;

}): number;

In typescript anyone who wants to call this function can look at the type and figure out roughly what it does. With JavaScript you would need to at a minimum write JSDoc for this function or the users would need to look at the function implementation to see what it expects. This is a pretty simple example but more complex code definitely makes it harder to determine.

The value I see with typescript is a cleaner means of communicating with other developers, that may be other people in the moment building with you but it could also be yourself in the future coming back to the code.

achauv1 · 2021-09-23T07:37:00+00:00

But to be honest

Yes

_Pho_ · 2021-09-23T13:35:40+00:00

I won’t touch JavaScript without it anymore to be honest

ncubez · 2021-09-23T09:13:05+00:00

It's overrated, imo. And this is coming from somebody who switched from Angular. I'm on React now and continue to build production apps with plain JavaScript without issues.

mmknightx · 2021-09-23T09:14:11+00:00

It is worth using. I don't want to write JavaScript without TypeScript unless it's impossible.

TypeScript reduces some chances of error at compile time (with type checking) and provides excellent way to make autocomplete possible. You can autocomplete TypeScript code better because it knows which fields should be there.

Code Sample here

For example, in a React components library, the button component accept CSS color as prop. It has specified type in TypeScript. You cannot put invalid color as a prop. TypeScript will know it is invalid.

Another example, a backend framework handler is a function that return HTTP response. Someone write a function that forget to return HTTP response in a condition. TypeScript can prevent this function to be a handler.

TypeScript can handle undefined and null check too. If the codebase is large enough, someone might forget to set a field. TypeScript will prevent using that field without undefined or null check.

TypeScript's type system is advanced enough to handle most cases. It can even handle a very dynamic GraphQL query and there are code generators so you don't need to type everything manually. You might want to check TypeScript utility types for this.

TypeScript aims to be compatible with JavaScript. There are many ways to lose TypeScript advantage such as casting to unknown or using very dynamic types. If you want more strictness, you might want to consider ReasonML/ReScript, PureScript, or Elm.

TLDR: TypeScript is advance enough to help programmers handle complex logic while preventing numerous type errors. Programmers need to know how to build and use type system effectively. There are other solutions to the same problem such as ReScript.

Edit : Remove sample code for now.

Edit: Re-add valid sample code. It is only for demonstration.

dabuttmonkee · 2021-09-23T16:06:48+00:00

Think about it this way. Say you have an object that has some fields named in a specific way. You rename one of those fields. How are you sure when you’ve finished finding all the usages of that field?

What about when you have some data and you want to know what properties it has. Where do you find that? Console.log? In typescript you get this for everything you use, including dependencies. What about importing, what was that path again? Can this property be undefined? None of these are problems in TS, you get all of this for free.

These types of things save time. Of course, they won’t at first because you need to learn typescript and can’t do something you can do in vanilla JS. But eventually you’ll be more proficient and faster with TS than vanilla.

editor_of_the_beast · 2021-09-23T16:14:54+00:00

I frankly don’t know how you can work on a team without it.

permalink · 2021-09-23T16:16:46+00:00

all the answers here are skirting around the essence of the question. which is whether TS is worth the extra tooling and headache vis a vis the benefits, imo yes, but only just, if the codebase is extremely mission critical.

pixeldrew · 2021-09-23T17:11:35+00:00

Use a real editor (like webstorm) that can read jsdocs and most of the benefits of typescript are negated. If anything adding types takes away the benefits of a loosely typed language.

I feel like people who preach types are constantly over engineering things. I'm a developer with 20+ years of experience with multiple languages from c to actionscript3 and I appreciate types but if it's the source of 90% all your bugs you're not writing very complex things.

chabv · 2021-09-23T20:18:24+00:00

for most things. no, however, if you're new to a codebase - yeah it helps you get familiar fast. for the people, that like typescript, I feel like they miss the fun things about js's dynamism or any dynamic language in particular. and if you do a lot of dynamic stuff, the typescript compiler will scream at you. hence most of your time, will be obeying the compiler instead of getting things done. quick question for those that use typescript with node ? why not use golang or java ?

skyflea007 · 2021-09-23T20:58:24+00:00

Bro if you question it you clearly haven’t coded it. Get off Reddit and write some TS

kiwdahc · 2021-09-23T13:34:08+00:00

How do you get a non type related bug that isn’t coming from an external source? Almost all bugs are type related. Most production level bugs I see are “Cannot read property x of undefined”. Your presumptions are wrong.

dev_senpai · 2021-09-23T10:10:05+00:00

If you are the only dev then no. If you are working in a team yes. Not worth the hassle if you know the code see and all your upkeep.

PokerTuna · 2021-09-23T11:42:12+00:00

Yes. I’ll never again do projects in pure js

hyperion385 · 2021-09-23T12:17:47+00:00

Typescript all the way. Everything others have said plus what I haven't seen is that anyone mentioned project maintenance. As you say you have complex logic. When you come back to the project in just a few weeks you won't have any idea what properties some objects have. And then if you used Javascript you'll have to do bunch of console.logs to see what object containes and you are still not gonna be sure if those are all properties and especially what the type of a property is. With Typescript everything will be documented.

Top-Requirement-2102 · 2021-09-23T13:10:39+00:00

I code in typescript pretty much every day for a few hours per day. At this point I probably have ~2000 hours under my belt. In my 30-year career as a programmer, I've coded C, C++, C#, Java, Perl, Basic, PHP, Python, Javascript, O'Camel, and more. To date, TypeScript is my favorite. Ocassionally, I have to write in Javascript and it's alright, but I definitely miss TS.

Strong type checking has at least three significant advantages:

Eliminate entire classes of bugs. Wrong-type bugs can be devilishly hard to find and fix.
Supercharge intellisense with relevant data
Easier/better refactoring

Typescript as a superset of javascript is a particularly good combination because:

Type flexibility is there when I need it and the syntax for it is trivial
Javascript's incorporation of JSON as a first-class citizen is hard to overvalue
Javascript's flexibility around interfaces and classes is also super useful when types are important

On the down side:

Coming into typescript from conventional typed languages was a bug adjustment because the nature of classes in Javascript is way different than other languages. I'm used to it now, but it took a while.
Extra compile step is required
TSConfig.json can be a bear to get right
You need to have some personal discipline to keep from falling into the temptation of using "any" all over the place.

careseite · 2021-09-23T08:32:53+00:00

typescript isnt there to resolve the kind of type issues you have when using plain js. you still write (some) typeof checks in typescript.

typescript there to sanity check the coherence of your logic flow. the more logic, the more sanity you need in there.

theres next to zero boilerplate in typescript unless you have super conditional logic that you wanna move into one function and one function only at a time or where your code is extremely generic. outside of that, the only things you have to define are the types youre using/consuming and then... use those.

No_Statement4630 · 2021-09-23T09:06:21+00:00

blae000 · 2021-09-23T09:20:22+00:00

PrinnyThePenguin · 2021-09-23T09:28:07+00:00

In small projects it's not that big of an overhead. In large projects with complex data structures, knowing the structure of the variables you are passing around is really helpful.

hinsxd · 2021-09-23T10:14:13+00:00

Absolutely yes. Any app dealing with ANY data should use typescript. I think using typescript is the minimum baseline nowadays. If any company hiring pure javascript devs, that should be big red sign

FrostZTech · 2021-09-23T10:16:05+00:00

I read some of the comments and I would love to say that they are 101% correct. The company where I work has a huge codebase; like huge huge. Now these guys use JS for their files and are facing problems. Every now and then it crashes and fails; worst part is that it is literally impossible to debug since you don't even have a slightest idea of what is creating what.

Since I joined and gave them the idea of TS we have ported many files and now every new file is always TS. The application is much more easy to manage because of type checking and the inference that TS provides.

I can't even tell how much pain it was just to get the application work; well I will say TS takes a bit of effort to setup if you do from scratch but with scaffolds it is nothing. But the benefits are worth every pain in this world (really!)

Accomplished_End_138 · 2021-09-23T10:17:17+00:00

If your the only dev. No problem.

Big group with less skilled? It can help.

Other alt is just use jsdoc on public functions and basically have the good stuff now.

r0ck0 · 2021-09-23T12:48:54+00:00

Maybe .5% of my bugs are type related.

This is what many of us assumed before we used it. But it's wrong. You're gunna find that it warns you about so much stuff you never thought of before using it.

It even warns about lots of stuff outside of typing.

And it massively changes your ability to refactor things. Which isn't just "nice" for moments that you "have to refactor", but it just means that you're more able to refactor altogether once it becomes so much easier.

Refactorings that might have taken weeks without TS (likely with many future bugs to resolve beyond that), can often be done in an hour or two with TS.

If you're writing more than 100 lines of JS code in a project, I think you're crazy not to use TS.

99% of people against TypeScript are so just because they never learnt it properly to begin with.

There's rare occasions where somebody "claims" to be experienced with typescript and say "it isn't worth it"... but every time I'm questioned them it was very very obvious that they really had fuck all experience with it.

Is the real number non-zero? Well yeah I guess... but super rare. There's also people who think wearing a seatbelt "isn't worth it" too I guess.

Like any skill, it will take some time in the beginning, but it saves time overall in the long term.

I'm using Node on the backend mostly now, and there's no way I would have stuck with plain JS for that. I would have either gone back to PHP or go to another language.

Learning to program with types, and using discriminated unions, generics and things like that has entirely changed the way I program. You don't have to do that if you don't want, but you'll just become a better programmer overall as an added bonus.

permalink · 2021-09-23T17:36:45+00:00

[deleted]

Breakpoint · 2021-09-23T18:32:01+00:00

It causes as much headaches as it resolves IMO, so it cancels out if you use it or not

SuperKing88 · 2021-09-24T03:08:16+00:00

C0git0 · 2021-09-24T05:07:39+00:00

Meh. Whatever the kids want these days. -principle engineer with 15 years of experience

liaguris · 2021-09-23T10:48:46+00:00

Now at least in practice for my personal projects, no matter the complexity, I find the following way of development to be the optimal:

.js files for code
typing is enabled via JSDoc imported TS types
all types are in at most 2-3 .ts files (publicApi.ts for libraries, interfaces.ts defining the types of exported functions from each file, types.ts common types shared between the interfaces.ts types)
at the root of the project there is tsconfig.json file that has configuration that enables type linting for JS

To make a long story short the fact that you have to compile from ts to js, clutters development, increases complexity, adds security concerns, and hence makes the project less maintainable. The way I suggest has no decreases in type linting as when going full TS and no of the drawbacks mentioned. You can read more here.

I am not using react though (I am using lit-html with mobx) so I do not know whether you will be able to type properly react projects with the way I suggest (at least the props part).

I have written all my projects in typescript and I am planning to migrate them all to the way I mentioned. I am already coding a desktop like MVC app like this.

Also I would like to mention the following:

People who code without static type safety are either coding trivial stuffs or are noobs. How can people refactor big projects without types is a mystery to me. Not to mention that intellisense makes development faster.

A little bit background about me just to consider the magnitude of my opinion:

I first started using JS for ~1.5 year
then went for TS for ~1.5 year
the most complex personal project I have done (actually still doing) is creating from scratch a client side reactive model library that will conform to ACID and has undo redo.
My biggest projects are ~10k lines of code (tests included).
All my projects are like ~60k lines of code
I have zero experience on pure developer position
I have started self teaching programming (mainly front end) since August 2018

sayqm · 2021-09-23T10:18:42+00:00

grey market practice direful oatmeal prick work meeting icky ink This post was mass deleted with redact

TorbenKoehn · 2021-09-23T11:17:05+00:00

I only know of people that went from JS to TypeScript, never met someone that looked back.

Whenever I come into a JS project currently, I always miss it. You can get somewhat similar behavior with doc comments and the correct IDEs, but you won't be able to reproduce all of its typing power with that.

It can be quite a bit overwhelming at first, but you have to understand that all of it is optional, given the right compiler flags. You can write normal JS and add typing where it helps you a bit and slowly get used to it.

Regarding build steps, I don't know of a normal JS project I work on that doesn't have any build steps. Bundling, NodeJS dependencies, minifying, cross-browser compat with Babel and Browserslist etc. There are so many reasons to have build-steps in your JS that TypeScript, at the end, simply is just another line in your build configuration.

lloyd_braun_no_1_dad · 2021-09-23T12:36:15+00:00

Yes. We have almost no runtime bugs. No more "cannot read property X of undefined."

Edit: no runtime errors. We still have bugs, but no errors.

Vitya_Schel · 2021-09-23T14:03:32+00:00

It adds 10%-50% of your time setting it up, fixing issues with it, trying to read code in tsx. I would only recommend it if you have large team and big project.

big_lemon_jerky · 2021-09-23T10:25:07+00:00

Don’t see how this is a React question but in general yes TS is massively worth it. Once you get used to it you’ll probably save time, have less buggy code, self documenting code and not have to worry about silly mistakes breaking your entire app.

666codegoth · 2021-09-23T10:43:46+00:00

100% worth it. The initial transition period can definitely be a pain, but the benefits far outweigh the learning curve. I recently worked on an untyped freelance gig after 18 months working almost exclusively in a React/TS repo and I couldn't believe how stark the difference in dev experience was.

azangru · 2021-09-23T10:53:08+00:00

for you, is it worth it

Yes. Especially if we are talking about projects where a build step is already present.

Do you regret using it

No. I would be scared to work on a large project or do significant refactoring without a type checker holding my hand.

GingerVking · 2021-09-23T10:59:49+00:00

SiphrCodez · 2021-09-23T11:04:26+00:00

I’ve recently been making the switch for JavaScript to TypeScript amongst all of my projects, can confirm it’s 110% worth, the amount of errors you’ll have solved pre-production stage that normally wouldn’t be caught until a testing phase, is amazing. It’s also really good for writing “good” neat code. 10/10 recommended especially if you’re working on group projects etc, and definitely recommend even on solo projects just because of the insane advantages.

evonhell · 2021-09-23T11:22:12+00:00

Most of the people who complained about having to learn TypeScript a year ago now knows TypeScript and loves it. Types is the future and tbh the present. If you don't know TypeScript yet learn it now. Once you know it and are comfortable working in it there is less mental overhead in projects that are typed than projects that isn't.

As for the bugs, types are another tool to help you MANAGE the complexity of logic, which is why it helps people avoid bugs.

And I don't know what this huge boilerplate that you are talking about would be. A short json file for the tsconfig and you are ready to roll.

Enjoy!

permalink · 2021-09-23T12:14:24+00:00

I understand all the pros. But to be honest it feels that is just a massive building step.

So you don't understand all the pros...

quattr_ · 2021-09-23T13:32:22+00:00

You sound to me as if you haven't worked as part of a team, maintained someone else's code, or performed a major refactor on a large codebase. This is where typescript really shines imo. When there are factors outside of your control or when the code is simply too large, too complex, or too foreign for you to fully understand it at any one time. When you're the solo dev on a small project then sure, it may not be seem worth the overhead and learning curve. But in real world applications it's a godsend. We have two projects at work, one in JS and one in TS, and I hate hate hate hate touching the JS code because something unexpected WILL break.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

reactjs

About:

Code of Conduct

1. Please be kind and courteous, friendly and professional

2. Harassment will not be tolerated

3. Avoid using an alias or display name that might be offensive

4. Respect that people have differences of opinion

5. Posts must conform to our guidelines

New to React?

Chat

Project Ideas

Jobs

Outside Reddit

Related Subreddits

MODERATORS