Ask HN: Is there a language that is simple and empowers developer productivity? | Hacker News Reader

Ask HN: Is there a language that is simple and empowers developer productivity?

3 pointsakkad3311 comments

I think many languages tried to be "simple", but in the process they also handicapped developers by removing useful features like generics and operator overloading. I'm thinking Java, Go, etc. Is there a language that actually is simple, but also is expressive while also remaining correct, with a reliable type system with no holes? I would not say Rust, D etc are simple, even though they allow enormous flexibility

View on HN

I’m reminded of Standard ML (note that this has nothing to do with machine learning). It is a simple language with a powerful static type system, and while it is a functional programming language, it permits impure operations such as mutability. Standard ML is more complex than Scheme (which is dynamically typed), but is simpler than its cousin OCaml (which is more feature-rich), Common Lisp, or Haskell. I think Standard ML is a nice combination of power, simplicity, and static typing.

https://www.smlnj.org/index.html

There’s no simple language that has generics, operator overloading and a type system because these are not simple concepts.

That’s OK, surely?

There are older languages that are simple, typed and powerful like Ada and Modula-2, but these have fallen out of favour because the world wants operator overloading and complex type definition languages and generics.

(The lack of a Modula-2 sort of language is IMO ably addressed by Go)

I think Julia is kind of simple in the sense that it has this idea that every function you write is automatically generic and the compiler infers the generic bounds by looking at the function implementation. A typed language that does something similar imperfectly is fsharps, but it does not work too well in practice

I must say I don't really know enough about Julia to know whether it is simple, but that's some reading for a long train journey bookmarked at least :-)

All editions of Ada have supported operator overloading, complex (rich) type definitions, generics, built-in concurrency, etc. It was overlooked for too long but seems to be getting attention and increased usage again.

Ada provides ways of restricting the features you use (i.e., specify your own subset if you like). Its also scalable from very small to very large projects.

Julia is really simple if you do math related stuff (sounds like from mention of operator overloading ): https://github.com/mossr/BeautifulAlgorithms.jl .

There is no reliable type system with no holes, because there are no humans who can generate a hole free collection of orthogonal types.

For simple, there is always Clojure. Uses predicates rather than declarative types.

>> For simple, there is always Clojure

"Simple Made Easy": https://www.infoq.com/presentations/Simple-Made-Easy/

Agreed, Clojure is concise, expressive, and relatively simple.

> Uses predicates rather than declarative types.

Could you explain what predicates are? I've never seen the concept of predicates put forth as an alternative to types

Sorry- "predicates" == boolean functions. Types operationalize as assertions- boolean functions, predicates, whatever- applied at different stages (to code at compile time, to data at runtime). That's mechanically what types are.

Rich Hickey, creator of Clojure, talks more comprehensively about this view in his talk on Clojure Spec (called "Speculation").

Kotlin?

Reply on news.ycombinator.com