This is a book about getting ((computer))s to do what you want them to

do. Computers are about as common as screwdrivers today, but they contain a

understand. To many, they remain alien, slightly threatening things.

image::img/generated/computer.png[alt="Communicating with a computer"]

(((graphical user interface)))We've found two effective ways of

bridging the communication gap between us, squishy biological

mimic that world and allow us to manipulate shapes on a screen with

our fingers. This works very well for casual machine interaction.

talent for language: teaching the machine a language.

(((human language)))(((expressivity)))Human languages allow words and

grammatically flexible, follow a similar principle.

(((JavaScript,availability of)))(((casual computing)))Casual computing

language-based interfaces, which once were the default way in which

people interacted with computers, have largely been replaced with

graphical interfaces. But they are still there, if you know where to

web ((browser)) and is thus available on just about every consumer

device.

____

(((programming,difficulty of)))Besides explaining JavaScript, I also

turns out, is hard. The fundamental rules are typically simple and

clear. But programs built on top of these rules tend to become complex

enough to introduce their own rules and complexity. You're building

It is up to you to make the effort necessary. When you are struggling

to follow the book, do not jump to any conclusions about your own

capabilities. You are fine—you just need to keep at it. Take a break,

the example programs and ((exercises)). Learning is hard work, but

easier.

[quote, Joseph Weizenbaum, Computer Power and Human Reason]

Analogies that try to compare programs to objects we are familiar with

tend to fall short. A superficially fitting one is that of a

machine—lots of separate parts tend to be involved, and to make the

interconnect and contribute to the operation of the whole.

(((computer)))A computer is a machine built to act as a host for these

straightforward things. The reason they are so useful is that they do

these things at an incredibly high speed. A program can ingeniously

combine enormous numbers of these simple actions in order to do very

that this complexity is best managed by using only a small set of

well-understood techniques in their programs. They have composed

strict rules (_“best practices”_) prescribing the form programs should

outside of this safe little zone to be _bad_ programmers.

(((experiment)))(((learning)))What hostility to the richness of

(((programming,history of)))(((punch card)))(((complexity)))That is a

program to add the numbers from 1 to 10 together and print out the

hypothetical machine. To program early computers, it was necessary to

strips of cardboard and feed them to the computer. You can probably imagine how

how tedious and error-prone this procedure was. Even writing simple

programs required much cleverness and discipline. Complex ones were

a profound sense of being a mighty wizard. And that has to be worth

something in terms of job satisfaction.

single instruction. It could be written in English like this:

[source,text/plain]

(((readability)))(((naming)))(((variable)))Although that is already

more readable than the soup of bits, it is still rather unpleasant. It

might help to use names instead of numbers for the instructions and

[source,text/plain]

----

[loop]

[end]

----

(((loop)))(((jump)))(((summing example)))Can you see how the program

build up the result of the computation, and `count` will keep track of the

number that we are currently looking at. The lines using `compare` are

probably the weirdest ones. The program wants to see

running. Because our hypothetical machine is rather primitive, it can only

test whether a number is zero and make a decision (or jump) based on

that. So, it uses the memory location labeled `compare` to compute the

(((while loop)))(((loop)))This version gives us a few more improvements.

Most importantly, there is no need to specify the way we want the

construct takes care of that. It continues executing the block

(wrapped in braces) below it as long as the condition it was given

holds. That condition is `count <= 10`, which means “++count++ is less than or equal to

indexsee:[WWW,World Wide Web] indexsee:[Web,World Wide Web](((history)))(((Netscape)))(((browser)))(((web

application)))(((JavaScript)))(((JavaScript,history of)))(((World Wide

been adopted by all other major graphical web browsers. It has made modern

web applications possible, applications with which you can interact

directly, without doing a page reload for every action. But it is also used in more

(((ECMAScript)))(((compatibility)))After its adoption outside of

Netscape, a ((standard)) document was written to describe the way the

software that claimed to support JavaScript were actually talking

about the same language. This is called the ECMAScript standard, after

terms ECMAScript and JavaScript can be used interchangeably—they are

two names for the same language.

issue here: JavaScript is ridiculously liberal in what it allows. The

idea behind this design was that it would make programming in

JavaScript easier for beginners. In actuality, it mostly makes finding

them out to you.

(((JavaScript,flexibility of)))(((flexibility)))This flexibility also

has its advantages, though. It leaves space for a lot of techniques

can be used to overcome some of JavaScript's shortcomings. After

((learning)) the language properly and working with it for a while, I have

learned to actually _like_ JavaScript.

During this time, work was underway on an ambitious version 4, which

planned a number of radical improvements and extensions to the

language. Changing a living, widely used language in such a radical

edition coming out in 2009. We're now at the point where all major

being finalized, and some browsers are starting to support new

features from this edition.

(((reading code)))(((writing code)))Code is the text that makes up

programs. Most chapters in this book contain quite a lot of it. In my

((learning)) to program, so try to not just glance over the examples. Read

them attentively and understand them. This may be slow and confusing

at first, but I promise that you will quickly get the hang of it. The

same goes for the ((exercises)). Don't assume you understand them

until you've actually written a working solution.

in an actual JavaScript interpreter. That way, you'll get immediate feedback on

tempted to ((experiment)) and go beyond the exercises.

ifdef::interactive_target[]

When reading this book in your browser, you can edit (and run) all

endif::interactive_target[]

the example code in the book, and to experiment with it, is to look it

up in the online version of the book at

http://eloquentjavascript.net/[_eloquentjavascript.net_]. There you

output it produces. To work on the exercises, go to

http://eloquentjavascript.net/code[_eloquentjavascript.net/code_],

to look at the solutions.

endif::book_target[]

(((developer tools)))(((JavaScript console)))If you want to run the

programs defined in this book outside of the book's sandbox, some care

JavaScript environment. But code in later chapters is mostly written

there. In addition, many chapters define bigger programs, and the

pieces of code that appear in them depend on each other or on external

files. The http://eloquentjavascript.net/code[sandbox] on the website

== Overview of this book ==

((browsers)) and the way JavaScript is used to program them. Finally,

JavaScript in.

Throughout the book, there are five _project chapters_, which describe

larger example programs to give you a taste of real programming. In

link:07_elife.html[artificial life simulation], a

link:11_language.html[programming language], a

link:15_game.html#game[platform game], a

you will be able to write simple programs. Next, Chapters

link:05_higher_order.html#higher_order[5] and

link:06_object.html#object[6] introduce techniques to use functions

under control.

After a link:07_elife.html#elife[first project chapter], the first

JavaScript has access to. You'll learn to display things on the screen

(Chapters link:13_dom.html#dom[13] and

link:16_canvas.html#canvas[16]), respond to user input (Chapters

communicate over the network (link:17_http.html#http[Chapter 17]).

There are again two project chapters in this part.

----

(((console.log)))Sometimes, in order to show the output that a program

[source,javascript]

----