
Scala Center - neverminder
http://scala.epfl.ch/
======
jowiar
Awesome -- I'm super glad to see there's going to be some leadership by the
folks from the "Scala, a language for making nice software" contingent to
balance out the echo chamber of the "Scala, where if you don't have a graduate
degree you're going to feel like a moron" contingent.

Edit: To clarify what I mean --
[http://underscore.io/blog/posts/2015/06/10/an-
introduction-t...](http://underscore.io/blog/posts/2015/06/10/an-introduction-
to-cats.html) exemplifies, to me, what is wrong in Scala-land. If Abstract
Algebra is prerequisite knowledge for tools I 'really should be using',
something has gone horribly wrong.

~~~
ane
That's... actually simple stuff. Have you had a look at Scalaz? Or Shapeless?
The whole point of Cats is to solve the overkill of Scalaz, where you
sometimes _do_ need algebra, by making abstractions simpler and safer to use.
Remember, nobody is forcing you to use this wizardry in Scala. You can write
it in a simple, matter-of-fact better Java style; or you can leverage the
power of abstractions to create something advanced. You don't have to indulge
in applicative functors and coproducts just because. Use them wisely, if at
all!

~~~
jowiar

        That's... actually simple stuff.
    

If you have the prerequisite knowledge. Most people don't. And then somehow it
always manages to lead to codebases that look like `a \~=>>> b`.

    
    
        nobody is forcing you to use this wizardry in Scala
    

Except that sorting out things in open source code absolutely does entail
dealing with this. With JS, Python, or Java, I can dive into just about any
open-source codebase, and at least get some clue as to what's going on. I
think a large part of why Scala's open-source situation is pretty awful is
that so many Scala codebases are a bunch of dudes waving their [censored]s
around, using libraries that consist of inscrutable squiggles and meaningless
terms, just to demonstrate how smart they are.

    
    
        You can write it in a simple, matter-of-fact better Java style; or you can leverage the power of abstractions to create something advanced.
    

This is a false dichotomy. When I look at code written by Martin Odersky, I
don't see people trying to brag about their grad degrees through their code.
And the reason this project makes me so happy is that it really feels like
"the good people" of Scala reclaiming the community from the LambdaBros.

~~~
eastWestMath
If it's something a sophomore with no background beyond calculus can handle,
it is simple stuff. It's ridiculous that treating software engineers as though
they have a bachelor's degree in STEM makes you a "LambdaBro."

~~~
jowiar
It's disingenuous to say that this is included in a "bachelor's degree in
STEM" \-- it's part of a specific course of study.

Part of the reason this issue pisses me off so much is that I have a degree
from one of the top CS programs in the world. I was definitely more of a
theory than a systems person. And yet it still feels like a pile of
unnecessary ego-stroking gibberish.

I feel comfortable saying most people who make software are less-experienced
in this area than I am. When I run into this, I can at least say: "This is
bullshit", and not feel the imposter syndrome of "It's just me -- I'm not
smart enough for this" that I imagine most people feel.

Beyond that, functional programming is, by and large, easier than imperative
programming. I love writing Scala -- It's honest about side effects, honest
about concurrency, and has one of the better type checkers around. And I'm
sick of seeing people try to "fence off the riffraff" by raising the barrier
of entry to the Scala community.

~~~
bgar

      Beyond that, functional programming is, by and large, easier than imperative programming.
    

You say this but dislike even a bit of abstract algebra? I see a conflict
here; anyone that likes FP, moreso, typed FP, should be familiar with simple
concepts like monoids, functors, and monads. Honestly, I don't understand how
someone can write in a functional language and _not_ know these concepts....
they're literally Haskell 101. That doesn't even scratch the surface of what
FP can do...

~~~
jowiar
To me, functional programming's advantage comes from avoiding reasoning about
state. Everything else is gravy.

Beyond that, it's very easy to go down a rabbit hole of terminology.
Javascript programmers write functors all the time, but I don't know if I've
ever seen the word "functor" written in a JS context by anyone other than
raganwald. They're just functions, and the fact that they return functions is
damn useful.

~~~
bgar
Yup I've never seen functors mentioned in anything JS-related. I bet there's
more Haskellers writing Scala than JavaScript though.

Being pedantic: functors don't return functions, functors let you map over
structures.

------
kjaer
Here's the blog post about it: [http://www.scala-
lang.org/blog/2016/03/14/announcing-the-sca...](http://www.scala-
lang.org/blog/2016/03/14/announcing-the-scala-center.html)

------
Cyph0n
What with the recent TypeSafe news, this is quite reassuring. I love Scala and
would have been devastated if it ended up going into financial backing limbo.

~~~
ktoso
Typesafe/Lightbend continues to back Scala as it always did, no change there.
Scala Center is a great additional move to get additional people / resources
to work on Scala :-) So while "the recent typesafe news" are nothing to worry
about, the scala center news are very awesome for the entire Scala community
:-) (disclaimer: Akka team here)

~~~
Cyph0n
Great to hear! I have yet to use Akka seriously, but I'm planning to soon.
Keep up the awesome work!

------
systems
ok, this is a sincere question

i've read a lot of negative opinions on scala, that it's becoming too big and
too complex

and honestly, i was kinda sorta, waiting for it to fail or fall out of favor

this doesnt seem to be happening, on the contrary, scala seem to be getting
more popular, compared to language which i favored (like clojure or f#)

are the negative opinions wrong, overblown, or is scala really heading for
failure, what am i missing, what did i see wrong

~~~
lmm
The negative opinions were overblown. A lot of them were complaining that
something that's impossible in other languages is hard or difficult to learn
in Scala, or real but superficial problems. The language has plenty of warts
and there are some bad libraries and tools out there, but all these things are
superficial and transitory; the core is sound and I expect all successful
future languages to have a very similar design.

To give an equally sincere response: dynamic languages are dead, and languages
without higher-kinded types are dying - they're too useful to do without, and
Scala shows they're practical. We're still discovering more things you can do
with Scala.

I think the language we'll be using in ten or twenty years' time won't be
Scala - or it will be a Scala that's changed unrecognizably from the Scala we
know today. But I think that whatever language it is will have a strong type
system with type inference and higher kinds and some kind of typeclass
functionality and probably also traditional-OO subtyping (failing that at
least Go-style delegation), will allow method calls without brackets and
concise lambdas with something like "_", will have a culture of not using C
libraries via FFI, and will be strictly evaluated. If you wrote a clean new
version of Scala today there's a lot you'd leave out (you might end up with
something that looked rather like Ceylon), but I think those things are here
for good. Maybe it'll be Idris, maybe something else.

~~~
mafribe

        the core is sound 
    

I agree completely. It might be interesting to spell out what that this core
is: it is the _successful_ marriage of ML-style functional languages with
class-based OO.

The core idea of ML is this: strongly typed with parametric polymorphism and
full sum and product types, type-inference, first-class functions, first-class
state, (almost) first-class modules. Exceptions as first-class non-local
control mechanism.

The key innovation Scala have over its predecessors Ocaml and F# which also
attempted this merger is that Scala recovers ML-style functional programming
as a special case of OO programming, while the predecessors when the other
way, which didn't work so well.

~~~
willtim
Much of Scalas complexity comes from trying to encode ML features using
subtyping and class-based OO. So I think the jury is still out on whether
Scala represents a successful marriage. There are other ways to add first-
class modules (objects) to ML, the most interesting is probably the new "1ML"
paper. Personally I would rather have OOP encoded in a functional language and
not the other way around. This would avoid many of Scala's warts such as a
nominal core (e.g. Function1-22), methods not first-class, pattern matches
that runtime cast etc.

~~~
mafribe
Depends on the criteria of success. Maybe OO and typed FP can be merged
successfully in more than one way.

I agree that that 1ML is interesting. Some of the warts come from JVM/Java
compatibility. In what sense would you argue that OOP _can_ be successfully
encoded on top of a typed lambda-calculus? Finally, the relative simplicity of
DOT [1] indicates that Scala's core is not that complicated.

[1] N. Amin et al., The Essence of Dependent Object Types.
[http://infoscience.epfl.ch/record/215280/files/paper.pdf](http://infoscience.epfl.ch/record/215280/files/paper.pdf)

~~~
willtim
The criteria of success for me is simplicity and generality. The part of OOP I
am interested in is first-class modules, being able to package up types and
functions acting on those types into records. Dotty is not the core of the
current version of Scala. It does look interesting, but personally I would
prefer an approach that does not use subtyping. My point is only that Scala
does not represent the last word in FP+OOP.

~~~
acjohnson55
Interestingly though, Scala's model is basically Javascript, with a sound type
system. As much as classes have been discredited as _the_ fundamental
structure of a system's architecture, they still prove their usefulness in
Java and all the dynamic languages, and now a new crop of languages, like
Swift, Rust, and Kotlin. So, I'd suggest that the Scala route may well be the
path forward, especially post-DOT.

~~~
lmm
Huh? Scala has nothing remotely resembling Javascript's weird prototype thing.

~~~
acjohnson55
True, there's nothing in Scala that's like the dynamic inheritance/delegation
of JS. But I'd say that in practice, people use Javascript's prototype
functionality to implement static class- or mixin-based OOP.

~~~
lmm
Well sure, but I'd say Scala's model is more similar to any of Java, Python,
Ruby or C++ than it is to Javascript. So I don't see that it's a "Javascript
model".

------
josep2
Fallen in love with Scala in the last 3 months. Happy to see more support.

~~~
kailuowang
May I ask which language are you mainly using other than scala?

~~~
josep2
Other than Scala I write Node.js and Python.

------
deepGem
Spectacular news! Really excited to see the Coursera MOOCs being offered again
as well.

~~~
redtuesday
I'm curious if users can get free certificates like in the past, or if they
will have to pay for them.

~~~
deepGem
You'll get a completion certificate for free. What you won't get is an
accredited certificate that you can show off on LinkedIn, to potential
employers/investors etc.

------
airless_bar
Great news! Nevertheless, some people will still manage to spin this
announcement into some proof that Scala is dying!!! (this time for real!)

~~~
vzip
One of the few languages that, when dying, appears to increase in use.

~~~
merb
The thing is that most of the things that people don't like with scala will
actually disappear without doing anything.

One of the greatest problem is compilation time, however since computers get
better this will be reduced. And still the team is working to bring more Scala
<-> Java interop and a newer compiler which will bring compilation times down,
too.

~~~
cosmolev
Single thread performance is not getting better anymore. Addition of new cores
does not cut compilation time (at least for Scala compiler).

~~~
airless_bar
See also

    
    
        Improved incremental compilation of #scala in the
        making yields 10-40x compilation speedups:
        https://github.com/sbt/sbt/issues/1104#issuecomment-188529825
    

and

    
    
        After turning on the java8 backend in Scala, our 
        bytecode size decreased by 50% and compile times
        decreased by 75%. Amazeballs!
    

by some Scala devs.

~~~
merb
Actually after I truned java8 backend on I got a reduced compile time. (after
changing code). Actually we use Scala as a Improved Java, so we likely don't
use so much "heavy" things.

------
pencilcode
I've been working with scala for the last 2 months and I like it. The things i
don't love are: the long compile times (lots of time wasted here), the lack of
a community accepted/official coding practices - if sbt by default would run
scalastyle on packaging/testing, that might help on enforcing a consistent set
of good common practices on community code.

~~~
herval
I'm following this project closely:
[http://olafurpg.github.io/scalafmt/](http://olafurpg.github.io/scalafmt/)

It's just been released, but I like the idea of adopting a tool in the likes
of gofmt. Coding style discussions are such a bike-shedding magnet, it's good
if you can just not think about it (and are able to follow it anyway,
regardless of IDE).

~~~
olafurpg
I'm the author of scalafmt, happy to hear there's interest in the project!
Scala has a very rich syntax. I remember first coding in Scala being unsure
where to put newlines or how far to indent. My hope is to make that problem go
away.

Scalafmt is indeed new, just released 0.1.0 last week. However, it's already
become useful for me with the IntelliJ plugin. Scalafmt is practically my
full-time job for 2 more months so you can expect it to get more mature soon.
Feature requests and bug reports are very welcome.

------
striletskyy
Sounds good, have tried scala before, that was great experience.

------
merb
What would be also great, would be a way to announce Scala Jobs regionally.
Actually we are still looking for a good way to find job canidates, but since
we are a small company it's really hard to find people especially scala
developers.

~~~
neverminder
I would guess that your problem is more geographical. Mildly amusing anecdote
- a friend of mine went to an interview for a dev position (without doing
proper due diligence) at a company just outside of London, but the location
was quite isolated - he ended up on a farm complex where this company had
their office. He said he could hear actual farm animal noises next door during
the interview and these people were desperate to offer him the job, but for
obvious reasons he declined.

~~~
duaneb
What are the obvious reasons? Is a farm a disreputable place to work in the
UK? Mostly it's confusing, not concerning. I would imagine a farm is harder to
keep afloat than a startup.

~~~
aninhumer
If I understood correctly, the company wasn't a farm, they just had their
office there, and the interviewee found that environment unpleasant.

~~~
duaneb
Ahh, makes sense.

Many engineers I know would love to work near a farm, heck I'd even consider
that a perk of the job. "Sick of twitter? Go look at some livestock."

This is subjective, obviously.

------
pklausler
I'm a happy Haskeller with no JVM in my environment. Should I learn Scala?

~~~
mafribe
I think you will find Scala relatively easy to learn since most Haskell
concepts have Scala equivalents.

If you want something much more Haskell-like on the JVM, check out Frege
[https://github.com/Frege/frege](https://github.com/Frege/frege)

------
geodel
> Provide scaffolding to help the community develop, publish, find, and
> evaluate Scala libraries.

This sounds little odd. Has there similar efforts for other languages?

~~~
gmartres
Some other languages have a central repository where everyone publishes their
packages like [https://hackage.haskell.org/](https://hackage.haskell.org/),
[https://crates.io/](https://crates.io/) or the venerable
[http://www.cpan.org/](http://www.cpan.org/). Scala has no such things: people
publish to various repositories like
[http://bintray.com/](http://bintray.com/) or
[https://oss.sonatype.org/](https://oss.sonatype.org/), so a central place to
get information about existing libraries would be very useful.

~~~
lmm
Doesn't everything go into maven central? I can't remember ever not finding a
library there.

~~~
jinst8gmi
That doesn't seem to cover the "develop" and "evaluate" parts.

------
freekh
Awesome news! Great initiative EPFL! :)

