GraalVM: Run Programs Faster Anywhere - <AUTHOR> http://www.graalvm.org/ <comment><USER3> Graal dev here. If you want to checkout all the sources/licenses of GraalVM CE. They are here:

Graal: [https://github.com/oracle/graal](https://github.com/oracle/graal) (GPLv2 with CPE)

JavaScript with Node Integration: [https://github.com/graalvm/graaljs](https://github.com/graalvm/graaljs) (UPL - BSD license)

Ruby: [https://github.com/oracle/truffleruby](https://github.com/oracle/truffleruby) (EPL, GPLv2, LGPL)

R: [https://github.com/oracle/fastr](https://github.com/oracle/fastr) (GPLv2)

Python: [https://github.com/graalvm/graalpython](https://github.com/graalvm/graalpython) (UPL - BSD license)

LLVM/Sulong: [https://github.com/graalvm/sulong](https://github.com/graalvm/sulong)

<comment><USER4> Thanks! Out of curiosity — if I built an application with truffleruby, could I distribute it as a JAR (provided that it was run under JDK 9)? Are there ways to call out to Java like JRuby? Having some difficulty finding documentation around this.

<comment><USER5> > if I built an application with truffleruby, could I distribute it as a JAR

Yes there is a Java embedding API.

[http://www.graalvm.org/docs/graalvm-as-a- platform/embed/](http://www.graalvm.org/docs/graalvm-as-a-platform/embed/)

> (provided that it was run under JDK 9)

It can run on 8. It'll be fast on JDK 9 or 10 because these have the interface to use Graal.

> Are there ways to call out to Java like JRuby?

JRuby compatible interop:

[https://github.com/oracle/truffleruby/blob/master/doc/user/j...](https://github.com/oracle/truffleruby/blob/master/doc/user/jruby- java-interop.md)

Our own interop:

[https://github.com/oracle/truffleruby/blob/master/doc/user/p...](https://github.com/oracle/truffleruby/blob/master/doc/user/polyglot.md)

> Having some difficulty finding documentation around this.

[https://github.com/oracle/truffleruby/tree/master/doc](https://github.com/oracle/truffleruby/tree/master/doc)

<comment><USER6> Actually, can you create a Graal/Truffleruby 101 example where a Ruby application is compiled to native and run ?

<comment><USER5> It doesn't do that - we compile the Ruby _interpreter_ to native, not the Ruby application.

It's a little bit more complex than that in that we can _run_ a Ruby application ahead of time up to a certain point where we compile it, and then when you run the application that state when it was compiled is restored. So we load the core library during compilation for example.

<comment><USER6> Genuinely interested in knowing this - if you can compile ruby , why cant you compile a program?

Will this be the case for truffle python, js,etc ?

<comment><USER7> I'm not on the Graal team but I can take a crack at an answer - it's because as languages get more dynamic, static ahead of time compilation becomes less and less effective and can even be counterproductive. To compile a Ruby program it really _needs_ to be just-in-time compiled, or at least a partial ahead of time compile using injected profiling runs.

The problem is that the semantics of Ruby are such that you can't compile it efficiently out of the box. TruffleRuby can but only by making tons of assumptions at runtime that might not be valid. So it compiles code on the assumption your program is normal and not weird, and if those assumptions are violated, it goes back to interpreting the source code.

Therefore even if you could pre-compile Ruby in some pedantic sense, you'd still need the source code to fall back to when the JITC has to bail out.

<comment><USER8> That's partly true, but depends on the particular program. There are Ruby programs that could be compiled ahead-of-time quite efficiently, despite their dynamic features.

The slow-path version of the code that violates runtime assumptions can still be compiled as an alternative variant - so instead of switching from fast compiled code to the interpreter, the code violating the assumptions can switch to slow-path compiled code.

<comment><USER9> While that's true, and switching to a slower path solves many problems, consider this common Ruby pattern:

        Dir.glob("some dir/*").each do |filename|
            require filename
        end

A _lot_ of Ruby code messes with how code is loaded (heck, "require" in almost every Ruby install is not the built in "require" but one that has been dynamically replaced). Sometimes that is intended to implement static behavior: The expectation is that the code remains the same. It's just a way of avoiding having to maintain a list manually.

But other times it is used as a plugin mechanism, where the expectation is for the code to be provided by a user or other developer, and processing this statically at compile time would remove capabilities that the user would expect.

You can't automatically determine things like that, because it is down to developer intent and the code does not document the intent.

So the problem goes deeper than being about being able to revert to a slow path: To compile Ruby in a meaningful way you need to make some level of trade-off in what aspects of Ruby you decide to treat as "ahead of time" vs runtime, because there is no clear rule that says "now the program has been loaded; everything after this is runtime".

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER10> It sounds amazing. But Oracle's legal reputation means I can never safely choose their tech stack, especially not something open source and free.

One of a million examples, this happens on the front page of HN at the same time:

[https://www.reddit.com/r/javascript/comments/8d0bg2/oracle_o...](https://www.reddit.com/r/javascript/comments/8d0bg2/oracle_owns_javascript_so_apple_is_taking_down_my/)

<comment><USER11> Oracle can't sue you for using Java and OpenJDK.

</comment></comment><comment><USER12> I have been paying some scant attention to GraalVM for some time, having been excited by "universal VMs" for decades now (including setups like LLVM, which most people forget was designed as a JIT-compiled VM, despite that being in the name), and I develop Cycript (which is somewhat the "opposite" technology, binding together existing virtual machines all into the same process space and doing crazy interop; though I haven't done a public release now in well over a year).

I am excited to see such a beast coming from a major company with a strong track record in VMs, and particularly given that it is based on their existing JDK, and am particularly excited that it now seems to be available!

I have some questions that I did not managed to easily get answered from looking over the website.

Can I AOT with this (via SubstrateVM) and deploy to "mobile" targets, and specifically iOS?

Are there any examples of embedding GraalVM in an existing native application (such as the noted idea of having GraalVM accessible inside of MySQL)?

Is there an existing embedding for node.js? (I don't mean "can I run node.js apps on GraalVM?"; I mean: from node.js, can I instantiate a GraalVM and give it code to execute in a new context, or will I need to build my own bindings to the GraalVM embedding API for that first?)

I did find some documentation for using an embedded GraalVM in a Java application, but while I work on many projects in many languages, none of them have been written in Java now for over a decade. I guess I was expecting a C/C++ API to be documented somewhere, not a Java API (due to the listed prototypical embeddings, and based on my long experience with embedding other virtual machines, including the Oracle/Sun JVM).

[http://www.graalvm.org/docs/graalvm-as-a- platform/](http://www.graalvm.org/docs/graalvm-as-a-platform/)

<comment><USER13> _Is there an existing embedding for node.js_

That's what their "node" program actually is. It's regular node but using GraalVM instead of V8. The semantic difference you're getting at doesn't seem to exist.

 _I guess I was expecting a C /C++ API to be documented somewhere, not a Java API_

SubstrateVM has a C API that can be used to start it up that's not the same as JNI, however, bear in mind Graal can be used as a plugin to regular HotSpot too. So you can just embed the JVM the usual way and ship the Graal compiler with it, enabled via a command line flag. So yes you can do this and it doesn't require any new documentation.

<comment><USER12> > That's what their "node" program actually is. It's regular node but using > GraalVM instead of V8. The semantic difference you're getting at doesn't > seem to exist.

No, because what I'm trying to accomplish is "I'm inside of a node.js program and I want to instantiate a GraalVM virtual machine instance context, load a random Java class (or whatever), and run a function on that class". Even if I'm running my node.js code on top of GraalVM, the semantic difference fundamentally exists. Like, you are trying to tell me that somehow running my node.js program on top of GraalVM is the same thing as being able to run GraalVM from inside of my program (which just so happens to be written in node.js, but that's arbitrary and meaningless in a way: I just want good bindings for the language I happened to write it in) on arbitrary code, but that clearly doesn't make any sense. I mean, it certainly isn't true for their Java embedding API, why/how would it somehow be true for their node.js API?

> SubstrateVM has a C API that can be used to start it up that's not the same > as JNI... So you can just embed the JVM the usual way and ship the Graal > compiler with it...

But SubstrateVM is the offline VM for AOT use, not the runtime VM for JIT use, so I really am not that interested in the SubstrateVM API... it isn't at all relevant for the use case I'm describing for embedding GraalVM; and the Graal compiler in this context is also for AOT use, which again isn't relevant for the use case of embedding the GraalVM.

What makes GraalVM interesting here is that it is a JIT. Just take a step back for a second and imagine you have a C program, and you want to boot that JIT and use it, as a library, loaded into your process. That's the use case here. You seem to be confusing that with either running the C program inside of the VM (which doesn't even change the problem) and then later with pre-compiling the thing we want to load and bringing the compiled code into the process (which bypasses the wonderful goal of working with the JIT).

The way you do this using their Java embedding API is clearly documented, and it is absolutely not the same thing as running a Java application in the GraalVM: it is a set of APIs that let you instantiate Graal Context objects, eval() code in various languages, and then work with the proxy Value objects. I am asking if that API has been exposed to any languages other than Java yet. It seems (from the answer from someone who actually works on Graal from 8 hours before your comment) that the answer is "yes" for C/C++, but I'm still guessing the answer is "no" for node.js.

[http://www.graalvm.org/docs/graalvm-as-a- platform/embed/](http://www.graalvm.org/docs/graalvm-as-a-platform/embed/)

<comment><USER13> My point is that you can load GraalVM into an already running process using JNI and access objects that way. JNI isn't a great API by any means but it works and there are tools to bind to it. It isn't new and I don't think GraalVM without Substrate or Sulong innovates in this area.

So if you wanted to run JavaScript using GraalJS, from C, you would link against libjvm, use JNI to initialise the VM with Graal as the JIT compiler (there's a special flag for this), and then use the Polyglot API via JNI.

To bind from JavaScript to Polyglot _without_ having Graal be the host would presumably require you to write a V8 extension that then loads the JVM using JNI and proxies back and forth. I think there are projects that do this already. But you wouldn't get the performance or convenience improvements than Graal/Truffle are pioneering.

In the end though, embedding the JVM this way - at least for node apps - <USER2> not be better or more efficient than using their node implementation, but ignoring things like performance and debuggability the results are presumably identical unless your code depends on an implementation detail of V8. So I don't get why you'd do that.

</comment></comment></comment></comment><comment><USER14> I wouldn't touch this with a ten-foot-pole without an explicit patent grant. Oracle has misbehaved too much in the past (and present) to ever be trusted again by the open source community in my opinion.

<comment><USER15> This was the first thought that crossed my mind.

If I have a choice between running our stack 50 times slower (and thereby 50 times the cost) or running anything Oracle, I know which choice is cheaper and doesn't come with an existential threat to my company.

Only governments and big corp are rich and reckless enough to take on this kind of risk willingly.

<comment><USER16> >> existential threat to my company

There is like a bajillion people out there running Oracle Java, MySql, Virtualbox and so on. All of them Oracle products, and with permissive licenses. Where is this "existential treat" thing coming from?

<comment><USER15> >There is like a bajillion people out there running Oracle Java, MySql, Virtualbox and so on. All of them Oracle products, and with permissive licenses. Where is this "existential treat" thing coming from?

Oracle. (see, I can be sarcastic too)

Ignoring the fact that most of those users were likely acquired back when those products were still known as Sun Java, Sun MySql, and Sun Virtualbox, those "bajillion" people are not lucrative enough to warrant the effort. The moment one of those people becomes large enough, Oracle's lawyers will come knocking. If you're large enough, they will even go as far as to change how copyright law itself is interpreted to get their fill.

With a company like that, entering any form of contract or agreement is a major liability and an existential threat.

<comment><USER16> "The moment one of those people becomes large enough, Oracle's lawyers will come knocking."

Can we see an example of big Java user being called by Oracle's lawyers? Excluding Google, they created their own Java with no regards to license, so yeah they got sued. So... did anyone that just downloaded Java and used it, got sued? I do not see it. Nor do I see what they could possibly be sued for.

<comment><USER17> How about this? [https://www.techrepublic.com/article/why-its-finally-time- to...](https://www.techrepublic.com/article/why-its-finally-time-to-give-up- on-the-name-javascript/)

</comment></comment></comment></comment></comment></comment><comment><USER18> Is there public documentation for the differences between the CE and EE editions? The website mentions that EE "provides improved performance and security for production deployments". What types of performance and security optimizations are locked behind the EE edition? What is your criteria for determining whether a new optimization belongs in CE or EE?

I also want to echo others' concerns about the license, lock-in, and lack of explicit patent grant. It's a shame that Oracle's (well-deserved) reputation is tainting so many excellent engineering efforts. I hope that these comments serve as some form of feedback about the very real cost the Oracle brand has suffered as a result of its legal activities.

</comment><comment><USER19> Truffle makes it possible to implement a JITed dynamically-typed language simply by annotating actions on the AST.

[http://www.graalvm.org/docs/graalvm-as-a- platform/implement-...](http://www.graalvm.org/docs/graalvm-as-a- platform/implement-language/)

Here's an example of the addition operator from Graal's SimpleLanguage:

      @NodeInfo(shortName = "+")
      public abstract class SLAddNode extends SLBinaryNode {

          @Specialization(rewriteOn = ArithmeticException.class)
          protected long add(long left, long right) {
              return Math.addExact(left, right);
          }

          @Specialization
          @TruffleBoundary
          protected SLBigNumber add(SLBigNumber left, SLBigNumber right) {
              return new SLBigNumber(left.getValue().add(right.getValue()));
          }

          @Specialization(guards = "isString(left, right)")
          @TruffleBoundary
          protected String add(Object left, Object right) {
              return left.toString() + right.toString();
          }

          protected boolean isString(Object a, Object b) {
              return a instanceof String || b instanceof String;
          }
      }

[https://github.com/graalvm/simplelanguage](https://github.com/graalvm/simplelanguage)

By default it uses an arbitrary precision adder. But node rewriting on the AST (predicated by the "guard") provides specializations for _long_ and _String_ types. The long-type execution is a "fast path" that executes machine instructions directly; the String-type execution is a string concatenation.

A research paper provides further details:

[https://dl.acm.org/citation.cfm?id=2658776](https://dl.acm.org/citation.cfm?id=2658776)

The full tutorial is at:

[https://github.com/oracle/graal/blob/master/truffle/docs/Lan...](https://github.com/oracle/graal/blob/master/truffle/docs/LanguageTutorial.md)

<comment><USER20> Someone I know wrote a Java implementation of the small VM for an open source project that had a simple C interpreter. My first thought was "wait, why?", until they mentioned that it was more than 10x faster and much, much easier to write and extend. You basically get a very good JIT engine for free. Not gonna underestimate Truffle after that.

<comment><USER3> Which one was it? Can you remember? One of these?

[https://github.com/oracle/graal/blob/master/truffle/docs/Lan...](https://github.com/oracle/graal/blob/master/truffle/docs/Languages.md)

If not. Please let me know.

<comment><USER20> It's not listed there, and didn't reach full feature parity (and seems to be dead now).

[https://github.com/frodwith/jaque](https://github.com/frodwith/jaque) is the project though, which is an implementation of the Nock VM from Urbit

<comment><USER3> Ho wow, never heard of it. Will put it on the experiments list. Thanks a lot!

<comment><USER21> Hi, author of jaque here. I've been working on some other things for a little while, but I'll be getting back to jaque soon. It's quite out of date and needs to be brought up to 1.0 and cleaned up a bit before I start grousing about the stack issues I was running into on the mailing list, but when I last was working on it I was running into issues with Graal when trying to increase the java stack size. Deep but bounded head recursion is quite common in nock, and I seem to recall I needed about 8 megs of stack space (I just passed -Xss 8m or something on the command line) and Graal slowed waaaay down. That's where I left it.

<comment><USER3> Truffle tech lead here. Happy to hear you are not giving up :-) Do you mind if I include your language on the experiments list?

BTW.: I'd recommend upgrading one Truffle release at a time. So it should always continue to compile. Just fix the deprecation warnings and continue with the next version until you reached the last version. We always keep deprecations for at least one version before we remove/break APIs.

If you want to discuss something in more detail feel free to join us in the Gitter chat: [https://gitter.im/graalvm/graal- core](https://gitter.im/graalvm/graal-core)

We don't bite.

<comment><USER21> > Do you mind if I include your language on the experiments list?

Not at all! Thanks for the advice, and I'll take you up on the invitation to come chat before too long.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER22> Can someone please explain this?

> Are you working on a Java application? Do you want a faster runtime? Enhance > your code with JavaScript!

First, the JVM already has the Nashorn JS engine. Second, if I'm "working on a Java app", that means that it's already running in a JVM. Where does the faster runtime come from? Is executing JS from Java using Graal faster than running actual Java code? Is it just faster than Nashorn? Something else?

<comment><USER3> The Graal compiler is compiling Java code to faster machine code on top of the JVM. Also GraalVM's JavaScript implementation uses an entirely different approach by using Truffle for its implementation making it significantly faster. Also GraalVM ships with Node.js support, tooling and other languages.

Here is a full list of reasons: [http://www.graalvm.org/docs/why- graal/](http://www.graalvm.org/docs/why-graal/)

Here are some (maybe a bit outdated, but independent) benchmarks comparing it to Nashorn: [http://blog.nidi.guru/tech/javascript/2018/04/02/javascript-...](http://blog.nidi.guru/tech/javascript/2018/04/02/javascript- benchmarks/)

We have some way to go to beat V8.

<comment><USER23> From the provided link:

\- graal has superior compiler technology based off of a research paper [1] that:

\-- has superior ability to remove costly object allocations in many scenarios

\-- has better inlining and more aggressive speculative optimizations

\-- has smarter jit compilation

[1] [http://www.ssw.uni- linz.ac.at/Research/Papers/Stadler14/Stad...](http://www.ssw.uni- linz.ac.at/Research/Papers/Stadler14/Stadler2014-CGO-PEA.pdf) (pdf)

<comment><USER24> A few additional papers with details on Graal IR and optimizations:

[http://lafo.ssw.uni- linz.ac.at/papers/2013_VMIL_GraalIR.pdf](http://lafo.ssw.uni- linz.ac.at/papers/2013_VMIL_GraalIR.pdf)

[https://dl.acm.org/citation.cfm?doid=2245276.2232084](https://dl.acm.org/citation.cfm?doid=2245276.2232084)

[http://aleksandar-prokopec.com/resources/docs/graal- collecti...](http://aleksandar-prokopec.com/resources/docs/graal- collections.pdf)

</comment></comment></comment></comment><comment><USER25> Might this (today, tomorrow) become another way to get access to the wonderful Lucene from non-Java environments? A long, long time ago there was a GCJ-based solution, but it was never loved much (either the port or GCJ itself). SubstrateVM looks potentially delicious here

edit: lol: talk about a low blow!

> The community version does not support DWARF information. The enterprise > version supports all native tools that rely on DWARF information, like > debuggers (gdb) and profilers (VTune).

<comment><USER13> Well, there has always been JNI. If you want to access Lucene from C or runtimes that can call into C then you could do that for years.

Otherwise with GraalVM you could run your non-Java environments on Graal and go at it the other way around.

</comment></comment><comment><USER26> This project is remarkable! Really excited to see where it goes. The biggest problem I see so far is sparse docs on interop. I see docs with a trivial example of importing simple types from java and using them in node, which is amazing! However, this is pretty far from a real world example. In the real world there are deep type graphs and dependencies and functions that look like IWidgetInterface createWidget(IAbstractWidgetFactory<CoolWidget> factory) etc... seeing examples of dealing with complex types, anonymous Callables, generics, etc... would be great.

<comment><USER3> Thanks for the feedback. We will definitely improve the polyglot docs in the next weeks. There is lots more to show.

Are you calling from Java? Then there are more examples here: [http://www.graalvm.org/docs/graalvm-as-a- platform/embed/](http://www.graalvm.org/docs/graalvm-as-a-platform/embed/)

Also some of the examples on the website use interop: [http://www.graalvm.org/docs/examples/](http://www.graalvm.org/docs/examples/)

</comment></comment><comment><USER27> GraalVM

1\. Community Edition (CE)

> GraalVM CE is available for free for development and production use. It is > built from the GraalVM sources available on GitHub

2\. Enterprise Edition (EE)

> GraalVM EE provides additional performance, security, and scalability > relevant for running critical applications in production. It is free for > evaluation uses and available for download from the Oracle Technology > Network.

"performance, security, and scalability" words don't present in p1. Is it just me or...?

</comment><comment><USER28> This is wonderful. I'm looking forward to playing around with JavaFX. Being able to compile that to a native image is huge! It would effectively invalidate the Electron approach of building "native" applications.

<comment><USER29> That approach was already invalidated long time ago.

All major commercial JDKs do support AOT compilation and ExcelsiorJET is free for open source projects.

<comment><USER28> This is _completely_ free, though.

</comment></comment></comment><comment><USER30> One VM to Rule them All. [https://news.ycombinator.com/item?id=6358772](https://news.ycombinator.com/item?id=6358772)

[https://news.ycombinator.com/item?id=6232240](https://news.ycombinator.com/item?id=6232240)

That was the earliest post I remember from HN. But I record there some other information scattered around a little before that.

So this is nearly 5 years coming. I am amazed what at first seems like fantasy, impossible work is now actually thing. 2012 / 2013 was the year when VM and JIT has lots of innovation. Rubinus, LuaJIT, SpiderMonkey and all those Javascript VM.

</comment><comment><USER31> Great! Benchmarks of TruffleRuby vs JRuby vs Ruby looks very promising. edit: [https://pragtob.wordpress.com/2017/01/24/benchmarking-a- go-a...](https://pragtob.wordpress.com/2017/01/24/benchmarking-a-go-ai-in- ruby-cruby-vs-rubinius-vs-jruby-vs-truffle-a-year-later/)

<comment><USER32> If we can successfully JIT it we normally do very well. The caveat is that we do have warm up time and if we can't compile stuff then you won't see the same level of performance.

</comment></comment><comment><USER30> I know lots of people are worry about Oracle. But the license is extremely clear, it is the same as Java.

So like the JVM or JDK, there is nothing stopping you from for forking the code, as long as you don't call it Java, and "your" JVM would not get the test suit.

GPL 2 with Classpath exception has been with us for so long. I know you hate Oracle, but I don't see any downside to it. I mean half of the Internet literally runs on JVM and MySQL.

I had to look hard and it doesn't seems to have any strings attached.

</comment><comment><USER33> > With the SubstrateVM it is possible to produce a single, statically linked > native binary executable version of Graal.js, which doesn't need any JVM to > run.

How large is the resulting executable? There was some mention of shares libraries — is it possible to build a runtime that is callable from C?

Relatedly, does the GraalVM _java_ executable support JNI?

I'm also curious about the runtime footprint in general; any idea what is the smallest possible VM for a real but relatively-small language like Lua?

<comment><USER5> > How large is the resulting executable?

A minimal executable is about 5 MB.

> There was some mention of shares libraries — is it possible to build a > runtime that is callable from C?

Yes you can compile a JAR to a shared library with C function entry points.

> Relatedly, does the GraalVM java executable support JNI?

Yes.

> I'm also curious about the runtime footprint in general; any idea what is > the smallest possible VM for a real but relatively-small language like Lua?

Real language VMs are quite a bit bigger - a hundred MB or so.

<comment><USER34> >> I'm also curious about the runtime footprint in general; any idea what is the smallest possible VM for a real but relatively-small language like Lua?

> Real language VMs are quite a bit bigger - a hundred MB or so.

Don't know if you're trying to say Lua is not a real language, or just skipped the part about Lua.

<comment><USER5> No, hello-world executables _built using SVM_ are 5 MB or so. Real world language VMs _built using SVM_ are a hundred MB or so. If you had a language VM for the real world language that is Lua _built using SVM_ it would probably be a hundred MB or so.

I'm not passing any opinions about any languages or VMs here.

<comment><USER33> > If you had a language VM for the real world language that is Lua built using > SVM it would probably be a hundred MB or so.

Is this mostly JRE? Would Jigsaw help, or is SubstrateVM already doing something like that? (To be clear, this tech is really impressive! Just trying to get a sense of embeddability constraints)

<comment><USER5> The SubstrateVM already does whole-world analysis to only compile methods that are actually used, so reducing the methods in the JAR before hand (which is what Jigsaw) would do, would not change anything.

Language VMs compiled using SubstrateVM are larger than you may think because as well as the native code they also need to contain a representation of the code that the compiler can read (IR) so it can dynamically compile the methods that are combined to form the compiled version of your user's code, and we also need to compile a sort of runtime debug information that allows us to jump from optimised code back to the native code when an optimisation proves to be wrong. This is a novel thing - most language VMs jump from optimised code to a bytecode interpreter - we have to jump back to the native code as there is no bytecode interpreter. Finally, a language VM also needs to include all of the Graal compiler itself for dynamic compilation, which is quite a bit of code.

</comment></comment></comment></comment></comment></comment><comment><USER35> Keep in mind that while this is nice technology, it's Oracle-based, split in CE/EE (which in itself is not a problem, but CE doesn't run on macOS), and they will find a way to screw you over at some point in the future regardless of what you do, use or choose.

<comment><USER36> Oh come on, I'm no fan of Oracle but this is some FUD nonesense..

<comment><USER37> I think it's a legitimate licensing concern.

I'm surprised you called it FUD, given the high-profile case against Android (google).

I was about to recommend we try it at my company and gave up as soon as I read "Oracle" in the company name.

Call it FUD if you want but Oracle does have a damaged reputation.

<comment><USER29> It happens when companies don't behave as they should, and others lack the money to enforce how things should be.

"James Gosling: Oracle vs Google"

[https://www.youtube.com/watch?v=JQ7xVO9lqD0](https://www.youtube.com/watch?v=JQ7xVO9lqD0)

<comment><USER38> I don't understand the point of the clip. He says that the code was similar to Sun's, but clearly admits that, not being involved with the trial, he didn't get to see Google's code.

</comment></comment></comment></comment></comment><comment><USER39> Runs a small erb template more than 50 times faster than jruby [1]. No mention of rails on that page though. It can also run C extensions.

[1]: [http://www.graalvm.org/docs/reference- manual/languages/ruby/](http://www.graalvm.org/docs/reference- manual/languages/ruby/)

</comment><comment><USER40> How is this better than compiling everything to WebAssembly and using V8 as your interpreter?

<comment><USER41> Because WebAssembly is extremely limited? Unless you need to ship on the web, using WebAssembly is almost certainly a bad decision as it makes highly compromising tradeoffs that you don't need.

<comment><USER42> Didn't know about this. Can you point me to some references that list the tradeoffs?

<comment><USER43> WebAssembly is a tool in work, supported by Google, Microsoft, Apple, etc... Currently it lacks a garbage collector, but this is planned. I would bet on wasm to be the holly graal in the future, more than anything else.

</comment></comment></comment></comment><comment><USER44> I recently stumbled on an announcement for Graal and Truffle in my bookmarks:

[https://blog.plan99.net/graal- truffle-134d8f28fb69](https://blog.plan99.net/graal-truffle-134d8f28fb69)

discussed at [https://news.ycombinator.com/item?id=13343845](https://news.ycombinator.com/item?id=13343845)

The idea there: "Graal is a research compiler. ... Truffle is a framework for implementing languages using nothing more than a simple abstract syntax tree interpreter."

As a bonus, you get high speed, good instrumentation for debugging and profiling, with great garbage collection, and hotswap code as you develop.

</comment><comment><USER45> So to contribute to this you have to sign the Oracle Contributors Agreement: [http://www.oracle.com/technetwork/community/oca-486395.html](http://www.oracle.com/technetwork/community/oca-486395.html)

"The OCA gives Oracle and the contributor joint copyright interests in thre code."

What does 'thre' mean? ;P

They want it physically printed and signed.. sigh, I haven't printed anything in years.

Is this normal to require a scanned signature for CLAs? I noticed Apache CLA is the same (they want scanned paper signature), but all others I've seen are an online form.

</comment><comment><USER46> Am I correct in reading the license in Github that this is all GPL? Albeit GPL2 but still not some Oracle proprietary license.

"One VM to rule them all" reminds me of Parrot VM (for Perl 6). Looks like development slowed down a year or two ago. Back then, it got me excited as it looked like the "open source community" alternative to "Big Corporate Java".

[https://en.wikipedia.org/wiki/Parrot_virtual_machine](https://en.wikipedia.org/wiki/Parrot_virtual_machine)

<comment><USER47> I was very interested in Parrot VM for a while too for the same reasons. I always liked the idea of language interoperability and being able to use the best libraries of each language. This brings me to a question I have had for a while, why do we even have so many language specific libraries for common tasks instead of more "universal" libraries with bindings for each. Of course these exist, but I feel like this should be almost the default, and language libraries would just be wrappers to help it integrate better with the language (like making it more pythonic for python etc). That way you would have at most a few competing libraries for each task with higher quality. Also it would be easier to bootstrap new programming languages since that is a big initial barrier (having few libraries).

<comment><USER48> There are fundamental semantic differences between the languages. An immutable language will always have a serious impedance mismatch with a mutable library. A library that uses GC won't work in a language without them, a specific example of the general principle that memory management strategies vary widely. A library that uses dynamic types will have a huge conversion boundary with a statically-typed language, and vice versa. A library that uses threads, or expects threads, will have a hard time working in an event-based environment that depends on code voluntarily yielding to maintain its responsiveness. A language that wants to provide guarantees about correctness or whathaveyou is forced to give all those up to talk to a lowest-common- denominator library.

And that's just the top-level differences. It gets worse as you get into the details of API style and the costs of the indirection layers to convert into the local style, assuming conversion is even technically possible.

Even if you write with the lowest possible common denominator of C or Rust with no runtime, you'll _still_ encounter a significant subset of those issues. And of course we still will use such things; all serious languages can communicate in some manner with a C implementation of a library. (Not for any theoretical reasons, really, C has more opinions than people often realize, but because it's still the baseline current systems are built on.) But it can't be as good as a native implementation.

<comment><USER49> >you'll still encounter a significant subset of those issues

Heck you will encounter those issues in a large project using only one language!

</comment></comment></comment></comment><comment><USER50> To what extent is this compatible with all existing libraries for allegedly supported languages?

I'm also curious if .net standard/c# support is being planned.

<comment><USER3> You can check libraries here: [http://www.graalvm.org/docs/reference- manual/compatibility/](http://www.graalvm.org/docs/reference- manual/compatibility/)

We don't test all of them but many.

We have considered .NET support but we are not actively working on it right now. But GraalVM is an open platform. Everyone can develop a language for it: [http://www.graalvm.org/docs/graalvm-as-a- platform/](http://www.graalvm.org/docs/graalvm-as-a-platform/)

<comment><USER51> It would be hilarious to discover if C# runs better on the JVM then CLR.

</comment></comment></comment><comment><USER52> Going to try it out, but does anyone know offhand whether GraalVM can be ran within the Linux subsystem in Windows 10?

<comment><USER3> If you can run a HotSpot JVM there then also GraalVM should work. I don't think we tested that.

<comment><USER52> Will let you know what I find out, thanks!

Edit: It works (for Ruby and Python)

Here is how to set up GraalVM for the Linux Subsystem on Windows 10:

1\. Enable and Install Ubuntu for Windows 10: [https://docs.microsoft.com/en- us/windows/wsl/install-win10](https://docs.microsoft.com/en- us/windows/wsl/install-win10)

2\. Download the EE edition of GraalVM to Windows: [http://www.graalvm.org/downloads/](http://www.graalvm.org/downloads/)

3\. Mount the folder that has the tar file: [https://stackoverflow.com/a/42586455/2548452](https://stackoverflow.com/a/42586455/2548452)

4\. Unzip the files (tar xvfs graalvm-ee-1.0.0-rc1-linux-amd64.tar.gz)

5\. Create a .bash_profile for setting the $PATH (my personal preference)

6\. Follow the instructions from the following up until the "Running Programs": [http://www.graalvm.org/docs/getting- started/](http://www.graalvm.org/docs/getting-started/)

7\. Follow instructions for installing LLVM and locales: [https://github.com/oracle/truffleruby#system- compatibility](https://github.com/oracle/truffleruby#system-compatibility)

8\. Follow instructions for installing libssl-dev: [https://github.com/oracle/truffleruby/blob/master/doc/user/i...](https://github.com/oracle/truffleruby/blob/master/doc/user/installing- libssl.md)

9\. NOW continue on with everything _after_ "Running Programs": [http://www.graalvm.org/docs/getting- started/](http://www.graalvm.org/docs/getting-started/)

Getting npm to work:

I could run node -v, but could not run npm and I was getting this error:

jvm library could not be loaded: /home/raj/graalvm/jre/lib/polyglot/libpolyglot.so: cannot enable executable stack as shared object requires: Invalid argument

I fixed it by running the following:

1\. sudo apt-get install prelink

2\. sudo execstack -c ~/graalvm/jre/lib/polyglot/libpolyglot.so

Going to do some experimenting, but so far so good!

</comment></comment></comment><comment><USER53> Really excited to see 1.0 release. Have been following Graal and SubtrateVM as a way to create native binaries (specifically CLI tools).

So, any plans to support Windows and MacOSx for CE?

Also, any support for cross-compilation to generate native-binary for a different target(something like Golang GOOS) ?

</comment><comment><USER54> This looks really interesting.

Can anyone comment on how mature the R and python support is? I'm coming at this from an ML/data science background, so anything that speeds up the above while maintaining broad library support would be a great help.

<comment><USER3> \- FastR is around for several years. Language support is pretty much done. Its mostly about getting to run CRAN packages that use native extensions.

\- Graal.python is pretty new and its really early days. So even basic language things might break right now. But we are investing a lot of resources in Python support.

You can check for compatibility of packages here (not yet for Python): [http://graal-staging.us.oracle.com/docs/reference- manual/com...](http://graal-staging.us.oracle.com/docs/reference- manual/compatibility/)

<comment><USER54> Thanks for that, link seems down unfortunately. I use data.table a lot but would happily switch if the dplyr family of packages work.

Would love to use this in Rstudio for exploratory analysis which would also need ggplot to work. Quite often have to cancel long running tasks when exploring a data set, so even if its a bit slower for interactive tasks but much faster for longer running tasks would be huge. E.g. typical interactive finished in 1 second instead of 50ms, but large loops that would take an hour finish in 10 minutes.

<comment><USER55> You will like to hear that there is some rstudio integration in the works.

Here is the correct link: [http://www.graalvm.org/docs/reference- manual/compatibility/](http://www.graalvm.org/docs/reference- manual/compatibility/)

(Accidentally posted the internal link :D)

<comment><USER54> Awesome, thanks for that. I'll definitely give it a shot once rstudio is supported.

</comment></comment></comment></comment></comment><comment><USER30> Some benchmarks I saw on Twitter.

[https://gist.github.com/havenwood/6fed7dd17131330ae4fd36a06f...](https://gist.github.com/havenwood/6fed7dd17131330ae4fd36a06fd2c19b)

*( Scroll to the bottom for Summary )

</comment><comment><USER56> On the "why graal" page, it says that one benefit is you can use a larger heap size for nodejs applications. I would imagine one other big benefit is that you can have true multithreading since the app now runs on the jvm. Is this indeed possible? Is there any guidance on how to do it? Rhino had the concepts of Scope's and Context's to somewhat safely parallelize code, so curious if there are similar primitives in Graal?

<comment><USER49> >I would imagine one other big benefit is that you can have true multithreading

Thank The Maker.

</comment></comment><comment><USER57> Does this mean I can convert my C++ win32 desktop app to run on virtually all platforms?

<comment><USER58> Probably not. Win32 itself is a windows-only API -- although wine is a thing.

</comment></comment><comment><USER59> Does GraalVM truly supports hotreload/class reloading without any hacks (Agent, new classloader every reload) unlike Hotspot?

Until then, areas like web development always will be a torture.

</comment><comment><USER60> I wonder what this means for Clojure and Clojurescript developers

<comment><USER61> For Clojure, I think it means native compilation, with fast startup times, and the ability to interop with Python, Ruby, or any of the other Graal languages. Not sure there would be an advantage to re-implementing a Clojure on Graal. Clojure is not an interpreted language like Ruby, JavaScript and Python is, so I don't think Graal adds as much benefit here.

For ClojureScript, it would mean full circle. You could run your ClojureScript back on the JVM, and have Java interop from it.

</comment></comment><comment><USER62> there is any roadmap to make available for MacOS?

<comment><USER3> GraalVM EE has a MacOS version that is free for evaluation uses. [http://www.graalvm.org/downloads/](http://www.graalvm.org/downloads/)

There are technical reasons we cannot have a CE for Mac OS as well. But we are working on that.

<comment><USER62> [https://github.com/oracle/truffleruby/releases/tag/vm-1.0.0-...](https://github.com/oracle/truffleruby/releases/tag/vm-1.0.0-rc1) this will contain EE or CE version?

<comment><USER3> Neither. You download EE or CE from graalvm.org. Then you install using the component installer.

gu -c install org.graalvm.ruby

or from a local file

gu install ruby-installable-linux-amd64.jar

</comment></comment></comment></comment><comment><USER63> That is super interesting. Im particularly interested in C++ with the other languages mentioned.

</comment><comment><USER64> Does it support lisp? If not, any plans to add soon?

</comment><comment><USER30> Is SubstrateVM part of this release ?

<comment><USER3> Yes. Its behind the native-image command. [http://www.graalvm.org/docs/getting-started/#native- images](http://www.graalvm.org/docs/getting-started/#native-images)

</comment></comment><comment><USER65> This is seriously huge. I wonder if it actually gets popular.

Can anyone comment on TruffleRuby ? What remains to be done for it to be production ready ? GraalVM page still mentions it's experimental.

<comment><USER32> We are getting there, lots of things work right out of the box just fine. C extensions are still being actively worked on as they often need some amount of patching because of assumptions they make about types and so forth. I think we can reduce that, but I doubt it can will disappear entirely, but in the end I hope extension authors will test on TruffleRuby themselves and patch the code themselves.

<comment><USER65> I know that you are using Rails as a reference point so is there any ETA when will be most of the features usable ? (openssl,activerecord,nokogiri..etc) ?

<comment><USER32> OpenSSL and nokogiri already work pretty well. ActiveRecord works providing you have a database driver and I've got a rough set of patches for pg that I'm working on right now.

I'm working on Discourse at the moment and can run the dB create and migrate tasks and I'm working on the asset compilation pipeline, but it's all pretty rough and won't be our final solution.

<comment><USER30> Just wondering if any Discourse or Rails Core people involved to get it working?

<comment><USER32> Not at the moment. I'm mostly doing some ugly hacks to get stuff working and generating a list of bugs for things we need to fix properly. Looking at my branch I think there's one small change that we will want to do PR for in the end, and some dependencies that we may want to make platform dependent (though they recently did change a couple for JRuby, which also helps us). Pretty much everything else I hope to back out when we've fixed a few of the root causes.

</comment></comment></comment></comment></comment></comment><comment><USER66> We changed the URL from the announcement post at [https://blogs.oracle.com/developers/announcing- graalvm](https://blogs.oracle.com/developers/announcing-graalvm). Pretty sure the project page will be better for HN.

<comment><AUTHOR> I was uncertain which to use and went with the site announcing what was new, even if a bit corporate. I guess I picked wrong. Thanks for fixing.

</comment></comment><comment><USER51> This is an epic announcement and it further extends the JVM as the best VM to develop new languages for and port existing ones to. I'm curious though, is there a Truffle version of the Java language that the Graal JIT uses?

<comment><USER55> Not yet. It's on our roadmap.</comment></comment>


C++11 breaking changes in const-correctness guarantees - <AUTHOR> http://cdmh.co/16rCL82

<comment><USER2> Awesome talk by Herb Sutter in "C++ and Beyond" "You don't know [blank] and [blank]": [http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb- Sutter...](http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You- dont-know-blank-and-blank)

As you can guess it is about const and mutable, and Herb speaks about this feature(or problem -- depending on how you see it).

C++98: const == logically const

C++11: const == thread-safe

</comment><comment><USER3> C++98 "const" code still works exactly the same in single-threaded environment, so this change is not breaking, because no _existing_ code is broken.

<comment><USER4> 100% correct; before this standard, there was no standard for how C++ code should behave when run by multiple threads.

Also, I do not think the claim that const member functions cannot have side effects is correct.

For example, it is OK, but very bad practice to have a const member function update a global integer counter.

<comment><USER5> Also, you can declare member variables as mutable which allows you to modify it from a const function. An example legitimate application for this is acquiring a read lock on a mutex from a const function.

<comment><USER6> C++11 is finally saying that this is not ok, as it really breaks the const contract, and can produce varying behavior in a threaded situation.

You could also argue that read/write locks aren't legitimate applications (starvation, increased contention, alternate solutions).

<comment><USER5> But the const function could still accept a non-const reference to a mutex, and still produce varying behavior in a threaded situation. In other words, what you're describing as the const contract sounds a lot like a pure function, which it definitely is not.

<comment><USER6> I'm not sure how it would produce varying behavior if it satisfies the const contract, in regards to the object itself.

You're passing in a non-const reference, so wherever that came from would be expected to change. However the object itself would not change. Your object would be at StateA regardless of who gets the mutex first.

</comment></comment></comment></comment></comment></comment><comment><USER7> Related: [http://isocpp.org/blog/2012/12/you-dont-know-const-and- mutab...](http://isocpp.org/blog/2012/12/you-dont-know-const-and-mutable-herb- sutter)

</comment><comment><USER8> I dont see that as being a breaking change. In both cases its wrong to mutate the object in the const member, Its just in C++98 no one _explicitly_ told you that. Maybe we should spell other good programming practices out for you so you can start following them before they are stated by the standards commitee

1\. Don't use global state 2\. Don't use goto 3\. Don't, for the love of all things good in this world, use exceptions to do control flow 4\. Don't just pass strings around in your functions and deserialise them in your function 5\. Make your data members private with public accessors and mutators.

<comment><USER2> > In both cases its wrong to mutate the object in the const member, Its just > in C++98 no one _explicitly_ told you that.

How so? You cannot mutate a data member(without placing mutable before it) in const member function. It is a compiler error. Pretty explicit IMO.

The point of the article is that you should ensure thread-safety when you mutate mutable(sounds funny, I know) members in const methods.

</comment></comment><comment><USER9> The author is a total idiot.

The C++ language is totally unsafe, so when you call third-party code, literally anything can happen.

Just because there might be a convention for "const" methods to be thread-safe doesn't mean that they are actually implemented this way, regardless of what the language spec says.

It's alarming that this guy apparently writes books, hopefully no one reads them.

</comment><comment><USER10> > The most common use of mutable data, and I would argue that the only > reasonable use of mutable data is for caching.

This was confusing to read in the context of C++, because I typically associate that view with functional programming. Don't the majority of C++ classes require mutable data to work properly, even the ones in the STL? How do you write std::vector<> without mutable data?

Ok, so I looked a bit more, and it turns out there's a "mutable" keyword...

<comment><AUTHOR> I've updated the text to emphasize that. Thanks for pointing it out

<comment><USER10> Looks good!

</comment></comment></comment><comment><USER11> I've always suspected not using const all around my OO code is going to save me some trouble sometime. Looks I was right ;)

<comment><USER12> Completely agree. Despite what gurus say, there is hardly an advantage in writing const correct code, other than complying with existing libraries. Const is a nice concept in theory, but it doesn't provide any guarantees, since it is so easy to cast const away from any pointer. As a result, compilers can't do anything in practice with const, other than give an endless stream of compilation errors.

<comment><USER13> Often, the point of stuff like 'const' is exactly to give a stream of compilation errors, because they presumably mean the programmer is doing something wrong (either using the const keyword wrong, or using the things marked const incorrectly)

Even if things like 'const' are useless to the compiler in optimisation terms, they provide (weak) contracts for the humans writing the code, and obvious flags when these contracts are broken, by having to be explicit about, in this instance, const_cast's. ('git grep const_cast' => places to examine closely for bugs.)

<comment><USER12> The problem is that const is also flawed as a contract. Whenever you're using const, you're trying to design a class that behaves as a mutable or as an immutable object, depending on how the pointer/reference is declared. A class that behaves in two different ways depending on the situation is a recipe for disaster, and that's exactly what const asks us to do.

I only noticed this problem when I learned how languages such as Smalltalk/objective-c deal with the same issue: they create different classes for each situation, so if you want a mutable array you have to say so.

</comment></comment></comment></comment><comment><USER14> Completely unrelated to the content, but it annoys me when sites put 'design' in front of readability. Darkening the background, lightening the text color and reducing the font size is a sure way to make it hard to see.

</comment><comment><USER15> I always wrote const member functions assuming they had to be threadsafe. I guess that's the "advantage" of always having worked with multi-threaded code.</comment>


Jolly Bad Taste vs. feeble Good Taste - <AUTHOR> http://standpointmag.co.uk/critique-february-2019-jonathan-meades-jolly-bad-taste-vs-feeble-good-taste <comment><USER2> _Scruton's antipathy to "modernism" — which he seems to believe is a single hegemonic idiom rather than countless strands of invention_

Scruton doesn't actually believe that, but the sort of people who read Meades will mistake his torrent of pompous verbiage for knowledge of his subject.</comment>


Salary Negotiation – how not to set a bunch of money on fire - <AUTHOR> https://medium.freecodecamp.com/salary-negotiation-how-not-to-set-a-bunch-of-money-on-fire-605aabbaf84b#.o8itco9kz <comment><AUTHOR> I did my best to boil a lot of conventional wisdom about negotiating, securing multiple offers, and eschewing equity compensation for cash. Did I leave anything big out?</comment>


Scheme hits the App Store again - <AUTHOR> http://jlongster.com/blog/2010/04/05/farmageddon-available/

<comment><USER2> I love it. Gambit-C Scheme is my favorite also (although MzScheme has lots of great libraries). I have an Android phone - any chance of an Android version? I've seen some links of compiling to Java byte code, and there is a native SDK.

<comment><AUTHOR> I don't have access to any of the Android platform yet, so not any time soon. There should be no problem targeting it though. This was highly an experiment, and I already had enough on my plate.

In the next year or two I hope to move away from the iPhone in favor of Android.

</comment></comment><comment><USER3> Neat. Could you talk more about Scheme. In retrospect how did it work out? If you could do it over again would you use Scheme or just jump into Objective-C? What were the pros and cons of using Scheme.

<comment><AUTHOR> Sure! I plan to write a good post-mortem on my blog soon, so I will go into all of that in detail then.

In general, I'm really glad I used Scheme. Gambit Scheme worked great, and let me develop the game much much faster using incremental develop commonly found in the Lisp family of languages. View this video of mine to see what I mean:

<http://www.youtube.com/watch?v=p6k7fjOjqZw>

There were some downsides. The main one being that people didn't understand what I was doing, and I couldn't have hired another programmer if I wanted to. I also developed it from scratch because I didn't want to bother with writing bindings (but that was also to learn more about graphics). Also, I feared that the GC would make it too slow, and in the end, it was hard to control what the GC was doing. It worked out pretty well, but although it runs decently fast, the GC still incurs a pretty hard performance hit.

All said, I would do it again in a heartbeat, but I would probably make bindings to an existing framework and use it more as a lightweight scripting language. That way, the GC isn't run as often, and a lot of developers would be familiar at least with the API.</comment></comment>


Peer-to-Peer Insurance - <AUTHOR> https://en.wikipedia.org/wiki/Peer-to-peer_insurance <comment><USER2> As a founder of a "peer-to-peer" insurance business I'm not a huge fan of this wiki article as it makes a lot of incorrect generalisations.

> In today's peer-to-peer models, insurance policyholders form small groups > online. A part of the insurance premiums paid flow into a group fund, the > other part to the insurer.

In a broker-based model this might be true, but you may also be regulated as an insurer, or have a commercial relationship with a regulated insurer.

> For claims above the deductible limit the regular insurer is called upon.

Or the re-insurer, depending on whether the business deals with the underwriters or goes directly to re-insurance.

> The only requirement is that all group members must have the same type of > insurance

Not necessarily. In fact ideally not. There are significant savings to be made by leveraging an existing float rather than having separate pots, and the social density of your group becomes sparse if you can only insure your ferret with other ferret fanciers.

> The providers are financed through brokerage commissions of insurance > companies

In some models. Others not so much. As discussed above, dealing with the underwriters isn't the only way to run this kind of business.

Also "peer-to-peer" is a misleading name in some cases. Crowdsourced might fit better.

<comment><USER3> If I understand it correctly from what your company's website is doing, essentially, you're leveraging the fact that good drivers tend to know good drivers and there could be a social pressure to not affect the group's members.

The function of your company would be similar to that of the traditional insurer except all of the premiums go to the pool for claims and admin instead of also having to share it with shareholders/investors.

What I'm curious is what happens when claims are more than what's already in the pool? My assumption would be that premiums would have to go up to cover the loss so you're banking on the fact that by group selection, claims will be less than the average. And in the event that claims are more than the average, there's probably insurance taken out on that.

<comment><USER2> Yeah, good comment. I had a few of these thoughts myself in the early days but I think you're missing the main value of it. Apologies for the over-wordy reply.

> leveraging the fact that good drivers tend to know good drivers

I think humans might overestimate our ability to pick 'good' drivers. I wouldn't trust it very far... but it also doesn't matter much.

What matters is badly underpriced drivers, for example your mate who drinks and drives but doesn't yet have a conviction for it. Don't invite him. Everyone else is broadly fine.

> ...there could be a social pressure to not affect the group's members

That's a factor we're expecting to be able to measure, but it's not part of the business model per se.

> The function of your company would be similar to that of the traditional > insurer except all of the premiums go to the pool for claims and admin > instead of also having to share it with shareholders/investors.

Yeah, broadly speaking. Guevara's revenue stream is a flat fee, compared to a conventional insurer whose income is your premiums... so Guevara isn't motivated to inflate your premium or to look for technicalities when handling claims.

> when claims are more than what's already in the pool?

The UK motor insurance market requires policies to have uncapped liability, so you always need reinsurance. Even when you're insured through Admiral et al the larger claims are farmed out to Munich Re, Swiss Re, Trans Re, etc.

> ... premiums would have to go up to cover the loss...

To an extent, yeah. You do get price volatility, but we cap it at 100% of your (competitive) Year 1 premium. Your premium can drop as low as 25-30% of your typical market rate in a good year, and averages out costing about 50%. You get that huge discount in exchange for taking that volatility.

That discount is effectively the underwriting profit that would normally go to the insurance company.

> ...so you're banking on the fact that by group selection, claims will be > less than the average.

We're not banking on group selection being meaningful to our claims rate. We _hope_ for lower claims rates, and lower average claim size, but we'll be very successful without those things because it's simply a better business model. There's much less moral hazard, lower susceptibility to fraud, less information asymmetry... but more importantly (a) as you build up capital your premium drops, so you get a lower price and we get a higher LTV through reduced churn, and (b) we have a lower CAC compared to conventional insurers. I know I'm biased but I think it's a strong model even before any of the behavioural benefits.

I should add that I have now stepped back from Guevara (I can't commit enough time for family reasons), so my knowledge of product pricing, policy, and the rest of this stuff is dating rapidly.

<comment><USER3> Thanks for your really insightful comments. I've been studying and working in the industry for several years now trying to see if there's a better way to do it. In fact, I did study Guevara along with other insurance-based startups to see if there's anything to learn from or be aware of.

It doesn't seem to me that customers would see full value of their "purchase" if they have never had a claim. Yet, it's crazy that their premiums go up because someone else had a major accident. On the flip side, insurers can't really choose to raise their rates like a normal business would do. For me, this is the fascinating part about insurance businesses.

What is curious to me is if there is a way to build a risk model that assumes that people will get into accidents by default? You've mentioned that people overestimate our ability to pick good drivers. Why not build a model that assumes people are bad drivers by default and optimize from there?

<comment><USER2> > It doesn't seem to me that customers would see full value of their > "purchase" if they have never had a claim.

If you think about Guevara's insurance as capital expenditure (by describing it as a purchase) then, sure, you're right, losing some of it because of someone else's accident triggers our human aversion to loss.

But, the trick there is that while Guevara's insurance can be described as capital expenditure, conventional insurance is always operational expenditure. With conventional insurance you're not _buying_ your insurance, you're only _renting_ it. At the end of the year you have nothing.

> Why not build a model that assumes people are bad drivers by default and > optimize from there?

I think Guevara's model is as close to that as it's possible to go. By moving an acceptable degree of the financial repurcussions for accidents onto you and your social group, Guevara is stepping back from needing to care directly about who is and who isn't a good driver.

For example, if there were a way let a group choose their own prices, or pay flat prices, then (in theory at least) Guevara would be able to entertain that idea. Pricing matters for Guevara in terms of customer acquisition, and in terms of making things feel fair for your group-mates, but other than that it's not a big issue.

Insurers care about pricing so much they're putting tracking devices in peoples cars to understand their driving patterns. They need to get more and more and more data because they're ultimately trying to predict the future. Guevara doesn't need to do that.

</comment></comment></comment></comment></comment><comment><USER4> This would be interesting to me if I could put together a small pool of say ~5 friends of the same age (22) and health (good).

If everyone did this, health insurance rates would drop drastically for pools of young, healthy individuals and rise drastically for the old and the sick. Which somewhat defeats the point of insurance - spreading risk over large, heterogeneous portions of the population.

<comment><USER5> Fwiw: I paid accident claims for over five years. Most claims fell into one of two categories: "accident waiting to happen" or people trying to get coverage for things like the chiropractic care they were going to get three times a week anyway. Only a tiny portion of claims really struck me as shit happens/man, it sucks to be you.

If you really want low health bills:

Do all that boring stuff you constantly read about, like brush, floss, eat right, exercise, and only drink in moderation. Do not ever get rip roaring drunk. Especially do not drive or engage in other dangerous activities while drunk or high. Don't sleep around casually. Don't ride a motor cycle. If you want to go hiking in the mountains, take the appropriate precautions and do not drink or do drugs.

A lot of claims will not be covered anyway if you were drinking, taking drugs or engaging in risky behavior (parachuting, mountain climbing). And keep in mind that insurance only protects against financial loss, and only to a limited degree. If you permanently maim yourself doing stupid crap, you will not only be stuck with high medical bills and reduced odds of making a good income thereafter, you are also _permanently maimed,_ duh. Living with chronic pain and other issues of that ilk still sucks majorly, even if you win the lottery and are set for life financially.

/boring old fogey

<comment><USER6> If I could offer you only one tip for the future, sunscreen would be it. The long-term benefits of sunscreen have been proved by scientists.

<comment><USER4> Whereas the rest of my advice has no basis more reliable than my own, meandering experience. I will dispense this advice on HN.

</comment></comment></comment></comment><comment><USER7> That article needs work, and lacks historical context. The first such organization was the Philadelphia Contributionship for the Insurance of Houses from Loss by Fire, established by Benj. Franklin in 1752. They're still in business.[1]

Originally, they sold permanent fire insurance. You paid premiums for some number of years, and were then paid up for the life of the building. The building can only burn down once, after all.

[1] [http://www.contributionship.com/](http://www.contributionship.com/)

<comment><USER8> You could add your edit and relevant link to the Wikipedia page?

</comment></comment><comment><USER9> Also known as "mutual insurance", which has existed for centuries. Or am I missing something?

<comment><USER10> Yeah, p2p is similar to p2p lending, which is not exactly a mutual credit union. The difference is the social factor which means they'll help each other, but also that they'll trust each other.

Material insurance (where you're insuring a certain $ amount) works because people have utility curves that justify it: the utility of losing 1M is much higher than 10 the utility of losing 100k.

So for p2p, 10 people can buy just 5 insurance contracts and distribute the rest of the risk amongst themselves.

</comment></comment><comment><USER11> This is how USAA got started as well. A group of 25 US Army officers got together back in 1922 to insure their vehicles. They're one of the better insurers these days if you're eligible for their services.

</comment><comment><USER12> How does this differ from long-existing "mutual" insurance companies? A policy holder essentially owns a a share in the insurance company. Peer-to-peer automates this on the web.

<comment><USER13> I'm under the impression the p2p insurance schemes are supposed to consist of small pools of peers supposedly closely-associated enough to be willing to evaluate each others' risks, whereas the mutuals tend to pool risk across larger groups and differ from other insurers only in that they share the profits with their policyholders.

I suspect in practice the larger, more diverse pool of risks and knowledge of professional underwriters at conventional insurers (mutual or otherwise) will trump the "I know X, Y and Z are very good at looking after their possessions" knowledge of the P2Ps, but it looks like the P2P schemes tend to back up the p2p scheme with a traditional insurance policy (with a relatively high excess), so actually the p2p scheme is only underwriting a portion of the overall insured risk. Theoretically you'd then get the benefit of the underwriters' ability to assess and cover expensive and idiosyncratic risks and your own better position to assess your peers' behaviour.

</comment></comment><comment><USER14> I would love to see some form of this concept implemented here in the US. Does anyone know of any startups trying to work on this? I wonder what some of the larger obstacles are from having this created.

</comment><comment><USER15> How does this differ from a reciprocal inter-insurance exchange[0] like USAA?

[0] - [https://en.wikipedia.org/wiki/Reciprocal_inter- insurance_exc...](https://en.wikipedia.org/wiki/Reciprocal_inter- insurance_exchange)

</comment><comment><USER16> You still need a ton of statistics and a big enough pool to make it reliable. Then you will need staff to handle applications, support and abuse ...</comment>


Breitbart misrepresents research from 58 scientific papers about global warming - <AUTHOR> https://climatefeedback.org/evaluation/breitbart-misrepresents-research-58-scientific-papers-falsely-claim-disprove-human-caused-global-warming-james-delingpole <comment><USER2> "Breitbart article is bullshit" is pretty much taken as read, but letting the cited authors have a Marshall McCluhan moment ("you know nothing of my work") does hav e its own satisfaction. Too bad it won't be seen by as many people.

<comment><USER3> 33k social media shares for the Breitbart article, 15.1k for Climate Feedback's debunk + 6k for Snopes' ([http://www.snopes.com/scientific-papers- global-warming-myth/](http://www.snopes.com/scientific-papers-global-warming- myth/)), not too bad...

<comment><USER2> Are we assuming shares is proportional to total viewing?

</comment></comment></comment><comment><USER4> A majority of reviewers tagged the article as: Cherry-picking, Derogatory, Flawed reasoning, Inaccurate, Misleading.</comment>


Books that influenced Clojure - <AUTHOR> http://www.amazon.com/Clojure-Bookshelf/lm/R3LG3ZBZS4GCTH/ref=cm_lm_byauthor_title_full <comment><USER2> I'm shocked that Java Concurrency in Practice isn't in the list:

[http://www.amazon.com/Java-Concurrency-Practice-Brian- Goetz/...](http://www.amazon.com/Java-Concurrency-Practice-Brian- Goetz/dp/0321349601/)

I only know about that book because of Rich's mentions of it.

To be honest, I"m also a little surprised that the Pickaxe book is in the list. Not that Ruby isn't the bees knees; it just didn't strike me as being influential on Clojure.

<comment><USER3> I, too, am surprised that Java Concurrency in Practice is missing. Rich has mentioned several times. Odd.

As for the Ruby influence, Rich mentioned that he is a "language nerd" and learns all kinds of languages. Whether any one language shows up in some way in Clojure is another matter ;-) I think the Ruby influence shows up in Clojure's ease of scripting Java, cutting through the ceremony to get things done in minimal code.

<comment><USER4> I'm sure I selected it, but I didn't realize it hadn't gone into the list. Now fixed - thanks.

</comment></comment></comment><comment><USER5> On #clojure, Rich once mentioned that Jim Gray's "Transaction Processing.." influenced his design of clojure's STM. IIRC, he mentioned that the MVCC aspect of the STM and the commute operation were some of the ideas that he took from the book.

Another paper that gets repeatedly mentioned as being influential in Clojure's design is <http://web.mac.com/ben_moseley/frp/paper-v1_01.pdf>

Once you finish the above paper, you should also look at [http://code.google.com/p/clojure- contrib/wiki/DatalogOvervie...](http://code.google.com/p/clojure- contrib/wiki/DatalogOverview) for seeing one way of doing FRP in clojure.

<comment><USER6> _Another paper that gets repeatedly mentioned as being influential in Clojure's design is ["Out of the Tar Pit" by Moseley and Marks]_

Repeatedly mentioned by whom? I've looked at these guys' stuff a few times. While the idea of functional-relational programming is appealing, it is also obvious, and as far as I can tell they're not providing much more than fluff.

<comment><USER7> _Repeatedly mentioned by whom?_

Rich Hickey.

<comment><USER6> That's interesting. I guess I'm missing the value there. I'd give it another look, except I just did.

<comment><USER7> He seems to use it to deflect the TDD crowd. Personally, I found it boring.

<comment><USER8> There are some interesting quotes there, but many of the intermediate conclusions are not well supported.

</comment></comment></comment></comment></comment></comment><comment><USER9> Since Clojure lacks tail-call optimization, I'm not sure how the book "Programming Clojure" influenced it...

<comment><USER10> Funny. :)

But really, the book betas were released months before Clojure 1.0, so it's likely Rich saw issues/confusion and adapted the language as necessary.

</comment></comment><comment><USER11> You can read the thesis that later became "Purely Functional Data Structures" for free online: <http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf>

It's a great read even for those who don't yet have experience with functional programming.

<comment><USER12> Can you explain to me what the distinction between persistant and ephemeral data structures are (as mentioned in the thesis)? From a brief reading, my understanding is that persistance implies a record of all changes to a data structure are kept somewhere, but that this is only really useful for multithreaded programs. Is that correct?

<comment><USER13> in a persistent data structure, you don't actively remove, delete, or change anything. rather each time you make a 'change', you create a new structure which points to, and reuses as much of the old one as possible. then the garbage collector removes the unused bits, if any.</comment></comment></comment>


Show HN: Generate a UI Kit for Your Web Project - <AUTHOR> https://ui1.io/ <comment><USER2> Thank you @dragondar for posting this. I'm one of the makers of UI1. If anyone has any questions, I'm here to answer =)</comment>


YouTube for Computer Science researchers - <AUTHOR> http://videolectures.net/ "2138+ free video lectures from the world's leading and prominent scientists." There are so many fascinating videos that it is difficult to select just one series to link to. <comment><USER2> Computer Science researches who use Windows that is. All seems to be in WMV format.

<comment><USER3> The WMV format wouldn't ordinarily be a problem; lots of video players everywhere can play that fine. Even WMV streams are ordinarily OK. It's just that something freaky is going on with these particular streams.

</comment></comment><comment><USER3> Does it work on Linux? VLC and Mplayer don't seem to like the stream, yelling about connection problems.

</comment><comment><USER4> Coming next, reddit for people who like to wear yellow hats.</comment>


Brazil's copyright societies indicted for fraud - <AUTHOR> http://www12.senado.gov.br/noticias/materias/2012/04/24/cpi-do-ecad-propoe-novas-leis-e-orgaos-para-gerir-direitos-autorais <comment><USER2> FYI ECAD is the Brazilian equivalent of ASCAP in the US. The article is basically saying that when ECAD was originally founded that it was a big win for writers, musicians and other creators of content, but that in the Senate hearings and investigations it was found that ECAD had degenerated into an organization with poor transparency that now operates as if it exists for its own sake. 15 people involved with ECAD are being indicted on a variety of issues including such as fraudulent collections.

This is awesome, and despite some backwardness in how Brazil's government is on some internet issues __, it has been very forward looking on issues such as the drafting of an Internet bill of rights ([http://www.techdirt.com/articles/20111004/04402516196/brazil...](http://www.techdirt.com/articles/20111004/04402516196/brazil- drafts-anti-acta-civil-rights-based-framework-internet.shtml) )

While this investigative committee was formed in the middle of the last year, it was ECAD's targeting of my co-founder's design blog ( <http://www.caligraffiti.com.br/> ) and one other blog that moved recently moved popular sentient against the organization and brought these fraudulent collections to light. Their attempts to double collect royalties from both Google (with whom they had a contractual agreement for royalty collection) and using legal threats against people, like bloggers, linking to content on sites like YouTube blew up in their face and they ended up getting a ton of well deserved bad press.

The cool thing about Brazil is that culturally, we own up to the fact that remixing is a big part of the creative culture and has been for a long time, something that is true of the US as well, but isn't as universally acknowledged.

 __(e.g. they are quick to send censorship notices to companies like Google, this is largely because most judges are very computer illiterate and don't understand how the medium differs dramatically from others. It is largely an issue of misinformed judges. Brazil desperately needs an EFF to help with the issue of legal education pertaining to the Internet, but current laws regulating legal organizations prevents the creation of an analogous organization.)

<comment><USER3> "we own up to the fact that remixing is a big part of the creative culture ... something that is true of the US as well, but isn't as universally acknowledged" ever wonder why American rap music only samples for 30 seconds, let me give you a hint if they went longer than that they would have to pay a royalty. Most artists have accepted and worked creatively within this confine. As for "isn't as universally acknowledged"; according to wikpedia a higher percentage of people in Brazil can't read than America [http://en.wikipedia.org/wiki/List_of_countries_by_literacy_r...](http://en.wikipedia.org/wiki/List_of_countries_by_literacy_rate) this leads me to believe your point is moot.

<comment><USER4> There's no 30 second rule for sampling - IIRC the limit to sampling is how many people you want to negotiate a composition credit with. That's why newer music that uses popular samples usually just sounds like an annoying remake of a song that was good enough already. This creates an image in the public mind that people who sample aren't very creative at all, just turning up the bass and shouting over old songs.

During the golden age of rap (aka the only reason rap entered worldwide mass consciousness), the music would be stitched together from half a dozen or more manipulated and overlaid samples of songs, often of sub-second length. After a few high profile lawsuits, rap was neutered into the type of party pop where it would be considered notable that samples were less than 30 seconds.

Listening to, for example, a Bomb Squad produced song from the era, you could have previously been familiar with every single song that went into the production, yet be hard put to spot more than one or two.

I'd liken the situation to trying to write a program in a world where there's a billion libraries that you can use, but for each one you have to share 25% to 75% of the profit from the program with the owner of the library. In addition, these billion libraries would be criss-crossed with a million patents, assuring that you can't simply reimplement the functionality without running into the same problem.

</why I stopped listening to rap in 1995>

</comment></comment></comment><comment><USER5> Brazilian here. I am surprised our senators are doing their job.

<comment><USER6> Brazilian expat here and I left mostly because I got tired of fake institutions.

This looks like the Mafia going after the smaller criminals in the neighborhood. The Brazilian Senate bosses are among the biggest gangsters in Brazil (e.g.: José Sarney, Renan Calheiros, Jader Barbalho, Demostenes Torres, etc.)

<comment><USER7> Another Brazilian here and you are definitively right, our government is mostly filled with white color thiefs.

So this might be mostly a some criminals going after another group for some problem they had.

<comment><USER8> Yet another Brazilian here and you mean white collar thieves.

</comment></comment></comment></comment><comment><USER9> This is not about copyright, but author rights.

<comment><USER10> A more productive comment would explain the difference between those two ideas for the benefit of people (such as most Americans) who have not encountered authors' rights.</comment></comment>


Show HN: Mindscope (iPad) – sweet spot between mind-mapping and outlining - <AUTHOR> http://www.mindscopeapp.com <comment><USER2> I haven't tried the app yet, but four suggestions would be:

\- dependency tracking between items (there are many use cases for this, anything from project management to social networks), inShort on iOS has an advanced implementation based on Theory of Constraints in industrial-scale manufacturing, [http://www.shortki.com/inShort.html](http://www.shortki.com/inShort.html) \- something much simpler could still be useful

\- multiple parents for a child node, NoteLynX has an implementation on Android: [http://astrodean.blogspot.com/2011/10/outliner- hierarchical-...](http://astrodean.blogspot.com/2011/10/outliner-hierarchical- tree-note-editor.html)

\- WebDav import/export for OPML or other formats, this allows sync to self- hosted storage

\- interoperability with iOS apps which perform local encryption, e.g. ipgmail

<comment><AUTHOR> Thanks for the ideas! Especially 2 and 3 remind me of stuff I've been considering anyways.

Re: 1 - could you be more specific regarding "dependency tracking"? Each entry is currently simply a text entry that you can move around with your finger. You can also set up arrows between entries. How would you envision tracking dependencies? Could be you'll need to try the app out first and would have more thoughts then.

Thanks again for the feedback!

<comment><USER2> A lot of visual apps allow users to draw arrows, but why are people drawing arrows? Is the direction of the arrow significant? It's usually a dependency, e.g. MS Project saying that this task must be completed before another task = time dependency. A hierarchical outline is another way of expressing dependency (composition).

What eventually happens after drawing lots of arrows and creating outlines is that users want to make changes to their diagrams. But the diagram editor then ignores all those beautiful arrows and the poor user ends up moving singular nodes around and repeating the layout manually.

inShort hard-codes a set of rules for a specific use case. A lightweight drawing tool could still benefit from allowing some operations to be aware of inter-entry dependencies/arrows/relationships, e.g. grouping, change propagation, composition.

I'll try the app at some point, currently using iThoughts (for fast layout speed on complex maps) on iPad, EccoPro & ConnectedText on PC (supports dependencies and facets). An interesting open-source app is [http://treesheets.com](http://treesheets.com), which is a cross between outliner & spreadsheet.

<comment><AUTHOR> I love iThoughts also, but more for classic mind-mapping on a certain topic rather than outlining or keeping a "life document" like Workflowy or OrgMode, which is closer to the typical usage scenario of Mindscope.

<comment><USER2> Quick feedback:

\- couldn't find the "share button" after long-pressing a board

\- breadcrumbs at top of page are useful, might be useful if long-press on a parent or grandparent breadcrumb brought up a list of peers

\- could there be an option to disable transition animation? Rollover on selection of item is good, but the whole-page zoom animation makes me dizzy.

\- need template support to reuse "forms" created by drawing lines

Overall feels promising. Scapple also looks cool, too bad it's only on OSX.

</comment></comment></comment></comment></comment><comment><AUTHOR> I wrote this app first and foremost for myself, and intended it to be the sweet spot between a mind-mapping tool and an outliner. On the one hand you can quickly enter thoughts, drag them around and sort them visually (kind of like Scapple in that regard). On the other hand, you can zoom into an entry to focus on it and you get a new space for new entries (kind of like Workflowy in that regard).

Would love to hear any feedback or thoughts on future developments you'd all recommend. I'm currently planning on adding search, sync, and alarms for entries.

Direct App Store link for the lazy: [https://itunes.apple.com/us/app/mindscope/id901513028?ls=1&m...](https://itunes.apple.com/us/app/mindscope/id901513028?ls=1&mt=8)

<comment><USER3> Thanks for making this. I've always wanted one myself (just didn't have time to make it). You're awesome. Thanks!

</comment></comment><comment><USER2> It would be helpful to read about the vision behind this app, e.g. how it differs from iThoughts HD, MagicalPad HD, TheBrain, etc.

<comment><AUTHOR> Sure - just posted a little description above, but would love to answer any other specific questions. From the three apps you mention, it's probably most like TheBrain, but I like to describe it more as what would happen if Scapple and Workflowy created a love child. ;)</comment></comment>


Bitcoin is so 2013: Dogecoin is the new cryptocurrency on the block - <AUTHOR> http://mobile.theverge.com/2013/12/16/5216862/bitcoin-is-so-2013-dogecoin-is-new-crypto-currency-on-the-block

<comment><USER2> clickable non mobile link for us old fashioned desktop users... [http://www.theverge.com/2013/12/16/5216862/bitcoin-is- so-201...](http://www.theverge.com/2013/12/16/5216862/bitcoin-is- so-2013-dogecoin-is-new-crypto-currency-on-the-block)</comment>


Generate responsive, maintainable and unified email templates Using SASS and Pug - <AUTHOR> https://github.com/dhilipsiva/email-template-generator <comment><USER2> If it meets the guidelines, this might make a good "Show HN".

Show HN guidelines: [https://news.ycombinator.com/showhn.html](https://news.ycombinator.com/showhn.html)</comment>


Star Trek and the shiny, boring future  - <AUTHOR> https://medium.com/geek-empire-1/7e7dc993b4fd

<comment><USER2> Oh, so you have a teleportation device? Antigravity machines that let you fly and hover without aerofoils or rockets? FTL communications? Disease-adaptive medicines? A volume-based universal positioning system?

It seems to me that the author a) took a highly selective reading of the technology on display in the film, and simply omitted anything that didn't suit his argument and b) ignored the fact that the _Star Trek_ franchise has about 40 years of 'world data' that it needs to maintain a fair degree of continuity with if it is not to piss off the large fan base.

People carry tablet computers in Star Trek not because we have iPads now, but because characters in Star Trek were using tablet computers (albeit large wedge-shaped ones with stylii) from the very early episodes.

<comment><USER3> I have to agree, the author simply ignores all the technology that doesn't yet exist.

I don't think anyone could have predicted before how quickly computers, and radio technology would minaturize giving us cellphones and ipads.

</comment></comment><comment><USER4> Just another formulated Hollywood movie, not an eyeglass into the future.

I don't want to nerd out on this, but realistically if we were however many hundreds of years down the line where we had the technology to do interstellar travel, it's unlikely it would resemble what's on Star Trek.

As far as devices go, they're getting smaller and more integrated so at some point they'll jump the bio-tech gap and just be integrated with your physiology. But who wants to watch a bunch of spandex laden crew walking around like schizophrenics? Gotta give a general audience something they can understand and relate to.

<comment><USER5> Exactly right.

At the beginning of the new film Spock is lowered on a rope into a volcano hanging from a little shuttle. Everyone knows this situation exists for the immediate drama and for the ramifications further on in the story, not because it's in the least bit plausible (let alone necessary). In the future they couldn't have had a robot deliver the package? Maybe just drop it in with a timer on board? The trouble is that it wouldn't have served the story, and it wouldn't have been Star Trek.

Today Star Trek is a brand, a flavour. Maybe once upon a time it was meant to have something to say about our future, but now any reasonable extrapolation would lose the essential character of the property. Hell, maybe Star Trek has never been about the future anyway. I'm sure everyone caught the bit about the morality and legality of extrajudicial killing in the new flick... I'm sure plenty of people would say the series has always been about the present as much as any other time.

</comment></comment><comment><USER6> Said this before, but Denno Coil is a recent post-cyberpunk sci-fi animated series from japan that explored AR tech in interesting new ways. It is not the "hardest" of sci-fi, and it is about kids, but it is touching, does not pull punches, and I like the art direction. I would suggest checking it out for anyone who wants some fresh sci-fi.

I think saying main stream movies are supposed to be imaginative is a bit of a straw man argument.

</comment><comment><USER7> I hate to think that what's driving innovation is fantasized _movie_ tech. I always thought it was science fiction literature, and, you know, trying to understand how the universe works in reality.

<comment><USER8> Science fiction literature isn't actually all that often _about_ the science. The number of science fiction authors writing about fields in which they're technically experts is likely vanishingly small, as being a successful storyteller is an expertise in and of itself. The trope of science fiction writers not having a sense of scale in regards to interstellar distance or geologic time is one good example. Or Asimov's Three Laws of Robotics, which weren't even really an extrapolation on the potential encoding of machine morality so much as a plot device, the entire point of which was the clever ways in which it could be broken by antagonists.

Of course the counterpoint... when it works (Peter Watts and Neal Stephenson and maybe the near-future stuff by William Gibson... Cory Doctorow maybe) the technology serves the story and illustrates the future in brilliant and almost plausible ways. More often than not though, the science in science fiction is window dressing or magic with "science" spray painted on it, because really how many stories about how bloody hard it is to get into space and not die from something besides aliens can people be expected to read?

<comment><USER5> Yeah, this essentially comes down to the "hardness scale" of science fiction writing. If you're making a big budget film then it's all for mass consumption, and realistic extrapolation only really makes the cut if the novelty or plausibility of it impresses the audience. Special effects and space battles are a better bet most of the time.

As you've said, exceptions exist, but they're even less present in the film market for obvious reasons. I'd actually say there's no dearth of good hard written scifi, though. Charles Stross (sometimes seen around here and on Reddit) has introduced a bunch of incredible new things in "Accelerando" that appear obvious in retrospect, things in Hannu Rajaniemi's "The Quantum Thief" like the privacy settings on Mars were insightful as hell. Just about everything written by Greg Egan is grounded in some jaw-dropping speculative physics or steeped in new thought on the philosophical or social ramifications of foreseeable technologies.

</comment></comment></comment><comment><USER9> _It's a terrible shame and a real disservice for the years to come when the people we count on to dream are content with IKEA and iPads._

</comment><comment><USER10> I do agree that Star Trek tech has been boring, but its tech predictions have always been boring, mostly just extensions and upgrades to what we have now, or invented as plot contrivances (i.e. the Holodeck)

It's too bad we have to hope that Hollywood invests more in thoughtful edgy fiction rather than marquee fan service vehicles mainly intended to make millions for the industry. If only there was some other form other that movies and TV that fiction could be communicated in...perhaps someone in the future will invent such a format that is ubiquitously consumable and intellectually stimulating.</comment>


Help solve package management on *nix systems - <AUTHOR> http://timolshansky.com/yumitude/

<comment><AUTHOR> Alternative solutions to the problem also very welcome. I haven't been able to find anything that solves the naming disparity.</comment>


Ask HN: What's the best alternative to MacBook Pro 13" retina? - <AUTHOR> <comment><USER2> Dell XPS 13".

See [http://www.anandtech.com/show/8983/dell- xps-13-review](http://www.anandtech.com/show/8983/dell-xps-13-review) or [http://arstechnica.com/gadgets/2015/04/dell-releases- updated...](http://arstechnica.com/gadgets/2015/04/dell-releases-updated- xps-13-developer-edition-in-wide-variety-of-configs/)

<comment><AUTHOR> The hard thing about giving up a Mac is their excellent touchpad. I tried the XPS one and it's nowhere near.

</comment></comment><comment><USER3> Kind of hard to make recommendations without knowing why you're looking for an alternative. Is it price? Do you prefer to use Windows/Linux and want something with one of those installed out of the box? Don't like Apple keyboards? Don't like glossy screens?

</comment><comment><USER4> Have you taken a look at the Thinkpad X1 Carbon? I always hear nice things about it.

</comment><comment><USER5> Why don't you want a rMBP? I love mine dearly.

<comment><AUTHOR> I start to hate Mac OS X.

</comment></comment><comment><USER6> Asus Zenbook</comment>