Its interesting to know World Bank has a
blog. Two economists are writing it, and there are some interesting topics covered like the “
Brain drain”. There are some
free books on this topic for download too.
In my opinion outsourcing can help prevent Brain Drain, at least to some extent. The primary reason why skilled workers migrate is because in developing countries their skills are not rewarded adequately. However outsourcing has enabled industry to pay better salaries, for example in India and Sri Lanka the average IT salary has increased considerably.
The secondary reason may be there aren’t enough challenging jobs for skilled workers. For example, if you take a City planner, who plans and builds cities from group up, I don't think there is much he/she can achieve in a developing country and this is why some of the world best city planners from developing countries have migrated and build cities for developed countries.
However as for ICT industry, Open Source can really stop brain drain since anybody looking for a challenge can contribute to Open source Projects and be recognized for their skills all without having to migrate to a developed country. In this perspective
Lanka Software Foundation is doing a great job is containing the brains in Sri Lanka I would say.
posted by 88Pro / Sunday, October 30, 2005
Another effective technique is to explain your code to someone else. This will often cause you to explain the bug to yourself. Sometimes it takes no more than a few sentences, followed by an embarrassed ``Never mind, I see what's wrong. Sorry to bother you.'' This works remarkably well; you can even use non-programmers as listeners.
One university computer center kept a teddy bear near the help desk. Students with mysterious bugs were required to explain them to the bear before they could speak to a human counselor.[
Source]
posted by 88Pro / Thursday, October 27, 2005
A very senior Microsoft developer who moved to Google told me that Google works and thinks at a higher level of abstraction than Microsoft. "
Google uses Bayesian filtering the way Microsoft uses the if statement" he said.[
source]
posted by 88Pro / Wednesday, October 19, 2005
An RSS Reader from Google. You can really see AJAX in action. I don't think I have comes across any web based application which is almost as fast as a desktop equivalent. Check it out. If you are already using a RSS/ATOM reader you could also do an OPML import to Google Reader.
http://www.google.com/reader
posted by 88Pro / Wednesday, October 19, 2005
After reading
Hasith’s blog on the Visitor design pattern, my first impression was, “hay I have done this kind of work?”, but the approach was different. I was responsible for writing modules which received the switch commands from billing system and executed them in the target telecom switch (DMS 100, DMS10, Alcatel, Interwave, Lucent). I opted for a RMI Server/Client based design since I needed a client which would sit in the Billing System network and a server which would be sitting in the telecom switch network (these might be even in two different states).
Client responsibilities were receiving switch commands from the billing system, formatting the switch commands, and passing them to server for execution and once the results are received from the server, interpret the results (success/failure/what kind of failure) and inform the billing system about the status.
The RMI server responsibilities were, receive the command, establish a connection to switch, execute the login sequence, execute the command, read the results, and pass it back to the client.
The common pattern I observed here was, for any given switch
1) establish connection (Serial, Socket, HTTP) and login
2) execute command (performTask())
3) read results
are common operation, but exactly how each of these are done will be different on each type of switch.
I had a Command pattern which had a command interface with above methods.
import java.io.*;
import java.rmi.*;
public interface Command
extends Serializable {
/**
* This method executes the the inbuilt process for that particular
* type of operation on the target Network Eliment.
*
* @return <code>Object</code> depends on the implementation. Most of the
* time it will be a <code>String</code>, <code>Integer</code>
* or <code>StringBuffer</code>
* @exception RemoteException for any exception that can't be handled
*/
public Object performTask() throws RemoteException;
/**
* This method executes the the inbuilt process for that particular
* type of operation on the target Network Eliment.
*
* @param instruction the instruction to be set
* this does not need a return value, needs to be removed in the next version
* @exception RemoteException for any exception that can't be handled
*/
public int setInstruction(String instruction) throws RemoteException;
/**
* This method contains logic to connect to the NE (Network Element) from
* RMI server.
*
* @exception RemoteException for any exception that can't be handled
* when trying to connect to the server.
*/
public int establishConnection() throws RemoteException;
/**
* This method contains logic to relase the already existing connection
* to the NE (Network Element) from RMI server.
*
* @exception RemoteException for any exception that can't be handled
* when trying to connect to the server.
*/
public void releaseConnection() throws RemoteException;
}
So for a given switch, I would first write a command, for example LucentCommand would implement command Interface and will know exactly how to establish a connection, login and execute command to a Lucent Switch.
RMI Client would depending on the switch, create a Command Object (e.g LucentCommand) and will call the setCommand(Command command) method on the RMI Server. Once the RMI Server has the command object, when you invoke any of the methods on the RMI server it simply delegates them to the Command Object.
public class SimpleRMIImpl
extends UnicastRemoteObject
implements SimpleRMIInterface, Command {
//This holds the command set by the setCommand(Command cmd) method
private Command commandHolder;
public SimpleRMIImpl(String name) throws RemoteException {
super();
}
public void setCommand(Command cmd) throws RemoteException{
if (commandHolder !=null)
commandHolder.releaseConnection();
commandHolder = cmd;
}
public Object performTask() throws RemoteException {
//The RMI Server delegating the task to command
return commandHolder.performTask();
}
public int setInstruction(String instruction) throws RemoteException {
return commandHolder.setInstruction(instruction);
}
public int establishConnection() throws RemoteException {
return this.commandHolder.establishConnection();
}
public void releaseConnection() throws RemoteException{
this.commandHolder.releaseConnection();
}
}
This enables that the RMI server and Client need not be changed for every switch implementation. Only we have to write a Command Object for that particular switch. Then the client can set that Command to the server.
When I write this I remember a scene from the film matrix. A scene where Carrie-Anne Moss tells the operator to load the program to fly a helicopter into her brain. You can imagine the RMI server as the Brain the programs being loaded as the command Objects. If you load the LucentCommand the Server knows how to talk to a Lucent Switch, and if you load an Alcatel command, the server knows how to talk to an Alcatel switch, without a single line of code changing on the RMI Server
posted by 88Pro / Sunday, October 16, 2005
