Benchmarking speed, memory footprint, safety, ease of use, reasons to use the language

Benchmarking:

Changes to upgrade performance for some input on one platform can deteriorate performance for a different input or platform. Using different platforms, browsers and types to test with, is a significant step to ensuring that the performance improvement really is a universal improvement.

The performance of a a > b heavily depends on the type. Some changes will work better for smaller datasets, others on larger datasets. Or changes might result in Javascript that might initially perform better, but can’t be handled efficiently by an optimising JIT. Developing for performance isn’t explicit. However, in terms of speed, Elm is second to none that can be statistically proven.

Creator of Elm, Evan Czaplicki created a benchmark that compares the renderer performance of Elm, Ember, React, and Angular. The benchmark is a TodoMVCapp where items are added and removed rapidly using for loops.

Here are the results:

As we can see, Elm is the fastest among the four languages. Elm is at least 30% faster than others.

Memory Footprint:

Elm compiles to JavaScript. JavaScript is a lightweight programming language. It is designed to have a small memory footprint. This is the amount of main memory that it uses. Low memory utilization is an essential feature for languages that are geared towards building websites and web applications. Part of the reason why, is because these applications have to be able to run on mobile devices. Elm is outstanding for this purpose.

Safety:

Elm is a functional language. One of its features is that it has no runtime errors. These are errors that occur during the execution of a program. Furthermore, all data in Elm is immutable. This means that a value can not be changed after it is created. This prevents side effects from occurring. Side effects modify state. State is the data stored at a given time that a function can access. Because of this, all functions in Elm are pure. They will always return the same output given the same input. These characteristics allow Elm to be easy to debug. Pure functions remove the dependencies that functions may have on code that was executed before them. This occurs in languages that do not implement pure functions. In Elm, a function’s output depends solely on its arguments and other immutable data in its scope. An error in Elm will most likely be the product of incorrectly applied logic inside a function. Naturally, this translates to easy testing as well. Verifying the proper output of each function is easier. This translates to unit testing in Elm. Qualities of this sort make Elm a safe language to use.

Ease of Use:

Being a declarative language, ease of use is an inherent quality of Elm. The focus is on describing what the programmer wants to accomplish, rather than how it is to be done. The implementation of actual algorithms explicitly is oftentimes bypassed in declarative languages. This is left up to the given language’s implementation. For the programmer, this means that he can focus his energy on specifying what solution is needed for a given problem, rather than focusing on how to implement said possible solutions. This translates to a straightforward, easier way of programming that quite appealing.

Reasons to Use Elm:

Throughout this five part series on Elm, we have related many of the winning qualities of this wonderful language. Elm builds upon more than four decades of work on typed functional reactive languages. Many of the features that make this language attractive, are free, easy, and built-in in Elm. Other languages require a stack of libraries to accomplish the same objectives. Elm includes a package manager. Elm has immutable values.

Elm implements control abstraction thoroughly. This means that it hides complicated code behind a simpler set of operations.

Its compiler error detection is top-notch, giving descriptive error messages and useful suggestions and hints.

Testing and debugging are a breeze. All in all, Elm is a superb tool for creating websites and web apps. It emphasizes simplicity, ease of use, and superior tooling. Good luck and bon voyage!

References:

https://elm-lang.org/docs

https://elm-lang.org/blog/blazing-fast-html-round-two

https://github.com/evancz/react-angular-ember-elm-performance-comparisonh

Beginning Elm

https://en.wikipedia.org/wiki/Declarative_programming

Toolchains, Internals, and Intermediate Representations

Toolchains:

A toolchain is a set of tools (programs) that developers use to aid in the development, maintenance, and support of a software task or product. The basic tools used in software development are source code editors and compilers or interpreters. A basic toolchain may comprise a compiler and linker, libraries, and a debugger. As mentioned earlier in this series, it is recommended that you install a text editor like Atom to use when writing Elm programs. Unlike other languages, where a lengthy tool stack is often necessary, Elm has many desirable features built-in. For example, if you are using JavaScript as your language of choice, you would have to install a package manager like npm to get packages. This feature is built-in in Elm.

Furthermore, if you wanted static type-checking and immutability, you would have to add these features. This is not the case when you use Elm. These features are not libraries that you have to install. These features are part of the language.

Internals and Intermediate Representations:

Elm compiles to JavaScript. A web browser then interprets this code. elm make builds Elm projects. It can compile Elm code to HTML or JavaScript. It is the most general way to compile Elm code, so if your project becomes too advanced for elm reactor, you will want to start using elm make directly.

Say you want to compile Main.elm to an HTML file named main.html. You would run this command:

elm make Main.elm --output=main.html

Compiling this program to an HTML file, allows you to view it in your browser.

The provided examples above shows the most common commands in elm. However, there are a few more commands that provides easy support in implementing programs. To see a full list of commands just type elm into your terminal.

Publish/Bump/Diff:

What makes Elm a powerful language is how easy to create a package by running a simple command elm publish. It’s vast package ecosystem makes it easier to for people to share ideas, mainly through Github, and test the packages to ensure the package is working properly.

The command elm bump takes the published package version number and bump the version if any modifications to the package were made. Then enter the elm publish command to release that version.

Finally, the elm diff command detects API changes. For example, if you updated a newer version of a package and wondered what is the difference between the new version and the old version.

For more information on publishing a package on elm, the provided link below is a great start:

The basic steps to publish a package with Elm 0.19 | Korban.net

References:

https://elm-lang.org/

https://guide.elm-lang.org

Elm (programming language) - Wikipedia

https://www.youtube.com/watch?v=kEitFAY7Gc8&t=959s

Introduction

Testing and debugging in Elm is straightforward. The tools explored here, are the compiler, the debug library, and the elm test package. To start with, there are no run-time errors in Elm. These are errors that occur during program execution. For example, Elm takes into consideration the possibility of incorrect input with the implementation of custom types. This rids Elm of many of the errors seen in other languages. Furthermore, functions in Elm are pure functions, meaning that they return the same value given the same arguments. These sorts of functions do not cause side effects. Side effects occur when a function performs anything else other than returning a calculated value. Obviously, pure functions make a program easier to debug. These characteristics, coupled with efficient compiler error detection, immutable data, and useful packages, allow for painless debugging and testing.

Compiler Error Detection

The Elm compiler is quite capable of detecting many common errors. One of the major features of Elm that is frequently praised by developers, is its compiler error detection. Compiler error messages in Elm are user-friendly. These appear in the terminal or in the text editor if it is being used instead. They often contain suggestions or hints that are quite useful.

Testing

Unit testing which focuses on testing each unit(component,class, content object), and fuzz testing which inputs large amounts of random data(fuzz) to the program in an attempt to make it crash, can be implemented in Elm using the elm test package.

To install enter npm install -g elm-test from your terminal. Next, cd into the project’s root directory. After, enter elm-test init from your terminal. This will create a tests directory with some files inside. We can open Example.elm to write a test. By entering elm-test from the terminal, we can see the result.

Debugging

The Debug library is part of the core Elm core package. One of its functions is called log.

Another function in the debug library is called crash. As the name implies, this function terminates the program with an error message. This can be used when a case expression is unfinished. The error will point to the related module name and line number.

The quickest way to debug in elm is through the console in your web browser. Once you configure the launch.json settings to properly run the file, go into your terminal or command prompt and enter “elm reactor” (without the parentheses). Then go find your elm file that you wanted to debug and run it. Right click on the screen and click inspect, then click the console tab to keep track of your program. A video to show how the debugger is used can be found here:

Time Travel Debug Tool

One of the greatest debug features included with the Elm language is the ability to record a snapshot of the session history and updates made to the model using the Time Travel debug tool. The process for this is shown in the video below.

References:

https://elm-lang.org

https://elmprogramming.com/

Basics:

Elm is a Functional Reactive Programming (FRP) language for building web apps. Functional, in that it treats computation as the evaluation of mathematical functions and it avoids mutable (changeable) data. Reactive, in that it is affected by change. In other words, the variable a, in a = b+c, in an imperative language, maintains the same value regardless of the possible changes made to b or c later in the program. This is not the case with reactive programming. In reactive languages, the value of a is updated when the values of b or c change.

Data Types:

The primitives(simplest elements) in Elm are standard types: integer, float, string, and boolean.

Integers in Elm (Int) are whole numbers that can be represented in either normal base 10 or base 16 (hexadecimal) with mathematical operation being well-defined in the range: -2³¹:2³¹-1. When generating JavaScript code in the compiler the range safely expands to -2⁵³:2⁵³-1. Floating point numbers (float) follow the IEEE 754 standard utilized by the vast majority of hardware in existence. These can be defined using the standard form of 1.1112 or in scientific notation as 6.022e23. It is interesting to note that Elm has been designed to make all conversions between integers and floats explicit, rather than implementing an automatic conversion like JavaScript. For example, you cannot add an Int and a Float directly without first converting them to the same data type through the use of functions such as toFloat() or round. A third type is called ‘number’. This type will set itself to the correct data type, either int or float, based upon how it is used.

Text based data types include String and Char. In Elm you are required to use double quotes for Strings and single quotes for characters where a char must be a single character. For a multi line String you may utilize a set of three double quotes. This allows the compiler to view everything in between as a string containing newline characters without explicit escaping.

Boolean literals must either be True or False. Elm does not equate True and False to a number, like 1 and 0, but requires the evaluation of conditions to precisely match True or False.

Elm also has Collections which include Lists (require same type), Tuples(muti-type support), and Records(like dictionaries in Python) which hold key/value pairs.

Functions and Control Abstraction:

Being a declarative language, Elm implements control abstraction thoroughly. This means that it hides complicated code behind a simpler set of operations. In a declarative language, the focus is on what the computer is to do as opposed to how the computer should do it. For example, the core module, List, contains functions to work with lists. Creation, sorting, and ordering are handled for the programmer. Logically, the programmer can create them as well.

Elm does not natively support the traditional loop structure of other languages and relies on recursive functions to implement a similar structure. There does exist a package, elm-loop, that you can install to provide the more familiar while loop structure, but even this warns the programmer that they should be using mapping, folding, and recursion for the vast majority of operations.

Folds can be thought of as collapsing a structure into a value in a particular direction(left or right). Below is an example of how a for loop can be expressed as a recursive definition in Elm utilizing a left fold.

Mapping in Elm and JavaScript refers to applying a function to each item in the list using the List.map function. The code below shows an example of a map operation on a list of integers. It simply multiplies each item by 2 and returns a new list of number type.

This shows an example of a map operation being used to concatenate two lists into a new list having every possible combination of the two,(a1, a2, a3,…f5, f6)

For branching Elm uses case statements and traditional if/else assertions.

Expressions:

Elm supports many standard expression evaluations. Strings for example can be concatenated using the “++” operator. In addition, math utilizes the normal syntax and operators [+, -, *, /, //] that represent addition, subtraction, multiplication, floating point division, and integer division respectively.

Some unique expressions in Elm include: Let(values are defined in specific expression), Custom Types (new types), Type aliases(shorter name for another type), and function application operators.

Function application operators allow the programmer to not have to use parentheses. It is a nice way to call functions.

Modules and Data Abstraction:

Modules are at the core for data abstraction in Elm. Data abstraction, allows the programmer to reduce cognitive load and risk of name conflicts. Data abstraction also hides data that is not explicitly imported. Modules allow programmers to work on the same project simultaneously.

References:

https://guide.elm-lang.org/

https://elm-lang.org/docs

Introduction to Elm

Elm is a Functional Reactive Programming (FRP) language focused on creating reactive graphical user interfaces (GUIs). Functional reactive programming for those that are unaware, is essentially, the implementation of the reactive programming model applied using functional programming techniques. Although Elm compiles to Javascript, the architecture of Elm provides an easier and more concise understanding, so for users who are familiar with functional programming, Elm is definitely an upgrade. Elm provides an elegant command-line interface, a supportive compiler, and an intuitive debugger.

Installation

The first step, is to install the Elm language compiler. This can be done here.

Once you have installed the compiler on your device, you will need a text editor. Atom is a great one, but there are other options available, all with Elm plugins. These include: Brackets, Emacs, IntelliJ, Light Table, Sublime Text, VS Code, and Vim.

Installing Elm on your workstation is made simple by a packaged executable which can be found either through the official install guide or through the project GitHub. Running this executable will make the binaries available to your environment through the terminal and allow you to become productive with the language in a short amount of time.

Package Manager

Following the installation of the binaries you will want to install a number of packages that will increase Elm capabilities without having to write a large library yourself. Elm makes this extremely simple as well as all packages are located in a single repository, package.elm-lang.org, and are installed through the terminal by using the command:elm install "root"/"package". This command modifies the compiler file elm.json to add the required dependencies that your code will call upon when compiling. For example, to install the package that allows you to make HTTP requests, you would type: elm install elm/http.If you find yourself in need of a reminder and don’t want to go searching the web, typing the command elm --help will provide you with a number of helpful reminders.

Basic Elm Demo

The official Elm guide provides a great demo program which I have included below:

import Browser
import Html exposing (Html, button, div, text)
import Html.Events exposing (onClick)

main =
  Browser.sandbox { init = 0, update = update, view = view }

type Msg = Increment | Decrement

update msg model =
  case msg of
    Increment ->
      model + 1

    Decrement ->
      model - 1

view model =
  div []
    [ button [ onClick Decrement ] [ text "-" ]
    , div [] [ text (String.fromInt model) ]
    , button [ onClick Increment ] [ text "+" ]
    ]

After you type your code into your editor, run the project in your command-prompt or terminal. In order to do that, create a directory where you would store your projects.

Once you created and change to the desired directory, type “elm init” to initialize your source folder that will store all of your elm files. The prompt will also provide a link so the user will have a deeper understanding on how to add files, how to see it in your browser, etc.

To compile the program, type “elm make” and the destination of the elm file.

Once you receive this message, type “elm reactor” to build your project and the prompt will return a link to your server which you can navigate to your elm file.

Once you enter to your server, go to your source folder and your elm file should be available. If you followed this demo your screen should like this.

References:

elm-lang.org