Historical errata for Seven More Languages in Seven Weeks

“the best part of working Factor was the simple joy”

Perhaps that should be changed to:

“the best part of working on Factor was the simple joy”

or

“the best part of working with Factor was the simple joy”

“and by collaborating with all of the extremely talented contributors”

Perhaps the ‘by’ should be removed:

“and collaborating with all of the extremely talented contributors”

In the line:

IN: scratchpad “Hello, Factor!”

the syntax highlighting appears to be incorrect for the ‘!"’ portion of the text.

In the following:

The if word takes a value and two quotations and calls the first quotation if the value is anything else but f(false). In the latter case, the second quotation is called

it seems the word ‘else’ may not be necessary. So it would read:

The if word takes a value and two quotations and calls the first quotation if the value is anything but f(false). In the latter case, the second quotation is called

Another take on this would be:

The if word takes a value and two quotations. If the value is anything but f(false) the first quotation is called. Otherwise the second quotation is called.

Here’s a version of ‘fizzbuzz’ from Rosetta Code:

USING: math kernel io math.ranges ;
IN: fizzbuzz
: fizz ( n — str ) 3 divisor? “Fizz” “” ? ;
: buzz ( n — str ) 5 divisor? “Buzz” “” ? ;
: fizzbuzz ( n — str ) dup [ fizz ] [ buzz ] bi append [ number>string ] [ nip ] if-empty ;
: main ( — ) 100 [1,b] [ fizzbuzz print ] each ;
MAIN: main

These words accept at most one item from the stack. I think this version is a little cleaner, but this is definitely a judgment thing. :) Hard to argue with four one-liners though. ;)

“Like many of its fellow scripting language” -> languages

“You can compare any values for equality inequality with == and ~=, respectively.” -> equality and inequality (I guess)

“You can also explicitly create variadic functions, that is, functions with an arbitrary number of outputs.” I think that should be “inputs”.

“This new function just stores each key/value pair in a list, then concatenates them into string at the end.” -> a string

Functions `strict_read` and `strict_write` don’t work as intended if `false` is allowed as a table value. In that case, we need `if _private[key] ~= nil then …`.

The assignment for day one Lua says to write a program to print the first n even prime numbers. This is a bad assignment because there is only one even prime number, 2. Should be changed to just the first n prime numbers.

…until you’re read this section -> “…until you’ve read this section” perhaps?

USING io math.functions ; should be USING: io math.functions ;

Explanation of cart-item code says “On the second line, we have the same code but we then call >>price on the instance.” — it should say “price>>” for the second line as it is extracting price and putting it on the stack.

You ask to “create a program that will print the first n even prime numbers”. There is only one even prime number.

metatables, reading and writing:

When putting the code in the order given in the book nothing happens (no error message as strict_read and strict_write are nil). That got me quite confused, please put the definition of mt after the definitions of strict_*

Setup Day3 for linux

para 2 reads

sudo apt-get install build-essential lua5.1 lua5.1-dev cmake rtmidi

should that not be? lua5.2 and lua5.2-dev?

When you introduce the `if` you should explain the different between if .. then .. else and if | .. -> | .. -> | otherwise ..

This might be a nitpicky but the following sentence is not entirely correct:
“Using precise terminology, Vect is indexed by Nat
and Type. The Nat is the number of elements allowed in this vector.”

While Vect is indeed indexed by a value of type Nat, it is parameterised by a value of type Type. The difference is that parameters are uniform in the resulting (it is ‘a’ in both constructors, while Nat differs ‘Z’ and ‘S n’). Idris will automatically detect such property (unlike Agda, which has an explicit syntactic difference) and it is apparent in the induction principle and the associated eliminator (try elim_for Prelude.Vect.Vect) and you will see how things are quantified.

The symbol :magnito in the Marvel Universe is incorrect! The correct spelling is Magneto, or in the sample code piece it would be :magneto. While I understand this may seem trivial, the fate of the Universe depends upon it’s Villains (oh wait, Hero, wait, he’s a bad guy again, uhmm, nevermind, whichever he is today) names being spelled correctly.

The print function at the bottom of page 135 no longer compiles of at least Elixir 0.12.4
def print(x), do: Enum.map x, &(IO.puts &1)
now spits out:

(SyntaxError) iex:1: unexpected comma. Parentheses are required to solve ambiguity in nested calls. Syntax error before: ‘,’

ELM point pattern matching does not work in repl

xDist {x} = abs x

can be compiled but does not work in the repl.

We now everything we need to calculate: “now” should be “know”

You will see that Elm takes full advantage of it’s heritage: “it’s” should be “its”

factoral 1 = 1 (and more occurrences in the rest of the code example)
“factoral” should be “factorial”

The character \\ helps when you’re running in the repl .
Superfluous space between repl and .

What were you main influences?
“you” should be “your”

String allows us to deal with graphics

According to library.elm-lang.org/catalog/elm-lang-Elm/0.12.3/String, String is for string manipulation.

We’ll use Input records This API will allow us

Missing period after “records”

which will come into handy when we work on our game
“into” should be “in”

The game is called LanguageHeads, but the module is called LanguageHead. I’d just call it LanguageHeads (plural) as well.

The third day will a little shorter

Missing “be” between “will” and “a”

Tuples are collections of fixed-size
“fixed-size” should be “fixed size”

We’ll start with the entire problem problem,
One “problem” is enough.

defmodule StateMachoneText do
“StateMachoneText” should be “StateMachineTest”

the macro will do all of the work for us, creating everything everything
One “everything” is enough

Most of Elixir semantics
“Elixir” should be “Elixir’s”

languages like Lisp, Ruby and Clojure.
Missing Oxford comma

protocols, which adds dynamic polymorphism to the language
“adds” should be “add”

start_link will spawns and links the supervisor process
Remove “will”

We also examined membero, a built in relation
“built in” should be “built-in”

Now’ll we’ll try to write some relations of our own.
“Now’ll” should be “Now”

[mano :alonso-church]
“alonso” should be “alonzo”

In the previous example, it may appears
“appears” should be “appear”

In the Elm ChessPiece example:

> data ChessPiece = CP Color Piece
> piece = CP Black Queen
CP Black Queen : ChessPiece

It is not explained what the meaning of “CP” is, and I could find no mention of it in the book or on the elm-lang.org site. The example also doesn’t work without it.

What does it mean?

quicksort.exs drops duplicate elements. Maybe change the first list comprehension from `x < head` to `x <= head`. On a related note, it seems `lc` has been deprecated in favor of `for` in recent versions of Elixir.

“Think of unqoute” -> unquote

“See if you can identify each of the these steps” -> “each of these steps”?

The one downside of defne is that you must always match on all the functions arguments
“functions” should be “function”

even if some of it’s values are logic variables
“it’s” should be “its”

Tests are run in order and whichever tests passes
“tests” should be “test”

For conde, we already say matche and defne
“say” should be “saw”

there’s a , at the end of the line height = cube_size,
I’m not sure it matters, but it seems strange, since these tables don’t have on in the final element of any other table.

We used featurec to contrains maps
“contrains” should be “constrain”

There are an infinte number of answers
there are an infinite number of possibilities

“are” should be “is” in both cases

We can ask core.logic to solve for every triple of distinct numbers that whose sum is 100
remove “that”

All the logic variables are constrained the finite range of 1 to 100.
Add “to” after “constrained”

such as [6 28 66] and 66 28 6.
The second vector is missing its brackets.

We’ll use Clojure’s reduce function to affect the transformation
“affect” should be “effect”

Asking for stories with more than 10 elements in whcih Yvette dies
“whcih” should be “which”

“miniKanren is more than a library. It’s simultaneously a new language and a new programming paradigm.”

Logic programming is a paradigm. miniKanren is certainly a fascinating implementation, but calling it a paradigm itself is a bit over the top.

Julia works in that the spirit
remove “the”

Dictionary literals use curly braces and=>, just like older version of Ruby.
“version” should be “versions”

Fetching keys and values from the dictionary is easy, as is testing for existence of a entry
“a entry” should be “an entry”

the_keys = keys(numbers)

ERROR: numbers not defined

A slice of single element still returns an array.
add “a” after “of”

“Julia is designed as a language for scientific and other numerical programming.”

This sounds like “scienctific” is more specific than “numerical”. I’d swap those two words.

Use a comma to give multiple indexes to an array.

For consistency with the rest of the book, “indexes” should be “indices”

and we didn’t even cover much of its built in library functions
“built in” should be “built-in”

change #include “lua.h” ff to #include PATH_TO_INSTALLATION/lua.h. Otherwise the compiler will load files from the current directory. There are versions (and versions and versions…) available on the internet, all of which give incomprehensible errors. There goes another day.

Same problem with include. RtMidi.h is, usually, not in the same directory, so use PATH_TO_INSTALLATION/RtMidi.h (often /usr/local/include/RtMidi.h)

tonumberx and a host of other functions are only available in the 5.2 edition of the lua library. Don’t install 5.1

Somewhere in your CMakelist.txt the use of the library RtMidi is missing, which gives rise to all kinds of incomprehensible errors. I’ve tried adding it to the CXXFLAGS, but that didn’t work. Editing link.txt so that -lrtmidi is added to the link command works, but it seems ugly.

ZynAddSubFX uses old style OSS audio, which is not supported in many Linux systems. It is possible to get audio from ZynAddSubFX using padsp (please add the footnote; I spent hours looking for it). In general, Day 3 of the LUA chapter invites a host of hardware and software problems having nothing to do with LUA. I’d suggest scrapping it.

“Accessing fields on a value of a type is done with the . operator, just like other dynamic languages.”
I’d remove “dynamic”, it’s the same in Java, and Java isn’t dynamic.

This is a perhaps unexpected, but probably helps simplify type inference.
Remove “a”

concurrency and distributed computing is a necessity
“is” should be “are”

We can still run code even if the worker’s are busy crunching numbers.
“worker’s” should be “workers”

Along the way we’ll point out of a few more of Julia’s many charms.
Remove “of”

Now that you’ve seen some of Julia’s main features and put the language through it’s paces
“it’s” should be “its”

which is more powerful version of overloading
Add “a” after “is”

“Like any dyanmic language” -> dynamic

“julia> julia> function flip_coins(times)” -> one prompt too much

“The extra parantheses” -> parentheses

“To be more concrete, image a picture” -> imagine?

“Then, we multiple it element-wise” -> multiply

“Since the mask keeps only 6 out of the 64 coefficients, this almost 90% less data.” Something’s missing…

“graying expects pixels values” -> pixel

“We used lots of new tools to acommplish the task” -> accomplish

“Try a large block size on a image” -> an image

“JPEG does prediction of the first cooefficient” -> coefficient

“is not a an amalgamation of parts” -> not an amalgamation

“As Julia is new, it’s package library is pretty small.” -> its package library

I’m not sure I understand function `concat` correctly, but doesn’t something like `zeros = int(ceil(log10(b+1)))` make more sense than `zeros = int(round(log10(a))–1)`?

Use pmap to take a array of trial counts and produce the number of heads
found for each element.
“a array” should be “an array”

We now have all the pieces to write your own macros.
“your” should be “our”

Macros excel at removing boiler plate code
“boiler plate” should be “boilerplate”

This means that in the frequency domain, its easy to identify the important values.
“its” should be “it’s”

Boolean, Integer, Float, String and Char are primitive types that do about what you’d expect them to.
Missing Oxford comma after “String”

Type the following into a file called data_types.idr in the console:
Remove “in the console”

List, String and Integer are types that describe values [], “Hello”, and 6.
Something is missing, maybe “like” after “values”

Maybe we’d get fancy and and create separate types for each of those.
Remove one occurrence of “and”

Write a function to transpose the matrix so that element m, n in the
argument is element m, n in the result
Swap m and n, it’s not transposition otherwise

Lua is putting its mark on everyday programming as a language for embedded systems and scripting because the language is compact, pure, adaptable and clean.
Missing Oxford comma before “and clean”

“The ecosystem, though it is young, already has a rich and robust ecosystem”
The ecosystem … has an ecosystem

Y2K, the date problem that came with the turn of the century
“century” should be “millennium”, that’s what the K in Y2K refers to

Most existing languages will be too slow, too buggy and too complicated.
Missing Oxford comma before “and too complicated”

In 2010, Seven Languages in Seven Weeks [Tat10] focused on new wave of functional languages.
Add “a” before “new”

The next gen- eration, languages like Elixir, Julia and Elm, is more practical,
Missing Oxford comma before “and Elm”

For rapid adoption, languages depends on a large and active community
“depends” should be “depend”

It’s just much easy to do business with a smaller ecosystem
“easy” should be “easier”

The error presented for `add` is wrong. The one presented in the book is:
Can’t unify
Vect (m + n) a
with
Vect (plus n m) a
Specifically:
Can’t unify
with
plus m n
plus n m

where it should be:
Specifically:
Can’t unify
Vect (n + n) a
with
Vect (plus n m) a
Can’t unify
plus n n
with
plus n m

That is, the size of xs is n so m should not appear at all in the first part of the error message (since that is the size of ys which doesn’t appear anywhere in the second clause).

As the module name in the current context is “Functions” the answer to:
“:t stringFunction” must show “Functions.stringFunction” rather than “Types.stringFunction”

Below the function remove_first(array)
there is a statement which reads
"And now to run the program! Create a new file called punch.lua with the following line at the top

dofile(“scheduler.lua”)"

punch.lua is NOT a new file It was already created on Page 26.

In the Julia Chapter on macros:

julia> @unless in(a, 1) begin
println(“a does not have 1”)
end
a does not have 1

The macro is wrong, it should start with:
@unless in(1, a)

a contains 1 so it should not print the wrong message
syntax is: in(item, collection) —> Bool

The scene method does not compile, complaining that “id” cannot be found. The code works when changed to “identity” instead.

In the ELM chapter, the spawnHead function will not compile because div cannot be found. Not sure what the backticks (`div`) even do, as I couldn’t find them anywhere in the chapter.

[1 of 1] Compiling LanguageHead ( languageHeads.elm )
Error on line 70, column 33 to 49:
Could not find variable ‘div’.

Additionally, when div is removed, the next error message is “Could not find variable ‘Text.height’.”, adding an “import Text” to the top fixes that problem. The next error after that is “Could not find variable ‘.’.” which I could not figure out. I am using elm v0.13. Also, elm-server does not exist (mentioned on page 139), it is now elm-reactor.

It seems ELM is currently a very fast moving language, while very interesting I had a significantly difficult time following this chapter due to these errors plus the author did not distinguish very well between which functions were builtin vs which functions we would write later.

Chapter 5, Julia - Multidimensional arrays.
In note #1, missing “eye(M,N)” from at the end of the following sentence:

eye constructs the identity matrix. eye(N) makes an N×N matrix, creates an M×N matrix.

The sentence should read (I believe):
eye constructs the identity matrix. eye(N) makes an N×N matrix, eye(M,N) creates an M×N matrix.

scheduler.lua has a bug where actions scheduled for later prevent actions scheduled for earlier to be run.

I believe this is because the `remove_first` function in the scheduler messes with the order of the `pending` table (it puts the last element in place of the first).
The `run` function then waits for the first element to be run. But that isn’t necessarily the earliest action that should be run.
I think it is not apparent with the code in the book because there’s only 2 actions.

I’ve modified punch.lua to make the bug apparent. It is available as a private gist here:
gist[dot]github[dot]com/vise890/d82b6abb98e637f79fa1

As a fix, I think you could just remove the call to `sort_by_time` in the `schedule` function`
and put it in the `run` function instead. The gist contains a copy of the code with the fix, it seems to work in my tests.

I hope this is helpful. If you need any further clarification, my email is vise890@gmail.com.

Otherwise, I am absolutely loving the book so far. Keep up the great work.

Cheers
Martino

In the latest build of Elm 0.14 the term lift has been removed. It is now map.

The 3rd paragraph reads:

[…] The third day will a little shorter […]

missing “be”:

[…] The third day will BE a little shorter […]

import List (..)
is required to get this example to work:
> 1 :: 2 :: 3 :: []]
Otherwise get an error:is required to get this example to work:
> 1 :: 2 :: 3 :: []]
Otherwise get an error:
Could not find variable ‘::’.
Could not find variable ‘::’.

In (2) near the end of the page it says
numbers = [:one => 1, :two => 2]
the_keys = keys(numbers)

But the result in (3)
collect(the_keys)
is ‘:c, :b, :a’

Either (2) must be ‘the_keys = keys(explicit)’ (and ‘numbers’ is not needed) or (3) returns ‘:two, :one’

keyword ‘data’ was changed to ‘type’ in newer elm versions

The third paragraph from the bottom begins “Elixir executed Rectangle.area/2, and then…”. I think the arity of the function should be 1, that is, Rectangle.area/1.

The key identifying the book title in the modified map in the middle of the page should be “title” not “book”. That is, the map should read {title: book.title,… not{book: book.title,…

The example of key handling in dictionary on that page defines:
the_keys = keys(numbers)

However, the following outputs of “collect(…)” and “a: in the_keys”
are inconsistent with the given example dictionary (“numbers”). They rather seem to belong to the dictionary (“explicit”) used in the previous examples on that page.

Not only is “lift” no longer part of Elm, but “asText” results in “Cannot find variable `asText`” — this makes the whole chapter really difficult to follow through in the “try elm” system.

The text has literal asterisks in “intelligent sugar”

Surely those words should just be italicized.

Missing word:

You can explore more of [the] List functions …

It would be helpful to explain the historical context and/or rationale for the function name “lift”.

Inconsistent word usage:

This page says “… we can lift the gameState signal onto display.” Elsewhere (IIRC), the book speaks of lifting a function onto a signal.

It might be helpful to point out the nice way that “all” works with currying in allHeadsSafe.

The discussion of spawnHead is a bit skimpy for such a complex function.

The keming of “Text” is very poor in “More about dealing with Text on …”

Consider moving “Each new language …” to the start of the following paragraph.

The phrase “C-style sigils” doesn’t seem very helpful. Wikipedia’s “Sigil (computer programming)” page doesn’t talk about C and none of my C references mention sigils. Did you mean Perl- or Ruby-style?

“… ran the module, and …” should be “… ran the module and …”

The sentence “Just for fun, …, and {w,h}.” is a bit hard to parse. I’d reword it.

“… the first or second, it will …” would read better as
“… the first or second definition, Elixir will …”

“… named functions and pipes, …” should be
“… named functions, and pipes, …”

I’d change “This kind of deconstruction …” to
“This kind of destructuring …”

In the second iex example, “in” is emboldened (and shouldn’t be).

I might add a few more examples, eg: “is_list ‘string’”, “is_list [1, 2]”, and is_list {1, 2}".

Why, exactly, is the Quicksort “ironically named”? Explain or remove.

"… were all [performed] in the console.

“… set of fields with the …” should be
“… set of fields and the …”

“… to represent our video.” should be
“… to represent each video.”

“… a customer decides to rent, return, or lose …” - Few customers “decide to lose” a video.

I’d swap the order of the fire/2 and fire/3 definitions.

“Since functional languages are immutable, …” should be
“Since data structures in functional languages are immutable, …”

I’d change “in the console use quote:” to
“use quote in the console:”

“That means … but that syntax is repetitive. Let’s fix that.” has too many
“that”s. Fix that…

In the code block, shouldn’t &renting/1 be &returning/1 ?

“… confirms macros run …” should be
“… confirms that macros run …”

“… and try it out” should be “… and try it out.”

There is an extra “…> end” line in the first iex example.

<bt: Actually, this is correct. One to close the function, and one to close the receive loop. >

“Elixir provides tasks, which starts another process and waits until …”
should be
“Elixir provides tasks, which start another process and wait until …”

The sentence “Elixir also provides … applications.” is long and convoluted. I’d break it up.

“… our video store using …” should be
“… our video store, using …”

“… is a behavior with some …” should be
“… is a behavior, with some …”

“The children defines …” should be
“The children list defines …”.

The word “in” (in the ERROR REPORT) is emboldened and should not be.

“… not as mature, as some of …” should be
“… not as mature as some of …”.

The code “type M<: …” should be emboldened.

For the benefit of later readers, what used to be `Text.asText` is now `Graphics.Element.show` and `lift` is now `Signal.map`, so a working example is

import Mouse
import Signal
import Graphics.Element

main = Signal.map Graphics.Element.show Mouse.position

`Signal.count` has been removed. Here’s how to implement it yourself:

count : Signal a -> Signal Int
count asig = foldp (\\sig total -> total + 1) 0 asig

You need to import foldp from Signal for that to work, here’s the complete example:

import Mouse
import Signal exposing (map, foldp)
import Graphics.Element exposing (show)

count : Signal a -> Signal Int
count asig = foldp (\\sig total -> total + 1) 0 asig

main = map show (count Mouse.position)

Julia changed the semantics of idct to return floats between 0 and 1. The “./ 255.0” should be removed or the code will produce all black images.

I line 7 and 9 the ‘b’ is unexplained
In line 7 replace “b |” by “color : Color, ”
IN line 9 replace “b” by “Color”

line 3 from the bottom change “y : number” to “y : number’”

The text and example describing counting the left and right arrows from the previous version of the book is missing, so the paragraph starting “Now, we create one signal with foldp.” doesn’t make sense.

Bottom paragraph of the page, there is a reference to `luaL_doFile()`. I think it should be `luaL_dofile()`.

It is spelled correctly in the preceding code example.

The Ghostbusters reference should exorcise poltergeists, not exercise them (that would defeat the purpose!).

New versions of Julia have deprecated the ruby hash syntax.
new syntax
Dict(“a” => 1, “b” => 2, “c” => 3)
Dict{String,Integer}(“a”=>1, “b” => 2)
so it should look like
```
typeof(Dict(:foo => 5))
```
or
```
typeof(Dict{Symbol, Int64}(:foo => 5))
```

lua/day3/b/play.cpp(3) should be
if (argc < 2) { return –1;}

the current code reads … (argc < 1) which is not correct as the function later references argv[1] which would result in undefined behavior if argc is 1

Setting up the map pattern match example as written gives an error:

iex(10)> book
%{author: %{first: “David”, last: “Thomas”}, title: “Programming Elixir”}
iex(11)> { author:{ last: “Thomas”}, book: title} = book

(MatchError) no match of right hand side value: %{author: %{first: “David”, last: “Thomas”}, title: “Programming Elixir”}

iex(11)>

Thank you.