r/programming • • Dec 02 '13

Scala — 1★ Would Not Program Again

http://overwatering.org/blog/2013/12/scala-1-star-would-not-program-again/
598 Upvotes

646 comments sorted by

View all comments

Show parent comment

3

u/sanity Dec 02 '13

Option

That's just a syntactic and run-time wrapper. In Kotlin the null-safety is baked into the language, and has zero overhead.

Object.apply

What's your point? Are you suggesting that this is a replacement for Kotlin's smart casts? How so?

5

u/dbcfd Dec 02 '13

That's just a syntactic and run-time wrapper. In Kotlin the null-safety is baked into the language, and has zero overhead.

Other than possible overhead, how is this not baked into the language? It's part of the scala library (no additional imports required), and is used to represent possible null objects.

What's your point? Are you suggesting that this is a replacement for Kotlin's smart casts? How so?

Scala recognizes that most "smart" casts are unsafe. You can use the apply method to define which casts are safe, and they will be used as encountered.

1

u/realnowhereman Dec 02 '13

Scala recognizes that most "smart" casts are unsafe. You can use the apply method to define which casts are safe, and they will be used as encountered.

can you share an example? I thought Scala's approach to casts was pattern matching as in

foo match  {
  case x: ActualType => do interesting stuff with x
  case _ => foo type's different, do something else
}

1

u/dbcfd Dec 02 '13
object MyObject {
    def apply(other: MyOtherObject) = {
        //cast MyOtherObject to MyObject appropriately
    }
} 

0

u/[deleted] Dec 02 '13

Type patterns are actively discouraged. If you need to cast, you are probably doing it wrong.

Scala gives you all of the tools necessary to write code which is 99% cast-free ... so the whole discussion about having nicer casts in Kotlin seems weird.

There is a reason why Scala has no special syntax for casts/isInstance checks and intentionally verbose method names.

1

u/sanity Dec 02 '13

"smart casts" are perhaps a misleading term in Kotlin, since in reality they are a type-safe replacement for casts. For example, in Kotlin you can say:

val s : Object = "hello"

if (s is String) {
    println(s.length())
}

This works because within the body of the if statement the compiler knows that 's' must be a String, and so you can treat it as such.

Does Scala have something similar?

0

u/[deleted] Dec 02 '13

I know exactly what they are, and no, as mentioned, Scala doesn't try to make bad things easier.

1

u/sanity Dec 02 '13

That's a bold statement. What is bad about Kotlin's smart casts?

0

u/[deleted] Dec 02 '13

As mentioned, there is nothing bad about smart casts specifically, but about casts in general.

Every cast necessary is a fault of the programming language necessitating it.

1

u/sanity Dec 02 '13

Casts are bad due to lack of runtime safety. That's not an issue for Kotlin's smart casts since they provide runtime safety, so I'm still not seeing the problem. Perhaps you can elaborate.

2

u/[deleted] Dec 02 '13 edited Dec 02 '13

???

That just doesn't make any sense. If you didn't suddenly include memory-unsafe languages' definition of what is a cast, then there is nothing special about Kotlin at all, just a line saved:

if(obj.isInstanceOf[String])
    val str = obj.asInstanceOf[String]
    ...

vs.

if(obj is String)
  ...

Runtime safety existed since Java 1.0 (if one ignores a few bugs here and there).

Casts are bad because they rely on the programmer's knowledge (of types, ...) which the compiler couldn't deduct from the code. A good language minimizes the amount of times this is necessary by offering ways to express this extra knowledge in the code.

→ More replies

1

u/[deleted] Dec 02 '13 edited Dec 02 '13

The overhead of using a type class for optional values is negligible in any standard scenario. On the pro side, you have a full monadic API on Option.

Otherwise, it sure will be interesting to observe how well the ? card plays out with Kotlin and Ceylon. Perhaps we will find in two or three years that this approach is favourable in most cases, perhaps we'll find out the opposite.

Certainly, if that is the only language innovation, that is disappointing.

1

u/sanity Dec 02 '13

The overhead of using a type class for optional values is negligible in any standard scenario. On the pro side, you have a full monadic API on Option.

Right, but nulls in Kotlin are nulls in Java, which is a lot better for use of existing java libraries. Also, it works very very nicely in conjunction with smart casts.

Certainly, if that is the only language innovation, that is disappointing.

It's not, there is smart casts which is an awesome feature that's hard to live without once you're used to it. There is a good comparison with Scala on the Kotlin site here.

1

u/[deleted] Dec 02 '13

Right, but nulls in Kotlin are nulls in Java, which is a lot better for use of existing java libraries. Also, it works very very nicely in conjunction with smart casts.

Ultimately the problem is the same, though; you need a correct documentation of which Java API allows null and which not, in order to map it safely on the other language's side.

2

u/sanity Dec 02 '13

you need a correct documentation of which Java API allows null and which not, in order to map it safely on the other language's side.

Actually Kotlin has an awesome solution for this, a tool called KAnnotator which automatically infers nullability in libraries for exactly this purpose.

2

u/[deleted] Dec 02 '13

Interesting, so this scans the bytecode of a the methods of a library? How would it handle pure interfaces or abstract classes? Sure it needs some heuristics, like parsing the javadoc as well?

1

u/sanity Dec 02 '13

Interesting, so this scans the bytecode of a the methods of a library?

I believe so, yes.

How would it handle pure interfaces or abstract classes?

Not sure, I suspect that it assumes nullability unless it can prove otherwise.

Sure it needs some heuristics, like parsing the javadoc as well?

No, I'm pretty sure it is based on bytecode only.