Nook Simple Touch Recovery


Since there was a bit of bad information out there about recovering Barnes and Nobles Simple Touch eReader I thought I’d share.

I rooted mine and wanted to recover it back to stock.  You can wipe the \data partition by doing 8 interupted starts.  To do that you power it off and then on (hold power and home buttons if it’s truly borked up) until it tries to start up.  As soon as you see the starting message, press the home and power buttons simultaneously and hold them down until it restarts again.  Lather, rinse, repeat 7 more times at which point it’ll wipe the data partition and your user data.  NOTE:  This does NOT restore to factory.

To do a full recovery, power it down and then power it up right after it starts coming up, press both the left and right lower buttons on the face of the nook touch, hold them down for several seconds during the start up and it’ll prompt you for a system wipe.  Press Home twice to confirm you truly want to do that.

Takes a minute or two and then you’ll have a clean nook.




Animated Menus Using jQuery



    <style type=”text/css”>
        body {
        /* Firefox Dotted Outline Fix */
        a:active {
                outline: none;
        /* Firefox Dotted Outline Fix */
        a:focus {
                -moz-outline-style: none;
        /* Menu Body */
        ul#menu {
                background:url(bg.png) repeat-x;
        /* Float LI Elements – horizontal display */
        ul#menu li {
        /* Link – common attributes */
        ul#menu li a {
                background:url(sprite.png) no-repeat scroll top left;
        /* Specify width and background position attributes specifically for the class: “home” */
        ul#menu li a.home {
        /* Specify width and background position attributes specifically for the class: “portfolio” */
        ul#menu li a.portfolio {
                background-position:-159px 0px;
        /* Span (on hover) – common attributes */
        ul#menu li a span {
                background:url(sprite.png) no-repeat scroll bottom left;
        /* Span (on hover) – display pointer */
        ul#menu li a span:hover {
        /* Shift background position on hover for the class: “home” */
        ul#menu li a.home span {
                background-position:0px -81px;
        /* Shift background position on hover for the class: “portfolio” */
        ul#menu li a.portfolio span {
                background-position:-159px -81px;
    </style><!– Include jQuery Library –>
    <script src=”jquery-1.2.2.pack.js” type=”text/javascript”>
    <!– Let’s do the animation –>
    <script type=”text/javascript”>
        $(function() {
                // set opacity to nill on page load
                $(“ul#menu span”).css(“opacity”,”0″);
                // on mouse over
                $(“ul#menu span”).hover(function () {
                        // animate opacity to full
                                opacity: 1
                        }, ‘slow’);
                // on mouse out
                function () {
                        // animate opacity to nill
                                opacity: 0
                        }, ‘slow’);
    <ul id=”menu”>
        <a href=”#”></a>
        <a href=”#”></a>

Super-Power Showdown – US vs. China



JavaScript Game Engine Comparision

Name Sprite.js Crafty gamecore.js (Playcraft) Impact
Size (KB)  45.2K 14.5KB
Unit Tests
Collision  yes  yes
2D  yes  yes  yes
Isometric  yes  yes
Sound  yes  yes
Physics  yes  no  yes
Optimized for Mobile  yes  yes
Canvas  yes  yes
DOM  yes  yes
HTML5  yes  yes  yes
Price  free  $99
Input  Keyboard, mouse, touchscreen  Keyboard, mouse
Notes  It centered on animation making. It doesn’t provide all features other support. Detail sprite animation. A lightweight, modular JavaScript full game engine to easily produce high quality games. Support a great deal of features. Includes a large variety of components such as animation, event management, redraw regions, collision detection, sprites and more gamecore.js is a framework to help build high-performance (and large) games.  avascript / HTML5 Game Engine with world editor.
Explosion  component system (modular)
time tracking ( track object)
 dynamic background support
 Good for simple game or animation  good for complex game with large amount of code


Private and Public Members in JavaScript


JavaScript is the world’s most misunderstood programming language. Some believe that it lacks the property of information hiding because objects cannot have private instance variables and methods. But this is a misunderstanding. JavaScript objects can have private members. Here’s how.


JavaScript is fundamentally about objects. Arrays are objects. Functions are objects. Objects are objects. So what are objects? Objects are collections of name-value pairs. The names are strings, and the values are strings, numbers, booleans, and objects (including arrays and functions). Objects are usually implemented as hashtables so values can be retrieved quickly.

If a value is a function, we can consider it a method. When a method of an object is invoked, the this variable is set to the object. The method can then access the instance variables through the this variable.

Objects can be produced by constructors, which are functions which initialize objects. Constructors provide the features that classes provide in other languages, including static variables and methods.


The members of an object are all public members. Any function can access, modify, or delete those members, or add new members. There are two main ways of putting members in a new object:

In the constructor

This technique is usually used to initialize public instance variables. The constructor’s this variable is used to add members to the object.

function Container(param) {
    this.member = param;

So, if we construct a new object

var myContainer = new Container('abc');

then myContainer.member contains 'abc'.

In the prototype

This technique is usually used to add public methods. When a member is sought and it isn’t found in the object itself, then it is taken from the object’s constructor’s prototype member. The prototype mechanism is used for inheritance. It also conserves memory. To add a method to all objects made by a constructor, add a function to the constructor’s prototype:

Container.prototype.stamp = function (string) {
    return this.member + string;

So, we can invoke the method


which produces 'abcdef'.


Private members are made by the constructor. Ordinary vars and parameters of the constructor becomes the private members.

function Container(param) {
    this.member = param;
    var secret = 3;
    var that = this;

This constructor makes three private instance variables: param, secret, and that. They are attached to the object, but they are not accessible to the outside, nor are they accessible to the object’s own public methods. They are accessible to private methods. Private methods are inner functions of the constructor.

function Container(param) {

    function dec() {
        if (secret > 0) {
            secret -= 1;
            return true;
        } else {
            return false;

    this.member = param;
    var secret = 3;
    var that = this;

The private method dec examines the secret instance variable. If it is greater than zero, it decrements secret and returns true. Otherwise it returns false. It can be used to make this object limited to three uses.

By convention, we make a private that variable. This is used to make the object available to the private methods. This is a workaround for an error in the ECMAScript Language Specification which causes this to be set incorrectly for inner functions.

Private methods cannot be called by public methods. To make private methods useful, we need to introduce a privileged method.


A privileged method is able to access the private variables and methods, and is itself accessible to the public methods and the outside. It is possible to delete or replace a privileged method, but it is not possible to alter it, or to force it to give up its secrets.

Privileged methods are assigned with this within the constructor.

function Container(param) {

    function dec() {
        if (secret > 0) {
            secret -= 1;
            return true;
        } else {
            return false;

    this.member = param;
    var secret = 3;
    var that = this;

    this.service = function () {
        return dec() ? that.member : null;

service is a privileged method. Calling myContainer.service() will return 'abc' the first three times it is called. After that, it will return null. service calls the private dec method which accesses the private secret variable. service is available to other objects and methods, but it does not allow direct access to the private members.


This pattern of public, private, and privileged members is possible because JavaScript has closures. What this means is that an inner function always has access to the vars and parameters of its outer function, even after the outer function has returned. This is an extremely powerful property of the language. There is no book currently available on JavaScript programming that shows how to exploit it. Most don’t even mention it.

Private and privileged members can only be made when an object is constructed. Public members can be added at any time.



function Constructor() {

this.membername = value;

Constructor.prototype.membername = value;


function Constructor() {

var that = this;
membername = value;function membername() {}


Note: The function statement

function membername() {}

is shorthand for

var membername = function membername() {};


function Constructor() {

this.membername = function () {};



// class Pet
var NamespaceAnimal = {};

NamespaceAnimal.Pet = function (name) {

//or function Pet(name) {
this.getName = function () { return name; };

this.setName = function (newName) { name = newName; };

this.getAge = function () { return age; };

this.setAge = function (newAge) { age = newAge; };


var weight;


NamespaceAnimal.Pet.prototype.toString = function () {

return “This pet’s name is: ” + this.getName();


// end of class Pet

var parrotty = new NamespaceAnimal.Pet(“Parrotty the Parrot”);

// class Dog : Pet

// public Dog(string name, string breed)

NamespaceAnimal.Dog = function (name, breed) {

// think Dog : base(name)
this.breed = breed, name);

//privilaged method
//in JavaScript, the private members are accessible only through
//methods that have these private members within their closures
//(these methods are usually called privileged methods, since
//they are different from ordinary public methods).
this.getBreed = function () { return this.breed; }; //breed is a private member

//private method
function checkBreed(breedType) {
if (this.getBreed == breedType) {
return 1;
} else {
return 0;


// this makes Dog.prototype inherits

// from Pet.prototype

NamespaceAnimal.Dog.prototype = new NamespaceAnimal.Pet();

// remember that Pet.prototype.constructor

// points to Pet. We want our Dog instances’

// constructor to point to Dog.

NamespaceAnimal.Dog.prototype.constructor = NamespaceAnimal.Dog;

// Now we override Pet.prototype.toString

NamespaceAnimal.Dog.prototype.toString = function () {

return “This dog’s name is: ” + this.getName() +

“, and its breed is: ” + this.getBreed(); //can’t call doggy.breed


// end of class Dog

var doggy = new NamespaceAnimal.Dog(“Buddy”, “Great Dane”);

// test the new toString()
jQuery(function ($) {

” + doggy.toString());




trigger button in javascript on server side

String csname2 = “ButtonClickScript”;

StringBuilder cstext2 = new StringBuilder();


cstext2.Append(“<script type=\”text/javascript\”>”);



cstext2.Append(“‘, ”);”);



Page.ClientScript.RegisterStartupScript(this.GetType(), csname2, cstext2.ToString());