Getting started with Scala's new macros

http://scalamacros.org/documentation/gettingstarted.html

by richdougherty • 14 years ago

16 34 14 years ago

lucian190010• 14 years ago

Every now and then I look around for ways to write native Android apps with something other than Java, and the only reasonable answer is still Scala.

But its syntax is so ridiculous! What on earth were they thinking?!

wiradikusuma• 14 years ago

how about Groovy? it's similar-ish with Java with less boilerplate. http://skillsmatter.com/podcast/home/groovy-android/

(disclaimer: i found the link from quick googling, never used it, but i'm quite familiar with Groovy)

lucian190010• 14 years ago

It doesn't seem like a significant enough improvement over Java. Similarly to how Scala seems a significant, but highly dangerous improvement over Java.

Its Android support is also not any better than JRuby or Rhino, both of which I prefer as languages.

noelwelsh• 14 years ago

It is actually very regular. There are a few rules:

a.b(c) = a b c

( <expr> ) = { <expr> }

<id>: is right associative.

That's about it. Once you know these you can decode just about any Scala program.

[Update: formatting]

lucian190010• 14 years ago

Not from what I've seen. There are a bunch of extra rules, an especially annoying set being those related to _

kenbot3• 14 years ago

Do you mean the macros specifically, or Scala in general?

lucian190010• 14 years ago

Scala in general, and the macros are an especially bad case.

cageface6• 14 years ago

I'm not too optimistic about this either. It's already easy enough to write very cryptic Scala. The potential for well-intentioned obfuscation is huge here.

I know the academic PL people shit on Go, but I'm really enjoying it so far just for it's minimalistic pragmatism. I really hope the rumors of Go support for the Android development are true.

bad_user• 14 years ago

Scala the language is not the problem, as it is consistent and the rules aren't really complicated. However, the culture around the language and the libraries are awful.

The problem with a language that has relaxed rules for syntax is that every complicated API ends up being a DSL. And you can do this with taste, or without taste.

Take SBT for instance. It is the standard build tool in Scala. SBT has many problems, the biggest one being that the chosen objective (type-safe DSL for project definitions) was the wrong problem to solve, with its second biggest problem being that it still relies on Maven. So instead of coming up with an alternative to the brokenness in Maven, the Scala folks that worked on SBT focused on only one of Maven's flaws (the XML config files, which were the least of everybody's problems).

And the DSL syntax in SBT is God-damn awful, with lines looking like this:

     libraryDependencies <+= sbtVersion(
       v => "com.github.siasia" %% "xsbt-web-plugin" % (v+"-0.2.10"))

The difference between this piece of shit and Ruby's Bundler is simply amazing. And newbies are exposed to this right from the beginning, as SBT is THE standard and as such every Scala library documents how to integrate with SBT ... in fact some libraries have such a dependency on SBT that integrating it with Maven or other build systems is a mystery (e.g. libraries that have a precompilation step).

So this is a language with a culture that (a) promotes cargo-culting through bad API design and (b) often breaks backwards compatibility.

cageface6• 14 years ago

My money is on Kotlin for an improved but still manageable JVM language:

http://confluence.jetbrains.net/display/Kotlin/Welcome

daniel_solano3• 14 years ago

Yes, Scala is currently the best alternative to Java for Android development, but I am hoping that Clojure can close the gap significantly.

The main drawback to Clojure is still the start-up time, but that's getting better. For example, the metadata elision introduced in Clojure 1.4.0 speeds things up a bit and makes a significant cut in Clojure’s heap use.

However, one thing that Clojure gives you that Scala cannot, is the ability to do REPL-driven Android development, i.e. sending code directly from your editor to a running application and seeing nearly instantaneous results.

One thing I hope will help Clojure significantly is that it has a Google Summer of Code student who is going to be working on improving the tooling support for Android and Clojure. This should make it much easier for Clojure developers to start creating Android applications.

lucian190010• 14 years ago

Being able to use Clojure would be great, but as you said not a viable option yet. GC pressure is the biggest problem, and it's one that sadly won't get solved too soon.

I've also looked at kawa (scheme), I might try that.

cageface6• 14 years ago

My understanding is that Clojure also relies heavily on some of the advanced Hotspot optimizations that aren't available in Dalvik so it's often much slower on Android than it is on the standard JVM.

islon2• 14 years ago

These are scala's macros? Lisp/clojure/scheme guys are probably laughing right now. I have nothing against scala but they really need to shoehorn every possible feature in the language?

kenbot3• 14 years ago

Scala's feature-space is admittedly crowded, but there is a method to the madness.

Scala's core design is generally to use a small number of rules to create a wide range of possibilities; the macro design they've chosen fits right in.

At the cost of almost no extra syntax, a whole range of things that would have required compiler plugins, special language features, or been flat-out impossible are enabled. It's (probably) a cheap win in this case.

islon2• 14 years ago

I agree, macros are a nice addition to the language and I would choose scala over java anytime. What bothers me is that scala has so much syntactic sugar one can die of diabetes just by looking at some source code.

Getting started with Scala's new macros

Related Stories