gmartres

Chisel picked up Scala 3 support in 7.0.0 released last September (https://github.com/chipsalliance/chisel/releases/tag/v7.0.0), right now they cross-compile between Scala 2 and 3 but from what I heard they should eventually move to Scala 3 only to start taking advantage of new features like named tuples (https://docs.scala-lang.org/scala3/reference/other-new-featu...).

Thanks for open-sourcing this! Roughly, what's the performance overhead from running code under hermit? I'm wondering if this could be used for doing benchmarking with less variance on non-deterministic platforms such as the JVM (I assume hermit is "deterministic enough" that the JIT and GC threads of the JVM will run the same code on every execution?)

https://www.lihaoyi.com/post/FromFirstPrinciplesWhyScala.htm...

It's coming to Scala too: https://dotty.epfl.ch/docs/reference/other-new-features/expl...

What are the main differences with last year's course ? Also can we expect http://course18.fast.ai/part2.html to be updated in the near future ?

Is there a runtime lib? That includes e.g. Scala collections for the browser for example?

Pretty much all Scala code compiles with Scala.js, that includes the Scala standard library, as well as part of the Java standard library that has been reimplemented in Scala.

How many kilobytes?

Scala.js does whole program optimization and dead code elimination, so there's not a single number that can be given here, you pay for what you use.

Meltdown also affects some ARM chips according to ARM itself: https://developer.arm.com/support/security-update

According to ARM yes, but only on a few architectures: https://developer.arm.com/support/security-update (Meltdown is CVE-2017-5754 and is responsible for Variant 3 and Variant 3a). See also https://github.com/marcan/speculation-bugs/blob/master/READM... which tries to summarize every known attack/platform/mitigation.

creator of Scala, and possibly also involved in SBT

Martin has never worked on sbt. sbt started as a community project and is now maintained by Lightbend, which Martin co-founded.

I'll be impressed the day this is turned on by default, or at least proposed as an option to the user after installation :).

How open is this going to be? Will it be based on a protocol implementable by other editors, akin to the Language Server Protocol (https://github.com/Microsoft/language-server-protocol) ?

you might want to give sbt 1.0 a try, it features better incremental compilation support: https://developer.lightbend.com/blog/2017-04-18-sbt-1-0-road...

The latest spec for 2.12 is available at http://www.scala-lang.org/files/archive/spec/2.12/

The whole point of monads (and most other typeclasses) is that they're an abstraction. If you use a type constructor then you cannot generalize your function to work with any kind of monad, see for example the definition of `mapM` in https://hackage.haskell.org/package/base-4.9.1.0/docs/src/GH... which uses `return`

Radia Perlman also wrote a great (and fun!) book on networking: https://www.amazon.com/Interconnections-Bridges-Switches-Int...

The maintainers might not see your comment, I encourage you to make a PR: https://github.com/scala/scala-lang

Scala does not have non-nullable types currently (but that might happen in the future), in practice this is not a problem simply because using null is seen as a code smell and basically no Scala library API expects parameters to be null or return null, optional values are usually represented with the standard library class Option: http://www.scala-lang.org/api/2.11.8/#scala.Option

Part of a good review should be to review how you decided to split your PR into separate commits (does every commit have a single purpose, or did you sneak unrelated changes in a commit? Could the commit message be improved?). Furthermore, sometimes you have to rebase your PR on top of master (for example, because things changed in master too much, or because your PR depends on a patch that was recently accepted in master to actually work), this shouldn't make review comments disappear.

Its something we're still working on, but it still helps to vocalize your support for wanting improved force push support. :D

YES! I wish for that feature everyday. Gerrit does it exactly right.

Related to this, I really, really hope that you will consider displaying commits in a PR in the correct order, suppose that I have three commits on top of master:

  a->b->c->master

  c->a->b->master

By the way, the post explicitly says:

Some teams choose to use a commit-by-commit workflow where each commit is treated as the unit of change and is isolated for review.

I'm glad that you're acknowledging that. But then why do comments on commits still get hidden when they correspond to an outdated diff? I would love to be able to comment on individual commits, but if half my comments are hidden because they correspond to lines that don't match the current diff, then I'm not going to do it for fear of my comments being missed. You should not hide important information that I'm trying to communicate! Here's a better way to do it: Add a "Done" button like Rietveld/Gerrit for every comment (this is a very useful feature on its own) and hide comments _if and only if_ the "Done" button has been clicked.

Anyway, I'm glad that people are working on this stuff and that they're listening to the community, thank you!

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

If you're interested in Dotty, other talks with more information are listed at https://github.com/lampepfl/dotty/wiki/Getting-Started#talks...

What's the relationship between Squeak and Pharo? Do they have the same goals?

What I wish would happen is GHCi allowed me to load just the things that type check

Use `-fdefer-type-errors` (should work with both GHC and GHCi), all errors become warnings, and if you try to use a function which was compiled with an error, you get a runtime error.

I think the best explanation available is still http://forum.doom9.org/showthread.php?t=168947

Nice post! I think your encoding of functors could be replaced by:

  object Module {
    private class MyUnbalancedSet[A](O: Ordered[A]) extends MySet[A] {
      ... body as in your post
    }
    def UnbalancedSet[A](O: Ordered[A]): MySet[A] = new MyUnbalancedSet[A](0)
  }

For LTS releases, Ubuntu provides optional updates of the kernel and the graphics stack: https://wiki.ubuntu.com/Kernel/LTSEnablementStack

How do you know that you recieve VP9 and not VP8, is there some download script for this?

Right-click on a video, click on "Stats for nerds", see if there's VP9 on the "Mime type" line.

As long as there aren't any compability issues I can't see why not, that said when playing some of my vp9 test encodings in VLC (which I believe uses ffvp9) I sometimes get decoding errors causing huge macro-blocks etc, when playing through Chrome or if I decode the vp9 stream to another format they play perfectly.

Assuming these issues still happen with a nightly build of VLC (http://nightlies.videolan.org), you should report the bug to FFmpeg: https://trac.ffmpeg.org/

Though this isn't implemented by the reference encoder yet, the VP9 bitstream supports this (encoding a downscaled frame and signaling to the decoder to upscale it before displaying it).

When you do a blame on a line of code, to figure out when the last change was, do you want to see the "fix whitespace to match style guide" commit that someone insert in the branch at the end, or the actual meaningful change that occurred earlier?

    git blame -w # works with git diff and git show too

https://xkcd.com/137/