Locked. This question and its answers are locked because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
Other than specific projects (although those are welcome as well)...
What tools, books, articles, and other resources should I have at my desk to help me learn Erlang?
Also, are there mobile runtimes for Erlang?
Please point me in the right direction.
Note: yes, I have visited Erlang and Wikipedia, but I'd like to hear some reliable, experienced opinions.
I'm a month-or-so into learning and the guides I'm enjoying most are:
The Erlang Site's Getting Started with Erlang Guide
Joe Armstrong's Book Software for a Concurrent World (thoroughly recommended)
And I have on order: O'Reilly's Erlang Programming which has had some really positive reviews and sounds like a good companion to Joe Armstrong's book (covering many of the same topics in greater depth, possibly with more "real world" examples)
I think you can dive into the Getting Started guide straight away and it will certainly give you a feel for functional programming and then concurrency.
If you're in London this June there is the Erlang Factory conference which looks really good.
While I remember, these are two good presentations taking you through Erlang and it's uses:
Thinking in Erlang
Functions + Messages + Concurrency = Erlang
Finally, you can follow my learning experiences on my blog (joelhughes.co.uk/blog) my step by step adjustment of FizzBuzz from python/ruby/php to Erlang might give you a good flavour (sorry about the shameless self promotion).
I have to say learning Erlang is currently one of my greatest pleasures, there is something very satisfying about it!
For beginners, the "Learn you some Erlang" guide is supremely awesome. It is as of yet incomplete, but provides a lot even with what little is there.
It also has an RSS so you can be informed when (if?) it is updated.
I found the best thing to do to learn erlang was reading joe's thesis
http://www.sics.se/~joe/thesis/armstrong_thesis_2003.pdf
and then writing something I enjoyed, for me it was an iax2 server.
What I can recommend you is not to browse the Wings3d source code.
(I did it and it was a waste of time similar as when I tried to read the Quake2 sources :-p)
I have the both the Erlang Progamming and the Software for a Concurrent World, both are excellent. I might almost say the Erlang Programming is better, it shows a lot more about using OTP (Erlang libraries), but I was also a little more comfortable with the language when I was reading it, so that's what I was looking for.
The Getting Started with Erlang Guide is also pretty good.
Definitely you should give writing a simple server a try. That's one of the areas where Erlang really shines and there's plenty of documentation and tutorials around message passing and the gen_server module.
-- edit
Also, you can run Erlang on ARM based mobile devices (ARMv5+) for sure, you could ask on erlang-questions for other architectures. Check out http://wiki.trapexit.org/index.php/Cross_compiling for the basics of getting started with cross-compiling.
Related
I appreciate there are a few posts out there, asking about F# tutorials/learning resources, but so many of the questions (and answers) assume a somewhat established knowledge or experience in C# or programming generally.
While I HAVE engaged in some programming, it's been very bitty and over many years. What I'm looking for is an F# tutorial, or series of tutorials, that walks you through from the very basics (a "complete" program that prints "Hello World!"), and progresses naturally while still showing you the complete solution. Most resources I've found cut out most things and just say "this is how you'd do it in C#, and this is now F#", leaving out other elements that complete the solution to the problem.
EDIT: I found the free course on F Sharp TV (udemy course), but didn't like how it was always exploiting F# Interactive to demo the language, as opposed to building an actually complete application.
I am very new to F#. I just started picking it up this month and I have really enjoyed it so far!
I can really relate to your question because every book or tutorial I've found assumed a lot more knowledge than I had. I would open them up start reading and then 3...2...1...and I was completely lost.
I'm sure once I am better at the language the references that are usually listed will be obviously superior to what I'm about to recommend.
One book I've enjoyed is "Functional Programming Using F#". It starts from the very, very basics and provides information about the small things in F# that I otherwise would have missed. The best part are the exercises at the end of the chapters, because someone went through all of them and posted answers here: [1]. So you can struggle through the exercises and then get an idea of how someone else approached the problem! The main drawback of this book is that the examples can be math heavy at times.
The second book I've used is called "Friendly F#". I really have never seen it linked or talked about, but I have thoroughly enjoyed it. I have found the approach the author takes to be rather novel. Instead of showing me how to implement the Fibonacci sequence in F# for the bajillionth time the author starts with projects! Real projects where you can actually visualize things! For example, in the first chapter you create an F# script where you visualize a ball bouncing in a box acted on by gravity! I know real coders are probably more worried about the esoteric features of the language but as someone starting out it was super motivating to actually be able to visualize something and more importantly to have something to show to my wife so she won't think I'm just wasting hours doing nothing. 😁
The last thing I'll recommend is Excercism. It's a great website where the tutors give great feedback. The only drawback is that you need to have somewhat of an idea of what the language can do. For me, I wasted countless hours trying to solve one of the problems only to realize that there is something called Seq.zip which would have solved the problem instantly. So, I recommend sitting down with a problem thinking hard on it for an hour and then googling "fsharp excercism solutions insert problem name here". Luckily, you can navigate directly to the solutions page and go through hundreds of solutions that other folks came up with. That's how I learned forever what Seq.zip is.
EDIT:
I also wanted to add this video [2]. It's not going to teach you all you need to know about F# in one video. However, it will give you a great overview of the language so while you are learning it in more depth you have an idea of what the language is capable of.
I hope this helps!!
[1] - https://github.com/TorbenRahbekKoch/Functional-Programming-Using-FSharp
[2] - https://www.youtube.com/watch?v=c7eNDJN758U
As mentioned in the comments, some might think this answer can be seen as opinion motivated. I feel that those resources could be a good entry point to learning more about the language.
Reference: sachabarbs.wordpress.com/1406-2
Reference en.wikibooks.org/wiki/F_Sharp_Programming
Bonus: Getting started with F# in the cloud with Azure, take a peek at this awesome reference!
Reference: Getting started with F# with Azure Notebooks
I would recommend first fsharpforfunandprofit.com - clearly a big starting point. You have the complete. This is a great section to "thibk functionally". https://fsharpforfunandprofit.com/series/thinking-functionally.html
When you get used to the language (a little bit), I would recommend "Stylish F#" . It is a very recent well written book on good practices for beginners (but who can write a bit of F#). Really liked it.
I am about to build a system with Erlang (my problem can be solved better with multiple CPUs) and I have skimmed through:
Learn You Some Erlang;
Erlang/OTP in Action
Programming Erlang (Armstrong);
Erlang Programming (Cesarini).
The Erlang/OTP in Action book (2) says: "...writing non-OTP Erlang code is really an advanced topic, and something that should be done only when you really really have to. So perhaps not ever having done it the non-OTP way is a blessing because you will pick up the right habits straight away with regard to things OTP..."
(2) insists that commercial systems should be built with OTP only, whilst (4) gently shows that OTP is not the only way to do this.
Additionally, by reading (4) I have found out that building the knowledge from the very basics of Erlang helps to understand how OTP works (but not in the opposite way).
So, the question is:
Should I choose Erlang/OTP to build a commercial system or can it be done with pure Erlang?
Learn and play with pure Erlang.
Build systems in Erlang/OTP.
can it be done with pure Erlang?
Yes, it can, subject to the analogue of Greenspun's Tenth Rule: your system will contain an ad hoc, informally-specified, bug-ridden, slow implementation of half of OTP.
OTP is written in Erlang so it definitely can be done in pure Erlang. That being said OTP provides you with a lot of useful functionality which you would otherwise need to write yourself. #Alexey is right than you will end up implementing a portion of OTP along the way. The problem is that the framework you need for building fault-tolerant systems, which OTP provides, has to itself be very fault-free.
I will also echo #Mazen in that experimenting with doing it in pure Erlang gives you a good feel for what is going on internally in OTP and how you can build fault-tolerant systems in Erlang. You will make better use of OTP afterwards. You will come to a better understanding when not to use OTP, and why.
If you read through the "Learn You Some Erlang" (like you said you have) you'll notice the author spends the Designing a Concurrent Application chapter building something half-useful in "plain Erlang". Then in the next 2 chapters, he basically throws it all away, and uses OTP to achieve the same thing with far less code (add to that the fact that because it's OTP code, it's standard - so other developers with familiarity with OTP will have a much better idea of where to look to understand it!)
The OTP has been developed and refined over a lot of years (initial release 1998 according to Wikipedia) with a large number of developers, and the backing of a large international company (Ericsson), and peer reviewed as it's all open source. I think it'd be a little audacious to assume you could single-handledly build something equally robust and scalable!
So use the OTP. Even for "play" projects, still use the OTP as it can only help you learn to make your "commercial" code better :)
I recently started learning Erlang and at this point I'm comfortable with most concepts and syntax. I'd like to continue my learning by using Erlang to build a "simple" instant message application. I'd appreciate suggestions on which resources (books, websites, etc.) can help me along.
Learn You Some Erlang has a bunch of chapters on concurrency, networking, and OTP. You might also be interested in reading the ejabberd code, though it might be a bit involved.
Hi I'd like to pick up one FP language (it's always a pain when you work in a position that does not require you learn much), and after doing some research, I felt Erlang and OCaml are the two that I'd really like to get my feet wet for the following reasons:
1) I work mainly on high-availability web server back-end system in C++. I heard Erlang is a great fix in scalability and fault-tolerance. Though I don't think my current company will have any project in Erlang, I feel Erlang may be a good language for my long term career development.
2) I have a co-worker who is really good at OCaml, I mean he is really good at it (but he does not work on that for his daily work now. He maintains several library). So I figured that he may be a good resource if I learn OCaml.
My interests are mainly on distributed systems (my current work is some midldle-ware development work) and high-performance computing (guess what, I had a couple of years graduate school research on it, in particular PDE in Financial applications -- so I always felt I may go back to do some finance modeling work maybe sometime later)
Any suggestions? Please don't suggest "learn both", as I am not that smart :-)
Thanks
Ocaml is a great language -- one of my favorites -- but if your interest is distributed systems than I'd recommend going with Erlang, which is head and shoulders ahead of the other FP languages with regards to distributed systems (although there's an offshoot of Ocaml called Jocaml which has some interesting aspects).
Ocaml is weaker even when just looking at parallelism, given its underlying architecture. Both Haskell and Clojure have better stories here, imho. (That said: once you get one FP language, you'll be able to carry the fundamental principles to other languages pretty easily, and they might be useful in the future. Both Scala and Clojure could easily sneak their way into organizations by virtue of the JVM.)
I think Ocaml is a great way to get started in FP, and Erlang is not very difficult once you have the basic FP concepts down.
But the suggestion from 'aneccodeal' is fantastic-- i.e., if you are interested in Ocaml and have a friend who is already strong in it, by all means develop a concurrency (perhaps MPI) library for it.
Keep in mind, however, that one of the barriers to making Ocaml concurrent is the lack of concurrent garbage collection (or so I have read).
If you have a co-worker who is "really good" with OCaml then it sounds like you have a great resource assuming that s/he is willing to answer your questions. It's always easier to learn when there's someone knowledgeable around that you can ask questions of if you get stuck.
Yes it's true that OCaml doesn't have the best story when it comes to parallelism, but there are ways to get parallelism in OCaml (fork-based seems to be the most common - checkout prelude.ml which includes things like parallel map: http://github.com/kig/preludeml/tree/master ). Also, it seems that Erlang's Actor-based concurrency is really fairly easy to duplicate in other languages. Maybe you and your co-worker could work on a project to develop an Actor-based concurrency library for OCaml? That would give you a nice learning project that you co-worker would probably find interesting enough to work on with you... in addition you could end up creating something useful for the entire OCaml community.
I would also consider to look at F# (especially when VS 2010 is out).
Learning a new language is a lot easier and more convenient with a nice IDE.
F# and OCaml are very similar as you can see in other SO threads (e.g. here)
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
I'm currently learning to program, and I didn't take CS classes so I'm basically starting out on the bottom. I have been putting together code on and off for many years, but haven't really had a good understanding of essential concepts needed for enganging in bigger projects. Object-orientation is an obvious one, and I feel I'm beginning to understand some of the concepts there. Then there is a lot of buzz and methodology, such as MVC, UML, SCRUM, SOLID and so foth and so on.. I've looked at many of these but I'm always stumped as most explanations seem to require some understanding of other concepts.
I want to learn this stuff the "right" way, so where do I begin?
What are the overarching constructs I need to understand that enable me to understand all the underpinnings of software architecture/design/development?
What am I missing?
Are there constructs and concepts that can and should wait until I've cleared the foundation?
The SOLID principles are probably the most important.
From those you understand the motivation behind using a pattern such as MVC, why people think of persistence ignorance as important and so on. They are at the core of the majority of good practices.
Loose coupling, high cohesion.
And as for books, Code Complete covers almost everything at some level, at least.
Software development is a HUGE arena and you should be careful that you don't take on too much too quickly. Unless you're going to go in the direction of functional programming I'd suggest you start off by making sure you fully understand the concepts surrounding OO design and programming as this should be your foundation.
Once you understand that well you'll be able to understand design patterns a lot better and get a feeling for when to use them.
I'd suggest you try out a few languages till you find one you feel comfortable with, personally my favourite language is Ada which is a very pure OO language but in the business world I work in C# which still has a lot of issues but these are outweighed by the more vibrant job market.
I wouldn't worry too much about Scrum at this stage as you need to focus more on your dev skills before worrying about project management.
The most important thing is to work with as much code as possible, download lots of good reference solutions and work through the code till you understand it, and try and keep an eye on the development trends.
If its viable you may also want to considering attending some developer conferences too as these can be very inspirational.
Stay away from ACRONYMS (including those you've listed) and Methodologies(tm). At least in the beginning.
Read good books. Start with this one: Pragmatic Programmer. Learn algorithms and data structures, possibly from Introduction to algorithms by Cormen et al.
Write a lot of code. Practice is more important than anything else.
How to test software with unit tests. Being able to do that will solve 90% of all the other issue automatically since you can't test while they are around.
When you know how to test, you can start on advanced topics like design.
I'd recommend "Object Oriented Analysis and Design with Applications" by Grady Booch et al. The latest editoin has detailed explanation of concepts of OOAD including MVC, UML (which he invented), and discussions on how to manage the whole process of software development. The second part of the book exemplifies all this by developing 5 sample systems (with sometimes orthogonal aspects from the very core).
Another good one is of course Design Patterns by GoF which will give you an idea of loose coupling, ways to efficient encapsulation and reuse of code, etc
For what concerns the algorithmic part, take any book which is not bounded to a particular programming language. My favorite is Introduction to Algorithms by T. H. Cormen et al, it gets a bit theoretical at some points, but I especially like it when they are proving certain things and not just asking you to believe it.
When you are working with any modern general purpose language, it is probably a good idea to get a handle on patterns (MVC or Model-View-Controller is one). The book by the "gang of four" is a must read for this, or at least research a few and use it as a reference.
clicky
Refactoring is another concept that should be in your arsenal. The book by Martin Fowler on this subject is a very nice read and helps understand the aforementioned patterns better also a little explanation about UML is included.
Can't post more than one hyperlink so...
search on amazon for: Refactoring, Improving the design of existing code
When you want to communicate your designs UML (Unified Modelling Language) is the 'tool' of choice for many people. However UML is large and unwieldy but Martin Fowler (again) has managed to boil it down to the essentials.
search on amazon for: UML Distilled (make sure you get the most recent one)
SCRUM is one of many methods that is used to manage software development groups, I do not think there is much merit in learning that when you are just starting out or on your own. Especially not in detail.
Hope it helps...
PS: SOLID I haven't heard about yet, somebody else has to help you there.
You'd have a decent foundation if you surveyed basic Data Structures, Algorithms, and Algorithms Analysis.
I think that you should start coding real world problems to get a feel for problems in the programming domain.
Then you have a better background to understand why objects are important. Then, after managing objects, you will learn why patterns and OO principles are important.
Personally, I highly recommend the Agile Software Development, by Robert C Martin.
But it may be a long and tiresome read unless you have a feel for the problems being solved. I'm afraid that you may need 500-1000 hours of coding at the minimum before you get an appreciation that the problems being solved are real.
And it probably takes 7000+ hours before you develop an instinctive heart-felt pain from merely reading the problems, making this sort of book become the page-turner that it should be.
Regrettably, many of the sound practices that you should develop are only appreciated after having to live with your code over time. If you just do many excercises and abandon the code afterwards just "because it works", then you are missing out on the greatest pain of all. It is a luxury our industry does not have, and "technical debt" is a very very real and costly to those with large code bases.
I feel kinda silly answering my own question like this.. :) But one valuable resource I've found for learning to write code, is the Euler Project at http://www.projecteuler.net
It's basically a collection of mathmatical problems that you solve by writing your own solution to it. Once you've found the answer to a particular problem, you're allowed access to that problem's forum where different solutions are discussed. I was amazed at how much I was learning in a) solving a challenge, b) reading about other peoples approaches and c) how many programming languages there are out there! :)
The problems start out easy (you can tell by the number of people who's solved them) and progress to harder and harder problems.
Currently I'm working on problem #3, having solved the previous two... I recommend you start chippin' away at them, no matter your level!