book

Erlang Programming

by Francesco Cesarini, Simon Thompson

June 2009

Intermediate to advanced

494 pages

14h 7m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Francesco: Why Erlang?Simon: Why Erlang?Who Should Read This Book?How to Read This BookConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact UsAcknowledgments
Why Should I Use Erlang?The History of ErlangErlang’s CharacteristicsHigh-Level ConstructsConcurrent Processes and Message PassingScalable, Safe, and Efficient ConcurrencySoft Real-Time PropertiesRobustnessDistributed ComputationIntegration and OpennessErlang and MulticoreCase StudiesThe AXD301 ATM SwitchCouchDBComparing Erlang to C++How Should I Use Erlang?
IntegersThe Erlang ShellFloatsMathematical OperatorsAtomsBooleansTuplesListsCharacters and StringsAtoms and StringsBuilding and Processing ListsList Functions and OperationsTerm ComparisonVariablesComplex Data StructuresPattern MatchingFunctionsModulesCompilation and the Erlang Virtual MachineModule DirectivesExercisesExercise 2-1: The ShellA. Erlang expressionsB. Assigning through pattern matchingC. Recursive list definitionsD. Flow of execution through pattern matchingE. Extracting values in composite data types through pattern matchingExercise 2-2: Modules and FunctionsExercise 2-3: Simple Pattern Matching
Conditional EvaluationsThe case ConstructVariable ScopeThe if ConstructGuardsBuilt-in FunctionsObject Access and ExaminationType ConversionProcess DictionaryMeta ProgrammingProcess, Port, Distribution, and System InformationInput and OutputRecursionTail-Recursive FunctionsTail-Call Recursion OptimizationTwo accumulators exampleIterations Versus Recursive FunctionsRuntime ErrorsHandling ErrorsUsing try ... catchUsing catchLibrary ModulesDocumentationUseful ModulesThe DebuggerExercisesExercise 3-1: Evaluating ExpressionsExercise 3-2: Creating ListsExercise 3-3: Side EffectsExercise 3-4: Database Handling Using ListsExercise 3-5: Manipulating ListsExercise 3-6: Sorting ListsExercise 3-7: Using Library ModulesExercise 3-8: Evaluating and Compiling ExpressionsExercise 3-9: IndexingExercise 3-10: Text Processing
Creating ProcessesMessage PassingReceiving MessagesSelective and Nonselective ReceivesAn Echo ExampleRegistered ProcessesTimeoutsBenchmarkingProcess SkeletonsTail Recursion and Memory LeaksA Case Study on Concurrency-Oriented ProgrammingRace Conditions, Deadlocks, and Process StarvationThe Process ManagerExercisesExercise 4-1: An Echo ServerExercise 4-2: The Process Ring
Client/Server ModelsA Client/Server ExampleA Process Pattern ExampleFinite State MachinesAn FSM ExampleA Mutex SemaphoreEvent Managers and HandlersA Generic Event Manager ExampleEvent HandlersExercisesExercise 5-1: A Database ServerExercise 5-2: Changing the Frequency ServerExercise 5-3: Swapping HandlersExercise 5-4: Event StatisticsExercise 5-5: Phone FSM
Process Links and Exit SignalsTrapping ExitsThe monitor BIFsThe exit BIFsBIFs and TerminologyPropagation SemanticsRobust SystemsMonitoring ClientsA Supervisor ExampleExercisesExercise 6-1: The Linked Ping Pong ServerExercise 6-2: A Reliable Mutex SemaphoreExercise 6-3: A Supervisor Process
RecordsIntroducing RecordsWorking with RecordsFunctions and Pattern Matching over RecordsRecords in the ShellRecord ImplementationRecord BIFsMacrosSimple MacrosParameterized MacrosDebugging and MacrosInclude FilesExercisesExercise 7-1: Extending RecordsExercise 7-2: Record GuardsExercise 7-3: The db.erl Exercise RevisitedExercise 7-4: Records and ShapesExercise 7-5: Binary Tree RecordsExercise 7-6: Parameterized MacrosExercise 7-7: Counting CallsExercise 7-8: Enumerated TypesExercise 7-9: Debugging the db.erl Exercise
Upgrading ModulesBehind the ScenesLoading CodeThe Code ServerLoading modulesManipulating the code search pathPurging ModulesUpgrading ProcessesThe .erlang FileExerciseExercise 8-1: Software Upgrade During Runtime

Functional Programming for RealFuns and Higher-Order FunctionsFunctions As ArgumentsWriting Down Functions: fun ExpressionsFunctions As ResultsUsing Already Defined FunctionsFunctions and VariablesPredefined, Higher-Order FunctionsLazy Evaluation and ListsList ComprehensionsA First ExampleGeneral List ComprehensionsMultiple GeneratorsStandard FunctionsBinaries and SerializationBinariesThe Bit SyntaxSizesTypesPattern-Matching BitsBitstring ComprehensionsBit Syntax Example: Decoding TCP SegmentsBitwise OperatorsSerializationReferencesExercisesExercise 9-1: Higher-Order FunctionsExercise 9-2: List ComprehensionsExercise 9-3: Zip FunctionsExercise 9-4: Existing Higher-Order FunctionsExercise 9-5: Length Specifications in List ComprehensionsExercise 9-6: Bitstrings
ETS TablesImplementations and Trade-offsCreating TablesHandling Table ElementsExample: Building an Index, Act ITraversing TablesExample: Building an Index, Act IIExtracting Table Information: matchExtracting Table Information: selectOther Operations on TablesRecords and ETS TablesVisualizing TablesDets TablesA Mobile Subscriber Database ExampleThe Database Backend OperationsThe Database ServerExercisesExercise 10-1: Pretty-PrintingExercise 10-2: Indexing RevisitedExercise 10-3: ETS Tables for System Logging
Distributed Systems in ErlangDistributed Computing in Erlang: The BasicsNode Names and VisibilityCommunication and SecurityDistributing the Erlang code: A warningCommunication and MessagesNode ConnectionsHidden nodesRemote Procedure CallsThe rpc ModuleEssential Distributed Programming ModulesThe epmd ProcessDistributed Erlang Behind FirewallsExercisesExercise 11-1: Distributed Associative StoreExercise 11-2: System Monitoring
Introduction to OTP BehaviorsGeneric ServersStarting Your ServerPassing MessagesStopping the ServerThe Example in FullRunning gen_serverSupervisorsSupervisor SpecificationsChild SpecificationsSupervisor ExampleDynamic ChildrenApplicationsDirectory StructureThe Application Resource FileStarting and Stopping ApplicationsThe Application MonitorRelease HandlingOther Behaviors and Further ReadingExercisesExercise 12-1: Database Server RevisitedExercise 12-2: Supervising the Database ServerExercise 12-3: The Database Server As an Application
When to Use MnesiaConfiguring MnesiaSetting Up the SchemaStarting MnesiaMnesia TablesTransactionsWritingReading and DeletingIndexingDirty OperationsPartitioned NetworksFurther ReadingExercisesExercise 13-1: Setting Up MnesiaExercise 13-2: TransactionsExercise 13-3: Dirty Mnesia Operations
wxWidgetswxErlang: An Erlang Binding for wxWidgetsObjects and TypesEvent Handling, Object Identifiers, and Event TypesPutting It All TogetherA First Example: MicroBlogThe MiniBlog ExampleObtaining and Running wxErlangExercisesExercise 14-1: Selecting the Blog FileExercise 14-2: Saving Blog Items SeparatelyExercise 14-3: Multiple Blogs in Separate TabsExercise 14-4: Extending the Entries—Rich TextExercise 14-5: Tagging EntriesExercise 14-6: Multiple Users and CommentsExercise 14-7: Layout and wxErlang Sizers
User Datagram ProtocolTransmission Control ProtocolA TCP ExampleThe inet ModuleFurther ReadingExercisesExercise 15-1: Snooping an HTTP RequestExercise 15-2: A Simple HTTP ProxyExercise 15-3: Peer to Peer
An Overview of InterworkingInterworking with JavaNodes and MailboxesRepresenting Erlang TypesCommunicationPutting It Together: RPC RevisitedInteractionThe Small PrintTaking It FurtherC NodesGoing FurtherErlang from the Unix Shell: erl_callPort ProgramsErlang Port CommandsCommunicating Data to and from a PortLibrary Support for CommunicationWorking in Ruby: erlectricityAn example using erlectricityLinked-in Drivers and the FFIExercisesExercise 16-1: C Factorial via a PortExercise 16-2: Factorial Server in Another Language
IntroductionThe Trace BIFsProcess Trace FlagsInheritance FlagsGarbage Collection and TimestampsTracing Calls with the trace_pattern BIFThe dbg TracerGetting Started with dbgTracing and Profiling FunctionsTracing Local and Global Function CallsDistributed EnvironmentsRedirecting the OutputRedirecting to sockets and binary filesMatch Specifications: The fun SyntaxGenerating Specifications Using fun2msOdds and ends with fun2msDifference Between ets and dbg Match SpecificationsMatch Specifications: The Nuts and BoltsThe HeadConditionsThe Specification BodySaving Match SpecificationsFurther ReadingExercisesExercise 17-1: Measuring Garbage Collection TimesExercise 17-2: Garbage Collection Using dbgExercise 17-3: Tracing ETS Table EntriesExercise 17-4: Who Is the Culprit?
Types in ErlangAn Example: Records with Typed FieldsErlang Type NotationTypEr: Success Types and Type InferenceDialyzer: A DIscrepancy AnaLYZer for ERlang ProgramsDocumentation with EDocDocumenting usr_db.erlModule tagsFunction tagsGeneric tagsRunning EDocModule pagesOverview pageTypes in EDocGoing Further with EDocExercises
Test-Driven DevelopmentEUnitHow to Use EUnitFunctional Testing, an Example: Tree SerializationThe EUnit InfrastructureAssert MacrosTest-Generating FunctionsEUnit Test RepresentationTesting State-Based SystemsFixtures: Setup and CleanupTesting Concurrent Programs in ErlangExercisesExercise 19-1: Testing Sequential FunctionsExercise 19-2: Testing Concurrent SystemsExercise 19-3: Software UpgradeExercise 19-4: Testing OTP BehaviorsExercise 19-5: Devising Tests for OTP Behaviors
Applications and ModulesLibrariesDirty CodeInterfacesReturn ValuesInternal Data StructuresProcesses and ConcurrencyStylistic ConventionsCoding StrategiesEfficiencySequential ProgrammingListsTail Recursion and Non-tail RecursionConcurrencyAnd Finally...
Getting Started with ErlangInstalling the SystemRunning the Erlang ShellTools for ErlangEditorsOther ToolsWhere to Learn More

Content preview from Erlang Programming

Foreword

Mike Williams

Director of Traffic and Feature SoftwareProduct Development Unit WCDMA, Ericsson ABone of the inventors of Erlang

Erlang is our solution to three problems regarding the development of highly concurrent, distributed “soft real-time systems”:

To be able to develop the software quickly and efficiently
To have systems that are tolerant of software errors and hardware failures
To be able to update the software on the fly, that is, without stopping execution

When we “invented” Erlang, we focused on telecommunication systems, but today these requirements are applicable to a large number of applications, and Erlang is used in applications as divergent as distributed databases, financial systems, and chat servers, among others. Recent interest in Erlang has been fueled by its suitability for use on multicore processors. While the world is struggling to find methods to facilitate porting applications to multicore processors, Erlang applications can be ported with virtually no changes.

Initially, Erlang was slow to spread; maybe it was too daring to introduce functional programming, lightweight concurrency, asynchronous message passing, and a unique method to handle failures, all in one go. It is easy to see why a language such as Java, which is only a small step away from C++, was easier for people to swallow. However, to achieve the goals I’ve just mentioned, we feel our approach has weathered the test of time. The use of Erlang is expanding rapidly.

This book is an excellent ...