Javascript – What common programming problems are best solved by using prototypes and closures

Take a look at this as a reference (Book of Speed): http://www.bookofspeed.com/chapter3.html

Essentially the best way is to combine all your javascript into one file called something like all.min.js that is also minimized.

Typically in HTML5 you would do something like:

<script src="js/all.min.js"></script>

As you can see, you DO NOT need the type attribute in HTML5, but you do in other versions of HTML and XHTML. The spec clarifies that if the content is other than "text/javascript" then you need to specify the type attribute, in HTML5.

Some things to remember:

• Always include it before the closing tag;
• You should load your scripts in a non-blocking pattern.

Note:

If you are going to specify another type other than text/javascript you would use one of the following:

• "application/ecmascript"
• "application/javascript"
• "application/x-ecmascript"
• "application/x-javascript"
• "text/ecmascript" "text/javascript"
• "text/javascript1.0"
• "text/javascript1.1"
• "text/javascript1.2"
• "text/javascript1.3"
• "text/javascript1.4"
• "text/javascript1.5"
• "text/jscript"
• "text/livescript"
• "text/x-ecmascript"
• "text/x-javascript"
• "text/javascript;e4x=1"

The above list is from: http://dev.w3.org/html5/spec-author-view/the-script-element.html#scriptingLanguages

Remember that you would not use the language attribute, only the type attribute.

I think the discussion regarding objects vs. functions is a red herring. If the question is, "Is a lambda a function or an object?" the answer should be yes.

That's the point of first-class functions: they aren't treated differently than any other type. Java already manages to mostly ignore the differences between Object and primitive types (and Scala does even better), so whether a lambda is a subclass of Object or is a new primitive type or something else isn't really important for the language. What is important is that you can put your lambdas in collections, pass them around to be called, call them, and do anything else you might want to do with either an object or a method.

Scala accomplishes this by using a wrapper object that has a method called apply which can be invoked with just (), making it look just like a method call. This works splendidly; much of the time you don't need to even care whether you have a method or are calling the apply of a function object.