def _callService (self, headers, callback, errback = None, method='GET'):
    # ....
    return some_val

def _callServiceGET (*args, **kwargs):
    return args[0]._callService (*args[1:], method='GET', **kwargs)

def _callServiceHEAD (*args, **kwargs):
    return args[0]._callService (*args[1:], method='HEAD', **kwargs)

/

Last time when I was here I was looking for the “Perfect Editor”.  Well, I guess there is no such thing as a “Perfect Editor”.  There is probably an “Editor which works for you”, but I guess that could be too subjective for some :).

I gave emacs a shot and I think I am in love.  I haven’t really looked at anything other than emacs at all. Took me a while to get used to those weird finger twister shortcuts but I think I am beyond that now and I don’t even realize when I do a C-x-s.

I have sort of personalized it a lot though.  Since I mostly program in C, the first thing I got was CEDET.  I probably just use 1% of what it really offers, but whatever I use, it makes writing code a lot easier e.g. It has these nice separators for functions so when you’re scrolling through the code you can easily figure where the functions start and finish; also, it has a status line on top which tells you the context you’re in (which function you’re writing etc.).  Well there’s so much it offers that I cannot possibly mention it all here.  If you’re curious its worth a shot.

I also got a couple of more plugins for managing collapsible scopes (like the +/- buttons next to functions in modern editors and IDEs) and languages like lua and php (support wasn’t there with the default emacs package on Arch).

Well, that’s all about it I guess, I’d be sticking to emacs for the foreseeable future I guess, but if I change my mind, I’d let you know.

/

On linux, there are a whole bunch of editors. None of them, right now to me I would say, sound as convenient as Visual Studio.  I am not saying Visual Studio is the ultimate editor/IDE, just that I am used to it and when I use a new editor that’s where my standard is.

On linux, I have been using eclipse lately. It was great initially, but now it’s turning into a nightmare.  Auto completion is painfully slow with it, and as the number of your library includes and source files go up, the more its failing to deliver.  It’s not that bad though, I’ve been using it for a while and so far I am getting my work done.

Another editor I’ve been using to edit single files is geany.  It’s simple, nice syntax highlighting, native (not in Java), and if you do a native compile on arch, you’re in for some serious speed surprise.

I started a thread on stackoverflow.com to discuss this.  I have a few things that I want my editor to do, and I have a few responses which I am going to try out.

Before getting into GUI editors, I will have to give emacs a try.  I’ve been putting it off for a while now and before I can make a choice, emacs deserves some serious thought.  I use vi occasionally, it hasn’t impressed me much to the point that I start using it as my regular editor. Not that its not great, its awesome.  The things people have been doing with it are mind-blowing.  Just that I don’t want that much hassle to setup my environment around. But I’ve got some nice scripts people are sharing on stackoverflow, so I will give it another shot.

But for now, its emacs’ turn.

In case you have a suggestion, I primarily program in C and python.  Occasionally in C++, C# and Java.

It is now available as an ubuntu package which can be downloaded and installed directly on an Ubuntu 9.04 machine. The program should now be super convenient to install.

More features are being added to the program everyday, so stay tuned (actually the program will let you know whenever a new version is available).

/

I just got the GMail Notification application I had been working to a stable state. It should now work for you on a Ubuntu 9.04+ system. Just download the source and run:

./gmail-notify

The first time you run it, it should ask you for your gmail credentials.

I am looking into making it into a .deb package but that will have to wait while I figure out how to do it. Till then feel free to test it and let me know of any problems you get into.

/

I have included some documentation on the Usage wiki page.

/

Silverlight is different, that it only has asynchronous network calls and you can’t really imitate sync calls, which makes the use of a RPC a little weird.

I have written a small XML-RPC library for Silverlight. Actually its just a single C# file which users can just drag and drop into their projects. The library is still under development, presently I am hacking together a parser, making sure it works with the most common scenarios.

Here is what the usage of this library looks like. You instantiate a service class, and then instantiate query requests as shown below:

XmlRpcService service
            = new XmlRpcService ("http://betty.userland.com/RPC2");
XmlRpcRequest req
            = new XmlRpcRequest (service, "examples.getStateName",
                     new object [] { 10 });
req.XmlRpcCallCompleteHandler
            += new XmlRpcCallComplete (req_XmlRpcCallCompleteHandler);

req.Execute (null);

Once your call completes or some error occurs, your event handler is invoked (Here I am just assuming that the call succeeded):

void req_XmlRpcCallCompleteHandler (XmlRpcResponse response, object userState) {
    string result = (string)response.TryCast (typeof (string));
    System.Diagnostics.Debug.WriteLine ("Result: " + result);
}

You try to cast the response into a string, if it cannot be casted you get back a null or the default value for value types. TryCast is pretty powerful, you can declare a class and have TryCast map the returned struct (associative array) to that class. E.g. lets say we have this fault class:

public class Fault {
    public int FaultCode;
    public string FaultString;

    public override string  ToString() {
                 return "Fault Code: " + FaultCode.ToString ()
                     + ", Fault String: " + FaultString;
    }
}

You can use TryCast to map a fault response to this class. Note that, the names of the members here actually match with those returned when a fault occurs (see XML-RPC spec), case is not important though. You can use your own classes to map with struct returned as XML-RPC responses, this should be pretty handy. I will include more details when I actually release the library.

So a more fault tolerant event handler would look something like this:

Fault f = (Fault)response.TryCast (typeof (Fault));
if (f != null) {
    Debug.WriteLine ("Fault occured: " + f.ToString ());
    if (f.FaultCode == -1) {
        Debug.WriteLine ("OMG! -1 ERROR!");
    }
}
else {
    string result = (string)response.TryCast (typeof (string));
    Debug.WriteLine ("Result: " + result);
}

I am still working on a few things with this library, I will post it up here as soon as I am done, I promise!

Stay tuned!

/

#!/usr/bin/python
#
import os
import fcntl

class lock:
        def __init__(self):
                self.lockf = 0
                self.file = 0

        def lock(self):
                self.lockf = open ('/tmp/mytmpfilename.1001', 'a')
                fcntl.flock (self.lockf, fcntl.LOCK_EX)
                self.file = open ('/tmp/mytmpfilename.1001','w')

        def unlock(self):
                self.file.close ()
                self.lockf.close ()

###

If you know of a better way of synchronizing processes, please let me know.

Edit.10/21/2008:

Here is more specifically what my scripts do. Perhaps, this post makes more sense in the correct context. The description below was taken from one of my comments.

All instances of my cgi script perform a read operation followed by a delete operation. Essentially, my script reads the top row from the database. Right after the information is retrieved that particular row is deleted. In other words, I am using my database as a FIFO buffer. Now if several instances of my scripts are running, more than one of them could access the first row (read it), thereby letting two different processes fetch the same element from a FIFO. One but all of them then fails with the deletion operation. The whole idea behind this locking mechanism was to avoid this. All instances of my script should always fetch a different item.

/

As one of the scenarios, lets say you have a data processing module in your program that accepts fixed size buffers for processing, however the way you’re accepting data from, lets say, the network is variable sized buffers. The data chunks recieved from over the network may be smaller or larger than the buffer size accepted by the data processing module. In this scenario, you should be able to wait for more data to arrive till your data processor can process it, or in case of access data you should be able to store it somewhere so that it could be retrieved in the next pass.

This is common problem I find myself stuck with whenever I am dealing with data streaming applications. So I wrote a simple class that helps me manage all this. Appending and retrieving operations with this class are O(1) As pointed out by Thomas below, appending and retrieving data is O(n) operation where n is the number of bytes being read in or appended.  Locating the correct block of data which holds the next chunk of data is O(1).

Here’s what the class looks like

class staging_buffer {
private:
	struct __buffer_data { unsigned char *pdata; size_t nlen; size_t offset; };
	std::list<__buffer_data>	__data;
	size_t __held_data_len;
private:
	size_t _internal_min(size_t x, size_t y) {
		return (x < y ? x : y);
	}

public:
	staging_buffer() : __data (), __held_data_len (0) {
	}

	~staging_buffer(void) {
		while (!__data.empty ()) {
			free (__data.front().pdata);
			__data.pop_front ();
		}
		__held_data_len = 0;
	}

	void append (void *pdata, int nlen) {
		__buffer_data bd;
		bd.pdata = (unsigned char *)malloc (nlen); memcpy (bd.pdata, pdata, nlen);
		bd.nlen = nlen;
		bd.offset = 0;

		__held_data_len += bd.nlen;
		__data.push_back (bd);
	}

	size_t  fetch (void *pdata, size_t nlen) {
		size_t nreadbytes = 0;
		while (nreadbytes < nlen && !__data.empty()) {
			__buffer_data& bd = __data.front ();

			size_t bytestocopy = _internal_min (nlen - nreadbytes, bd.nlen - bd.offset);
			std::memcpy ((unsigned char *)pdata + nreadbytes, bd.pdata + bd.offset, bytestocopy);
			if (bytestocopy + bd.offset &gt;= bd.nlen) {
				free (bd.pdata); __data.pop_front  ();
			} else {
				bd.offset += bytestocopy;
			}

			nreadbytes += bytestocopy;
		}
		__held_data_len -= nreadbytes;

		return nreadbytes;
	}

	size_t size () {
		return __held_data_len;
	}
};

Hope you find it useful.

Which is a YAY! IMHO. I love Java.