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

Chapter 12. OTP Behaviors

In previous chapters, we introduced patterns that recur when you program using the Erlang concurrency model. We discussed functionality common to concurrent systems, and you saw that processes will handle very different tasks in a similar way. We also emphasized special cases and potential problems that have to be handled when dealing with concurrency.

For example, picture a project with 50 developers spread across several geographic locations. If the project is not properly coordinated and no templates are provided, how many different client/server implementations might the project end up with? Even more dangerous, how many of these implementations will handle special borderline cases and concurrency-related errors correctly, if at all? Without a code review, can you be sure there is a uniform way across the system to handle server crashes that occur after clients have sent a request to the server? Or guarantee that the response from a request is indeed the response, and not just any message that conforms to the internal message protocol?

OTP behaviors address all of these issues by providing library modules that implement the most common concurrent design patterns. Behind the scenes, without the programmer having to be aware of it, the library modules ensure that errors and special cases are handled in a consistent way. As a result, OTP behaviors provide a set of standardized building blocks used in designing and building industrial-grade systems. The subject ...