book

Learn You Some Erlang for Great Good!

by Fred Hebert

January 2013

Beginner to intermediate

624 pages

17h 18m

English

No Starch Press

Read now

Unlock full access

To the ForeignerTo the Erlang RegularTo the Person Who Has Read This Online
So What’s Erlang?Don’t Drink Too Much Kool-AidWhat You Need to Dive InWhere to Get Help
Using the Erlang ShellEntering Shell CommandsExiting the ShellSome Erlang BasicsNumbersInvariable VariablesAtomsBoolean Algebra and Comparison OperatorsTuplesListsList ComprehensionsWorking with Binary DataBit SyntaxBitwise Binary OperationsBinary StringsBinary Comprehensions
What Are Modules?Creating ModulesCompiling CodeCompiler OptionsDefining MacrosMore About ModulesMetadataCircular Dependencies
Pattern MatchingFancier PatternsVariables in a BindGuards, Guards!What the If ?!In case ... ofWhich Should We Use?
Dynamite-Strong TypingType ConversionsTo Guard a Data TypeFor Type Junkies
How Recursion WorksLength of a ListLength of a Tail RecursionMore Recursive FunctionsA Duplicate FunctionA Reverse FunctionA Sublist FunctionA Zip FunctionQuick, Sort!More Than ListsThinking Recursively

Let’s Get FunctionalAnonymous FunctionsMore Anonymous Function PowerFunction Scope and ClosuresMaps, Filters, Folds, and MoreFiltersFold EverythingMore Abstractions
A Compilation of ErrorsCompile-Time ErrorsNo, YOUR Logic Is Wrong!Runtime ErrorsFunction Clause ErrorsCase Clause ErrorsIf Clause ErrorsBad Match ErrorsBad Argument ErrorsUndefined Function ErrorsBad Arithmetic ErrorsBad Function ErrorsBad Arity ErrorsSystem Limit ErrorsRaising ExceptionsError ExceptionsWhen Not to Use ErrorsCustom ErrorsExit ExceptionsThrow ExceptionsDealing with ExceptionsHandling Different Types of ExceptionsAfter the CatchTrying Multiple ExpressionsWait, There’s More!Try a try in a Tree
Reverse Polish Notation CalculatorHow RPN Calculators WorkCreating an RPN CalculatorTesting the CodeHeathrow to LondonSolving the Problem RecursivelyWriting the CodeRunning the Program Without the Erlang Shell
RecordsDefining RecordsReading Values from RecordsUpdating RecordsSharing RecordsKey/Value StoresStores for Small Amounts of DataProplistsOrddictsLarger Dictionaries: Dicts and GB TreesA Set of SetsDirected GraphsQueuesEnd of the Short Visit
Don’t PanicConcurrency ConceptsScalabilityFault ToleranceConcurrency ImplementationNot Entirely Unlike Linear ScalingSo Long and Thanks for All the Fish!Spawning ProcessesSending MessagesReceiving Messages
State Your StateWe Love Messages, But We Keep Them SecretTime OutSelective ReceivesThe Pitfalls of Selective ReceivesMore Mailbox Pitfalls
LinksIt’s a Trap!Old Exceptions, New ConceptsExceptions and Trapsexit/2 Changes EverythingKilling Me (Not So) SoftlyMonitorsNaming Processes
Understanding the ProblemDefining the ProtocolLay Them FoundationsAn Event ModuleEvents and LoopsAdding An InterfaceThe Event ServerHandling MessagesHot Code LovingI Said, Hide Your MessagesA Test DriveAdding SupervisionNamespaces (or Lack Thereof)
The Common Process, AbstractedThe Basic ServerIntroducing the Kitty ServerGeneralizing CallsGeneralizing the Server LoopStarter FunctionsGeneralizing Kitty ServerSpecific vs. GenericCallback to the FutureThe init FunctionThe handle_call FunctionThe handle_cast FunctionThe handle_info FunctionThe terminate FunctionThe code_change Function.BEAM Me Up, Scotty!
What Is a Finite-State Machine?Generic Finite-State MachinesThe init FunctionThe StateName FunctionThe handle_event FunctionThe handle_sync_event FunctionThe code_change and terminate FunctionsA Trading System SpecificationShow Me Your MovesDefining the State Diagrams and TransitionsGame Trading Between Two PlayersThe Public InterfaceFSM-to-FSM FunctionsThe gen_fsm CallbacksThat Was Really SomethingFit for the Real World?
Handle This! *pumps shotgun*Generic Event HandlersThe init and terminate FunctionsThe handle_event FunctionThe handle_call FunctionThe handle_info FunctionThe code_change FunctionIt’s Curling Time!The ScoreboardGame EventsAlert the Press!
Supervisor ConceptsUsing SupervisorsRestart Strategiesone_for_oneone_for_allrest_for_onesimple_one_for_oneRestart LimitsChild SpecificationsChildIdStartFuncRestartShutdownTypeModulesBand PracticeMusiciansBand SupervisorDynamic SupervisionUsing Standard Supervisors DynamicallyUsing a simple_one_for_one Supervisor
A Pool of ProcessesThe Onion Layer TheoryA Pool’s TreeImplementing the SupervisorsWorking on the WorkersWriting a WorkerRun Pool RunCleaning the Pool
My Other Car Is a PoolThe Application Resource FileConverting the PoolThe Application BehaviorFrom Chaos to ApplicationLibrary Applications
From OTP Application to Real ApplicationThe Application FileThe Application Callback Module and SupervisorThe DispatcherReturning Results through CPSDispatching and ReceivingThe CounterRun App RunIncluded ApplicationsComplex Terminations
Fixing the Leaky PipesTerminating the VMUpdating the Application FilesCompiling the ApplicationsReleases with systoolsCreating a Boot FilePackaging the ReleaseReleases with ReltoolReltool OptionsRelease-Only OptionsRelease-wide and Application-wide OptionsModule-Specific OptionsAll-levels OptionsThat’s DenseReltool RecipesDevelopment VersionsImporting or Exporting Only Part of a LibrarySmaller Apps for Programmers with Big HeartsReleased from Releases
The Hiccups of Appups and RelupsThe Ninth Circle of ErlProcess QuestThe regis-1.0.0 ApplicationThe processquest-1.0.0 ApplicationThe sockserv-1.0.0 ApplicationThe ReleaseMaking Process Quest BetterUpdating code_change FunctionsAdding Appup FilesUpgrading the ReleaseRelup Review
IO ListsUDP and TCP: Bro-tocolsUDP SocketsTCP SocketsMore Control with InetSockserv, RevisitedWhere to Go from Here?
EUnit—What’s an EUnit?Test GeneratorsFixturesMore Test ControlTest DocumentationTesting RegisHe Who Knits EUnits
Why ETSThe Concepts of ETSETS Phone HomeCreating and Deleting TablesInserting and Looking Up DataMeeting Your MatchYou Have Been SelectedDETSA Little Less Conversation, a Little More Action, PleaseThe InterfaceImplementation Details
This Is My BoomstickFallacies of Distributed ComputingThe Network Is ReliableThere Is No LatencyBandwidth Is InfiniteThe Network Is SecureTopology Doesn’t ChangeThere Is Only One AdministratorTransport Cost Is ZeroThe Network Is HomogeneousFallacies in a NutshellDead or Dead-AliveMy Other Cap Is a TheoremConsistencyAvailabilityPartition ToleranceZombie Survivors and CAPSetting Up an Erlang ClusterThrough the Desert on a Node with No NameConnecting NodesMore ToolsCookiesRemote ShellsHidden NodesThe Walls Are Made of Fire, and the Goggles Do NothingThe Calls from BeyondThe net_kernel ModuleThe global ModuleThe rpc ModuleBurying the Distribunomicon
Adding More to OTPTaking and Failing OverThe Magic 8 BallBuilding the ApplicationThe Supervisor ModuleThe Server ModuleMaking the Application Distributed
What Is Common Test?Common Test StructureCreating a Simple Test SuiteRunning the TestsTesting with StateTest GroupsDefining Test GroupsTest Group PropertiesThe Meeting RoomTest Suites ReduxTest SpecificationsSpecification File ContentsCreating a Spec FileRunning Tests with a Spec FileLarge-Scale TestingCreating a Distributed Spec FileRunning Distributed TestsIntegrating EUnit Within Common TestIs There More?
What’s Mnesia?What Should the Store Store?The Data to StoreTable StructureFrom Record to TableOf Mnesia Schemas and TablesCreating TablesInstalling the DatabaseStarting the ApplicationAccess and ContextReads, Writes, and MoreImplementing the First RequestsA Test for Adding ServicesTests for LookupsAccounts and New NeedsMeet the BossDeleting Stuff, DemonstratedQuery List ComprehensionsRemember Mnesia
PLTs Are the Best SandwichesSuccess TypingType Inference and DiscrepanciesTyping About Types of TypesSingleton TypesUnion and Built-in TypesDefining TypesTypes for RecordsTyping FunctionsTyping PracticeExporting TypesTyped BehaviorsPolymorphic TypesWe Bought a ZooSome CautionsYou’re My TypeThat’s All, Folks
Other Erlang ApplicationsCommunity LibrariesYour Ideas Are Intriguing to Me and I Wish to Subscribe to Your NewsletterIs That It?
The TemplateThe English SentenceAnd, Or, Done.In Conclusion

Overview

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 Hebert 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.