eeperson

In the spirit of Cunningham's Law, you can open multiple files using emacsclient. Just list them after emacsclient (e.g. 'emacsclient file1.txt file2.txt'). This will open each file in its own buffer (roughly the equivalent to tabs).

Since I'm not very familiar with vim tabs, I'm curious what you get using using vim tabs that you don't get out of emacs buffers?

Tab bar mode conflicts with a bunch of other modes. So a lot of times you will switch to a buffer and and the tabs will disappear. It also doesn't support 'most recent' tab ordering.

Centurylink has started rolling out Gigabit in the Seattle area: https://www.centurylink.com/fiber/plans-and-pricing/seattle-...

According to this[1], as of 2 years ago, hello world was only 2.63KB. It's probably even better now as there have been several releases in the past 2 years.

[1] - https://github.com/scala-js/scala-js/issues/4#issuecomment-2...

This is probably SBT's greatest weakness and Gradle's biggest strength, relatively. I've never run in to this personally, probably because I'm use Nexus[1] as a repository cache. My understanding is that the underlying problem is a limitation of the dependency resolution library they use, Ivy[2]. Gradle used to use this but at some point wrote their own dependency resolution library. There are some improvements in recent versions of SBT but you have do a little configuration. See here[3] for more details.

[1] http://www.sonatype.com/nexus/product-overview

[2] http://ant.apache.org/ivy/

[3] https://www.typesafe.com/blog/improved-dependency-management...

I'm using it on a 100k line codebase without issue. What problems are you having?

Yes, it is. This is commonly accomplished with a tool called ProGuard. Doing this comes with some other trade offs but it is easy to do.

I don't think 'Reimplementable Independently' means what you think it means. See my reply to your other post for more details[1].

I'm not sure I get how those slides indicate that the systemd interfaces are not standardized (with the possible exception of timedated, although the slides were kind of vague). Most of the problems seemed to be due to the fact that OpenBSD doesn't support PAM. Was there a particular section you were referring to?

[1] https://news.ycombinator.com/item?id=10234379

I think the 'Reimplementable Independently' just means that it is straightforward to reimplement on top of systemd (although that isn't made very clear). Since the external login DBus interface is standardized, I can't imagine why it would be difficult to reimplement logind on top of another init system.

edit-grammar

Systemd does standardize many interfaces[1] (including logind).

[1] - http://www.freedesktop.org/wiki/Software/systemd/InterfacePo...

So its the systemd developers' fault that this is not a very good list of issues?

This is a pretty bad list of issues with systemd. A large portion of criticisms in this list seems to be due to a misunderstanding of the author about what is actually in the systemd git repo. The git repo contains udev and other deamons in addition to the init process. As a result, most of the claims on this page about things going in to the init process are incorrect. If you look the actual release notes they are usually referencing a completely different daemon.

For example the line 'pid 1 does DNS' points to a release note about a separate daemon called 'systemd-resolved'.

edit: grammar

Yes, it is the same as the "group" in group theory. However, I the name is a misnomer since I believe it is technically a semigroup because the binary operator is not invertable.

That doesn't really seem definitive. That page also includes a link to this[1] page, from a month ago, stating that LinkedIn is moving part of its stack to Scala.

[1] - https://engineering.linkedin.com/frontend/new-technologies-n...

Yeah, I think that would work.

edit - I think the need for explicit types for each SAM was fixed by https://issues.scala-lang.org/browse/SI-8310

Interestingly Scala 2.12 will have support for user defined types using function literals (it's actually in 2.11 behind a compiler flag). This feature is referred SAM (single abstract method) functions [1].

Also, there are plans to move tuples to something more like HLists. You can see it here[2] as part of 3 under 'Don Giovanni'.

[1] - https://typesafe.com/blog/scala-211-has-arrived [2] - http://www.scala-lang.org/news/roadmap-next

I'm not sure I understand what distinction you are making. All of the examples you mention are built by reusing OS/JVM threads. That is how you have to implement user-threads. How do you feel Akka differs from Quasar/Go (aside from the coroutine/actor distinction) .

Why did you feel it was unfriendly?

Weston already supports RDP (including desktop sharing). I believe newer versions of RDP can support a root windowless mode (so I'm not sure if Weston's RDP currently supports this).

Debian Testing or Unstable?

This isn't necessarily due to erasure. This actually about boxing. Reified generics is one way to solve this. Another option is tagged pointers. That is how OCaml handles this[1].

[1] http://stackoverflow.com/questions/3773985/why-is-an-int-in-...

edit: clarity

Yeah, historically the artifact resolution has been kind of slow if you have several sub projects. However, there was just a new release of SBT that added a bunch of improvements for this[1].

[1] http://typesafe.com/blog/improved-dependency-management-with...

Your experience around the performance of SBT (and possibly, by extension, Play compilation) runs very much counter to my experience. I have found SBT to be much faster than Maven (thanks largely to the console). There may be something wrong with your project that is causing it to build so slowly. Are you seeing the compilation go very slowly or is it more issues with artifact resolution?

Yes, http://qt-project.org/doc/qt-5/ios-support.html

Why do you feel that it is a failed experiment? As a user of the collections, it seems to me to work out. Is it more of a problem with the implementation of the collections?

There actually is a recent spec, although I'm not sure if it still needs some updating. http://www.scala-lang.org/files/archive/spec/2.11/

Don't compiler plugins provide a way to provide a way to experiment with language changes more quickly?

That recommendations is strange. The directions just have you include an almost standard version of the IntelliJ plugin for SBT (it is the standard plugin with an extra bug fix). So, any of these IDEs should work without issue. You just need to set up the standard SBT plugins for integrating those IDEs.

Have you looked at the usage guides for the various plugins [1][2]?

[1] https://github.com/jberkel/android-plugin/wiki/getting-start... [2] https://github.com/pfn/android-sdk-plugin#usage

What do you mean by z-axis scaling?