• Almost done with my master thesis

    26May
    Categories: Uncategorized Comments: 0

    Puff. This semester must be the most demanding one, as the master thesis should be completed, and all necessary writing, coding, analyzing, etc should be comprehensible presented in the report.

    One observation I’ve made is that concepts and understandings which I find quite simple and understandable in my own words, may have the opposite effect on others. It is hard to mentally set yourself behind the wheels of another person, and try to write explanations as simple and understandable that almost everyone can get the idea at the first try. This is where figures comes in handy. One tips: Learn to use the Dia tool early, because you will need it. Also, gnuplot is extremely usefull.. :)

    It seems like for each day goes by, I only produce more and more post-its on my desk.

    The final delivery date for my master thesis is now 8.June 2008, as I managed to get an postponement from my faculty. The second after delivery, I’ll go straight home and pop up a ice-cold refreshing beer. Can’t wait.. :)

    The above picture is from my working desk. Notice the left-most pc beneath the desk - that’s my feet-relaxer box. Efficient resource usage one might say. Also, the post-it’s, every geek got to love post-it’s…

    Every working environment needs a whiteboard - in fact, every home needs a whiteboard. That shall be one of the first things I will purchase when I’ve delivered my master thesis… :) This working environment is shared by 12 others master students, and a room full of 13 geeks

    needs some “time-killers”.. For instance, we have a racetrack, as shown below:

  • Twitter from commandline

    05May
    Categories: Funny, Uncategorized, linux, lucene, python, tips Comments: 1

    I’ve been taken by the Twitter storm these days.. Damn, I should focus a hole lot more on my master report. Well, this took me only one little hour, so it’s not that waste of time.. :) So, I guess you have heard about the new “facebook” called Twitter? Well, its this new web community thing were people can write their current status for what they are doing in the world.. And, of course, one can follow friends and pay attention to were / what they are doing.. Now, after some time I found it rather heavy to enter the twitter webpage, login, and then post a new twitter message for each time I want to update my status. So, as a python fan I am, I created myself a little python script to capture this problem. It relies on the python-twitter module available at the Google Code pages. So, lets have a look at the code. I have named this file “update.py”, however feel free to rename it.

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

    #!/usr/bin/env python
import twitter
import sys
 
USERNAME=""
PASSWORD=""
 
def postNewMessage(msg):
    api = twitter.Api()
    api = twitter.Api(username="", password="")
 
    if isinstance(msg, list):
        msg = " ".join(msg)
    msg = unicode(msg, "utf-8")
    if len(msg) > 140:
        print "ERROR: Message can't be over 140 chars."
        return
    try:
        api.PostUpdate(msg)
        print "OK. Was %i chars in msg." % len(msg)
    except Exception, e:
        print "FUck.."
 
    api.ClearCredentials()
 
if __name__ == "__main__":
    if len(sys.argv) > 1:
        t = sys.argv[1:]
        if len(t) == 1 and len(t[0]) > 10:
            # writes ./update "hi there mate"
            postNewMessage(t[0])
        else:
            # writes ./update hello world
            postNewMessage(sys.argv[1:])
    else:
        print "fuck"
    Tags: ,

  • Performing disitributed operation with python

    01May
    Categories: distributed, python Comments: 0

    Hi.

    In the worst writing rush in my master thesis I found it quite relaxing to enjoy some other reading than research papers and such. What I wanted to do is to create a master robot to control a set of other robots, whereas a robot is just a simple program running on a host. Pretty much the same thing that goes on in Botnets, but this is not a botnet though. My goal is to create a crawling system to crawl URIs, and download and parse the documents retrieved into plain text. Then, to create a forward index in a efficient data structure. When this is done, I would make my not-yet-constructed indexer index those documents and construct an inverted index.

    Now, this project is not meant to be any “enterprise” software or such, only a hobby or shall I say interest of my.

    However, the core in such a crawling system is that is needs a way to communicate with each other. So, I’ve explored some distributed approaches performed in Python, and come up with some alternatives:

    • Pyro: Python Remote Object is very much the same as the good old CORBA.
    • XML-RPC: Has the advantage of beeing extreme simplistic. However, there are some overhead of using XML to transport remote-procedure-calls. I would guess that it is quite application dependent (do you need speed or simplicity?)
    • SOAP: Doh.. SOAP is a very heavy protocol widely used in web services. It is also very simple, given the appropriate tools, but a little deprecated in light of the other approaches.
    • Sockets: Using pure TCP/UDP sockets (low-level) is significantly fast in contrast to the above approaches. However, it requires some more programming and hence more time. There is a tradeoff here somewhere..

    We will here illustrate a simple “client-server” example based on the Pyro module. Our goal is to add two integers and return the result. Lets first consider the server:

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    #!/usr/bin/env python
import Pyro.core
import Pyro.naming
 
class MathServer(Pyro.core.ObjBase):
    def add(self, a, b):
        return a+b
 
daemon=Pyro.core.Daemon()
ns=Pyro.naming.NameServerLocator().getNS()
daemon.useNameServer(ns)
uri=daemon.connect(MathServer(),"mathserver")
daemon.requestLoop()
</code>
</div>
So, basically what we do here is to create a simple Class (MathServer) which enherits from Pyro.core.ObjBase. Next we simply create our methods as for a standard class. Later on we "start" the server, and connects an instance of MathServer to our Pyro server and awaits incoming connections. Lets now consider the Pyro client:
<div class="code">
<code>
#!/usr/bin/env python
import Pyro.core
mathserver = Pyro.core.getProxyForURI("PYRONAME://mathserver")
print mathserver.add(1000, 2500) # will return 3500.
print mathserver.add("hello ", "world") # will return "hello world"

    In our client code we take advantage of the simple name service which is shipped with Pyro. Basically what happens is that we instruct our client to lookup the Pyro name server and then connect to the provided controller named “mathserver” (recall from the server code?).

    One important note is that to be able to use the name server that is shipped with Pyro, it will need to be started. In Ubuntu Gutsy the name server is disabled by default, so changing the value “ENABLED=0″ to 1 in file /etc/default/pyro-nsd, and then “/etc/init.d/pyro-nsd start” will do the trick.

Blogroll:

Meta:

Recent Posts