A Typical Call Center in the Philippines

WOW. After watching this video/documentary, I can definitely say that the state of outsourcing here in the Philippines is SO MUCH better compared to India.

What happens when a successful US-based computer programmer, who lost his lucrative job to outsourcing, travels to India to try to get it back?

Will he discover the secret of India’s success, or that sending jobs overseas is an unstable gamble?

The videos below share his incredible experience. It’s a fascinating and humanizing portrait of real Indians in Bangalore, the “Silicon Valley of India”.

This inside look shows how ridiculous it is to throw around terms like “slave labor” and “stealing jobs” without understanding the realities of this unusual world where best jobs start at 6pm and end at 3am…

Three suggestions:

1. Keep in mind which jobs are displacing foreign workers and which are not.
2. Notice the level of complaining among Indian workers. It’s almost non-existent.
3. Give the videos a minute to load. Patience, young Jedi.

This is hard-to-find coverage that will change how you think about “your” job. Highly recommended.

Watch the documentary here!

My "Newspaper Article"

…. CRAP?

I was fooled by this “aXXo is dead” post from Digg. I really thought the great aXXo is dead. But as it turns out, the newspaper article is fake!

The newspaper “image” was created using this Newspaper Generator. Have fun!

Hackers & Painters by Paul Graham

While reading Hackers and Painters by Paul Graham, I stumbled upon his essay entitled “The Hundred-Year Language” which reminded me about my essay of the same title. I wrote this essay as an assignment for our Compiler Class back in College.

A Hundred Year Old Language

For almost one hundred years, humans have been writing computer programs. They had written it on almost all possible forms – from object code to a fifth-generation source code.

Object code, as we know it, is a collection of commands written as a binary string that can only be efficiently understood by a microprocessor. The first twenty years of computer programming history was written using object code – without it, computer science will never have existed. Throughout those fateful twenty years, early programmers have learned that writing object code is nasty, erroneous and time-consuming. There must be a better way to write computer programs, there should be a better way.

The solution came in the 1950’s in the form of an assembler. The assembler allowed the programmers to directly interact and instruct the computer via mnemonics – a microprocessor language. For the first time in computer history, humans are no longer bounded by ones and zeros – they are now able to write computer programs more intelligently. The assembler served as a catalyst for change because it allowed computer programs to be commercially feasible. For almost a decade, assemblers served their purpose; but the programmers soon realized that assemblers produced machine dependent application. Furthermore, optimization of an assembly code took more time than the actual development of the application. Simply put, majority of the programmers work are in the actual “writing” of the code and not in the actual “development” of the application. With that, the programmers needed an automated way to write their application – hence, the compiler was born.

Compiler revolutionized the way programmers write computer application. From that very crucial time in computer history, humans can now write computer application using their own natural language – thus, programming languages were born. With that, programmers can now develop application efficiently and effectively. Debuggers are also present to debug their application in an organized manner – hence increasing the quality of application produced. From then on, compilers have undergone major changes. Interpreters were added to allow the produced application to run on different processors via virtual machines. Profilers were added to optimize the source automatically on compile-time. Compilers fueled the Information Technology era because it allowed the programmer to write more complicated and complex codes without actually worrying on how the computer will execute it.

Today, compilers can be found hidden and embedded inside powerful IDEs. So the next time you press the F5 button to compile your program, think of the people that made the compiler. Because those people allowed us to convert our language to computer instructions, magically.

But if you happen to be part of the new “Knowledge Worker” workforce, you are probably working somewhere in Makati, Ortigas or Taguig. Day in and Day out, all I  see are these huge office buildings and sometimes, it makes me forget that we were once a Third World Country. Try it, go to The Fort Global City.

Makati Skyline at Night by "Rawrage"

Oh, just some random ramblings. Anyway, there will be no article about Software Development this week as I will be attending a 3-day seminar about Leadership in Tagaytay hosted by Accenture.

Top 1 result in Google!

I have not really believed in those “free” SEO optimization tools. But it works! In fact, I just bought the domain 2 weeks ago and upped this blog just a couple of days ago and Google is already crawling my site.

I checked my SiteMeter stats just now and saw three incoming referrals from Google with search terms like:

• Accenture Student Leadership Conference 2009
• accenture slc 2009 friendster
• Cristopher Ian Uy (Probably my search)

Also, there is a referral for “Top Salary” from Topblogs.ph and another referral from http://accenture.cymfony.com (Accenture’s outsourced email server?). Maybe someone inside Accenture saw my blog post about leadership that also talks about SLC 2009.

I just have a little problem with how Google indexes my site. If you try to Google “site:ianuy.com”, you will see that Google only indexed http://blog.ianuy.com and not the individual posts. I don’t know why Google is doing this but I hope its a temporary thing since Google’s crawler is still crawling my entire site.

The site is doing fine in terms of hits. Got 70 uniques today.

The training is about Windows Communication Framework or WCF — Microsoft’s answer to building Service-Oriented Architectures (SOA). Gone were the days of Web Services, more so, socket programming! It’s all abstracted now. Yay for lame programmers!

But anyway, the training was GREAT! I was able to learn the ins and outs of WCF. But what’s interesting is that I learned a new “way” to do rollbacks automatically! It’s called…

TRANSACTIONS!

But what’s more interesting is that Transactions is not really part of the WCF nor the.NET 3.5. It’s an existing feature from .NET 1.1! )So what’s Transactions? Well, its really hard to explain so I’ll just present a scenario on how and where you can use Transactions.

Let’s say that you have a Point of Sales (POS) system that have 2 tables namely Inventory table and Sales table. And you have a method called CustomerBuysStuff(int ItemID). The said method will be called if a customer buys new stuff (obviously)… so the implementation would be something like:

1. Deduct 1 unit from the Inventory table using the ItemID
2. Add 1 unit from the Sales table using the ItemID

This means that this particular method must execute two (2) SQL statements and both of them must SUCCEED or you will have a decrepancy on your data. If you can remember from your Database Management Course, you have studied a concept called ACID. This scenerio represents the A in ACID — Atomic Operations. In our case, this means that “All statements in a group must execute, or no statement in a group must execute. “

Frequently in a database application you come across a situation where you need to execute two or more SQL commands in such a way that if any one of the statements fails, then no other statement will be able to change the database.

I’ll try to demonstrate Transactions using REAL code (Click the image to enlarge):

Let’s call the code snippet as “No Rollback”. This assumes that you are 101% sure that both operation will succeed that you did not even bother to write a rollback method if ever one of the two fails. This is a very bad practice in the real world because it will create a discrepancy in your data that cannot be traced — and worst, debugged.

The above code snippet is called “With Rollback”, because in this code snippet, when the second command fails, you cared enough to rollback the changes made by the first command. This is how I did it in the college days when I’m too lazy to use Stored Procedures (and TRANS/COMMIT) and I’m too stupid to not have researched about Transactions! Oh the dark ages. Mind you, this method is not 100% fool-proof. What will happen if your rollback command also failed? Discrepancy!

Now, let’s call this code snippet “Almighty Transaction”. In the above code, there is no extra method or SQL command to invoke to do the rollback when the pre-requisite part of your code fails. And oh, there’s also no extra code to detect an exception or an error. It just magically knows that something awful had happened and it will just magically rollback ALL the changes that happened before the error. Like, MAGICALLY! Isn’t it freakin great?!

Also, this will work on ANYTHING (Not only on Database Related Stuffs). During my thesis days, I have to write a method to perform rollbacks when my encryption/decyption algorithm fails. It took me a whole week and lots of messy code to make it work perfectly. If only I have the knowledge of Transactions then, it could have just taken me 5 minutes. DAMN!
So yeah… I love these TRAININGS (Have 6 more to go for this year)! You can learn lots of useful stuffs in a very short span of time (Like 3 days). They will even give you a certificate that is signed by Billy-G himself! Haha! Another additional line in my Resume.

What’s great about the training company that my company chose is that they are official Microsoft Partners… This means that I can take the official WCF Online Test and if I pass, I will then be a “Certified” MCP (Microsoft Certified Professional)!

Remember…

TransactionScope AtomicScope = new TransactionScope()
using(AtomicScope)
{
//ATOMIC OPERATIONS
AtomicScope.Complete();
}