Introduction to Erlang for the talk at the Programming Environments Meetup at the Centrum for Mathematics and Computer Science (CWI), December 14, 2012.
The document introduces GO and discusses why a consulting firm chose to build an instant messaging server using GO. It provides an overview of GO, including that it is a lightweight programming language developed by Google that uses garbage collection and makes concurrency easy using goroutines and channels. The document also provides code samples and discusses getting started with GO development.
Protocol buffers are a flexible, efficient, and automated mechanism for serializing structured data that is simpler, faster, smaller and generates access classes compared to XML and JSON. It works by defining message types in .proto files that can then be compiled to generate data access classes in various languages like Java, C++, Python and more. Many large companies like Google, Twitter and Oracle use protocol buffers for internal APIs, queue systems and database objects due to its performance advantages over other data formats.
This document discusses using Spring Boot and Kotlin together. It outlines some benefits of Kotlin like less verbosity and null safety compared to Java. It also discusses some common pitfalls when using JPA with Kotlin like needing no-arg constructors. Finally, it provides examples of where the speaker has used Spring Boot and Kotlin together like for streaming and CRUD applications.
This document provides an overview of the Ruby programming language, including:
- Ruby was influenced by Perl and created in 1993 by Yukihiro Matsumoto to have more scripting power than Perl and be more object-oriented than Python.
- Ruby is truly object-oriented, portable, has garbage collection, exception handling, and a syntactically simple design.
- Everything in Ruby is an object, including properties and actions, and there is no difference between expressions and statements.
- Ruby is very flexible, allowing users to freely alter its parts with open classes and the ability to change built-in methods and core classes.
The document discusses the principles and tactical tools of Domain-Driven Design (DDD). It describes DDD as a way to build a domain model focused on business concepts rather than data. The key aspects covered include:
- Using a ubiquitous language and bounded contexts to separate domains and ensure clear communication.
- Identifying the core domain and distilling it from supporting subdomains to focus modeling efforts.
- Tactical patterns like entities, aggregates, value objects, domain services, events, and repositories to structure the domain logic and persistence.
- Command Query Responsibility Segregation (CQRS) and event sourcing as effective ways to implement DDD by separating writes from reads and modeling state as events
CQL is a structured query language for Apache Cassandra that is similar to SQL. It provides an alternative interface to the existing Thrift API, with the goals of being more stable, easier to use, and providing a better mental model for querying and data. The document outlines the motivations for developing CQL, including limitations of the existing Thrift API, and provides details on CQL specification, drivers, and additional resources.
The document discusses growth and development. In a concise yet informative manner, it touches on the natural process of expanding and increasing in size over time through nourishment and care. While brief, it implies the importance of fostering growth through proper support and conditions.
The document introduces GO and discusses why a consulting firm chose to build an instant messaging server using GO. It provides an overview of GO, including that it is a lightweight programming language developed by Google that uses garbage collection and makes concurrency easy using goroutines and channels. The document also provides code samples and discusses getting started with GO development.
Protocol buffers are a flexible, efficient, and automated mechanism for serializing structured data that is simpler, faster, smaller and generates access classes compared to XML and JSON. It works by defining message types in .proto files that can then be compiled to generate data access classes in various languages like Java, C++, Python and more. Many large companies like Google, Twitter and Oracle use protocol buffers for internal APIs, queue systems and database objects due to its performance advantages over other data formats.
This document discusses using Spring Boot and Kotlin together. It outlines some benefits of Kotlin like less verbosity and null safety compared to Java. It also discusses some common pitfalls when using JPA with Kotlin like needing no-arg constructors. Finally, it provides examples of where the speaker has used Spring Boot and Kotlin together like for streaming and CRUD applications.
This document provides an overview of the Ruby programming language, including:
- Ruby was influenced by Perl and created in 1993 by Yukihiro Matsumoto to have more scripting power than Perl and be more object-oriented than Python.
- Ruby is truly object-oriented, portable, has garbage collection, exception handling, and a syntactically simple design.
- Everything in Ruby is an object, including properties and actions, and there is no difference between expressions and statements.
- Ruby is very flexible, allowing users to freely alter its parts with open classes and the ability to change built-in methods and core classes.
The document discusses the principles and tactical tools of Domain-Driven Design (DDD). It describes DDD as a way to build a domain model focused on business concepts rather than data. The key aspects covered include:
- Using a ubiquitous language and bounded contexts to separate domains and ensure clear communication.
- Identifying the core domain and distilling it from supporting subdomains to focus modeling efforts.
- Tactical patterns like entities, aggregates, value objects, domain services, events, and repositories to structure the domain logic and persistence.
- Command Query Responsibility Segregation (CQRS) and event sourcing as effective ways to implement DDD by separating writes from reads and modeling state as events
CQL is a structured query language for Apache Cassandra that is similar to SQL. It provides an alternative interface to the existing Thrift API, with the goals of being more stable, easier to use, and providing a better mental model for querying and data. The document outlines the motivations for developing CQL, including limitations of the existing Thrift API, and provides details on CQL specification, drivers, and additional resources.
The document discusses growth and development. In a concise yet informative manner, it touches on the natural process of expanding and increasing in size over time through nourishment and care. While brief, it implies the importance of fostering growth through proper support and conditions.
The document discusses different concurrent programming paradigms including single and multi-threaded applications, race conditions that can occur with shared memory between threads, using locks to prevent race conditions, the actor model which uses mailboxes and private state, and fork/join parallelism which breaks an application into parts processed concurrently and joined. It provides references for further reading on concurrency topics.
The document discusses the Ruby on Rails web application framework. It describes RoR's structure using the MVC pattern, with model, view and controller folders. It highlights RoR's emphasis on convention over configuration. Key features include built-in JavaScript libraries, scaffolding for rapid code generation, and the Rake task automation tool. The document also provides an overview of the Ruby programming language that RoR is built on.
Concurrency Programming in Java - 01 - Introduction to Concurrency ProgrammingSachintha Gunasena
This session discusses a basic high-level introduction to concurrency programming with Java which include:
programming basics, OOP concepts, concurrency, concurrent programming, parallel computing, concurrent vs parallel, why concurrency, real world example, terms, Moore's Law, Amdahl's Law, types of parallel computation, MIMD Variants, shared memory model, distributed memory model, client server model, scoop mechanism, scoop preview - a sequential program, in a concurrent setting - using scoop, programming then & now, sequential programming, concurrent programming,
The document discusses how to write scalable network servers that can handle high loads with many concurrent connections. It begins by providing some background on the author and why high performance network code is important. It then shows simple examples of a basic HTTP client and server implementation. The document discusses issues with the traditional approach of using one process per connection, including the high latency of forking processes and scheduling overhead with many processes. It presents benchmark results demonstrating the performance costs of forking. The document advocates avoiding the one process per connection model for scalability.
Erlang is a functional, concurrency-oriented, distributive, fault-tolerant programming language. It was designed for writing concurrent programs that "run forever" with a focus on fault tolerance through processes and message passing. Erlang uses processes, message passing, and distribution to enable concurrency and high availability.
Erlang Message Passing Concurrency, For The Winl xf
Erlang is a language and runtime designed for scalable and distributed systems. It uses message passing for concurrency between processes rather than shared memory. Processes in Erlang are very lightweight and can communicate asynchronously. Erlang supports features like hot code upgrading, distributed programming, and has built-in support for building fault-tolerant systems through its Open Telecom Platform (OTP) libraries. Popular applications and platforms built with Erlang include WhatsApp, RabbitMQ, and ejabberd due to its ability to handle high volumes of concurrent connections and messages.
Erlang - Concurrent Language for Concurrent WorldZvi Avraham
This document provides biographical information about Zvi Avraham, the founder and CEO of ZADATA Ltd. It then discusses concurrency-oriented programming (COP) and how it differs from object-oriented programming (OOP). COP focuses on processes rather than objects and emphasizes location transparency, isolation of processes without shared memory, and message passing between processes. The document outlines principles of COP like "share nothing" and "no mutable state." It discusses the Erlang programming language, which is designed for COP. Key aspects of Erlang covered include lightweight processes, distribution, fault tolerance, hot code reloading, and the BEAM virtual machine. Tools for Erlang like OTP, libraries, and debuggers are also
Concurrent Open Source Software Developmentartfulgeek
This document discusses concurrent open source software development. It examines concurrent development methodology from the perspective of open source software projects. Concurrent development involves simultaneous work by multiple developers, while open source refers to software that is openly developed and improved upon. The document also discusses version control tools like CVS that help facilitate concurrent changes to code by different developers.
This document discusses concurrency and threading in programming languages. It covers different levels of concurrency including machine instruction, statement, unit, and program levels. It also describes the evolution of multiprocessor architectures from single to multiple processors. Key aspects of concurrency discussed include physical vs logical concurrency, reasons for studying concurrency, task-level concurrency, and synchronization methods like semaphores and monitors. The document also provides an overview of threads in Java.
(Given to the Vancouver Erlang and Ruby/Rails Meetup groups on May 19, 2009.)
Erlang is an up-and-coming language on the web scene. New libraries and frameworks are sprouting up at a rampant rate, and web giants Facebook and Twitter are using it to develop highly-scalable web applications.
This talk will introduce Erlang as a language and platform, summarize its strengths and weaknesses, and cover how you can use Erlang and Ruby together to conquer the web frontier.
Speaker Bio:
Ken Pratt has been developing software for the web for over 10 years. He fell in love with Ruby four years ago, but is still passionate about learning other languages and platforms. He has developed scalable web services for Electronic Arts, built Rails-based web applications since pre-1.0, and been featured in interactive art installations.
Essa apresentação consiste em uma introdução à linguagem de programação Elixir desde a sintaxe ao ecossistema. Elixir é funcional, tem suporte a concorrência e paralelismo e tolerância a falhas, entre outras features.
Erlang 101 provides an overview of the Erlang programming language. It discusses Erlang's history and current status, key features like concurrency, distribution, and fault tolerance. These features make Erlang well-suited for building large, distributed, highly-available systems. Examples are given of companies using Erlang like Amazon, Facebook, Twitter, and of applications and frameworks built with Erlang like Apache CouchDB, RabbitMQ, and Riak. Resources for learning more about Erlang are also provided.
This document discusses stateful applications in Elixir. It provides examples of stateful applications like ExVenture, a MUD server, and Grapevine, a MUD community site. The document reviews why stateful applications may be useful in Elixir due to its ability to handle soft real-time capabilities, reduce database queries through caching, and make websites feel "alive". However, stateful applications also require more complex architectures using tools like OTP, come with cache management challenges, and are harder to deploy at scale. The presentation provides an overview of building blocks like GenServers, supervision trees and ETS for stateful applications in Elixir.
Web scraping is mostly about parsing and normalization. This presentation introduces people to harvesting methods and tools as well as handy utilities for extracting and normalizing data
The document provides an overview of the Go programming language including its guiding principles, syntax, concurrency model, and examples of usage. It discusses that Go was created at Google in 2007 to have better support for concurrency and scalability compared to other languages. It emphasizes simplicity, readability, and minimalism in design. Go uses goroutines and channels for concurrency where goroutines are lightweight threads and channels allow goroutines to communicate without shared memory. Examples demonstrate basic syntax, goroutines, and using channels for patterns like ping-pong.
Performance optimization techniques for Java codeAttila Balazs
The presentation covers the the basics of performance optimizations for real-world Java code. It starts with a theoretical overview of the concepts followed by several live demos
showing how performance bottlenecks can be diagnosed and eliminated. The demos include some non-trivial multi-threaded examples
inspired by real-world applications.
An overview of how recent changes in technology have changed priorities for databases to distributed systems, and how you can preserve consistency in distributed data stores like Riak.
This document introduces functional programming concepts using the Elixir programming language. It summarizes that Elixir is a dynamic and functional language that runs on the Erlang VM and is designed for fault tolerance and distribution. It emphasizes immutable state, recursion over loops, and passing functions as first-class citizens. The document provides examples of communication between processes, static and dynamic typing in Elixir, and building fault-tolerant applications using supervisors. It encourages learning Elixir through patience and finding the right learning method.
Threads and processes are abstractions of execution units that differ in how they share resources. The key differences are that threads share memory and file descriptors by default, while processes do not. Underneath, both are created using the clone() system call but with different flags. Whether to use threads or processes depends on the specific workload and how system calls like malloc(), read/write, and setreuid() are implemented at the OS level. Understanding these implementation details is important for choosing the best approach.
The document discusses different concurrent programming paradigms including single and multi-threaded applications, race conditions that can occur with shared memory between threads, using locks to prevent race conditions, the actor model which uses mailboxes and private state, and fork/join parallelism which breaks an application into parts processed concurrently and joined. It provides references for further reading on concurrency topics.
The document discusses the Ruby on Rails web application framework. It describes RoR's structure using the MVC pattern, with model, view and controller folders. It highlights RoR's emphasis on convention over configuration. Key features include built-in JavaScript libraries, scaffolding for rapid code generation, and the Rake task automation tool. The document also provides an overview of the Ruby programming language that RoR is built on.
Concurrency Programming in Java - 01 - Introduction to Concurrency ProgrammingSachintha Gunasena
This session discusses a basic high-level introduction to concurrency programming with Java which include:
programming basics, OOP concepts, concurrency, concurrent programming, parallel computing, concurrent vs parallel, why concurrency, real world example, terms, Moore's Law, Amdahl's Law, types of parallel computation, MIMD Variants, shared memory model, distributed memory model, client server model, scoop mechanism, scoop preview - a sequential program, in a concurrent setting - using scoop, programming then & now, sequential programming, concurrent programming,
The document discusses how to write scalable network servers that can handle high loads with many concurrent connections. It begins by providing some background on the author and why high performance network code is important. It then shows simple examples of a basic HTTP client and server implementation. The document discusses issues with the traditional approach of using one process per connection, including the high latency of forking processes and scheduling overhead with many processes. It presents benchmark results demonstrating the performance costs of forking. The document advocates avoiding the one process per connection model for scalability.
Erlang is a functional, concurrency-oriented, distributive, fault-tolerant programming language. It was designed for writing concurrent programs that "run forever" with a focus on fault tolerance through processes and message passing. Erlang uses processes, message passing, and distribution to enable concurrency and high availability.
Erlang Message Passing Concurrency, For The Winl xf
Erlang is a language and runtime designed for scalable and distributed systems. It uses message passing for concurrency between processes rather than shared memory. Processes in Erlang are very lightweight and can communicate asynchronously. Erlang supports features like hot code upgrading, distributed programming, and has built-in support for building fault-tolerant systems through its Open Telecom Platform (OTP) libraries. Popular applications and platforms built with Erlang include WhatsApp, RabbitMQ, and ejabberd due to its ability to handle high volumes of concurrent connections and messages.
Erlang - Concurrent Language for Concurrent WorldZvi Avraham
This document provides biographical information about Zvi Avraham, the founder and CEO of ZADATA Ltd. It then discusses concurrency-oriented programming (COP) and how it differs from object-oriented programming (OOP). COP focuses on processes rather than objects and emphasizes location transparency, isolation of processes without shared memory, and message passing between processes. The document outlines principles of COP like "share nothing" and "no mutable state." It discusses the Erlang programming language, which is designed for COP. Key aspects of Erlang covered include lightweight processes, distribution, fault tolerance, hot code reloading, and the BEAM virtual machine. Tools for Erlang like OTP, libraries, and debuggers are also
Concurrent Open Source Software Developmentartfulgeek
This document discusses concurrent open source software development. It examines concurrent development methodology from the perspective of open source software projects. Concurrent development involves simultaneous work by multiple developers, while open source refers to software that is openly developed and improved upon. The document also discusses version control tools like CVS that help facilitate concurrent changes to code by different developers.
This document discusses concurrency and threading in programming languages. It covers different levels of concurrency including machine instruction, statement, unit, and program levels. It also describes the evolution of multiprocessor architectures from single to multiple processors. Key aspects of concurrency discussed include physical vs logical concurrency, reasons for studying concurrency, task-level concurrency, and synchronization methods like semaphores and monitors. The document also provides an overview of threads in Java.
(Given to the Vancouver Erlang and Ruby/Rails Meetup groups on May 19, 2009.)
Erlang is an up-and-coming language on the web scene. New libraries and frameworks are sprouting up at a rampant rate, and web giants Facebook and Twitter are using it to develop highly-scalable web applications.
This talk will introduce Erlang as a language and platform, summarize its strengths and weaknesses, and cover how you can use Erlang and Ruby together to conquer the web frontier.
Speaker Bio:
Ken Pratt has been developing software for the web for over 10 years. He fell in love with Ruby four years ago, but is still passionate about learning other languages and platforms. He has developed scalable web services for Electronic Arts, built Rails-based web applications since pre-1.0, and been featured in interactive art installations.
Essa apresentação consiste em uma introdução à linguagem de programação Elixir desde a sintaxe ao ecossistema. Elixir é funcional, tem suporte a concorrência e paralelismo e tolerância a falhas, entre outras features.
Erlang 101 provides an overview of the Erlang programming language. It discusses Erlang's history and current status, key features like concurrency, distribution, and fault tolerance. These features make Erlang well-suited for building large, distributed, highly-available systems. Examples are given of companies using Erlang like Amazon, Facebook, Twitter, and of applications and frameworks built with Erlang like Apache CouchDB, RabbitMQ, and Riak. Resources for learning more about Erlang are also provided.
This document discusses stateful applications in Elixir. It provides examples of stateful applications like ExVenture, a MUD server, and Grapevine, a MUD community site. The document reviews why stateful applications may be useful in Elixir due to its ability to handle soft real-time capabilities, reduce database queries through caching, and make websites feel "alive". However, stateful applications also require more complex architectures using tools like OTP, come with cache management challenges, and are harder to deploy at scale. The presentation provides an overview of building blocks like GenServers, supervision trees and ETS for stateful applications in Elixir.
Web scraping is mostly about parsing and normalization. This presentation introduces people to harvesting methods and tools as well as handy utilities for extracting and normalizing data
The document provides an overview of the Go programming language including its guiding principles, syntax, concurrency model, and examples of usage. It discusses that Go was created at Google in 2007 to have better support for concurrency and scalability compared to other languages. It emphasizes simplicity, readability, and minimalism in design. Go uses goroutines and channels for concurrency where goroutines are lightweight threads and channels allow goroutines to communicate without shared memory. Examples demonstrate basic syntax, goroutines, and using channels for patterns like ping-pong.
Performance optimization techniques for Java codeAttila Balazs
The presentation covers the the basics of performance optimizations for real-world Java code. It starts with a theoretical overview of the concepts followed by several live demos
showing how performance bottlenecks can be diagnosed and eliminated. The demos include some non-trivial multi-threaded examples
inspired by real-world applications.
An overview of how recent changes in technology have changed priorities for databases to distributed systems, and how you can preserve consistency in distributed data stores like Riak.
This document introduces functional programming concepts using the Elixir programming language. It summarizes that Elixir is a dynamic and functional language that runs on the Erlang VM and is designed for fault tolerance and distribution. It emphasizes immutable state, recursion over loops, and passing functions as first-class citizens. The document provides examples of communication between processes, static and dynamic typing in Elixir, and building fault-tolerant applications using supervisors. It encourages learning Elixir through patience and finding the right learning method.
Threads and processes are abstractions of execution units that differ in how they share resources. The key differences are that threads share memory and file descriptors by default, while processes do not. Underneath, both are created using the clone() system call but with different flags. Whether to use threads or processes depends on the specific workload and how system calls like malloc(), read/write, and setreuid() are implemented at the OS level. Understanding these implementation details is important for choosing the best approach.
Distributed Erlang systems aim to be decentralized, distributed, homogeneous, and fault tolerant. Nodes use only local data and there is no global state or reliance on physical time. Cluster membership is handled through a configuration file or gossip protocol. Load balancing uses techniques like consistent hashing. Liveness is checked through Erlang tools and custom mechanisms. Soft state through gossip protocols can provide an alternative to global state. Shipping code embedded in a runtime and upgrading through reboots helps manage distributed systems.
This document discusses the benefits of using the Erlang programming language and its Open Telecommunications Platform (OTP) for building reliable server applications and services. It highlights key aspects of Erlang such as process isolation, easy process spawning and supervision, lightweight virtual machine, and built-in tools for debugging and hot code loading. Erlang processes are similar to operating system processes and can fail independently without bringing down the whole system. The OTP framework in Erlang provides behaviors and tools for declaring restart rules to automatically recover from failures without operator intervention.
This document discusses concurrent programming concepts in Elixir such as processes, messages, and supervision trees. It provides code samples of processes maintaining state using tail recursion and receiving messages. It also describes some OTP behaviors like GenServer and Supervisor that implement common patterns to make complex tasks simpler. The document references some Elixir apps built using these concepts.
Benchmarks, performance, scalability, and capacity what s behind the numbers...james tong
Baron Schwartz gave a presentation on analyzing database performance beyond surface-level metrics and benchmarks. He discussed how ideal benchmarks provide full system specifications and metrics over time to understand response times and throughput. Little's Law and queueing theory can predict concurrency, response times, and capacity given arrival rates and service times. While tools like Erlang C model queues, the assumptions must be validated. True scalability is nonlinear due to bottlenecks, and debunking performance claims requires examining raw data.
Benchmarks, performance, scalability, and capacity what's behind the numbersJustin Dorfman
Baron Schwartz gave a presentation on analyzing database performance beyond surface-level metrics and benchmarks. He discussed how ideal benchmarks provide full system specifications and metrics over time to understand response times and throughput. Little's Law and queueing theory can predict concurrency, response times, and capacity given arrival rates and service times. While tools like Erlang C model queues, the assumptions must be validated. True scalability is nonlinear due to bottlenecks, and debunking performance claims requires examining raw data.
Linux provides powerful multiplexing capabilities through file descriptors and APIs like epoll. Multiplexing allows a single thread to handle multiple I/O operations simultaneously. File descriptors can represent network sockets, pipes, timers, signals and more. The epoll API in particular provides efficient waiting on large numbers of file descriptors in kernel space. This allows applications to achieve high concurrency with fewer threads than alternative approaches like multi-threading.
Speeding up Page Load Times by Using StarlingErik Osterman
The document discusses how using a queue server like Starling can provide faster response times compared to directly writing a large amount of data to a database. With Starling, jobs are added to a queue instead of writing directly to the database. A batch processor then quickly runs the jobs from the queue to write the data asynchronously. This avoids slowing down responses by throttling write requests. Starling is lightweight, fast, and easy to implement and scale compared to alternatives like increasing database resources or using replication.
- There are different architectures for web servers that result in variations in performance and resource usage, including:
- Single-process, single-threaded architecture that can only handle one request at a time. Not used in production.
- Multiple process, one thread per process architecture where each process handles one request. Uses more RAM than multi-threaded.
- Multiple threaded architecture where a process distributes requests to a thread pool, allowing for more concurrency limited only by thread pool size.
- Event-based architectures provide an alternative to threads by manually handling context switches in an event queue, allowing for more parallelism than threads. Technologies like Nginx and Node.js use this model.
The document is a presentation about the Elixir programming language. It introduces Elixir and some of its key features such as being fault tolerant, using an agent-based model, and enabling high scalability. It also discusses how Elixir was influenced by Erlang but adds new capabilities like metaprogramming and protocol-based polymorphism. Additional resources on Elixir are provided for more information.
Similar to Erlang: Software for a Concurrent world (20)
The document discusses a case study of rewriting the architecture of a dance matching app called DuoDisco using the Erlang programming language. Originally the app had issues with race conditions and debugging complex interactions between connected players. By modeling each player as an Erlang process and using processes to represent rooms and matchmaking, the rewritten app in Erlang had no more bugs. The presenter advocates using the right tools like Erlang for concurrency and fault tolerance when needed.
Talk given at the Erlang User Conference, june 2013, Stockholm, about the performance of Zotonic, the Erlang Web Framework and CMS.
It highlights Zotonic's architecture, performance charts and provides a glimpse into the future of this web development framework.
Zotonic is a content management system built with Erlang. It aims to maximize hardware usage, be frontender friendly, and allow sites to hit the ground running. The tutorial demonstrates building a portfolio site with Zotonic, including creating project categories, templates, lists, forms, and integrating with the notification system. Attendees are encouraged to experiment with the open source code and talk to the presenters.
This document provides an overview and introduction to developing Android applications. It discusses the speaker's background in computer science and independent software development. It then describes the core components of the Android system, including activities, views, intents, services, and notifications. It outlines how to install the Android SDK and Eclipse development environment. Finally, it proposes creating a sample Snake game as a tutorial for getting started with Android application development.
The document summarizes physical computing with Android and the IOIO board. It introduces physical computing as building interactive physical systems using software and hardware to sense and respond to the physical world. It describes the IOIO board, which provides 48 input/output pins and allows Android apps to control electronics. Examples of projects built with the IOIO board are also mentioned, such as a robot and an autonomous RC car. Setup and getting started instructions for the IOIO board are provided.
Zotonic presentation Erlang Camp Boston, august 2011Arjan
I gave this presentation on friday August 12, 2011 in the John Hancock Conference center in Boston as the closing session of the 2-day Erlang Camp event.
The first presentation in the "Mediamatic Night Lab" series. This presentation is about the Open-CI network and its use of open web standards to create a network of sites which are connected and feature content sharing, transparent actions and inter-site login using OpenID and OAuth.
38. Performance
● Processes are cheap
● Data copying is expensive
● Handle much of request in single process
● Cache locally in process dict
● Reduce size of messages
● Bigger binaries (> 64 bytes) are shared and reference
counted, make use of them.
● String processing is expensive
● Keep eye on process inboxes
39. Garbage Collection
● per process, no global gc sweep = no locking
of vm
● can specify per-process initial heap size
● prevent big GCs
● keep big data outside process
● or in process dict
● large binaries = external, use refcounting
40. Common Pitfalls
● Message inbox overflowing
● Atom table injection / crash
● VM tweaks needed for
– nr of open file descriptors
– nr of processes
– heap size