Live Demo

Download

Code sample:

<script type="text/javascript"
    src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js"></script>
<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=true"></script>
<script type="text/javascript" src="map.js"></script>

<input type="reset" id="pick_addr" value="Pick Address" />

<script type="text/javascript">
<!--
$(document).ready(function(){
	function callback(pos, addr, addr_ext){
		alert(pos, addr, addr_ext);
	}

	var default_pos = new google.maps.LatLng(39.904214, 116.407413);
	var opt = {
		pos: default_pos,
		callback: callback
	};
	var addr_picker = new AddressPicker(opt);

	$('#pick_addr').click(function(){
		addr_picker.open();
	});
});
//-->
</script>

• You codes run before the image is downloaded from web server,
• event you use jQuery to bind a “load” event handler on that image, your codes won’t work when the image is loaded from browser cache(jQuery bug).

Let me show you the WRONG ways:

(WRONG)get width/height after setting html content

var html = '<img src="URL" />;
$('#my_div').html(html);
var width = $('#my_div img').width(); // may return 0

(WRONG)get width/height in “load” event handler

var html = '<img src="URL" />';
var img = $(html);
html.load(function(){
    // return 0 if image is loaded from browser cache
    var width = img.width();
});
$('#my_div').html(img);

And now, comes the right way…

The Exact way

var html = '<img src="URL" />';
$('#my_div').html(html);

var ni = new Image();
ni.onload = function(){
    var width = ni.width;
}
ni.src = img.attr(URL);

• Text segment, the machine instructions that the CPU executes. Usually, the text segment is sharable so that only a single copy needs to be in memory for frequently executed programs, such as text editors, the C compiler, the shells, and so on. Also, the text segment is often read-only, to prevent a program from accidentally modifying its instructions.
• Initialized data segment, usually called simply the data segment, containing variables that are specifically initialized in the program. For example, the C declaration

      int   maxcount = 99;
  

  appearing outside any function causes this variable to be stored in the initialized data segment with its initial value.

• Uninitialized data segment, often called the “bss” segment, named after an ancient assembler operator that stood for “block started by symbol.” Data in this segment is initialized by the kernel to arithmetic 0 or null pointers before the program starts executing. The C declaration

      long  sum[1000];
  

  appearing outside any function causes this variable to be stored in the uninitialized data segment.

• Stack, where automatic variables are stored, along with information that is saved each time a function is called. Each time a function is called, the address of where to return to and certain information about the caller’s environment, such as some of the machine registers, are saved on the stack. The newly called function then allocates room on the stack for its automatic and temporary variables. This is how recursive functions in C can work. Each time a recursive function calls itself, a new stack frame is used, so one set of variables doesn’t interfere with the variables from another instance of the function.
• Heap, where dynamic memory allocation usually takes place. Historically, the heap has been located between the uninitialized data and the stack.

Figure 7.6 shows the typical arrangement of these segments. This is a logical picture of how a program looks; there is no requirement that a given implementation arrange its memory in this fashion. Nevertheless, this gives us a typical arrangement to describe. With Linux on an Intel x86 processor, the text segment starts at location 0x08048000, and the bottom of the stack starts just below 0xC0000000. (The stack grows from higher-numbered addresses to lower-numbered addresses on this particular architecture.) The unused virtual address space between the top of the heap and the top of the stack is large.

Figure 7.6. Typical memory arrangement

Several more segment types exist in an a.out, containing the symbol table, debugging information, linkage tables for dynamic shared libraries, and the like. These additional sections don’t get loaded as part of the program’s image executed by a process.

Note from Figure 7.6 that the contents of the uninitialized data segment are not stored in the program file on disk. This is because the kernel sets it to 0 before the program starts running. The only portions of the program that need to be saved in the program file are the text segment and the initialized data.

The size(1) command reports the sizes (in bytes) of the text, data, and bss segments. For example:

    $ size /usr/bin/cc /bin/sh
       text     data   bss     dec     hex   filename
      79606     1536   916   82058   1408a   /usr/bin/cc
     619234    21120 18260  658614   a0cb6   /bin/sh

The fourth and fifth columns are the total of the three sizes, displayed in decimal and hexadecimal, respectively.

——

All text copy from Advanced Programing in the Unix Environment.

View: Demo

// define
(function($){
    $.fn.lazybind = function(event, fn, timeout, abort){
        var timer = null;
        $(this).bind(event, function(e){
            var ev = e;
            timer = setTimeout(function(){
                fn(ev);
            }, timeout);
        });
        if(abort == undefined){
            return;
        }
        $(this).bind(abort, function(){
            if(timer != null){
                clearTimeout(timer);
            }
        });
    };
})(jQuery);

// example
$('#my_img').lazybind(
    'mouseover',
    function(){
        alert(1);
    },
    500,
    'mouseout');

@Parameters

• event: string, event to bind to
• fn: function, callback
• timeout: int, time to wait before fn being called, in millisecond
• abort: string, on which event the binding will be cancelled.

We didn’t talk too much on the phone during first call from Google HR, a kind lady. Actually, it was because my spoken English, you know, I didn’t even speak a English word during the past threes year. But I suggest I should directly go to there office and have a face-to-face interview.

The guy was an engineer, we had a comfortable conversation. He asked me to traverse a binary tree for the first question to work out. I was not simply the Preorder Traversal, Inorder Traversal or Postorder Traversal, but to print out every node when you left it behind, it was: Parent-Left-Parent-Right-Parent order.

The second question was based on the first one. I was asked to transform the output of the first question back into a tree. This one was more easier, I worked it out within 3 minutes. All codes were written in Python.

So I got into next round, also a coding and algorithm interview. I was asked to find out the Not-intersection set from two lists. He wrote a prototype of C++ function, then I asked if I may change the return type from list to list pointer, and the parameters from list to list reference. I firstly wrote one with two loops and STL list.find(), it was O(n2). We both know Google would not satisfied with it, then I said it should be using hashmap, not the solution. The he said the lists are ordered.

Next question was to find one random element from a list with an unknown length, with we only had a random function that returns double in (0, 1). He said that was one of the problems he faced in Google works and has not yet figured out a acceptable solution. I said it would be two traverses through the list, one to find out the length, and one to return the randomed index one. Until now, I still don’t know how could it be improved. But later after came home, I find something interesting relative to the question, and wrote a mail to the interviewer about that.

The last interviewer, I felt a bit weird about him, the conversation totally turned us into opposite sides. You know, people have feelings about each other at first glance. He asked me to design a web system like is.gd – the URL shorten service. Firstly, make it work, then supporting enormouse number of users, multi-IDC, distributed system synchronization, etc. I thought this as a wide question, so I didn’t answer into specifics, but he did not caught my idea at all! He asked something like how to distribute HTTP requests on multi servers? I said we may use network hardwares, or software like LVS, or HTTP proxy server(e.g. lighttpd, nginx). Oh man, what were you expecting for? Is this a question about certain technic, or is this a question about system/architecture design?

He realized the question was a blow into the air, so he followed with an algorithm question. Which I don’t want to talk about here, because I didn’t work it out at that time. It was not a complicated question, but he told in a unprofessional way. Howerver, time spending with this guy was not pleasant, it should be a friend-talk, which I expected.

You may have guessed out the consequence, I failed the interview for my weakness in algorithm. But I actually made a big improvement on my career since three years ago. I sent my resume to Google when I was a university student three years ago, and I didn’t even get a man-made reply. This time, I went a further way.

Play Online Now >>

The structure of source code can be demonstrate in this steps:

1. handle = BeginInvoke(my_function)
2. do other work
3. result = handle.EndInvoke()
4. deal with result

Or in callback way:

1. handle = BeginInvoke(my_function, callback)
2. do other work

Python does not support Asynchronous, so I made a Delegate class, you can do Asynchronous Programming in the same way like .NET Framework does:

#encoding=UTF-8
import time, random
import sys
from delegate import *

def proc(a):
    time.sleep(random.random())
    return str(a)

def proc_callback(handle, args=None):
    try:
        ret = d.end(handle)
        log.debug('proc return: ' + repr(ret))
    except Exception,e:
        log.warn('end throw Exception: ' + str(e))
        return

d = Delegate()
d.init(2) # number of workers

n = 0
while True:
    n += 1
    log.debug("Press 'q' to quit, Enter to continue.")
    line = sys.stdin.readline().strip()
    if line == 'q':
        break
    data = str(n)
    handle = d.begin(proc, data, proc_callback, 'test')
    log.debug('register ' + data)

d.free()

Download source code: pap.zip API doc

File objects on Windows are not acceptable, but sockets are. On Windows, the underlying select function is provided by the WinSock library, and does not handle file descriptors that don’t originate from WinSock.

In a recent project, I must continuously read from one network socket, forward to another socket, until the user input ‘q’ from the console. One may think to use threading, but I don’t want to deal with multi-thread stuffs. Finally, I found a none-clear solution, and it worked.

I create one thread – YES, thread, but no multi-thread concerns – this thread open a server socket listening on random port, then open a client socket connect to this server. The server socket accept the connection, then call sys.stdin.read() in a block way, all data read from stdin will write to that accepted connection. So client socket receive data reading from stdin. Now, the client socket is a *selectable* stdin, and it is thread-safe.

Download source code: stdio.py