Paisa Bolta Hai Sabri Brothers Free mp3 | Paisa Bolta Hai.mp3 | Sabri Brothers | Download Free Mp3

The Sabri Borthers
Paisa Bolta Hai-All Time Hit....(original)Live Concert Qawwali!!! 
Format                         : MPEG Audio
File size                        : 11.4 MiB
Duration                      : 12mn 25s
Overall bit rate           : 128 Kbps
Album                          : Paisa Bolta Hai (orignal_All Time Hit)
Performer                    : Sabri Brothers
Accompaniment         : Uploaded by
Composer                    : Sabri brothers
Publisher                      : Uploaded by
Genre                            : Other
Comment                      : Visit for more.....

Format                           : MPEG Audio
Format version             : Version 1
Format profile               : Layer 3
Mode                              : Joint stereo
Mode extension            : MS Stereo
Duration                         : 12mn 27s
Bit rate mode                 : Constant
Bit rate                            : 128 Kbps
Channel(s)                      : 2 channels
Sampling rate                : 44.1 KHz
Stream size                     : 11.4 MiB (100%)

Saw Inception? Still Confused?

Like a lot of you we’ve spent most of the weekend thinking about one thing: Inception. You can see our attempt to explain what’s going on the movie here but before you can even begin to guess at director Christopher Nolan’s intentions or what happens after the movie’s mind-blowing final sequence, you’ll need a clear idea of all the levels of Inception.

With that in mind, we’ve put together a helpful visual aid. Here it is, an illustrated guide to the five levels of Inception:

SPOILER WARNING: What follows should only be viewed by people who have already seen Inception. It contains heavy, critical spoilers which will impact your viewing of the film. If you haven’t seen Inception yet, stop reading and don’t come back until you do.

See below Diagrammatic Explanation of Inception 

The absolute bare minimum every programmer should know about regular expressions

The absolute bare minimum every programmer should know about regular expressions

Wtf is a regular expression?

Regular expressions are strings formatted using a special pattern notation that allow you to describe and parse text. Many programmers (even some good ones) disregard regular expressions as line noise, and it’s a damned shame because they come in handy so often. Once you’ve gotten the hang of them, regular expressions can be used to solve countless real world problems.
Regular expressions work a lot like the filename “globs” in Windows or *nix that allow you to specify a number of files by using the special * or ? characters (oops, did I just use a glob while defining a glob?). But with regular expressions the special characters, or metacharacters, are far more expressive.
Like globs, regular expressions treat most characters as literal text. The regular expression mike, for example, will only match the letters m - i - k - e, in that order. But regular expressions sport an extensive set of metacharacters that make the simple glob look downright primitive.

Meet the metacharacters: ^[](){}.*?\|+$ and sometimes -

I know, they look intimidating, but they’re really nice characters once you get to know them.

The Line Anchors: ‘^’ and ‘$’

The ‘^’ (caret) and ‘$’ (dollar) metacharacters represent the start and end of a line of text, respectively. As I mentioned earlier, the regular expression mike will match the letters m - i - k - e, but it will match anywhere in a line (e.g. it would match “I’m mike”, or even “carmike”). The ‘^’ character is used to anchor the match to the start of the line, so ^mike would only find lines that start with mike. Similarly, the expression mike$ would only find m - i - k - e at the end of a line (but would still match ‘carmike’).
If we combine the two line anchor characters we can search for lines of text that contain a specific sequence of characters. The expression ^mike$ will only match the word mike on a line by itself - nothing more, nothing less. Similarly the expression ^$ is useful for finding empty lines, where the beginning of the line is promptly followed by the end.

The Character Class: ‘[]‘

Square brackets, called a character class, let you match any one of several characters. Suppose you want to match the word ‘gray’, but also want to find it if it was spelled ‘grey’. A character class will allow you to match either. The regular expression gr[ea]y is interpreted as “g, followed by r, followed by either an e or an a, followed by y.”
If you use [^ ... ] instead of [ ... ], the class matches any character that isn’t listed. The leading ^ “negates” the list. Instead of listing all of the characters you want to included in the class, you list the characters you don’t want included. Note that the ^ (caret) character used here has a different meaning when it’s used outside of a character class, where it is used to match the beginning of a line.

The Character Class Metacharacter: ‘-’

Within a character-class, the character-class metacharacter ‘-’ (dash) indicates a range of characters. Instead of [01234567890abcdefABCDEF] we can write [0-9a-fA-F]. How convenient. The dash is a metacharacter only within a character class, elsewhere it simply matches the normal dash character.
But wait, there’s a catch. If a dash is the first character in a character class it is not considered a metacharacter (it can’t possibly represent a range, since a range requires a beginning and an end), and will match a normal dash character. Similarly, the question mark and period are usually regex metacharacters, but not when they’re inside a class (in the class [-0-9.?] the only special character is the dash between the 0 and 9).

Matching Any Character With a Dot: ‘.’

The ‘.’ metacharacter (called a dot or point) is shorthand for a character class that matches any character. It’s very convenient when you want to match any character at a particular position in a string. Once again, the dot metacharacter is not a metacharacter when it’s inside of a character class. Are you beginning to see a pattern? The list of metacharacters is different inside and outside of a character class.

The Alternation Metacharacter: ‘|’

The ‘|’ metacharacter, (pipe) means “or.” It allows you to combine multiple expressions into a single expression that matches any of the individual ones. The subexpressions are called alternatives.
For example, Mike and Michael are separate expressions, but Mike|Michael is one expression that matches either.
Parenthesis can be used to limit the scope of the alternatives. I could shorten our previous expression that matched Mike or Michael with creative use of parenthesis. The expression Mi(ke|chael) matches the same thing. I probably would use the first expression in practice, however, as it is more legible and therefore more maintainable.

Matching Optional Items: ‘?’

The ‘?’ metacharacter (question mark) means optional. It is placed after a character that is allowed, but not required, at a certain point in an expression. The question mark attaches only to the immediately preceding character.
If I wanted to match the english or american versions of the word ‘flavor’ I could use the regex flavou?r, which is interpreted as “f, followed by l, followed by a, followed by v, followed by o, followed by an optional u, followed by r.”

The Other Quantifiers: ‘+’ and ‘*’

Like the question mark, the ‘+’ (plus) and ‘*’ (star) metacharacters affect the number of times the preceding character can appear in the expression (with ‘?’ the preceding character could appear 0 or 1 times). The metacharacter ‘+’ matches one or more of the immediately preceding item, while ‘*’ matches any number of the preceding item, including 0.
If I was trying to determine the score of a soccer match by counting the number of times the announcer said the word ‘goal’ in a transcript, I might use the regular expression go+al, which would match ‘goal’, as well as ‘gooooooooooooooooal’ (but not ‘gal’).
The three metacharacters, question mark, plus, and star are called quantifiers because they influence the quantity of the item they’re attached to.

The Interval Quantifier: ‘{}’

The ‘{min, max}’ metasequence allows you to specify the number of times a particular item can match by providing your own minimum and maximum. The regex go{1,5}al would limit our previous example to matching between one and five o’s. The sequence {0,1} is identical to a question mark.

The Escape Character: ‘\’

The ‘\’ metacharacter (backslash) is used to escape metacharacters that have special meaning so you can match them in patterns. For example, if you would like to match the ‘?’ or ‘\’ characters, you can precede them with a backslash, which removes their meaning: ‘\?’ or ‘\\’.
When used before a non-metacharacter a backslash can have a different meaning depending on the flavor of regular expression you’re using. For perl compatible regular expressions (PCREs) you can check out the perldoc page for perl regular expressions. PCREs are extremely common, this flavor of regexes can be used in PHP, Ruby, and ECMAScript/Javascript, and many other languages.

Using Parenthesis for Matching: ‘()’

Most regular expression tools will allow you to capture a particular subset of an expression with parenthesis. I could match the domain portion of a URL by using an expression like http://([^/]+). Let’s break this expression down into it’s components to see how it works.
The beginning of the expression is fairly straightforward: it matches the sequence “h - t - t - p - : - / - /”. This initial sequence is followed by parenthesis, which are used to capture the characters that match the subexpression they surround. In this case the subexpression is ‘[^/]+’, which matches any character except for ‘/’ one or more times. For a URL like, ‘’ will be captured by the parenthesis.


Top 10 Things That Annoy Programmers

Programmers all have their pet peeves. Whether it’s scope creep, Hungarian notation, or smelly coworkers, we’ve come to accept that there are certain nuisances that come with our line of work. The following is a list of the top 10 things that annoy programmers, compiled from the results of my recent question on StackOverflow along with some of my own experiences:

10. Comments that explain the “how” but not the “why”

Introductory-level programming courses teach students to comment early and comment often. The idea is that it’s better to have too many comments than to have too few. Unfortunately, many programmers seem to take this as a personal challenge to comment every single line of code. This is why you will often see something like this code snippit taken from Jeff Atwood’s post on Coding Without Comments:
1r = n / 2; // Set r to n divided by 2
3// Loop while r - (n/r) is greater than t
4while ( abs( r - (n/r) ) > t ) {
5    r = 0.5 * ( r + (n/r) ); // Set r to half of r + (n/r)
Do you have any idea what this code does? Me neither. The problem is that while there are plenty of comments describing what the code is doing, there are none describing why it’s doing it.
Now, consider the same code with a different commenting methodology:

1// square root of n with Newton-Raphson approximation
2r = n / 2;
4while ( abs( r - (n/r) ) > t ) {
5    r = 0.5 * ( r + (n/r) );
Much better! We still might not understand exactly what’s going on here, but at least we have a starting point.
Comments are supposed to help the reader understand the code, not the syntax. It’s a fair assumption that the reader has a basic understanding of how a for loop works; there’s no need to add comments such as “// iterate over a list of customers”. What the reader is not going to be familiar with is why your code works and why you chose to write it the way you did.

9. Interruptions

Very few programmers can go from 0 to code at the drop of a hat. In general, we tend to be more akin to locomotives than ferraris; it may take us awhile to get started, but once we hit our stride we can get an impressive amount of work done. Unfortunately, it’s very hard to get into a programming zone when your train of thought is constantly being derailed by clients, managers, and fellow programmers.
There is simply too much information we need to keep in mind while we’re working on a task to be able to drop the task, handle another issue, then pick up the task without missing a beat. Interruptions kill our train of thought and getting it back is often a time-consuming, frustrating, and worst of all, error-prone process.

8. Scope creep

From Wikipedia:
Scope creep (also called focus creep, requirement creep, feature creep, and sometimes kitchen sink syndrome) in project management refers to uncontrolled changes in a project’s scope. This phenomenon can occur when the scope of a project is not properly defined, documented, or controlled. It is generally considered a negative occurrence that is to be avoided.
Scope creep turns relatively simple requests into horribly complex and time consuming monsters. It only takes a few innocent keystrokes by the requirements guy for scope creep to happen:
  • Version 1: Show a map of the location
  • Version 2: Show a 3D map of the location
  • Version 3: Show a 3D map of the location that the user can fly through
Argh! What used to be a 30 minute task just turned into a massively complex system that could take hundreds of man hours. Even worse, most of the time scope creep happens during development, which requires rewriting, refactoring, and sometimes throwing out code that was developed just days prior.

7. Management that doesn’t understand programming

Ok, so maybe there are some perks.

Management is not an easy job. People suck; we’re fickle and fragile and we’re all out for #1. Keeping a large group of us content and cohesive is a mountain of a task. However, that doesn’t mean that managers should be able to get away without having some basic understanding of what their subordinates are doing. When management cannot grasp the basic concepts of our jobs, we end up with scope creep, unrealistic deadlines, and general frustration on both sides of the table. This is a pretty common complaint amongst programmers and the source of a lot of angst (as well as one hilarious cartoon).

6. Documenting our applications

Let me preface this by saying that yes, I know that there are a lot of documentation-generating applications out there, but in my experience those are usually only good for generating API documentation for other programmers to read. If you are working with an application that normal everyday people are using, you’re going to have to write some documentation that the average layman can understand (e.g. how your application works, troubleshooting guides, etc.).
It’s not hard to see that this is something programmers dread doing. Take a quick look at all the open-source projects out there. What’s the one thing that all of them are constantly asking for help with? Documentation.
I think I can safely speak on behalf of all programmers everywhere when I say, “can’t someone else do it?“.

5. Applications without documentation

I never said that we weren’t hypocrites. :-) Programmers are constantly asked to incorporate 3rd party libraries and applications into their work. In order to do that, we need documentation. Unfortunately, as mentioned in item 6, programmers hate writing documentation. No, the irony is not lost on us.
There is nothing more frustrating than trying to utilize a 3rd party library while having absolutely no fricken idea what half the functions in the API do. What’s the difference between poorlyNamedFunctionA() and poorlyButSimilarlyNamedFunctionB()? Do I need to perform a null check before accessing PropertyX? I guess I’ll just have to find out through trial and error! Ugh.

4. Hardware

Any programmer who has ever been called upon to debug a strange crash on the database server or why the RAID drives aren’t working properly knows that hardware problems are a pain. There seems to be a common misconception that since programmers work with computers, we must know how to fix them. Granted, this may be true for some programmers, but I reckon the vast majority of us don’t know or really care about what’s going on after the code gets translated into assembly. We just want the stuff to work like it’s supposed to so we can focus on higher level tasks.

3. Vagueness

“The website is broken”. “Feature X isn’t working properly”. Vague requests are a pain to deal with. It’s always surprising to me how exasperated non-programmers tend to get when they are asked to reproduce a problem for a programmer. They don’t seem to understand that “it’s broken, fix it!” is not enough information for us to work off of.
Software is (for the most part) deterministic. We like it that way. Humor us by letting us figure out which step of the process is broken instead of asking us to simply “fix it”.

2. Other programmers

Programmers don’t always get along with other programmers. Shocking, but true. This could easily be its own top 10 list, so I’m just going to list some of the common traits programmers have that annoy their fellow programmers and save going into detail for a separate post:
  • Being grumpy to the point of being hostile.
  • Failing to understand that there is a time to debate system architecture and a time to get things done.
  • Inability to communicate effectively and confusing terminology.
  • Failure to pull ones own weight.
  • Being apathetic towards the code base and project
And last, but not least, the number 1 thing that annoys programmers…

1. Their own code, 6 months later

Don’t sneeze, I think I see a bug.

Ever look back at some of your old code and grimace in pain? How stupid you were! How could you, who know so much now, have written that? Burn it! Burn it with fire!
Well, good news. You’re not alone.
The truth is, the programming world is one that is constantly changing. What we regard as a best practice today can be obsolete tomorrow. It’s simply not possible to write perfect code because the standards upon which our code is judged is evolving every day. It’s tough to cope with the fact that your work, as beautiful as it may be now, is probably going to be ridiculed later. It’s frustrating because no matter how much research we do into the latest and greatest tools, designs, frameworks, and best practices, there’s always the sense that what we’re truly after is slightly out of reach. For me, this is the most annoying thing about being a programmer. The fragility of what we do is necessary to facilitate improvement, but I can’t help feeling like I’m one of those sand-painting monks.
Well, there you have it. The top 10 things that annoy programmers. Again, if you feel that I missed anything please be sure to let me know in the comments!

Mozilla Firefox's Need For Speed | Firefox 4.0 | Mozilla Firefox |

It's clear that Mozilla likes what Google has done with the web browser. Chief among their plans for Firefox 4, which they hope to release later this year, are a focus on improving performance and creating a new tabbed interface that resembles Google Chrome.

Firefox 4 will bring a number of new features, including support for Direct2D, compatibility with multitouch and a 64-bit version. But the biggest focus will be on speed. One reason why many people have switched from Firefox, which is easily one of the most powerful browsers, to Google Chrome, which is playing catch-up in the feature department, is the pure speed of Google's web browser.

Over the past few years, Firefox has become packed with really cool features, especially in the plug-in department. And as often happens, the added bloat has detracted from overall performance. So, instead of people switching from Microsoft's Internet Explorer (IE) to Mozilla's Firefox to see big boost in speed, people are switching from IE and Firefox to Chrome.

In an effort to get back to its roots, Firefox will shine the spotlight on both true performance and perceived performance, such as modifying the order in which web page elements load. Add in the speed increase that a 64-bit version will bring and Firefox 4 should be a breath of fresh air.

But the biggest visible change 
-- and likely the one that will have Firefox users chatting 
-- will be to the interface itself. 

Firefox 4 will move the tabs above the address bar ala Google Chrome. It will also do away with the standard menu bar (File, Edit, View, etc.) in favor of a Firefox button with a drop down menu, another feature taken from Chrome.

And, of course, there will be a lot of HTML 5 goodies, including support for Scalable Vector Graphics. There's also hopes to include support for WebGL, but that feature could find itself on the cutting room floor in order to bring the browser in on time.

Which programming language should I learn first? | Which language? | First Learning Language | Choosing 1st Programming Language |

Which programming language should I learn first?
[billion times ask by new bees/new programmers ]


  • To program in an expressive and powerful language: Python

  • To get a website up quickly: PHP

  • To mingle with programmers who call themselves “rockstars”: Ruby.

  • To really learn to program: C.

  • To achieve enlightenment: Scheme.

  • To feel depressed: SQL

  • To drop a chromosome: Microsoft Visual Basic

  • To get a guaranteed, mediocre, but well paying job writing financial applications in a cubicle under fluorescent lights: Java.

  • To do the same thing with certifications and letters after your name: C#

  • To achieve a magical sense of childlike wonder that you have a hard time differentiating from megalomania: Objective C

I could go on… but I’m not feeling hateful enough today.

Seven JavaScript Things I Wish I Knew Much Earlier In My Career..... | Seven JavaScript | JavaScript |

Seven JavaScript Things I Wish I Knew Much Earlier In My Career.....

I’ve been writing JavaScript code for much longer than I care to remember. I am very excited about the language’s recent success; it’s good to be a part of that success story. I’ve written dozens of articles, book chapters and one full book on the matter, and yet I keep finding new things. Here are some of the “aha!” moments I’ve had in the past, which you can try out rather than waiting for them to come to you by chance.

Shortcut Notations

One of the things I love most about JavaScript now is shortcut notations to generate objects and arrays. So, in the past when we wanted to create an object, we wrote:
var car = new Object();
car.colour = 'red';
car.wheels = 4;
car.hubcaps = 'spinning';
car.age = 4;
The same can be achieved with:
var car = {
Much shorter, and you don’t need to repeat the name of the object. Right now, car is fine, but what happens when you use invalidUserInSession? The main gotcha in this notation is IE. Never ever leave a trailing comma before the closing curly brace or you’ll be in trouble.
The other handy shortcut notation is for arrays. The old school way of defining arrays was this:
var moviesThatNeedBetterWriters = new Array(
  'Transformers','Transformers2','Avatar','Indiana Jones 4'
The shorter version of this is:
var moviesThatNeedBetterWriters = [
  'Transformers','Transformers2','Avatar','Indiana Jones 4'
The other thing about arrays is that there is no such thing as an associative array. You will find a lot of code examples that define the above car example like so:
var car = new Array();
car['colour'] = 'red';
car['wheels'] = 4;
car['hubcaps'] = 'spinning';
car['age'] = 4;
This is not Sparta; this is madness—don’t bother with this. “Associative arrays” is a confusing name for objects.
Another very cool shortcut notation is the ternary notation for conditions. So, instead of the following…
var direction;
if(x < 200){
  direction = 1;
} else {
  direction = -1;
… You could write a shorter version using the ternary notation:
var direction = x < 200 ? 1 : -1;
The true case of the condition is after the question mark, and the other case follows the colon.

JSON As A Data Format

Before I discovered JSON to store data, I did all kinds of crazy things to put content in a JavaScript-ready format: arrays, strings with control characters to split, and other abominations. The creation of JSON by Douglas Crockford changed all that. Using JSON, you can store complex data in a format that is native to JavaScript and doesn't need any extra conversion to be used immediately.
JSON is short for "JavaScript Object Notation" and uses both of the shortcuts we covered earlier.
So, if I wanted to describe a band, for example, I could do the following:
var band = {
  "name":"The Red Hot Chili Peppers",
      "name":"Anthony Kiedis",
      "role":"lead vocals"
      "name":"Michael 'Flea' Balzary",
      "role":"bass guitar, trumpet, backing vocals"
      "name":"Chad Smith",
      "name":"John Frusciante",
      "role":"Lead Guitar"
You can use JSON directly in JavaScript and, when wrapped in a function call, even as a return format of APIs. This is called JSON-P and is supported by a lot of APIs out there. You can use a data endpoint, returning JSON-P directly in a script node:

This calls the Delicious Web service to get my latest JavaScript bookmarks in JSON format and then displays them as an unordered list.
In essence, JSON is probably the most lightweight way of describing complex data—and it runs in a browser. You can even use it in PHP using the json_decode() function.

Native JavaScript Functions (Math, Array And String)

One thing that amazed me is how much easier my life got once I read up thoroughly on the math and string functions of JavaScript. You can use these to avoid a lot of looping and conditions. For example, when I had the task of finding the largest number in an array of numbers, I used to write a loop, like so:
var numbers = [3,342,23,22,124];
var max = 0;
for(var i=0;i
  if(numbers[i] > max){
    max = numbers[i];
This can be achieved without a loop:
var numbers = [3,342,23,22,124];
numbers.sort(function(a,b){return b - a});
Notice that you cannot use sort() on a number array because it sorts lexically. There's a good tutorial on sort() here in case you need to know more.
Another interesting method is Math.max(). This one returns the largest number from a list of parameters:
Math.max(12,123,3,2,433,4); // returns 433
Because this tests for numbers and returns the largest one, you can use it to test for browser support of certain properties:
var scrollTop= Math.max(
This works around an Internet Explorer problem. You can read out the scrollTop of the current document, but depending on the DOCTYPE of the document, one or the other property is assigned the value. When you use Math.max() you get the right number because only one of the properties returns one; the other will be undefined. You can read more about shortening JavaScript with math functions here.
Other very powerful functions to manipulate strings are split() and join(). Probably the most powerful example of this is writing a function to attach CSS classes to elements.
The thing is, when you add a class to a DOM element, you want to add it either as the first class or to already existing classes with a space in front of it. When you remove classes, you also need to remove the spaces (which was much more important in the past when some browsers failed to apply classes with trailing spaces).
So, the original function would be something like:
function addclass(elm,newclass){
  var c = elm.className;
  elm.className = (c === '') ? newclass : c+' '+newclass;
You can automate this using the split() and join() methods:
function addclass(elm,newclass){
  var classes = elm.className.split(' ');
  elm.className = classes.join(' ');
This automatically ensures that classes are space-separated and that yours gets tacked on at the end.

Event Delegation

Events make Web apps work. I love events, especially custom events, which make your products extensible without your needing to touch the core code. The main problem (and actually one of its strengths) is that events are removed from the HTML—you apply an event listener to a certain element and then it becomes active. Nothing in the HTML indicates that this is the case though. Take this abstraction issue (which is hard for beginners to wrap their heads around) and the fact that "browsers" such as IE6 have all kind of memory problems and too many events applied to them, and you'll see that not using too many event handlers in a document is wise.
This is where event delegation comes in. When an event happens on a certain element and on all the elements above it in the DOM hierarchy, you can simplify your event handling by using a single handler on a parent element, rather than using a lot of handlers.
What do I mean by that? Say you want a list of links, and you want to call a function rather than load the links. The HTML would be:

Great Web resources

The normal way to apply event handlers here would be to loop through the links:
// Classic event handling example
  var resources = document.getElementById('resources');
  var links = resources.getElementsByTagName('a');
  var all = links.length;
  for(var i=0;i
    // Attach a listener to each link
  function handler(e){
    var x =; // Get the link that was clicked
This could also be done with a single event handler:
  var resources = document.getElementById('resources');
  function handler(e){
    var x =; // get the link tha
    if(x.nodeName.toLowerCase() === 'a'){
      alert('Event delegation:' + x);
Because the click happens on all the elements in the list, all you need to do is compare the nodeName to the right element that you want to react to the event.
Disclaimer: while both of the event examples above work in browsers, they fail in IE6. For IE6, you need to apply an event model other than the W3C one, and this is why we use libraries for these tricks.
The benefits of this approach are more than just being able to use a single event handler. Say, for example, you want to add more links dynamically to this list. With event delegation, there is no need to change anything; with simple event handling, you would have to reassign handlers and re-loop the list.

Anonymous Functions And The Module Pattern

One of the most annoying things about JavaScript is that it has no scope for variables. Any variable, function, array or object you define that is not inside another function is global, which means that other scripts on the same page can access—and will usually override— them.
The workaround is to encapsulate your variables in an anonymous function and call that function immediately after you define it. For example, the following definition would result in three global variables and two global functions:
var name = 'Chris';
var age = '34';
var status = 'single';
function createMember(){
  // [...]
function getMemberDetails(){
  // [...]
Any other script on the page that has a variable named status could cause trouble. If we wrap all of this in a name such as myApplication, then we work around that issue:
var myApplication = function(){
  var name = 'Chris';
  var age = '34';
  var status = 'single';
  function createMember(){
    // [...]
  function getMemberDetails(){
    // [...]
This, however, doesn't do anything outside of that function. If this is what you need, then great. You may as well discard the name then:
  var name = 'Chris';
  var age = '34';
  var status = 'single';
  function createMember(){
    // [...]
  function getMemberDetails(){
    // [...]
If you need to make some of the things reachable to the outside, then you need to change this. In order to reach createMember() or getMemberDetails(), you need to return them to the outside world to make them properties of myApplication:
var myApplication = function(){
  var name = 'Chris';
  var age = '34';
  var status = 'single';
      // [...]
      // [...]
// myApplication.createMember() and
// myApplication.getMemberDetails() now works.
This is called a module pattern or singleton. It was mentioned a lot by Douglas Crockford and is used very much in the Yahoo User Interface Library YUI. What ails me about this is that I need to switch syntaxes to make functions or variables available to the outside world. Furthermore, if I want to call one method from another, I have to call it preceded by the myApplication name. So instead, I prefer simply to return pointers to the elements that I want to make public. This even allows me to shorten the names for outside use:
var myApplication = function(){
  var name = 'Chris';
  var age = '34';
  var status = 'single';
  function createMember(){
    // [...]
  function getMemberDetails(){
    // [...]
//myApplication.get() and myApplication.create() now work.
I've called this "revealing module pattern."

Allowing For Configuration

Whenever I've written JavaScript and given it to the world, people have changed it, usually when they wanted it to do things that it couldn't do out of the box—but also often because I made it too hard for people to change things.
The workaround is to add configuration objects to your scripts. I've written about JavaScript configuration objects in detail, but here's the gist:
  • Have an object as part of your whole script called configuration.
  • In it, store all of the things that people will likely change when they use your script:
    • CSS ID and class names;
    • Strings (such as labels) for generated buttons;
    • Values such as "number of images being displayed," "dimensions of map";
    • Location, locale and language settings.
  • Return the object as a public property so that people can override it.
Most of the time you can do this as a last step in the coding process. I've put together an example in "Five things to do to a script before handing it over to the next developer."
In essence, you want to make it easy for people to use your code and alter it to their needs. If you do that, you are much less likely to get confusing emails from people who complain about your scripts and refer to changes that someone else actually did.

Interacting With The Back End

One of the main things I learned from all my years with JavaScript is that it is a great language with which to make interactive interfaces, but when it comes to crunching numbers and accessing data sources, it can be daunting.
Originally, I learned JavaScript to replace Perl because I was sick of copying things to a cgi-bin folder in order to make it work. Later on, I learned that making a back-end language do the main data churning for me, instead of trying to do all in JavaScript, makes more sense with regard to security and language.
If I access a Web service, I could get JSON-P as the returned format and do a lot of data conversion on the client, but why should I when I have a server that has a richer way of converting data and that can return the data as JSON or HTML… and cache it for me to boot?
So, if you want to use AJAX, learn about HTTP and about writing your own caching and conversion proxy. You will save a lot of time and nerves in the long run.

Browser-Specific Code Is A Waste Of Time. Use Libraries!

When I started Web development, the battle between using document.all and using document.layers as the main way to access the document was still raging. I chose document.layers because I liked the idea of any layer being its own document (and I had written more than enough document.write solutions to last a lifetime). The layer model failed, but so did document.all. When Netscape 6 went all out supporting only the W3C DOM model, I loved it, but end users didn't care. End users just saw that this browser didn't show the majority of the Internets correctly (although it did)—the code we produced was what was wrong. We built short-sighted code that supported a state-of-the-art environment, and the funny thing about the state of the art is that it is constantly changing.
I've wasted quite some time learning the ins and outs of all of the browsers and working around their issues. Doing this back then secured my career and ensured that I had a great job. But we shouldn't have to go through this trial by fire any longer.
Libraries such as YUI, jQuery and Dojo are here to help us with this. They take on the problems of browsers by abstracting the pains of poor implementation, inconsistencies and flat-out bugs, and relieve us of the chore. Unless you want to beta test a certain browser because you're a big fan, don't fix browser issues in your JavaScript solutions, because you are unlikely to ever update the code to remove this fix. All you would be doing is adding to the already massive pile of outdated code on the Web.
That said, relying solely on libraries for your core skill is short-sighted. Read up on JavaScript, watch some good videos and tutorials on it, and understand the language. (Tip: closures are God's gift to the JavaScript developer.) Libraries will help you build things quickly, but if you assign a lot of events and effects and need to add a class to every HTML element in the document, then you are doing it wrong.

How Google Keeps Your Data Safe in the Cloud

How Google Keeps Your Data Safe in the Cloud

In a blog post today, Google essentially reminds its enterprise customers that Google Apps provides an alternative to expensive, complex solutions as far as data disaster recovery goes.
Synchronous replication is a system that Google Apps uses to store customer’s info in two data centers at once, so that if one data center fails, Google () says it nearly instantly transfers data over to the other one that’s also been reflecting the actions taken by the customer all along.
On the practical side this means that thanks to the cloud-based storage solution, Google customers won’t lose any data in a data center failure. Just as crucially, they are theoretically back up and running straight away — although the online giant does acknowledge that no backup solution is perfect.
This synchronous replication is applied to the entire Apps suite as well as Gmail () (Google Calendar, Google Docs () and Google Sites), with the sales angle being enterprise-class back-up for all at a much lower cost than if companies were to provide or contract separately for their own data redundancy systems.
Google, ever keen to push its Apps suite to new corporate clients of all sizes, estimates that this kind of backup could cost up to $500 for 25GB of data from other providers, but says it can bundle it in because it’s already running large, fast data centers.
This is essentially Google reminding enterprise customers (and potential customers) about one of the significant benefits of cloud computing over traditional in-house server farm data storage. How does your business handle data backup and redundancy issues? Do you think cloud computing is the ideal solution to hardware failure?

10 Popular Firefox Add-ons for Web Developers | Add-ons for Web Developers | Popular Firefox Add-ons |

10 Popular Firefox Add-ons for Web Developers

We searched forums, blogs, and TwitterTwitter to find out which Firefox 
Firefox add-ons are most popular with web developers, and we came up with this top 10 list.
Every plug-in on the list offers outstanding utility to developers who install them in their browsers. In fact, some of them are even considered indispensable. And they’re all available as free downloads for Firefox, right now.
If you know any other developer staples that didn’t make our top 10, be sure to share them with us and our other readers in the comments.

1. Firebug

With Firebug, you can edit the CSS, HTML, and JavaScript on any web page live without navigating to a different application. Changes can be made and previewed in real-time. The add-on also comes with network activity analysis tools and a JavaScript performance profiler. Like the Firefox browser itself, Firebug can be extended with plug-ins that add new features.

2. Web Developer

The Web Developer add-on is the most powerful and dynamic extension in this list; it adds a toolbar that lets you do numerous useful things.
You can disable Java, disable or view cookies, disable CSS, view styles, see detailed information on forms, disable images, find broken images, view JavaScript, display all kinds of behind-the-scenes information, edit HTML, show hidden elements, resize the window to a specified resolution, validate code and much more.

3. ColorZilla

ColorZilla is a color picker that lives down in your browser’s status bar. Just click the ColorZilla button and move the cursor over the color you want to find out about; you’ll be given a reading that includes the color’s RGB values and the hexadecimal code you need to duplicate the color on your own site. ColorZilla also includes a color wheel, a page zoomer and a measuring tool.

4. HTML Validator

HTML Validator appears as an icon in the status bar, and displays the number of HTML errors Firefox encountered when opening up a web page. You can then dive into the HTML code to investigate what caused the errors.
Be warned that when you navigate to the Firefox add-on page for HTML Validator, you’ll be told that the add-on isn’t available for download for your operating system if you’re a Mac or Linux user. Take a quick trip to the developer’s website and you’ll find versions for several platforms, though.

5. FireFTP

FireFTP is an adequately featured FTP (File Transfer Protocol) client that runs inside Firefox. When you execute it, it appears as an extra window just like Firefox’s bookmark or download managers. Features aren’t just limited to the basics; you can perform integrity checks or searches, sync directories while navigating, compare directories and so on. This add-on should meet the needs of the majority of FTP users.

6. IE Tab

Microsoft’s Internet ExplorerInternet ExplorerInternet Explorer web browser is barely used by web developers, but it’s the most popular browser in the world at large. With IE Tab you can open any website in a tab that’s actually running IE instead of Firefox. That way, you can more easily make sure your website runs correctly for millions of people who aren’t using Firefox.
Note that IE Tab is not available for Mac or Linux, since you need to have IE installed for it to work and there are not any currently supported versions of IE for non-Windows operating systems.

7. MeasureIt

With MeasureIt, you can draw a rectangular ruler anywhere on the website to get the measurements (height and width) in pixels of any element or space. Similar functionality is offered by ColorZilla, so running both add-ons at the same time would be redundant, but this plug-in is nevertheless hugely popular.

8. Greasemonkey

Greasemonkey allows more advanced customization of your browser by executing custom JavaScript scripts that change the way websites are displayed. Hundreds of scripts are available, and many of them are tailored to specific websites. For example, we’ve covered the Facebook Friends Checker script in the past; it monitors your friends list when you’re logged in to FacebookFacebookFacebook and notifies you when one has been removed.

9. View Source Chart

When you look at the source for a web page using Firefox’s normal tools, you’re given a massive block of barely-organized text; it’s not very easy to scan and look for something specific. View Source Chart displays a web page’s source code in a set of smartly divided, colored partitions. It visually represents tag boundaries and DOM structure so you can navigate efficiently without getting lost in the noise.

10. Aardvark

Use Aardvark to select elements on a website and perform any one of a broad selection of functions on them. You just click on an element and hit one of several keyboard shortcuts. Possibilities include hitting R to remove the element, W to widen it, I to isolate it or V to view the element’s source. Hitting H for “help” brings up a list of all 14 shortcuts.

Advanced Call Manager | ACM E63 | Global Bloxx | ACM | ACM Download | ACM free Download | Advanced Call Manager for Eseries |

Advanced Call Manager

Advanced Call Manager will handle your incoming calls and let you personalize your response so your phone never rings at an inappropriate time again. All you need to be in control is Advanced Call Manager: it will handle the incoming calls for you and personalize your approach to the callers – play an instant busy tone, send an SMS, divert calls, mute the ringer or play a personal greeting.


 Advanced Call Manager | ACM E63 | Global Bloxx | ACM | ACM Download | ACM free Download | Advanced Call Manager for Eseries |


Take control of your time!

ACM handles your incoming calls with a personalized approach to different callers – it can play an instant busy tone, send a custom SMS, mute the ringer, divert calls or play a personal greeting. You can easily save different profiles and schedule them according to a time interval or location.
Advanced Call Manager lets you set up your mobile into several modes:
  • Accept all calls (inactive)
  • Reject all calls
  • Accept phonebook only
  • Reject from black list and accept from white list (you have to define the lists in advance)
  • Reject all + custom action (e.g. send SMS to your wife or girlfriend if she calls)

Supported Reject Actions (depending on your platform):
  • Send busy tone / drop
  • Reply by SMS
  • Mute the ringer
  • Divert calls
  • Play a personal greeting
  • Pick up and hang up

Working with Lists and SMS Templates
With Advanced Call Manager, you can organize your phone book into custom lists - black lists (people you don't like to disturb you), white list (important people who are "allowed" to call you) or any other custom list. You can set different call-handling actions for the groups you have defined and thus have extra flexibility in personalized handling of calls.
With the SMS templates you can set special messages for each group very easily. You can do the same with personalized voice greetings.
The application allows you to save selected call-handling configurations for typical scenarios as Profiles. You can easily switch to a profile whenever you need it and save the time for re-configuration.
The Scheduler tool allows you to activate a selected profile at a certain time once or on a daily basis. No need to switch profiles in the evenings while you are home or in the daytime while you are in the office. Allow ACM to handle this depending on your daily schedule. With Advanced Call Manager, you are able to associate previously selected network cells to a profile and thus have automatic profile activation depending on your location.

With its comprehensive set of features designed to cater to your needs, ACM seamlessly integrates with your phone and secures flawless call capturing and handling – allowing you to enjoy your time and privacy.
  • Ultra‐fast recognition and capturing of incoming calls, leaving the caller unaware of your current availability
  • Changeable status indicator of the program activity in the phone stand‐by screen (not available for BlackBerry devices)
  • Handling of hidden callers to help you avoid people whose numbers cannot be retrieved
  • Tight integration with phone book contacts
  • Feature‐rich, making it possible to effectively handle any situation and all incoming call traffic
  • Auto‐run at power‐on

You are busy, constantly in important meetings and discussions and your mobile is always ringing in a bad moment? All you need is the Advanced Call Manager. It will handle the incoming calls for you and personalize your approach to the callers - answer with a busy tone, send a kind SMS, divert calls, mute the ringer or play a personalized greeting.

The Advanced Call Manager unique feature is the ultra-fast recognition of remote callers which allows personalized replies (SMS, mute, reject, accept, greet, divert) to be attributed within a part of a second leaving the caller unaware of your current availability. The application rich functionality makes it a very convenient tool for any manager as it saves time by taking over the management of your incoming calls when you are too busy to do it by yourself.

With Advanced Call Manager you can organize your phone book into custom lists like Black (people you don't like to disturb you), White list (important people which are "allowed" to call you) or any other custom lists (a very special custom group could be your family to which you can wish to send a personal SMS if somebody calls you during a meeting). The application enables you to set different actions for the groups you have defined - you can accept, reject, divert calls, send personalized SMS, play personalized greeting or mute the ringer. In SMS templates you can set special messages for each group very easily. You can do the same with the personalized greetings.

The Advanced Call Manager lets you tune your mobile into several modes:

  • Accept all calls (inactive)
  • Reject all calls
  • Accept Phonebook only
  • Reject from black list (you have to define the list in advance)
  • Accept from white list (you have to define the list in advance)
  • Reject all personal (e.g. send SMS to your wife or girlfriend if she calls).

Additionally you can specify:

  • Reject hidden callers (you can avoid people whose numbers cannot be retrieved)
  • Accept hidden callers.

For reject-call actions you can choose to:

  • Send busy tone
  • Reply by SMS
  • Divert calls
  • Play personalized greeting
  • Mute the ringer.

Main product features:

  • Ultra fast searching algorithm recognizes the remote caller within a part of the second
  • Convenient management of all incoming calls
  • Auto run at power-on feature
  • Status indicator of the program activity
  • Tight integration with the contacts from the phone book
  • Profiles management: You can save/load your current ACM configuration. ACM Profiles includes your active mode, hidden callers mode and the default action.
  • Profile schedule: You can schedule your custom configuration according to specified time.
  • Profiles localization: You can localize your custom configuration according to your current Cell Id.

If you have problems with installing the program or licence, please go to Tools->Application Manager->Options->Settings->Software Installation and select "All".

S60 3rd Edition Screenshots: