snearch + erlang   353

Is Perl6 faster than Perl 5 on average? : perl6
https://tutorial.ponylang.org/ The only VM besides parrot with concurrency safety and not using copy-all. Erlang has a slow VM and passes everything as copy and is still fast (a IO bottleneck cost you min. 50x), but sharing makes the difference. And it's the fastest language around, faster than C++ with OpenMP. And proper syntax and types. Go is nice but limited, Rust is lying all over to its users such as perl5+6. Hype-driven development, such as perl6.

...

[–]reini_urban 2 points 2 days ago
Rust allows memory unsafety: https://doc.rust-lang.org/1.14.0/book/unsafe.html which normal languages only need for their FFI. Here it's a keyword and used all over their stdlib.

Rust is concurrency unsafe. It does not protect from deadlocks and race conditions, but calls it "Fearless Concurrency" https://doc.rust-lang.org/book/second-edition/ch16-00-concurrency.html Instead you need to fear it, and work around with manual mutex and semaphores. Concurrency safety means the compilers does this for you, or the compiler avoids locks at all. Like parrot or pony do. Or fall back to copy-only, no shared data. Which is the desperate slow path Erlang and Go went. There refs are either read-only or copied.

permalinkembedsaveparentreportgive goldreply

----

[–]reini_urban 0 points 9 hours ago
Or perhaps you accept the answer -- and accept that MoarVM could one day approach the JVM's abilities for some workloads -- but think C++ is not remotely the same deal as C.

Nobody in his sane mind will accept that.

This has nothing to do with cperl or perl5. These are dinosaurs and the slowest of all big dynamic languages. Only moar is slower, but that is not considered big.

It has to with analyzing the three fastest dynamic languages around: v8/javascript, and the two lua's with a jit: luajit (= tvmjit) and potion (= p2), which was based on a pre-luajit lua with classes and mop (for ruby). you can also look at guile btw. which would be an excellent backend, much better than moar. tvmjit is based on the very fastest dynamic language design, and got a very good nqp level compared to moar. 50x better and faster. 10x smaller. You could also at pypy/rpython or graal to the mix, but these are already the monsters like v8 or perl6. These can only be improved by a huge compiler expert group, and will never reach the luajit, potion or JVM levels, just by trashing the caches with their dynamic bloat.

If you look at these you'll see that moar will never ever reach any of these capabilities. And with the latest jit plans it became even worse. Startup time is at the JVM level, even worse. Remember perl6 is to be used mostly for smallish scripts, not huge programs and servers. Run-time is at the 100x slower level, not even the 10x slower level, where php,ruby,python,perl5 are. That's trivial to observe by looking at all the bloat carried around at runtime, and what it is compiled to. And the architectural design, as I said before. You can demand a native stdlib, as pypy or common lisp does, when you got a fast VM and compiler, but not with something like perl6/nqp/moar.

There are certain level's you can agree to reach and certain levels which are just out of reach. JVM or luajit/potion are totally out. Even perl5 seems to be out of reach. The typical Moose benchmark comparison is totally bogus, there's nothing worse designed than Moose. (Well, Distzilla would have to carry that bag, but we are talking about OO). You can compare it to the realistic and recommended OO systems in perl5, which are cperl and Mouse, and there perl6 looses badly. Given that perl5 has a horrible VM design, with its broken ABI and stack design, that's quite a feature.
choice_of  Programming_Language  Pony  Erlang  Perl  Perl6  Rust  CONs  Lus  LusJIT  Potion  VM  Parrot  Moar  Insightful  higher_quality  Urban_Reini  cperl  cro  framework  criticism 
june 2018 by snearch
Why I’m Learning Perl 6 – Evan Miller
For the curious: Go switches contexts on I/O, message passes, and function calls. The Erlang VM switches contexts on I/O, message passes, and every 4,000 VM instructions. MoarVM switches contexts on calls to await, which can include message passes and asynchronous I/O promises. Nginx and Node.js never switch context, which is why all the callbacks are necessary.
higher_quality  Perl6  MoarVM  context_switch  Multithreading  Golang  Erlang 
september 2017 by snearch
Managing two million web servers
We do not have ONE web-server handling 2 millions sessions. We have 2 million webservers handling one session each.
...
The reason people think we have one webserver handling a couple of million users is because this is the way it works in a sequential web server. A server like Apache is actually a single webserver that handles a few million connections.

In Erlang we create very lightweight processes, one per connection and within that process spin up a web server. So we might end up with a few million web-servers with one user each.

If we can accept say 20K requests/second - this is equivalent to saying we can create 20K webservers/second.

On the surface things look very similar. But there is a fundamental difference between having one webserver handling two million connections, and two million web servers handling one connection each.

If there is a software error and the server software crashes we lose either two million connections or one depending upon the model.

In Erlang if the web server software itself is incorrect we’ll lose a single connection, which is OK. Since the software is incorrect and crashes we don’t know what to do so crashing is a good alternative. What is important is that one session crashing does not effect all the other sessions.

This requirement, goes way back to when we designed Erlang in the mid 1980’s. In Telecoms systems, losing one connection due to a software error was acceptable, losing them all due to a bug was big time bad news.
Armstrong_Joe  Webdevelopment  Erlang  Elixir  Multithreading  Webserver  fehlertolerant 
march 2016 by snearch
How to build stable systems — Medium
You build your system as a 12 factor app.

Your system is a flat set of modules with loose coupling. Each module have one responsibility and manages that for the rest of the software. Modules communicate loosely via a protocol, which means any party in a communication can be changed, as long as they still speak the protocol in the same way. Design protocols for future extension. Design each module for independence. Design each module so it could be ripped out and placed in another system and still work.
Avoid deep dependency hierarchies. They breed tight coupling. Avoid monster-modules and break them apart. Avoid the mess of microscopic modules as well. Always remember the power of copying a function and thus breaking a dependency. Fewer dependencies can some times be a win.
...
Picking a programming language

To get a robust system, you have to pick Erlang somewhere inside the system. No other language supports the robustness principles needed for stable operation.

If you don’t pick Erlang, you will have to reimplement the ideas of Erlang in your Weapon-of-Choice™.
...
A language can only succeed if you have a way to automatically deploy it with ease. The deployment tooling must be in place before use.
Professional_Software_Development  architecture_software  Ergonomie  Arbeitstechniken  modularisation  TOP  Inspiration  Erlang  PROs  deployment  higher_quality  y2018  m05  d26 
february 2016 by snearch
Erlang and distributed systems expert, gives his views on BEAM languages, Hindley–Milner… — This is not a Monad tutorial — Medium
I haven’t seen any new languages pop up recently that have grabbed my interest. On technologies, I think that microkernels are very, very interesting. Things like OSv for the JVM based languages, Mirage for OCaml and BSD Rump Kernels for the rest. I think those are going to become the fundamental building block of system orchestration in the very near future. The other thing to keep an eye on is the Nix Package manager, NixOS, and technologies like Atlas from Hashicorp. It’s not going to be too much longer before we declaratively describe out systems as well as our code. I am looking forward to that.
Prognose  Profession  Professional_Software_Development  Trend  Zukunftsmärkte  Microkernel  OSv  JVM  Mirage  OCaml  BSD  BSD_Rump_Kernel  system_orchestration  declarative  NixOS  Nix_Package_Manager  technology  Merritt  Erlang 
august 2015 by snearch
Why Go? Use Racket | Hacker News
lomnakkus 1 hour ago

> Or Clojure or Erlang. Funny enough out of "functional" languages those have probably just as much (or even more) been used to develop distributed, fault tolerant systems than F# or Haskell. Just saying.

(I generally agree with the gist of your comment, I think. This just stuck out.)

I don't believe Clojure belongs in that class (as "proven" for writing reliable software), but whatever.

If you want truly reliable software and have the budget, then you just need to throw process at the problem -- it doesn't matter much which language you use. Several (if not all) the Mars landers were programmed in C -- with very few critical flaws experienced/discovered[2]. The Ericsson switches that achieved previously-unheard-of reliability were programmed in Erlang, but they used process and a huge number of engineers to achieve that. (Plus they're mostly stateless and so can just reset if they do it fast enough and don't lose important state when doing so.)

For large-scale software which has to evolve fast, I belive strong type systems do win out. It's not so much that they prevent bugs which could be caught by test suites, but having a strong type system means that you can be certain that there are a lot of tests that you actually will never have to write or, more importantly, rewrite as the system evolves.

There have been actual studies which may be of interest[1], but even if I'm on the "winning" side, I don't think I would put too much stock in the methodology/analysis of this particular study. (E.g. concluding that JavaScript suffers from few concurrency bugs relative to other languages is kind of being oblivious of the fact that JS is single-threaded (semantically) and that all the other languages in the comparison permit "real" concurrency/parallellism, and that it should thus perhaps be excluded from the category or at least treated separately.)

[1] http://macbeth.cs.ucdavis.edu/lang_study.pdf

[2] https://www.usenix.org/conference/hotdep12/workshop-program/...

(Sorry, references out of order because edited-post-facto)

reply
reliable  software  Erlang  C  process  Professional_Software_Development 
march 2015 by snearch
The eleventh year: what to do after having taught yourself programming in ten years — Medium
I was bored. Thankfully, working with Erlang for a year and a half introduced me to the amazing world of functional programming, distributed systems, parallalelism and concurrency, and there is no way of going back. Erlang also led me to the Haskell and Lisp/Clojure world. I found Haskell, with its awesome Parsec parser combinator library, at the bottom of the rabbit hole of compilers and programming language design. Finally, Lisp was the selling point that made me migrate from vim to emacs.
fun_in_programming  Lernherausforderung  Haskell  Erlang  LISP  COMMON_LISP  Emacs  Profession  distributed_systems  book_recommendation 
january 2015 by snearch
You Have Ruined JavaScript : programming
Now - I still do JS, but I'm mostly working in Erlang these days, building video streaming/encoding systems and blah blah blah, that's why I'm not really blogging at the moment but basically my backend is pretty sexy and my frontend is pretty sexy too (Facebook's React + NPM to fill the gaps). I came across this post on Stackoverflow that brought back all the flashbacks of those enterprise days and to my horror it has spread like a java-borne venereal disease to the front-end of the body of my internets.
Webdevelopment  Javascript  client_side  ReactJS  server_side  Erlang 
april 2014 by snearch
Elixir v0.13.0 released, hex.pm and ElixirConf announced | Hacker News
phamilton 7 hours ago | link

You are missing a much bigger piece. Protocols.

I can implement any data structure, and if I define reduce for that data structure I get the entire Enum module for free, all tail call optimized.

It means I can mix and match data structures. I can do crazy things like zip a binary search tree and a lazy data stream together and then call take(5) to get the first 5 elements. And all that is required is reduce to be defined for all data structures. Protocols are a big deal.

reply
Erlang  Elixir  Macros  protocol 
april 2014 by snearch
Rob Harrop | LinkedIn
Zusammenfassung von Rob Harrop

Co-founder of SpringSource, the software company behind the wildly-successful Spring Framework.

Specialist in high-volume, high-scale enterprise systems.

Prior to SpringSource, co-founder and CTO at Cake Solutions, a boutique consultancy in Manchester, UK.

Author and co-author of five books, including the highly-popular Spring Framework reference "Pro Spring".
Spezialgebiete

Java, Erlang, Oracle DB, OSGi, Spring, Tomcat, Java EE, Functional Programming
model  Harrop_Rob  Haskell  Freiberuflichkeit  Entrepreneurs/Freelancer  Consultant  Java  Erlang  Oracle  OSGi  Spring  Tomcat  Java_EE  functional  programming 
september 2013 by snearch
Erlang at Basho, Five Years Later | Hacker News
xaritas 2 hours ago | link

I found Erlang to be much easier to digest the second time through. The first time I looked at Erlang, I knew of its benefits, but didn't have much experience with functional programming. The unusual syntax and unfamiliar paradigm led me to put it aside.

Later, after I learned me some foldr and flatMaps (mostly thanks to Martin Odersky's Scala/FP course on Coursera), I revisited the language when I saw an article here about an Erlang based CMS (http://zotonic.com/). It seemed pretty cool, I host some websites for local businesses, so I set up it to evaluate it and realized that I now had no trouble at all with Erlang and the syntax made more sense. Searching around for some other web stuff I found Chicago Boss (http://chicagoboss.org/), a Rails-inspired web framework with ridiculously easy Comet/WebSocket/"real time" support.

Now I'm really excited about it and I can't wait to do some cool things with it.
Erlang  Webdevelopment  PROs  Framework  ChicagoBoss  Zotonic  websockets  Comet  functional  programming 
july 2013 by snearch
A Beginners Guide to Erlang | Hacker News
SingAlong 18 minutes ago | link

I'm currently reading "Programming Erlang" by Joe Amstrong and I'm loving it.

Buy the second edition beta ebook here - http://pragprog.com/book/jaerlang2/programming-erlang. The new edition highlights features that are in the yet-to-be-released versions of Erlang. Also has content on how to use tools like rebar.

There's also Chicago Boss, which is a cool web framework. If you are coming from Rails, you'll feel right at home. https://github.com/evanmiller/ChicagoBoss/

The IRC channels: #erlang, #chicagoboss #ninenines (for Cowboy, Ranch, etc) on Freenode.

reply
Erlang  Armstrong_Joe  Programming_in_Erlang_2nd_Ed.  Lernherausforderung  book_recommendation 
may 2013 by snearch
Chicago Boss: The Official API Reference
. As of version 0.8.0, Chicago Boss provides infrastructure for defining one or more WebSocket controllers. Note that WebSockets are only supported with Cowboy, so put {server, cowboy} in your boss.config before attempting anything on this page.
Webdevelopment  Erlang  Chicago_Boss  Framework  websockets  html5  Cowboy 
may 2013 by snearch
iskra/jsonx
JSONX is an Erlang library for efficient JSON decoding and encoding, implemented in Erlang NIFs. Works with binaries as strings, arrays as lists and only knows how to decode UTF-8 (and ASCII).
Erlang  JSON  libraries_programmers_tools 
april 2013 by snearch
Concurrency Models: Go vs Erlang
Update: Since I wrote this article, I’ve had a lot of talks with some very knowledgeable Erlang programmers. My experience with Erlang is pretty minimal, and the opinions I’ve expressed were more from my experience creating my first Erlang programs, not the experience of 10 years working with idiomatic Erlang. That said, I should clear up a few things. There are a couple main other differences between the languages’ concurrency models:

Erlang’s concurrency model uses “processes” and does not share memory, which Go’s goroutines do.
Erlang’s scheduler is preemptive, which is a goal of Go’s but not the current state.

As for Erlang’s exception model, it is safer than Go’s because of OTP. The model is still more formal than Go’s, but OTP has made it safer because of monitor/restart semantics. From talking with some more knowlegeable Erlang people, its clear to me that error/exit/throw and try/catch syntax is rarely used, and the more appropriate “error as a value” is used idiomatically. This is the same as is forced in Go (since Go has no throw except for panic, but don’t use that). Thus perhaps the two models are not as dissimilar as I first suggested. The informality of the model in Go is still attractive, but the safety guarantees are better in Erlang.
Erlang  error_handling  Golang 
march 2013 by snearch
David Nolen on Logic and Constraint Programming, Core.logic, Mozart/Oz
But even with functional programming, what you encounter is that there’s often a lot of “how” involved. There’s a really great talk from Guy Steele where the subtitle is “Why foldl and foldr are considered harmful” and his point is that functional programming, because it comes from recursion theory and has strong foundations in logic and induction, that we sort of have encoded in our functional programs this notion of sequence and that actually is really bad when you want to build a truly concurrent application, you really don’t want to be too specific about the direction, but that’s where “how” is creeping into our functional programs and so part of my talk is that I think the logic programming community, because they are actually a little bit further down the declarative path, that they tend to write code that is more susceptible to concurrency optimizations and I don’t think it’s a coincidence that Erlang started in Prolog. There is something about a purely declarative Prolog program where you look at it and it's like time doesn’t even seem involved in the code, it seems like “Oh, we could start anywhere and it’s still going to work out” and I think that’s really powerful and part of my talk is getting functional programmers to look at this stuff, because I think with functional programming we’ve found an excellent “how” language and I think we can actually use functional programming as a foundation for something higher-level, we can actually use functional programming to implement logic programming ideas.

You are not telling us to use Prolog or switch to Prolog, you are saying we can build Prolog into a language? I’m sort of trying to hint at your library.
Yes and not just Prolog, I think the area of logic programming is quite wide, I’ve been working on a library which tries to embed some of the semantics of Prolog, but the library is called core.logic for Clojure, it’s about two years old now, a year ago I would have said ”Yes, it’s just Prolog” but it’s now becoming a general constraint logic programming framework. There’s a language called “Mozart/Oz” which is really fantastic. There’s an amazing book called “Concept techniques and models of computer programming” which a lot of people say it’s like the book you should read after “The structure and interpretation of computer programs” and I totally agree. For me it’s been very eye opening constraint logic programming, the types of problems you can solve with this much higher level tool and it’s much more descriptive. So my talk sort of explores how you can actually play with these ideas in a functional programming context, you can actually take logic programming and constraints and you could just mix it up with functional programming and I think it’s pretty cool.
Logic_Programming  Clojure  Prolog  Haskell  Erlang  Mozart/Oz  Nolan_David  libraries_programmers_tools  core.logic  book_recommendation  functional  programming  higher_quality 
march 2013 by snearch
DynamoDB One Year Later: Bigger, Better, and 85% Cheaper… - All Things Distributed
From our own experience designing and operating a highly available, highly scalable ecommerce platform, we have come to realize that relational databases should only be used when an application really needs the complex query, table join and transaction capabilities of a full-blown relational database. In all other cases, when such relational features are not needed, a NoSQL database service like DynamoDB offers a simpler, more available, more scalable and ultimately a lower cost solution.
Vogels_Werner  amazon  DynamoDB  Erlang  NoSQL  vs.  SQL  PROs  CONs  scaling_website 
march 2013 by snearch
Erlang/OTP verbessert Geschwindigkeit | heise Developer
Erlang/OTP verbessert Geschwindigkeit

Pünktlich zum angekündigten Termin konnten die Entwickler von Erlang die Beta-Phase der R16-Reihe abschließen und ihr Major-Release Erlang/OTP R16B freigeben. Die neue Version der Programmiersprache, die in Kombination mit einem eigenen Laufzeitsystem und Bibliotheken als Erlang/OTP bekannt ist, umfasst unter anderem nicht-blockierendes Laden von Code. In älteren Releases wurden laufende Prozesse auf der Virtual Machine während des Ladens neuer Erlang-Module gestoppt, R16B ermöglicht hingegen das parallele Ausführen.

Darüber hinaus haben die Entwickler interne Prozesstabellen eingeführt, die gleichzeitiges Lesen und Schreiben erlauben, und das dynamische Allokieren von Port-Strukturen ergänzt. Eine verbesserte Implementierung der internen Port-Tabelle und ein neues Scheduling sollen darüber hinaus zum reibungslosen Ablauf von Prozessen beitragen.

Was das Schreiben von Code angeht, steht es Entwickler dank UTF-8-Unterstützung nun frei, auf diese Weise kodierte Zeichen in ihrem Quelltext zu verwenden. Eventuelle Kompatibilitätsprobleme zu Vorgängerversionen von Erlang lassen sich der Readme-Datei des aktuellen Release entnehmen.

Erlang/OTP steht unter einer abgewandelten Mozilla Public License, der Erlang Public License, und lässt sich von der Website der Sprache herunterladen. Die Sprache kommt momentan in Projekten wie Riak, CouchDB und GitHub sowie in Telekommunikationsanwendungen zum Einsatz. (jul)
Erlang 
february 2013 by snearch
Elixir 0.7.1 — A meta-programmable language built on the Erlang VM [video] | Hacker News
codewright 5 hours ago | link

Okay, if I wanted to get started writing a webapp in Dynamo using Elixir, how do I start?

I looked at the GitHub repo and there didn't seem to be much.

All I could find was:

https://github.com/josevalim/dynamo/blob/master/examples/sim...

Can I mix a websockets server into a Dynamo app? Websockets are a key use-case for Erlang for me.

I've been looking into how to do a WS server on Erlang and this was the most modern example I could find: https://github.com/ostinelli/misultin/blob/master/src/misult...

To be frank: pretty fucking gnarly.

reply


nirvana 4 hours ago | link

Dynamo seems to be still pretty early in development. You might want to watch the video linked to the page from the 0redev conference. He doesn't talk about dynamo much, but he does give "2013" as the date for Dynamo.

On the WebSockets issue, I'd check out Cowboy. Cowboy seems to be the new hotness in erlang web apps. It has at least some support for web sockets.

https://github.com/extend/cowboy

If you're looking for a full featured web framework with built-in web socket support then maybe what you really want is Nitrogen: http://nitrogenproject.com

Finally, and just for completeness, since I'm mentioning web frameworks, you'll probably want to see what ChicagoBoss's WS story is: http://www.chicagoboss.org or if someone's done something with WebMachine and websockets: http://basho.com

I think Nitrogen sounds like the best bet.

Since Elixir seems to mix effortlessly with Erlang, you should be able to write your code in Elixir using any of these frameworks.

reply
Elixir  Erlang  Webdevelopment  Cowboy 
november 2012 by snearch
Why Program In Erlang : programming
Actually, one of the most popular programs today in Android, iOS and WP is WhatsApp. It has millions of users.

The entire network is made with Erlang. They can handle millions of concurrent messages with next to zero server loads.

Hope this answered your question.
TOP  Inspiration  offer_web_services  vServer  Erlang  Haskell  Scala  OCaml  Node.js  TypeScript  Dart  print! 
october 2012 by snearch
Why I Program in Erlang | Hacker News
codewright 3 hours ago | link

>There's no pattern matching like erlang pattern matching

Really? I'd imagine Haskell's is even better being lazy.

Not to mention the sort of things Prolog is capable of.

Thinking about making a game recently, current choice for backend will probably end up being Clojure or Erlang.

reply
Erlang  Programmiersprache_wählen  comment  "simple_tagging_is_not_enough"  Prolog  Haskell  pattern_matching 
october 2012 by snearch
functional programming - Haskell vs Erlang for web services - Programmers
Between the two you mention, definitely Haskell is academic, while Erlang is used in real-life high-scalability projects. So of the two for web services I'd choose Erlang.

But I'd say you have third choice: Scala, a language that is heavily influenced by both Haskell and Erlang. It's used to build top notch web services like Twitter or Foursquare. There is even Lift, a web framework inspired by Rails and Django, although with a bit different, more functional approach. Foursquare is using Lift.
Erlang  Haskell  Webdevelopment  functional  programming 
september 2012 by snearch
What's the use of Erlang and is it worth the investment? - Stack Overflow
7 down vote accepted


Probably the biggest draw for Erlang is that it is (for the most part) always thread safe. With the restriction on single core processors, there is a big draw for doing parallel coding. This can be done in languages like C++ or Java with Threads, but it can be very difficult to get everything to run without subtle bugs.

With Erlang, writing parallel code is much easier, and although it may not have the sequential speed of other langauges, it is a lot safer and you end up spending less time (and often no time) debugging the tricky parallel gotcha.

As a particular example, Erlang is very good a dealing with web interfaces. For reliablily Yaws can handle a huge amount of parallel sessions, and for speed, Misultin runs request faster than any other web interface I have seen.

I would say that Erlang is worth the investment, because at the very least, since it is a functional langauge it gets you into the habbit of writting good sequential code too (Following function language patterns)
Webdevelopment  Erlang  PROs 
september 2012 by snearch
Speakers -> John Hughes
John Hughes has been a functional programming enthusiast for more than thirty years, at the Universities of Oxford, Glasgow, and since 1992 Chalmers University in Gothenburg, Sweden. He served on the Haskell design committee, co-chairing the committee for Haskell 98, and is the author of more than 75 papers, including "Why Functional Programming Matters", one of the classics of the area. With Koen Claessen, he created QuickCheck, the most popular testing tool among Haskell programmers, and in 2006 he founded Quviq to commercialise the technology using Erlang
Javascript  Haskell  QuickCheck  Hughes_John  Erlang  Quvig  Claessen_Koen 
september 2012 by snearch
« earlier      
per page:    204080120160

related tags

"simple_tagging_is_not_enough"  Actors  advertising  Agner  algorithm  amazon  Angular.js  Apiary.io  Arbeitstechniken  architecture_software  Armstrong_Joe  asynchronous_event_processing  Atoms  Autobench  Backend  BaseCase.com  Batman.js  benchmarking  Berlin  Beruf::Stellenangebote  book_recommendation  Boost  BOSH  BSD  BSD_Rump_Kernel  Bullrich  C  C#  c++  Challenges_Technical  ChicagoBoss  Chicago_Boss  choice_of  Claessen_Koen  client_side  Clojure  CMake  CMS  Comet  comment  COMMON_LISP  Concurrency  configuration_library  CONs  Consultant  context_switch  CONTRAs  Cookbooks  Cookies  Core  core.logic  CouchDB  cowboy  cperl  criticism  cro  CUFP_2008  d26  d29  Dart  Databases  debugger  debugging  debugging_strategies  declarative  decoupling  deployment  Depressionen  design_decisions  Dialyzer  Discord  distributed_systems  DIY  Django  doxygen  DynamoDB  ec2  Eclipse  ejabberd  Elixir  Elixir_Programming_Language  emacs  email  Embedded_Linux  Embedded_Systems  Entrepreneurs/Freelancer  epoll  Erfolgsgeschichte  Erfolgsprinzip  Erfolgstypen  Ergonomie  Ericsson  erl2  erlang  Erlang/ALE  Erlang2  error_handling  exprecs  F#  Facebook  fehlertolerant  filetype:pdf  FizzBuzz  Flash  framework  FreeBSD  Freiberuflichkeit  ftp  functional  fun_in_programming  games  git  gittorrent  Golang  Google  Graphen  Gumstix  Hardware_Basteleien  Harrop_Rob  Haskell  Haskell-Core  have_a_demo_ready  higher_quality  High_Reliability  Hilfe_gegen  Hoare_C._A._R.  Hoffmann_Torben  hot_code_swapping  html5  http  http-server  Hughes_John  Index  Informatik::Algoritmen::MapReduce  Insightful  inspiration  interessant  Interview  java  javascript  Java_EE  Joe_Armstrong  JSON  JVM  katt  Kay_Alan  KERL  Learn_you_some_Erlang  Lernherausforderung  lesen  Lesezeichen-Symbolleiste  libraries_programmers_tools  Linux  LISP  load_balancing  Logic_Programming  LOKI  Lus  LusJIT  m05  m08  Macros  mailrank.com  mechanizerl  media:document  mehr_A_verdienen  Mercurial  Merritt  Microkernel  Miller_Evan  Mirage  ML9  Mnesia  Mo  Moar  MoarVM  mochiweb  model  moden  modularisation  Moffitt_Jack  Mozart/Oz  MQTT  MTA  Multithreading  networking_hardware  nitrogen  NixOS  Nix_Package_Manager  Node.js  Nolan_David  NoSQL  Objective-C  OCaml  Odersky_Dr._Martin  offer_web_services  OOP  OpenCL  Oracle  OSGi  OSv  OS_X  OTP  p2p  packages_repository  Parallelism  Parallel_Programming  Parrot  Parsing  pattern_matching  perl  Perl6  Peyton-Jones_Simon  Php  Pietro  Pony  Potion  print  print!  process  Profession  Professional_Software_Development  Prognose  Programmiersprache_wählen  programming  Programming_Erlang_2nd._Ed.  Programming_in_Erlang_2nd_Ed.  Programming_Language  programming_rules  Prolog  property_based_testing  PROs  protocol  Python  Python_Stackless  QuickCheck  Quickcheck  Quvig  RabbitMQ  Rails  Raspberry_Pi  ReactJS  real_time_bidding  Real_World_Haskell  reliable  REPL  resource_pooling_tool  REST  RPC  Ruby  Rust  S3  Scala  ScalaCheck  scaling_website  Scheme  screen_scraping  sendmail  server_side  SimpleDB_amazon  SIP  Smalltalk_Programmiersprache  SMTP  Snap  SOA  social_games  Social_Networks  Sockets  software  Soundcloud.com  Spring  SQL  SQLite  Startup  static_type_checker  Stellenangebot  STOMP  SWF  Symbols  Syme_Don  system_orchestration  tail_call_optimization  technology  testing  Thrift  tinch++  Tipps_und_Tricks  Tomcat  TOP  Trading  transactions  Transaction_Memory  Trend  tutorial  TypeScript  Ubuntu  Urban_Reini  vi  video  visual_tour  VM  Vogels_Werner  VoIP  vs.  vServer  Wall_Larry  webdevelopment  webdriver  Webhosting  webmachine  Webserver  Webservices  website  websockets  week  WhatsApp  where_is_the_pain_source  wooga.com  wo_setzt_Ericsson_Erlang_ein?  writer  WWW::Mechanize  XHR  XMPP  y2017  y2018  Yahoo  Yaws  Yesod  You_and_your_Research  Zotonic  Zuckerberg_Marc  Zukunftsmärkte 

Copy this bookmark:



description:


tags: