This is the second of three planned release candidates before the OTP 24 release.
The intention with this release is to get feedback from our users. All feedback is welcome, even if it is only to say that it works for you.

We encourage users to try it out and give us feedback either by creating an issue here https://github.com/erlang/otp/issues
or by posting to the mailing list erlang-questions@erlang.org.

Erlang/OTP 24 is a new major release with new features, improvements as well as a few incompatibilities. Some of the new
features are highlighted below.

Highlights rc2

compiler

• The compiler will now inline funs that are used only once immediately after their definition.

erts, kernel, stdlib

• hex encoding and decoding functions added in the binary module

There is as usual a number of bug fixes and improvements detailed in the readme.

Highlights rc1

erts, kernel, stdlib

• The BeamAsm JIT-compiler has been added to Erlang/OTP and will give a significant performance boost for many applications.
  The JIT-compiler is enabled by default on most x86 64-bit platforms that have a C++ compiler that can compile C++17.
  To verify that a JIT enabled emulator is running you can use erlang:system_info(emu_flavor).

• A compatibility adaptor for gen_tcp to use the new socket API has been implemented (gen_tcp_socket).

• Extended error information for failing BIF calls as proposed in EEP 54 has been implemented.

• Process aliases as outlined by EEP 53 has been introduced.

compiler

• Compiler warnings and errors now include column numbers in addition to line numbers.
• Variables bound between the keywords 'try' and 'of' can now be used in the clauses following the 'of' keyword
  (that is, in the success case when no exception was raised).

ftp

• Add support for FTPES (explicit FTP over TLS).

ssl

• Support for the "early data" feature for TLS 1.3 servers and clients.
• Make TLS handshakes in Erlang distribution concurrent.

wx

• The application has been completely rewritten in order
  to use wxWidgets version 3 as its base.
• Added support for wxWebView.

edoc

• EDoc is now capable of emitting EEP-48 doc chunks. This means that, with some configuration, community projects
  can now provide documentation for shell_docs the same way that OTP libraries did since OTP 23.0.

For more details about new features and potential incompatibilities see
https://erlang.org/download/OTP-24.0-rc2.README

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_24.0-rc2.exe
http://erlang.org/download/otp_win64_24.0-rc2.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-12.0-rc2/doc/

The Erlang/OTP source can also be found at GitHub on the official Erlang repository,
https://github.com/erlang/otp

Erlang/OTP 23.3 is the third and final maintenance patch package for OTP 23, with mostly bug fixes as well as a few improvements.

A full list of bug fixes and improvements in the readme.

Download and documentation

Online documentation can be browsed here:
https://erlang.org/documentation/doc-11.2/doc

Pre-built versions for Windows can be fetched here:
https://erlang.org/download/otp_win32_23.3.exe
https://erlang.org/download/otp_win64_23.3.exe

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:
https://github.com/erlang/otp

Lukas Larsson and John Högberg from the OTP team are talking about the new JIT implementation for the BEAM in this PODCAST from ThinkingElixir.

https://thinkingelixir.com/podcast-episodes/017-jit-compiler-for-beam-with-lukas-larsson-and-john-hogberg/

OTP 23 Release Candidate 2

This is the second of three planned release candidates before the OTP 23 release.
The intention with this release is to get feedback from our users. All feedback is welcome, even if it is only to say that it works for you.

Erlang/OTP 23 is a new major release with new features, improvements as well as a few incompatibilities.

Potential Incompatibilities

• SSL:
  • Support for SSL 3.0 is completely removed.
  • TLS 1.3 is added to the list of default supported versions.
• erl_interface: Removed the deprecated parts of erl_interface
  (erl_interface.h and essentially all C functions with prefix erl_).
• The deprecated erlang:get_stacktrace/0 BIF now returns an empty list instead of a stacktrace.
  erlang:get_stacktrace/0 is scheduled for removal in OTP 24.
• ...

Highlights (rc2)

• ssh:
  • OpenSSH 6.5 introduced a new file representation of
    keys called openssh-key-v1. This is now supported with the exception of
    handling encrypted keys.
  • Algorithm configuration could now be done in a .config file.
    This is useful for example to enable an algorithm that
    is disabled by default without need to change the code.
• ssl:
  • Support for the middlebox compatibility mode makes the TLS 1.3 handshake
    look more like a TLS 1.2 handshake and increases the chance of successfully
    establishing TLS 1.3 connections through legacy middleboxes.
  • Add support for key exchange with Edward curves and PSS-RSA padding in
    signature verification
• The possibility to run Erlang distribution without
  relying on EPMD has been extended. To achieve this a
  couple of new options to the inet distribution has been
  added.
  • -dist_listen false Setup the distribution
    channel, but do not listen for incoming connection.
  • -erl_epmd_port Port Configure a default port that
    the built-in EPMD client should return.
  • ...
• A first EXPERIMENTAL socket backend to
  gen_tcp and inet has been implemented. gen_udp and gen_sctp will follow.
  Putting {inet_backend, socket} as first option to listen() or connect() makes it easy to try this for
  existing code

Highlights (rc1)

• A new module erpc in kernel which implements an enhanced subset of the operations provided by the rpc module. Enhanced in the sense that it makes it possible to distinguish between returned value, raised exceptions and other errors. erpc also has better performance and scalability than the original rpc implementation. This by utilizing the newly introduced spawn_request() BIF. Also the rpc module benefits from these improvements by utilizing erpc when possible.
• Scalability and performance Improvements plus new functionality regarding distributed spawn operations.
• In binary matching, the size of the segment to be matched is now allowed to be a guard expression (EEP-52)
• When matching with maps the keys can now be guard expressions (EEP-52).
• ssh: support for TCP/IP port forwarding, a.k.a tunneling a.k.a as tcp-forward/direct-tcp is implemented. In the OpenSSH client, this corresponds to the options -L and -R.
• Allow underscores in numeric literals to improve readability. Examples: 123_456_789, 16#1234_ABCD.
• New functions in the shell for displaying documentation for Erlang modules, functions and types. The
  functions are:
  • h/1,2,3 -- Print the documentation for a Module:Function/Arity.
  • ht/1,2,3 -- Print the type documentation for a Module:Type/Arity.
    The embedded documentation is created as docchunks (EEP 48) when building the Erlang/OTP documentation.
• kernel: The module pg with a new implementation of distributed named process groups is introduced. The old module pg2 is deprecated and scheduled for removal in OTP 24.
• Our tool chain for building the Windows packages is upgraded with new C++ compiler, Java compiler, OpenSSL libraries and wxWidgets versions. We are now using WSL (the Linux Subsystem for Windows when building) which makes it easier to handle the build environment.
• ...

For more details see
http://erlang.org/download/otp_src_23.0-rc2.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_23.0-rc2.exe
http://erlang.org/download/otp_win64_23.0-rc2.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-11.0-rc2/doc
The Erlang/OTP source can also be found at GitHub on the official Erlang repository,
https://github.com/erlang/otp

Erlang/OTP 22.3 is the last planned patch package for the 22 major release with new features, improvements and bugfixes. Below follows some highlights.

Highlights

• ssl/public_key:
  • Implementation of the key and initialization vector
    update feature, and general hardening of TLS 1.3.
    There are cryptographic limits on the amount of
    plaintext which can be safely encrypted under a given set of keys.
    This change enforces those limits by triggering
    automatic key updates on TLS 1.3 connections.
  • Add support for TLS 1.3 Session Tickets (stateful and
    stateless). This allows session resumption using keying
    material from a previous successful handshake.
  • Add support for key exchange with Edward curves and
    PSS-RSA padding in signature verification.
• erts:
  • A socket "registry" has been added making it possible to list current open sockets.
  • Add a "full featured" version of getifaddrs in the net module.
• ssh:
  • The new functions ssh:set_sock_opts/2 and ssh:get_sock_opts/2 sets and reads option values for
    the underlying TCP stream.
  • Changes to the internal api of the experimental ssh_dbg tool.
• common_test: The ct_property_test has now a report function for
  results of stateful testing.
• stdlib:
  • Implement uri_string:resolve/{2,3} that can be used to
    resolve a URI reference against a base URI.
  • In gen_statem it is now possible to change the callback
    module for a running server. See gen_statem's
    documentation for change_callback_module,
    push_callback_module, and pop_callback_module.

For more details see
http://erlang.org/download/otp_src_22.3.readme
Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_22.3.exe
http://erlang.org/download/otp_win64_22.3.exe
Online documentation can be browsed here:
http://erlang.org/doc/search/
The source tarball can be fetched here:
http://erlang.org/download/otp_src_22.3.tar.gz
The documentation can be fetched here:
http://erlang.org/download/otp_doc_html_22.3.tar.gz
The man pages can be fetched here:
http://erlang.org/download/otp_doc_man_22.3.tar.gz
The Erlang/OTP source can also be found at GitHub on the official Erlang repository:
https://github.com/erlang/otp
OTP-22.3

Thank you for all your contributions!

Highlights

erts:

• The Kernel application's User's Guide now contains a Logger Cookbook with common usage patterns.
• Numerous improvements in the new socket and net modules

Standard libraries:

• common_test: ct_property_test logging is improved
• ssl: Correct handling of unordered chains so that it works as expected

Tools:

• Emacs erlang-mode function that lets the user open the documentation for an Erlang/OTP function in an Emacs buffer has been improved. Users will be asked if they want the man pages downloaded if they are not present in the system.

For more details see
erlang.org/download/otp_src_22.2.readme

Pre-built versions for Windows can be fetched here:
erlang.org/download/otp_win32_22.2.exe
erlang.org/download/otp_win64_22.2.exe

Online documentation can be browsed here:
erlang.org/doc/search/

The source tarball can be fetched here:
erlang.org/download/otp_src_22.2.tar.gz
The documentation can be fetched here:
erlang.org/download/otp_doc_html_22.2.tar.gz
The man pages can be fetched here:
erlang.org/download/otp_doc_man_22.2.tar.gz

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:

https://github.com/erlang/otp

OTP-22.2

Thank you for all your contributions!

We have migrated our email-list to a new server, and during the move we accidentally sent out a email to everyone saying that you have been unsubscribed from the email-list.

This is not true, and you are still subscribed to all the list you where subscribed to before this happened.

This move might be accompanied by a small delay in email traffic due to MX propagation delays.

We do apologize for the inconvenience!

Potential Incompatibilities

• Mnesia: Transactions with sticky locks could with async_asym transactions be committed in the wrong order, since asym transactions are spawned on the remote nodes. To fix this bug the communication protocol between mnesia nodes had to be updated, thus mnesia will no longer be able to connect to nodes earlier than mnesia-4.14 ,first realeased in OTP-19.0.
• Stdlib: Debugging of time-outs in gen_statem has been improved. Starting a time-out is now logged in sys:log and sys:trace. Running time-outs are visible in server crash logs, and with sys:get_status. Due to this system events {start_timer, Action, State} and {insert_timout, Event, State} have been added, which may surprise tools that rely on the format of these events. New features: The EventContent of a running time-out can be updated with {TimeoutType, update, NewEventContent}. Running time-outs can be cancelled with {TimeoutType, cancel} which is more readable than using Time = infinity.{rel, Name, Vsn, RelApps, Opts}.

Highlights

Compiler:

• erlc can now automatically use a compile server to avoid starting an Erlang system for each file to be compiled in a multi-file project. See the documentation for how to enable it.

Standard libraries:

• SSL: Basic support for TLS 1.3 Client for experimental use. For more information see the Standards Compliance chapter of the User's Guide.
• crypto: The Message Authentication Codes (MAC) CMAC, HMAC and Poly1305 are unified into common functions in the New Crypto API. See the manual for CRYPTO. cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

For more details see
http://erlang.org/download/otp_src_22.1.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_22.1.exe
http://erlang.org/download/otp_win64_22.1.exe

Online documentation can be browsed here:
http://erlang.org/doc/search/

The source tarball can be fetched here:
http://erlang.org/download/otp_src_22.1.tar.gz
The documentation can be fetched here:
http://erlang.org/download/otp_doc_html_22.1.tar.gz
The man pages can be fetched here:
http://erlang.org/download/otp_doc_man_22.1.tar.gz

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:

https://github.com/erlang/otp

OTP-22.1

Thank you for all your contributions!

OTP 22.0

Erlang/OTP 22 is a new major release with new features and improvements as well as incompatibilities.

For a deeper dive into the highlights of the OTP 22 release, you can read our blog here:

http://blog.erlang.org/OTP-22-Highlights/

Potential Incompatibilities

• gen_* behaviours: If logging of the last N messages through sys:log/2,3 is active for the server, this log is included in the terminate report.
• reltool: A new element, Opts, can now be included in a rel tuple in the reltool release specific configuration format: {rel, Name, Vsn, RelApps, Opts}.
• All external pids/ports/refs created by erlang:list_to_pid and similar functions now compare equal to any other pid/port/ref with same number from that node.
• The old legacy erl_interface library is deprecated as of OTP 22, and will be removed in OTP 23. This does not apply to the ei library.
• VxWorks is deprecated as of OTP 22 and will be removed in OTP 23.

New Features

Erts:

• Support for Erlang Distribution protocol to split the payload of large messages into several fragments.
• ETS option write_concurrency now also effects and improves scalability of ordered_set tables.
• The length/1 BIF used to calculate the length of the list in one go without yielding, even if the list was very long. Now it yields when called with long lists.
• A new (still experimental) module socket is introduced. It is implemented as a NIF and the idea is that it shall be as "close as possible" to the OS level socket interface.
• Added the NIF function enif_term_type, which helps avoid long sequences of enif_is_xyz by returning the type of the given term. This is especially helpful for NIFs that serialize terms, such as JSON encoders, where it can improve both performance and readability.

Compiler:

• The compiler has been rewritten to internally use an intermediate representation based on Static Single Assignment (SSA). The new intermediate representation makes more optimizations possible.
  • The binary matching optimizations are now applicable in many more circumstances than before.
  • Type optimizations are now applied across local function calls, and will remove a lot more redundant type tests than before.
• All compiler options that can be given in the source file can now be given in the option list on the command line for erlc.
• In OTP 22, HiPE (the native code compiler) is not fully functional. The reasons for this are new BEAM instructions for binary matching that the HiPE native code compiler does not support. If erlc is invoked with the +native option, and if any of the new binary matching instructions are used, the compiler will issue a warning and produce a BEAM file without native code.

Standard libraries:

• Cover now uses the counters module instead of ets for updating counters. The new function cover:local_only/0 allows running Cover in a restricted but faster local-only mode. The increase in speed will vary depending on the type of code being cover-compiled, as an example the compiler test suite runs more than twice as fast with the new Cover.
• A simple socket API is provided through the socket module. This is a low level API that does *not* replace gen_[tcp|udp|sctp]. It is intended to *eventually* replace the inet driver. It also provides a basic API that facilitates the implementation of other protocols than TCP, UDP and SCTP. Known issues are; No support for the Windows OS (currently), a small term leakage. This feature will be classed as experimental in OTP 22.
• SSL: now uses the new logger API, including log levels and verbose debug logging.
• SSL: Basic support for TLS 1.3 Server for experimental use.
• crypto: The new hash_info/1 and cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

For more details see
http://erlang.org/download/otp_src_22.0.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_22.0.exe
http://erlang.org/download/otp_win64_22.0.exe

Online documentation can be browsed here:
http://erlang.org/doc/search/

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:

https://github.com/erlang/otp

OTP-22.0

Thank you for all your contributions!

This is the 3rd release candidate for OTP 22.0

Erlang/OTP 22 is a new major release with new features and improvements as well as incompatibilities.

There are no major highlight for this release, as the main focus of this is bugfixes and polish.

Please consult the readme for a detailed changelog for the release.

The intention with this release is to get feedback from our users. All feedback is welcome, even if it is only to say that it works for you, as it lets us know that the release candidate got some testing.

Highlights in release candidate 2

Potential Incompatibilities

• gen_* behaviours: If logging of the last N messages through sys:log/2,3 is active for the server, this log is included in the terminate report.
• reltool: A new element, Opts, can now be included in a rel tuple in the reltool release specific configuration format: {rel, Name, Vsn, RelApps, Opts}.
• All external pids/ports/refs created by erlang:list_to_pid and similar functions now compare equal to any other pid/port/ref with same number from that node.
• The old legacy erl_interface library is deprecated as of OTP 22, and will be removed in OTP 23. This does not apply to the ei library.
• VxWorks is deprecated as of OTP 22 and will be removed in OTP 23.

Additional highlights in release candidate 2

• A simple socket API is provided through the socket module. This is a low level API that does *not* replace gen_[tcp|udp|sctp]. It is intended to *eventually* replace the inet driver. It also provides a basic API that facilitates the implementation of other protocols than TCP, UDP and SCTP. Known issues are; No support for the Windows OS (currently), a small term leakage. This feature will be classed as experimental in OTP 22.
• ssl: Basic support for TLS 1.3 Server for experimental use.
• In OTP 22, HiPE (the native code compiler) is not fully functional. The reasons for this are new BEAM instructions for binary matching that the HiPE native code compiler does not support. If erlc is invoked with the +native option, and if any of the new binary matching instructions are used, the compiler will issue a warning and produce a BEAM file without native code.
• erts: Added the NIF function enif_term_type, which helps avoid long sequences of enif_is_xyz by returning the type of the given term. This is especially helpful for NIFs that serialize terms, such as JSON encoders, where it can improve both performance and readability.
• crypto: The new hash_info/1 and cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

Highlights in release candidate 1

Erts:

• Support for Erlang Distribution protocol to split the payload of large signals into several fragments.
• ETS option write_concurrency now also effects and improves scalability of ordered_set tables.
• The length/1 BIF used to calculate the length of the list in one go without yielding, even if the list was very long. Now it yields when called with long lists.
• A new (still experimental) module socket is introduced. It is implemented as a NIF and the idea is that it shall be as "close as possible" to the OS level socket interface.

Compiler:

• The compiler has been rewritten to internally use an intermediate representation based on Static Single Assignment (SSA). The new intermediate representation makes more optimizations possible.
  • The binary matching optimizations are now applicable in many more circumstances than before.
  • Type optimizations are now applied across local function calls, and will remove a lot more redundant type tests than before.
• All compiler options that can be given in the source file can now be given in the option list on the command line for erlc.

Standard libraries:

• Cover now uses the counters module instead of ets for updating counters. The new function cover:local_only/0 allows running Cover in a restricted but faster local-only mode. The increase in speed will vary depending on the type of code being cover-compiled, as an example the compiler test suite runs more than twice as fast with the new Cover.
• SSL now uses the new logger API, including log levels and verbose debug logging.

For more details see
http://erlang.org/download/otp_src_22.0-rc3.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_22.0-rc3.exe
http://erlang.org/download/otp_win64_22.0-rc3.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-11.0-rc3/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:

https://github.com/erlang/otp

OTP-22.0-rc3

Thank you for all your contributions!

OTP 22 Release Candidate 2

This is the second of three planned release candidates before the OTP 22 release.

The intention with this release is to get feedback from our users. All feedback is welcome, even if it is only to say that it works for you, as it lets us know that the release candidate got some testing.

Erlang/OTP 22 is a new major release with new features and improvements as well as incompatibilities.

Potential Incompatibilities

• gen_* behaviours: If logging of the last N messages through sys:log/2,3 is active for the server, this log is included in the terminate report.
• reltool: A new element, Opts, can now be included in a rel tuple in the reltool release specific configuration format: {rel, Name, Vsn, RelApps, Opts}.
• All external pids/ports/refs created by erlang:list_to_pid and similar functions now compare equal to any other pid/port/ref with same number from that node.
• The old legacy erl_interface library is deprecated as of OTP 22, and will be removed in OTP 23. This does not apply to the ei library.
• VxWorks is deprecated as of OTP 22 and will be removed in OTP 23.

Additional highlights in release candidate 2

• A simple socket API is provided through the socket module. This is a low level API that does *not* replace gen_[tcp|udp|sctp]. It is intended to *eventually* replace the inet driver. It also provides a basic API that facilitates the implementation of other protocols than TCP, UDP and SCTP. Known issues are; No support for the Windows OS (currently), a small term leakage. This feature will be classed as experimental in OTP 22.
• ssl: Basic support for TLS 1.3 Server for experimental use.
• In OTP 22, HiPE (the native code compiler) is not fully functional. The reasons for this are new BEAM instructions for binary matching that the HiPE native code compiler does not support. If erlc is invoked with the +native option, and if any of the new binary matching instructions are used, the compiler will issue a warning and produce a BEAM file without native code.
• erts: Added the NIF function enif_term_type, which helps avoid long sequences of enif_is_xyz by returning the type of the given term. This is especially helpful for NIFs that serialize terms, such as JSON encoders, where it can improve both performance and readability.
• crypto: The new hash_info/1 and cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

Highlights in release candidate 1

Erts:

• Support for Erlang Distribution protocol to split the payload of large signals into several fragments.
• ETS option write_concurrency now also effects and improves scalability of ordered_set tables.
• The length/1 BIF used to calculate the length of the list in one go without yielding, even if the list was very long. Now it yields when called with long lists.
• A new (still experimental) module socket is introduced. It is implemented as a NIF and the idea is that it shall be as "close as possible" to the OS level socket interface.

Compiler:

• The compiler has been rewritten to internally use an intermediate representation based on Static Single Assignment (SSA). The new intermediate representation makes more optimizations possible.
  • The binary matching optimizations are now applicable in many more circumstances than before.
  • Type optimizations are now applied across local function calls, and will remove a lot more redundant type tests than before.
• All compiler options that can be given in the source file can now be given in the option list on the command line for erlc.

Standard libraries:

• Cover now uses the counters module instead of ets for updating counters. The new function cover:local_only/0 allows running Cover in a restricted but faster local-only mode. The increase in speed will vary depending on the type of code being cover-compiled, as an example the compiler test suite runs more than twice as fast with the new Cover.
• SSL now uses the new logger API, including log levels and verbose debug logging.

For more details see
http://erlang.org/download/otp_src_22.0-rc2.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_22.0-rc2.exe
http://erlang.org/download/otp_win64_22.0-rc2.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-11.0-rc2/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:

https://github.com/erlang/otp

OTP-22.0-rc2

Thank you for all your contributions!

OTP 21.3

Erlang/OTP 21.3 is the third service release for version 21 release with, improvements as well as a few features!

Highlights

Kernel:

• The standard logger handler, logger_std_h, now has a new internal feature for log rotation. For full information see the documentation.

SSL:

• The Reason part of the error return from the functions connect and handshake has a better and documented format. This is a potential incompatibility. See the documentation.
• Refactoring of state handling has improved the TLS application data throughput and reduced CPU overhead
• Code optimizations has reduced CPU load for encryption/decryption, especially for Erlang's distribution protocol over TLS
• Now supports active N

Erl_interface:

• Support for plugin of a user supplied socket implementation has been added.

OTP:

• The HTML reference documentation now shows the OTP version where modules and functions were first introduced.
• Versions of OTP older than R13B04 is not shown in the reference documentation

For a full list of details see:
http://erlang.org/download/otp_src_21.3.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_21.3.exe
http://erlang.org/download/otp_win64_21.3.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-10.3/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository, Here: OTP-21.2

Please report any new issues via Erlang/OTPs public issue tracker

OTP 22 Release Candidate 1

This is the first of three planned release candidates before the OTP 22 release.

The intention with this release is to get feedback from our users. All feedback is welcome, even if it is only to say that it works for you, as it lets us know that the release candidate got some testing.

Erlang/OTP 22 is a new major release with new features and improvements as well as incompatibilities.

Potential Incompatibilities

• gen_* behaviours: If logging of the last N messages through sys:log/2,3 is active for the server, this log is included in the terminate report.
• New element, Opts, can now be included in a rel tuple in the reltool release specific configuration format: {rel, Name, Vsn, RelApps, Opts}.
• All external pids/ports/refs created by erlang:list_to_pid and similar functions now compare equal to any other pid/port/ref with same number from that node.
• The old legacy erl_interface library is deprecated as of OTP 22, and will be removed in OTP 23. This does not apply to the ei library.
• VxWorks is deprecated as of OTP 22 and will be removed in OTP 23.

Known problems

Native code generation does not work for all modules due to new BEAM instructions not supported by HiPE the native compiler. However, dialyzer's automatic compilation to native code still works. Building OTP with the configure option enable-native-libs will not work in this release candidate.

Highlights

Erts:

• Support for Erlang Distribution protocol to split the payload of large signals into several fragments.
• ETS option write_concurrency now also effects and improves scalability of ordered_set tables.
• The length/1 BIF used to calculate the length of the list in one go without yielding, even if the list was very long. Now it yields when called with long lists.
• A new (still experimental) module socket is introduced. It is implemented as a NIF and the idea is that it shall be as "close as possible" to the OS level socket interface.

Compiler:

• The compiler has been rewritten to internally use an intermediate representation based on Static Single Assignment (SSA). The new intermediate representation makes more optimizations possible.
  • The binary matching optimizations are now applicable in many more circumstances than before.
  • Type optimizations are now applied across local function calls, and will remove a lot more redundant type tests than before.
• All compiler options that can be given in the source file can now be given in the option list on the command line for erlc.

Standard libraries:

• Cover now uses the counters module instead of ets for updating counters. The new function cover:local_only/0 allows running Cover in a restricted but faster local-only mode. The increase in speed will vary depending on the type of code being cover-compiled, as an example the compiler test suite runs more than twice as fast with the new Cover.
• SSL now uses the new logger API, including log levels and verbose debug logging.

For more details see
http://erlang.org/download/otp_src_22.0-rc1.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_22.0-rc1.exe
http://erlang.org/download/otp_win64_22.0-rc1.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-11.0-rc1/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository:

https://github.com/erlang/otp

OTP-22.0-rc1

Thank you for all your contributions!

OTP 21.2

Erlang/OTP 21.2 is the second service release for the 21st major release with, improvements as well as a few features!

Highlights

SSH:

• Public key methods: ssh-ed25519 and ssh-ed448 added. Requires OpenSSL 1.1.1 or later as cryptolib under the OTP application

SSL:

• ssl now uses active n internally to boost performance. Old active once behaviour can be restored by setting a application variable.

ERTS, Kernel:

• New counters and atomics modules supplies access to highly efficient operations on mutable fixed word sized variables.
• New module persistent_term!. Lookups are in constant time! No copying the terms!

• New pollset made to handle sockets that use {active, true} or {active, N}. Polled by a normal scheduler!

• No more ONESHOT mechanism overhead on fds! Only on Linux and BSD

For a full list of details see:
http://erlang.org/download/otp_src_21.2.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_21.2.exe
http://erlang.org/download/otp_win64_21.2.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-10.2/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository, Here: OTP-21.2

Please report any new issues via Erlang/OTPs public issue tracker

OTP 21.1

Erlang/OTP 21.1 is the first service release for the 21st major release with improvements as well as a few new features!

Highlights

SSH:

•  The cipher 'chacha20-poly1305@openssh.com' is now  supported if OpenSSL 1.1.1 or higher is used as cryptolib.

•  The key exchange methods 'curve25519-sha256@libssh.org', 'curve25519-sha256' and 'curve448-sha512' are implemented. 
   They all depends on that OpenSSL 1.1.1 or higher used as cryptolib.

Crypto:

• Typing in crypto and public_key applications are reworked and corrected.
• New chapter on Algorithm details in the User's guide

ERTS, Kernel:

• The socket options recvtos, recvttl, recvtclass and pktoptions have been implemented in the socket modules. 
  Se documentation in gen_tcp, gen_udp and inet modules for more info!

For more details see:
http://erlang.org/download/otp_src_21.1.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_21.1.exe
http://erlang.org/download/otp_win64_21.1.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-10.1/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository, Here: OTP-21.1

Please report any new issues via Erlang/OTPs public issue tracker

OTP 21

Erlang/OTP 21 is a new major release with new features, improvements as well as incompatibilities.

Potential Incompatibilities

• All Corba applications are now moved from the OTP repository
• A new Corba repository will be created https://github.com/erlang
• New applications ftp and tftp, moved from inets
• ssl no longer supports 3_DES cipher suites or RSA-key exchange cipher suites by default
• erlang:monitor on a primitive node (erl_interface, jinterface, etc) will no longer fail with badarg exception. Instead a monitor will be created, but it will only supervise the connection to the node.

 Highlights

 Erts:

• Enhanced IO scalability
• Support for usage of distribution controller processes for alternative transports, routing etc
• compact instructions on 64bit systems for code below 4GB 20% less memory for loaded code
• Rewrite of the efile-driver with NIFs and "Dirty schedulers" resulting in faster file operations
• non-smp VM removed
• link and monitor optimized for scalability
• os:getenv/putenv now work on thread-safe emulation. No longer in sync with libc getenv(3). Manual synchronization will be needed.

Compiler:

• Misc compiler optimizations including contributions from the Elixir team resulting in 10% improvements in benchmarks
• "Tuple calls" have been removed from the run-time system.
• Code such as f({ok, Val}) -> {ok, Val} is now automatically rewritten to f({ok, Val} = Tuple) -> Tuple. this reduces code size, execution time, and removed GC pressure.
• More information in stacktrace from a number of operators
• erlang:get_stacktrace/0 deprecated to be replaced with try ... catch C:R:Stacktrace -> ...
• Creation of small maps with literal keys optimized.
• A new predifined macro `OTP_RELEASE` and preprocessor directives `-if` and `-elif`

Security:

• DTLS is now supported in the SSL application
• Enhanced support for distribution over TLS
• "unsecure" ciphers removed from defaults in SSL and SSH.
• A new option value defined to facilitate implementing exec servers. Old option kept for compatibility, but now gives errors on stderror.

Standard libraries:

• New API for logging, logger
• New uri_string module for parsing URIs according to "The standard"
• New function lists:search(list,fun/1) -> {ok, Value} | false
• Changed default behaviour of .erlang loading. escript, erlc, dialyzer and typer no longer load an .erlang at all.

For more details see
http://erlang.org/download/otp_src_21.0.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_21.0.exe
http://erlang.org/download/otp_win64_21.0.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-10.0/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository, Here: OTP-21.0

Thank you for all your contributions!

OTP 21 Release Candidate 2

This is the second of two planned release candidates before the OTP 21 release.

As we move closer to OTP 21 we aim to improve the quality and stability of the release candidate.

The intention with this release is that you as users try it and give us feedback

Erlang/OTP 21 is a new major release with new features, improvements as well as incompatibilities.

Potential Incompatibilities

• All Corba applications are now moved from the OTP repository
• A new Corba repository will be created https://github.com/erlang
• New applications ftp and tftp, moved from inets
• ssl no longer supports 3_DES cipher suites or RSA-key exchange cipher suites by default
• erlang:monitor on a primitive node (erl_interface, jinterface, etc) will no longer fail with badarg exception. Instead a monitor will be created, but it will only supervise the connection to the node.

 Highlights

 Erts:

• Enhanced IO scalability
• Support for usage of distribution controller processes for alternative transports, routing etc
• compact instructions on 64bit systems for code below 4GB 20% less memory for loaded code
• Rewrite of the efile-driver with NIFs and "Dirty schedulers" resulting in faster file operations
• non-smp VM removed
• link and monitor optimized for scalability
• os:getenv/putenv now work on thread-safe emulation. No longer in sync with libc getenv(3). Manual synchronization will be needed.

Compiler:

• Misc compiler optimizations including contributions from the Elixir team resulting in 10% improvements in benchmarks
• "Tuple calls" have been removed from the run-time system.
• Code such as f({ok, Val}) -> {ok, Val} is now automatically rewritten to f({ok, Val} = Tuple) -> Tuple. this reduces code size, execution time, and removed GC pressure.
• More information in stacktrace from a number of operators
• erlang:get_stacktrace/0 deprecated to be replaced with try ... catch C:R:Stacktrace -> ...
• Creation of small maps with literal keys optimized.

Security:

• DTLS support in SSL
• Enhanced support for distribution over TLS
• "unsecure" ciphers removed from defaults in SSL and SSH.
• A new option value defined to facilitate implementing exec servers. Old option kept for compatibility, but now gives errors on stderror.

Standard libraries:

• New API for logging, logger
• New uri_string module for parsing URIs according to "The standard"
• New function lists:search(list,fun/1) -> {ok, Value} | false
• Changed default behaviour of .erlang loading. escript, erlc, dialyzer and typer no longer load an .erlang at all.

For more details see
http://erlang.org/download/otp_src_21.0-rc2.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_21.0-rc2.exe
http://erlang.org/download/otp_win64_21.0-rc2.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-10.0-rc2/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository,

https://github.com/erlang/otp

OTP-21.0-rc2

Thank you for all your contributions!

OTP 21 Release Candidate 1

This is the first of two planned release candidates before the OTP 21 release.

The intention with this release is that you as users try it and give us feedback

Erlang/OTP 21 is a new major release with new features, improvements as well as incompatibilities.

Potential Incompatibilities

• All Corba applications are now moved from the OTP repository
• A new Corba repository will be created https://github.com/erlang
• New applications ftp and tftp, moved from inets
• ssl no longer supports 3_DES cipher suites or RSA-key exchange cipher suites by default
• erlang:monitor on a primitive node (erl_interface, jinterface, etc) will no longer fail with badarg exception. Instead a monitor will be created, but it will only supervise the connection to the node.

 Highlights

 Erts:

• Enhanced IO scalability
• Support for usage of distribution controller processes for alternative transports, routing etc
• compact instructions on 64bit systems for code below 4GB 20% less memory for loaded code
• Rewrite of the efile-driver with NIFs and "Dirty schedulers" resulting in faster file operations
• non-smp VM removed
• link and monitor optimized for scalability
• os:getenv/putenv now work on thread-safe emulation. No longer in sync with libc getenv(3). Manual synchronization will be needed.

Compiler:

• Misc compiler optimizations including contributions from the Elixir team resulting in 10% improvements in benchmarks
• "Tuple calls" have been removed from the run-time system.
• Code such as f({ok, Val}) -> {ok, Val} is now automatically rewritten to f({ok, Val} = Tuple) -> Tuple. this reduces code size, execution time, and removed GC pressure.
• More information in stacktrace from a number of operators
• erlang:get_stacktrace/0 deprecated to be replaced with try ... catch C:R:Stacktrace -> ...
• Creation of small maps with literal keys optimized.

Security:

• DTLS support in SSL
• Enhanced support for distribution over TLS
• "unsecure" ciphers removed from defaults in SSL and SSH.
• A new option value defined to facilitate implementing exec servers. Old option kept for compatibility, but now gives errors on stderror.

Standard libraries:

• New API for logging, logger
• New uri_string module for parsing URIs according to "The standard"
• New function lists:search(list,fun/1) -> {ok, Value} | false
• Changed default behaviour of .erlang loading. escript, erlc, dialyzer and typer no longer load an .erlang at all.

For more details see
http://erlang.org/download/otp_src_21.0-rc1.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_21.0-rc1.exe
http://erlang.org/download/otp_win64_21.0-rc1.exe

Online documentation can be browsed here:
http://erlang.org/documentation/doc-10.0-rc1/doc

The Erlang/OTP source can also be found at GitHub on the official Erlang repository,

https://github.com/erlang/otp

OTP-21.0-rc1

Thank you for all your contributions!

Check out http://blog.erlang.org

• crypto, ssl

•  ssl

• stdlib

Erlang/OTP 20.1 is the first service release for the 20 major release.
The service release contains mostly bug fixes and characteristics improvements but also some new features.

Some highlights for 20.1

• crypto, public_key: Extend crypto and public_key functions sign and verify with:

  • support for RSASSA-PS padding for signatures and for
    saltlength setting
  • X9.31 RSA padding.
  • sha, sha224, sha256, sha384, and sha512 for dss
    signatures as mentioned in NIST SP 800-57 Part 1.
  • ripemd160 to be used for rsa signatures.

• A new tuple in crypto:supports/0 reports supported MAC
  algorithms.

• diameter:

  • Add service option decode_format to allow incoming messages to be decoded into maps
    instead of records.
  • Decode performance has been improved.
  • Add service/transport option avp_dictionaries to give better support for dictionaries only defining AVPs.

• erts: Upgraded the ERTS internal PCRE library from version 8.40 to version 8.41.

• erts, kernel, tools: Profiling with lock counting can now be fully toggled at runtime in
  the lock counting emulator (-emu_type lcnt). Everything
  is enabled by default to match the old behavior, but
  specific categories can be toggled at will with minimal
  runtime overhead when disabled. Refer to the
  documentation on lcnt:rt_mask/1 for details.

  lcnt:collect and lcnt:clear will no longer block all
  other threads in the runtime system. This makes it possible to run the lock counting
  under heavier load.

• erts: The zlib module has been refactored and all its operations will now yield appropriately,
  allowing them to be used freely in concurrent applications.

• erts, tools: Add erlang:iolist_to_iovec/1, which converts an
  iolist() to an erlang:iovec(), which is suitable for use
  with enif_inspect_iovec().

• erts: Add new nif API functions for managing an I/O Queue.
  The added functions are: enif_ioq_create(), enif_ioq_destroy(), enif_ioq_enq_binary(),
  enif_ioq_enqv(), enif_ioq_deq(), enif_ioq_peek(), enif_inspect_iovec(), enif_free_iovec()

• observer/crashdump_viewer:

  • Reading of crash dumps with many binaries is optimized.
  • A progress bar is shown when the detail view for a process is opened.
  • The cdv script now sets ERL_CRASH_DUMP_SECONDS=0 to
    avoid generating a new crash dump from the node running the Crashdump Viewer.

• observer:
  Add system statistics and limits to frontpage in
  observer.

• public_key, ssl**:
  Improved error propagation and reports

• ssh: A new option modify_algorithms is implemented. It
  enables specifying changes on the default algorithms
  list. See the reference manual and the SSH User's Guide
  chapter "Configuring algorithms in SSH".

• tools/xref: The predefined Xref analysis locals_not_used now understands
  the -on_load() attribute and does not report unused functions.

• tools/fprof: When sampling multiple processes and analyzing
  with totals set to true, the output now sums together
  all caller and callee entries which concerns the same
  function. Previous behaviour was to report each
  contributing entry separately.

You can find the README and the full listing of changes for this service release at

http://www.erlang.org/download/otp_src_20.1.readme

The source distribution and binary distributions for Windows can be
downloaded from

http://www.erlang.org/download/otp_src_20.1.tar.gz
http://www.erlang.org/download/otp_win32_20.1.exe
http://www.erlang.org/download/otp_win64_20.1.exe

Note: To unpack the TAR archive you need a GNU TAR compatible program.

For installation instructions please consult the README file that is part
of the distribution.

The Erlang/OTP source can also be found at GitHub on the official Erlang
repository, https://github.com/erlang/otp with tag OTP-20.1

The on-line documentation can be found at: http://www.erlang.org/doc/
You can also download the complete HTML documentation or the Unix manual files

http://www.erlang.org/download/otp_doc_html_20.1.tar.gz
http://www.erlang.org/download/otp_doc_man_20.1.tar.gz

Please report any new issues via Erlang/OTPs public issue tracker

https://bugs.erlang.org

We want to thank all of those who sent us patches, suggestions and bug reports!

Thank you!

The Erlang/OTP Team at Ericsson

Erlang/OTP 20.0 is a new major release with new features, quite a few (characteristics) improvements, as well as a few incompatibilities.

There are only minor changes compared to the second release candidate, some of them listed below:

• ERTS:
  • erlang:term_to_binary/1 changed the encoding of all atoms from ATOM_EXT to ATOM_UTF8_EXT and SMALL_ATOM_UTF8_EXT. This is now changed so that only atoms actually containing unicode characters are encoded with the UTF8 tags while other atoms are encoded ATOM_EXT just as before.

Here are some of the most important news in OTP 20:

Potential Incompatibilities

• ERTS:

  • The non SMP Erlang VM is deprecated and not built by default
  • Remove deprecated erlang:hash/2
  • erlang:statistics/1 with scheduler_wall_time now also includes info about dirty CPU schedulers.
  • The new purge strategy introduced in OTP 19.1 is mandatory and slightly incompatible for processes holding funs
    see erlang:check_process_code/3.
  • The NIF library reload is not supported anymore.
  • Atoms can now contain arbitrary unicode characters which means that the DFLAG_UTF8_ATOMS capability in the distribution protocol must be supported if an OTP 20 node should accept the connection with another node or library. Third party libraries which uses the distribution protocol need to be updated with this.

• Asn1: Deprecated module and functions removed (asn1rt, asn1ct:encode/3 and decode/3)

• Ssh: client only option in a call to start a daemon will now fail

Highlights

Erts:

• Dirty schedulers enabled and supported on VM with SMP support.
• support for “dirty” BIFs and “dirty” GC.
• erlang:garbage_collect/2 for control of minor or major GC
• Erlang literals are no longer copied when sending messages.
• Improved performance for large ETS tables, >256 entries (except ordered_set)
• erlang:system_info/1 atom_count and atom_limit
• Reduced memory pressure by converting sub-binaries to heap-binaries during GC
• enif_select, map an external event to message
• Improvements of timers internally in the VM resulting in reduced memory consumption and more efficient administration for timers

Compiler:

• Code generation for complicated guards is improved.
• Warnings for repeated identical map keys. #{'a'=>1, 'b'=>2, 'a'=>3} will warn for the repeated key a.
• By default there is now a warning when export_all is used. Can be disabled
• Pattern matching for maps is optimized
• New option deterministic to omit path to source + options info the BEAM file.
• Atoms may now contain arbitrary unicode characters.
• compile:file/2 has an option to include extra chunks in the BEAM file.

Misc other applications

• Significantly updated string module with unicode support and many new functions
• crypto now supports OpenSSL 1.1
• Unnamed ets tables optimized
• gen_fsm is deprecated and replaced by gen_statem
• A new event manager to handle a subset of OS signals in Erlang
• Optimized sets add_element, del_element and union
• Added rand:jump/0-1
• When a gen_server crashes, the stacktrace for the client will be printed to facilitate debugging.
• take/2 has been added to dict, orddict, and gb_trees.
• take_any/2 has been added to gb_trees
• erl_tar support for long path names and new file formats
• asn1: the new maps option changes the representation of SEQUENCE to be maps instead of records
• A TLS client will by default call public_key:pkix_verify_hostname/2 to verify the hostname
• ssl: DTLS documented in the API, experimental
• ssh: improving security, removing and adding algorithms
• New math:fmod/2

For more details see
http://erlang.org/download/otp_src_20.0.readme

The Erlang/OTP source can also be found at GitHub on the official Erlang repository,
https://github.com/erlang/otp with tag OTP-20.0

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_20.0.exe
http://erlang.org/download/otp_win64_20.0.exe

On line documentation can be browsed here:
www.erlang.org/doc/

Thanks to all contributors.

OTP 20 Release Candidate 1

This is the first of two release candidates before the OTP 20 release in June 2017.

The intention with this release is that you as users try it and give us feedback if something does not work as expected. Could be a bug, an unexpected incompatibility, a significant change of characteristics in negative direction, etc.

Erlang/OTP 20.0 is a new major release with new features, quite a few (characteristics) improvements, as well as a few incompatibilities.
 

Here are some of the most important news:

Potential Incompatibilities

• ERTS:

  • The non SMP Erlang VM is deprecated and not built by default
  • Remove deprecated erlang:hash/2
  • erlang:statistics/1 with scheduler_wall_time now also includes info about dirty CPU schedulers.
  • The new purge strategy introduced in OTP 19.1 is mandatory and slightly incompatible for processes holding funs
    see erlang:check_process_code/3.
  • The NIF library reload is not supported anymore.

• Asn1: Deprecated module and functions removed (asn1rt, asn1ct:encode/3 and decode/3)

• Ssh: client only option in a call to start a daemon will now fail

Highlights

Erts:

• Dirty schedulers enabled and supported on VM with SMP support.
• support for “dirty” BIFs and “dirty” GC.
• erlang:garbage_collect/2 for control of minor or major GC
• Erlang literals are no longer copied when sending messages.
• Improved performance for large ETS tables, >256 entries (except ordered_set)
• erlang:system_info/1 atom_count and atom_limit
• Reduced memory pressure by converting sub-binaries to heap-binaries during GC
• enif_select, map an external event to message

Compiler:

• Code generation for complicated guards is improved.
• Warnings for repeated identical map keys. #{'a'=>1, 'b'=>2, 'a'=>3} will warn for the repeated key a.
• By default there is now a warning when export_all is used. Can be disabled
• Pattern matching for maps is optimized
• New option deterministic to omit path to source + options info the BEAM file.
• Atoms may now contain arbitrary unicode characters.
• compile:file/2 has an option to include extra chunks in the BEAM file.

Misc other applications

• Unnamed ets tables optimized
• A new event manager to handle a subset of OS signals in Erlang
• Optimized sets add_element, del_element and union
• Added rand:jump/0-1
• When a gen_server crashes, the stacktrace for the client will be printed to facilitate debugging.
• take/2 has been added to dict, orddict, and gb_trees.
• take_any/2 has been added to gb_trees
• Significantly updated string module with unicode support
• erl_tar support for long path names and new file formats
• Dtls: Documented API, experimental
• SSH: improving security, removing and adding algorithms
• New math:fmod/2

For more details see
http://erlang.org/download/otp_src_20.0-rc1.readme

Pre built versions for Windows can be fetched here:
http://erlang.org/download/otp_win32_20.0-rc1.exe
http://erlang.org/download/otp_win64_20.0-rc1.exe

On line documentation can be browsed here:
www.erlang.org/documentation/doc-9.0-rc1/doc/

Thanks to all contributors.

Reporting a Security Issue in Erlang/OTP

Please follow this document in order to report the issues regarding security in Erlang/OTP. Please do not create a public issue for a security issue.

When should you report a security issue?

The risk level is often determined by a product of the impact once exploited, and the probability of exploitation occurring. In other words, if a bug can cause great damage, but it takes highest privilege to exploit the bug, then the bug is not a high risk one. Similarly, if the bug is easily exploitable, but its impact is limited, then it is not a high risk issue either.

There is not any hard and fast rule to determine if a bug is worth reporting as a security issue to erlang-security [at] erlang [dot] org. A general rule is that an attack by someone that has no access to the Erlang application or its system can affect the confidentiality, integrity and availability.

What happens after the report?

All security bugs in the Erlang/OTP distribution should be reported to erlang-security [at] erlang [dot] org. Your report will be handled by a small security team at the OTP team. Your email will be acknowledged as soon as we start handling the issue.

Please use a descriptive email title for your report. After the initial response to your report, the security team will keep you updated on the progress and decision being made towards a fix and release announcement.

Flagging Existing Issues as Security-related

If you believe that an existing public issue on bugs.erlang.org is security-related, we ask that you send an email to erlang-security [at] erlang [dot] org. The email title should contain the issue ID on bugs.erlang.org (e.g. Flagging security issue ERL-001). Please include a short description to motivate why it should be handled according to the security policy.

Some highlights for 19.3

• crypto, ssh: The implementation of the key exchange algorithms diffie-hellman-group-exchange-sha* are optimized, up to a factor of 11 for the slowest ( = biggest and safest) group size.
• dialyzer: The peak memory consumption is reduced.
  Analyzing modules with binary construction with huge strings is now much faster.
• erts: A received SIGTERM signal to beam will generate a 'stop' message to the init process and terminate the Erlang VM nicely. This is equivalent to calling init:stop/0.
• kernel: The functions in the 'file' module that take a list of paths (e.g. file:path_consult/2) will now continue to search in the path if the path contains something that is not a directory.
  Two OTP processes that are known to receive many messages are 'rex' (used by 'rpc') and 'error_logger'. Those processes will now store unprocessed messages outside the process heap, this will improve their capability to handle large message queues.
• public_key: New function pkix_verify_hostname/2,3 Implements certificate hostname checking. See the manual and RFC 6125.
• public_key, ssh: The ssh host key fingerprint generation now also takes a list of algorithms and returns a list of corresponding fingerprints. See public_key:ssh_hostkey_fingerprint/2 and the option silently_accept_hosts in ssh:connect.
• ssl: Move PEM cache to a dedicated process, to avoid making the SSL manager process a bottleneck. This improves scalability of TLS connections.
• stdlib: filename:safe_relative_path/1 to sanitize a relative path has been added.
• Thanks to more than 20 different contributors

You can find the README and the full listing of changes for this service release at
http://www.erlang.org/download/otp_src_19.3.readme
The Erlang/OTP source can also be found at GitHub on the official Erlang repository,
https://github.com/erlang/otp with tag OTP-19.3

Please report any new issues via Erlang/OTPs public issue tracker

https://bugs.erlang.org

We want to thank all of those who sent us patches, suggestions and bug reports!

Thank you!

The Erlang/OTP Team at Ericsson

Some highlights for 19.2

• STDLIB: The new behaviour gen_statem has been improved with 3 new features: the possibility to use old style non-proxy timeouts for gen_statem:call/2,3, state entry code, and state timeouts. These are backwards compatible. Minor code and documentation improvements has been performed including a borderline semantics correction of timeout zero handling.
• SSL: Experimental version of DTLS. It is runnable but not complete and cannot be considered reliable for production usage. To use DTLS add the option {protocol, dtls} to ssl:connect and ssl:listen.
• SSH: Extended the option silently_accept_hosts for ssh:connect to make it possible for the client to check the SSH host key fingerprint string. Se the reference manual for SSH.
• ~40 contributions since the previous service release OTP 19.1

You can find the README and the full listing of changes for this service release at

  http://www.erlang.org/download/otp_src_19.2.readme
  
The source distribution and binary distributions for Windows can be
downloaded from

  http://www.erlang.org/download/otp_src_19.2.tar.gz
  http://www.erlang.org/download/otp_win32_19.2.exe
  http://www.erlang.org/download/otp_win64_19.2.exe
  
Note: To unpack the TAR archive you need a GNU TAR compatible program.

For installation instructions please consult the README file that is part of the distribution.

The Erlang/OTP source can also be found at GitHub on the official Erlang
repository, https://github.com/erlang/otp with tag OTP-19.2

The on-line documentation can be found at: http://www.erlang.org/doc/
You can also download the complete HTML documentation or the Unix manual files

  http://www.erlang.org/download/otp_doc_html_19.2.tar.gz
  http://www.erlang.org/download/otp_doc_man_19.2.tar.gz
  
Please report any new issues via Erlang/OTPs public issue tracker 

   https://bugs.erlang.org
   
We want to thank all of those who sent us patches, suggestions and bug reports!

Thank you!

The Erlang/OTP Team at Ericsson

We have just released the source code for erlang.org website on Github. 

https://github.com/erlang/erlang-org

The website is written in Cowboy, ErlyDTL and sumo_db. It is licensed under Apache License 2.0. You can follow the instructions to set up. 

The erlang.org website is developed and maintained by Industrial Erlang User Group in collaboration with Erlang/OTP team at Ericsson.

Happy hacking!

Some highlights of the release are:

• erts: Improved dirty scheduler support. A purge of a module will not have to wait for completion of all ongoing dirty NIF calls.
• erts: Improved accuracy of timeouts on MacOS X.
• kernel: Add net_kernel:setopts/2 and net_kernel:getopts/2 to control options for distribution sockets in runtime.
• asn1: Compiling multiple ASN.1 modules in the same directory with parallel make (make -j) should now be safe.
• httpd: support for PUT and DELETE in mod_esi
• ~30 contributions since 19.0

You can find the Release Notes with more detailed info at

http://www.erlang.org/download/otp_src_19.1.readme

The Windows binary distributions can be downloaded from

http://www.erlang.org/download/otp_win32_19.1.exe

http://www.erlang.org/download/otp_win64_19.1.exe

You can also download the complete HTML documentation or the Unix manual files

http://www.erlang.org/download/otp_doc_html_19.1.tar.gz
http://www.erlang.org/download/otp_doc_man_19.1.tar.gz

You can also read the documentation on-line here:
(see the Release Notes mentioned above for release notes which
are not updated in the doc, but the new functionality is)

http://www.erlang.org/doc/

We also want to thank those that sent us patches, suggestions and bug reports.

If you find bugs in Erlang/OTP report them via the public issue tracker at http://bugs.erlang.org

The Erlang/OTP Team at Ericsson

The following decisions regarding EEPs (Erlang Enhancement Proposals) has been taken during the spring:

EEP-45 Function_Name and Function_Arity as macros

Approved

Already implemented and available in OTP 19.0-rc1.

EEP-44 Additional preprocessor directives

Partly Approved

Only the -warning and -error directives was approved and they are already implemented and available in OTP 19.0-rc1.

Some of the reasons for not approving the other directives in EEP-44 where:

• Rather unclear what an OTP_RELEASE is and it will not be clearer as there are plans to split OTP in several parts.

• Could lead to strange situations if these directives are combined with a package manager which also deals with dependencies.

• Could lead to strange situations if testing for a version or existence of functions in non OTP modules.

In summary we where not convinced that the new directives will solve more problems than they might introduce. It is also already rather easy to create a preprocessor variable in the build-procesess that can be used in combination with -ifdef to achieve similar effects.

Erlang/OTP 19.0-rc1 is available for testing.

This is the release candidate before the final OTP 19.0 product release in June 2016.

Between the 19.0 rc1 and the final release there will be new updates of
the master branch with corrections and minor new features.
Occasionally there might be new tags which we in that
case will communicate and ask you to test.

Erlang/OTP 19.0 is a new major release with new features, quite a few (characteristics) improvements, as well as a few incompatibilities.

See the Release Notes and the documentation for more details.

We would like to ask you to build and test this release candidate and send us
your feedback as soon as possible, so that we can make the necessary
corrections before OTP 19.0.

The release contains many changes; thus, some unexpected incompatibilities
or issues may have slipped through our tests.
Please try to build and run your current products/applications and let us
know about any problems.

Some highlights of the release are:

• compiler, stdlib:
  • New preprocessor macros ?FUNCTION_NAME, ?FUNCTION_ARITY
  • New preprocessor directives -error(Term) and -warning(Term) to cause a compilation error or warning, respectively.
• gen_statem a new state machine behavior
• mnesia_ext: plugin of external storage solutions to mnesia
• crypto: uses EVP interface in OpenSSL resulting in generally better performance and support for HW acceleration
• ssh: performance improvements, uses the new gen_statem behavior
• dialyzer: the support for maps is very much extended both the type specification syntax and the type analysis.
• erts:
  • erlang:open_port(spawn, ...) 3-5 times faster
  • tracing, extensive improvements (scalability, speed, match specifications on send/receive, support for lttng, ...)
  • dirty schedulers improved
  • per process configurable handling of message_queue
  • fast loading of multiple modules
  • max_heap_size process flag
  • and much more ....

You can find the Release Notes with more detailed info at

http://www.erlang.org/download/OTP-19.0-rc1.README

You find the source code at github.com in the official Erlang repository.

Git tag OTP-19.0-rc1

https://github.com/erlang/otp/tree/OTP-19.0-rc1

You can also read the documentation on-line here:
(see the Release Notes mentioned above for release notes which
are not updated in the doc, but the new functionality is)

http://www.erlang.org/documentation/doc-8.0-rc1/doc/

We also want to thank all of you that have contributed with new features, bug-fixes, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

Some highlights of the release are:

• New statistics info about runnable and active processes & ports. 
  Call erlang:statistics with total_run_queue_lengths | run_queue_lengths | total_active_tasks | active_tasks.
• Time warp improvements: dbg:p/2 and erlang:trace/3 with monotonic_timestamp | strict_monotonic_timestamp.
• Introduced a validation callback for heart.
• The module overload in sasl has been deprecated.
• ~90 contributions since 18.2

You can find the Release Notes with more detailed info at

http://www.erlang.org/download/otp_src_18.3.readme

The Windows binary distributions can be downloaded from

http://www.erlang.org/download/otp_win32_18.3.exe

http://www.erlang.org/download/otp_win64_18.3.exe

You can also download the complete HTML documentation or the Unix manual files

http://www.erlang.org/download/otp_doc_html_18.3.tar.gz 
http://www.erlang.org/download/otp_doc_man_18.3.tar.gz

You can also read the documentation on-line here: 
(see the Release Notes mentioned above for release notes which 
are not updated in the doc, but the new functionality is)

http://www.erlang.org/doc/

We also want to thank those that sent us patches, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

Due to a bug in the handling of paths on windows none of the following would work with paths containing a space:

• ct_run
• dialyzer
• erlc
• escript
• typer

This also contains a fix for HiPE enabled emulator for FreeBSD.

Erlang/OTP 18.2 is a service release on the 18 track with mostly bug fixes, but is does contain a number of new features and characteristics improvements as well. 

Some highlights of the release are:

• ssl: Add configurable upper limit for session cache.
• erts: Add function enif_getenv to read OS environment variables in a portable way from NIFs.
• kernel: Add {line_delim, byte()} option to inet:setopts/2 and decode_packet/3
• ssh: The 'ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384' and 'ecdsa-sha2-nistp521' signature algorithms for ssh are implemented. See RFC 5656.
• ssh: The ssh:daemon option dh_gex_groups is extended to read a user provided ssh moduli file with generator-modulus pairs. The file is in openssh format.
• Thanks to 41 different contributors!

You can find the Release Notes with more detailed info at

http://www.erlang.org/download/otp_src_18.2.readme

The Windows binary distributions can be downloaded from

http://www.erlang.org/download/otp_win32_18.2.exe

http://www.erlang.org/download/otp_win64_18.2.exe

You can also download the complete HTML documentation or the Unix manual files

http://www.erlang.org/download/otp_doc_html_18.2.tar.gz 
http://www.erlang.org/download/otp_doc_man_18.2.tar.gz

You can also read the documentation on-line here: 
(see the Release Notes mentioned above for release notes which 
are not updated in the doc, but the new functionality is)

http://www.erlang.org/doc/

We also want to thank those that sent us patches, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

December 8th 2015 marks the seventeenth year since Erlang/OTP was released as open source. 

What is Erlang/OTP and why was Erlang Open Sourced?

The Erlang programming language was created and implemented in the Ericsson Computer Science Laboratory, headed by Bjarne Däcker. Later, a separate organisation was created within Ericsson - the OTP unit. Its aim was to commercialise and stabilise the implementation of Erlang, its libraries, tools and documentation. This unit still continues today, headed by Kenneth Lundin.

Prior to being released as Open Source, Erlang and OTP was used to develop several commercial telecommunication products by Ericsson. Erlang/OTP was released as open source to encourage innovation and to spread the use of Erlang. The Open Source release was thus well tested and stable.

What has happened during the 17 years?

"Looking back, it was a beneficial decision for both Ericsson and the Open Source community,” says Kenneth Lundin, head of Erlang/OTP, who is one of the original staff members.

The characteristics of Erlang and OTP - fault tolerance, massive concurrency, scalable distribution and ease of software development - have found applications in many other innovative areas. In the mid 2000s, the introduction of support for multicore (Symmetric multiprocessing, SMP) gave Erlang/OTP a major boost in popularity. 

We are now seeing products developed in applications as diverse as banking, network supervision, gaming, cloud services, databases, messaging and Internet of Things to name but a few.

Where is Erlang going?

Erlang and OTP nowadays witness an increasing popularity across industries, used by companies such as WhatsApp, Facebook, Bet365 and Machine Zone. "It is exciting to see that what started as a small project an a software research laboratory has grown into the basis of commercial successes around the world,” says Mike Williams, one of the co-inventors.

In 2015, Erlang/OTP 18.0 was released under a less restrictive and OSI-approved Apache License 2.0. Behind the license change was the Industrial Erlang User Group, a group of enterprise users of Erlang/OTP collaborating with Ericsson in securing the future health, well being and commercial success of the Erlang outside of Ericsson.

Bruce Yinhe

community-manager@erlang.org

Berlin Erlang Factory Lite is back on 1 Dec. Get ready for one day of Erlang and Elixir talks ranging from beginner to advanced. Meet experts such as Sonny Scroggin and Peer Stritzinger as well as local members of the Erlang and Elixir communities: http://www.erlang-factory.com/berlin2015/#speakers 

Three days courses on Elixir - Phoenix, Erlang Express and OTP Express will be held after the conference on 2-4 Dec: http://www.erlang-factory.com/berlin2015/training#elixir-phoenix-24-december

To get a 50% off student discount email conferences@erlang-solutions.com from the university email account.

 

 

The Dublin Erlang Factory is a single day conference focused on Erlang and Elixir programming. It’s undoubtedly a great opportunity for all tech lovers passionate about Erlang/OTP/Elixir programming to meet up, learn about new emerging technologies, exchange ideas, inspire and get inspired by others!

The Dublin Erlang Factory Lite 2015 will take place Friday afternoon on 11 Sept, hosted by the friendly folks at AOL.

The programme and speaker lineup includes Joe Armstrong, Erlang's Co-Inventor, sharing his brilliant ideas through a keynote talk and also a tutorial (a limited number of seats still available), Philip Clarke (AOL) diving into the topic of Real Time Bidding Exchange, Christopher Brown (University of St Andrews) presenting LAPEDO framework for programming heterogeneous multicore systems in Erlang, and many more.

The Erlang Factory Lite is co-organised by AOL and Erlang Solutions and is organised in conjunction with the Kats Conf 15.

Tickets available here http://www.erlang-factory.com/dublin2015/home#registration

Find more details here http://www.erlang-factory.com/dublin2015

Erlang/OTP 18.0 is a new major release with new features, quite a few (characteristics) improvements, as well as some incompatibilities. 
A non functional but major change this release is the change of license to Apache License 2.0.

Some highlights of the release are:
 

• Starting from 18.0 Erlang/OTP is released under the Apache License 2.0
• erts: The time functionality has been extended. This includes a new API for 
  time, as well as "time warp" modes which alters the behavior when system time changes. You are strongly encouraged to use the new API instead of the old API based on erlang:now/0. erlang:now/0 has been deprecated since it is a scalability bottleneck. 
  For more information see the Time and Time Correction chapter of the ERTS User's Guide. Here is a linkhttp://www.erlang.org/doc/apps/erts/time_correction.html
• erts: Beside the API changes and time warp modes a lot of scalability and performance improvements regarding time management has been made. Examples are: 
  • scheduler specific timer wheels, 
  • scheduler specific BIF timer management, 
  • parallel retrieval of monotonic time and system time on OS:es that support it.
• erts: The previously introduced "eager check I/O" feature is now enabled by default.
• erts/compiler: enhanced support for maps. Big maps new uses a HAMT (Hash Array Mapped Trie) representation internally which makes them more efficient. There is now also support for variables as map keys.  
• dialyzer: The -dialyzer() attribute can be used for suppressing warnings 
  in a module by specifying functions or warning options. 
  It can also be used for requesting warnings in a module.
• ssl: Remove default support for SSL-3.0 and added padding check for TLS-1.0 due to the Poodle vulnerability.
• ssl: Remove default support for RC4 cipher suites, as they are consider too weak.
• stdlib: Allow maps for supervisor flags and child specs
• stdlib: New functions in ets:
  • take/2. Works the same as ets:delete/2 but
              also returns the deleted object(s).
  • ets:update_counter/4 with a default object as
              argument

You can find the Release Notes with more detailed info at

http://www.erlang.org/download/otp_src_18.0.readme

IMPORTANT INFO when building your own code with this OTP release

Since erlang:now is deprecated your build might stop if you are using
"warnings as errors".
To let the build through you can turn of warnings for deprecated functions
by setting an environment variable like this:
  export ERL_COMPILER_OPTIONS=nowarn_deprecated_function

You find the source code at github.com in the official Erlang repository.

Git tag OTP-18.0

https://github.com/erlang/otp/tree/OTP-18.0

You can also read the documentation on-line here: 
(see the Release Notes mentioned above for release notes which 
are not updated in the doc, but the new functionality is)

http://www.erlang.org/doc/

We also want to thank those that sent us patches, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

Join us in Stockholm on 11-12 June  for great talks about Erlang/OTP and Elixir innovations, the latest Erlang projects from companies such as Klarna, Machine Zone, Ericsson and much more: http://www.erlang-factory.com/euc2015/#home

Among the speakers are Erlang's co-inventor Robert Virding, functional expert Bodil Stokke, University of Kent professor Simon Thompson, Neotoma creator Sean Cribbs, author of the Cowboy web server Loïc Hoguin, Joacim Halén - Ericsson cloud technology researcher, Fredrik Linder - Erlang lead at Machine Zone, Alvaro Videla- co-author of ‘RabbitMQ in action’,  professor Kevin Hammond from University of St. Andrews, and Mikael Pettersson - senior developer at Klarna.

The Conference will be preceded by one day of tutorials at Ericsson on 10 June and 3 days of expert on 8-10 June: http://www.erlang-factory.com/euc2015/training#erlang-express-810-june

For more details see the README file at http://www.erlang.org/download/otp_src_17.5.readme

Erlang/OTP 18.0-rc1 is available for testing.

This is an alpha release, which will be followed by a planned beta release in May and a final OTP 18.0 product release in June 2015.

Between the alpha and beta and final release there will be new updates of the master branch with corrections and minor new features. Occasionally there might be new tags which we in that case will communicate and ask you to test.

Erlang/OTP 18.0 is a new major release with new features, quite a few (characteristics) improvements, as well as a few incompatibilities. 

See the Release Notes and the documentation for more details.

We would like to ask you to build and test the alpha release and send us your feedback as soon as possible, so that we can make the necessary corrections before OTP 18.0-rc2 and OTP 18.0, respectively.

The release contains many changes; thus, some unexpected incompatibilities or issues may have slipped through our tests. Please try to build and run your current products/applications and let us know about any problems.

IMPORTANT INFO when building your own code with this OTP release

Since erlang:now is deprecated your build might stop if you are using "warnings as errors".

To let the build through you can turn of warnings for deprecated functions by setting an environment variable like this:

export ERL_COMPILER_OPTIONS=nowarn_deprecated_function

Some highlights of the release are:

• dialyzer: The -dialyzer() attribute can be used for suppressing warnings in a module by specifying functions or warning options. It can also be used for requesting warnings in a module.
• erts: The time functionality has been extended. This includes a new API for time, as well as "time warp" modes which alters the behavior when system time changes. You are strongly encouraged to use the new API instead of the old API based on erlang:now/0. erlang:now/0 has been deprecated since it will always be a scalability bottleneck. For more information see the Time and Time Correction chapter of the ERTS User's Guide. Here is a link http://www.erlang.org/documentation/doc-7.0-rc1/erts-7.0/doc/html/time_correction.html
•  
• erts: Beside the API changes and time warp modes a lot of scalability and performance improvements regarding time management has been made. Examples are:
  
  • scheduler specific timer wheels,
  • scheduler specific BIF timer management,
  • parallel retrieval of monotonic time and system time on OS:es that support it.
• erts: The previously introduced "eager check I/O" feature is now enabled by default.
• erts/compiler: enhanced support for maps. Big maps new uses a HAMT (Hash Array Mapped Trie) representation internally which makes them more efficient. There is now also support for variables as map keys.  
• ssl: Remove default support for SSL-3.0 and added padding check for TLS-1.0 due to the Poodle vulnerability.
• ssl: Remove default support for RC4 cipher suites, as they are consider too weak.
• stdlib: Allow maps for supervisor flags and child specs

You can find the Release Notes with more detailed info at http://www.erlang.org/download/otp18rc1_relnotes.pdf

You find the source code at github.com in the official Erlang repository.

Git tag OTP-18.0-rc1

https://github.com/erlang/otp/tree/OTP-18.0-rc1

You can also read the documentation on-line here: (see the Release Notes mentioned above for release notes which are not updated in the doc, but the new functionality is)

http://www.erlang.org/documentation/doc-7.0-rc1/doc/

We also want to thank those that sent us patches, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

Erlang User Conference 2015

Stockholm 11-12 June

Call For Talks ends on 17 March

EUC 2015 will take place on 11-12 June, with one day of tutorials on 10 June and 3 days of expert training on 8-10 June: http://www.erlang-factory.com/euc2015

We are looking for passionate people who made an interesting innovation, open-source application or product with Erlang/OTP/Elixir. If you used Erlang or Elixir in a real-world project or you developed a cool tool, we want to hear about it! We are seeking talks aimed at beginners as much as for talks suited for more experienced users. This is to help newer members to the Erlang community make the maximum out of the EUC as well.    

The deadline for talk proposals is 17 March, please submit your talk here: http://goo.gl/forms/bO9kU9PYrr

Erlang Workshop 2015 will take place in Vancouver, September 4. The workshop will bring together the open source, academic, and industrial programming communities of Erlang. The workshop is open for technical (academic) papers as well as practice and applications papers describing "real-world" uses of Erlang.

See the call for papers here.

We are aware that parts of erlang.org need improvement. For example http://www.erlang.org/article/tag/examples and http://www.erlang.org/course/course.html are outdated. We would like to see a number of small code examples for beginners. The purpose of these examples is to provide an attractive and useful introduction for people who are interested in adopting the Erlang programming language. 

Please send your input to community-manager@erlang.org. We would like to call for help from the community since OTP team does not have too much time and it is not possible to submit pull requests for editorial of erlang.org as of now. 

Any other suggestions for erlang.org are always welcome.

Berlin EFL is back on 4 December, and we hope this year will be at least as fun as last year. The Call for Talks will be open until 10 October, but we tend to have more talks submitted than we have slots available, so the earlier you send yours the better your chances.

Have you made an interesting innovation, open-source application or product with Erlang/OTP? Have you used Erlang in a real-world project and want to present a case study? Or maybe you developed a cool tool? Let the crowd know about it! 

IMPORTANT: Elixir talks also welcome this year :) 

Link to submission form: https://docs.google.com/a/erlang-solutions.com/forms/d/1oD8J66a0pjOU-5Y8vG2Ffn8twyDIyPcRMFrPEdANaY4/viewform

Link to website: http://www.erlang-factory.com/berlin2014/home

Erlang/OTP 17.1 is a service release on the 17 track with mostly bug fixes, but is does contain a number of new features and characteristics improvements as well.

Some highlights of the release are:

• crypto: Add aes_cfb8 cypher to crypto:block_encrypt and block_decrypt.
• diameter: Add result code counters for CEA, DWA, and DPA.
• erts: The following built in functions in the erlang and binary modules now bump an appropriate amount
  of reductions and yield when out of reductions:
  binary_to_list/1, binary_to_list/3, bitstring_to_list/1, list_to_binary/1,
  iolist_to_binary/1, list_to_bitstring/1, binary:list_to_bin/1
• hipe: Handle Maps instructions get_map_elements, put_map_assoc,
  put_map_exact in the HiPE native code compiler.
• mnesia: The time for inserting locks for a transaction with large
  number of locks is reduced significantly.
• ssh: Option max_sessions added to ssh:daemon/{2,3}.
• stdlib: Add maps:get/3 to maps module. The function will return the
  supplied default value if the key does not exist in the map.

Many thanks to 24 different contributors in this release

You can find more info and download the release at the download page.

The Vancouver Erlang Factory Lite will take place on 17 May and will be hosted by the Simon Fraser University. The call for talks is open until 11 April. If you have a project you are working on that you'd like to share, submit before 11 April in the following Google doc.

The Erlang User Conference 2014 will feature over 50 talks on open-source applications, products and war stories from the Erlang world. The keynotes will be delivered by Stuart Bailey, CTO of Infoblox and by Katie Miller, OpenShift Developer Advocate and co-founder of the Lambda Ladies. Speakers include: ‘Seven Languages in Seven Weeks’ author Bruce Tate, co-designer of Haskell and QuickCheck John Hughes, O’Reilly author Erik Stenman, manager of the Ericsson Erlang/OTP dev team Kenneth Lundin, Rakuten lead technologist Yosuke Hara, Feuerlabs Co-founder and Developer Advocate Ulf Wiger and many more.

The conference will be followed by 3-day training courses on 11-13 June: Erlang Express, OTP Express, Elixir, Cowboy Express and Test Driven Development.

Early Bird rates end on 9 May.
http://www.erlang-factory.com/conference/EUC2014/

Erlang/OTP 17.0 is a new major release with new features, characteristics improvements, as well as some minor incompatibilities. See the README file and the documentation for more details.

Some highlights of the release are:

Erlang/OTP has been ported to the realtime operating system OSE.
• Maps, a new dictionary data type (experimental)
• A more natural mapping from ASN.1 OCTET STRING and BIT STRING to Erlang types, and other ASN.1 improvements and optimizations
• The {active, N} socket option for TCP, UDP, and SCTP
• A new (optional) scheduler utilization balancing mechanism
• Migration of memory carriers has been enabled by default on all ERTS internal memory allocators
• Increased garbage collection tenure rate
• Experimental "dirty schedulers" functionality
• Funs can now be given names
• Miscellaneous unicode support enhancements
• A new version scheme for OTP its applications has been introduced

You can find more information and download the release at the download page.

We had again a planned power outage at 6:30 - 15:00 Sunday March 23:d CET so the whole erlang.org site was down.

Apologies for any inconveniances.

Erlang/OTP 17.0-rc2 has been released.

This is a beta release, which will be followed by the final OTP 17.0 product release in the beginning of April.

Between this beta and the final release there will be new updates of the master branch with corrections and minor new features. Occasionally there might be new tags which we in that case will communicate and ask you to test.

Erlang/OTP 17.0 is a new major release with new features, quite a few (characteristics) improvements, as well as some incompatibilities. See the README file and the documentation for more details.

We would like to ask you to download and test the beta release and send us your feedback as soon as possible, so that we can make the necessary corrections before OTP 17.0.

The release contains many changes and a few potential incompatibilities. Please try to build and run your current products/applications and let us know about any problems.

One known, but previously insufficiently documented incompatibility that we would like to highlight is:

OTP-11719 == erts ==

The default encoding of Erlang files has been changed from ISO-8859-1 to UTF-8. The encoding of XML files has also been changed to UTF-8.

Please verify that your source code compiles with Erlang/OTP 17. If your (ISO-8559-1 / Latin-1 encoded) source code files contain characters that are outside of the bit 7-bit ASCII character set, you will receive a compiler error similar to the following:

tst.erl:1: cannot parse file, giving up
tst.erl:1: no module definition
tst.erl:1: cannot translate from UTF-8

In this case, you need to apply one of the following alternatives to each (impacted) file:

Alternative 1: Encode the file in UTF-8 (instead of Latin-1). If the file is going to be compiled with both OTP 17 and previous versions, insert a comment stating the encoding at the beginning of the file:

   %% -*- coding: utf-8 -*-

Alternative 2: Leave the file encoded as Latin-1 and insert a comment stating the encoding at the beginning of the file:

   %% -*- coding: latin-1 -*-

For detailed information, see the STDLIB User's Guide, 2 Using Unicode in Erlang

The 17.0 release contains many changes; thus, some unexpected incompatibilities or issues may have slipped through our tests. Please try to build and run your current products/applications and let us know about any problems.

Note! The new datatype MAP is not properly documented yet but the EEP 43 https://www.erlang.org/eeps/eep-0043.html will provide a good start. Also note that it is a limited implementation of maps implemented so far:

• no variable keys are allowed
• native code can not be generated for modules using maps

Some other highlights of the release are:

• Erlang/OTP has been ported to the realtime operating system OSE.
• Maps, a new dictionary data type (experimental)
• A more natural mapping from ASN.1 OCTET STRING and BIT STRING to Erlang types, and other ASN.1 improvements and optimizations
• The {active, N} socket option for TCP, UDP, and SCTP
• A new (optional) scheduler utilization balancing mechanism
• Migration of memory carriers has been enabled by default on all ERTS internal memory allocators
• Increased garbage collection tenure rate
• Experimental "dirty schedulers" functionality
• Funs can now be given names
• Miscellaneous unicode support enhancements
• A new, semantic version scheme for OTP and its applications

You can find the README file with more detailed info at http://www.erlang.org/download/otp_src_17.0-rc2.readme

You can download the full source distribution from http://www.erlang.org/download/otp_src_17.0-rc2.tar.gz

Note: To unpack the TAR archive you need a GNU TAR compatible program. For installation instructions please read the README that is part of the distribution.

You can also find this release at the official Erlang/OTP Git-repository at Github here: https://github.com/erlang/otp tagged *OTP_17.0-rc2*

The Windows binary distribution can be downloaded from

http://www.erlang.org/download/otp_win32_17.0-rc2.exe
http://www.erlang.org/download/otp_win64_17.0-rc2.exe

You can also download the complete HTML documentation or the Unix manual files http://www.erlang.org/download/otp_doc_html_17.0-rc2.tar.gz
http://www.erlang.org/download/otp_doc_man_17.0-rc2.tar.gz

We also want to thank those that sent us patches, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

Below you can find the preliminary release dates, and code stop dates for 17.0.
Note: We will not accept any NEW feature patches for inclusion in Erlang/OTP 17.0 after 2014-02-21.

Preliminary dates for the upcoming release:
Release:        erts, emu,comp  |Code stop           |Documentation stop        |Release Date

17.0-rc2         2014-02-21         2014-02-21         2014-02-21                        2014-02-26
17.0               2014-03-10         2014-03-17         2014-03-19                        2014-03-26

We will focus the time between 17.0-rc2 and 17.0 on bug fixes, improvements, and testing. Therefore you are most welcome to submit patches regarding such issues and we will try our best to include them before 17.0 is released.
Especially bugs introduced in 17.0-rcX.

Erlang Workshop 2014 will take place in Gothenburg, September 5. The workshop will bring together the open source, academic, and industrial programming communities of Erlang. The workshop is open for technical (academic) papers as well as practice and applications papers describing "real-world" uses of Erlang.

The Erlang Workshop is co-located with the (International Conference on Functional Programming) ICFP and the (Commercial Users of Functional Programming) CUFP, so schedule a visit to Gothenburg and learn abouth the latest in functional programming in general and Erlang in particular!

See the call for papers here.

Erlang User Conference Stockholm 9-10 June: Call for Talks now open

EUC2014 will take place on 9-10 June and will be followed by one day of tutorials on 11 June and 3 days of expert training on 11-13 June. http://www.erlang-factory.com/conference/EUC2014

The deadline for talk proposals is 10 March. If you are interested in giving a talk or tutorial, submit your talk here:

Preliminary track titles:

• Case Studies & Architecture
• Meta-programming with Elixir
• DevOps
• Cool Tools & Gadgets
• Next Generation Databases & Analytics
• Scalability & Multi-core
• Infrastructure & Distribution
• Erlang VM
   

Erlang/OTP 17.0-rc1 has been released.

This is an alpha release, which will be followed by a planned beta release about a month later and a final OTP 17.0 product release in the end of March, 2014.

Between the alpha and beta and final release there will be new updates of the master branch with corrections and minor new features. Occasionally there might be new tags which we in that case will communicate and ask you to test.

Erlang/OTP 17.0 is a new major release with new features, quite a few (characteristics) improvements, as well as some incompatibilities. See the README file and the documentation for more details.

We would like to ask you to download and test the alpha release and send us your feedback as soon as possible, so that we can make the necessary corrections before OTP 17.0-rc2 and OTP 17.0, respectively.

The release contains many changes; thus, some unexpected incompatibilities or issues may have slipped through our tests. Please try to build and run your current products/applications and let us know about any problems.

Note! The new datatype MAP is not properly documented yet but the EEP 43 https://www.erlang.org/eeps/eep-0043.html will provide a good start. Also note that it is a limited implementation of maps implemented so far:

• no variable keys are allowed
• native code can not be generated for modules using maps

Some other highlights of the release are:

• Maps, a new dictionary data type (experimental)
• A more natural mapping from ASN.1 OCTET STRING and BIT STRING to Erlang types, and other ASN.1 improvements and optimizations
• The {active, N} socket option for TCP, UDP, and SCTP
• A new (optional) scheduler utilization balancing mechanism
• Migration of memory carriers has been enabled by default on all ERTS internal memory allocators
• Increased garbage collection tenure rate
• Experimental "dirty schedulers" functionality
• Funs can now be given names
• Miscellaneous unicode support enhancements
• A new, semantic version scheme for OTP and its applications

You can find the README file with more detailed info at http://www.erlang.org/download/otp_src_17.0-rc1.readme

You can download the full source distribution from http://www.erlang.org/download/otp_src_17.0-rc1.tar.gz

Note: To unpack the TAR archive you need a GNU TAR compatible program. For installation instructions please read the README that is part of the distribution.

You can also find this release at the official Erlang/OTP Git-repository at Github here: https://github.com/erlang/otp tagged *OTP_17.0-rc1*

The Windows binary distribution can be downloaded from http://www.erlang.org/download/otp_win32_17.0-rc1.exe http://www.erlang.org/download/otp_win64_17.0-rc1.exe

You can also download the complete HTML documentation or the Unix manual files http://www.erlang.org/download/otp_doc_html_17.0-rc1.tar.gz http://www.erlang.org/download/otp_doc_man_17.0-rc1.tar.gz

We also want to thank those that sent us patches, suggestions and bug reports.

The Erlang/OTP Team at Ericsson

OTP R16B03-1 is a service release which corrects a few issues found in the R16B03 release. The corrections are:

• The ODBC application was missing in the prebuilt Windows installers
• 3 corrections in the SSL application:
  • Add missing validation of the server_name_indication option and test for its explicit use.
  • Elliptic curve selection in server mode now properly selects a curve suggested by the client, if possible.
  • The server did not indicate support for secure renegotiation during TLS extension handling.
• In the syntax tools application a bug was introduced which broke reverting of local funs. This is now corrected (thanks to Anthony Ramine)
• wx - Solved a problem which caused the debugger to crash when closing a window. Fixed static linking on Mac.
• xmerl - Fixed a problem in the SAX-parser when the header of the next document was appearing in the buffer when using the xmerl_sax_parser:stream/2 function.

The Zurich Erlang Factory Lite is back! Join us for a day of expert Erlang/Riak/Elixir talks on 10 April and three days of training on Erlang and OTP (7-9 April). Call for talks is open until 21 February.

http://www.erlang-factory.com/conference

There will be a planned power outage at Sun 15 Dec 7:00-14:00 CET
in the building where the erlang.org servers are located.  So all
services (www, mail, ...) will be down at least during that period.

We are sorry for any inconveniences this may cause the community.

...edit...

Our Internet provider cut the power to the internet router already at Fri 19:00 CET, so we were down almost all the weekend.  Apparently sh*** happens.  Sorry about that!

We are back up again, apparently... Hello World!

OTP R16B03 is a service release with mostly a number of small corrections and user contributions. But there are some new functions worth mentioning as well, here are some of them: 

•   A new memory allocation feature called "super carrier" has been introduced. It can for example be used for pre-allocation of all memory that the runtime system should be able to use. It is enabled by passing the +MMscs (size in MB) command line argument. For more information see the documentation of the +MMsco, +MMscrfsd, +MMscrpm, +MMscs, +MMusac, and, +Mlpm command line arguments in the erts_alloc(3) documentation.
• The LDAP client (eldap application) now supports the start_tls operation. This upgrades an existing tcp connection to encryption using TLS, see eldap:start_tls/2 and /3.
• The FTP client (inets application) now supports FTP over TLS (ftps).

~50 open source contributions. Many thanks for that!

We have a planned firewall upgrade at our connection provider at saturday march 16 daytime (8..18) CET. The downtime is expected to be some 15 minutes and promised less than an hour.

Erlang/OTP R15B03 has been released on schedule November 28:th. It is the third R15 service release.

See the release notes in the Read me

Download the new release from the Downloads page

Or prebuilt packages from Erlang Solutions Downloads page

Tech Mesh – The Alternative Programming Conference 4th-6th December

Tech Mesh takes place in London between the 4th and the 6th of December and it will go down in history with a first:

Joe Armstrong, Robert Virding and Mike Williams will be together on a stage for the first time, giving a joint keynote on ‘183 years of programming’

Other great talks include:

Garret Smith:  Building an Application Platform: Lessons from CloudBees

Stuart Bailey:  Erlang and OpenFlow: A Match Made in the Cloud!

Steve Vinoski: Implementing Riak in Erlang: Benefits and Challenges

Chris Brown: Living in a Polyglot World: Ruby on the client, Erlang on the server

Francesco Cesarini: OTP, the middleware for concurrent distributed scalable architectures

Pavlo Baron: 100% Big Data. 0% Hadoop. 0% Java

Jesper Richter Reichhelm: You are not alone - multiplayer games in Erlang

The event covers 8 tracks and over 50 speakers among whom are Simon Peyton Jones, Philip Wadler and John Hughes – also on a joint keynote, Rich Hickey, Bruce Tate – “author of 7 languages in 7 weeks”, Klarna CTO David Craelius and many more. For a full list of the over 50 speakers, check out the event programme on the website: http://techmeshconf.com/techmesh-london-2012/schedule/index.jsp.

See you at Tech Mesh!

Erlang/OTP R15B02 has been released on schedule September 5:th. It is the second R15 service release.

See the release notes in the Read me

Download the new release from the Downloads page

Or prebuilt packages from Erlang Solutions Downloads page

Highlights:

• Dialyzer: The type analysis tool Dialyzer is optimized to be generally faster. - It can now also run in parallel (default) on SMP systems and by this perform the analysis significantly faster (Thanks to Stavros Aronis and Kostis Sagonas)
• The SSL application now has experimental support for the TLS 1.1 and 1.2 standards as well (Thanks to Andreas Schultz).
• CommonTest: It is now possible to sort the generated html tables. A Netconf client (ct_netconf) which support basic netconf over ssh is added
• Diameter: Statistics counters related to Diameter messages can now be retrieved by calling the diameter:service_info/2 function.
• Various smaller optimizations in the Erlang VM
• This release also contains 66 contributions from users outside the Ericsson team

ErlangCamp is back, this time in Coruña Spain the 5-6:th of October.

We felt it our duty as good upstanding engineers to let you know about ErlangCamp 2012 which will be held in Coruña Spain this Oct 5th and 6th.

Why Erlang? Why ErlangCamp? And what could I possibly learn in two days?

In two days, you learn how to build world-class solutions using the technology that powers NoSQL data stores like Basho’s Riak and CouchDB, enterprise messaging platforms like VMWare’s RabbitMQ and ejabbard, Erlang Solutions’ OpenFlow software-defined network (SDN) switch LINC, VoIP platforms like Kazoo, financial exchange systems, and commercial solutions from companies like Ericsson, Klarna, Campajna, Tail-f Systems, 2600Hz, Machine Zone, ShoreTel, and Quviq.

Your instructors are experts at developing real-world Erlang/OTP-based solutions, including two of the authors of the "Erlang and OTP in Action" (http://manning.com/logan)

And, of course, you will be at the Universidade da Coruña, in scenic Northern Spain (Note* the program is in English). Take a couple extra days, and make it a working vacation!

For more information see the ErlangChamp website (http://erlangcamp.com) or email info@erlangcamp.com.

Spawnfest, a 48 hours programming contest for Erlang, is back again this year. It is scheduled for July 7-8, and open to any team of 1 to 4 members. Prizes to be given!

It's a great opportunity to show the world what Erlang/OTP and its users are capable of. The contest is in no way limited to web applications or any specific domain; diversity of entries is embraced.

Participants will see their entries judged by Eric B. Merrit ( founding member of the Erlware, co-author of "Erlang and OTP in Action"), Joe Armstrong (co-inventor of Erlang), Loïc Hoguin (Founder of Nine Nines, writer of Cowboy), and Scott Lystig Fritchie (long-time Erlang user, senior software engineer at Basho, worked on D-Trace for  Erlang, and so on).

You can register your team at http://spawnfest.com/

FlowForwarding.org has announced the availability of LINC, an Erlang based open source soft switch implementing the 1.2 version of the OpenFlow standard. The LINC switch has now been released as commercial friendly open source through the FlowForwarding.org community website, encouraging users and vendors to use LINC and contribute to its development. The initial LINC implementation focuses on correctness and feature compliance. Through an abstraction layer, specialized network hardware drivers can be easily interfaced to LINC. It has been implemented by using the power and flexibility of the Erlang programming language and software environment. Erlang allows for rapid industrial strength implementations, a key requirement for developing and deploying an evolving technology such as OpenFlow. For more information, visit FlowForwarding.org.

The description below is an excerpt from Erlang Solutions download page.

Erlang Solutions has the facilities to port Erlang to your operating system and hardware platform of choice. We have ported Erlang to a wide range of configurations, from embedded to high specification servers. These have included HiPE enabled, 32 and 64 bit configurations, alongside the half-word emulator. We have worked with operating systems such as VxWorks, OSE Delta, QNX, Android and iOS as well as the most popular operating systems. We are able to create and test customized binaries where your applications are packaged and tested alongside the OTP ones on the hardware / operating systems of your choice. Packages and ports that we are currently building and testing free of charge include popular Linux, Mac OS X and Windows versions. They can be downloaded from their Erlang Download page.

Erlang/OTP R15B01 has been released ahead of schedule on April 3:rd. It is the first service release.

See the release notes in the Read me

Download the new release from the Downloads page

Highlights:

• Added erlang:statistics(scheduler_wall_time) to ensure correct determination of scheduler utilization. Measuring scheduler utilization is strongly preferred over CPU utilization, since CPU utilization gives very poor indications of actual scheduler/vm usage.
• Changed ssh implementation to use the public_key application for all public key handling. This is also a first step for enabling a callback API for supplying public keys and handling keys protected with password phrases. Additionally the test suites where improved so that they do not copy the users keys to test server directories as this is a security liability. Also ipv6 and file access issues found in the process has been fixed.
• When an escript ends now all printout to standard output and standard error gets out on the terminal. This bug has been corrected by changing the behaviour of erlang:halt/0,1, which should fix the same problem for other escript-like applications, i.e. that data stored in the output port driver buffers got lost when printing on a TTY and exiting through erlang:halt/0,1. The BIF:s erlang:halt/0,1 has gotten improved semantics and there is a new BIF erlang:halt/2 to accomplish something like the old semantics. See the documentation.
• The DTrace source patch from Scott Lystig Fritchie is integrated in the source tree. Using an emulator with dtrace probe is still not supported for production use, but may be a valuable debugging tool. Configure with --with-dynamic-trace=dtrace (or --with-dynamic-trace=systemtap) to create a build with dtrace probes enabled. See runtime_tools for documentation and examples
• Added Torbjörn Törnkvists LDAP client as a new application called eldap.
• Added options for the ssh client to support user keys files that are password protected.

Erlang/OTP R15B has been released as planned on December 14:th 2011.

See the release notes in the readme file.

Download the new release from the download page.

We have recently pushed a new master to GitHub tagged OTP_R15A.

This is a stabilized snapshot of the current R15 development (to be released as R15B on December 14:th) which, among other things, includes:

OTP-9468  'Line numbers in exceptions'

OTP-9451  'Parallel make'

OTP-4779  A new GUI for Observer. Integrating pman, etop and tv into
                    observer with tracing facilities.

OTP-7775  A number of memory allocation optimizations have been
             implemented. Most optimizations reduce contention caused by
             synchronization between threads during allocation and
             deallocation of memory. Most notably:
             Synchronization of memory management in scheduler specific
             allocator instances has been rewritten to use lock-free
             synchronization.

             Synchronization of memory management in scheduler specific
             pre-allocators has been rewritten to use lock-free
             synchronization.

             The 'mseg_alloc' memory segment allocator now use scheduler
             specific instances instead of one instance. Apart from
             reducing contention this also ensures that memory allocators
             always create memory segments on the local NUMA node on a
             NUMA system.

OTP-9632  An ERTS internal, generic, many to one, lock-free queue for
             communication between threads has been introduced. The many
             to one scenario is very common in ERTS, so it can be used in
             a lot of places in the future. Currently it is used by
             scheduling of certain jobs, and the async thread pool, but
             more uses are planned for the future.

             Drivers using the driver_async functionality are not
             automatically locked to the system anymore, and can be
             unloaded as any dynamically linked in driver.

             Scheduling of ready async jobs is now also interleaved in
             between other jobs. Previously all ready async jobs were
             performed at once.

OTP-9631  The ERTS internal system block functionality has been
             replaced by new functionality for blocking the system. The
             old system block functionality had contention issues and
             complexity issues. The new functionality piggy-backs on
             thread progress tracking functionality needed by newly
             introduced lock-free synchronization in the runtime system.
             When the functionality for blocking the system isn't used,
             there is more or less no overhead at all. This since the
             functionality for tracking thread progress is there and
             needed anyway.

... and much much more.

This is not a full release of R15 but rather a pre-release. Feel free to try our R15A release and get back to us with your findings.

Your feedback is important to us and highly welcomed.

Regards,

The OTP Team

Erlang/OTP R14B04 has been released as planned on October 5:th 2011. It is the fourth R14 service release.

See the release notes in the readme file.

Download the new release from the download page.

This release is mainly a stabilization of the R14B03 release (but as
usual there are
some new functionality as well).

Proposals for who will become Erlang User of the Year are invited. Please send proposed names with a short motivation to Bjarne Däcker bjarne[at]cs-lab.org.

The selection will be made by a panel consisting of Joe Armstrong (prime creator of Erlang), Kenneth Lundin (manager of the Erlang/OTP team at Ericsson), Ulf Wiger (chief technical officer at Erlang Solutions Ltd) and some of the last few years' recipients of the award. The award will be presented at the Erlang User Conference in Stockholm on 3 November. In 2010 it was awarded to Kresten Krab Thorup at Trifork for his development of Erjang.

Erlang User Conference 2011.
It is  with great pleasure that we announce the launch of the 2011 Erlang User  Conference in Stockholm. The date for your diary is 3 November 2011.  Early Bird registration will open on 15 August so in the meantime if you  wish to submit a talk, we would love to hear from you.

After  the success of last year's Conference and it selling out, you will want  to book your place early. The Erlang User Conference brings together the  best minds and names in Erlang programming from language inventors,  implementers and maintainers. Open source committers, community leaders  and Erlang authors. Everyone who is anyone will be at the Erlang User Conference 2011!

The program for the Tenth ACM SIGPLAN Erlang Workshop on Friday September 23, 2011, in Tokyo, Japan,
has been released. Please see the program here.

The Spawnfest Erlang contest will be taking place on July 9-10. Teams of 1 to 4 members can register on the site. Prizes to be given!

ErlangCamp is back, this time in Boston. This year we have partnered with Erlang Solutions and their Erlang University Program. There is not enough information out there relating to how you write real production grade Erlang systems. ErlangCamp is a 2 day inexpensive workshop (12-13 August) that teach exactly that. The workshop will teach participants how to construct solid production grade Erlang OTP software. Among the instructors are the authors of Erlang and OTP in Action.

Erlang/OTP R14B03 has been released as planned on May 25:th 2011. It is the third R14 service release.

See the release notes in the readme file

Download the new release from the download page.

Highlights:

• Diameter is a brand new application in this release. The application support the diameter protocol specified in RFC 3588 and is intended to provide an Authentication, Authorization and Accounting (AAA) framework for applications. 
• The documentation for stdlib and kernel now uses type specifications from the source modules which should guarantee that the documentation and code are consistent with regard to the type information.

ACM SIGPLAN Erlang Workshop

The Tenth ACM SIGPLAN Erlang Workshop will take place in Tokyo, Japan, on September 23, 2011. Please see the call for papers here .

The Erlang Factory London is back! The dates you need for your diary are 6th, 7th and 8th June for the Erlang University courses and 9th and 10th June for the Erlang Factory Conference.

There are 10 places left at the very Early bird rate of £395 which is a saving of £200! Book now  to get your place!

 

The mailing lists at erlang.org are now back online after fixing a subtle Python "gotcha" configuration error.

Please report any posts that you feel slipped into the void, or double posts or whatnot!

Our demo site has now been launched as the regular erlang.org. We hope you like it. Report any problems.

Erlang/OTP R14B02 has been released as planned on March 16:th 2011. It is the second R14 service release.

See the release notes in the readme file

Download the new release from the download page.

Highlights:

• The "halfword" emulator is now official. A 64-bit emulator that uses less memory than the full 64-bit emulator.
• EDoc handles Erlang specifications and types.
• All test suites now run with CommonTest

Erlang/OTP R14B01 has been released as planned on September 15:th 2010. It is the first R14 service release.

See the release notes in the readme file

Download the new release from the download page.

Erlang/OTP R14B has been released as planned on September 15:th 2010. It is the first non-beta R14 release.

See the release notes in the readme file

Download the new release from the download page.

Erlang/OTP R14B  will be released on September 15th. This is 2 weeks later than previously announced.

Erlang/OTP R14A has been released. R14A is a beta release before the R14B release which is planned for September 1:st.

See the release notes in the readme file

Download the new release from the download page.

The Erlang Extension Proposals have been rewritten in Markdown format

They can be found at github and are readable online at /eeps/.

Read about it at EEP.

Members of the Erlang/OTP team is giving presentations at the Erlang Factory conference in the SF Bay Area March 25-26

Patrik Nyblom is giving a presentation with the title "Erlang SMP support, behind the scenes" and Kenneth Lundin will present "Latest News from the Erlang/OTP team".

Erlang/OTP R13B04 has been released. R13B04 is a service release for R13B. There are mostly error corrections, but also some new functionality.
This is the first release after the introduction of the official Git repository at Github and it is amazing to notice that the number of contributions from the community has increased significantly. As many as 32 contributors have provided 1 or more patches each until now, resulting in 51 integrated patches from the open source community in this service release.
In addition to the contributions provided by the community we have the following examples of highlights in the release:

• The documentation can now be built from the source.
• The Native Implemented Functions (NIFs) are still in beta, but much enhanced.
• The garbage collection of binaries is further enhanced.
• Support for user defined prompt in the shell. A small but useful new function.
• Enhanced cross compilation support

Download the new release from the download page.

Try the new document search at /doc.html, right column text box.

It is a preliminary version that searches for the given words as a module, function or application in the documentation and gives you a hit list with links into the online documentation.

Erlang/OTP R13B03 has been released. R13B03 is a service release for R13B. There are mostly error corrections, but also some new functionality. Some highlights in the R13B03 release are:

• Native Implemented Functions (NIFs) still experimental but very useful. Feedback is welcome.
• Beginning with this release we will maintain (and update on a daily basis) a GIT repository on GitHub. The intention is that this will make it easier for users to contribute with bugfixes and new functionality and also easier for us to receive the contributions.
• The documentation is built in a new way using xsltproc and Apache FOP. The layout is changed both in HTML and PDF versions. This is the first step, more changes and improvements will come in the following releases.
• A completely new erlang.org web site (this one) is also on its way but slightly delayed. Will be launched really soon now.

Download the new release from the download page.

The demo site will remain a demo for yet a while. There were more rough corners to work on than we first realized.