News for hackers. Stuff that matters.
Re:Iris: Fast back-end web framework for Go by oneloop on Tuesday June 21, 2016 @03:37AM (#11944086)
Could someone clarify: why is Go faster than say Python? And if the answer is just that it's a lower level language and therefore has less overhead, why not just use C?
Re:Iris: Fast back-end web framework for Go by weberc2 on Tuesday June 21, 2016 @01:14PM (#11947384)
Former C++ dev, current Python dev here.

Go is somewhere between Python and C. Go has a garbage collector, scheduler, and runtime type information (aka reflection, aka introspection). Like C, Go has "value types" whereas everything in Python (or even Java/C#) is a reference (this gives more control over memory layout, generaly less indirection, and generally less work for the garbage collector). In this sense, Go performs similarly to Java for serial tasks.

For parallel and concurrent tasks (e.g., web servers), things get more interesting. Efficient concurrency in C is hard, and efficient parallelism in Python is hard (async IO makes efficient concurrency easier, but it's not widely used as far as I can tell). Go's goroutines solve both of these problems by providing a lightweight threading mechanism that abstracts over both OS threads and async IO (I/O is always async in Go, but there are no callbacks, promises, or async/await). These lightweight threads (goroutines) can be dispatched and moved across thread boundaries, and there is no Global Interpreter Lock (unlike Python) so shared memory parallelism is easy.

Basically, Go is as easy as Python (even easier for nontrivial applications in my opinion), about 20-30 times faster than Python (or about half as fast as C or on par with Java/C#), and much much nicer for concurrent and parallel tasks than all of the above.

Re:Iris: Fast back-end web framework for Go by kasey_junk on Tuesday June 21, 2016 @07:43PM (#11950395)
Nitpick c# has value types
Re:Iris: Fast back-end web framework for Go by ngrilly on Wednesday June 22, 2016 @06:42AM (#11952730)
In C#, can you create an array of (x, y, z) tuples, where x, y and z are floats, and the whole array is store contiguously, without any indirection? Last time I checked C# documentation, it wasn't possible, but maybe I missed something.

Edit:

Ok, I definitely missed something ;-) I checked again C# documentation and kasey_junk is right. The tuple can be implemented as a struct, which is a value type (not a reference type), and arrays items are stored in contiguous memory. This is a big advantage of C# over Java (value types are planned for a future version of Java).

Re:Iris: Fast back-end web framework for Go by weberc2 on Wednesday June 22, 2016 @10:26AM (#11954187)
I know. Java and C# have primitives as well, which are also values and not references. I was speaking broadly. :)
Re:Iris: Fast back-end web framework for Go by andkenneth on Tuesday June 21, 2016 @05:36AM (#11944576)
Go has high level constructs like python, C# or Java. However, it compiles down to machine code directly, like C. This is much faster than C# or Java, which compile to an intermediate interface (CLR and java bytecode respectively, which then run in a VM), and miles ahead of Python, which interprets from the source every single time the program is run.

The closest language to go would probably be C++, and the language designers were quoted saying the main driving force behind go was to replace C++ due to it's complexity.

Re:Iris: Fast back-end web framework for Go by pcwalton on Tuesday June 21, 2016 @01:21PM (#11947461)
> This is much faster than C# or Java, which compile to an intermediate interface (CLR and java bytecode respectively, which then run in a VM)

No. Both C# and Java use JITs, and their JITs have been carefully tuned to focus on hot spots. By not having a JIT, Go (in the 6g/8g/gccgo implementations) loses some important optimizations that are very helpful for making virtual-heavy languages like Go faster. JITs enable on-stack replacement, bailouts, and self-modifying code, which enable speculative devirtualization and (polymorphic) inline caching, just to name two techniques. These are very important optimizations that generally you can only get reliably in an ahead-of-time setting with profile-guided optimization, which Go 6g/8g don't have (and PGO is kind of a worse version of what good JITs do anyway).

The true benefits of AOT are reduced startup time and a greater tolerance for slower compilation, allowing for more sophisticated compiler optimizations—instruction scheduling, alias analysis, range analysis, etc. But Go 6g/8g are focused on fast compilation and omit most of those optimizations anyway.

Re:Iris: Fast back-end web framework for Go by ngrilly on Wednesday June 22, 2016 @06:58AM (#11952781)
> By not having a JIT, Go loses some important optimizations that are very helpful for making virtual-heavy languages like Go faster.

How does Rust work in this regard? By avoiding virtualization, and compiling each function to many specialized variants corresponding to each possible permutation of input and output types?

Re:Iris: Fast back-end web framework for Go by eddyb on Wednesday June 22, 2016 @08:16AM (#11953249)
With generics, yes, like C++ templates: each combination of parameters results in one instance.

However, you can opt into using trait objects instead, which do use virtual calls.

Re:Iris: Fast back-end web framework for Go by ngrilly on Wednesday June 22, 2016 @04:46PM (#11956871)
Is pcwalton saying that a JIT compiler is more adequate for a "virtual-heavy" language like Go (to use devirtualization with inline caching and bailout), and an AOT compiler is more adequate for languages like Rust and C++ that mostly use code specialization?
Re:Iris: Fast back-end web framework for Go by kibwen on Thursday June 23, 2016 @12:53AM (#11958918)
It's not quite as clean-cut as that, though it is self-evident that optimizing at runtime (e.g. JIT) is the only recourse for optimizations that are otherwise reliant on runtime information (e.g. dynamic dispatch/virtual calls). Go does have an advantage over Java in that it prefers static semantics (pcwalton's assertion that Go is "virtual heavy" should likely be taken as relative to Rust/C++), so has less to benefit from devirtualization, and thus less of an argument to go the JIT route (which would take monumental engineering effort).

I believe pcwalton's points are that 1) running in a virtual machine does not imply that a language is slow (though I bet he'd agree with you that JIT introduces substantial memory overhead), and 2) Java, specifically, is not slow, thanks to a highly-tuned JIT.

Re:Iris: Fast back-end web framework for Go by ngrilly on Thursday June 23, 2016 @03:07AM (#11959346)
Thanks! That's exactly what I wanted to know.
Re:Iris: Fast back-end web framework for Go by ngrilly on Wednesday June 22, 2016 @06:48AM (#11952747)
You forgot to mention a significant another drawback of most JIT implementations, compared to AOT: the bigger memory footprint.
Re:Iris: Fast back-end web framework for Go by fulafel on Tuesday June 21, 2016 @09:46AM (#11945525)
Compiling Python down to machine code and eliminating the VM interpreter loop does not speed it up dramatically (iirc ~30%), it has been tried. It's largely because Python is a dynamically typed language with a lot of runtime dispatch, and Go is a statically typed language with less runtime dispatch.
Re:Iris: Fast back-end web framework for Go by pjmlp on Tuesday June 21, 2016 @08:05AM (#11945055)
> This is much faster than C# or Java, which compile to an intermediate interface (CLR and java bytecode respectively, which then run in a VM).

Except there are things like ExcelsiorJET, CodenameONE, J9, .NET Native, CoreRT, Mono -AOT, IL2CPP.

As usual, language and implementation aren't the same thing.

Re:Iris: Fast back-end web framework for Go by insertnickname on Tuesday June 21, 2016 @05:42AM (#11944601)
IIRC, Go code compiled with the gc compiler has about the same performance as Java running on the JVM. Surely Go isn't much faster than Java.
Re:Iris: Fast back-end web framework for Go by ptman on Tuesday June 21, 2016 @05:58AM (#11944655)
You are mostly correctly. There are some things that Go can do to perform better than Java. Go arrays have one less step of indirection compared to Java arrays. And Go allows for more control about the memory layout of structs/classes and arrays.
Re:Iris: Fast back-end web framework for Go by kasey_junk on Tuesday June 21, 2016 @07:53AM (#11945015)
But it also doesn't perform as well with large data sets and has less compiler optimizations and no JIT.

Saying Go is much faster than Java is nonsense.

Re:Iris: Fast back-end web framework for Go by thwd on Tuesday June 21, 2016 @12:39PM (#11947039)
The speed at which a big data set is processed has nothing to do with the language or its' compiler. It's the way in which the data set is streamed through memory by a particular program. Go offers two standardized interfaces for this, `io.Reader` and `io.Writer`. Also, if the data set can be batched, it's trivial to parallelize processing in Go, while it's a big hurdle in Java.

A JIT is not a performance feature per-se, either. It can be used for runtime code-optimization and -specialization which can improve performance. Some JVM implementations try and do this as well as they can automatically. The stuff they optimize, though, is exactly the kind of indirection that doesn't exist in Go in the first place.

The optimizations `javac` does are one of the few things that allows Java code to run at a competitive speed. And they're mostly trading space for performance, hence the unusually large memory footprint of Java applications.

Re:Iris: Fast back-end web framework for Go by kasey_junk on Tuesday June 21, 2016 @01:21PM (#11947459)
The big data set stuff I generalized around has more to do with the runtimes involved. Most JVM gc systems for instance are moving collectors while the golang one isn't (or wasn't last I looked). This can cause slow downs in comparison to a comparable GC environment especially around large data sets in long running environments.

"And Go allows for more control about the memory layout of structs/classes and arrays." Is an absolutely true statement, and it means that for some classes of problems (namely systems that prioritize GC latency for throughput) golang might be faster. The opposite is also true, especially with regard to large interdependent data sets, the golang runtime handles those worse than most JVMs.

I'd also completely disagree with your statement "Also, if the data set can be batched, it's trivial to parallelize processing in Go, while it's a big hurdle in Java." Especially with regard to "fast". There are more & better high performance concurrency libraries in Java than there are in go.

All that said, I was really reacting to this line "This is much faster than C# or Java, which compile to an intermediate interface" which is utter nonsense.

In the end, talking about performance in such large grained ways is usually not valuable but I'm willing to say that golang performs in the same category of performance as most jvms and that calling go faster than java is nonsense unless you speak about very specific cases.

Re:Iris: Fast back-end web framework for Go by cakoose on Tuesday June 21, 2016 @06:29AM (#11944739)
There are two things here -- how fast can a language be in theory vs how fast a particular implementation is.

Interpreters are typically slower (though simple to write and portable). The standard Python/Ruby/PHP implementations are interpreters. (The Python interpreter doesn't interpret from source every time, though; it usually uses the bytecode from previous runs.)

Implementations that generate machine code are more complicated and less portable, but have the potential to be faster. However, while compiling "down to machine code directly" can help startup time, it has little to do with what allows a language to be fast. What matters is whether it's possible to generate efficient machine code.

Static typing, for example, allows a compiler (ahead-of-time or JIT/VM) to generate more efficient machine code [1]. The ability to monkey-patch code -- which is common in many dynamic languages -- makes things harder for a compiler.

That said, there are compilation techniques to make dynamic languages pretty fast -- much faster than the standard Python/Ruby/PHP interpreters. For example, Javascript VMs have gotten 10x (or more?) faster over the last 5 years. (One of the big ideas: <https://en.wikipedia.org/wiki/Inline_caching>.)

A great example of all this is Facebook's PHP compiler. The first version would compile to machine code ahead-of-time, but it wasn't that much faster than the standard PHP interpreter (and definitely slower than the Firefox/Chrome Javascript VMs). They eventually switched to a JIT compiler, which is a better strategy for a dynamic language. Later, they transitioned to statically-typed sorta-PHP-compatible language called Hack, which allows for even more efficient machine code.

[1] There are different levels of static typing, too. For example, Go is statically typed but doesn't have generics. A C# generic data structure can be converted to more efficient code than a Go "interface{}"-based data structure.

Re:Iris: Fast back-end web framework for Go by weberc2 on Tuesday June 21, 2016 @01:18PM (#11947424)
> The ability to monkey-patch code

"The liability to monkey-patch" in my opinion. :p

Re:Iris: Fast back-end web framework for Go by TheHydroImpulse on Tuesday June 21, 2016 @08:41AM (#11945202)
The early version of hiphop (Facebooks php compiler) would compile PHP into C++. It was really interesting how they went from C++ to now a full featured JIT.
Re:Iris: Fast back-end web framework for Go by cakoose on Wednesday June 22, 2016 @08:58PM (#11958206)
Right. But just to be clear, C++ was an implementation detail. You could treat the entire toolchain as a black box that read in PHP code and produced a single executable binary.
Re:Iris: Fast back-end web framework for Go by insertnickname on Tuesday June 21, 2016 @03:51AM (#11944152)
Go actually lets you work at a quite high level, much like C# or Java (and the performance is in the same ballpark). I think a better question to ask is: why is Python so slow?
Re:Iris: Fast back-end web framework for Go by andybak on Tuesday June 21, 2016 @05:14AM (#11944514)
Alex Gaynor had an interesting take on this - https://speakerdeck.com/alex/why-python-ruby-and-javascript-...

From what I remember - even leaving aside core language speed - the idioms of certain languages lead people to write slow data structures and algorithms. You can write (much) faster Python but it might start to look un-Pythonic.

But of course there is the counter-argument - if your web framework is your bottleneck then you're doing something weird. Personally I don't work on high-traffic sites and I'll choose expressivity over speed any day.

Re:Iris: Fast back-end web framework for Go by insertnickname on Tuesday June 21, 2016 @05:39AM (#11944589)
There are tons of blog posts about companies that have switched from Ruby or Python to Go and have been able to massively scale down their amount of servers while handling the same load. Here's one example: https://www.iron.io/how-we-went-from-30-servers-to-2-go/

I don't think it's weird that the web server could be a bottleneck in a web application (even if it is a database-driven app, as most are).

Of course, if you're making an internal CRUD app that two people are going to use, it's unlikely to matter which stack you use.

Re:Iris: Fast back-end web framework for Go by andybak on Tuesday June 21, 2016 @10:22AM (#11945788)
I suppose 'weird' wasn't the right word but the vast majority of web development probably isn't constrained by the performance of the language.

> if you're making an internal CRUD app that two people are going to use

I know you're exaggerating for comic effect but still. You can run sites that have millions of visits a day on a $20/month VPS and still not have to worry about performance - unless you're doing something completely resistant to caching. I don't personally know anyone that has to handle more traffic than that but if you believed the general chatter on HN then that segment of the market doesn't even exist. Going from 30 servers to 2? I might be able to cut my overall hosting bill by a few hundred dollars a year but it's not top of my list of concerns.

Re:Iris: Fast back-end web framework for Go by nemothekid on Tuesday June 21, 2016 @12:50PM (#11947128)
>There are tons of blog posts about companies that have switched from Ruby or Python to Go and have been able to massively scale down their amount of servers while handling the same load. Here's one example

FWIW, these cases don't come down to raw rq/s performance, but are more due to RAM usage.

Re:Iris: Fast back-end web framework for Go by insertnickname on Tuesday June 21, 2016 @04:49PM (#11949292)
In the iron.io blog post, they write that their CPU load was drastically reduced as well.
Re:Iris: Fast back-end web framework for Go by greut on Tuesday June 21, 2016 @06:29AM (#11944738)
To make Python fast in that regard, you'll have to rely on C-based libraries (C as in Cython) like httptools or libuv. http://magic.io/blog/uvloop-blazing-fast-python-networking/
Re:Iris: Fast back-end web framework for Go by oneloop on Tuesday June 21, 2016 @07:53AM (#11945014)
Ok, so why is Python so slow (comparatively)? I had understood that must of the speed-critical tasks in python were done by wrappers of lower-level C code. Example: numpy. Is this not correct?
Re:Iris: Fast back-end web framework for Go by insertnickname on Tuesday June 21, 2016 @09:15AM (#11945341)
You can indeed do that, and there are other ways to speed up Python (PyPy, Cython, or even just writing more efficient Python code). However, the problem is that you now have to write C.

A lot of the slowness in Python probably comes from the many memory allocations all over the place. Go gives you a lot of control over allocations even though it is a garbage collected language.

These slides posted by another commenter has some good points about why Python is so slow: https://speakerdeck.com/alex/why-python-ruby-and-javascript-...

Interestingly, there was actually a talk at PyCon US 2016 about using Go's http server in Python via C. https://www.youtube.com/watch?v=CkDwb5koRTc

Re:Iris: Fast back-end web framework for Go by TheHydroImpulse on Tuesday June 21, 2016 @08:53AM (#11945248)
The reason it's slow is because python interprets it's input. It essentially introduces major indirection for instructions to be executed.

So for '1 + 1', you can't just output some fast x86 instruction and inline it. You'll usually need to jump to where the python vm will do 'a + b' in C. You're having to do a bunch of redundant work at a higher level to emulate the CPU (sorta).

That's why you have JIT compilers that will read '1 + 1' and compile the appropriate machine code, store that in an executable memory region and jump to it. First time might be slow, but after that it's pretty fast. Because you need to jump to the dynamically generated code, you usually compile whole functions at a time.

This topic is super complicated but also super interested but I tried to simplify it a bit here.

Re:Iris: Fast back-end web framework for Go by SEJeff on Tuesday June 21, 2016 @10:07AM (#11945674)
FWIW: There is a new set of async / await bits in CPython 3.5 that are allowing some really interesting new performance profiles.

http://magic.io/blog/uvloop-blazing-fast-python-networking/

This is almost exactly on par with golang's net/http for a simple echo server, yet it is written in python.

Re:Iris: Fast back-end web framework for Go by scandinavian on Tuesday June 21, 2016 @05:23AM (#11944535)
Python is not slow, cPython is slow. PyPy is pretty fast.
Re:Iris: Fast back-end web framework for Go by jerf on Tuesday June 21, 2016 @09:59AM (#11945619)
PyPy is pretty fast... for a Python runtime. It's not "fast" without qualifiers. The only 1990s-style dynamic language runtime that's fast-without-qualifiers is LuaJIT.
Re:Iris: Fast back-end web framework for Go by rudedogg on Tuesday June 21, 2016 @05:44AM (#11944606)
From my understanding, the main reasons are that python is interpreted and has the global interpreter lock: https://wiki.python.org/moin/GlobalInterpreterLock.
Re:Iris: Fast back-end web framework for Go by lmm on Tuesday June 21, 2016 @06:25AM (#11944731)
The GIL makes Python faster than a Python without it would be.
Re:Iris: Fast back-end web framework for Go by andkenneth on Tuesday June 21, 2016 @07:54AM (#11945018)
yeah, the GIL only slows down threaded code. The big reason that the GIL hasn't been removed is that any patch removing the GIL slows single threaded performance.
Re:Iris: Fast back-end web framework for Go by weberc2 on Tuesday June 21, 2016 @01:23PM (#11947476)
The GIL massively slows down threaded code. To the point where (almost?) all multithreaded cases are actually slower than single threaded cases. :(
Re:Iris: Fast back-end web framework for Go by shadowmint on Tuesday June 21, 2016 @06:54AM (#11944831)
C is hard.

You're right though, why not use C? It's a good language, and it's hard to beat for it's low level powers, portability and speed.

What go gives you is high level productivity, testing, a solution for package management (abit a rubbish one), and a good ecosystem of 3rd party libraries for things like AWS.

The things that suck about C:

- It's hard to do right. There's a great book called 'Deep C Secrets' on this topic by Peter van der Linden. If you haven't read it, I recommend against writing a large project in C until you have.

- C has no package management solution at all. Go doesn't have a great one, but at least it has some kind of high level management for this. Working with C dependencies and the C various build tools for them is a nightmare.

- C has no memory safety, which means if you do screw up, the 'things that can do wrong' are much much worse than if you screw up in a relatively safe language like python or java.

- C (and even 'modern C++') suffer from major portability problems. Not that it's not portable; it is, but in order to be portable, you have to write weird, arcane and terrible code. It's entirely common to see code littered with `#ifdef WIN32 ...` or a typedef for every primitive type (eg. mInt32) to abstract across compiler differences etc. This means any code coverage you get is probably going to poorly represent the actual code in the library. Oh, did I mention C has no test runner? (although to be fair, CMake helps).

On the other hand, it is extremely embedable, and if you know what you're doing, it is the right choice. Have a look at this excellent highly portable IPC library: https://github.com/saprykin/plibsys <-- That's the right choice for the right job.

It's also the right choice, arguably, for a low level component that might import into some other slow-as-balls language like python. I'd argue Rust is a better choice, but hey, its much of a muchness.

...but for a web service or web framework?

nah.

Go was written specifically for those purposes, with high throughput performance as its goal, and a significant amount of effort devoted to optimizing that.

It's not suitable for something like plibsys either.

Re:Iris: Fast back-end web framework for Go by znpy on Tuesday June 21, 2016 @08:23AM (#11945136)
Besides, keep in mind that the C language has some "weird corners" and in some considtions, you might encounter an "unspecified behaviour" scenario.

For short, there are some cases in which the C language specification does not tell you what to do and how to interprete code and in this cases, the choice is left to the compiler.

This is not trivial as it might look.

For example, what happens when you omit the return statement at the end of a function? GCC will to automatically insert a return statement for you, but Clang will not. Both are perfectly fine behaviours... As long as you are aware of it.

If you always compiled your code with GCC and suddenly switch to clang you might see weird shit, because the processor reached the end of your function, found no return instruction, and just went ahead and executed whatever code was put after your function (and it might not be so obvious what code is there).

(But in a way, this is part of the beauty of the C language: there is very little abstraction, and it is easy to understand what will happen when you run C code.)

Re:Iris: Fast back-end web framework for Go by gummiruessel on Tuesday June 21, 2016 @08:05AM (#11945056)
>Have a look at this excellent highly portable IPC library: https://github.com/saprykin/plibsys <-- That's the right choice for the right job.

>[...]

>...but for a web service or web framework?

>nah.

>Go was written specifically for those purposes, with high throughput performance as its goal, and a significant amount of effort devoted to optimizing that.

>It's not suitable for something like plibsys either.

I found this part of your comment difficult to understand. Is C not suitable for plibsys after all, or is it Go which wouldn't be suitable, or something else?

Re:Iris: Fast back-end web framework for Go by shadowmint on Tuesday June 21, 2016 @11:20AM (#11946285)
Sorry, I was referring to go at the end there.

The point I was making is:

Don't pick go. Or C. Or Rust. ...unless it's the right tool for the job. Or at least the right sort of tool; there's plenty of cross over.

In this case (web framework), C isn't the right tool for the job. ...but, to be fair, C is the right tool for some jobs.

Re:Iris: Fast back-end web framework for Go by Shorel on Tuesday June 21, 2016 @07:50PM (#11950438)
> C has no package management solution at all.

Curiously, I just found this today:

https://conan.io/

It seems to be a full featured package manager to use with C and C++.

Re:Iris: Fast back-end web framework for Go by oneloop on Tuesday June 21, 2016 @07:58AM (#11945029)
Thanks for this answer. After reading it it seems to me that every other answer is just saying "C is hard" with a lot of words.
Re:Iris: Fast back-end web framework for Go by vegabook on Tuesday June 21, 2016 @07:58AM (#11945028)
I have to write a whole bunch of

  if Sys.info()["sysname"] == "Windows"
even in R!