Episode 268

John Papa on Single Page Applications

Episode 231

Chris Powers on Code Reuse

JavaScript’s popularity proves how useful people have found the language. Novices use it to add simple validations to web forms, while advanced build amazing applications with JavaScript.

Yet, for all its utility, many look at JavaScript with disdain and fear, pointing to dangerous features and to the difficult of dealing with the browser's Document Object Model.

In JavaScript: The Good Parts, Douglas Crockford distinguishes between the good features of JavaScript that make it and elegant and powerful language; and the bad parts that make it dangerous and difficult to understand. Crockford’s message is to use the good parts and avoid the bad parts and stop fearing JavaScript.

According to Crockford, most people misunderstand JavaScript and so they misuse it; then, they complain about the language.

Crockford acknowledges that the designers of JavaScript made some mistakes (global variables, for example), but that there are enough good features of the language to make it appealing to a wide range of users writing a wide range of applications. He notes that JavaScript succeeded as a platform for creating client code for the web – something that that the more powerful Java language attempted and failed badly – and that this proves JavaScript’s power.

Applications will be better and developers happier, notes Crockford, if developers avoid the bad parts of the language. For example, always use the "===" operator, which returns what most users expect because it doesn't do any type coercion. Avoid the confusion of the "==" operator, Crockford recommends.

Crockford's style is concise and straightforward. At fewer than 200 pages, the book has no room for distractions. Regular Expressions are presented and described and examples are shown how to use them. Crockford clearly describes Closures, a feature that is likely new to many developers; and he spells out how callbacks are implemented in JavaScript.

Before reading this book, I was unaware of implied semicolons in JavaScript and whey they can be dangerous. Crockford spelled out the dangers and how to avoid them very clearly.

JavaScript can be a great language if you confine your programs to using the best parts of the language and steer clear of most of the dangerous features. This book will help distinguish the two.

Episode 223

Joel Cochran on KnockoutJS

Episode 214

Elijah Manor on AmplifyJS

At Codeslingers last night, someone pulled out some coding Katas. For those who don’t know, a Kata is a coding exercise that is designed to practice your programming skills, rather than to solve a particular business problem. I was handed the classic “FizzBuzz” problem. The assignment:

Create a function that will print the integers from 1 to 100 with the following exceptions:

• If a number is divisible by 3, print the word “Fizz” in place of that number.
• If a number is divisible by 5, print the word “Buzz” in place of that number.
• If a number is divisible by both 3 and 5, print the word “FizzBuzz” in place of that number.

The output should look something like the following:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16

I started with a C# console application because that is the language with which I am most familiar. It was able to finish the following in under 2 minutes. It took me 5 minutes to write the unit tests.

          class Program { staticvoid Main(string[]
args) { for (int i = 1; i <
100; i++) { var p = FizzBuzz(i); Console.WriteLine(p); } Console.ReadLine(); } protectedstaticstring FizzBuzz(int i)
{ if (i % 15 == 0) return"FizzBuzz"; if (i
% 3 == 0) return"Fizz"; if (i
% 5 == 0) return"Buzz"; return i.ToString();
} }

I only occasionally code in JavaScript, so I tackled that language next. Someone recommended using http://jsfiddle.net/
as an online IDE for writing and sharing JavaScript, so I tried it and liked it. Of course, JavaScript is a dynamic language and one of my big challenges was spelling things correctly without all the help Visual Studio provides when writing in a statically-typed language. In my case, I misspelled the id of a div, which cost me at least 15 minutes. I created the following boilerplate HTML:

<html>
    <body>
        <div id="fizzbuzz"></div>
</body> </html>

Then, I used the following JavaScript (plus a bit of jQuery) to output the FizzBuzz results:

          for (i = 1; i <= 100; i++) {
$("#fizzbuzz").append(function()
{ var newLine = i; if (i % 3 ===
0) { newLine = "Fizz"; } if (i
% 5 === 0) { newLine = "Buzz"; } if (i
% 15 === 0) { newLine = "FizzBuzz"; } var newDiv
= $("<div>").text(newLine); return newDiv;
}); }

A simple program like this provides a fun way to practice an old language and to learn a new language. Next up, I’ll try this program with F# and Ruby, since I have very little experience with these languages.

Episode 192

Stephen Walther on the Ajax toolkit

Episode 162

Mike Amundsen on node.js