SlideShare a Scribd company logo
1 of 20
Intro to OTP Behaviours
 Presenters: John Patton and Tristan Sloughter
What we’ll cover
• Build concepts over the course of the
  presentation to create a general server
  architecture

• Assumption: basic Erlang knowledge
• We’ll have time for Q&A at the end
What are we going to do?
• Look at high-level concepts used in making a
  simple chat server

• Start off using basic Erlang!!!
• Let’s understand the concepts first
• Build on top of concepts until we
  understand how a general server framework
  works under the hood
Simple Chat Server
What kind of things does a simple chat server need?
Simple Chat Server
What kind of things does a simple chat server need?
 •   Startup routine

 •   Server needs to be aware of the clients that are
     connected

 •   Clients need to register and unregister with the server

 •   The server needs to facilitate sending chat messages from
     one client to another

 •   Shutdown routine
What does our design look like?
                               start            stop

 register_client('john',Pid)                              register_client('tristan',Pid)
                                        Chat
         Chat                          Server                    Chat
         Client                                                  Client

send_message('tristan',Msg)                            send_message('john',Msg)

                               Client Lookup (dict)
                          Client = atom()   pid = pid()
                                'john'       <0.35.0>
                              'tristan'      <0.39.0>
Basic Design

 client defined elsewhere
 chat_server                                         chat_server
chat_server ! {register_client, Name, Pid}.

chat_server ! {send_message, To, Msg}.
                                                                  receive loop
chat_server ! {unregister_client, Name}.
                                                              {register_client,...}

...                                           loop            {unregister_client,...}
                                                              {send_message,...}
                                                              {stop,...}




                                                            loop()
Chat Server Receive loop
•   Our chat server’s loop function
    is spawned and registered
                                                  chat_server
•   The chat server loop function
    will maintain the dictionary of
    clients (client name -> pid)                               receive loop

                                                           {register_client,...}
                                           loop            {unregister_client,...}

•   Traditional tail recursion, will run                   {send_message,...}
                                                           {stop,...}

    until a stop message is received
                                                         loop()
•   Messages sent from a client are
    handled within the receive loop
Let’s organize startup                  start_link
  and initialization                                                spawn



•   Create an initialization function
    to handle registering self()
                                            init
                                        ‘chat_server’
•   Wrap the spawn inside a
    start_link function

•
                                                                 receive loop
    Instead of spawning loop, let’s                          {register_client,...}
    spawn the init function and call       loop              {unregister_client,...}
                                                             {send_message,...}
    loop                                                     {stop,...}



                                                    loop()
Where should we keep                start_link
 track of our clients?                                              spawn



•   Let’s make use of an internal
    state, a key-value dictionary
                                        init
                                    ‘chat_server’
•   Init will be responsible for      dict:new()
    creating the server’s State:
    {ClientName, ClientPID}                     State
                                                                 receive loop



•
                                                             {register_client,...}
    State will be passed into and      loop                  {unregister_client,...}
                                                             {send_message,...}
    maintained within the receive                            {stop,...}


    loop
                                               loop(State)
Let’s look back at
      where we started
 client defined elsewhere
 chat_server                                         chat_server
chat_server ! {register_client, Name, Pid}.

chat_server ! {send_message, To, Msg}.
                                                                  receive loop
chat_server ! {unregister_client, Name}.
                                                              {register_client,...}

...                                           loop            {unregister_client,...}
                                                              {send_message,...}
                                                              {stop,...}




                                                            loop()
Take a look at
        where we are.                             start_link
                                                                                  spawn
 client defined elsewhere
 chat_server
chat_server ! {register_client, Name, Pid}.

chat_server ! {send_message, To, Msg}.                init
                                                  ‘chat_server’
chat_server ! {unregister_client, Name}.      !     dict:new()

...                                                           State
                                                                               receive loop

                                                                           {register_client,...}

                                                     loop                  {unregister_client,...}
                                                                           {send_message,...}
                                                                           {stop,...}



                                                             loop(State)
Let’s make it easier for the
 client to bang messages
                                                          start_link
                                                                                  spawn

  •   “API” Functions in the
      chat_server module
      that a client can call                                 init
                                                          ‘chat_server’
                                   register_client          dict:new()
                                                                          State




  •
                                  unregister_client
      API functions facilitate                        !     loop
                                                                                        receive loop

                                                                                   {register_client,...}

      banging messages to the      send_message                                    {unregister_client,...}
                                                                                   {send_message,...}
                                                                                   {stop,...}


      server pid for the client         stop
                                                                    loop(State)




  •   Cleans up the code
Let’s make a handler for
    banged messages                                   start_link
                                                                              spawn

•   “Callback” functions in
    a module that will
    implement the                                        init
                                                      ‘chat_server’
                               register_client          dict:new()
    message functionality                                             State

                              unregister_client

•   Turns message loop         send_message
                                                  !     loop
                                                                                    receive loop

                                                                               {register_client,...}
                                                                               {unregister_client,...}

    into an interface                                                          {send_message,...}
                                                                               {stop,...}

                                    stop

•   Separates the                                               loop(State)


    implementation from
                               handle_receive
    the interface                                     {Message, State}

•
                                 terminate
    Callbacks update state
Why use OTP?
•   Large collection of libraries

•   Unified Application packaging and release structure

•   Standardized coding practices

•   Components: HTTP and FTP server, CORBA
    ORB, SNMP Agent, IDL, Error Handling

• Formalized design patterns into
    “behaviors”
What is an OTP
      behavior?                          OTP Behavior
                                      • gen_*:functionA/3
•   Simply: a formalization of a      • gen_*:functionB/2
    common pattern into two
    parts.                              ...

    •   Behavior Module that defines
        the pattern interface.
                                       Callback Module
    •   Callback Module that          • module:callbackA/2
        implements the pattern
        interface.                    • module:callbackB/3
                                        ...
Why use OTP for our server?
•   Much of the code needed to create the server in
    our example is already written in the OTP
    behavior: gen_server

•   Since the interface is only used to call a callback
    function, the callbacks can be in any module

•   The gen_server has a generic set of behavior
    functions available for use by ANY implementation
    (can use more than one callback implementation)
Behavior: gen_server
     chat server                  gen_server               !              callback
chat_server:start_link          gen_server:start_link            callback:init/1

chat_server:send_message        gen_server:call                  callback:handle_call/3
chat_server:register_client     gen_server:multi_call
chat_server:unregister_client

chat_server:stop                gen_server:cast                  callback:handle_cast/2
                                     sends stop message               returns: {stop, normal, State}
                                                                 callback:terminate/2



                                State is maintained here   State is passed in and returned back here
More Information
•   Client-server design principles:
    http://www.erlang.org/doc/design_principles/
    gen_server_concepts.html

•   gen_server “behaviour”:
    http://www.erlang.org/doc/man/gen_server.html

•   Chicago Erlang Users Group: start a discussion!

•   Me: John Patton <jpatton@gmail.com>
What happens if it
   crashes?

More Related Content

Recently uploaded

Recently uploaded (20)

Google I/O Extended 2024 Warsaw
Google I/O Extended 2024 WarsawGoogle I/O Extended 2024 Warsaw
Google I/O Extended 2024 Warsaw
 
TEST BANK For, Information Technology Project Management 9th Edition Kathy Sc...
TEST BANK For, Information Technology Project Management 9th Edition Kathy Sc...TEST BANK For, Information Technology Project Management 9th Edition Kathy Sc...
TEST BANK For, Information Technology Project Management 9th Edition Kathy Sc...
 
A Business-Centric Approach to Design System Strategy
A Business-Centric Approach to Design System StrategyA Business-Centric Approach to Design System Strategy
A Business-Centric Approach to Design System Strategy
 
Free and Effective: Making Flows Publicly Accessible, Yumi Ibrahimzade
Free and Effective: Making Flows Publicly Accessible, Yumi IbrahimzadeFree and Effective: Making Flows Publicly Accessible, Yumi Ibrahimzade
Free and Effective: Making Flows Publicly Accessible, Yumi Ibrahimzade
 
Using IESVE for Room Loads Analysis - UK & Ireland
Using IESVE for Room Loads Analysis - UK & IrelandUsing IESVE for Room Loads Analysis - UK & Ireland
Using IESVE for Room Loads Analysis - UK & Ireland
 
Syngulon - Selection technology May 2024.pdf
Syngulon - Selection technology May 2024.pdfSyngulon - Selection technology May 2024.pdf
Syngulon - Selection technology May 2024.pdf
 
Where to Learn More About FDO _ Richard at FIDO Alliance.pdf
Where to Learn More About FDO _ Richard at FIDO Alliance.pdfWhere to Learn More About FDO _ Richard at FIDO Alliance.pdf
Where to Learn More About FDO _ Richard at FIDO Alliance.pdf
 
Optimizing NoSQL Performance Through Observability
Optimizing NoSQL Performance Through ObservabilityOptimizing NoSQL Performance Through Observability
Optimizing NoSQL Performance Through Observability
 
TopCryptoSupers 12thReport OrionX May2024
TopCryptoSupers 12thReport OrionX May2024TopCryptoSupers 12thReport OrionX May2024
TopCryptoSupers 12thReport OrionX May2024
 
Behind the Scenes From the Manager's Chair: Decoding the Secrets of Successfu...
Behind the Scenes From the Manager's Chair: Decoding the Secrets of Successfu...Behind the Scenes From the Manager's Chair: Decoding the Secrets of Successfu...
Behind the Scenes From the Manager's Chair: Decoding the Secrets of Successfu...
 
Designing for Hardware Accessibility at Comcast
Designing for Hardware Accessibility at ComcastDesigning for Hardware Accessibility at Comcast
Designing for Hardware Accessibility at Comcast
 
AI revolution and Salesforce, Jiří Karpíšek
AI revolution and Salesforce, Jiří KarpíšekAI revolution and Salesforce, Jiří Karpíšek
AI revolution and Salesforce, Jiří Karpíšek
 
Measures in SQL (a talk at SF Distributed Systems meetup, 2024-05-22)
Measures in SQL (a talk at SF Distributed Systems meetup, 2024-05-22)Measures in SQL (a talk at SF Distributed Systems meetup, 2024-05-22)
Measures in SQL (a talk at SF Distributed Systems meetup, 2024-05-22)
 
Secure Zero Touch enabled Edge compute with Dell NativeEdge via FDO _ Brad at...
Secure Zero Touch enabled Edge compute with Dell NativeEdge via FDO _ Brad at...Secure Zero Touch enabled Edge compute with Dell NativeEdge via FDO _ Brad at...
Secure Zero Touch enabled Edge compute with Dell NativeEdge via FDO _ Brad at...
 
ECS 2024 Teams Premium - Pretty Secure
ECS 2024   Teams Premium - Pretty SecureECS 2024   Teams Premium - Pretty Secure
ECS 2024 Teams Premium - Pretty Secure
 
FDO for Camera, Sensor and Networking Device – Commercial Solutions from VinC...
FDO for Camera, Sensor and Networking Device – Commercial Solutions from VinC...FDO for Camera, Sensor and Networking Device – Commercial Solutions from VinC...
FDO for Camera, Sensor and Networking Device – Commercial Solutions from VinC...
 
Simplified FDO Manufacturing Flow with TPMs _ Liam at Infineon.pdf
Simplified FDO Manufacturing Flow with TPMs _ Liam at Infineon.pdfSimplified FDO Manufacturing Flow with TPMs _ Liam at Infineon.pdf
Simplified FDO Manufacturing Flow with TPMs _ Liam at Infineon.pdf
 
AI presentation and introduction - Retrieval Augmented Generation RAG 101
AI presentation and introduction - Retrieval Augmented Generation RAG 101AI presentation and introduction - Retrieval Augmented Generation RAG 101
AI presentation and introduction - Retrieval Augmented Generation RAG 101
 
Linux Foundation Edge _ Overview of FDO Software Components _ Randy at Intel.pdf
Linux Foundation Edge _ Overview of FDO Software Components _ Randy at Intel.pdfLinux Foundation Edge _ Overview of FDO Software Components _ Randy at Intel.pdf
Linux Foundation Edge _ Overview of FDO Software Components _ Randy at Intel.pdf
 
Integrating Telephony Systems with Salesforce: Insights and Considerations, B...
Integrating Telephony Systems with Salesforce: Insights and Considerations, B...Integrating Telephony Systems with Salesforce: Insights and Considerations, B...
Integrating Telephony Systems with Salesforce: Insights and Considerations, B...
 

Featured

Social Media Marketing Trends 2024 // The Global Indie Insights
Social Media Marketing Trends 2024 // The Global Indie InsightsSocial Media Marketing Trends 2024 // The Global Indie Insights
Social Media Marketing Trends 2024 // The Global Indie Insights
Kurio // The Social Media Age(ncy)
 

Featured (20)

PEPSICO Presentation to CAGNY Conference Feb 2024
PEPSICO Presentation to CAGNY Conference Feb 2024PEPSICO Presentation to CAGNY Conference Feb 2024
PEPSICO Presentation to CAGNY Conference Feb 2024
 
Content Methodology: A Best Practices Report (Webinar)
Content Methodology: A Best Practices Report (Webinar)Content Methodology: A Best Practices Report (Webinar)
Content Methodology: A Best Practices Report (Webinar)
 
How to Prepare For a Successful Job Search for 2024
How to Prepare For a Successful Job Search for 2024How to Prepare For a Successful Job Search for 2024
How to Prepare For a Successful Job Search for 2024
 
Social Media Marketing Trends 2024 // The Global Indie Insights
Social Media Marketing Trends 2024 // The Global Indie InsightsSocial Media Marketing Trends 2024 // The Global Indie Insights
Social Media Marketing Trends 2024 // The Global Indie Insights
 
Trends In Paid Search: Navigating The Digital Landscape In 2024
Trends In Paid Search: Navigating The Digital Landscape In 2024Trends In Paid Search: Navigating The Digital Landscape In 2024
Trends In Paid Search: Navigating The Digital Landscape In 2024
 
5 Public speaking tips from TED - Visualized summary
5 Public speaking tips from TED - Visualized summary5 Public speaking tips from TED - Visualized summary
5 Public speaking tips from TED - Visualized summary
 
ChatGPT and the Future of Work - Clark Boyd
ChatGPT and the Future of Work - Clark Boyd ChatGPT and the Future of Work - Clark Boyd
ChatGPT and the Future of Work - Clark Boyd
 
Getting into the tech field. what next
Getting into the tech field. what next Getting into the tech field. what next
Getting into the tech field. what next
 
Google's Just Not That Into You: Understanding Core Updates & Search Intent
Google's Just Not That Into You: Understanding Core Updates & Search IntentGoogle's Just Not That Into You: Understanding Core Updates & Search Intent
Google's Just Not That Into You: Understanding Core Updates & Search Intent
 
How to have difficult conversations
How to have difficult conversations How to have difficult conversations
How to have difficult conversations
 
Introduction to Data Science
Introduction to Data ScienceIntroduction to Data Science
Introduction to Data Science
 
Time Management & Productivity - Best Practices
Time Management & Productivity -  Best PracticesTime Management & Productivity -  Best Practices
Time Management & Productivity - Best Practices
 
The six step guide to practical project management
The six step guide to practical project managementThe six step guide to practical project management
The six step guide to practical project management
 
Beginners Guide to TikTok for Search - Rachel Pearson - We are Tilt __ Bright...
Beginners Guide to TikTok for Search - Rachel Pearson - We are Tilt __ Bright...Beginners Guide to TikTok for Search - Rachel Pearson - We are Tilt __ Bright...
Beginners Guide to TikTok for Search - Rachel Pearson - We are Tilt __ Bright...
 
Unlocking the Power of ChatGPT and AI in Testing - A Real-World Look, present...
Unlocking the Power of ChatGPT and AI in Testing - A Real-World Look, present...Unlocking the Power of ChatGPT and AI in Testing - A Real-World Look, present...
Unlocking the Power of ChatGPT and AI in Testing - A Real-World Look, present...
 
12 Ways to Increase Your Influence at Work
12 Ways to Increase Your Influence at Work12 Ways to Increase Your Influence at Work
12 Ways to Increase Your Influence at Work
 
ChatGPT webinar slides
ChatGPT webinar slidesChatGPT webinar slides
ChatGPT webinar slides
 
More than Just Lines on a Map: Best Practices for U.S Bike Routes
More than Just Lines on a Map: Best Practices for U.S Bike RoutesMore than Just Lines on a Map: Best Practices for U.S Bike Routes
More than Just Lines on a Map: Best Practices for U.S Bike Routes
 
Ride the Storm: Navigating Through Unstable Periods / Katerina Rudko (Belka G...
Ride the Storm: Navigating Through Unstable Periods / Katerina Rudko (Belka G...Ride the Storm: Navigating Through Unstable Periods / Katerina Rudko (Belka G...
Ride the Storm: Navigating Through Unstable Periods / Katerina Rudko (Belka G...
 
Barbie - Brand Strategy Presentation
Barbie - Brand Strategy PresentationBarbie - Brand Strategy Presentation
Barbie - Brand Strategy Presentation
 

CEUG: Introduction to OTP Behaviors, Part I - gen_server

  • 1. Intro to OTP Behaviours Presenters: John Patton and Tristan Sloughter
  • 2. What we’ll cover • Build concepts over the course of the presentation to create a general server architecture • Assumption: basic Erlang knowledge • We’ll have time for Q&A at the end
  • 3. What are we going to do? • Look at high-level concepts used in making a simple chat server • Start off using basic Erlang!!! • Let’s understand the concepts first • Build on top of concepts until we understand how a general server framework works under the hood
  • 4. Simple Chat Server What kind of things does a simple chat server need?
  • 5. Simple Chat Server What kind of things does a simple chat server need? • Startup routine • Server needs to be aware of the clients that are connected • Clients need to register and unregister with the server • The server needs to facilitate sending chat messages from one client to another • Shutdown routine
  • 6. What does our design look like? start stop register_client('john',Pid) register_client('tristan',Pid) Chat Chat Server Chat Client Client send_message('tristan',Msg) send_message('john',Msg) Client Lookup (dict) Client = atom() pid = pid() 'john' <0.35.0> 'tristan' <0.39.0>
  • 7. Basic Design client defined elsewhere chat_server chat_server chat_server ! {register_client, Name, Pid}. chat_server ! {send_message, To, Msg}. receive loop chat_server ! {unregister_client, Name}. {register_client,...} ... loop {unregister_client,...} {send_message,...} {stop,...} loop()
  • 8. Chat Server Receive loop • Our chat server’s loop function is spawned and registered chat_server • The chat server loop function will maintain the dictionary of clients (client name -> pid) receive loop {register_client,...} loop {unregister_client,...} • Traditional tail recursion, will run {send_message,...} {stop,...} until a stop message is received loop() • Messages sent from a client are handled within the receive loop
  • 9. Let’s organize startup start_link and initialization spawn • Create an initialization function to handle registering self() init ‘chat_server’ • Wrap the spawn inside a start_link function • receive loop Instead of spawning loop, let’s {register_client,...} spawn the init function and call loop {unregister_client,...} {send_message,...} loop {stop,...} loop()
  • 10. Where should we keep start_link track of our clients? spawn • Let’s make use of an internal state, a key-value dictionary init ‘chat_server’ • Init will be responsible for dict:new() creating the server’s State: {ClientName, ClientPID} State receive loop • {register_client,...} State will be passed into and loop {unregister_client,...} {send_message,...} maintained within the receive {stop,...} loop loop(State)
  • 11. Let’s look back at where we started client defined elsewhere chat_server chat_server chat_server ! {register_client, Name, Pid}. chat_server ! {send_message, To, Msg}. receive loop chat_server ! {unregister_client, Name}. {register_client,...} ... loop {unregister_client,...} {send_message,...} {stop,...} loop()
  • 12. Take a look at where we are. start_link spawn client defined elsewhere chat_server chat_server ! {register_client, Name, Pid}. chat_server ! {send_message, To, Msg}. init ‘chat_server’ chat_server ! {unregister_client, Name}. ! dict:new() ... State receive loop {register_client,...} loop {unregister_client,...} {send_message,...} {stop,...} loop(State)
  • 13. Let’s make it easier for the client to bang messages start_link spawn • “API” Functions in the chat_server module that a client can call init ‘chat_server’ register_client dict:new() State • unregister_client API functions facilitate ! loop receive loop {register_client,...} banging messages to the send_message {unregister_client,...} {send_message,...} {stop,...} server pid for the client stop loop(State) • Cleans up the code
  • 14. Let’s make a handler for banged messages start_link spawn • “Callback” functions in a module that will implement the init ‘chat_server’ register_client dict:new() message functionality State unregister_client • Turns message loop send_message ! loop receive loop {register_client,...} {unregister_client,...} into an interface {send_message,...} {stop,...} stop • Separates the loop(State) implementation from handle_receive the interface {Message, State} • terminate Callbacks update state
  • 15. Why use OTP? • Large collection of libraries • Unified Application packaging and release structure • Standardized coding practices • Components: HTTP and FTP server, CORBA ORB, SNMP Agent, IDL, Error Handling • Formalized design patterns into “behaviors”
  • 16. What is an OTP behavior? OTP Behavior • gen_*:functionA/3 • Simply: a formalization of a • gen_*:functionB/2 common pattern into two parts. ... • Behavior Module that defines the pattern interface. Callback Module • Callback Module that • module:callbackA/2 implements the pattern interface. • module:callbackB/3 ...
  • 17. Why use OTP for our server? • Much of the code needed to create the server in our example is already written in the OTP behavior: gen_server • Since the interface is only used to call a callback function, the callbacks can be in any module • The gen_server has a generic set of behavior functions available for use by ANY implementation (can use more than one callback implementation)
  • 18. Behavior: gen_server chat server gen_server ! callback chat_server:start_link gen_server:start_link callback:init/1 chat_server:send_message gen_server:call callback:handle_call/3 chat_server:register_client gen_server:multi_call chat_server:unregister_client chat_server:stop gen_server:cast callback:handle_cast/2 sends stop message returns: {stop, normal, State} callback:terminate/2 State is maintained here State is passed in and returned back here
  • 19. More Information • Client-server design principles: http://www.erlang.org/doc/design_principles/ gen_server_concepts.html • gen_server “behaviour”: http://www.erlang.org/doc/man/gen_server.html • Chicago Erlang Users Group: start a discussion! • Me: John Patton <jpatton@gmail.com>
  • 20. What happens if it crashes?

Editor's Notes

  1. Remove &amp;#x201C;OTP&amp;#x201D;: just say youre developing a framework for a general server arch
  2. I&apos;d move the 3rd bullet to second bullet, reword it without a specific gen_server reference, say we will build these concepts into a general framework, something like that.. then the 3rd bullet can be we will show erlang&apos;s already existing framework, and why to use it instead
  3. move the spawn and registering bit to slide 9 just focus on the loop first
  4. if you are going to use &quot;behavior&quot;, stick with it, otherwise just use &quot;behavior&quot; everywhere and not make a reference to its english counterpart Revisit verb tense on all bullets Much More: * A major objective of the OTP is to provide a highly productive environment for designing applications.
  5. so 16 is really good, just when you talk, make sure to refer back to your initial guiding example you started with A Behaviour Module is a generic collection of functions provided by OTP. Callback Module is an implementation of a pre-defined set of functions expected by the behaviour.
  6. Lead into Tristan&amp;#x2019;s presentation