Author: Fred Hebert
Publisher: No Starch Press
Release Date: 2013-01-13
Erlang is the language of choice for programmers who want to write robust, concurrent applications, but its strange syntax and functional design can intimidate the uninitiated. Luckily, there’s a new weapon in the battle against Erlang-phobia: Learn You Some Erlang for Great Good! Erlang maestro Fred Hébert starts slow and eases you into the basics: You’ll learn about Erlang’s unorthodox syntax, its data structures, its type system (or lack thereof!), and basic functional programming techniques. Once you’ve wrapped your head around the simple stuff, you’ll tackle the real meat-and-potatoes of the language: concurrency, distributed computing, hot code loading, and all the other dark magic that makes Erlang such a hot topic among today’s savvy developers. As you dive into Erlang’s functional fantasy world, you’ll learn about: –Testing your applications with EUnit and Common Test –Building and releasing your applications with the OTP framework –Passing messages, raising errors, and starting/stopping processes over many nodes –Storing and retrieving data using Mnesia and ETS –Network programming with TCP, UDP, and the inet module –The simple joys and potential pitfalls of writing distributed, concurrent applications Packed with lighthearted illustrations and just the right mix of offbeat and practical example programs, Learn You Some Erlang for Great Good! is the perfect entry point into the sometimes-crazy, always-thrilling world of Erlang.
It's all in the name: Learn You a Haskell for Great Good! is a hilarious, illustrated guide to this complex functional language. Packed with the author's original artwork, pop culture references, and most importantly, useful example code, this book teaches functional fundamentals in a way you never thought possible. You'll start with the kid stuff: basic syntax, recursion, types and type classes. Then once you've got the basics down, the real black belt master-class begins: you'll learn to use applicative functors, monads, zippers, and all the other mythical Haskell constructs you've only read about in storybooks. As you work your way through the author's imaginative (and occasionally insane) examples, you'll learn to: –Laugh in the face of side effects as you wield purely functional programming techniques –Use the magic of Haskell's "laziness" to play with infinite sets of data –Organize your programs by creating your own types, type classes, and modules –Use Haskell's elegant input/output system to share the genius of your programs with the outside world Short of eating the author's brain, you will not find a better way to learn this powerful language than reading Learn You a Haskell for Great Good!
Author: Simon St. Laurent
Publisher: "O'Reilly Media, Inc."
Release Date: 2017-03-06
If you’re new to Erlang, its functional style can seem difficult, but with help from this hands-on introduction, you’ll scale the learning curve and discover how enjoyable, powerful, and fun this language can be. In this updated second edition, author Simon St.Laurent shows you how to write simple Erlang programs by teaching you one skill at a time. You’ll learn about pattern matching, recursion, message passing, process-oriented programming, and establishing pathways for data rather than telling it where to go. By the end of your journey, you’ll understand why Erlang is ideal for concurrency and resilience. Get cozy with Erlang’s shell, its command line interface Define functions, using the fun tool, to represent repeated calculations Discover atoms, pattern matching, and guards: the foundations of your program structure Delve into the heart of Erlang processing with recursion, strings, lists, and higher-order functions Create processes, send messages among them, and apply pattern matching to incoming messages Store and manipulate structured data with Erlang Term Storage and the Mnesia database Learn about Open Telecom Platform, Erlang’s open source libraries and tools
This book is an in-depth introduction to Erlang, a programming language ideal for any situation where concurrency, fault tolerance, and fast response is essential. Erlang is gaining widespread adoption with the advent of multi-core processors and their new scalable approach to concurrency. With this guide you'll learn how to write complex concurrent programs in Erlang, regardless of your programming background or experience. Written by leaders of the international Erlang community -- and based on their training material -- Erlang Programming focuses on the language's syntax and semantics, and explains pattern matching, proper lists, recursion, debugging, networking, and concurrency. This book helps you: Understand the strengths of Erlang and why its designers included specific features Learn the concepts behind concurrency and Erlang's way of handling it Write efficient Erlang programs while keeping code neat and readable Discover how Erlang fills the requirements for distributed systems Add simple graphical user interfaces with little effort Learn Erlang's tracing mechanisms for debugging concurrent and distributed systems Use the built-in Mnesia database and other table storage features Erlang Programming provides exercises at the end of each chapter and simple examples throughout the book.
Erlang is a concurrent, functional programming language designed for programming large industrial real-time systems. The language is untyped and has a pattern matching syntax. Functions are written as a set of recursion equations and the language has explicit concurrency and asynchronous message passing. Written in a tutorial style, this book emphasizes learning through example, illustrating a number of problems in designing and programming concurrent fault-tolerant real-time systems. This edition features new chapters on distributed programming, distributed programming techniques and distributed data.
Author: Gene I. Sher
Publisher: Springer Science & Business Media
Release Date: 2012-11-06
Handbook of Neuroevolution Through Erlang presents both the theory behind, and the methodology of, developing a neuroevolutionary-based computational intelligence system using Erlang. With a foreword written by Joe Armstrong, this handbook offers an extensive tutorial for creating a state of the art Topology and Weight Evolving Artificial Neural Network (TWEANN) platform. In a step-by-step format, the reader is guided from a single simulated neuron to a complete system. By following these steps, the reader will be able to use novel technology to build a TWEANN system, which can be applied to Artificial Life simulation, and Forex trading. Because of Erlang’s architecture, it perfectly matches that of evolutionary and neurocomptational systems. As a programming language, it is a concurrent, message passing paradigm which allows the developers to make full use of the multi-core & multi-cpu systems. Handbook of Neuroevolution Through Erlang explains how to leverage Erlang’s features in the field of machine learning, and the system’s real world applications, ranging from algorithmic financial trading to artificial life and robotics.
If you need to build a scalable, fault tolerant system with requirements for high availability, discover why the Erlang/OTP platform stands out for the breadth, depth, and consistency of its features. This hands-on guide demonstrates how to use the Erlang programming language and its OTP framework of reusable libraries, tools, and design principles to develop complex commercial-grade systems that simply cannot fail. In the first part of the book, you’ll learn how to design and implement process behaviors and supervision trees with Erlang/OTP, and bundle them into standalone nodes. The second part addresses reliability, scalability, and high availability in your overall system design. If you’re familiar with Erlang, this book will help you understand the design choices and trade-offs necessary to keep your system running. Explore OTP’s building blocks: the Erlang language, tools and libraries collection, and its abstract principles and design rules Dive into the fundamentals of OTP reusable frameworks: the Erlang process structures OTP uses for behaviors Understand how OTP behaviors support client-server structures, finite state machine patterns, event handling, and runtime/code integration Write your own behaviors and special processes Use OTP’s tools, techniques, and architectures to handle deployment, monitoring, and operations
This easy-to-use, fast-moving tutorial introduces you to functional programming with Haskell. You'll learn how to use Haskell in a variety of practical ways, from short scripts to large and demanding applications. Real World Haskell takes you through the basics of functional programming at a brisk pace, and then helps you increase your understanding of Haskell in real-world issues like I/O, performance, dealing with data, concurrency, and more as you move through each chapter.
Author: Eric Matthes
Publisher: No Starch Press
Release Date: 2015-11-01
Python Crash Course is a fast-paced, thorough introduction to Python that will have you writing programs, solving problems, and making things that work in no time. In the first half of the book, you’ll learn about basic programming concepts, such as lists, dictionaries, classes, and loops, and practice writing clean and readable code with exercises for each topic. You’ll also learn how to make your programs interactive and how to test your code safely before adding it to a project. In the second half of the book, you’ll put your new knowledge into practice with three substantial projects: a Space Invaders–inspired arcade game, data visualizations with Python’s super-handy libraries, and a simple web app you can deploy online. As you work through Python Crash Course you’ll learn how to: –Use powerful Python libraries and tools, including matplotlib, NumPy, and Pygal –Make 2D games that respond to keypresses and mouse clicks, and that grow more difficult as the game progresses –Work with data to generate interactive visualizations –Create and customize Web apps and deploy them safely online –Deal with mistakes and errors so you can solve your own programming problems If you’ve been thinking seriously about digging into programming, Python Crash Course will get you up to speed and have you writing real programs fast. Why wait any longer? Start your engines and code! Uses Python 2 and 3
How prepared are you to build fast and efficient web applications? This eloquent book provides what every web developer should know about the network, from fundamental limitations that affect performance to major innovations for building even more powerful browser applications—including HTTP 2.0 and XHR improvements, Server-Sent Events (SSE), WebSocket, and WebRTC. Author Ilya Grigorik, a web performance engineer at Google, demonstrates performance optimization best practices for TCP, UDP, and TLS protocols, and explains unique wireless and mobile network optimization requirements. You’ll then dive into performance characteristics of technologies such as HTTP 2.0, client-side network scripting with XHR, real-time streaming with SSE and WebSocket, and P2P communication with WebRTC. Deliver superlative TCP, UDP, and TLS performance Speed up network performance over 3G/4G mobile networks Develop fast and energy-efficient mobile applications Address bottlenecks in HTTP 1.x and other browser protocols Plan for and deliver the best HTTP 2.0 performance Enable efficient real-time streaming in the browser Create efficient peer-to-peer videoconferencing and low-latency applications with real-time WebRTC transports
Author: Simon St. Laurent
Publisher: "O'Reilly Media, Inc."
Release Date: 2014-09-10
Elixir is an excellent language if you want to learn about functional programming, and with this hands-on introduction, you’ll discover just how powerful and fun Elixir can be. This language combines the robust functional programming of Erlang with a syntax similar to Ruby, and includes powerful features for metaprogramming. This book shows you how to write simple Elixir programs by teaching one skill at a time. Once you pick up pattern matching, process-oriented programming, and other concepts, you’ll understand why Elixir makes it easier to build concurrent and resilient programs that scale up and down with ease. Get comfortable with IEx, Elixir’s command line interface Discover atoms, pattern matching, and guards: the foundations of your program structure Delve into the heart of Elixir with recursion, strings, lists, and higher-order functions Create processes, send messages among them, and apply pattern matching to incoming messages Store and manipulate structured data with Erlang Term Storage and the Mnesia database Build resilient applications with Erlang’s Open Telecom Platform Define macros with Elixir’s metaprogramming tools
Build fault tolerant concurrent and distributed applications with Akka About This Book Build networked applications that self-heal Scale out your applications to handle more traffic faster An easy-to-follow guide with a number of examples to ensure you get the best start with Akka Who This Book Is For This book is intended for beginner to intermediate Java or Scala developers who want to build applications to serve the high-scale user demands in computing today. If you need your applications to handle the ever-growing user bases and datasets with high performance demands, then this book is for you. Learning Akka will let you do more for your users with less code and less complexity, by building and scaling your networked applications with ease. What You Will Learn Use Akka to overcome the challenges of concurrent programming Resolve the issues faced in distributed computing with the help of Akka Scale applications to serve a high number of concurrent users Make your system fault-tolerant with self-healing applications Provide a timely response to users with easy concurrency Reduce hardware costs by building more efficient multi-user applications Maximise network efficiency by scaling it In Detail Software today has to work with more data, more users, more cores, and more servers than ever. Akka is a distributed computing toolkit that enables developers to build correct concurrent and distributed applications using Java and Scala with ease, applications that scale across servers and respond to failure by self-healing. As well as simplifying development, Akka enables multiple concurrency development patterns with particular support and architecture derived from Erlang's concept of actors (lightweight concurrent entities). Akka is written in Scala, which has become the programming language of choice for development on the Akka platform. Learning Akka aims to be a comprehensive walkthrough of Akka. This book will take you on a journey through all the concepts of Akka that you need in order to get started with concurrent and distributed applications and even build your own. Beginning with the concept of Actors, the book will take you through concurrency in Akka. Moving on to networked applications, this book will explain the common pitfalls in these difficult problem areas while teaching you how to use Akka to overcome these problems with ease. The book is an easy to follow example-based guide that will strengthen your basic knowledge of Akka and aid you in applying the same to real-world scenarios. Style and approach An easy-to-follow, example-based guide that will take you through building several networked-applications that work together while you are learning concurrent and distributed computing concepts. Each topic is explained while showing you how to design with Akka and how it is used to overcome common problems in applications. By showing Akka in context to the problems, it will help you understand what the common problems are in distributed applications and how to overcome them.