Life « Not Really a Blog

April 15, 2010

March 24, 2010

Amdocs buys MX Telecom

Filed under: Life — Tags: amdocs, mx telecom, openmarket, work — jroncero @ 09:27

So, the company I work for, wammux, has been bought by Amdocs, the super mega corporation that owns openmarket, in order to merge us with them. The deal has been $104 million in cash !!!

Don’t really know how that’s going to affect us. We shall see.

More information about Amdocs in wikipedia.

Leave a Comment

September 5, 2009

Apple Converted

Filed under: Computers, Life — Tags: apple, macbook, phones — jroncero @ 13:11

Over the last few months I’ve acquired a few items from Apple. Namely and Mac Book Pro 13″, an iPod Touch 2nd gen (which came with the Mac Book Pro and I’m reselling, probably) and an iPhone, with O2.

I’m quite pleased to be honest. It might be that I’m getting older but I’m lately not so apt to be continually fighting configuration issues and stuff with Linux (which I haven’t erased from my life. Use it at work, my servers and my desktop). Anyway, the Mac Book Pro was a no brainer, specially since it’s light, small and powerful (which makes it perfect for me to carry it around) and comes with Leopard (now upgraded to Snow Leopard) which is a very nice operating system (and I still love having good old unix underneath).

The iPhone was more of an issue in terms of decision making. I was considering getting an Android based handset, like the HTC Hero, myself, but after much though, I believe that it’s not ready and mature enough to go for it. So I opted for an iPhone. I’ll wait until next year and see how the market is and decide again (I can always sell my iPhone as there’s always a market for this). So we shall see.

Any suggestions to make the best out of all these Apple goodies?

Leave a Comment

August 14, 2006

Moving to London

Filed under: Life — jroncero @ 02:54

Well, it was time to leave Brighton and move on to something different.

Boredom, lack of internet and sleep has been a constant over the last couple of months. Finally, I found a job in London and moved to it to, well, start something different/new.

Moving all my stuff from Brighton to London has been a bit of a pain in the ass. I had way too many things to move. Including a bike. I had to rent a car and move all my stuff in a heavy loaded car. Nice because it’s been an interesting experience to drive on the left side of the road (England!). It’s easier than it looks. Anyway, Although I’ll miss Brighton a bit, I was a bit tired of being in the same place living in a residence with eighteen-year-olds and the like. What I definitely will miss is the people. Well, some people more than others, but some special people. ¡Así es la vida!

And now, I have permanent internet connection, a house, a new flatmate (who is a good friend) and a new job that would definitely help me not to waste time thinking in girls (lack of), sysadmin (although I will get plenty of that [not the girls ] at my new job) and how to pay the bills.

I’ll talk in a different post about my new employer and what kind of job they do.

Leave a Comment

March 9, 2006

Chord

Filed under: Internet, Programming, Sussex University — Tags: p2p, university — jroncero @ 18:01

As part of another assignment for the Distributed System course at the University of Sussex we have been doing some research on Chord, a distributed hash lookup primitive, and, in the end, implement part of what is called a chord ring in java.

The idea behind Chord is a research paper in which a distributed protocol for adding nodes to the system, insert data into it, retreive it and drop from the system is described. The way in which nodes lookups and inserts are done is O(log n), so it’s quite efficient. Chord could be look as a layer over which p2p-like applications could be built. One example of this is CFS, the Cooperative File System, a distributed read-only file system.

What we had to do is, basically, implement a simple Ring protocol and a Chord protocol:

Ring protocol: Each node in the system has a pointer to the next one in the ring, so, for instance, if any node wants to do a lookup on some data, it would ask the next one in the ring. If such node does not have it, it would forward that question to the next node in the ring and so forth. This would be O(n)
Chord Protocol: In this version of the protocol, each node not only has a pointer to the next node in the ring, but it also has a pointer to a number of other nodes, not necessarily in a row, so when any node wants to do a lookup, depending on a hash function and the list of pointers to other nodes, it would forward the question to a closer node, where the information is more likely to be stored. This is the way we get a O(log n) algorithm. In fact, there is more than this going on, so I recommend you to have a look at the chord paper again if you are interested.

So, all we had to do is implement both protocols in java and run it in a
simulator, as implementing a working solution was too much for an university assignment due in two weeks.

What happens is that using the simulator and programming the whole thing is harder than it sounds, as the simulator itself is lacking some good documentation and have some bugs. In any case, doing it has been fun and interesting as well, as it has let me understand how a distributed system, such as a p2p system, works. So, I recommend anyone interested to have a look at how the protocol works (ie, by reading the Chord paper )

What we had to do is, basically, implement a simple Ring protocol and a Chord protocol:

Ring protocol: Each node in the system has a pointer to the next one in the ring, so, for instance, if any node wants to do a lookup on some data, it would ask the next one in the ring. If such node does not have it, it would forward that question to the next node in the ring and so forth. This would be O(n)
Chord Protocol: In this version of the protocol, each node not only has a pointer to the next node in the ring, but it also has a pointer to a number of other nodes, not necessarily in a row, so when any node wants to do a lookup, depending on a hash function and the list of pointers to other nodes, it would forward the question to a closer node, where the information is more likely to be stored. This is the way we get a O(log n) algorithm. In fact, there is more than this going on, so I recommend you to have a look at the chord paper again if you are interested.

So, all we had to do is implement both protocols in java and run it in a
simulator, as implementing a working solution was too much for an university assignment due in two weeks.

Leave a Comment

February 9, 2006

Depeche Mode and Barcelona

Filed under: Life, Music — Tags: depeche mode — jroncero @ 17:30

Tomorrow I’m heading to Barcelona to see my first Depeche Mode concert of the Playing the Angel tour at Palau Sant Jordi sports arena, built for the 1992 olimpic games.

While I am not finding this last album exciting at all (maybe I am changing musical tastes), I am really excited to go to Barcelona, as it is always a city with a lot to offer. Also, I’m seeing some of my friends as they are comming from Seville to the concert, which is going to be lots of fun. And, they are bringing me some Spanish food I could take back to England (Yeah!!!)
The venue is taking place in the Palau Sant Jordi, which is a very nice place to make gigs as it has pretty good acoustics and a capacity for almost 25000 people.

I’ll be arriving at 17:00 at Barcelona’s El Prat airport on Friday evening if there are no delays and will be back on Sunday evening. So, it’s going to be 48 interesting hours. Hope to get enough sleep.

I’ll be posting photos soon.

Comments (3)

February 5, 2006

FON, google and Skype

Filed under: Internet, Sussex University — Tags: fon, google, skype — jroncero @ 23:34

So, they did it

Fon has just announced it would get 21.5 million dollars from Google, Skype, and Sequoia Capital. Something I already talked about a couple of days ago.

Amazing. Just waiting for comments right now!.

Comments (2)

January 31, 2006

Computer puzzles in job interviews

Filed under: Computers, Life — Tags: interviews, jobs — jroncero @ 20:20

Yesterday, I went to a job interview. I was asked some difficult
problems and ways to solve them. One of them was: We have a list of a
million phone numbers on the standard input and we have a reduced memory
pc which we want to use it to sort them and use to check later if any
number given is in that list or not.

The solution offered was to use an array of bits and use the number as
an index, so if b[1234 ] == 0 would mean that the phone number 1234
wasn’t on the input list and 1 would mean that we had it.

I have been thinking about the solution they provided me.
I’ve been thinking for a while and would
like to extend the rationale behind.
Ok, so, Let’s imagine we have 1 million phone numbers. If we choose to
use the bit array approach, that means that, given the English phone
number system, we have numbers like these:

01273 121212

That is, eleven numbers. I guess, the initial 0 is always present, so we
can omit it right now. So that leaves us 10 numbers to deal with.
Supposing that there are no numbers starting with a 0 (after the initial
0), that leaves us with the possibility of having number in the range:

1000000000 to
9999999999 (=10 000 000 000, 10 thousand million numbers )

So, there can be a total of 10,000,000,000 – 1,000,000,000 numbers, which is
then, 9,000,000,000.

If you want an array of bits to use for storing if certain number is on
the list or not, that means that you need an array of 9,000,000,000
elements, or, 9,000,000,000 bits. That is 1,125,000,000 bytes, or, 1,072Mb
or a little bit more than 1 Gb, right?

Ok, that’s a lot of memory. And, the thing is that you would need to
have all that array even if it was the best case (that in which all the
numbers would be the same, one single number repeated one million
time). So the memory consumption would be fixed.

On the other hand, if we used a n-ary tree to hold all the information
as something like this:

would mean that the number 544 (in a 3-number scheme) would exist.

For example, if we used a C struct like this one:

typedef struct Node Node;
struct Node {
        Node *array[10]; /*  */
	};

In which each position of the array of pointers would represent a number
itself and a pointer to the next one.

    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |    ------    \    |null|
    +----+    +----+\   +----+
    |null|    |null| \  |null|
    +----+    +----+  \ +----+
    |null|    |null|   \ XXX |
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |    \    |null|    |null|
    +----+\   +----+    +----+
           \
            \   +----+    +----+
             \  |null|    |null|
              \ +----+    +----+
               \ null|    |null|
                +----+    +----+
                |null|   / XXX |
                +----+  / +----+
                |null| /  |null|
                +----+/   +----+
                |    /    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |    \    |null|
                +----+\   +----+
                       \
                        \
                         \  +----+
                          \ |null|
                           \+----+
                             XXX |
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+

So that would give us numbers 446 and 912 and 992 in a 3 digit scheme.
We would set up all the pointers to null. If any pointer at any position
is different of null, that means that is a valid number and it points to
the following number (the next array of pointers), so we use the pointer
to both show the number and point to the next structure. The only
exception is for the last node (last digit), that we could make it point
to a invalid address (represented here as XXX).

So, I don’t know if I make myself clear enough, but using this method,
the thing is that in the worst case, we would have 1,000,000
ways to go from the root to the end of each branch, meaning that we
would need 1,000,000 * 10 (the number of digits each phone number has)
nodes to hold all that information. That is 10,000,000 nodes. In this
structure, thats about 40 bytes, which gives us the amount of
400,000,000 bytes, that’s is : 381 Mb approximately, which is 1/3 of the
other approach. But, that’s the worst case scenario. In the average case
scenario, many numbers would be repeated and the total size would be
reduced, actually. And on the best case scenario (one number repeated
one million times) we would only need 10 nodes.

On doing the search, using this n-ary tree, it is O(10) at most if we
need to check the whole number, but as soon we found a null on any
digit’s position, we can stop there, so it would be < O(10) which is a
good number anyway.

the thing is, Am I right, or not?

Ok, so, Let’s imagine we have 1 million phone numbers. If we choose to
use the bit array approach, that means that, given the English phone
number system, we have numbers like these:

01273 121212

1000000000 to
9999999999 (=10 000 000 000, 10 thousand million numbers )

So, there can be a total of 10,000,000,000 – 1,000,000,000 numbers, which is
then, 9,000,000,000.

On the other hand, if we used a n-ary tree to hold all the information
as something like this:

would mean that the number 544 (in a 3-number scheme) would exist.

For example, if we used a C struct like this one:

typedef struct Node Node;
struct Node {
        Node *array[10]; /*  */
    };

In which each position of the array of pointers would represent a number
itself and a pointer to the next one.

    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |    ------    \    |null|
    +----+    +----+\   +----+
    |null|    |null| \  |null|
    +----+    +----+  \ +----+
    |null|    |null|   \ XXX |
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |null|    |null|    |null|
    +----+    +----+    +----+
    |    \    |null|    |null|
    +----+\   +----+    +----+
           \
            \   +----+    +----+
             \  |null|    |null|
              \ +----+    +----+
               \ null|    |null|
                +----+    +----+
                |null|   / XXX |
                +----+  / +----+
                |null| /  |null|
                +----+/   +----+
                |    /    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |null|    |null|
                +----+    +----+
                |    \    |null|
                +----+\   +----+
                       \
                        \
                         \  +----+
                          \ |null|
                           \+----+
                             XXX |
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+
                            |null|
                            +----+

the thing is, Am I right, or not?

Comments (3)

January 29, 2006

About FON

Filed under: Internet, Random, Sussex University — Tags: fon, Internet — jroncero @ 21:00

As part of my studies in my e-business
course at the University of Sussex, I have been asked to write a report of a company that is somehow involved with e-business (e-commerce, use of technology to become more profitable or efficient, etc.).

So, I have decided that I am going to do some research on FON, a company created by Martin Varsavsky who is famous for founding Jazztel and Ya.com, one of the biggest phone companies and ISP in Spain.

FON idea is to profit from creating a network of wireless users around the world, called the p2p of wifi.

My task is, first of all, writing a background briefing report about the company, and afterwards an investment recomendation based on my research and study of the subject.

I chose this company because I have a friend who is working there and because I think it is interesting to see if FON’s business model is profitable or not. By the way, I have no access to internal sources as Teo (hi Teo!!) is quite secretive about it (I think because of NDAs).
Anyway, I’ll post more about it in the near future, I guess. Stay tuned.

Comments (3)

January 28, 2006

On Distributed Computing using RMI

Filed under: Programming, Sussex University — Tags: java, rmi — jroncero @ 17:40

Ok, so I have this assignment in one of my courses at the University of Sussex, Distributed Systems. The thing is that we need to implement a distributed event notification system, in which clients subscribe themselves to the server to which some event generators sends their events.

All of this, using RMI (Remote Method Invocation) in Java.

The assignment is an introduction to distributed objects in java by implementing this little system. In it, each Event Generator, sends events to the server, made of an identification string and a message (in fact, it could be any kind of object).

On the other hand, the server get subscriptions of clients. These send the server a regular expression and a timeout, each of which would be used to choose among the different events received and to set a maximu time in which the subscription is valid. When doing so, the server sets up a callback function to the clients so, when a matching event is received, the server has a way to send the clients the object (event). I think it can be better understood by looking at the graph above.

So far, it’s been quite interesting to learn this kind of distributed framework, although java is not my kind of language. I want to do some more researh on how to do this kind of things with other languages like ruby o r python. Seems to me interesting.

Here is a little bit of the code used, just for curiosity:

public static void main(String[] args) {
	if (System.getSecurityManager() == null) {
	System.setSecurityManager(new RMISecurityManager());
	}
	try {
		EventNotificationServer server = new EventNotificationServerImpl();
		String hostName = InetAddress.getLocalHost().getHostName();
		Naming.rebind("//" + hostName + "/"
				+ EventNotificationServer.rmiName, server);
		System.out.println("EventNotificationServerImpl bound to "
				+ hostName);

	} catch (Exception e) {
		System.err.println("EventNotificationServerImpl exception: "
				+ e.getMessage());
		e.printStackTrace();
	}

}

On the other hand, the server get subscriptions of clients. These send the server a regular expression and a timeout, each of which would be used to choose among the different events received and to set a maximum time in which the subscription is valid. When doing so, the server sets up a callback function to the clients so, when a matching event is received, the server has a way to send the clients the object (event). I think it can be better understood by looking at the graph above.

Here is a little bit of the code used, just for curiosity:

public static void main(String[] args) {
    if (System.getSecurityManager() == null) {
    System.setSecurityManager(new RMISecurityManager());
    }
    try {
        EventNotificationServer server = new EventNotificationServerImpl();
        String hostName = InetAddress.getLocalHost().getHostName();
        Naming.rebind("//" + hostName + "/"
                + EventNotificationServer.rmiName, server);
        System.out.println("EventNotificationServerImpl bound to "
                + hostName);

    } catch (Exception e) {
        System.err.println("EventNotificationServerImpl exception: "
                + e.getMessage());
        e.printStackTrace();
    }
}

Comments (3)