
Typesafe Changes Name to Lightbend - jlward4th
http://www.lightbend.com/blog/typesafe-changes-name-to-lightbend
======
16bytes
"Lightbend" as a name is I think the least interesting part of this
announcement.

So, Typesafe pivots away from being the company behind Scala to being the
company behind the "Reactive Platform (tm)".

I didn't understand the motivation at first--they announced they were going to
do this a while ago--but this sentence sums it up:

> ... with more than half of our customers representing traditional Java
> enterprises. We continue to evolve, becoming more language agnostic ...

I can understand this. While I always liked the Typesafe brand because of it
tech connotation and implicit relation to Scala, if you want to diversify
outside of the Scala box, you'll have to change the name.

As a Scala fan, however, it's hard to not see this as a blow to the community.
Having Typesafe behind Scala was one of the major advantages of choosing
Scala, and IMHO the primary reason Scala adoption spread wider and faster that
Clojure, Haskell et. al.

I was hoping the JVM community would coalesce around one post-java language
and I was hoping it was Scala. But now add Kotlin to the mix of Groovy and
Clojure, and the future gets murkier. Especially with the mind-share and great
communities around Rust and Go.

This is probably a good thing for Typesafe/Lightbend, however. The Scala
ecosystem had been tough to monetize. Putting their full weight behind
commercial offerings on top of FOSS foundations seems like a better business
strategy.

~~~
acjohnson55
Rust _could_ be the future, but I just don't see it for Kotlin. Scala's not
perfect, but moving to Kotlin leaves a lot on the table. It reminds me of
Swift in the way that it left out a lot of Scala at the outset, but appears to
be slowly growing Scala-like functionality. At some point, I'm like, maybe
life would be better if people just used Scala or languages that attempt to
build on its techniques, rather than scale them back.

~~~
azth
> but I just don't see it for Kotlin

From what I understand, Kotlin will be gaining more features slowly but
steadily, similar to what you describe for Swift. I think that Kotlin's
ability to integrate seamlessly into any Java codebase (at least in theory) is
one of the strongest things it has going for it. Plus being backed up by
Jetbrains, with very strong focus on providing a top notch IDE experience.

~~~
acjohnson55
How would you distinguish Kotlin's and Scala's Java integration? I only use
Scala, but don't use it within a larger Java codebase, but my understanding is
that this is pretty straightforward.

~~~
azth
You should be able to drop in a Kotlin file into any Java project, and mix and
match as you choose, without having to restructure the entire project, and
move to a different build system.

~~~
acjohnson55
You still need to build it with a Kotlin compiler though, right? Assuming you
install the Scala compiler directly, rather than relying on SBT, you can do
the same.

~~~
azth
I tested it out a bit, it seems that first, the Kotlin files get compiled with
the Kotlin compiler jars; after that the Java files get compiled with javac.

------
insulanian
Gut feeling and first-second impression: Meh...

I felt somehow connected to the Typesafe name. It felt tech-y, dev-y, but this
one is somehow... non-charismatic.

~~~
redtuesday
Yes, this sounds more like a optics company.

------
virtualwhys
Given how long it took relative to the original announcement that a name
change would take place (more than a year ago IIRC), I thought the idea had
been shelved, apparently not.

Guess it doesn't really matter what the name of the company is, so Lightbend,
Streamy, Scalewhale, etc. all make sense. The logo though, really? Looks like
a 3rd place winner from the local kindergarten arts and crafts contest.

Anyway, wrt to Scala, Lightbend's focus seems to have shifted at least in part
to enterprise Java, which by necessity means less resources for Scala
development. Probably explains the delay in the Scala 2.12 release: the core
developers are too busy serving 2 masters (Lightbend clients and the
compiler).

Well, moving forward Scala's surthrival depends on the community and continued
popularity of libraries, not so much the company behind the language.
Fortunately EPFL provides an ongoing stream of R & D to help bridge the gap
created by Lightbend's semi-pivot.

------
atemerev
Goodnite, sweet prince.

On one side, I support Odersky's decision to focus on Scala's simple and
modular next version, Dotty (the present one became a Flying Spaghetti
Monster, without the flying part). But as for now, Scala is effectively dead.

~~~
MrBuddyCasino
"Dotty is a platform to try out new language concepts and compiler
technologies for Scala." [0]

Why should Scala be dead for now? I agree its a Flying Spaghetti Monster, but
so is C++.

[0] [https://github.com/lampepfl/dotty](https://github.com/lampepfl/dotty)

~~~
lmm
As a huge Scala fan, I fear that Dotty will suck the oxygen away. In
particular, freezing the syntax for as long as the proposed timeframe for
Dotty to be delivered would kill any language.

I would urge typesa^H^Hlightbend to bring forward the introduction of vital
syntactic features from dotty (e.g. existentials as HKTs, if they really think
that's the best way to express type lambdas). Even if that involves making
large changes to scalac that will have to be thrown away, the Scala community
cannot survive with the syntax the way it is for much longer.

~~~
allengeorge
Of all the things holding Scala back, frozen syntax is the _least_ of its
worries.

My two biggest day-to-day peeves are:

    
    
      1) The poor quality of the entire tool chain
      2) Immature libraries and ecosystem
    

Tool chain: from the slow-as-molasses compiler, to the fact that every so
often IDEA gives up and refuses to parse parts of our project, to the horror
that is SBT, working with Scala just feels* painful. Heck! - my Macbook Pro
sounds like it's taking off whenever I start a Scala compile, and if I'm
building from scratch? [https://xkcd.com/303/](https://xkcd.com/303/)

Libraries and ecosystem: many opensource Scala libraries feel more like
experiments in language wrangling or narrow (exposing only a tiny subset of
the underlying features) wrappers for existing Java libraries than well-tested
code. Documentation? Almost always spotty. Library community? Spotty. Source?
Good luck reading it. Depending on the author's bent it can range from vaguely
understandable to downright inscrutable. (On this last point: I've often poked
around various Java/Python/Go/C libraries and been able to figure out fairly
quickly what's going on. Much less so with Scala.)

Besides those two points - Scala is _complex_. To a newcomer the language is
unfriendly and has a lot of rough edges. You have to build a lot of context to
interpret existing Scala code - and much of this context is incidental to the
problem at hand. This makes it _very tough to incrementally learn about Scala
features /syntax_ and slowly explore an existing Scala code base (especially
an opensource one, where authors are more likely flexing their advanced Scala
knowledge). And all that syntactic sugar? Terse. Elegant. Unintelligible to a
newcomer.

Sorry. /rant over.

~~~
lmm
There are better options on the tooling. Eclipse rather than IDEA, Maven
rather than SBT. Not perfect by any means, and the compiler _is_ slow, but
good enough to work with day-to-day.

The library ecosystem is growing every day, and the community is starting to
recognize the importance of good documentation. See e.g. the Cats project,
with a big emphasis on that.

Code readability in general, rough edges, and things that are difficult for
newcomers to read incrementally are precisely why I'm so worried about the
syntax being frozen.

~~~
the_af
Is Eclipse (Scala IDE) better than IntelliJ now? About a year ago people
convinced me to switch _to_ IntelliJ because Scala IDE was _totally unusable_
, full of spurious compilation errors and useless refactor that introduced
random symbols instead of doing its job.

So has the situation been reversed now?

~~~
lmm
Eclipse still has problems, its refactoring doesn't really work, and the UI
locks up every so often, but its compiler is substantially more reliable than
IntelliJ's. It's a case of picking your poison really.

------
tunesmith
Not bad, I was worried they'd pick some version of "reactive" to confuse us
all even more.

------
alblue
The problem is threefold.

Firstly, as the letter notes, the majority of people using
TypeSafe/LightBend's services are in fact "traditional" Java shops. This
suggests that - in the enterprise at least - there's limited Scala
penetration.

Secondly, the move to a more generic name (LightBend) is one more step away
from their core competency. The name TypeSafe was chosen to highlight a
particular aspect of the platform they felt was important. Although they
likely still do, their customers don't appear to appreciate it (or at least in
the same way it was meant, as an advert for Scala).

Finally the bifurcation of technical resources between ongoing Scala
development and Dotty as a research project are likely to come up short in
both regards. We are on the cusp of Java 9 being released within the year and
Scala's big backwards incompatible step forwards with Java 8 still hasn't
happened.

At the least you'd have to be a gambling person with a penchant for long odds
to continue with Scala at this point.

~~~
estefan
> At the least you'd have to be a gambling person with a penchant for long
> odds to continue with Scala at this point.

Rubbish. Banks have gone in on scala + spark and are paying top dollar.

~~~
Eridrus
I was at Spark Summit East last week, and a lot of users are Python users,
rather than Scala users.

So I could definitely see people moving away from Scala there.

~~~
gclaramunt
Are you sure they moved from Scala to Python or they're just Python shops
using Spark? (I strongly suspect the latter)

~~~
Eridrus
Probably the latter, just pointing out that the health of Spark doesn't
necessarily say a lot about Scala's health in the long term.

------
seanmcdirmid
Actually not a bad name, and it sounds more "do good" rather than mostly
"prevent bad" as TypeSafe did.

~~~
the_af
On the other hand, Lightbend is so generic and bland, while TypeSafe, at least
for those "in the know", has a nice technical ring to it.

I guess bland & non-threatening trumps meaningful in enterprisey software.
Still, very disappointing, especially if it signals a lack of focus on Scala.

~~~
seanmcdirmid
Meh, if you are into the academic PL community's fixation on "preventing bad",
TypeSafe is a perfect name, but as soon as you step out of that bubble, it
sounds just as bland and enterprisey as say...SalesForce or PeopleSoft.

Scala isn't just a safe language, heck, it is not even an especially type safe
language. But Scala allows you to do more, not do the same things
significantly type safer like say...Haskell, Rust, Ada, or Agda. The name
"TypeSafe" sends confusing signals in that respect. Scala does increase
expressiveness without sacrificing type safety, but doesn't really focusing on
going beyond that. Correcting that misconception is reasonable, and Lightbend
more aptly emphasizes this "do more good" aspect.

Lightbend is a generic name, but not particularly so. It doesn't have an
enterprisey feeling to it, and even if it did, that wouldn't be a negative
with its potential money-paying customers. As far as the "focus on Scala" go,
I think Martin Odersky has already decided to focus on Scala while the company
focuses on promoting the Scala ecosystem, which is also quite reasonable and
should bear fruit.

------
merb
Offtopic:

When people talk about the slow "Scala" compiler I always wonder what they
actually do. I mean most of the time you are lightyears slower I thinking how
to solve the problem than the compiler compiles. I mean changing a file
compile -> looking at the result takes on my machine mostly 1-2 seconds
(incremental compilation). Javac isn't lightyears faster and on go I would
take nearly the same time, only full compilation is way way faster.

~~~
harveywi
The Scala compiler is excruciatingly slow for me. I frequently rely on
polytypic programming techniques to prove (with a small "p") that my code is
correct. The compiler simply can't keep up with me.

The end result is that my state of flow is continually interrupted, or at
least under assault. Bobbling my head to trance music while implicits are
resolved is the only antidote that I know of.

~~~
merb
Do you really need so many implicits? I actually learned that they will do
more harm than good. I try to avoid them, where ever I can. And actually the
playframework doesn't take so long to compile, to make sbt publishLocal after
a clean takes no longer than 5 minutes (travis needs 40-50 minutes not sure
why) for me, which is actually really fast. I mean running every tests every
time takes a while, but I think that people should start incremential
compilation / test if they want a fast workflow.

------
dv35z
Meta: Recommend changing the HN title to "Typesafe (makers of Scala) Changes
Name to Lightbend".

Personally, I am very interested in Scala, but didn't immediately recall that
Typesafe was the company that owns it when I saw the article title. The
conversation here is valuable (about roadmap, developer sentiment, etc), so
don't want folks to miss out.

------
jkot
Sounds like a Javascript framework or Lighttpd.

------
aaronbrethorst
Because nothing says nimbleness and agility like a name that suggests you are
so heavy that you distort the very fabric of spacetime.

What's the backstory on this company? Who are they and why are they on the
front page of HN?

~~~
edko
There is no minimum mass required to bend light. Why does bending light
suggest something "so heavy" to you?

~~~
mintplant
I assume aaronbrethorst is thinking of gravitational lensing.

