Hacker Newsnew | past | comments | ask | show | jobs | submitlogin
Ask HN: JS++ ? Why not make a new, strongly typed JavaScript ?
8 points by alcover on Dec 29, 2020 | hide | past | favorite | 39 comments
Javascript has a nice syntax but needs to be faster and more reliable.

With strong typing JS++ would eliminate many runtime bugs. Without all the crazy implicit conversions, boxing, 'eval', etc... fantastic speeds could be achieved.

Lots of electricity and developper hair could be saved.

JS++ would break backward compatibility but this could be softened by retaining the old syntax as largely as possible. With implicit and explicit typing.

It should be easy/automated to convert js to js++.

Inb4 ActionScript 3 : yes, something like that.



It's probably a terribly unpopular opinion, but I think the weak typing is the main attraction of JS. When I want stronger typing, I have C or (god forbid) C++.

If you've ever written typescript, you can see how a strongly typed JS gives you the worst of both worlds.


I think you’re confusing strong/weak with static/dynamic. The former happens at runtime, the latter at compile time.

Typescript adds static typing to JS, but it’s still weakly typed. This post is about strong typing in JS, which I’m still scratching my head about.


Maybe, whatever the case, what I think immensely practical in JS is being able to do things like

const o = {}; o.prop = "something"; // oh, actually, o.prop = 5;

and being able to do if( typeof o.prop === 'number' ) ...


I bet you really like spaghetti.


I like clean, elegant, expressive code, just like everyone else.

I don't particularly care for the attitude that because something can be used to write horribly unmaintainable messes, it must necessarily be bad and have few practical applications.

No, if you get horrid unmaintainable messes it's because you're either inexperienced or a bad programmer, you may be able to hide that in layers and layers of corporate Java that adheres to every guideline, but the second anyone tries to touch it, you'll be found out anyway. I'm going to take a wild guess that you're also imbued with a similarly low opinion of PHP based on that (insightful if somewhat one-sided and flawed) article that guy wrote.

In my opinion, the flexibility and elegance you can get out of exploiting, not abusing or misusing, the dynamic nature of JS, is the main appeal of the language, it's really damn fast to get stuff done, and even done in a nice and safe way, provided you have some idea what you're doing.

There are terrible things that you can do in JS, and those are terrible even in the context of JS, but, what is a terrible thing to do in one language may be just fine(tm) in another, so trying to force some Java or C++ ideas onto any other language is just not a good way of going about things. Every language must be considered on its own.

What is reasonable to do when writing machine code may not be reasonable in assembler, and what is reasonable in assembler may not be reasonable in C and up you go.


> const o = {}; o.prop = "something"; // oh, actually, o.prop = 5;

Care to share some examples / use cases where using these language characteristics can result in better, more expressive, more readable code?

(Not saying there aren't. I've been wondering about it myself and am genuinely curious)

Thanks!


I mean... let’s keep in mind we’re talking about a language and community that uses the keyword “const” to define mutable objects. Logic went out the window a long fucking time ago.


> we’re talking about a language and community that uses the keyword “const” to define mutable objects.

Nope they use const to define immutable references, the same way that val/var define mutable references.

If you don't understand the difference between mutability of a reference and mutability of the value it refers to, JavaScript is far from the only language you’ll have a problem with.


I understand the difference. The problem is that you can completely change the shape of the object that’s “const”, so it’s hardly fucking constant is it.


> I understand the difference

No, you clearly don't.

> The problem is that you can completely change the shape of the object that’s “const”

“const” is not a feature of objects, but of the reference to a value (which may or may not be an object).

You can't change the reference at all (unlike a var/let references), hence it is constant.

Object immutability is orthogonal to reference immutability and is attained by Object.freeze().


dragonwriter is right.

In C for ex.

  const int* p
means the value pointed at can't change, but

  int* const p
means you can't reaffect p


TIL relying on a bunch of boilerplate “typeof o.prop” checks is “clean, elegant, expressive code”, while knowing implicitly that o.prop is always an integer is not?


> TIL relying on a bunch of boilerplate “typeof o.prop” checks is “clean, elegant, expressive code”, while knowing implicitly that o.prop is always an integer is not?

Clean and elegant are certainly debatable, but, yes, code that is explicit in its preconditions (whether through explicit runtime checks or explicit static declarations or other mechanism) is pretty clearly more expressive than code that relies on the developer “knowing implicitly” the same information.


When I said knowing implicitly I was referring to for example, declaring that class `Foo` has an integer property `prop`, and function `bar` only accepts an instance of `Foo` as argument `obj`, thus `obj.prop` is always an integer. The developer doesn’t need to add typeof checks on the argument, on the property, etc.

The above comments point to (a) not using classes or declared properties at all, and regardless JavaScript has no support for automatic type checks on properties or function arguments.


> I think you’re confusing strong/weak with static/dynamic. The former happens at runtime, the latter at compile time.

Strong typing usually describes the combination of compile and runtime typing; Haskell code doesn't have types after compilation, so there is no runtime enforcement of typing, but no one calls it weakly-typed, because the static typing prevents any of the conditions which would display weak typing behavior fromm happening.


> which I’m still scratching my head about.

I'm no type theorist and - per wikipedia - 'strong' is not precisely defined.

'Static' may be closer to my idea : a JS where `typeof` and Number.isInteger are of no use.


> If you've ever written typescript, you can see how a strongly typed JS gives you the worst of both worlds.

Actually, no. I genuinely think Typescript is amazing and I would love if there was native support one day.


> When I want stronger typing, I have C

Not in the browser.. Nor in the app/server.


In what world does C code not run in “app/server”?


I meant server web application. The one in Node/Go/Python where you will write your business logic then `http.listen()`.

See what I mean ?

JS matters most client-side anyway.


> I meant server web application.

You can absolutely write server web apps in C (there are even web app frameworks in C), though I wouldn't want to, or...

> The one in Node/Go/Python where you will write your business logic then `http.listen()`.

You definitely can link and call C code from Node, Go, and Python; they'd be much less useful otherwise; it's not at all hard in Python, and I assume the same is true of Node and Go.


Node is absolutely excellent server side, and if you have something where you want it to be much faster, and slower to develop, go with C or C++, there are libraries out there for writing webservices, or go another route and write your critical parts as native node modules, against V8.


Web service in C ?

dealing with http queries, strings, regexp, json... is a lot of (unsafe) work..


Actually a lot of high performance modules are wrote in c for python and you can do the same for node.


So literally somewhere c code can and does run all the time.


> Not in the browser..

WebAssembly as a target is a thing, so, yes, C is available there.

> Nor in the app/server.

How is C not available on the backend?


Honestly, ask yourself _why_ you think you need strongly typed JS. Are type errors the most common source of errors in JS? Not even close. So why add another level of complexity for negligible gain.


> ask yourself _why_ you think you need strongly typed JS

Because I -and everyone- need a faster, less energy-wasting JS.

> Are type errors the most common source of errors in JS?

They happen. And could be caught at compile-time under a stronger type system.

JS is used client-side in many banking/crypto webapps. I know everything is validated on the server but still presentation is done by JS with its nutty casts/coercions...


Parent comment has a point - the appeal of JS is that it's a weakly typed, hacky language. I love duck typing. I don't use Typescript, nor would I use a JS++.

There are a good number of programming languages. Why not something like Go? I heard Go compiles to JS, but never tried it. Why is JS even used for banking, and why would converting to a JS++ be easier than adopting something else?


> duck typing hacky language

It may be possible to keep duck typing for objects while introducing fast unambiguous primitives like int64_t ?

> Why not something like Go?

Because JS syntax is very nice - that's my premise. Moreover, client side has to be JS, no other choice yet.


I have understood that current JIT compilers for JavaScript are smart enough to recognize when a function is called with the same type of arguments and compile the function into an optimized form making use of this typing knowledge. So, adding types to JavaScript might no result in a great performance boost. If will definitely make JavaScript more verbose which might have a negative effect on performance.


> making use of this typing knowledge

That makes JIT a complicated business, for you still have to accept any value. So two versions of the func would have to coexist ? One strong and one weak ? I'm no JS/JIT expert..


Have a look at https://hacks.mozilla.org/2017/02/a-crash-course-in-just-in-...


Thanks, I read it.

It is like I thought : holding different optimisation versions of the same code... that is overly complicated in my (naive) view.


I’m still surprised that for all the “enhancements” it’s had in the last decade or so JavaScript still doesn’t allow basic things like optional type declarations (ie type hints in php).

Want to accept muck? Leave it as is. Want to accept something specific? Specify the class to accept, or even specify the shape if you want to go the duck typing route.


you can typify untyped code, but you can't untypify typed code. because typify is to make constraints and untypify is real life, I mean, a window is a house device and a computer device, the meaning window relies on other information of context besides type. that other information is unkown so if you close de door to unkown you will never know if that exception could be handled by machine at first runtime. it's more related to the tradeoff between scale and flexibility. i'm not concerned with scale, it's tedious and prone to automation. the question is do you believe in money or in future code? I mean a code that is so untyped that behaves like human.


It exists and it's called Elm. it's not work backwards compatible, but it's a really solid language


There are plenty of strongly typed (and often both strong and static typed) languages that compile to JS or WebAssembly for web use (or portability anywhere JS/WASM run).

If you are going to break from JS semantics by using strong typing rather than JS’s mostly-very-weak typing, I don't see what the point is of making code deceptively look like JS.


last time i had a bug due to type error was probably years ago. all bugs i get are due to logical errors or misunderstanding stuff.




Consider applying for YC's Fall 2025 batch! Applications are open till Aug 4

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: