News for hackers. Stuff that matters.
Re:Porting a NES Emulator from Go to Nim by madez on Friday May 01, 2015 @03:25PM (#9473922)
I'd say that it feels more like a scripting language in comparison to Rust and is more approachable than Haskell or Erlang while being fast since it's compiled to C.
Re:Porting a NES Emulator from Go to Nim by mreiland on Friday May 01, 2015 @03:58PM (#9474106)
being compiled to C doesn't imply fast :)
Re:Porting a NES Emulator from Go to Nim by def- on Friday May 01, 2015 @05:18PM (#9474592)
It does have other advantages though, like inheriting C's excellent portability.
Re:Porting a NES Emulator from Go to Nim by coldtea on Friday May 01, 2015 @06:51PM (#9475005)
Unless done badly, it does.

Transpiling to C gives you the opportunity to emit code that is straightforward clean and fast C for most operations, which avoid an abstraction overhead.

Re:Porting a NES Emulator from Go to Nim by jerf on Friday May 01, 2015 @07:11PM (#9475087)
No, it doesn't. You could easily compile Python into C (basically, "just" inline the core interpreter loop), but it will still be slow, because the Python semantics still require a lot of dictionary resolutions on every operation. Getting efficient C still requires you to think about getting efficient code. You can not get it "for free" just by waving a C compiler over your language. Otherwise, everyone would just do that and there would be no languages slower than C.

Before you reply to disagree, make sure to very, very carefully think through the implications of the last sentence there. It is not as if compiling to C is particularly hard; it is literally "homework assignment for a normal college senior in a compilers course"-difficult. Many languages have gone through a phase where they compile to C. Usually they deliberately leave C at some point, another thing to carefully ponder the implications of before replying in disagreement.

Re:Porting a NES Emulator from Go to Nim by coldtea on Friday May 01, 2015 @07:25PM (#9475155)
>No, it doesn't. You could easily compile Python into C (basically, "just" inline the core interpreter loop), but it will still be slow, because the Python semantics still require a lot of dictionary resolutions on every operation.

Yeah, and you could do this too at the start of your emitted code from the transpiler:

sleep(UINT_MAX)

which would also make it slower than an interpreted language. But I specified I wasn't talking about that, or about "just inlining the core interpreter loop", but about transpiling letting you also emit straightforward and clean code without extra abstractions for most operations.

A new language like Nim doesn't come with all the baggage of Python's runtime pre-existing, and doesn't need to recreate it.

Re:Porting a NES Emulator from Go to Nim by mreiland on Friday May 01, 2015 @11:16PM (#9475728)
HipHop doesn't support the entirety of the PHP runtime for exactly the reasons that have been laid out for you.

That's reality from a company with a shitton of money and a vested interest in doing it successfully.

They can't do it in the general case because reality disagrees with you.

Re:Porting a NES Emulator from Go to Nim by coldtea on Saturday May 02, 2015 @07:49AM (#9476726)
Not sure what are you getting at. What I didn't say: transpiling is magic fairy dust for speed, and you don't have to care about language semantics at all.

What I said: "unless done badly" (my words on the original comment), it's fast, as it gives you a chance to emit straightfoward C code for most operations. Now, regarding your example:

First, HipHop is not transpiled to C. It's a runtime with a JIT.

Second, what does "HipHop not supporting the entirety of the PHP runtime" has to do with anything?

I take it you mean that the fact they had to skip some parts of the runtime for increased speed, proves something related to what I wrote. But (besides the JIT thing) PHP is not greenfield like Nim. They have a runtime, and it has to work in a certain way. PHP wasn't designed with transpiling in mind, and HipHop had to follow it closely as a design goal. I never said runtime decisions you have to mimic to be 100% compatible can't slow you down.

Re:Porting a NES Emulator from Go to Nim by mreiland on Saturday May 02, 2015 @08:56AM (#9476877)
http://en.wikipedia.org/wiki/HipHop_for_PHP

> HipHop for PHP (HPHPc) is a PHP transpiler created by Facebook. By using HPHPc as a source-to-source compiler, PHP code is translated into C++, compiled into a binary and run as an executable, as opposed to the PHP's usual execution path of PHP code being transformed into opcodes and interpreted.

Re:Porting a NES Emulator from Go to Nim by coldtea on Saturday May 02, 2015 @10:33AM (#9477198)
OK, I had in mind the JITed HipHop VM that they tout now (later development it seems).

Still, how does the original version of HipHop as a transpiling compiler invalidate what I said?

I said (check my original comment): unless you do it badly, transpiling to C gets you to run faster, because it lets you translate most operations to straightforward and fast C code.

And that's exactly the logic they followed and what they achieved: they transpiled PHP to C, as opposed from running it with PHPs runtime interpreter, in order to make it faster, and it worked.

That they skipped some parts of PHP runtime behavior/semantics, which if they didn't it would slow things down, doesn't clash with what I said. In fact it's already covered in my comment: "it let's you translate MOST" (not all) operations to fast C code.

Re:Porting a NES Emulator from Go to Nim by mreiland on Saturday May 02, 2015 @06:28PM (#9478812)
> transpiling to C gets you to run faster

You're changing the context.

> while being fast since it's compiled to C. - them

> being compiled to C doesn't imply fast :) - me

> Unless done badly, it does. - you

You've switched to "faster" because it's a more defensible position, but that isn't the idea that was originally being responded to. That's why jerf said the following, emphasis mine:

> No, it doesn't. You could easily compile Python into C (basically, "just" inline the core interpreter loop), __but it will still be slow__

Re:Porting a NES Emulator from Go to Nim by jerf on Sunday May 03, 2015 @09:48PM (#9483915)
You're really providing further evidence for my pet theory that anybody who seriously uses the word "transpiler" has no clue how compilers work, or what they can and can not do. (This is on the theory that anybody who does have that understanding also understands that "transpiler" is a etymological solution to a problem that didn't exist... the word "compiler" already covered the bases completely and totally... if you actually understand them.)
Re:Porting a NES Emulator from Go to Nim by Dewie3 on Friday May 01, 2015 @04:00PM (#9474117)
> while being fast since it's compiled to C.

Which is fast compared to what? Being compiled to JS?

It's not like being compiled to a "fast language" automatically makes that compiled program fast. You also have to consider how complex the runtime is, and other variables which are probably a direct result of the semantics of the language.