The keynote will be about the two approaches used for software development today. Either as large (LARGE) projects with a lot of organization and lots of people (sometimes hundreds) using standard technology (C++, Java, UML etc), or by a small (SMALL) number of highly competent people using advanced technology (Erlang, Haskell, OCaml etc).
There are cases where LARGE may be necessary, for example in developing software for cellular (mobile) base stations. But for a lot of cases, the SMALL approach is both cheaper and faster. If you look at the presentations at Erlang user conferences/factories, you see that all applications described use the SMALL approach. The LARGE approach will inevitably result in outsourcing software development to countries where labor costs are cheaper, we see already that companies like IBM and Ericsson do a lot of their software development in India and China. If we want to keep a vibrant software development (programming) business in the West (North America and Western Europe) we need to exploit the SMALL approach and also expand it to areas where the LARGE approach is used today. In other words, we need technologies such as Erlang and highly skilled and competent people to exploit them.
Within the last year, the two dominant US mobile operators have eclipsed 100 million subscribers. Along with this honor comes a host of technology issues ideally suited for Erlang-based solutions.
This talk will explore the perfect storm of opportunity in the mobile industry (and others) including barriers to entry, paths to success, and an extrapolative perspective on where carrier ecosystems are heading. Expect a talk that is devoid of Erlang code examples and laden with anecdotes of why the "best" technology doesn't always win, all while remaining generally optimistic on the prospects of an Erlang-centric future.
Thanks to utility computing providers such as Amazon EC2, the basic infrastructure for processing Big Data is available to everyone. Whereas earlier it was critical to design the software so that it would not hit limits of your infrastructure, now the software needs to avoid hitting your credit limit.
In this talk, we will tell how and why we have used Erlang to build Bitdeli, a new backend service for data-intensive web applications. A key design goal was to make the system extremely cost-efficient without sacrificing scalability or latency. This required a language that can cope with a rapidly changing environment, which made Erlang a natural choice for the job.
We'll walk through the tradeoffs and design decisions made when building a Redis Server Clone in Erlang. We're using leveldb as the backend, so we'll talk about how that choice affects ultimate performance goals. There are not appropriate sorted set structures in Erlang so we have to build those and we'll talk in detail about those objects. These issues will lead into a discussion about performance of Redis and Edis, so we'll show some benchmarks and talk about the tradeoffs. Finally, we'll talk about production system deployment, and how we've used Edis in the production environment.
Microbenchmarks are notoriously bad at predicting overall performance, but running experiments with actual production code using alternative implementations for key algorithms can identify expected performance improvements if the comparisons are executed relative to each other in the same environment. I show how to use YAWS, HTML5 and d3.js to dynamically graph the benchmark performance of erlang code. The goal is to make it easy for a contributor to demonstrate an improvement to your code and convince you to accept a pull request.
Some of you are in businesses that generate - possibly vast amounts of - data as part of your regular operations, quite a bit of which is used by your customers in one form or the other. As your business scales, an issue that you will almost certainly face is that of data latency and consistency degradation. To put it differently, the speed of access to, and reliability of your data will decrease, causing you and your customers quite a bit of pain and suffering.
In this talk, we will explore this issue in detail. In particular, we will focus on how an erlang-based infrastructure can ease your pain at scale, and help keep your customers - happily - in the loop.
Data-parallel processing frameworks are being introduced at a fast pace and Erlang seems to be particularly well suited to soft real-time applications with high level of data parallelism and processing concurrency where reliability is important. With increased memory size and multi-core computing capabilities of modern processors and introduction of high-performance persistent storage, Erlang covers increasing portions of response time-data volume chart and complements very well existing large-scale analytics platforms like Hadoop.
This talk aims at presenting a case for building soft real-time, scalable data-parallel processing pipelines in Erlang.
We present architecture and simple specification language for building data-parallel flows in Erlang and share use cases covering data-parallel methods such as map-reduce and iterative graph algorithms to illustrate flexibility of the proposed approach. We discuss other important elements of the architecture such as capacity planning for typical use cases, relationship with other ecosystem components, instrumentation and monitoring, scheduling, replication and failover.
With the power provided by Erlang/OTP, developing complex distributed systems is easier than ever. However, verifying the correctness of these complex systems remains a challenge. This talk will present an approach to testing that I have used at Basho which leverage's QuviQ's QuickCheck. I will present how to build a system model in QuickCheck to test an early-stage idea against random orderings of client events and server state transitions. Then, how the model can be converted into the actual intended product code. And finally, how unit tests and system tests can be extracted from the original model, with the system tests leveraging a QuickCheck harness that deploys and runs command sequences against a cluster of multiple Erlang VMs. I will also present preliminary details about integrating the Concuerror tool into this approach, as well as thoughts on generating Coq proof scripts from the original Erlang model.
"Tracking application metrics is pivotal to knowing what your applications are doing at any point in time. Folsom is a library to help developers track these details through various metric types and powerful statistical functions. This talk will cover details on metrics collection and exporting in general as well as how to get started with Folsom and Folsom Webmachine."
Couchbase Server provides a simple, distributed document store. Written in a combination of Erlang using components of OTP for clustering and supervision alongside some C/C++, Couchbase Server manages the distribution of documents across a cluster of commodity hardware allowing for indexing of these documents and analytics through views. The system is accessible from nearly any programming language or through one of two open protocols: HTTP and memcached protocol.
This session will be a case study in designing and building this distributed, document oriented database. Couchbase ran into challenges with understanding where performance bottlenecks were in the system, for which Couchbase's Dustin Sallings contributed new DTrace probes to the common Erlang VM. Using these probes, Dustin and the Couchbase team were able to identify and correct bottlenecks in the system. Since then, Dustin and others in the Erlang community have collaborated to enhance Erlang observability. Couchbase also had to overcome some challenges in trying to cluster the system to ever larger groups of computers with Erlang/OTP. The Couchbase team has been able to overcome these challenges with careful separation of cluster management from data management processing and careful attention to how OTP is used in the system.
In this session, Dustin and Matt will cover these topics, sharing what has worked and where the challenges were in bringing Couchbase Server together. Couchbase Server has it's roots in both the Apache CouchDB project and the Membase project.
Today's applications are often web applications. And the ones who aren't usually include not only an HTTP server, but a complex interface to access all the components of the underlying application. All this in realtime.
Farwest is a new web development platform that allows you to painlessly build realtime web applications. It is designed to allow a clean separation of concerns, allowing an Erlang developer to only worry on the backend, and a frontend developer to never have to look at Erlang code.
Farwest packs many great libraries and mechanisms to cut down the amount of code you need to write. It's entirely built on REST principles and all existing Farwest code can be used as a REST API out of the box. It also brings Erlang's upgrade management to the frontend, allowing you to fully upgrade both server and client-side of your web application in a single step.
The Erlang/OTP programming model and framework is a boon to developers trying to build robust, scalable servers. Immutable data structures, lightweight processes and message passing in lieu of shared state all encourage healthy server designs with predictable operational characteristics.
Cloudant builds and operates a global network of database servers based on a heavily customized flavor of Apache CouchDB called BigCouch. I'll provide a view of our Data Layer through an Erlang/OTP lens and show how various pieces of the stack -- from the storage subsystem up to global data replication -- mirror the essential elements of a typical Erlang application.
The Boston Globe launched its new subscription site at BostonGlobe.com using advanced techniques of Responsive Design and aspects of HTML 5 to optimize the device for as many screen sizes as possible. In the process, the development team chose Erlang to build its My Saved feature, which allows users to save stories to a queue for reading later or when offline. Moriarty will talk about the overall strategy, why they chose Erlang and Mnesia as the foundation and what they are planning next.
Parse transformations is one of those techniques that is generally either loved or hated. They are a fantastic weapon but used carelessly can shoot you in the foot. But the only way to learn using such weapons carefully is to master them first.
An explanation of mechanics will be given, and some tricks & libraries that simplify the whole job of writing parse transformations will be shown. A few existing parse transformations (such as SeqBind and Exportie) will be explained and some other usage ideas will be discussed.
The cloud, and especially Amazon, has raised the bar for systems administration and large-scale systems architecture. In this talk I will go through how we have used Erlang’s location transparency features to manage clusters of machines on using EC2 and rightscale.
Software Defined Networks (SDN) is one of the hot topics in the networking industry these days. SDN is a radical change in the way networking is approached today. SDN brings the whole software development eco system close the network forwarding elements like switches and router. SDN enables the operators to integrate all the network resources and aspect into the application domain. The network virtualization will follow the computer virtualization.
By defining a vendor agnostic API (OpenFlow) to program the behavior of a whole network or network segment. This specification enables the software industry to quickly deliver new architectures, standards, functionalities and applications running on top of every OpenFlow enabled network.
FlowER is an open-source Erlang based OpenFlow controller. Its purpose is to provide a simplified platform for writing network control software in Erlang. While still under heavy development, FlowER is the basis for Travelping next generation products and already in use in selected projects.
This talk will give an introduction to SDN, OpenFlow and how Erlang and FlowER can help you to get some spring fever in to your network.
Chango is an online advertising company that pioneered a technique called Search Retargeting. Our systems look at about 10 billion records / day which means we need a fast and effective way of analyzing our data. In our search for a better Map/Reduce framework we found Disco, an Erlang/Python based Map/Reduce framework that's small, fast, elegant, understandable. We needed a way to tame the power of Disco and that's when we came up with the Inferno project which takes even more complexity out of Map/Reduce. With Inferno you concentrate about what you want from your data by letting it take care of all the underlying Map/Reduce complexity.
The hypothesis behind DevOps is that production and deployment risks decrease when Development understands the impact their code has on operations, and when Operations understands how the software was developed and why a new version has to be deployed. DevOps improves an IT organization’s collaboration, coordination, and management of releases by establishing best practices and automating processes. Decreasing deployment risks makes it possible to increase the speed in which new software can be deployed, thereby improving the business' overall agility.
But, the staff must still rely on traditional infrastructure operation visualization and analysis tools, and employ ad hoc, manually intensive processes in order identify anomalies, respond to failures, and keep the infrastructure operational day-to-day. This talk will explore ways to make better use of infrastructure “Big Data” to increase IT uptime, decrease total costs of ownership, and keep CIOs and their teams off the hot seat.
The Erlang runtime system includes an extensive set of primitive functions for observing a running application. Having this capability available both during the development and throughout the whole lifetime of an application is one of the great advantages of using Erlang/OTP. We believe that there is lots of room for improving the current set of desktop and web based tools building on this capability. In doing so we hope to make life easier for developers who're just getting started with Erlang as well as more experienced developers looking to improve their understanding of an application.
In this talk we want to present a data collection application building on the tracing and error reporting capabilities in the erlang runtime system as well as the open source library folsom by Joe Williams. We also want to present a web application for controlling and presenting the data collected from one or more running Erlang nodes.
Distributed systems aren't limited to the world of computing. Companies and communities, for example, are also distributed networks of resources. In this talk, we'll take a high-level look at computers, companies, and communities as distributed systems and examine why maintaining their health is crucial if they are to scale.
Refactoring is the process of changing the design of a program without changing its behaviour. Many refactoring tools have been developed for various programming languages; however, their support for composite refactorings – refactorings that are composed from a number of primitive refactorings – is limited. In particular, there is a lack of powerful and easy-to-use frameworks that allow users to script their own large-scale refactorings efficiently and effectively.
This paper introduces the domain-specific language framework of Wrangler – a refactoring and code inspection tool for Erlang programs – that allows users to script composite refactorings, test them and apply them on the fly. The composite refactorings are fully integrated into Wrangler and so can be previewed, applied and ‘undone’ interactively.
As a part of the presentation there will be a demonstration of the DSL in action, showing how complex refactorings can easily be described using the language, which is itself embedded in Erlang. This demonstration will include a set of refactorings designed to eliminate "bug preconditions" in Erlang models for components, as well as the Wrangler mechanism for synthesising API migration refactorings, illustrated by the example of moving from the regexp to the re library for regular expressions in Erlang/OTP.
More and more things will be connected in order to make our lives and our businesses more efficient and more enjoyable. But while some people are creating big data clusters, The Refuge projetc wants to build a platform that will allow you to connect data endpoint and use datas in a distributed and decentralized manner.
The refuge data platform is fully written in Erlang (with some C) and is embedding Apache CouchD as the primary data storage.
The open source application magicbeam contains a variety of functionality which has been used at the ExactTarget Social Media Lab. We find it helps to ensure we are developing a robust OTP system. The core functionality allows us to easily deploy software without having to implement the full OTP release handling process. The full functionality of magicbeam is useful for both production and development environments differing only in how lucky a DevOps engineer feels.
Modern cars are full of software, with 50-100 processors and tens of millions of lines of code. Increasingly, this software is based on the AUTOSAR standard, drawn up by a consortium including Toyota, Ford, GM, and most of the world's other major car manufacturers. AUTOSAR defines the "basic software" which should run on each processor, providing a standardised environment enabling AUTOSAR applications to be distributed freely around the processors in the car.
Such is the theory. In practice, the basic software is supplied by
multiple vendors, and follows the standard to a greater or lesser degree. Mixing software from different vendors can lead to unexpected failures as a result. For the last year Quviq has been working with Volvo to model AUTOSAR basic software components using Erlang, and test them for compliance using QuickCheck. I'll present some of the challenges and results--which may help make your car more reliable in the future!
The Swedish payment solution provider Klarna has grown from three founders to over 600 employees in seven years. The customer base has grown from zero to 14.000 connected e-stores and almost ten million end users.
To grow at this rate, currently one new employee every second day, brings tremendous demands on scalability.
Obviously the technical solution has to scale with the increased user load, but the process and the people in the organisation need to scale as well.
This talk will draw on the experiences from Klarna's journey so far with a focus on scaling people and processes, but it will also touch on some technical challenges and choices.
Erik will share some anecdotes from a business in rapid growth and sprinkle the presentation with tips of dos and don'ts when scaling your development and operation.
Riak and Erlang are being extended to push the boundaries of scalability and reliability in the Cloud. Because of this, some of the world's largest companies are relying on Riak and Erlang to build resilient cloud storage services. This talk will cover the approach Riak takes to distributed, reliable cloud storage, with a focus on long-running production deployments and applicability to real-world scenarios.
ErlangPro is a way to facilitate the Erlang development and to extend the capabilities of applications written in Erlang and operated in various target distributed environments. Being the new form of packaging and deployment of Erlang-based software products, it is at the same time a new deployment and maintenance strategy for distributed solutions, which enables single-image solution delivery and single console monitoring, management and control for virtually any-size installations. ErlangPro's development environment creates an isolation layer between application and operating system, provides easy access to high variety of development tools, automates packaging custom software components with Erlang/OTP and the process of generating of the virtual appliances.
Let's take a moment and think about a world without Linux. Your Internet search, your social networking company, you mobile phone os, your ecommerce provider. Where would we -- and they -- be without Linux? What were the critical defining moments that contributed to the foundation of Linux and its establishment as the underpinning of so much of our economy and culture. Jim Zemlin will discuss the cross points of Linux and Erlang and how both are contributing to the advancement of technology in key segments that are making this world WITH Linux and open source software an amazing place to be.
Patrik gives an update of the Erlang/OTP team's work at Ericsson - their current projects and plans for future.
One of the most common reasons why people choose Erlang is to build highly scalable systems. And Erlang does a great job helping developers reach those goals. But creating a scalable web system is not a matter of just writing it in Erlang. In this talk I will create a sample web project and I'll show several tricks ant tactics to make it scale from 1K to 100K clients.
Erlang is perfectly suited for a modern distributed world. Part of this world is also a relatively new kind of client/server paradigm, namely Peer-to-Peer communication. We believe that this kind of communication is important to the modern internet and hence, the eTorrent project was born to gauge the usefulness of Erlang in a heavily distributed Peer-to-peer setting.
This talk is about using Erlang for implementing Peer-to-Peer clients. I claim Erlang made us write an efficient BitTorrent client in a fraction of the effort compared to other clients. I claim our client is more robust than the competition for normal operation. And I claim the Erlang mentality fits the Peer-to-Peer model well. I also explain how we utilize the Erlang platform to implement the client in an OTP-idiomatic way, and how we differ from the mainstream implementations.
This talk will describe the architecture, design decisions, and the current implementation and performance of ErLLVM. ErLLVM is an extension of the HiPE native code compiler of Erlang/OTP that uses the Low Level Virtual Machine (LLVM) compiler infrastructure as a back-end. As such, it benefits from the set of existing components and low-level optimizations that LLVM provides. More importantly, it is in principle readily
available on all platforms that LLVM supports.
ErLLVM is a full system currently available as open-source and has been tested on x86 and x86_64 based machines running Linux. It supports the complete Erlang language and to the best of our knowledge is robust enough for others to try. We welcome user feedback and extensions!
This talk wants to sum up the experience of designing, deploying and maintaining an Erlang application targeting the cloud and precisely AWS as hosting infrastructure.
As the application now serves a significantly large user base with a sustained throughput of thousands of games actions per second we're able to analyse retrospectively our engineering and architectural choices and see how Erlang fits in the cloud environment also comparing it to previous experiences of clouds deployments of other platforms.
We'll discuss properties of Erlang as a language and OTP as a framework and how we used them to design a system that is a good cloud citizen. We'll also discuss topics that are still open for a solution.
e2 is a light weight library that simplifies development of correct OTP applications. It improves developer productivity by eliminating boilerplate code and clarifying important concepts that are often lost in OTP's complexity.
Many view OTP as an advanced topic, to be used only after a developer has mastered lower level Erlang concepts. e2 simplifies the use of OTP to the point where it's no longer "advanced" or complex.
Some have called e2 "OTP on rails".
e2 was born from the speaker's experience teaching OTP fundamentals at ErlangCamp and his work with new Erlang developers at CloudBees. e2 is running in production in a variety of organizations and is a proven accelerator for learning Erlang and building correct applications.
Two years ago Rackspace had a problem: how do we backup 20K network devices, in 8 datacenters, across 3 continents, with less than a 1% failure rate -- every single day? Many solutions were tried and found wanting: a pure Perl solution, a vendor solution and one in Ruby, but none worked well enough. They were not fast enough, not reliable enough or they were not transparent enough when things went wrong. After re-examining the problem we decided to rewrite critical portions of the Ruby application in Erlang. This solution was a huge success. In this talk we'll get down and dirty with the details: why the solution was so successful as well as the prob
When advertisers want to buy advertisement, they can do it at large on some user group and hope to get decent results, or participate in Real Time Bidding (RTB). In RTB, advertisers bid on individual advertisement spaces to obtain more targeted audiences. This is usually built on the backbone of large exchanges where bidders require high performance, short response times, and a high volume.
BLOOM 's AdGear platform is a service offering (along other things) a unified interface that offers media buying capability over ad exchanges, as well as traditional third-party ad delivery and trafficking. An Erlang gateway is used to route dozens of thousands of queries per second from and to exchanges and ad agencies.
In this talk, we explain why we chose Erlang, and give insights in our design and architecture, including things that were learnt while developing it, chases for bottlenecks and glory.
Commonly-used patterns of parallel computation, communication, and interaction provide a high-level parallel programming methodology which allows the conceptual description of parallel programs whilst fostering platform independence and algorithm abstraction. This talk presents some trends in parallel patterns for CPU/GPU architectures to enable software and hardware virtualization. It will discuss some initial results and the plans in ParaPhrase, a novel 36-month €3.5 million European research project to develop a new structured pattern-based framework in Erlang and C/C++ for heterogeneous parallel architectures.
IP version 6 (IPv6) has been gaining more popularity as an alternative to the current IP version 4 (IPv4) protocol, as the global IPv4 address spaces will no longer be freely assigned. In this talk, Kenji will explain the similarity and difference between IPv4 and IPv6, and how the two protocols are handled in Erlang/OTP library modules. Kenji will also describe common pitfalls and lessons learned from reviewing various software packages to make them IPv6-compatible.
The new Erlang emulator is being developed that is capable of running directly on Xen hypervisor without an operating system. The design goal of the new emulator is to minimize the startup latency of new Xen instances running Erlang applications. The long-term vision is a super-elastic fabric for Erlang applications that allow real-time provisioning of computing resources.
After the success of the Java Hot Spot VM, just-in-time compilers are become more and more popular in more and more languages. Just-in-time compilers attempt to make code run faster by compiling parts of your programs to native code in order to speed up execution time. Just-in-time compilers have been shown to speed up performance by up to a factor of 5 for specific benchmarks and it is about time that the Erlang VM is fitted with one of its own.
This talk will give a brief overview of the different approaches one can take to just-in-time compiling and then dive into the details of how the Erlang VM executes code. After laying the ground work I will try to explain how a JIT can be done for the Erlang VM and finish of with a status report of what work has been done so far.
In this case study, we'll describe how and why we ported Opscode's high-volume Hosted Chef API from Ruby/CouchDB to Erlang/MySQL and share insights on:
- Writing high-volume web APIs in Erlang with webmachine
- Scripting with gen_fsm to coordinate loosely coupled back-end systems during a datastore migration.
- Performance and operational comparisons between Ruby/Erlang and CouchDB/MySQL
Heroku's cloud application platform has grown from its Ruby heritage into a true polyglot platform. Apps can now be built and deployed in nearly any language, including Erlang.
Come see how to quickly get started running Erlang apps on Heroku. Learn advanced tricks to run your app with any Erlang version and customize the Erlang build pack to suit your needs.
Software development is more of craftsmanship than of engineering. A good craftsman carries more tools around than just a hammer. And it's relatively inefficient to use a hammer where you need a saw. So when you take the Java ecosystem for hammer, there is still a lot of situations where a saw called Erlang would be a much better fit. In this talk you will learn these situations from concrete examples.
In the ever expanding world of cloud computing, messaging across back-end systems must be done quickly, reliably, and accurately 100% of the time. In this talk, we will discuss how AMQP is the open standard application layer protocol with Erlang implementation through RabbitMQ that successfully meets these needs. It serves as a rendezvous point for back-end systems to communicate efficiently and reliably while providing extensive features and full functionality for all languages to communicate with one another, otherwise known as polyglot programming.
In order to meet the demands of our growing user population while keeping our server footprint as small as possible, at WhatsApp we've been optimizing our Erlang-based server applications and tuning and patching the BEAM emulator and FreeBSD kernel to remove bottlenecks and improve efficiency. Our results have demonstrated the fantastic scalability of Erlang, and in this talk we will share some of the discoveries and modifications we have made along the path to supporting millions of connected users per server.
The concurrency model of the Erlang language is claimed to be ideally suited for the multicore era. In theory it allows concurrent programs to achieve good scalability as the number of cores increases. OK, but what happens in practice?
Since November 2011, we have embarked on a project that aims to improve the scalability of Erlang programs on machines with hundreds, thousands, and possibly even hundreds of thousands of cores. As a first step, we have created a benchmark suite, consisting of both synthetic benchmarks and actual Erlang applications with needs for massive concurrency, in order to measure the scalability of existing Erlang/OTP versions, identify possible bottlenecks in the language and the VM, and get inspiration for language extensions and VM improvements for future versions of Erlang/OTP. The talk will present the results of our investigation so far and offer some advice on dos and don'ts for achieving good scalability on the existing VM.
When creating a new language, either a DSL (Domain Specific Language) or a more general purpose one, it can be a great help to build on top of an existing language or VM. This can give you "for free" many of the properties and existing libraries of that system. However, it can also limit you to the properties of the base system thereby restricting your language. This talk will describe building languages on the Erlang VM and how the features of Erlang affect the properties of these languages. It will also look at some of the tools available for Erlang for implementing new languages.
GitHub Pages, a feature allowing users to publish content to the web by simply pushing content to one of their GitHub hosted repositories, has had lackluster performance and uptime in the recent years. In this talk, Jesse will discuss the core requirements of the GitHub Pages application, why Erlang, Riak, and Webmachine were chosen for the development, and how they were used to fulfill those requirements now and for years to come with minimal development and operational maintenance.
ADTECH’s ad delivery systems have traditionally been built using C++ technology. When the time came to build a real time bidding ad delivery system the team felt that traditional approaches would not be able to scale to the requirements that such a system would demand. The team undertook a very short investigation and then embarked on a journey to transform themselves, in a very short period of time, into an Erlang development group despite having no previous experience of the language. This talk is about that journey and some of the lessons learnt in the process.
Join Monica Wilkinson of the Cloud Foundry Team and Paul Jones, founder at 23wide, for a hands-on-session to learn how to develop and deploy a simple application to the cloud in minutes and experiment with new technology. In this session, you will learn:
What is Cloud Foundry - Monica
How to deploy and scale apps on Cloud Foundry - Monica
How to bind application services - Monica
How languages go into Cloud Foundry - Paul
How Erlang runs on Cloud Foundry - Paul
Open Source Process - Monica
The 64bit Erlang Virtual machine can host very large Erlang applications. However, the amount of memory consumed for an ordinary Erlang process is doubled compared to a 32bit virtual machine. Memory bandwidth is a bottleneck in modern computer environments, so wasting memory on 64bit heaps (with e.g. 128 bits consumed for every character in a string) is a problem. The halfword virtual machine addresses these problems for applications having vast amounts of data in ETS tables and binaries, but does not need more than 4GB of primary memory for regular Erlang processes - a class of applications that is quite common. Using the halfword virtual machine gets you the best of two worlds - even higher speed than with any of the ordinary virtual machines, but a huge memory address range for data stored in i.e. mnesia and ETS and as binaries.
The linux halfword virtual machine has been in OTP since the R14B02 release, but few people know about it and ever consider using it, a fact that we want to change.
The speaker has made something of a hobby in recent years of porting Open Source software to HP’s heritage OpenVMS operating system. One of the most challenging and interesting porting exercises was porting Erlang/OTP. In this talk, the speaker will discuss the motivations behind this work, some of the challenges faced, progress to date, and future plans. In addition, the speaker has recently joined HP’s corporate Cloud Services team, and in this capacity he will provide an overview of where and how Erlang is currently being used within the HP Cloud, and will outline potential future opportunities to further leverage Erlang technology in this space.
What services could a PaaS provide to make Erlang easier to deploy and operate in production? Are there any Erlang features that are fundamentally incompatible with PaaS? How can some of Erlang/OTP's more unique features (distributed processes, hot code upgrades) be made PaaS compatible?
In this session, we'll explore these topics through an open discussion with the aim of discovering how best to make a PaaS where Erlang feels like a first class citizen.
To generate Erlang code dynamically, you have until now had two choices: you could either create plain tuples according to the "abstract format" as generated by erl_parse (which is messy and has many special cases to keep in mind), or you could use the API functions in the erl_syntax module (which offer more abstraction, but can get pretty verbose). This talk will present the missing ingredient; a library allowing you to use template strings with metavariables, both for generating and matching on abstract syntax trees. As examples, I will show how we have used this at Klarna to implement a small domain-specific language for business logic, and demonstrate how you too can easily write a parse transform and even implement your own DSL that compiles to Beam code.