IMHO, programming languages can be learned best like natural languages: by
using them in everyday life.  Therefore, I (seriously) suggested you try to
use scripting to solve *your* problems first, those which bug *you* the
most.  Start with the ones that look simple on the outset.  Find them to be
more complex than you thought.  Do not let yourself be discouraged, and take
your time to solve them eventually.  Then use the experience gained to solve
even more complex problems.

When (not: if) you get stuck in the process, read *again* everything about
the topic that you can get your hands on (electronic material is cheapest
and readily available, but not always best; books are more expensive and
tend to be bad).  Read it again.  What is most important: Do not fall for
self-proclaimed gurus; compare your sources, verify what they are saying.
Look into the message, not at the messenger.  If anything still remains
unclear, ask smart questions[1] about it.

This is how I started learning the languages a decade ago and it is still
serving me well.

HTH

PointedEars

Tackle problems that you really need to solve only when you know
enough to be reasonably sure of making a good job of them.

http://webstervanrobot.com/ (only tested on Firefox)

The program implements a small programming language on top of
Javascript that allows a robot to move around a grid of streets and
avenues.

It got me acquainted with the following concepts:

  creating objects
  manipulating DOM
  parsing strings
  implementing data structures
  responding to events
  setting up callbacks and responding to them
  variable scoping (this, var, etc.)
  cross-browser pain (which I have punted on so far)

If you're learning Javascript, this might be a fun program to hack on,
because it's all self-contained and not tied to any domain, and I'm
hoping to make it a useful program.  It really is a "Javascript
program," as opposed to code that lives within a larger system, for
better or worse.

Some challenges:

  1) Make it work on a browser other than Firefox.
  2) Change the world to be rendered on a canvas instead of tables.
  3) Add scrolling to the world.
  4) Add new capabilities for the robot.
  5) Add new syntax to the programming language.
  6) Simply play around with the code, try to restructure it to your
liking.
  7) Get the program to have a mode where you can click on it to see
the internal data structures that define the world.

Yes, I'm subversively asking for help with my program, but the program
was written with the intention of helping people learn Javascript (and
programming in general).  It's free software.

Cheers,

http://developer.yahoo.com/yui/theater/

Define function add such that

     add(3)(4)

function add (first) {
    return function (second) {
        return first + second;
    }

@Douglas:
I'd also appreciate more puzzles if you know any. This kind of (simple
but interesting) problem is a godsend when you're teaching kids.

The only thing I've seen recently that comes close to a puzzle is this
website:

  http://parentnode.org/static/challange2.html

You need to enter the correct password, that's all. No rewards :-) It's
not pretty, rather the opposite, but if you like obfuscation, it might
be interesting. Syntax highlighting helps.

Also, I thank others who posted their invaluable comments.

A few caveats:
- The examples assume that a print() function has been defined, which
  is usually not the case in a browser environment (Rhino does have a
  print() function though).
- The later examples build on the results of the previous ones, meaning
  that they are not self-contained.

IIRC that page has even been posted here before.

var n = 101111;

n.toString(2).replace(/1/g, "ON ").
replace(/0/g,"OFF ").replace(/ $/,'');

Garrett

http://groups.google.com/group/comp.lang.javascript/msg/28559592272d4e54

The whole thread is

http://groups.google.com/group/comp.lang.javascript/browse_frm/thread...

Thanks for posting that because I have played with it a little and I
have learnt that it converts reals as well:

(3.1416).toString(2) ->
11.001001000011111111100101110010010001110100010100111

and that it will fail as miserably as mine and without warning (for
those numbers that a 'number' primitive value can't represent
accurately):

javascript:alert((9007199254740991).toString(2))  ->
11111111111111111111111111111111111111111111111111111
javascript:alert((9007199254740991.4).toString(2))->
11111111111111111111111111111111111111111111111111111
javascript:alert((9007199254740991.5).toString(2))->
100000000000000000000000000000000000000000000000000000
javascript:alert((9007199254740992).toString(2))  ->
100000000000000000000000000000000000000000000000000000
javascript:alert((9007199254740993).toString(2))  ->
100000000000000000000000000000000000000000000000000000

While writing 'my version', I was going to 'logically' test the bits
with an '&', but I have discovered that the & operator operates on
just 32 bits, not on the 53 available in the mantissa of a 'number'
primitive value:

javascript:alert(9007199254740991 & Math.pow(2,31)) ===
-10000000000000000000000000000000
javascript:alert(9007199254740991 & Math.pow(2,32)) === 0

function toBinaryString (number) {
  var weight= Math.pow(2, 52), binStr= '', decimalPoint;
  do {
    if (number >= weight) {
      number-= weight;
      binStr+= '1';
    } else { binStr+= binStr ? '0' : ''; }

    if (((weight/= 2) < 1) && !decimalPoint) {
        decimalPoint= 1;
        if (number) {
          binStr+= binStr ? '.' : '0.';
        } else { binStr+= binStr ? '' : '0'; }
    }
  } while (!decimalPoint || (number && weight))
  return binStr;