Friendster can't even send email

I’m surprised that Friendster is even still around, but today I got an email from their CEO and it had the entire MIME body in the message. These guys can’t even figure out how to send email.

X-Campaign-ID: 8002
X-Campaign-Type: 1
X-Message-Ref: 19lGRwmaJkSjEf8FZP7XSCijJOJhOejGu832ySW13bA*
Content-Type: multipart/alternative; boundary="----_=_FSter_001_3251309519900466"
MIME-Version: 1.0

This is a MIME email, the first part is the text message.

------_=_FSter_001_3251309519900466
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: 7bit

Friendster www.friendster.com July 2011

A Personal Message from Friendster's CEO

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Dear fellow Friendster members,
As many of you may know, Friendster announced that it is re-launching itself as a social gaming portal and launched a beta version of the new Friendster a couple of weeks ago. The beta version was well received. I am pleased to announce that the new Friendster is going live thereby enabling all our users to login to the new Friendster using your existing Friendster username and password.
Friendster has touched the lives of many. Since MOL, the company I founded acquired Friendster in early last year; many people have come up to me to tell me how Friendster has changed their lives. Many have told me that they have found their life partners over Friendster. Just last week, a successful Internet entrepreneur in Singapore told me that her success was triggered by promoting her business on Friendster. Friendster pioneered social networking and ignited the social media industry that has created billion dollar companies such as Facebook and Twitter, companies that may not have existed in their present form if not for Friendster's early innovation.
Today, Friendster is in a unique position to take advantage on the growth of social gaming. Through its relationship with MOL, which has a 10 year history in working with gaming companies, Friendster has both the experience and track record to make innovations in this space.
Today, as Friendster reinvents itself as a social gaming destination that enables its users to create multiple avatars, play games and enjoy rewards; I hope that all of you will wish us luck and continue to support us in our new reincarnation. The new Friendster is not perfect and we will continue to add new games and features such as localization and rewards over the next few months. Our team is working hard on adding these features and welcomes your suggestions and comments on how we can better serve your needs as a social gaming and entertainment destination.
I would like to take this opportunity to thank all of you for your support and hope that all of you will enjoy the new Friendster as Friendster continues to innovate to serve and entertain you better.
Yours truly,
Ganesh Kumar Bangah
Chief Executive Officer
ceo@friendster.com

****************************************************************
To manage your notification preferences go to: http://www.friendster.com/account/notifications
Copyright 2002-2011 Friendster, Inc. All rights reserved.
****************************************************************

------_=_FSter_001_3251309519900466
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: 7bit

[SNIP - I cut out the HTML so I didn't have to escape everything by hand]

------_=_FSter_001_3251309519900466--

 

An evening with Jason Fried from 37 Signals

I went to the 37 Signals event last night sponsored by CPB. The speaker was Jason Fried, who is a founder of the company, a designer and all around smart guy.

Jason spoke mainly about small business. He presented a list of things that companies can do to become more productive and better at whatever they do. His list included things such as:

  • 4 day work weeks
  • Virtual companies
  • Saying no to your customers more often than not
  • Do the easiest thing possible
  • Don’t design, just do
  • Don’t go to meetings
  • Turn off email and IM

A number of these things I do each day including turning off email and IM when I’m really cranking, be as virtual as possible, reduce lengthy design and just start working. Overall, Jason has great ideas for small companies. 37 Signals is probably in the 3-5 million dollar range or lower, with about 2-3 million dollars of overhead or more. They are a life-style company and will not grow beyond a certain threshold because of these ideals.

Having worked for a large company, worked on vastly more complex systems than Jason, created many open source frameworks and now starting my own company, I found Jason’s ideas exciting and total crap at the same time. I regularly find myself battling with creating solutions that will scale, versus creating the simplest solution. This naturally occurs to anyone who has ever worked with applications that do hundreds of millions of transactions per day (or per hour).

I pushed Jason a bit to see where he would break ranks with some of his ideals. From his responses, he absolutely would not abandon these ideals at any cost. However, I think this is a marketing tool created by 37 signals to promote their products as well as Ruby on Rails. The reason I know this to be true, is that Jason is intelligent and capable or understanding moderately complex problems with more ease than say a college student. In addition, he spoke briefly about how a single feature request such as adding time-stamps to ToDo list items can have a larger impact than any customer might think. These features requests require a large amount of thought and planning because they impact the entire system. Similarly, changes to the Rails internals require a large amount of thought and testing to ensure they don’t break existing applications.

This dichotomy is something that is a fact of life. It is something engineers, product managers and executives must deal with, no matter how small or large your company is. 37 Signals has built a reputation that they can safely ignore these problems and be wildly successful. However, it is 95% smoke and mirrors. The reality is that 37 Signals is composed completely of phenomenal employees who can work in complex domains without losing their minds. The can distill complexity into manageable pieces and then combine those pieces in the end to produce a complex yet functional system.

Restoring a SubVersion repository from an old backup

I have recently gone through the exercise of restoring a medium sized SubVersion repository from an older backup and wanted to share my experience with everyone. First, the problem:

The problem

After you restore the older backup, if any work was performed between the last backup and when the repository crashed, the repository will be “older” than what developers have on their boxes. Here is an example:

  • Let’s say you have a backup from Monday evening
  • The repository crashed sometime Tuesday
  • There was work done during the day Monday

Now, let’s say there is a project A that looks like this:

  • The last change to the project was at revision 100 just before the repository crashed
  • The last change to the project from the backup was 80
  • Frank’s computer contains a checkout of the project at revision 85
  • Mary’s computer contains a checkout of the project at revision 100

This means that both Frank and Mary’s computers contain newer code than the repository, but not the latest code. Mary’s computer contains newer code than the repository, but might not be a complete snapshot of what version 100 was before the repository was corrupt. The reason why Mary’s computer might not be 100% correct is that Mary might have committed files to the repository but not performed a “svn update” prior to committing.

SubVersion is like CVS in that each file contains a version number. So, you might have a local checkout that contains version 100 for one file and 90 of another file. Therefore, you might be missing an updated version of the file from revision 93 when it was checked in.

Okay, now onto the fix:

The fix

Each developer’s computer must be analyzed before anything new is put into the repository. You must have a complete picture of the entire company, otherwise you might miss some changes. These changes can be merged in by hand from each developers machine, but this could be error prone and lengthy process. It is usually better to script out as much as possible.

Step 1

In order to determine the local “revision” of a project on a developers computer, you will need to look at each file in the checkout. You can run an ‘svn stat’ on each file to determine the version number of that file. Write a script to output a file like this for each local checked out project on all developers machines:

src/java/foo.java: 90

The first part is the file and the second part is the revision of that file.

Next, once you have the complete list of revisions for all projects on all developer’s computers in the entire company, you can compare each file with the current revision in the restored repository to determine if the developer has a later version of a file than the repository. This should ignore all files that the developer has modified locally, but not committed.

This comparison will look like this:

Restored repository
src/java/foo.java: 80

Mary's checkout
src/java/foo.java: 90

Mary has a later version of foo.java!

You should script all of these comparisons out. If a developer doesn’t have later revisions than the repository or any locally modified files, they can safely take these steps:

  1. Make a backup of the local checkout
  2. Delete the local checkout
  3. Re-checkout the project
  4. Don’t do anything until the restore is complete

Step 2

The next step is to make a list of the revision that each file in the project was lasted changed on in the restored repository. This report will look like this:

build.xml: 10
src/java/main/foo.java: 16293
src/conf/main/logging.properties: 12093

Next, for each project, collect all of the revision reports from the previous step into a single location. These reports look like this:

frank-project-a-report.txt
build.xml: 10
src/java/main/foo.java: 16301
src/conf/main/logging.properties: 16405
mary-project-a-report.txt
build.xml: 10
src/java/main/foo.java: 16410
src/conf/main/logging.properties: 16321

Combine each of the developer reports into a global report that gives you the revision number for each file on every developers computer. Next, use this global developer report to determine whose computer contains the latest version for each file in the project. Based on the examples above, you can see that build.xml didn’t change recently enough to matter since the version in the repository is the same as the version on Frank’s and Mary’s computers. However, Frank made the most recent commit in revision 16405 to logging.properties and Mary made the most recent commit in revision 16410 to foo.java. Both of these files are more current that the repository and therefore need to be re-committed.

Step 3

Finally, setup a staging area that contains a copy of every checked out project from every developers computer who has a later revision than the repository (from step 1). This will be pretty large, but necessary. Based on the results from step 2, copy the latest version of each file over to a clean checkout of the project from the restored repository. Once you have all of the changes copied over for a single project, commit all of those files for that project back to TRUNK.

You should now have a fully restored repository based on the files from various developers computers.

Open source operating system quest

While waiting to see if my X300 sells on Craig’s list and before I eBay it, I figured I would go back to my roots and install a bunch of operating systems on the machine. It is very new hardware and I wanted to see what else is out there. For those who don’t know or haven’t ever read my white-paper, I wrote a fairly lengthy paper around 2000 that outlined how to build an open source operating system that was geared 100% towards desktop and laptop users. It covered mainly changes to Linux, but could be easily abstracted out to any operating system. It had things like:

  • Drop LHS (linux file system standard) in favor of a more friendly naming convention like /config, /system (or operating-system), /users, /applications, /libraries, etc.
  • Drop X-Windows in favor of OpenGL foundation with no networking and everything vector based where possible
  • Standard system APIs for everything, including graphics. No more Gnome vs. KDE vs. whatever
  • Better file permissions
  • Better login
  • Remove TTYs
  • Remove termcap and all that jazz
  • Assume latest modern hardware everywhere, even shell/terminals
  • Fix run-levels and services
  • Standard hardware abstraction
  • Better packaging (no more littering files everywhere)

It had a bunch of other stuff, but you get the drift. Some of this stuff has actually happened in the last decade or so. However, a lot of it hasn’t quite gotten there and Linux has suffered from more and more server syndrome that it probably will always be rough around the edges for desktops and laptops.

Anyways, back to the main point… I downloaded and installed a bunch of different operating systems and here’s what I found.

Linux (Ubuntu, Fedora, OpenSuse, etc)

Same old story. ACPI is rough, the CPU is a hog, the battery life is short, 3D desktop doesn’t quite work, missing drivers, bloated, etc, etc. Definitely a thumbs down on my scale, even though I am currently running Ubuntu on all my machines and love Linux to death, it still sucks for desktop and laptop compared to other OS’s.

OpenSolaris

Sorry to say that this is just like Linux with a different kernel and some minor tweaks here and there. It still runs X-Windows, Gnome and all the other Linux upper layers. Plus, it has worse driver support and very little modern desktop and laptop necessary support such as ACPI, CPU scaling, low voltage, etc. Definitely a thumbs down for now. We’ll see what Sun does. If they are smart, which they don’t appear to be yet, they would drop all the upper layers and build something better and new. They would also drop all the file system standard crap and just start fresh. They have the man power and the money to do it, just not the vision or the drive it seems.

Syllable

This is a very promising OS. They have a lot of the key components, but they have also been using Linux and Unix too long to deviate drastically enough to make it truly usable for the average Laptop and Desktop user. However, it still isn’t 1.0 and they might update some of these things. I never actually got it running, but from what I’ve seen on their website, they have the right idea. If I had some advice for all the developers and users of this OS it would be: hang a sign that says, “can my grandmother use this OS?” on your wall next to your computer and if that answer is ever “no”, fix things until it is “yes”. If I had a million bucks or so laying around, I’d definitely put my money on this project.

Hackitosh

Yeah, just wanted to see if I could get it running and the answer is no. Apple definitely has a great OS. Although some things are still lacking, it is probably the best out there right now. However, it runs best on Apple hardware and I’m not about to fight that. I’m planning on a 100% switch to Mac OSX here soon.

There are a few others that I didn’t get to like Haiku, but they seemed quite new as well and probably wouldn’t have worked all that well. Another thing that was lacking from most of the newest OS variants out there was 64bit support.

Google Code could be EXTREMELY dangerous

I host a number of projects including JCatapult over at Google code. We use the wiki over there for our documentation because it is simple and centralized. The wiki is stored inside the SubVersion repository and when you update the wiki it performs a commit to the repository. Pretty straight-forward.

One of the project members, James Humphrey, was editing our wiki last night, finished editing a page and hit Save. Rather than just updating the wiki page in SubVersion, Google’s custom built SubVersion server decided it wanted to completely revert our entire project back to revision 1. Yeah, I’m totally serious!

Well, the old revisions appear to be in the repository, but in order to clean this clandestine (hehe) mess up I’ll have go in by hand and revert our entire repository. This consists of roughly 10 sub-projects and 5 tags for each project plus branches, etc, etc. Really nasty.

So, here is my warning to all those out there that might be using Google Code, be careful. I’m working with Google right now on trying to figure out what happened and how to fix it. I’ll update this post once we figure it out.

Do we really need code reloading?

With Grails, Rails, Python, etc offering developers the chance to change code, hit refresh and see the changes I often wonder if reload truly a feature that is a must have these days? It seems like it is one of the main selling point by most of the folks pushing those frameworks.

I think this is not a requirement, and doesn’t really increase productivity. Here’s why:

  • This promotes less tested code as you can code an entire app without testing at all by simply hitting refresh
  • The testing cycle is lengthy by nature, so you do any testing during development, it is going to take some time
  • Rather than using reload, if you use the development cycle of write, test, run or test, write, run, than starting up the application incurs minimal overhead in addition to running the tests
  • So, what are we really trying to accomplish while developing? Better code, less code, better tests, faster development. These things seem to imply great conventions and excellent extensibility and not reloading.

Comment spam is too much

First, I want to apologize to all those who have put good comments up on this blog and I haven’t approved them for days or weeks. I just don’t have the time to be checking all the comments I get.

Second, I’m certain that I have deleted good comments and for that I apologize.

Lastly, I’m planning on fixing this ASAP. I’ll either be moving to so other blog system like Google or implementing some more spam controls here. I haven’t decided which, but I would love to hear your ideas and suggestions. So, add comments to this entry with your ideas and suggestions and I’ll be sure to approve them all as quickly as possible.

The sky is falling

Having just finished a conversation with a co-worker, I’ve started noticing that software engineers tend to exaggerate situations quite a bit. I’ve done it. If you are a software engineer, I’m sure you’ve done it. It goes something like this:

“That thing was so messed up I had to rewrite the entire thing.”

“That library is lacking so many features its gonna take weeks to finish it.”

“I spent hours tracking down an enormous bug in you code.”

Usually, reality is really something like this:

“I had to refactor a class or two to add my feature. It took a while to learn the code, but only a little while to code it.”

“If we add 3-5 more things, that library will be much more useful, but they are just nice to have.”

“I spent an hour or so learning your code because I had to fix a bug. Next time I’m sure it won’t take as long since I know the code much better now.”

More often than not, the solution is relatively simple and when it isn’t, I’ve found more often than not, the solution is being over-engineered. It seems to me that this is a systemic problem that occurs in software engineering because of a number of reasons:

  • Engineers get frustrated and lose sight of the larger picture
  • Engineering is tough and requires a lot of brain power and sometimes engineers run out of steam
  • If you didn’t write it, you don’t want to touch it
  • Jealousy
  • Ego

My solution, try to reason with the offending engineer and after two shots, give up. It’s not worth the aggravation and usually you’ll have to do the work in the end anyways, so just save your energy for doing the work.