How to create a bootable UEFI USB drive with Windows 10 setup image file

Follow the steps described below and you will create by your own a Windows 10 bootable memory stick:

  1. You need to download the latest version of the software called “Rufus”;
    Note: The “Rufus” application is a nice solution, because it is free and works without any issues.You can download it from here.
  2. Install the “Rufus” application and locate the executable file;
  3. Insert in one of your computer’s USB ports a USB drive. Make sure that the memory available on your USB drive is at least 4GB;
  4. Format the USB drive in order to erase the entire data;
    Note: Before erasing it, backup everything from the USB drive to your hard drive;
  5. Run the “Rufus” executable file;
  6. From the drop-down menu,located under the “Device” feature, select your USB drive;
  7. From the drop-down menu located under the “Partition scheme and target system type” selection, chose the “MBR partition scheme for UEFI computer” feature;
    Note: If your computer has a GPT partition scheme, select from the drop-down menu the appropriate feature;
  8. Select “NTFS” feature from the drop-down menu located under the “File system”;
  9. Check if it is selected the “4096 bytes (Default)” option for the “Cluster size” selection;
  10. Check the box next to the “Quick format” feature;
  11. Check the box next to the “Create a bootable disk using” feature;
  12. Select the “ISO Image” option from the drop down menu;
  13. Click on the CD/DVD drive icon (this can be found in the right side of the “ISO Image” feature);
  14. Browse to the Windows 10 ISO image file;
  15. Check the box next to the “Create extended label and icon files” feature;
  16. Left click on the “Start” button;
  17. Now you will have to wait until the Windows 10 bootable UEFI USB stick will be created.

This is it. Now you are the happy owner of a Windows 10 UEFI bootable USB drive.



New Firefox Browser – Developer edition is awesome

First download and install from the following link..

You can check the features and tools in the following link..

Believe me..its awesome 😀

Watch this video for more..

12-11-2014 11-43-56

Callback functions in javascript

Callback functions are derived from a programming paradigm known as functional programming. At a fundamental level, functional programming specifies the use of functions as arguments.

A callback function, also known as a higher-order function, is a function that is passed to another function (let’s call this other function “otherFunction”) as a parameter, and the callback function is called (or executed) inside the otherFunction.

How Callback Functions Work?

We can pass functions around like variables and return them in functions and use them in other functions. When we pass a callback function as an argument to another function, we are only passing the function definition. We are not executing the function in the parameter. In other words, we aren’t passing the function with the trailing pair of executing parenthesis () like we do when we are executing a function.

And since the containing function has the callback function in its parameter as a function definition, it can execute the callback anytime.

Here’s a very simple example of a custom callback function:

function mySandwich(param1, param2, callback) {
    alert('Started eating my sandwich.\n\nIt has: ' + param1 + ', ' + param2);

mySandwich('ham', 'cheese', function() {
    alert('Finished eating my sandwich.');

Here we have a function called mySandwich and it accepts three parameters. The third parameter is the callback function. When the function executes, it spits out an alert message with the passed values displayed. Then it executes the callback function.

Notice that the actual parameter is just “callback” (without parentheses), but then when the callback is executed, it’s done using parentheses. You can call this parameter whatever you want, I just used “callback” so it’s obvious what’s going on.

The callback function itself is defined in the third argument passed to the function call. That code has another alert message to tell you that the callback code has now executed. You can see in this simple example that an argument passed into a function can be a function itself, and this is what makes callbacks possible in JavaScript.

Difference between closure and callback:

Closure is how you build it, callback is how you use it.

A callback can be implemented as a closure (in languages that have them) or an implementation of an interface (in Java, as an anonymous inner class or a regular class).

Callback means that you pass a piece of code to a function, so that the function can call that piece of code later. It is a special kind of parameter.

The piece of code can be a function pointer or a closure or an object with well-known methods, depending on what the language offers.



Self executable functions in javascript

I hate explaining in very big theories like big bang theory 😉

I want to be simple and short always. I will make it clear with what  i understood.

Guys, I understood self exec functions are like some kind of anonymous functions partially. Dont get confuse, my coming to end of this article i promise you will understand the reason why javascript introduces this self executable functions.

Piece of code..

(function(){ console.log(‘Hello World!’); })();


var helloWold = function() {
	alert('Hello World');


The above one is self exec function and anonymous function too..

Let’s look at this carefully. This code is made up of two key parts.

First is the anonymous function:

  //Normal code goes here

The really interesting part is what happens when we add this right at the end:


Those two little brackets cause everything contained in the preceding parentheses to be executed immediately. What’s useful here is that JavaScript has function level scoping. All variables and functions defined within the anonymous function aren’t available to the code outside of it, effectively using closure to seal itself from the outside world.


var foo = 3;




will first alert “3” and then throw an error on the next alert because foo is not defined.

Simple words: Its all about variable scoping. Variables declared in the self executing function are, by default, only available to code within the self executing function. This allows code to be written without concern of how variables are named in other blocks of javascript code.