adriaanm

This guy has an agenda. I would check his numbers yourself.

Ditto. I just moved from the Bay Area to Lausanne for many of the same reasons (except the vacations: still working for the same awesome employer).

+1 I use them in Lausanne. 777 CHF/year is a great deal!

Interesting model: the price is the same for everyone, while bandwidth is the maximum they can offer in your location. Excellent support. I bought a TP-LINK MC220L + patch cables from them, and hooked up an edgerouter lite for PPPoE & VLAN tagging. Already had a wifi router (google wifi), which sadly can't do VLAN tagging. Haven't noticed any issues with the double NATing.

Good to hear! I agree :-)

It was a necessary transition because we need to keep attracting customers that initially are reluctant to invest in Scala training. We've found our Java APIs to be a potent gateway drug to Scala, with many of our customers who begin with the Java APIs quickly realizing they'll be even more productive with Scala :-)

Typesafe->Lightbend transition

The renaming never affected the staffing of the Scala team at Lightbend -- we've been doing about 2/3 of core Scala development (major thank you to the community for the other third!) since 2.10 (when I went from post-doc in Martin's lab to the Scala team lead position).

In my opinion, it was a good thing that feature development slowed down in Scala 2.x (while Martin pushed the research frontier forward in Dotty), so we could focus on (in no particular order) compiler performance, a new back-end and optimizer, Java 8 support, modularization,...

I am reluctant in part because Scala.js does not quite have financial support of Lightbend. Or so it seems, it's a bit hard to tell where Lightbend ends and the non-profit Scala Center begins.

As the Scala team lead at Lightbend, I'd love to have a few members of my team focus on scala.js and scala-native. We do financially support their development (most recently, as part of our funding of the Scala Center).

As a business, it's a bit of a chicken-and-egg problem: our customers usually indicate they are hesitant to switch from JS for their frontend work. It would be great to have more customers provide feedback like yours (via our customer surveys)!

Procedure syntax (the last two lines, lacking the `=`) will be deprecated in Scala 2.13. The two variants before those are due to type inference. Are you really arguing against type inference?

The empty argument list `()` is a convention to denote that a method has a side-effect, whereas a method with no argument list at all is considered pure.

Thanks for your balanced reply. Sadly, some people see it as a badge of honor to write super clever code that's essentially write-only, and Scala somehow triggers this in them :-)

We, as the Scala community, play an important role in shaping the culture of programming in Scala as one that embraces simplicity as the true elegance, maintainability and testability, friendliness and openness to criticism. The language will remain flexible (though we're always looking to remove warts), it's really up to your company culture to decide how to use it (which is different for different teams over time).

Many big players, such as Twitter, have done a great job with that (and continue to do so).

[Scala team lead at Lightbend here]

I'm always eager to learn how we can improve Scala, especially as we kick of the Scala 2.13 cycle (hard at work on compiler performance and standard library improvements). Email is 'adriaan.at("lightbend.com")

Regarding Scala's growth, I will leave you with https://www.indeed.com/jobtrends/q-scala.html.

Thanks, glad you like it! We at Lightbend (my employer) don't think of ourselves as very corporate, but we definitely sponsor Scala development. My team is hard at work on Scala 2.13 (well, except the part of it that's commenting on HN stories).

Which non-orthogonal and/or incoherent features do you have in mind?

The only thing on your list on your blog [1] that's still true is that we care about PL research. Since 2.10, we've worked really hard on improving the migration between major versions, and the feedback has been very positive. We'll keep working on finding the right balance between ease of migration and fixing issues in the libraries. Scala 2.13 will be a library release, with further modularisation of the library (towards a core that we can evolve much more slowly, and modules that can move more quickly, but where you can opt to stay with older versions as you prefer).

We've also invested heavily in incremental compilation in sbt. Sbt is meant for use as a shell, and it's super powerful when used like that. When I'm hacking the compiler in IntelliJ, recompiles of some of the biggest source files in the compiler (Typers.scala, say) take just a few seconds. I rarely have time for office chair sword fights anymore.

With Scala 2.13, half of my team at Lightbend is dedicated to compiler performance. We'll have some graphs to show you soon, but our internal benchmarking shows our performance has steadily improved since 2.10.

With scala async, you can also express this in direct style: https://github.com/scala/async.

Yep, 2.11.9 is the last planned release, but we would release another one for security fixes or anything as severe. If we get customer requests for backports, we (usually) also release those publicly.

Thanks for your support!

Thanks for the example. We agree that this is a tricky part in the collections. For Scala 2.13, our headline feature will be simplifying/refining the collections API. One of the areas we'd like to improve is to make the transitions from eager to lazy more clear. Also, we'd like to keep immutable (more) separate from mutable collections. Once we switch gears from 2.12.0 to 2.13 milestones, we'll be sure to provide a convenient way to share gotchas like this, so we can see how to prevent them.

I see how people might look at how close java & javax are, and think scala & scalaz are equally close. They are not. Scalaz is a completely separate project from the core Scala project.

As the Scala team lead at Lightbend, I'm truly saddened to see posts like this. It couldn't be farther from our intentions and interests! We absolutely want outstanding Scala documentation, and would never stand in the way of improving them in any way.

My whole team has worked extremely hard this year to bring you the best 2.12 compiler we can. We also spend as much time as possible helping out with polishing documentation, but we feel a coordinated push for better documentation belongs under the umbrella of the Scala Center (whose mission is to "Independently guide and support the Scala community" and to "Provide deep, and quality, educational materials for Scala"). We'll be thrilled to collaborate, but we (as veteran Scala users) are not the best placed to write getting started guides.

EDIT: It was brought to my attention that my comment about the Scala Center could be misinterpreted. I meant to say I would support a proposal to the Scala Center advisory board about improving Scala's documentation, with a focus on the getting started experience.

None of this makes any sense to me (except that these unfounded claims are not charitable). Lightbend (my employer) builds our whole platform in Scala, and we are proud to say you'll have the best experience using it from Scala (though Java 8 will do too, if that's more your jam). Sure, we make some money from training, but we are far more interested in having as many people use Scala so that they'll be even more productive using our platform.

My team at Lightbend is responsible the majority of the Scala 2.x compiler and standard library work. That's our focus. We do try to help out on the documentation front over at https://github.com/scala/scala-lang. You can easily see for yourself that 90% of the PRs there get merged.

Don't boo -- submit a PR!

True Scala 2.12 generates byte code that requires a Java 8 VM. Scala 2.11 will be supported for a while longer, with as many as the 2.12 features implemented there first (those that don't require Java 8).

Keen eye! The release is tagged and the artifacts are indeed on maven central, but we are holding the official announcement for a few days to be able to launch with a nice set of community libraries already published. So much for flying under the radar :-)

In addition to being supported by the community, we (Lightbend) offer commercial support for Scala 2.11. If you're paying Oracle for Java 6 support beyond its EOL, perhaps you'd be willing to establish a commercial relationship with us as well? That said, the vast majority of our customers are eagerly upgrading to Java 8 (https://news.ycombinator.com/item?id=7346224, https://info.lightbend.com/COLL-2014-10-20-Java-8-II-Survey-...)

Yes, if you're tied to Java 6, you're also tied to Scala 2.11. Why is the former version peg ok but not the latter? We do everything we can to enable 2.11.x maintenance by the community (and contributions are trending up!), as well as doing some of our own -- time permitting. If you'd like to get commercial support, we do offer that to our customers.

The code emitted by 2.12.0-M5 is slower in certain benchmarks, but I don't expect this to be the case for the final 2.12 release.

We're working on the performance issue, with help from the team at Oracle. The problem is likely the JIT having trouble optimizing the bytecode we emit in M5 (we know of other schemes that don't suffer this slowdown, but require more bytecode).

Hi, Scala team lead at Lightbend here (I left academia in 2012 to lead the team). We dropped Java 6 because we did not anticipate any business case for it, based on surveying our customers (we have continued to monitor the adoption of Java 8 amongst our customers, and everyone is upgrading, save for android).

We did consider (and regret) potentially leaving android behind, but we were (perhaps naively) hoping that something like retrolambda would suffice, or that android would catch up. In any case, it doesn't make a lot of sense to have 2.12 still support Java 6, since most of its features require Java 8 (those that don't, we first implemented in 2.11.x).

As announced in http://scala-lang.org/news/2.12-roadmap/, we will continue to support 2.11 for a bit longer than most releases, and we welcome community backports of 2.12 features that you'd like to see in 2.11.

Thanks, I appreciate it! Also, thank you for sharing your feedback & concerns. I acknowledge we need to communicate more.

We share your concern. As I said in my comment above -- the Scala and Dotty teams actively work together (we have our roots in the same research group at EPFL) to make sure Scala 2.x evolves towards Dotty and Dotty evolves towards Scala 2.x. Scala 2.12 and 2.13 will have language flags that unlock features being incubated in Dotty that we can already implement, and the Dotty compiler already has a Scala 2 compatibility mode.

We take continuity very seriously. No one wants a Python 3-style transition. In addition to the desire to avoid this, we also have a type system and a community build (think Google Blaze for Scala) that builds > 1MLoC OSS Scala code.

Wrong, there's more Scala than Java in Lagom's implementation, as is easily verified on the link you provided yourself. See my comment above on some more info on the Scala team.

Without getting too philosophical, I don't see what's so ominous about the present not being the future or vice versa. All we have is the present, really.

It's easy to verify for yourself who's working on Scala right now: https://github.com/scala/scala/graphs/contributors (work on Dotty started around 2012, when I moved from EPFL to Typesafe).

Myself, retronym & lrytz are on the Scala team at Lightbend. I'm proud of what we've accomplished with 2.10, 2.11 (8 minor releases!) and 2.12 (RC1 coming soon -- see my comment above), and excited about what the future holds for Scala! We work together closely with Martin's Dotty team, exchanging ideas about compiler performance and convergence of language features in Scala 2 and Dotty (the incubator for the future of Scala).

I'd love to turn off write-access to JIRA and move to GitHub for new tickets. We'll get there, but first need to finish this release everyone's waiting for :-)

Hi, Scala Team Lead at Lightbend here! We are working hard on getting 2.12 out. Almost ready!

While the theme for 2.12 is easily summarized (Java 8), I assure you the changes behind the scenes go all the way to the core. Compiling lambdas and traits to the best Java 8 bytecode we can think of, unifying type checking of Single Abstract Method types and Scala's built-in function types, as well as rewriting the whole optimizer and byte code emitter was no small feat! It's been very satisfying to rework these parts of the compiler, and I'm excited to see 2.12 going live soon!

We're cutting the last milestone (M5) this week, with RC1 scheduled for the second half of July -- assuming M5 is well received. We're pretty confident, as we build over 1MLoC of OSS Scala every night using dbuild (see scala/community-builds on github).

We at Lightbend care deeply about language stability and compiler robustness, as we believe they are key for driving Scala adoption by the community and the enterprise alike. Being PL researchers, we are also excited about simplifying and evolving Scala! This is why we're working on a smooth & steady migration path towards the ideas being incubated in Dotty.

Scala's process is a dialogue, which means coordinating with Martin Odersky and his teams at EPFL and the Scala Center, as well as the whole Scala Community. Ultimately, we at Lightbend set the Scala 2.x roadmap based on this consensus (since 2.10), and take on OSS development and maintenance (as well as commercial support for our customers). With the founding of the Scala Center, we're happy to share governance, while remaining as committed to the day-to-day engineering and representation of the pragmatic robustness and careful evolution voice :-)

This dialogue comes naturally to us, as half of our team are alumni from Martin's lab (Lukas & I have been working on the Scala compiler for almost 10 years, ranging from adding support for type constructor polymorphism in Scala 2.5, rewriting the pattern matcher in 2.10, implementing named & default arguments, while working on the theoretical foundation of an effect system for Scala as well as the core of Dotty), while the other half are long-time contributors to all aspects of Scala.

Sure, releases sometimes slip a bit -- we are a small team (we're a small company -- our team size is no outlier), and while we get to spend the vast majority of our time working on OSS, we also have some commercial obligations inside the company (e.g., Scala support tickets are handled by us). The other reason is that we have worked on 2.11 for 6 months longer than we usually spend on a major release, because we wanted our Java 6 users to get as many of the 2.12 features as possible on their platform (2.12 requires Java 8), as well as providing a preview of the new ASM-based back-end and optimizer.

The Scala team at Lightbend takes care of half of all PRs, with the other half being contributed by our awesome community (including EPFL, though they mostly focus on their research and Dotty, which is how things are supposed to be). We've worked hard on making it easier to contribute to Scala, and I'm very glad to see the rate of community contributions trending up!

The Scala and Dotty teams talk regularly (we just had a Dotty & Scala summit before Scala Days), to exchange tips on compiler performance as well as to work towards convergence for Scala 2.x and Dotty. For example, the 2.12 trait and lambda encodings were tried first in Dotty, with our real world adoption of these ideas feeding back into the Dotty compiler. For 2.13, we're planning feature flags to implement the first wave of Dotty features and restrictions (and vice versa for Dotty emulating Scala 2), so that you can start migrating your code bases. For some more background, here are our roadmap updates: http://www.scala-lang.org/news/2016-schedule/, http://www.scala-lang.org/news/roadmap-next/, http://www.scala-lang.org/news/2.12-roadmap/.