Amazon’s shares jumped by more than 9% following Citigroup analysts Mark Mahaney predicting its Kindle to become the “iPod of books”:

In a report to clients, analyst Mark Mahaney said Amazon could be on track to sell as many as 380,000 units of the Kindle this year. This would match the number of sales for the iPod digital music player in its first year on the market, leading the analyst to predict that the Kindle “is becoming the iPod of the book world.”

Mahaney predicted that the Kindle will likely top the lists of holiday “gadget gifts” this year. He warned that his projections do not account for a possible launch of an updated version of the device.

Personally, I want one! I just can’t wait for Amazon to release a Wifi version that’ll work world wide and will save me delivery costs and time when ordering my books.

I’m exactly the kind of person the Kindle appeals to - a techie who reads lots of books (mostly tech too) via Amazon.
I don’t think its a very large niche…  at least, not as large as the iPod’s target market…

I find it ridiculous comparing Kindle success to the iPod simply because of one people fact: People don’t read anymore!

Apparently, I’m not the only one holding this opinion:

Today he had a wide range of observations on the industry, including the Amazon Kindle book reader, which he said would go nowhere largely because Americans have stopped reading.

“It doesn’t matter how good or bad the product is, the fact is that people don’t read anymore,” he said. “Forty percent of the people in the U.S. read one book or less last year. The whole conception is flawed at the top because people don’t read anymore.”

By the way, the US is ranked 18 in literacy rate…  Just a fact worth mentioning…

Tags: Amazon, AMZN

Designing for scale is one of the greatest challenges when building when building web applications for the Internet. The huge scale of the Internet and the amount of potentials users requires applications to be able to handle huge amounts of data and traffic.

Today’s Internet applications has to be design with large scale in mind:

• It has to be able to accommodate increased usage
• It has to be able to accommodate increased data volumes.
• It has to be maintainable

While the need seems obvious, implementing a working solution seems is not trivial, and so we see a lot of new companies that fail to handle the load (Cuil, Twitter, ….)

Joining Nuconomy’s ranks recently has opened me to the world of web scalability. And so, I’ve had to do quite a lot of reading the past couple of weeks.

I’ve compiled a list of the best resources I came across:

• The following presentation by Cal Henderson provides a detailed overview of common patterns and approaches when building application for high availability and scale (you might also want to check out his book his book) :

• The High Scalability blog features lots of interesting content on the topic.
  Be sure to check its featured overviews over the technology behind the top Web 2.0 sites:
  • Amazon
  • Google
  • YouTube
  • MySpace
  • Twitter
• Another series of posts worth a reading is Tim O’Reilly series on Web 2.0 and Databases covering the data strategy of major Web 2.0 companies: 
  • Google File System and BigTable
  • Flickr
  • MySQL
  • Second Life
  • Findory and Amazon
  • Craigslist
  • Blogline and Memeorandum
  • NASA World Wind
  • O’Reilly Research
• Google’s Paxos implementation. The Paxos algorithms is a set of protocols used for developing fault tolerant distributed databases. Google’s Paxos Made Live – An Engineering Perspective (1052) is a very well written and easy to read paper, written by Google’s engineers, describing their experience implementing Paxos in the creation of Chubby, a system used by BigTable for keeping replicas consistent in case of failures:

We describe our experience building a fault-tolerant data-base using the Paxos consensus algorithm.
Despite the existing literature in the field, building such a database proved to be non-trivial. We describe
selected algorithmic and engineering problems encountered, and the solutions we found for them. Our
measurements indicate that we have built a competitive system.

…

We used the Paxos algorithm (“Paxos”) as the base for a framework that implements a fault-tolerant
log. We then relied on that framework to build a fault-tolerant database. Despite the existing literature on
the subject, building a production system turned out to be a non-trivial task for a variety of reasons:
While Paxos can be described with a page of pseudo-code, our complete implementation contains several
thousand lines of C++ code. The blow-up is not due simply to the fact that we used C++ instead
of pseudo notation, nor because our code style may have been verbose. Converting the algorithm into
a practical, production-ready system involved implementing many features and optimizations – some
published in the literature and some not.

Got some more interesting scalability resources to share?  feel free to leave a comment…

Tags: Scalability, Web 2.0

I’ve been having mixed feeling for quite some time now regarding LINQ.
Sure it can make working with data sources a lot easier and it can definately save a lot of code…
But, what happens with the following C# foreach statement

List<KeyValuePair<string, string>> resultList = new List<KeyValuePair<string, string>>();
string[] paramsArray = parameters.Split(new char[] { '&' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string p in paramsArray)
{
    int index = p.IndexOf('=');
    if (index > 0)
    {
        string key = p.Substring(0, index);
        string value = p.Substring(index + 1);
        resultList.Add(new KeyValuePair<string, string>(key, value));
    }
}

IEnumerable<KeyValuePair<string, string>> result =
    resultList.Distinct((p1, p2) => p1.Key == p2.Key);

Turns to this query:

var distinctPairs = (from keyValuePair in parameters.Split(new char[] { '&' }, StringSplitOptions.RemoveEmptyEntries)
                     let index = keyValuePair.IndexOf('=')
                     where index != -1
                     let key = keyValuePair.Substring(0, index)
                     where !string.IsNullOrEmpty(key)
                     let valueText = keyValuePair.Substring(index + 1)
                     select new { Key = key, ValueText = valueText })
                             .Distinct( (p1, p2) => (p1.Key == p2.Key) )
                             .ToArray();

I don’t know about you but I find the first version a lot more approachable, readable and quicker to understand. The same code in LINQ is not shorter and looks simply looks Evil.

LINQ is like the force… It can be used to wonderful code that is simple and functional, but it also has the potential of producing cryptic code that’s hard to maintain.

Use it wisely and don’t be tempted for its dark side…

Tags: LINQ

I’ve recently decided to move my blog from dasBlog to WordPress. The reason for this move is mainly because dasBlog really lacked several features that were important for me and I found WordPress to be much more mature platform with a wide community support.

Moving the blog to WordPress turns out to be not as complex as I thought it would. However there are some pitfalls that are important to avoid in order for the process to really be as quick and simple as possible.

When moving our blog we have two main tasks: migrate all the blog’s data (post’s etc.) and ensure that the old blog redirects all calls to the new blog so that we don’t loose search engine links\ranking and confuse readers.

Migrating Blog Data

WordPress does not support importing from dasBlog out of the box and there’s no available plugin that does that. The best way I could find to migrate the data to WordPress is to use RSS import. The only downside here is that comments will not get imported

In order to migrate dasBlog posts to WordPress using RSS perform the following:

1. Setup dasBlog’s RSS to contain all your data. On dasBlog’s configurations page, under Syndication Settings, increase the number of items in your RSS feed to cover all posts.
   

   Also, turn off FeedBurner support so that when trying to access dasBlog’s RSS feed it will not redirect you to FeedBurner.

2. Disable Aggregator Bugging. dasBlog can add an image to your RSS item that is used to gather feed usage statistics. You don’t want those images to be part of your WordPress posts.
   To disable feed bugging simply go to the dasBlog configuration screen and uncheck the Enable Webbugs for RSS checkbox in the Service Settings section:
    
3. Save the RSS as a file. Load the RSS into your browser by clicking on the RSS icon on your blog’s home page or by navigating to http://<blog url>/SyndicationService.asmx/GetRss.
   Save the displayed XML to a text file on your local drive.
4. Fix content formatting in the RSS. You have to remove end-of-line characters from the file, otherwise they will be transformed by WordPress during import to line breaks that will mess up your posts layout:
   1. Open the file in Microsoft Word, press CTRL+H to open the Find and Replace dialog.
      Click on More->Special Characters->Paragraph Character. Replace it with nothing (an empty string).
   2. Replace all double spaces with one space character.
5. Import the file to WordPress. In the WordPress Admin Dashboard go to Manage->Import (or navigate directly to http://<blog url>/wp-admin/import.php). Click the RSS link and browse for the RSS file you just edited. Click Upload file and import button to import your content to WordPress.

Redirect Requests from dasBlog to WordPress

If you’ve been using your blog post title for your post’s permalink than you’re going to have a relatively easy job redirecting all the requests made directly to a post on your dasBlog blog to their new location on WordPress (some coding is required though). Handling the other pages - archive, date and category pages - is a bit more complicated.

First, configure WordPress’s permalinks to use the post’s title like dasBlog. In the WordPress Admin Dashboard go to Settings->Permalinks and choose the Day and name option so that your permalinks will look as follows : http:// <blog domain> /2008/08/04/sample-post/

Now we have to redirect the requests from the old blog to WordPress. I couldn’t find a way to perform this without editing dasBlog’s source code. To be honest, I’ve been running my own customized version of dasBlog for a while now so I’ve had the code ready for use and I didn’t invest much time in looking for alternatives.
In the newtelligence.DasBlog.Web.Core project, open SharedBasePage.cs and add the following code snippet at the end of the SetupPage method:

// *** Redirect to WordPress
string redirectUrl = "http://<blog homepage>.com/";
if (!this.IsAggregatedView)
{
    // We're looking at an indevidual post so we can redirect directly to
    // that post's new location
    Entry entry = DataService.GetEntry(weblogEntryId);

    redirectUrl = string.Format("http://<your blog>/{0}/{1}/{2}/{3}/",
        entry.CreatedUtc.Year,
        entry.CreatedUtc.Month,
        entry.CreatedUtc.Day,
        entry.CompressedTitleUnique.Replace('+', '-'));
}
else
{
    if (Request.QueryString["category"] != null)
    {
        // We're in a category page
        redirectUrl = string.Format("http://<your blog>/redirectFromDasBlog/category/{0}", this.CategoryName);
    }
    if (Request.QueryString["date"] != null)
    {
        redirectUrl = string.Format("http://<your blog>/{0}/{1}/{2}/",
            DayUtc.Year.ToString(),
            DayUtc.Month.ToString("d2"),
            DayUtc.Day.ToString("d2"));
    }
    else if (Request.QueryString["month"] != null)
    {
        redirectUrl = string.Format("http://<your blog>/{0}/{1}/",
            Month.Year.ToString(),
            Month.Month.ToString("d2"));
    }
}
this.Response.StatusCode = 301;
this.Response.Status = "301 Moved Permanently";
this.Response.RedirectLocation = redirectUrl;
this.Response.End();

Compile dasBlog and then replace newtelligence.DasBlog.Web.Core on your dasBlog’s bin folder with the modified version.

The snippets redirects requests to blog posts and archive pages (day pages and month pages) to their new destination on WordPress using permanent redirect status code (301).
Category pages cannot be handles automatically as, when moving to WordPress, you will probably play around with the category hierarchies, names and slug.
Therefore, the code builds a category URL that points to the WordPress blog and guaranteed to get a 404 error. We can track 404 hits on WordPress and manually configure where to direct them…

Track and redirect 404 requests on WordPress. A WordPress plugin, called Redirection, allows you to track 404 errors and manage their permanent (301) redirections:

Redirection is a WordPress plugin to manage 301 redirections, keep track of 404 errors, and generally tidy up any loose ends your site may have. This is particularly useful if you are migrating pages from an old website, or are changing the directory of your WordPress installation.

Install the plugin and then you can go to Manage->Redirection on the WordPress Admin Dashboard and manage redirections from the fake URLs created by the code we added to dasBlog to real destinations on your new WordPress blog.

That’s it! If you’ve reached this far you’re covered…
All the posts have moved to their new WordPress location and all links are correctly forworded to the new location. As mentioned earlier, unfortunately, the only thing left out are the blog comments.
If you know of a way to get the comments migrated to WordPress too please do tell…

Tags: dasBlog, WordPress

At least if everything goes as planned, your RSS reader should keep on getting regular updates without any work on your part (thanks FeedBurner :-))

I just retired the good old dasBlog on ekampf.com for a branch new WordPress 2.6 blog on www.DeveloperZen.com.
The ekampf.com is still up and running, forwarding all traffic to the new blog (even old blog permalinks are redirected to the correct post under DeveloperZen.com) so you can still use it if you’ve got existing bookmarks, subscriptions, or if just feel it’s easier to remember.

The move to DeveloperZen.com brings along a brand new design (still in the works) and a renewed commitment to blogging - I’ll be working a lot harder on the DeveloperZen brand from now on.

Please let me know if you have any problems moving over subscriptions, finding stuff or getting old links to work. I’ll also be happy to heard comments or suggestions regarding the new site.

MyBlogLog unveiled their new design yesterday:

Don’t worry, we still got all the features that you can’t live without; your stats, your widgets and, of course, the New With stuff. Only now everything is framed with shiny shadows and rounded edges! Also notice that on your profile we have moved the most recent visitors module, up on top, not down below the fold so you can quickly see who’s been checking you out.

If you’re a DeveloperZen reader and part of the MyBlogLog community (or just have a Yahoo ID), please join the DeveloperZen community on MyBlogLog.

Tags: MyBlogLog

According to various reports from Reuters and Rediff.com, nine bomb blasts have rattled Bangalore, which hosts offices of some of the technology industry’s biggest players- Texas Instruments, Intel, Qualcomm, Infosys, SAP…

Low intensity blasts in a span of one hour in six different places rocked the IT capital of India on Friday afternoon in which two people died and several others were injured. While the first seven blasts took place between 1.30-2.30 pm, the eighth blast took place at Hosaguddahalli, near Gopalan Mall, on Mysore road at around 5.30 pm and the ninth blast took place near the R V Engineering College on Mysore Road at 6.30 pm. The Bengaluru police have termed it as an act of terror.

Om Malik notes that these attacks are likely to reverberate through Silicon Valley. Beefed up security procedures will probably follow and companies with operations offshore will probably have to review their business continuity plans. It will probably also accelerate diversification away from the city…

In any case, I do hope all of my colleagues, people I have dealt with and reader over there are fine.
I would love to hear updates from anyone reading this post…

Tags: Globalization, India

Consider the following (imaginary) conversation:

Programmer: What if a user will want the ability to sort the values in the report grid by columns?

Manager: We don’t need a dynamic grid for version one.

Programmer: But someone might want to sort the values! Users will expect to be able to sort values by clicking on the column headers…

Manager: We don’t have time to add this feature to our schedule. Can’t we consider it for a future release?

Programmer #2: I don’t think sorting makes sense here.

….

Sounds familiar? If you’ve been part of a product development team you’ve probably encountered this kind of feature debate before… maybe even quite frequently…

Programmers are trained to think about possibilities and logic terms, that’s why the logic of what “might” happened is irresistible to the programmer.
Alan Cooper describes this behavior in The Inmates are Running the Asylum:

Programmers call these one-in-a-million possibilities edge cases. Although these oddball situations are unlikely to occur, the program will whenever they do if preparations are not made.
Although the likelihood of edge cases is small, the cost for lack of preparedness is immense. Therefore, these remote possibilities are very real to the programmer. The fact that an edge case will crop only once every 79 years of daily use is no consolation to the programmer. What id this one time is tomorrow?

The manager can’t advance the argument with the force of reason as he has no way to logically contradict this programmer and so he’s left with the choice of giving up or using his authority, which is usually how these kinds of arguments end up.

The programmers concern with the possible can easily obscure the probable by loading the program’s interface with controls and functions that will rarely be used.

The problem with this entire argument lies in the fact that arguing about what users might expect is the same as asking “What does Bigfoot like for breakfast?”

Users come in many forms and shapes. Some are proficient with computers, some don’t even like them. Some are used to Microsoft UI and some work mainly on the Mac. Some require advanced control with the expense of simplicity and should would rather give advanced control away in exchange for a quick and simple way to perform their goals.

In order to avoid this kind of dead-end feature debates its useful to change the team terminology and work in terms of personas and their goals. Rather than thinking of users as an abstract, difficult-to-describe, amorphous group of people, personas instruct us to talk about specific users who have names, personalities, needs, and goals.
Understanding exactly who the users are and what they do with the software is essential to determine if a certain feature is actually required.

Do we really need to allow sorting the column? there’s no way of telling…  but if you know that we’re designing for Jeff, a CFO of a large enterprise, who would like to get his report in a fixed predetermined format then its probably a requirement not to do so…

A very good example for use of personas can be found in Nikhil Kothari’s post about where he describes three personas that were used by the development division at Microsoft while working on Visual Studio 2005:

We have three primary personas across the developer division: Mort, Elvis and Einstein.

Mort, the opportunistic developer, likes to create quick-working solutions for immediate problems and focuses on productivity and learn as needed.
Elvis, the pragmatic programmer, likes to create long-lasting solutions addressing the problem domain, and learn while working on the solution.
Einstein, the paranoid programmer, likes to create the most efficient solution to a given problem, and typically learn in advance before working on the solution.

The description above is only rough summarization of several characteristics collected and documented by our usability folks.
During the meeting a program manager on our team applied these personas in the context of server controls rather well:

• Mort would be a developer most comfortable and satisfied if the control could be used as-is and it just worked.
• Elvis would like to able to customize the control to get the desired behavior through properties and code, or be willing to wire up multiple controls together.
• Einstein would love to be able to deeply understand the control implementation, and want to be able to extend it to give it different behavior, or go so far as to re-implement it.

Using the above described personas, Nikhil’s team was able to effectively design a set of .NET controls so that each persona will find them usable for his use:

All of these controls just work out of the box in implementing the end-to-end scenario of managing user sign-on. Coupled with themes, these controls can look pretty good as well. They go on to provide a whole set of properties to tweak their behavior, and appearance.

Furthermore, they provide the ability to flip into template mode for more significant changes to their content and layout.

Finally, they’re built on the provider-model in ASP.NET so an advanced developer could come along and swap out the built-in membership provider going against say the default SQL or Active Directory user database and replace it with one that goes against say an Oracle user database or some other custom store while keeping the UI functionality intact.

So, the next time you’re in a feature debate, stop and ask yourself “Who exactly am I designing this feature for? Why does he need it?”.
Describe a set of personas that your software will target and use them as reference in any design discussion or feature debate instead of referring to an amorphous group of “users” that might not even exist.

Don’t design your software for bigfoot….

Tags: Design, Personas, User Experience, UX

I was checking out my analytics page with Yosi the other day when I noticed this rather disturbing Unique Visitors graph:

I’ve been paying less attention to the blog the past couple of months and it shows… I’m loosing readership and I don’t like it…

As I see it, the most important rule for blogging successfully is to continuously produce great content for your blog. As Larry O’Brian best puts it:

My theory is that lead generation derives from Google rank and that the best way to increase Google rank is to be like a professional fighter: neither jabs nor haymakers are enough. You must be always jabbing and you must regularly throw haymakers. Blog continuously to keep your hit-rate and link-traffic high and write longer pieces, containing the high-value words associated with your niche, occasionally.

I’ve been pilling up more than 15 posts on my drafts folder so it doesn’t seem like I have nothing to write about. Getting these drafts to a state where I’m willing to post them online is a different story…

As I’ve learned for the past couple of years, the best thing you can do when writing a blog is to pick a schedule you can live with and stick to it.

And so, I’m going to pick a two-posts-a-week schedule and see how well it goes…

What’s your posting schedule?

Tags: Blogging

(via Dor)

Tags: Humor, Twitter