Erjang - a JVM-based Erlang VM
Author: Kresten Krab ThorupPurpose: London Erlang User Group Meeting
Involvment:
Abstract:
Attachments:
NKtalk Case Study
Author: Bartlomiej PuzonPurpose: Krakow Erlang User Group Meeting
Involvment: Presentation by Erlang Solutions employee
Abstract: The presentation covers the technical challenges which the developers faced while creating the service. Bartek Puzon explains why the Erlang language was chosen. He also describes how communication within NKtalk works and he talks about the usage of XMPP in web applications.
Attachments:
ComputErl Erlang Based Framework for Many-Task Computing
Author: Michal PtaszekPurpose: TFP 2010 Symposium
Involvment: Erlang Solutions
Abstract:
This paper shows how Erlang programming language can be used for creating a framework for distributing and coordinating the execution of many task computing problems. The goals of the proposed solution are (1) to disperse the computation into many tasks, (2) to support multiple well-known computation models (such as master-worker, map-reduce, pipeline), (3) to exploit the advantages of Erlang for developing an efficient and scalable framework and (4) to build a system that can scale from small to large number of tasks with minimum effort. We present the effects of work on designing, implementing and testing ComputErl framework. Experiments with benchmarks as well as real scientific applications on the cluster show scalability on up to 100 nodes.
Attachments:
Exago, property monitoring via log file analysis
Author: Atilla ErdodiPurpose: London Erlang User Group Meeting
Involvment: Tamas Nagy and Ulf Wiger
Abstract: When a failure occurs or just some concerns arise about the correctness a system, the first thing to check is the log files. However, manually analysing large amounts of log data can be daunting, or even impossible. Exago is an offline log monitoring tool that allows system engineers and testers to monitor properties on live systems, by analysing the generated log files. Exago's approach is to create abstract representations of the events that occurred in the live system during the analysed time period and re-evaluate them against a model of the system. If these abstract commands are accepted by the model, it means that the system (probably) behaved as expected. If not, it reveals an error in the system, and can give the developers a clue about where to look for them. Exago was written in Erlang, as a part of the ProTest project, but the target system can be written in any language as long as "enough" information is logged. In this talk, we show how much information is "enough" for our purposes, demonstrate the usage of Exago through a simple example, and also briefly explore the possibilities and the limits of our tool as well as the current research progress.
Attachments:
Exploring Tracing
Author: Judit KőszegiPurpose: Erlang User Group Meeting
Involvment: University of Kent
Abstract: Existing tools for tracing and debugging in Erlang provide only severely limited interactive trace exploration. The talk will be about a tool that provides free navigation through the trace, so we can explore the generated trace events independent of the time arrow, concentrating on casual relationships instead. Processes are at the heart of any Erlang system, thus we will focus on them instead of function definitions and try to localise faults up to purely functional code.
Attachments:
The Erlang Web. An Open Source Fault Tolerant and Scalable Web Framework
Author: Michal Ptaszek, Michal Slaski and Michal ZajdaPurpose: Paper presented at the 2008 Erlang User Conference
Involvment: Presentation by Erlang Training and Consulting staff
Abstract: The Erlang Web is an open source framework released by Erlang Training and Consulting. The framework follows the MVC (model view controller) pattern and can be used for building web applications with Erlang. In this presentation we describe the Erlang Web features. We also present results of stress testing an application built on top of the Erlang Web. We demonstrate how scalability and fault tolerance can be addressed.
Attachments:
Taking the Erlang OTP distro on github to the next level. Continuous builds and tests for community patches
Author: Tino BreddinPurpose: Erlang User Group Meeting
Involvment: Ulf Wiger
Abstract: Swarm is a continuous build system implemented in Erlang which takes software collaboration to another level. It allows users to share patches based on pre-defined rules, allowing for a more streamlined patch submission process than currently used for Erlang/OTP. Furthermore it supports the build and test of custom Erlang distributions which can be used to create specialized and supported collections of Erlang applications. Erlang Solutions plans to use Swarm to automatically test patches submitted to Erlang/OTP's main branch on Github and provide ready-to-use operating system packages of Erlang/OTP and custom variants. Tino will present the concepts behind Swarm and show how it can be used to improve the Erlang/OTP collaboration process.
Attachments:
Erlang Usage In The World.
Author: Francesco CesariniPurpose: A Presentation on the usage of Erlang in the world.
Involvment: Presented at the Erlang ACM Sigplan workshop in Snowbird, Utah, in September 2004.
Abstract: This presentation is based on download statistics and hits form the erlang.org website, posts and subscribers from the erlang-questions mailing lists, and Erlang User Conferences. It gives a good insight on how erlang is spreading in the world.
Attachments:
HiPE and Erlang internals
Author: Daniel LunaPurpose: London Erlang User Group Meeting
Involvment: Daniel Luna
Abstract: HiPE is a native code compiler for Erlang. It compiles Erlang code into machine code while running in inside the normal OTP runtime environment. This allows HiPE native code to coexist with BEAM byte compiled code in a running program on a module by module basis. HiPE supports hot code loading and all other typical Erlang magic and is packaged together with the standard Erlang/OTP distribution. The presentation explains the internals of the HiPE compiler and selected internals of the BEAM interpreter. Have you ever wondered how the Erlang data types are represented in machine code? Do you know how the HiPE loader works? What are the caveats when working on a 64 bit machine? The presentation is aimed at both beginner Erlang programmers as well as experienced hackers.
Attachments:
QuickCheck, a property-based approach to software testing
Author: Mietek BakPurpose: Zosia 2010
Involvment:
Abstract: Opowiem o tesknocie za utracona wiara w poprawność kodu, towarzyszacej przesiadce z jezyka ze statycznym systemem typow na jezyk z dynamicznym systemem typow, oraz o probach odzyskania tejze wiary przy uzyciu QuickCheck — biblioteki do automatycznego, deklaratywnego i stochastycznego testowania oprogramowania.
Attachments:
Bridging the gap between Jabber/XMPP and Gadu-Gadu
Author: Mietek BakPurpose: Krakow User Group Meeting
Involvment: Presentation by Erlang Training and Consulting staff
Abstract: Mietek gave a talk about bridging the gap between Jabber/XMPP and Gadu-Gadu by way of extending ejabberd. Starting with an overview of the XMPP architecture and protocol, the talk continued with tutorials on writing ejabberd modules and interfacing Erlang with C libraries, to conclude with a discussion of Mietek's XMPP/GG gateway module.
Attachments:
Productivity Gains with Erlang
Author: Jan Henry NystromPurpose: Presentation at the 2007 Commercial Users of Functional Programming workshop
Involvment: Presentation by the Training Manager on research produced and presentation written in conjunction with the Training Manager.
Abstract: Currently most distributed telecoms software is engineered using low- and mid-level distributed technologies, but there is a drive to use high-level distribution. This talk reports the first systematic comparison of a high-level distributed programming language in the context of substantial commercial products. The research clearly demonstrates that Erlang is not only a viable, but also a compelling choice when dealing with high availability system. This is due to the fact that it comparatively easy to construct systems that are * Resilient: sustaining throughput at extreme loads and automatically recovering when load drops. * Fault tolerant: remaining available despite repeated and multiple failures. * Dynamically reconfigurable: with throughput scaling, near-linearly, when resources are added or removed. But most importantly these systems can be delivered at a much higher productivity and with more maintainable deployed systems than current technology. This is attributed to the language features such as automatic memory and process management and high-level communication. Furthermore Erlang interoperates at low cost with conventional technologies, allowing incremental reengineering of large distributed systems.
Attachments:
QuickChecking Refactoring Tools
Author: Dániel Horpácsi and Dániel DrienyovszkyPurpose: Erlang User Group Meeting
Involvment: University of Kent
Abstract: Refactorings are behaviour preserving transformations of program source code. Many tools exist for automating large parts of refactoring steps, but these tools are often poorly tested. We present a method for testing Wrangler, an Erlang refactoring tool, using Quviq's Quickcheck. As the input for the refactoring tools is Erlang source code, to generate random test data we should create a large number of data generators that describe the Erlang language and generate random Erlang source code. This talk will demonstrate a better solution: we will introduce a metalanguage above the QuickCheck generators, which provides an easy way to create generators from L-Attributed Grammar descriptions. We will also present a way to test a large subset of Erlang for behavioural equivalence.
Attachments:
Refactoring Erlang with Wrangler
Author: Huiqing Li, Simon Thompson, Xingdong BianPurpose: London User Group Meeting
Involvment: Presentation wrote by Huiqing Li, Simon Thompson and Xingdong Bian
Abstract: Wrangler is an interactive refactoring tool for Erlang, integrated into both Emacs and Eclipse. Wrangler's refactorings cover structural changes such as function, variable and module renaming, function extraction and generalisation. Wrangler recognises macros in code, and can be used in a single file or across a whole project. Wrangler can also be used to locate and remove code clones, and we're working on locating similar code fragments.
Attachments:
Erlang Web Scalable and Reliable web framework
Author: Michal ZajdaPurpose: Erlang User Group Meeting
Involvment: Presentation wrote by Michal Zajda with supervision of Michal Slaski
Abstract: The Erlang Web is an open source framework for applications based on HTTP protocols, giving the developer better control of content management. With Erlang Web's simple but extensible concept of including dynamic content in pages, libraries of reusable components can be built.
Attachments:
ERESYE. Artificial Intelligence in Erlang Programs
Author: Francesca Gangemi and Corrado SantoroPurpose: Master's Thesis at the University of Catania, condensed into a paper that was, accepted at the 2005 ACM SIGPLAN Erlang Workshop, Tallinn, Estonia
Involvment: Paper was co-authored and presented by a consultant at Erlang Training and Consulting Ltd
Abstract: This presentation describes ERESYE, a tool for the realization of intelligent systems (expert systems) using the Erlang lan- guage. ERESYE is a rule production system that allows rules to be written as Erlang function clauses and provides a support for their execution. ERESYE is also able to sup- port object-oriented concepts and ontologies, thanks to a suitable ontology handling tool, which provides a means to translate object-based concepts into an Erlang form. The architecture of ERESYE and its basic working scheme are described in the paper. A comparison with CLIPS, one of the most famous tools for expert systems, and the descrip- tion of some examples of ERESYE usage are also provided, in order to show the effectiveness and the validity of the pro- posed solution, which is able to open new and interesting application scenarios for Erlang.
Attachments:
Experiences of Using, Teaching and Supporting Erlang/OTP, memories of an Erlang Consultant
Author: Francesco CesariniPurpose: Talk given at the 2005 Commercial Users of Functional Programming Languages Workshop, Tallinn, Estonia
Involvment: The presentations is based on the experiences of Erlang Training and Consulting Ltd's founder
Abstract: Who choses Erlang/OTP when developing products, and why? What are the results when management does not want to listen, is negative towards it, or when they champion it without having the programmers on their side? Do support staff learn maintainence skills when the system never goes down? What are the lessons learnt from working with Erlang in the past, and how can they help us prepare for the future? These are all questions covered in the presentation given by the founder or Erlang Training and Consulting after having worked with Erlang for over ten years.
Attachments:
