4 ms·

It's crazy the amount of work that is spent to essentially implement static typing into dynamically / duck typed languages. Projects like this, mypy and others

by Eikon 7y ago

It's crazy the amount of work that is spent to essentially implement static typing into dynamically / duck typed languages. Projects like this, mypy and others makes the whole thing bizarre to say the least.

BiteCode_dev 7y ago
I used to dislike type hints for Python because: - I was afraid it would change the language culture - It was not comfortable to use - The idea and design was, as you said, bizarre - Use use a dynamic language, why the hell would I want that? Years after the fact, I'm really happy about it. First, most of my Python code don't use them, so Python stays python. But if I ever need them, there are here. Of course, you could argue I should just use a language that has been designed for that since I need type. But that's missing the point: I don't usually start using hints. I code regular Python, because it's awesome. I just sometimes add type hints after the fact as a bonus. The ability to do that is fantastic, even if the type system is far from perfect. I want to code with Python most of the time anyway. I personally have very few use cases for another language, doing mostly web stuff. Type hints are still very verbose, and convoluted, although it will get better with 3.9 thanks to 2 PEP targeting type hints ergonomics. So sure, it's never going to fit perfectly, but I'm glad it's here. Now for a JSON schema, I guess it's the same deal. You use JSON because it fits your use case, and one day you realize your situation could now benefit from more robustness, and you add it to the mix. Again, you could argue you should have though of that at the beginning, but projects don't have frozen requirements, they evolve. And often, you want to start lean, because it will most probably stays that way, and otherwise would be so costly the project would never grow to a point you would need robustness. Now in this particular case, this lib is not just checking type, but also arbitrary logic. And making sure data is consistent is necessary no matter how dynamic or static your language is. There is a limit to the constraints your type system can represent.
- thrwaway69 7y ago
  Have you ever checked dart? Type inference can get you so so far
  - BiteCode_dev 7y ago
    Yes. Flutter is a killer app. But then again, Django as well.
- dehrmann 7y ago
  I led a project for validating customer-provided data against a json schema. The structure of the data was moderately complex, and it was getting bound to pojos by a pretty lenient binder. This caused issues when making additions to the API since customers were sending arbitrary fields, and duck typing the data wasn't that reliable. The easiest thing to validate before binding with a json schema. What's different this and Python type hints is that this was a public-facing API, so you have far less control over what data you'll see, and the server code was Java, so getting things strongly typed and validated early on makes your life easier.
  - BiteCode_dev 7y ago
    Schema validation is more than type checking, and has been very well solved by libraries like marshmallow and pydantic for a long time. I don't think the comparison holds.
- dehrmann 7y ago
  I've worked with Python professionally for 3-5 years, but only type-hinted Python for ~5 months. This is coming from someone who prefers Java, but I don't like Python type hints because they were bolted onto the language worse than classes, type hierarchies aren't mature, and if I wanted types, I'd be using Java. That said, you do need strong typing for a project once it hits a certain line count or developer count.
  - BiteCode_dev 7y ago
    Yes, the type system is clearly not well integrated. My point is, I'd rather have a not so perfect one when I need it, that None at all. And most of the time I don't need one.
  - baq 7y ago
    Java's type system is weaker than what Python's typing provides. If you want to make fun of Python's type system, compare it to TypeScript, ocaml or haskell. Python's typing is actually useful even if it's bolted on and the typeshed is incomplete.
- zmmmmm 7y ago
  There are languages though like eg: Groovy where gradual typing is more designed in. It's unfortunate to me that Python has cultivated this attititude because it's like local maxima that prevents the mainstream getting to soemthing better. Python is the new perl / PHP etc.
  - BiteCode_dev 7y ago
    What attitude?
    - zmmmmm 7y ago
      Apologies ... I mean the attitude that Python is "good enough" because it has type hinting and therefore it is not worth bothering with exploring other languages, especially ones that have wholly more powerful type systems. I have found (personal experience only here) that it can be tremendously hard to get Python programmers to learn and embrace other languages and approaches to software.
      - baq 7y ago
        that's true of any sufficiently popular tech stack. some people get either way too attached to their beloved language (...do carpenters fall in love with hammers?) or just are too lazy to learn something else - assuming that programming is their profession and not just a means to an end.
mhd 7y ago
It's not like bringing features you get for free from dynamic languages into static languages doesn't involve an crazy amount of work, either.
junke 7y ago
Declaring and checking the type of values is still dynamic typing, I see no static types here.
catlifeonmars 7y ago
This is orthogonal to type safety. In fact, schema-based validation is an excellent way to perform type narrowing even in statically typed languages. An extremely prolific example of this is parsing incoming JSON from network requests :)
ken 7y ago
What statically typed language lets me define a type as “number between -180 and +180”, or “string which contains only alphanumeric chars”? I think that would be a great feature but from what I see static typing fails here, too.
- JoeAltmaier 7y ago
  Been missing this for 20 years.
- wry_discontent 7y ago
  It's not statically typed, but you can do this with clojure.spec (s/def ::number #(<= -180 % 180)) (s/def ::my-string (s/and string? #(re-matches #"[a-zA-Z0-9]*" %)))
- arethuza 7y ago
  I think Pascal's subranges would cover both those examples? NB Last time I used Pascal was probably 35 years ago.... Edit: I would suspect Ada would have something like this.
- metalrain 7y ago
  I think Idris does, see http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html#the-finite-sets http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html... But probably there is some horrible trade-off or limits that seem arbitrary.
- rraval 7y ago
  > What statically typed language lets me define a type as “number between -180 and +180”, or “string which contains only alphanumeric chars”? Pretty much all of them. Any simple predicate like this can be encoded with witness types. Here's an example in Java, which is hardly the paragon of static typing (i.e. it's no Haskell/Idris/Agda/Rust/Typescript): class AlphaNumericString { private final String str; // use a fallible factory with a `private` constructor if you're // morally opposed to exceptions public AlphaNumericString(String str) throws AlphaNumericException { if (!str.matches("^[a-zA-Z0-9]*$")) { throw new AlphaNumericException(); } this.str = str; } private static class AlphaNumericException extends Exception { } } Now code can freely use `AlphaNumericString` and be guaranteed that it has been validated. You may object and say that newtype wrapping is cumbersome but: 1. That's an argument about sugar and ergonomics, not about the semantics that the static type system enforces 2. Some languages make it easier to generate forwarding methods to the underlying type (a la https://kotlinlang.org/docs/reference/delegation.html https://kotlinlang.org/docs/reference/delegation.html) 3. The `AlphaNumericString` is describing a smaller set of values than `String`. In general, you should be strongly considering the methods you allow and make sure that all paths continue to enforce the semantics you intend.
lewiscollard 7y ago
This has little to do with dynamically typed languages, "JS" in the name notwithstanding. JSON is a serialisation format that is used in both statically & dynamically-typed languages. It makes as much sense to call XML validators bizarre as it does to pin this project as a weird byproduct of dynamically typed languages. If your program produces or consumes JSON _and_ you think it would be a good idea to ensure said JSON is what you are/a client is expecting, then you need something like this in any implementation language.
- baq 7y ago
  preach. what I completely don't understand is the current fad on everything-should-be-yaml where yaml is marginally easier to write than XML, a tiny bit more than marginally easier to read (caveat emptor - Norway has a country code) and otherwise exactly as broken. (i'm talking about the 'safe' variant.)
globular-toast 7y ago
I don't think you understand static typing and you might be confusing dynamic typing with duck typing or other concepts. The presence of types doesn't mean static typing. Python, for example, is strongly typed, but it's dynamic because the type of any object can't be determined until run time. But you can still check types!

by Eikon 7y ago

BiteCode_dev 7y ago

I used to dislike type hints for Python because: - I was afraid it would change the language culture - It was not comfortable to use - The idea and design was, as you said, bizarre - Use use a dynamic language, why the hell would I want that? Years after the fact, I'm really happy about it. First, most of my Python code don't use them, so Python stays python. But if I ever need them, there are here. Of course, you could argue I should just use a language that has been designed for that since I need type. But that's missing the point: I don't usually start using hints. I code regular Python, because it's awesome. I just sometimes add type hints after the fact as a bonus. The ability to do that is fantastic, even if the type system is far from perfect. I want to code with Python most of the time anyway. I personally have very few use cases for another language, doing mostly web stuff. Type hints are still very verbose, and convoluted, although it will get better with 3.9 thanks to 2 PEP targeting type hints ergonomics. So sure, it's never going to fit perfectly, but I'm glad it's here. Now for a JSON schema, I guess it's the same deal. You use JSON because it fits your use case, and one day you realize your situation could now benefit from more robustness, and you add it to the mix. Again, you could argue you should have though of that at the beginning, but projects don't have frozen requirements, they evolve. And often, you want to start lean, because it will most probably stays that way, and otherwise would be so costly the project would never grow to a point you would need robustness. Now in this particular case, this lib is not just checking type, but also arbitrary logic. And making sure data is consistent is necessary no matter how dynamic or static your language is. There is a limit to the constraints your type system can represent.

thrwaway69 7y ago
Have you ever checked dart? Type inference can get you so so far
- BiteCode_dev 7y ago
  Yes. Flutter is a killer app. But then again, Django as well.
dehrmann 7y ago
I led a project for validating customer-provided data against a json schema. The structure of the data was moderately complex, and it was getting bound to pojos by a pretty lenient binder. This caused issues when making additions to the API since customers were sending arbitrary fields, and duck typing the data wasn't that reliable. The easiest thing to validate before binding with a json schema. What's different this and Python type hints is that this was a public-facing API, so you have far less control over what data you'll see, and the server code was Java, so getting things strongly typed and validated early on makes your life easier.
- BiteCode_dev 7y ago
  Schema validation is more than type checking, and has been very well solved by libraries like marshmallow and pydantic for a long time. I don't think the comparison holds.
dehrmann 7y ago
I've worked with Python professionally for 3-5 years, but only type-hinted Python for ~5 months. This is coming from someone who prefers Java, but I don't like Python type hints because they were bolted onto the language worse than classes, type hierarchies aren't mature, and if I wanted types, I'd be using Java. That said, you do need strong typing for a project once it hits a certain line count or developer count.
- BiteCode_dev 7y ago
  Yes, the type system is clearly not well integrated. My point is, I'd rather have a not so perfect one when I need it, that None at all. And most of the time I don't need one.
- baq 7y ago
  Java's type system is weaker than what Python's typing provides. If you want to make fun of Python's type system, compare it to TypeScript, ocaml or haskell. Python's typing is actually useful even if it's bolted on and the typeshed is incomplete.
zmmmmm 7y ago
There are languages though like eg: Groovy where gradual typing is more designed in. It's unfortunate to me that Python has cultivated this attititude because it's like local maxima that prevents the mainstream getting to soemthing better. Python is the new perl / PHP etc.
- BiteCode_dev 7y ago
  What attitude?
  - zmmmmm 7y ago
    Apologies ... I mean the attitude that Python is "good enough" because it has type hinting and therefore it is not worth bothering with exploring other languages, especially ones that have wholly more powerful type systems. I have found (personal experience only here) that it can be tremendously hard to get Python programmers to learn and embrace other languages and approaches to software.
    - baq 7y ago
      that's true of any sufficiently popular tech stack. some people get either way too attached to their beloved language (...do carpenters fall in love with hammers?) or just are too lazy to learn something else - assuming that programming is their profession and not just a means to an end.

mhd 7y ago

It's not like bringing features you get for free from dynamic languages into static languages doesn't involve an crazy amount of work, either.

junke 7y ago

Declaring and checking the type of values is still dynamic typing, I see no static types here.

catlifeonmars 7y ago

This is orthogonal to type safety. In fact, schema-based validation is an excellent way to perform type narrowing even in statically typed languages. An extremely prolific example of this is parsing incoming JSON from network requests :)

ken 7y ago

What statically typed language lets me define a type as “number between -180 and +180”, or “string which contains only alphanumeric chars”? I think that would be a great feature but from what I see static typing fails here, too.

JoeAltmaier 7y ago
Been missing this for 20 years.
wry_discontent 7y ago
It's not statically typed, but you can do this with clojure.spec (s/def ::number #(<= -180 % 180)) (s/def ::my-string (s/and string? #(re-matches #"[a-zA-Z0-9]*" %)))
arethuza 7y ago
I think Pascal's subranges would cover both those examples? NB Last time I used Pascal was probably 35 years ago.... Edit: I would suspect Ada would have something like this.
metalrain 7y ago
I think Idris does, see http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html#the-finite-sets http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html... But probably there is some horrible trade-off or limits that seem arbitrary.
rraval 7y ago
> What statically typed language lets me define a type as “number between -180 and +180”, or “string which contains only alphanumeric chars”? Pretty much all of them. Any simple predicate like this can be encoded with witness types. Here's an example in Java, which is hardly the paragon of static typing (i.e. it's no Haskell/Idris/Agda/Rust/Typescript): class AlphaNumericString { private final String str; // use a fallible factory with a `private` constructor if you're // morally opposed to exceptions public AlphaNumericString(String str) throws AlphaNumericException { if (!str.matches("^[a-zA-Z0-9]*$")) { throw new AlphaNumericException(); } this.str = str; } private static class AlphaNumericException extends Exception { } } Now code can freely use `AlphaNumericString` and be guaranteed that it has been validated. You may object and say that newtype wrapping is cumbersome but: 1. That's an argument about sugar and ergonomics, not about the semantics that the static type system enforces 2. Some languages make it easier to generate forwarding methods to the underlying type (a la https://kotlinlang.org/docs/reference/delegation.html https://kotlinlang.org/docs/reference/delegation.html) 3. The `AlphaNumericString` is describing a smaller set of values than `String`. In general, you should be strongly considering the methods you allow and make sure that all paths continue to enforce the semantics you intend.

lewiscollard 7y ago

This has little to do with dynamically typed languages, "JS" in the name notwithstanding. JSON is a serialisation format that is used in both statically & dynamically-typed languages. It makes as much sense to call XML validators bizarre as it does to pin this project as a weird byproduct of dynamically typed languages. If your program produces or consumes JSON _and_ you think it would be a good idea to ensure said JSON is what you are/a client is expecting, then you need something like this in any implementation language.

baq 7y ago
preach. what I completely don't understand is the current fad on everything-should-be-yaml where yaml is marginally easier to write than XML, a tiny bit more than marginally easier to read (caveat emptor - Norway has a country code) and otherwise exactly as broken. (i'm talking about the 'safe' variant.)

globular-toast 7y ago

I don't think you understand static typing and you might be confusing dynamic typing with duck typing or other concepts. The presence of types doesn't mean static typing. Python, for example, is strongly typed, but it's dynamic because the type of any object can't be determined until run time. But you can still check types!