├── .gitignore
├── bsconfig.json
├── package.json
├── src
    ├── ffriends.js
    ├── friends_literal.js
    ├── friends.re
    └── friends.js
├── index.js
├── LICENSE
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | /lib/
2 | /node_modules/
3 | 


--------------------------------------------------------------------------------
/bsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "bucklescript-benchmark",
3 |   "sources": [
4 |      {
5 |        "dir": "src"
6 |      }
7 |   ]
8 | }
9 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "bucklescript-benchmark",
 3 |   "version": "0.0.1",
 4 |   "description": "A small benchmark comparing Bucklescript to plain JavaScript",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "start": "node index.js",
 8 |     "build": "bsb",
 9 |     "watch": "bsb -w"
10 |   },
11 |   "author": "Jochen H. Schmidt",
12 |   "license": "MIT",
13 |   "devDependencies": {
14 |     "bs-platform": "^1.6.0"
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ffriends.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const {makePerson} = require('./friends')
 4 | 
 5 | function addFriend (friend, person) {
 6 |     person.friends.push(friend.name)
 7 |     return person;
 8 | }
 9 | 
10 | function friends () {
11 |   let tom = makePerson("Tom", 23, []);
12 |   let mary = makePerson("Mary", 25, []);
13 |   let john = makePerson("John", 27, []);
14 |   let sara = makePerson("Sara", 21, []);
15 |   let smiths = [tom, mary];
16 |   let millers = [john, sara];
17 | 
18 |   millers = millers.map(p=>addFriend(tom, p))
19 |   smiths = smiths.map(p=>addFriend(john, p))
20 |   millers = millers.map(p=>addFriend(mary, p))
21 |   smiths = smiths.map(p=>addFriend(sara, p))
22 | }
23 | 
24 | module.exports = {
25 |   friends
26 | }
27 | 


--------------------------------------------------------------------------------
/src/friends_literal.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const {makePerson} = require('./friends')
 4 | 
 5 | let addFriend = (friend, {name, age, friends}) =>
 6 |     ({name, age, friends: [friend.name, ...friends]})
 7 | 
 8 | function friends () {
 9 |   let tom = makePerson("Tom", 23, []);
10 |   let mary = makePerson("Mary", 25, []);
11 |   let john = makePerson("John", 27, []);
12 |   let sara = makePerson("Sara", 21, []);
13 |   let smiths = [tom, mary];
14 |   let millers = [john, sara];
15 |   millers = millers.map(p=>addFriend(tom, p))
16 |   smiths = smiths.map(p=>addFriend(john, p))
17 |   millers = millers.map(p=>addFriend(mary, p))
18 |   smiths = smiths.map(p=>addFriend(sara, p))
19 | }
20 | 
21 | module.exports = {
22 |   friends
23 | }
24 | 


--------------------------------------------------------------------------------
/src/friends.re:
--------------------------------------------------------------------------------
 1 | type person = {name: string, age: int, friends: list string};
 2 | 
 3 | let makePerson name age friends => {name, age, friends};
 4 | 
 5 | let addFriend friend person => {
 6 |   ...person,
 7 |   friends: [friend.name, ...person.friends]
 8 | };
 9 | 
10 | let friends () => {
11 |   let tom = makePerson "Tom" 23 [];
12 |   let mary = makePerson "Mary" 25 [];
13 |   let john = makePerson "John" 27 [];
14 |   let sara = makePerson "Sara" 21 [];
15 |   let smiths = ref [tom, mary];
16 |   let millers = ref [john, sara];
17 |   millers := !millers |> List.map (addFriend tom);
18 |   smiths := !smiths |> List.map (addFriend john);
19 |   millers := !millers |> List.map (addFriend mary);
20 |   smiths := !smiths |> List.map (addFriend sara);
21 | };
22 | 


--------------------------------------------------------------------------------
/src/friends.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | let makePerson = (name, age, friends) => ({name,age,friends})
 4 | 
 5 | let addFriend = (friend, person) => {
 6 |   return Object.assign({}, person, {
 7 |     friends: [friend.name, ...person.friends]
 8 |   });
 9 | }
10 | 
11 | function friends () {
12 |   let tom = makePerson("Tom", 23, []);
13 |   let mary = makePerson("Mary", 25, []);
14 |   let john = makePerson("John", 27, []);
15 |   let sara = makePerson("Sara", 21, []);
16 |   let smiths = [tom, mary];
17 |   let millers = [john, sara];
18 |   millers = millers.map(p=>addFriend(tom, p))
19 |   smiths = smiths.map(p=>addFriend(john, p))
20 |   millers = millers.map(p=>addFriend(mary, p))
21 |   smiths = smiths.map(p=>addFriend(sara, p))
22 |   return millers.concat(smiths);
23 | }
24 | 
25 | module.exports = {
26 |   makePerson, friends
27 | }
28 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const FriendsRe = require('./lib/js/src/friends.js')
 4 | const FriendsJS = require('./src/friends.js')
 5 | const FriendsJS_literal = require('./src/friends_literal.js')
 6 | const FriendsFJS = require('./src/ffriends.js')
 7 | 
 8 | function bench (name, n, fn) {
 9 |     console.time(name)
10 |     let result
11 |     for (let i=0; i<n; ++i) {
12 |         result = fn()
13 |     }
14 |     console.timeEnd(name)
15 |     return result
16 | }
17 | 
18 | const N = 1000000
19 | console.log("Timings:\n")
20 | const b1_label = "Reason: using BuckleScript Records/Lists "
21 | const b1 = bench(b1_label, N, FriendsRe.friends)
22 | 
23 | const b2_label = "JS:     using Object.assign              "
24 | const b2 = bench(b2_label, N, FriendsJS.friends)
25 | 
26 | console.log("\nTimings of unfair/cheating variants")
27 | 
28 | const b3_label = "JS: using Object and manual key mapping (brittle code!)         "
29 | const b3 = bench(b3_label, N, FriendsJS_literal.friends)
30 | 
31 | const b4_label = "JS: using Object mutation (no immutability!)                    "
32 | const b4 = bench(b4_label, N, FriendsFJS.friends)
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Jochen H. Schmidt
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # BuckleScript Benchmark
  2 | 
  3 | This little benchmark demonstrates how static compilation using a
  4 | compiler like
  5 | [Bucklescript](https://github.com/bloomberg/bucklescript) can make
  6 | very similar looking [Reason](https://facebook.github.io/reason/) code run an order of magnitude faster than naively written JS.
  7 | 
  8 | ## Descriptions of the Code-Variants:
  9 | 
 10 | ### `src/friends.re`
 11 | A straight forward implementation in Reason.
 12 | 
 13 | ### `src/friends.js`
 14 | Direct adaption from the Reason code. Is using JS objects instead of a
 15 | record. Immutable object update is done with `Object.assign` which is
 16 | similar to the Object spread syntax that is often used when
 17 | transpiling JS with Babel. The array gets updated immutable through
 18 | Array spread.
 19 | 
 20 | ## Unfair / cheating Variants
 21 | 
 22 | The following variants implement strategies in JS to make it run faster. In a way those solutions are "cheating", because they don't actually do the same thing. They break rules like immutability or maintainability of code. The purpose here is to show, what price you have to pay if you want similar terse code like the Reason variant but more speed than the first JS variant. Interestingly none of this variants is actually faster then the Reason variant on Node.js (V8)!
 23 | 
 24 | ### `src/friends_literal.js`
 25 | Instead of `Object.assign` this variant uses a direct object literal
 26 | and any property gets manually set from the source object. This is
 27 | significantly faster then Object.assign because it sidesteps reading out which fields the object has and looping over them at runtime. But: One has to manually and carefully
 28 | maintain that any possible field in the source object gets set in
 29 | the clone. If you change your record structure you have to change this code. You at least could implement a `clonePerson` method to abstract this out - but it nevertheless is an additional step you have to do that is automaticalle taken care for you in Reason.
 30 | 
 31 | ### `src/ffriends.js`
 32 | This variant doesn't behave immutable. Instead the inital person
 33 | objects get modified directly and also the friends-Array is modified
 34 | using `Array.push()` instead of `Array.spread()`. So it clearly breaks one of the essential contracts of this benchmarks. Most interestingly it isn't even faster than the Reason variant on Node.js (V8). If you do not even update the Array at all (just return the initial object unmodified!) - it is still much slower than Reason! Curious why? [Read here!](#where-is-the-price) 
 35 | 
 36 | ### `lib/js/src/friends.js`
 37 | Well... yeah... thats just the Bucklescript output. Of course it is exactly as fast as the Reason code because it actually is the result of it. Of course you could hand write such code, but it is much more difficult to do and maintain so. You lose the terseness and maintainability of the Reason code and also any further improvements you could get by using future Bucklescript versions.
 38 | 
 39 | ## Build and Run
 40 | 
 41 | To build the javascript code from the Reason-Code using Bucklescript just run `npm run build`.
 42 | 
 43 | To run the benchmark run `npm start`. The output should be similar to the following:
 44 | 
 45 | ```
 46 | Timings:
 47 | 
 48 | Reason: using BuckleScript Records/Lists : 710.390ms
 49 | JS:     using Object.assign              : 8263.039ms
 50 | 
 51 | Timings of unfair/cheating variants
 52 | JS: using Object and manual key mapping (brittle code!)         : 3123.591ms
 53 | JS: using Object mutation (no immutability!)                    : 1721.166ms
 54 | ```
 55 | (Measured using Node.js v7.7.1 on a MacBook Pro Retina 2,3 GHz Intel
 56 | Core i7, 16GB RAM)
 57 | 
 58 | Of course the timings depend on the used JS engine!
 59 | 
 60 | ## How realistic is such code?
 61 | 
 62 | Functional programming patterns are more and more common in modern Javascript projects. Strictly controlling side effects is an important aspect when applying them. Directly modifying data structures makes it harder to follow the state flow of complex programs. So instead of this, a functional program makes use of immutable datastructures.
 63 | 
 64 | JavaScript objects are inherently optimized to get directly modified at runtime. Though, operations like `Object.assign` or Syntax extensions like Object spread or Array spread make it very easy to code in a style that implements immutable datastructures ad hoc from plain javascript objects and arrays. Typical use cases are state transformations implemented in Redux reducers. The example used in this benchmark uses this style to demonstrate how this can lead to bad performance compared to code that is compiled using a compiler that knows that its datastructures actually really are immutable and that the field offsets are known by compile time. This means there is very cheap field lookup and cloning a whole record doesn't need to access individual keys like in JavaScript.
 65 | 
 66 | The second JavaScript  variant demonstrates, that even a direct destructive modification of the Array within the person records themselves may not necessarily give better performance. It also isn't generating exactly the same result, because the order of the friends array ends up reversed.
 67 | 
 68 | **This leads to an interesting outcome: While languages like [TypeScript](http://www.typescriptlang.org)
 69 | can use their static type system to offer better tooling or less
 70 | runtime errors, they still are - by their whole definition -  bound to
 71 | the mutative nature of JavaScript**
 72 | 
 73 | A language like [Reason](https://facebook.github.io/reason/) with a
 74 | compiler like BuckleScript has a much stricter definition. Those
 75 | constraints open up the door to more freedom in optimizing code and
 76 | choosing more efficient data structure representations.
 77 | 
 78 | ## Hand optimization vs. Compilers
 79 | 
 80 | Some readers may note, that this example doesn't show that
 81 | "Bucklescript" generates faster code than "handwritten" JS because one could just
 82 | manually write code that does the same as what Bucklescript generates.
 83 | This is true, but it isn't practical. While this may work for very small
 84 | toy examples like this benchmark, it never would work for real
 85 | programs. It is nearly impossible to sustain this kind of hand
 86 | optimization across public API boundaries.
 87 | 
 88 | The main point here is, that a language like Reason defines simple
 89 | language semantics of OCaml that _abstract away_ any concrete representation of
 90 | code and values so that they can later be changed, improved or
 91 | optimized. Automatically. Or short: A future improved BuckleScript compiler
 92 | can generate even faster code out of the same given Reason example. Without
 93 | changing the code itself.
 94 | 
 95 | ## Where is the price?
 96 | 
 97 | [Bucklescript](https://github.com/bloomberg/bucklescript) doesn't just map records directly on JavaScript objects. It instead  uses a representation of Arrays and any property access is compiled to simple array index accesses. This representation is the reason how the result can deliver such a good runtime performance. Also lists are not mapped 1:1 on Arrays! Their representation uses 2-element arrays where the first element is the list head and the 2nd element is the tail of the list:
 98 | 
 99 | ```
100 | [1,2,3,4]
101 | ->
102 | [1, [2, [3, [4, 0]]]]
103 | ```
104 | 
105 | This makes pushing a new element onto a list a constant timed operation (just allocate a new "CONS-Pair" with the new head item and the old list as tail).
106 | 
107 | On the other side: If records and lists are structured this way, they
108 | are more difficult to handle in arbitrary JS code or within a
109 | debugging session. You lose the easy runtime introspectability of
110 | plain javascript objects. Blunt said: you do not directly see the
111 | names of the fields anymore. If you want to access such record
112 | instances from JavaScript you need to write accessor functions in
113 | BuckleScript.
114 | 
115 | If you want to use idiomatic JS objects in [Bucklescript](https://github.com/bloomberg/bucklescript) (e.g. for
116 | interoperability with JS libs) - you can use the FFI (Foreign Function
117 | Interface) of BuckleScript. This FFI is what makes a big difference to
118 | languages like TypeScript: When writing pure BuckleScript
119 | (OCaml/Reason) code, the compiler is free to take any representation
120 | it likes, as all interoperability is restricted _within_ the Reason/OCaml language
121 | semantics. With the FFI one interfaces the pure written code with the
122 | JavaScript runtime. This is where BuckleScript has to play by the 
123 | rules of its host language and accept the dynamic behaviour there.
124 | 
125 | --
126 | Jochen H. Schmidt
127 | 27. Mar. 2017
128 | 


--------------------------------------------------------------------------------