Function.prototype.method = function ( name, func ) {
                        this.prototype[name] = func;
                        return this;
                        };

Number.method('integer' , function()    {
                        return Math[this < 0 ? 'ceiling' : 'floor'](this);
                        });

My question is: what the hell is Function.prototype.method doing?
2nd What the hell is Number doing?

The function creates a property of the object referenced by its this
keyword with a name that is the value of the 'name' parameter and
assigns it a reference to whatever the value of func is (in this case,
it is expected to be a reference to a function).  It returns the value
of its this keyword (I guess for convenience if it's required, it can
be ignored).

If I'd written the above, I'd probably have used the name 'addMethod'
rather than 'method'.

To be clear, when calling Number.method, the identifier 'method' will
be checked to see if it is a property of Number.  If not found,
Number's internal [[prototype]] property will be checked - it
references Function.prototype, which has the newly added 'method' as a
property, so method is called with the value of its this keyword set
as a reference to Number.

The method function added to Function.prototype provides a convenient
way of adding methods to any native constructor's prototype (including
both built-in and user-defined ones) and is effectively equivalent to
using <constructor>.prototype.  The methods added with method will be
inherited by instances created by the constructors.

e.g.

  function func(){}
  var functionRef = func;

  function Foo(){}
  Foo.method('methodName0', functionRef);
  Foo.method('methodName1', function() {/*...*/});

  var foo = new Foo();

  alert(typeof foo.methodName0) // -> function
  alert(typeof foo.methodName1) // -> function

1. Quite a few of the built-in objects in javascript are set up this
way, such as Object, Array, String and others.

As a further note, had method been added to Function, to have the same
effect it would have to have been called as:

  Function.method.call(constructor, name, func);

  e.g. from the Number example:

  Function.method.call(Number, 'integer' , function() {...});

rather than:

  constructor.method(name, func);

        var x = 3.5;
        alert( x.integer() ); // 3

        var y = -4.5;
        alert( y.integer() ); // -4

Hubert

I hope you've understood that Crockford is creating the language he
would have invented if he'd had the chance. It's not always easy to work
out why he's doing it.

Function.prototype.method = function ( name, func ) {
    this.prototype[name] = func;
    return this;

Inline code would be an alternative:-

n |= 0; // chop off decimal.

No conversion to object, no function call and doesn't change
Number.prototype.

Garrett

Because he's not a good designer ?

He sometimes forgets to type 'new' and the compiler doesn't notice, so
you mustn't use 'new'.

You might forget to type 'else' and the compiler won't notice, but
that's all right because he doesn't make that mistake.

Yea verily, he's not the thinking programmer's greatest framework
designer.