Pusher's engineering blog covers Go, Redis, networking, and MySQL, drawn from running a realtime messaging API service.
HN links it for Go posts, like the one on real-time garbage collection, used to argue GC pauses matter little next to network latency.
Oh, the range notation. It's a little convenience that can save a bit of typing here and there. Not a tremendously important feature, to be honest.
About multithreading, not sure what you mean but F# definitely has parallel collections in addition to its general async capability that lets you handle concurrency in a safe way. If you haven't already, check out the Hopac project (http://hopac.github.io/Hopac/Hopac.html , scroll down to the Description section).
About memory use, yes you create copies but at the same time immutability means you can have persistent data structures which share and thus save a lot of memory. Also, in general performance is good enough that you don't really have to worry about it, and when you do, you can always measure, profile, and see what's actually causing the memory pressure.
That said, it's true that functional programming languages have a different memory profile than imperative languages, and implementations which have been designed with this profile in mind perform really well. E.g. check out OCaml's performance in this GC pause benchmark: https://making.pusher.com/golangs-real-time-gc-in-theory-and-practice/
Pusher | pusher.com | Old Street, London | Full-time | On-site
Pusher makes realtime APIs that power applications around the world - From chat, trading, maps, games, and any other realtime apps you can think of.
On the server-side, you'll help us use Go, Kubernetes, Ruby, and Redis to handle millions of connections and send 300K messages every second. On the client-side, you'll help us build great developer experiences with SDKs for JavaScript, Swift, Kotlin, Unity, and many more platforms.
We're around 60 people - mostly engineers. See what it's like to work here at https://making.pusher.com/.
Open roles:
- Senior Backend Engineer (https://apply.workable.com/pusher/j/A60FD87F52/)
- Ruby on Rails Full Stack Engineer (https://apply.workable.com/pusher/j/A7950329A8/)
email: jack.broughton@pusher.com if you're interested to hear more
I would argue that at least for client-server apps Erlang is faster. Here is why: in most cases the perceived performance of a server is constrained by maximum (or 99%, whatever) latency, not by throughput. Moreover, you can scale throughput horizontally, while scaling for latency is more or less impossible. Haskell's GC can give you horrendous pauses (see [1][2]), ruining perceived performance. Erlang, on the other hand, is thoroughly optimized for minimal latency.
TL;DR: "fast" isn't well-defined, and for a lot (or even most) applications "fast" is about latency, not throughput, and Erlang is "faster" in that sense.
[1] https://making.pusher.com/latency-working-set-ghc-gc-pick-two/
[2] they eventually abandoned Haskell for Go https://making.pusher.com/golangs-real-time-gc-in-theory-and-practice/
Over the years I've collected various links on topics related to Haskell performance. I'll spare you the whole list, but here are a few that may be of some use.
Haskell Performance Patters - Johan Tibell (2012)
http://johantibell.com/files/haskell-performance-patterns.html#(1)
Performance (Haskell Wiki)
https://wiki.haskell.org/Performance
Detecting Space Leaks - Neil Mitchell (2015)
http://neilmitchell.blogspot.com/2015/09/detecting-space-leaks.html
The Haskell performance checklist - Chris Done, et. al. (2017 - 2019)
https://github.com/haskell-perf/checklist/blob/master/README.md
ThreadScope (Haskell Wiki)
https://wiki.haskell.org/ThreadScope
Top tips and tools for optimising Haskell - Will Sewell (2015)
https://making.pusher.com/top-tips-and-tools-for-optimising-haskell/
Pusher: https://making.pusher.com/
Disclosure: I work there and have written articles for the blog.
At the moment we mainly blog about our experiences with Golang (our language of choice right now). But really it's open to any topic someone in our engineering team is interested in writing about.
We aim to keep things visual, interactive and example-based. For example Jim Fisher created an interactive animation of Golang's GC algorithm here: https://making.pusher.com/golangs-real-time-gc-in-theory-and-practice/#how-does-a-concurrent-garbage-collector-work. We also managed to embed Golang's trace visualiser within one of the posts: https://making.pusher.com/go-tool-trace/#tour-of-the-go-tool-trace-interface (using some pretty dirty tricks).
One to two lines of iptables limits connection attempts, making a brute force attack take thousands of years. No logging, no monitoring, no extra software.
If you only use SSH keys, no brute force attack will work anyway.
https://www.systutorials.com/how-to-use-iptables-to-limit-rates-new-ssh-incoming-connections-from-each-ip-on-linux/ https://making.pusher.com/per-ip-rate-limiting-with-iptables/ https://stackoverflow.com/questions/18616246/iptables-limit-number-of-new-ssh-connections-per-minute https://blog.oshim.net/2009/06/iptables-to-rate-limit-incoming/ https://stackoverflow.com/questions/47775809/iptables-rate-limiting-connection-request#48194151 http://blog.serverbuddies.com/using-iptables-to-rate-limit-incoming-connections/