Scala: The Static Language that Feels Dynamic (Bruce Eckel)

http://www.artima.com/weblogs/viewpost.jsp?thread=328540

by peod • 15 years ago

151 62 15 years ago

spullara• 15 years ago

The biggest thing that is still in the language that they should have removed early on is the native XML syntax support. If I were them I would take it out in 3.0 and break from that bad decision.

dustingetz• 15 years ago

please elaborate? do you think its harmful because it influences people to reach for XML instead of another format?

kikibobo692• 15 years ago

I used to agree, until I ran into a bunch of inline StringBuilder Java XML where no schema existed, and simply converting it to Scala at least ensured it was well-formed while we reverse-engineered a schema. I agree it's not something one should use much (well, maybe with Lift), but wow, is it ever useful when it's useful. I agree, doesn't hurt much; helps massively when you need it.

jorgeortiz853• 15 years ago

See my answer on Quora to "Will Scala ever remove XML literals?" http://www.quora.com/Will-Scala-ever-remove-XML-literals

Summary: No. At the time that Scala was started, built-in support for XML showcased one area were object-oriented decomposition failed and functional programming proved quite useful. Today the benefits of FP are more well known, and it's generally agreed that if Scala were starting from scratch it would not include XML literals. However, given that XML literals are in the language already, that large code bases have come to rely on them, and that they generally don't get in the way if you don't use them, it's unlikely that they will be removed.

_sh• 15 years ago

Solution: move it to a library, like perl did with it's format syntax, and take it out of core.

fizx• 15 years ago

...because what scala needs is more api-breaking decisions...

curtis• 15 years ago

Putting XML literals in the language just feels wrong. On the other hand, they've turned out to be damn useful when you're writing the back end for a web application.

corruptmemory8• 15 years ago

It was a mistake. A better effort would have been to implement a first-class Macro system a-la Lisp. You can see here that Nemerle supports macros and makes dealing with XML like relatively painless as if it were built in: http://nemerle.org/About/#ID0E6G

Macros for the win.

corruptmemory8• 15 years ago

There are several decent Scala-esque alternatives to the built-in XML support (with has many things broken about it). For instance: Anti-XML http://anti-xml.org/ and Scala-Scales: http://code.google.com/p/scala-scales/ they can't replace the functionality of the built-in support (need to alter parser/compiler for that), but are considerably more sane than the default functionality in scala.xml

carsongross3• 15 years ago

Gosu has the same dynamic feel in a statically typed JVM language, with much less complexity. (I should mention Fantom too, although I'm much less familiar with it.)

Artima appears to have gone all-scala-all-the-time at some point in 2010. Weird.

kikibobo692• 15 years ago

Bill Venners, owner of Artima, is a co-author of the Staircase book, and author of ScalaTest. He has embraced Scala more than most.

cageface9• 15 years ago

Scala looks complex on paper, but my experience has been that in practice it's not that bad. If you're designing a library you need to think hard about types but you can put together an app very quickly in Scala and with a lot fewer initial bugs than in a dynamically typed language.

jshen3• 15 years ago

I wonder if there is value in making it easy to make library? I feel like the ruby eco system gains a lot for the rate at which people can try out ideas for libraries.

carsongross3• 15 years ago

You could say the same thing about C++

The reality is that complex features will be used and abused.

cageface9• 15 years ago

Followed up your suggestion of Gosu, which I hadn't heard about before. Looks interesting but this feature comparison chart is hilarious: http://gosu-lang.org/comparison.shtml

It's the first time I've seen "not lisp" as a checkbox feature. :)

carsongross3• 15 years ago

;)

kenjackson• 15 years ago

Maybe I missed something, but there is nothing in there that gives me the feel of a dynamically typed language. What he describes feels more like Haskell than Python.

andrewflnr2• 15 years ago

Perhaps by "feels like a dynamic language" he means "is succinct".

contextfree3• 15 years ago

Reminds me of this classic comment by Frank Atanassow on Lambda the Ultimate: http://lambda-the-ultimate.org/node/1562#comment-18623

> "Dynamic" is technical jargon used by programmers, meaning "good". It derives from the Latin dyno mite, meaning "I am extremely pleased", and is first recorded in the historical work Bona Aetas of noted Roman sage and pundit J.J. Walker. Its meaning evolved in the 4th century after monks copying an obscure manuscript on programming linguistics in their ignorance tried to deduce its meaning from context. [...]

(the comment continues at the link; read the whole thing, it's pretty funny whether or not you agree with the sentiment)

vorg• 15 years ago

> I find it one of the most promising things about Scala -- it is not determined to become an instant boat anchor by committing to early decisions that are later revealed to be suboptimal, or outright mistakes.

The fact that Scala uses the JVM, with a hacky workaround for type erasure, is suboptimal.

Lewisham• 15 years ago

Depends on what is suboptimal to you. If "suboptimal" is "not optimal for the perfect programming language", then sure. If "suboptimal" is "not optimal for real world use", then no.

Scala's interop with Java libraries has been a huge, huge boon, and undoubtedly drove take-up where there otherwise would have been none. Scala has come this far in a decade. Python is 20 years old. Ruby is 16. Scala came a long way in a short time, and was probably resigned to the dustbin of "that would have been cool" languages without that interop.

gaius2• 15 years ago

The Scala team have plans afoot to target LLVM and .NET too.

stonemetal• 15 years ago

Do they have actual plans though? There has been talk of .NET support since the beginning. Basically I wouldn't hold my breath.

rvasa• 15 years ago

one of the better written articles out there for some one new to the language. Also like the fact that some of the funamentals of functional programming are also briefly introduced in context.

eegilbert• 15 years ago

Somehow I missed parallel collections in 2.9. I'm in love.

srean• 15 years ago

I believe JVM now supports some restricted form of class re-definition at run time in debug mode. But it is quite limited. This is probably old hat for JVM hackers, I do not keep myself updated on the Java/JVM side of things.

I came across Sun's (now Oracle's?) open-source(GPL) fork of the JVM that allows for changing class internals on the fly. The following analogy comes to mind DCE VM : JVM :: DLR : CLR

I quote:

  The class data structures of the Java HotSpot virtual
  machine are immutable during the execution of a program.
  While new classes can be loaded, it is not possible to
  change existing classes (e.g. add/remove methods or
  fields). This projects tries to relax this condition to
  allow arbitrary changes to existing Java classes
  (including changes to the class hierarchy) while running
  a Java program.

This looks interesting http://ssw.jku.at/dcevm/ and wonder if runtimes of dynamic languages could make use of this.

contextfree3• 15 years ago

I'm not familiar with the DCE VM, but DLR is a library on top of the CLR, not a different version of the CLR.

bad_user• 15 years ago

It is a library on top of the CLR, but it cannot function without CLR-specific capabilities.

For example DynamicMethod, which represents a method reference that can be created at runtime and garbage-collected when no longer in use; similar to the lightweight method handlers in JSR 292.

That said, modifying existing classes on top of the CLR is not possible, unless it inherits from something like ExpandoObject, but you can pull the same trick in Java (though not as easily until JSR 292 comes out).

MrMan• 15 years ago

This post may garner some down-vote for being non-rigorous, but I will offer my opinion on Scala so far. I accept it's good points readily enough when they are presented in list form, but when I read the language and try to reason in it, I just don't like it. Scala just doesn't feel like where I want to go. I do not want to embrace endless complexity in the form of hard-coded language features layered onto the language. XML literals instead of macros???? Please, I say. I have decided that Clojure will take the place in my dev life that Java and C# have occupied for the last 12 years. I hope that is the right decision.

thomaslangston• 15 years ago

I only have one complaint about Clojure. It is very unfortunately named. Closures, the programming construct, and Clojure are too similar sounding.

If I could rename Clojure and GIMP I'd do so in a heartbeat.

jpeterson• 15 years ago

> Closures, the programming construct, and Clojure are too similar sounding.

They sound identical, in fact, when Clojure is pronounced properly.

http://en.wikipedia.org/wiki/Clojure

cletus• 15 years ago

I actually like that both Clojure and Scala have names that otherwise don't mean something else. This unambiguity means you can more easily search for related pages and get more meaningful data out of Google Trends. Java will bring up some coffee references and the island in Indonesia. Python is, well, obvious. Just as two examples.

I'd much rather everything not also be something else.

GIMP is actually appropriate because AFAIC the program is completely crippled.

cageface9• 15 years ago

I'd encourage you to give some actual Scala coding a try. It can look dauntingly complex in short snippets and people often showoff complex stunts with the type system but once you actually start coding it makes a lot more sense.

You really can start by writing Java-in-Scala and then gradually making use of the more advanced features as you need them.

Clojure is great too, of course, but I think Scala is much more likely to gain a foothold in the programming mainstream.

zmmmmm• 15 years ago

Scala definitely needs more people like Bruce Eckel to start explaining it. I understood several concepts from this article that have eluded me so far because every other article I found descended in to abstract concepts of language or type theory without explaining what the practical uses of things were.

Unfortunately I think it may have missed it's peak opportunity to catch on because of this kind of problem - and a chronically buggy and unstable Eclipse plugin - but we'll see.

Egregore• 15 years ago

So we'll be waiting for "Thinking in Scala" book...

Scala: The Static Language that Feels Dynamic (Bruce Eckel)

Related Stories