
Typesafe acquires Spray.io - octo_t
http://www.marketwired.com/press-release/Typesafe-Reactive-Platform-Acquires-New-High-Performance-HTTP-Foundation-1841738.htm
======
memracom
Wow! When I started working with Scala, I realized that its actor model was
sort of like Erlang, but missing stuff like the supervisor tree which is
rather useful. So I looked around, and discovered Akka. Shortly afterwards,
Typesafe was formed by merging the groups creating Scala and creating Akka.
Then, my company was moving towards a services oriented architecture that used
the HTTP api as its core for accessing services. I felt that this was
inefficient, especially because you couldn`t do any message queuing or event
related stuff without layering it over the top of HTPP`s RPC calls. That
seemed counterintutive because fire and forget messaging is a more fundamental
construct than RPC. Then I discovered Spray which had already done a lot of
the groundwork needed to have an HTTP composition technique for services, plus
it even had a more efficient HTTP server to use when you needed to allow for
HTTP RPC. And now, Typesafe has joined with Spray.

This is making Scala look more and more like _THE_ Java successor. Clojure is
still a strong contender, but the Typesafe activities have really pushed
Groovy out of the ring, as well as things like JRuby and Jython. I doubt that
Java will ever go away, but I can see that Scala and/or Clojure will
eventually supercede Java as the main development language for the JVM.

And this is important because the JVM is showing signs of moving into the
dominant position in the new world of massive multicore. It may never muscle
out things like Erlang/Elixir or Python, but it will probably be the core
dominant platform of this century.

~~~
smrtinsert
I don't think Scala and clojure are in competition. I perceive Scala as a
practical enhancement for Java built for performance and
maintainability/tooling. I see Clojure as more of an architects language,
great for high level exploration of ideas.

I'm learning both and really like both. I do wish that clojurescript was as
easily developed as clojure is. I think scala-js seems to be the stronger of
the ->js projects. Scala-js now also supports the closure compiler which makes
for nice small distributions; this is compelling in the age of html5.

~~~
brandonbloom
> I think scala-js seems to be the stronger of the ->js projects

What makes you say that?

(I'm a CLJS contributor. Just want to help improve it)

~~~
smrtinsert
I'm slightly biased in that I've played with cljs more than scala-js, but it
was tough to find a productive workflow from the time I started looking into
it. For example with lein-droid you run a lein command to start the android
app with embedded repl and connect to it, with seesaw you can use your local
repl, with clojurescript ???

Instead there seemed to be a whirlwind of finding info on lein-cljsbuild/cljs
and dealing with little problems like the repl not finding jarred or external
js files. also online theres all sorts of grumbles about browser repl
instability so it gives you a big warning feeling even though it seems like
the only way through. Ultimately I felt lost in the tooling and setup. I
haven't had time to investigate clojurescript in lighttable, maybe its easier
there. I just figured any editors repl and the source files should be all you
need to start working productively with it.

By contrast I haven't done much scalajs yet, but it builds like just another
sbt project (after a local install of the scala-js project itself). I was able
to clone the sample scala-js app run sbt;/packageJS and see the js file. Sure
that's not updating live, but its clean and straightforward from the first
time you investigate it. 5-10 minutes to "wow".

Good luck, I really want clojurescript to become easier to use as I really
enjoy clojure.

~~~
brandonbloom
cljs-build is very good for non-interactive workflows, but I agree that the
REPL situation is less than ideal. I mostly develop in a CLJ REPL and then
only test in the browser with auto-refresh, in a more traditional web-app
style.

The browser REPL is the biggest offender, but luckily there is now
[https://github.com/cemerick/austin](https://github.com/cemerick/austin) which
is a huge improvement in usability, stability, and features. Give that a try!

------
programminggeek
I think it is really interesting how Typesafe is basically acquiring
everything good/interesting in the Scala space. It makes for a very different
ecosystem than say ruby or clojure or go.

I think this is actually a good approach for making Scala something that
larger companies will rely on, while benefitting smaller shops and individual
developers.

Now, if only Typesafe would either build or buy a scala compiler that is as
fast as go's. If they did, I would be a scala developer like yesterday.

~~~
benmccann
I think that's impossible. One of the reasons Google developed Go was to be
able to compile its large code base quickly. Compilation speed was built into
the language from the beginning. Meanwhile, Scala continues to add every
feature under the sun without a thought to compilation speed. I can't see them
removing enough language features to improve compilation speed enough to catch
up to Go (although I wish they would).

~~~
saryant
> I can't see them removing language features to improve compilation speed
> (although I wish they would).

That's why Scala 2.11 removes features from the core compiler.

[http://docs.scala-lang.org/scala/2.11/](http://docs.scala-
lang.org/scala/2.11/)

~~~
ghostdiver
it's a bandaid

------
kodablah
Spray fits nicely in with Akka and I expect HTTP to just become another Akka
feature (the way the new IO is, which included assistance from Spray devs
IIRC). I wouldn't be surprised to see
[https://github.com/eligosource/eventsourced](https://github.com/eligosource/eventsourced)
moved into Akka more directly at some point too.

~~~
rit
That is already happening. We are moving Eventsourced into Akka to become
"akka-persistence":

[https://groups.google.com/forum/#!msg/eventsourced/B2Nx4HJB-...](https://groups.google.com/forum/#!msg/eventsourced/B2Nx4HJB-
tA/mbI0PHZpfEQJ)

------
tenpoundhammer
Typesafe continues to show that they understand the needs of the scala
development community. I couldn't be more impressed with their work.
Furthermore, their great work basically makes it impossible to work with
anything not supported by typesafe, because everything else will eventually
become unsupported.

