Fiziksel: Cihazın dış ögeleri

Bir cihazın dış güzelliği içi kadar, hatta içinden daha önemli olabilir. Cihazlarla fiziksel temasa girdiğimiz nokta, o cihazın başarılı olup olmayacağı konusunda büyük bir kriterdir.

Dış yüzey tuşları

Telefonu elinize aldığınızda ilginizi çeken ilk şey Android telefonlarda gelen tuşların (ana ekran, geri, menü tuşlarının) bir kısmının soft, diğer bir kısmının ise hard tuşlardan oluşuyor olması. Zira tuşlar iki sıra halinde yerleştirilmiş. İlk sırada dokunmatik (soft) olan menü ve geri tuşları var. Alt sırada ise arama kabul etme, ana ekran ve arama sonlandırma tuşları sıralandırılmış. Android bir telefonda en çok etkileşime geçtiğiniz tuşların geri ve menü tuşları olduğunu söyleyecek olursam bu yerleştirim başarılı sayılabilinir. Fakat dokunmatik olan geri ve menü tuşları ekranın kendisi kadar hassas değil. Bu durum, yanlışlıkla basmaları engellemek için alınmış bir tasarım kararı olarak görünse de doğru bir karar olduğunu düşünmüyorum. Çünkü cihazı test ederken geri tuşu yerinde bir çok kez ekranın sağ alt köşesine, menü tuşuna basacağım diye de birçok kez ekranın sol alt köşesindeki tuşlara dokundum. Telefonun en çok kullanılan iki tuşuna bu kadar sert davranmak zorunda kalmanız parmaklarınız açısından acı verici.

Geri tuşunun ergonomisi hakkında yapılabilinecek bir yorum daha var. Bunlardan en önemlisi bu tuşun yerleşimi. Telefon benim kişisel görüşüme göre solaklar için tasarlanmış. Sağ elinizle kullandığınızda geri tuşu avucunuzun tam içinde kalıyor. Baş parmağınızla ona dokunmanız gerçekten büyük bir uğraş. Ayrıca bu iki soft tuş yüzünden ekranın alt kısmında olan biteni görmek gerçekten imkansız. Soft tuşlar, fiziksel tuşların altında olsaydı belki daha kullanılabilir olurlardı. Özelleştirilmiş ekranlarda ana fonksiyon tuşlarının en alta yerleştirilmesi uygun olmamış, bu ögeler parmaklarınız yüzünden tamamen görünmez kalıyor – Özelleştirme ile ilgili yorumların devamını yazının alt kısmında bulabilirsiniz.

Arama için ayrılmış Android tuşunun ön yüzeyde değil de sağ yan duvara konumlandırılmış olması ise iyi düşünülmüş. Keza, ara sıra yanlışlıkla arama tuşuna basıp arama uygulamasının çalıştırmasının önüne geçilebiliyor.

Ekran özellikleri

320×480 çözünürlüğünde 160dpi’lık resistif bir ekran var önümüzde. Resistif bir ekran kullandıysanız bu ekranların çalışma prensibini biliyor olabilirsiniz. Resistif ekranlar iki katman arasında yer alan hava boşluğunun daralıp genişlemesi sayesinde sizin dokunuşunuzu fark eden ekranlardır. Bu nedenle iPhone veya Nexus One’daki kapasitif ekranlarla karşılaştırıldığında dokunmaya değil basınca duyarlı ekranlar oldukları söylenebilir. Resistif ekranlar bu nedenle kullanırken daha fazla azim gerektiren yüzeylerdir. Özellikle sanal klavyede hassasiyetle ilgili sorunları olan bir ekran oldukça problem yaratabilir. Optimus’un resistif ekranının belirgin en büyük özelliği de bu. Varsayılan olarak numkey ile gelmesi QWERTY klavyesinin yeterince kullanabilir olmadığını kanıtlar gibi. Yatay pozisyonda ise çok daha rahat bir kullanım sağlıyor QWERTY. Açıkcası klavyeyi sürekli olarak yatay pozisyonda kullandım ve herhangi bir kullanılabilirlik sorunu yaşamadım. Göreceli olarak minik sayılabilecek parmaklarım dikey konumadaki klavye ile fazla barışık değildi.

Genel klasmanda en sorunsuz klavye telefon tuş takımı dizilimine sahip olan klavye (son resimdeki). QWERTY’den daha hızlı yazabiliyorsunuz, üstelik strese girmeden.

QWERTY klavye ile olan deneyimi size daha net bir şekilde anlatabilmek için küçük bir deney yaptım. 200 kelimelik bir cümlede yanlış olarak bastığım karakter, noktalama işaretleri vb. ögeleri saydım. Sonuçlar yatay pozisyonun 3.5 kat daha doğru yazıma olanak verdiğini ortaya çıkardı.

Yatay durumda 200 kelimede yapılan hata sayısı: 12
Dikey konumda 200 kelimede yapılan hata sayısı: 43

Resistif ekranların basınca duyarlı olmasına bir süre sonra alışabiliyorsunuz fakat multitouch desteği olmayan bir telefonda özellikle tarayıcı ve haritalar üzerindeki kabiliyetleriniz sınırlanıyor. Zoom tuşlarını kullanarak scroll etmek zaman kaybına yol açıyor çünkü multitouch destekli bir ekranla bunların ikisini aynı anda yapabiliyorsunuz. Sayfada kalma ve sayfayı inceleme sürelerinizin saniyelerle ölçüldüğü bir dünyada elbette ki saniyeler çok önemli. Fakat bu klasmandaki telefonların birçoğunun resistif ekranlara sahip olduğunu belirtmeden geçemeyeceğim. Benzer sınıfta olan Huawei’in başka bir Android’iyle deneyim karşılaştırması yaptığımda LG Optimus GT540, dokunuşlarıma çok daha net ve hızlı karşılık veriyordu.

Her telefona uygulamaktan zevk aldığım bir teste geldi sıra. Hemen hemen her telefonun ekranının orta bölgesi dokunmaya yeterli bir seviyede cevap verebilirken, aynı durum ekranın kenarları için geçerli değil. Bu da kenarlara yerleştirilen her türlü elementin kullanımını zorlaştırıyor. GT540′in ekranla ilgili büyük sorunu kenarlardaki kötü hassasiyetinden kaynaklanıyor. Köşegenlere paralel olarak gizmeye çalıştığım çizgilerin kenarlarda nasıl deforme olduğunu ve son 10-15 pikselde neredeyse yok olduğunu görebilirsiniz. Benzeri bir testi Nexus One’da yaptım ve en ufak bir deformasyon yaşamadım. Klavye ile ilgili problemlerimin de nedeni ortaya çıkmış oldu böylece.

Ekran plastik, zaten resistif bir ekran olduğundan dolayı elastik bir maddeden yapılmamış olma ihtimali bulunmamakta. Ekranın parlaklığı ve çözünürlüğü dış kaplaması nedeniyle sınırlı kalmakta. Sentetik maddelerin ışığın kırmasıyla ilgili problemi olan benim gibi kullanıcılar netlik ile ilgili problem yaşayabilirler. Plastik ekran, malzemesi nedeniyle eldeki yağı daha fazla kendine bulaştırıyor. Fakat ekranın temizlenmesi oldukça kolay. Telefonu küçük bir bez parçası ya da kendi giysilerinizle birkaç saniye içerisinde temizlemeniz mümkün.

Yazılım: Özelleştirilmiş Android

Neredeyse tüm üreticiler Android’i ürünlerinin hedef kitlesine göre özelleştiriyor. LG Optimus GT540 da bu ürünlerden biri. Telefonu elinize ilk aldığınızda özelleştirilmiş ana tema, sosyal ağ entegrasyonu, temel fonksiyonların ekranlara yerleştirilmiş olması ve kendi marketi olan SlideME göze çarpıyor. Telefon Android’in 1.6 sürümüyle geliyor. Üretici ileri tarihte 2.1 veya üstü bir sürümle çıkmayı planladığını açıkladı fakat elinizdeki 1.6 telefonların güncellemesiyle ilgili net bir bilgi yok. Uygulama geliştiriciler genellikle 2.1 ve üstü sürümleri destekleyen uygulamalar çıkardıklarından dolayı, 1.6 sizi eski uygulamalarla dolu bir köşeye sıkıştırabilir.

Sosyal Ağ Hizmetleri

LG Optimus GT540 ürün olarak gençlerin hedef alındığı ve telefon özelliklerinin sosyal ağlarla donatıldığı bir telefon olarak tasarlanmış. Telefonu açtığınızda ilk olarak gözünüze çarpan, sosyal ağ hesaplarınızı telefona bağlamıza yarayan uyguluma. Bu uygulamadan Facebook, Twitter ve Bebo hesaplarınızı telefonla eşleştirebiliyorsunuz ve adres defterinizi sosyal ağlarla entegre çalışacak hale getirebiliyorsunuz. Bebo’yu neredeyse kullanmayan bir ülke olan Türkiye’de telefonun pazara bu sosyal ağı içererek girmesi yanlış olmuş. Onun yerine FriendFeed ya da LinkedIn gibi daha aktif kullanılan bir ağa öncelik verilebilir ve bu ağ için geliştirme yapılabilinirdi.

Temel Fonksiyon Tuşları

Android’in birçok kör noktası olduğu konusundaki tartışmalarda ön saflarda yer alan kişilerden biriyim. Bu kör noktaların biri de menü tuşuyla ulaşılan ana fonksiyon tuşları. İlk kez Android kullanmaya başlamış kişilerin bu navigasyonu keşfetmesi zaman alabiliyor. Menüyü keşfedinceye kadar da uygulamaların işlevsizliğinden yakınabiliyorlar. LG, bu telefonda ana fonksiyon tuşunu ekranın üzerine konumlandırmayı uygun görmüş. Bu sayede en çok kullanılan fonksiyona tek bir tuşla erişmek mümkün olurken, ilk kullanıcılar için de bir ipucu sunulmuş olmuş.

Fakat, öte yandan bu tuşlar kullanıcının araştırma dürtüsünü azalttığından dolayı menü navigasyonunu keşfetmesini zorlaştırabilir.

Standart Android ekranlarında farklı olarak menü tuşuyla gelen özelliklerinden en temellerinin alta tuş olarak yerleştirilmiş olması. Bu sayede menüde zaman kaybetmeden işleri halletmek mümkün. Fakat küçük parmağım alt tabakaya yerleştirilmiş bu tuşlardan memnun değil. Hemen altındaki menü ve geri dönme tuşlarına basma ihtimalim var çünkü.

Android Market’in Yokluğu

Google’ın market uygulaması bu telefonla da gelmiyor. Market konusunda problem yaşayan bir dolu operatör ve cihaz üreticisi varken bu bir sürpriz değil. Android market yerine SlideMe denilen farklı bir market bulunmakta. İçerik, Google’ınki kadar geniş değil ve market uygulamasının kullanılabilirliği beni tatmin etmedi. Ayrıca upgrade etmeye çalıştığımda bir türlü güncellenemediğinden motivasyonumu kaybetmeme neden oldu. Google marketli bir ROM bulup, telefona Google marketini ilave etme konusunda fazla kararlı değildim. Bunun en önemli nedeni bu telefon için hazırlanmış bir ROM bulamamamdı. Fazla riske girmek istemediğimden telefonu olduğu gibi kabullendim. Daha önceden kullandığım uygulamaların APK dosyalarını bularak kendim yükledim birçoğunu. Market’in rahatlığını yakalayamadım ama neredeyse aradığım tüm uygulamaları buldum.

Uygulamaların listelendiği ekranda, kullanıcının yüklediği uygulamalarla ilgili kullanışlı bir organizasyon yaratılmış. Sonradan yüklenen uygulamalar ayrı bir segmentte sunularak kullanıcının kendi yüklediklerini kolayca ayırt edebilmesi sağlanmış. Özellikle yeni bir uygulama yüklediğinizde bulmanız çok daha kolay oluyor.

Tarayıcı Konforu

Tarayıcı performans açısından yeterli düzeyde, en azından sayfaların render edilmesi ile ilgili bir performans problemi bulunmamakta. Oldukça ağır JavaScript içeren sayfalarda tamamen tıkanabiliyor fakat bu tür sayfalara telefondan erişmek isteyen kullanıcı sayısının azlığı düşünülecek olursa tamamen es geçilebilinir. Tarayıcının üzerinde varsayılan Android tarayıcısından farklı olarak kısayollar paneli gelmekte. Bu panel sayfanın üzerine overlay olarak yerleştirildiğinden bazen bazı elementlerle etkileşime geçmenize engel oluyor. Örneğin, Google’da arama yaparken arama button’unun tam üzerinde durduğundan kullanıcı olarak kendinizi rahatsız hissediyorsunuz.

Varsayılan Uygulamalar

Telefon ile birlikte gelen uygulamalar tatmin edici bir seviyede. Birkaç uygulama, telefonu ilk elime aldığımda ilgimi çekti. Bunlar:

1. Video düzenleyici: Video çekip daha sonra bu videoları düzenlenize yardımcı olan mini bir uygulama var. Özellikle video çekimini aktif olarak kullanan ve çektiklerini çabucacık paylaşmak isteyenler için ideal.
2. FM Radyo: Hala radyo kullanıcıları var mıdır bilinmez ama bu telefon FM radyo desteğiyle birlikte geliyor. Yayını duraklatma gibi artık temel sayılabilinecek özellikler ise es geçilmiş.
3. IO File Manager: Dosya sisteminize tamamen erişebilmeniz için tasarlanmış bir uygulama. Bu uygulama ile işletim sistemine ait dosyaları görmek de mümkün.

Performans ve Batarya Tüketimi

Telefonun teknik ayrıntılarına ulaşmakta büyük bir zorluk çektiğimi belirtmem lazım. Çeşitli performans araçları ile elde ettiğim verilerde 256 MB RAM ve 600 MHz bir işlemciyle karşılaştım. Telefonun tepki verme hızı uygulamalar arasında geçişler yaparken bariz olarak etkileniyor. Animasyonlar ve diğer arayüz ile ilgili olan geçişler yeterince performanslı değil. Performans konusunda iyi bir kriter olabileceğine inandığım tarayıcı deneyimi ise kesinlikle ortalamanın altında. En azından Sun Spider testi bitmek bilmiyor ki, size gerçekçi bir metrik verebileyim.

Batarya tüketimi konusunda şampiyon olarak nitelendirebileceğim bir telefon. İçerisindeki 1500lük batarya ile aktif kullanımda bile 1.5 günü aşan bir kullanım olanağı sağlıyor. Tamamen yeniden sarj olması 1.2 saat sürdüğünden dolayı sürekli olarak sahada gezenlere uygun bir telefon.

GSM, Ağ Baglantıları ve GPS

Telefonla ilgili en önemli kriterlerden biri de veri bağlarıyla arasındaki köprünün ne kadar başarılı olup olmadığı. Telefonun GSM ağı ile etkileşiminin oldukça problemsiz olduğunu belirtmem lazım. Ayrıca 3G bağlantı sağlamakta zorluk çektiğim çoğu noktada LG Optimus GT540 ile bağlantı hızım ortalamanın üzerindeydi.

Kablosuz ağları yakalama potansiyeli, kullandığım diğer tüm Android telefonlardan çok daha başarılıydı. Fakat GPS alıcısından çok da memnun kaldığımı söylemem. Araç içerisindeyken tatminkar bir servis sağlıyor ve navigasyon araçlarını kullanmanıza problemsiz olanak veriyor. Ama, dış alanda sabit dururken veya pencere kenarında konumunuza göre diğer telefonlara göre daha kötü. Navigasyon için kullanacaksanız sadece Google Maps uygulaması ile bile oldukça mutlu olabilirsiniz.

Kamera

Telefon satın alırken en üzerinde durulan kriterlerden biri kamera. Özellikle sosyal ağlarla entegre olma konseptiyle çıkmış bir telefondan sürekli paylaşım halindeki kullanıcısını mutlu etmesi bekleniyor. GT540′ın kamerası ışığı oldukça yayıyor, bu nedenle ışığın fazla olduğu ortamlarda ve gün ışında fotoğraflar yeterince net değil. Öte yandan, karanlıkta çektiğim fotoğraflardan daha çok verim aldığımı söyleyebilirim. 3.0 mega piksel bir kamera taşıdığı için beklentiniz çok yüksek olmuyor. İncelemeniz için birkaç örnek fotoğraf ekliyorum:

Sonuç

Çok düşük bütçelilere hitap eden bu telefon, sıradan özelliklere sahip bir cihaz almaktansa Android’le tanışmak ve ucuz telefonlardakinden çok daha iyi bir tarayıcı deneyimi yaşamak isteyen insanlar için ideal. Açıkca belirtmek gerekirse cihaz bir multimedya aracı değil ve resistif ekranı yüzünden klavyesi çok başarısız. Email trafiği arasında kaybolanlara ve Internet bağımlılarına kesinlikle hitap etmiyor. “Sadece temel telefon özellikleri (telefon/mesaj/kamera) bana yeterli, geri kalan tüm diğer özellikler benim için artı bir puan.” diyorsanız almayı ciddi olarak düşünebilirsiniz. Telefonunuzu yenilemeyi düşünüyorsanız ve Android’e ilgi duyuyorsun mutlaka göz atın.

Öte yandan, benim kalibremde konfor arayan bir telefon kullanıcısı iseniz, bu cihaz kesinlikle size göre değil.

EK – Sürücü Problemleri

Telefon benim elime ilk geçtiğinde hemen USB debugging modunu açarak kendi yazdığım uygulamalardan birkaçını test etmek istedim. Mac OS X, telefonu tanımadı. Telefon için uzun uğraşlar gerektiren bir sürücü avına başladım. Öncelikle telefonla bize verilen CD’nin içerisine baktım. Sürücülerin burada olacağını umuyodum. Fakat CDnin içerisinden sadece basın bildirisi ve fotoğraflar çıkınca biraz üzüldüm.

Hiç Windows makinem olmadığından dolayı şirketten makinelerden birine göz koydum önce. LG’nin mobil telefonlarla ilgili güncellemelerini dağıttığı bir uygulama indirmek zorunda kaldım. Bu program, lgmobile.com’dan indirilmesi gerekirken, bağlantı bana 404 verdiğinden dolayı tamamen farklı bir yerden güvenilir olmayan bir kopyasını buldum. Programı çalıştırıp sürücümü alabileceğimi düşünürken, her şey yeniden tepetaklak oldu. Uygulama benden, elimdeki telefonu IMEI numarasınıyla veya model ile seri nosuyle tanıtmamı bekliyordu. Hepsini denedim, hiçbiri işe yaramadı. Yaklaşık 2 saat uğraştıktan sonra pes ettim. Ertesi gün Windows XP kurulu bir makineye USB üzerinden bağlanmaya çalıştığımda biraz daha moralim yerine geldi. Makinem cihazın takılı olduğunu algılayabiliyordu en azından. Uzun süren bir sürücü arayışından sonra umutlarım yeniden yerle bir oldu.

GT540, geliştiricileri hedefleyen bir makine olmadığından arayışlarımı sonlandırma kararı aldım. Çünkü telefonu kullanacak son kullanıcının (örneğin annemin) benim yaptıklarımdan daha ötesiyle uğraşmak istediğini sanmıyorum. Sonra tesadüfen LGMobile güncelleme uygulamasını yanlış çalıştırdığımı farkettim. Yaklaşık 30dklık bir kurulum merasiminin ardından telefonu DDMS’te görebiliyordum. O kadar çok kurulum yaptı ki, bu sürecin gerçek olmadığına inanmaya başlamıştım. Şu an GT540′a erişebiliyorum, fakat Android SDK ile gelen sürücü güncellemelerim bozuldu ve kendi telefonlarım bana cevap vermiyor.

Yukarıdaki liste kurulan komponentleri gösteriyor. Kuruluma başladıysanız bir şeylerin ters gittiğini düşünüp sakın iptal etme yoluna girmeyin. Yani kısacası, Windows kullanmıyorsanız  telefon sizi sinirlendirecektir Başka bir Android telefonunuz varsa çıldırabilirsiniz.

So, what is Object.prototype?

You should be familiar with Object.prototype at least you have a little dirty object oriented JS experience. If you dont, let me explain you in a few words. In order to bind methods to a type, you extend your type’s prototype. For instance, let us assume we need a Student type, who can enroll to and withdraw classes.

var Student = function(){};
Student.prototype.enroll = function(classes){
     // code here
}
Student.prototype.withdraw = function(classes){
     // code here
}


So, Student’s prototype is referencing to an object which has two functions, enroll and withdraw. Similarly you could have written the same as:

var Student = function(){};
var methods = {
     enroll: function(classes){ /* code here */ },
     withdraw: function(classes){ /* code here */ }
}
Student.prototype = methods;

Great, now it’s time to explain you what prototype object is doing. Whenever you are constructing an instance of Student type, it appends enroll and withdraw functions to the created object. In short,
var student = new Student();
student object can call student.enroll([4, 5]); and student.withdraw([5]); in order to enroll to classes which are identified with 4 and 5. And withdraw the class identified with 5. Student class will be extended before Student.constructor is called so, you can use enroll and withdraw right inside of the constructor if needed. Visually the memory looks like:

So if you make a change to Student.prototype after student is created, changes will affect the student instance.

You started to be fascinated, arent you? But we’re just beginning. We’ll take a look how we’re using prototypes to share common behavior among classes. Assume we need another class called PartTimeStudent that inherits Student. To transfer all of the capabilities of the Student, we can set PartTimeStudent’s prototype to a Student object.
var PartTimeStudent = function(){}
PartTimeStudent.prototype = new Student();
PartTimeStudent.prototype.constructor = PartTimeStudent;
By setting the prototype to a Student object that’s being initialized by new Student() line, you also transferred the PartTimeStudent’s constructor to the Student’s. Last line resets the constructor to the right one.

And finally you can continue to extend PartTimeStudent by adding more methods to its prototype.
PartTimeStudent.prototype.other = function(){/* code here */}

Anytime you ask for enroll() from a PartTimeStudent, firstly PartTimeStudent will be searched if it has its own property called as enroll. After no result is found, object’s prototype is being searched. This chain goes until a match is found. If there are no matches, there will be an error to output. Prototype chaining is usually a very costly operation and as you change the deeper definitions such as Object.prototype, it’s becoming a performance bottleneck. That’s the main reason behind the common advices that tell you not to extend Object.prototype directly. And as far as I can understand, if you don’t extend Object.prototype (or any of the existing classes), JS engine uses the natively implemented Object internally which is expected to run . If you make changes, standard implementation cannot be used and extra memory will be consumed to keep the definitions.

This was a quick intro for prototype based inheritance. Part II will cover more existing issues.

I simply thought that I’m not the only one on the comparison need side, that’s how I decided to launch it. It’s funny to watch the metrics from Gordon Brown vs David Cameron, Obama vs BP and etc. I became a huge addict! I’m planning a minor update with some useful features and fix some of the usability problems. If you have any feedback, please drop it here.

Most of the maps APIs provide this functionality such as Google Maps API, so developers seem to have problems with implementing theirs. Google Maps API for Android does not provide functionality for setting bounds to a box. Instead, what’s provided is to zoom to a span.

com.google.android.maps.MapController.zoomToSpan(int latSpanE6, int lonSpanE6)

latSpanE6 is the difference in latitudes * 10^6 and similarly lonSpanE6 is the difference longitude * 10^6. You may question how map controllers know where to zoom in just by the differences. For examples, kms between longitudes differ from equator to poles. Fortunately, Google maps projection has them in the same length. This may remind you the infamous South America versus Greenland syndrome. Although Greenland is much much smaller than South America, it doesnt look so with this map projection.

On the below, I implemented a boundary arranger method for MapView. Method takes three arguments: items, hpadding and vpadding. items as you may guess is a list of POIs. Other arguments are a little bit more interesting. hpadding and vpadding is the percentage of padding you would like to leave horizontally and vertically so that pins don’t appear just on the corners. For instance, if you assign 0.1 for hpadding, 10% padding will be given from top and bottom.

BTW, You’ll have to extend the existing MapView and add this method to your own MapView to use this method properly.

public void setMapBoundsToPois(List<GeoPoint> items, double hpadding, double vpadding) {

    MapController mapController = this.getController();

    // If there is only on one result
    // directly animate to that location

    if (items.size() == 1) { // animate to the location
        mapController.animateTo(items.get(0));
    } else {

        // find the lat, lon span
        int minLatitude = Integer.MAX_VALUE;
        int maxLatitude = Integer.MIN_VALUE;
        int minLongitude = Integer.MAX_VALUE;
        int maxLongitude = Integer.MIN_VALUE;

        // Find the boundaries of the item set
        for (GeoPoint item : items) {
            int lat = item.getLatitudeE6(); int lon = item.getLongitudeE6();

            maxLatitude = Math.max(lat, maxLatitude);
            minLatitude = Math.min(lat, minLatitude);
            maxLongitude = Math.max(lon, maxLongitude);
            minLongitude = Math.min(lon, minLongitude);
        }

        // leave some padding from corners
        // such as 0.1 for hpadding and 0.2 for vpadding
        maxLatitude = maxLatitude + (int)((maxLatitude-minLatitude)*hpadding);
        minLatitude = minLatitude - (int)((maxLatitude-minLatitude)*hpadding);

        maxLongitude = maxLongitude + (int)((maxLongitude-minLongitude)*vpadding);
        minLongitude = minLongitude - (int)((maxLongitude-minLongitude)*vpadding);

        // Calculate the lat, lon spans from the given pois and zoom

        mapController.zoomToSpan(Math.abs(maxLatitude - minLatitude), Math
.abs(maxLongitude - minLongitude));

        // Animate to the center of the cluster of points
        mapController.animateTo(new GeoPoint(
              (maxLatitude + minLatitude) / 2, (maxLongitude + minLongitude) / 2));
    }

} // end of the method

You can read Vodafone’s tutorial to make a Widget first to have an initial look.

The Good

For many years, I’ve been in a huge debate with people who uses work force inefficiently by their 35k different platforms and SDKs. Half of the developer have written HTML once in their life and JavaScript has a very large developers base. Every new mobile platform is usually re-inventing the wheel once again and this default action is usually driven by business fears.

Widgets make software accessible anywhere you can run a browser. It’s definitely “Write once, run everywhere”. And the complaints about slow page transmission is being fixed by running them from local resources.

Widgets will push mobile web browsers to act more similarly as applications base grow. Many of the extensions such as geo-location APIs dont really fit each other and some mobile browsers provide totally non-standard features. If web applications dominates the mobile, community will push browsers to act better.

It’s easy to get in. You dont have to download SDKs, learn another language and read documentation/tutorials to learn something new.

The Bad

Performance. Native apps run fast. Even Dalvik empowered Android is horrible and not really responsive compared to other platforms’ applications because of Java. Heavy JS on web browsers are not scalable and just like most of the other browsers, Safari on iPhone has rendering issues even on local websites.

Forget the advantages of Web when it comes to releasing software. No on the fly updates at all. Software should be downloaded again and again as new versions release.  Accessibility to internal platform is questionable. Open platforms like Android provide access to internals such as contact lists, file system and invoking other applications. If mobile  operating system manufacturers cant meet at providing the similar APIs, this wont work.

The Ugly

I find the old-generation of mobile development community is very ill-minded. They use the know-how to make money and this community is interested in their complex and closed environments.

On the other hand, the only contributor is Opera for now. I’m not really sure if they go for larger market share or not. If an open standard acts like a diverse platform for Opera browser phones, it’s the same story.

I was introduced to programming and computing technology very long time ago. I was pushed to it and fascinated by the flow of bits and bytes. But everything was embodied in 1996, the day I met the Web. Finally there was an easy and cheap way to distribute products. And to be able to ship products, I had to learn programming. This is how I started.

Now as a professional, I still couldn’t understand why I’m not also responsible for budget, strategy, concept, ux et al as a developer. I’m a products person, I want to code for beautiful products to change mindsets and push the limits for more market visibility. I’m driven by breakthrough concepts, user interaction improvement, performance, cognition and reasoning. If you cant convince me, I perform bad. To be honest, I’m not sure this is how a developer should act but this is my formula. My time is valuable and if you want me to invest it in your project, you have to convince me. I never remember myself applying for a company to work on a product I dont believe that I can dedicate myself to.

Most probably this makes me an inefficient developer. I get angry when we don’t make enough revenue and we ship features that turns into invisible toys that 80% doesnt even use. I find myself crazily analysing the logs where available and trying to understand how users think.

Now ask me how many companies I started. Actual the number is “one” — the sector was totally out of technology business. We had great recognition from major industry players in the USA and our main service was quite profitable for college students. I made some huge mistakes in the past two years with losing the entrepreneurship I have inside. Now I decided to be a half entrepreneur and half time&energy investor.

There were possibilities to listen touches and calculate the positioning of the next item and scroll to it. But to be honest, I had no time to try out fancy and not-stable solutions. Instead of losing myself in the rules of UIScrollView, I wanted UIScrollView to get lost in me. Remind the rule: “Only scroll multiples of its width horizontally”. Great, so why not modifying scroll view’s size? Well, just because I want other items to be visible and lined together to give user a feeling that it is a slider.

Normally, that is where you stop, but there appeared a trick to make it work my way. I decided not to clip the subviews of scroll view and TA-DA! Images were lined up together and were visible even though they were not in the bounds of my scroll view. Very simple and clean solution. Inline note please: Before moving to the “how”, I want to point out there is a problem with this trick. You cannot interact with items out of the scroll view boundaries. If your items are tiny, this is a huge problem because scrolling will only be active for 50-60 pixels. Consequently, use this trick if items are at least %50-%60 of the whole screen.

Start a new window-based Xcode project. Create a view controller with a xib file. Open xib file and add a UIScrollView to the main view. Return back to the controller you created and add a property to connect UIScrollView. Return back to Interface Builder. Modify the width, height and positioning of the view. Connect controller’s scroll view to UIScrollView we created. Enable paging and uncheck “Clip Subviews”. Our scroll view is ready to be filled. On the viewDidLoad method, I’m going to add several images.

// Implement viewDidLoad to do additional setup after loading the view, typically from a nib.
- (void)viewDidLoad {

    [super viewDidLoad];

	int i = 0, cx = 0;

	for(;;i++){

		UIImage *image = [UIImage imageNamed:[NSString stringWithFormat:@"image%d.png", i + 1]];

		if(image == nil)
			break;

		UIImageView *view = [[UIImageView alloc] initWithImage:image];
		view.frame = CGRectMake(cx,0, scrollView.frame.size.width, scrollView.frame.size.height);
		[scrollView addSubview:view];

		[view release];

		cx += scrollView.frame.size.width;
	}

	scrollView.contentSize = CGSizeMake(cx, scrollView.frame.size.height);

}

And finally build and run. It is going to work.

1. It’s natural: You have passion for technology

You don’t have to have a reason. This should be very natural. If you are passionate about technology, you are also passionate about the trends in tech. Blogging is the top of the game since 2002-2003. Regretting the fashions won’t make you a cooler person. Early adoption gives a better impression. Running a blog and not making money out of it gives me one obvious signal: I’m passionate about what I’m doing, this is not just a job to earn my life.

2. Self promotion

Isn’t it obvious? Nowadays if you are not on the Web, you are nowhere. You will at least have a personal space to introduce yourself to the world of networks. It’s good because you can find others who are interested in similar technologies and are passionate for similar concepts.

3. Self improvement

How could writing improve my own abilities? It’s usually being asked. Being socially active is the best thing to find more people who can challenge your existing capabilities. I understand you were the smartest of your family, you had great marks at high school, was a top student at college and now a superstar employee. But due to the existence of your blog, everyday you have replies back to you from smarter people around to remind you are still a beginner. This is a great opportunity to see there are no limits and you are never done.

On the other hand, your blog serves as a timeline which captures your interests, technical knowledge and other capabilities. You can easily review yourself by taking a look at your older posts.

4. Sharing Knowledge

And obviously, sharing knowledge has its factor. It’s common for others to struggle where you went down. You may like to share an exceptional bug, a trick to make things work, a newly released product, methodologies, stories, experiences and reviews.

Blogging makes you a better developer. More people you meet, the better person you will be. Physically there are many constraints but an online representation of yours will fasten things. And as a blogger, I want to get that as an RSS feed! Now there is one thing I’m curious about. Do you blog or not? Why or why not?

First of all in our to show map tiles properly, we need an API key. This is all because you are requesting from Google Data API and have to agree with the terms of service. I’m also sure that quote rules also apply.

Every Android application is signed with a signature of the publisher. While obtaining a key, you must provide the MD5 summary of your signature to Google, and Google activates possible transactions between Maps API and the application your signature signs. In order to complete these actions, you have to

1. Obtain the MD5 summary of your signature. If you do not have a signature, you can use the default one.
2. Sign up for an API key directly from Google by providing the hash of your signature.
3. Use API key with map elements and generate a sample map view.

Obtaining an API key

You will have to use the keytool to obtain information about signatures. If you haven’t created one, Android SDK puts a default one in your ~/.android directory. In this tutorial, I’m going to show you how to register with this default signature. Open a terminal prompt and enter

$ keytool -list -keystore ~/.android/debug.keystore

It’s going to ask you the password of the keystore (debug.keystore). Default is “android”. If you receive a MalformedKeyringException, you are giving the wrong password. If everything works great, it will output a few lines of information including the hash. Please read the summary line and copy the hash.

Certificate fingerprint (MD5): E8:F4:F2:BF:03:F3:3A:3D:F3:52:19:9B:58:20:87:68

After obtaining the summary key, you can jump to the next level — signing up for an API key. Give the hash as input and register. Please note the API key Google has given to you.

Generating Maps on Android

Android SDK comes with two archives. First one is the android.jar which contains the standard platform libraries. And maps.jar which is a library dedicated to generation of maps. In the maps API, you will notice MapView. You can extend MapView to customize and add new features to show a custom map view. Or invoke the existing methods to perform simple operations like panning, zooming and adding overlays to show information on the default map. There are great tutorials about Android’s map view and controller on web, I simply didn’t want to copy-cat the existing. Google’s Hello, MapView is a place to start.

Multiple-Developer Cases

A signature can only be associated with a single API-key. What you are going to do if development is made across a team? You dont need to create different signatures for each developer and register them to use Data API one by one. Register a single signature and obtain a key. Then, distibute the signature among the developers – better add it to your version controlling system.

Redis explains itself as a non-volatile memcached with various in-built data structures. Instead of only key and string value pairs, you can have lists and sets as values. There are atomic pop/push operations to work on these structures and increment/decrement functionality to work on numeric values.

Several client libraries are available including Perl, Python, Erlang, C++, Ruby, Scala and PHP. To write a more meaningful post, I’d like to add lines from a simple Python script.

import redis

storage = redis.Redis()
storage.keys("a*")  # returns keys starting with a

storage.get("key1") # returns the value of "key1"
storage.set("key1", "hello world") # setting the value of "key1"
storage.delete("key1") # deletes the pair with key1.

# working on lists
storage.push('key2', 'This is the first value', tail=True)
storage.push('key2', 'This is the second value', tail=True)
print storage.pop('key2')

Most of these methods are ported to client libraries and are available in downloadable Redis archive.

Although Redis can not be distributed, it’s easy to set up a slave node to replicate the master. Since it syncs with hard-disk in certain intervals, there might be data-loss in possible system crashes. So, setting up a slave may decrease the risks. It’s also advised to use Redis on a central server and manage sharding in the application level.

1. Readability of the code,
2. Compatibility with coding standards,
3. Organization of the codebase,
4. Documentation inside the code /* comments */,

will stay as surprises. These may lead to a dirty and badly organized base after a few years of continuous development. Asking a peer before you integrate new code into your product is a better approach since you may most probably have more time to fix, reshape and enhance your code if you take the action earlier. Usually only one other team will have time to review your code. But reviewing should be done with two people. First one should be a master, the one that knows the existing system well and can see the big picture. He can guess the impacts of your certain changes among the codebase. Other peer should be ideally someone who is not very familiar with the code, so you can test how easy to get into your code if you have to assign a bug to a new member, how well it suits with patterns in software development, how simple and obvious your solution is.

Consequently, whatever you are working on is shared among people. Asking for a review is always better than not asking and keep your actual contribution as a secret until it needs to be changed.

The problem

Current spec does not serve as a latitude, longitude carrier. Current properties only include post-office-box, extended-address, street-address, locality, region, postal-code and country-name which are text fields to form an address. This schema is defined in vCard and migrated to hCard microformat in 2004. Then, the need of address-based extraction led them to copycat this format and call it adr. vCard’s final design spec was way before we had online maps. Nowadays, we have addresses all over the Web. Automatically directing these text addresses to locations on maps or providing a preview on hovers would be the first basic attempts to improve our data representations. But unfortunately, maps are talking more in mathematics than text addresses. In practise, there is a process that takes addresses and transforms them into a latitude, longitude couple and pans map to that location. This process is called geocoding, and it is far away from perfection in today’s scale. Instead of depending on a geocoder to transform addresses into mathematical locations, I suggest microformats to enable built-in (lat, long) arrays in adr.

Extending adr with a set of latitudes and longitudes

What I’m going for is to extend adr with an optional list of (lat, long) values. So, in cases where coordinates are given, instead of asking a geocoder to land us on a location we can directly move. But why to use a list of coordinates and not a single point? Because, in spatial domain different geometric structures are being represented as different shapes. Examples are below.

1. If you are talking about a city centre, it’s most likely to be a Point.
2. Mississippi river is a long long Line.
3. And a university campus is obviously a Polygon.

In the image above, British Museum is represented by 12 latitudes and longitudes as the inner area which these points compose. On the other hand another representation may be made with the centre point of the museum with (51.529038,-0.128403). Formally speaking, the museum is located on “British Museum, Great Russell Street, London, WC1B 3DG, UK“. And this translates to the coordinate I gave. What about using them together to form:

<div class="adr">

<div class="street-address">Great Russell Street</div>
<span class="locality">London</span>,
<span class="postal-code">WC1B 3DG</span>,
<div class="country-name">UK</div>

<div class="geo"> <!-- optional coordinates attribute from geo -->
<span class="latitude">51.529038</span>,
<span class="longitude">-0.128403</span>
</div>

</div>

In the example above, I’ve used geo to include the single point <lat, long> optionally to map the address to a physical location. More useful structures can be defined within standards to enable multiple point entries to provide polygons such as 12-point representation of British Museum in the image above. Or basically, multiple geo entries inside an adr may work.

TODO: Write about the impact this usage can bring.

I love machine learning and classification. My whole life is being spent between two parameters: accuracy and precision. These are the common statistical values to determine how successful your system is. If you have a search engine, accuracy may tell you what percentage of retrieved documents are really relevant. And percentage is a value to determine how likely your results cover all the relevant documents available.

Surprisingly a few days ago, I was asked to break a machine learning system during a job interview. I was asked to come up with some possible cases. According to my own philosophy, accuracy and precision are parts of the system requirements. They are related with the quality of the overall product. But how are you going to collect information to come up with these numbers? Imagine you are working on a searching engine. Is it manageable to find n people and ask them manually if they like the results or not? Will your sample (n people) reflect your user base? How costly it will be and how objective? Is it really scalable? Is it possible to for a human to read all of the documents on the Web and decide which are really related to his search phrase? These are a few introductory level problems with analysis of accuracy and precision.

Post-Processing and the Importance of Feedback

It may not be critical for you to release a product with a target accuracy and precision. Mostly, consumer market suits this model the best. But this alone should not be translated into the “inessentiality of the quality tracking”. I am just advising you to track the quality after the release (similar to ship-then-test method). Detect which results are exit-links, provide instant feedback tools for users to relocate their results and etc. Use acquired feedback to improve the existing system. Testing may not be done with the release, you may need to discuss and analyze if your product is performing well and report to your development team and influence them with scalable user-oriented improvements.

UDP 53, what’s wrong there?

I started to recognize a pattern. My downloads were even more slower because resolving was failing miserably every time I try. I was not even able to resolve domain names to IP addresses. Had to check myself what might cause this problem. As a quick note, if your local DNS cache (managed by operating systems) doesn’t have a record of the domain name you’re trying to visit, you make a request to one of the nearby DNS servers to return the associated IP. If your nearby server doesn’t have that record, it asks to root servers etc. Most of my reader audience knows the story well. This communication is made on UDP port 53. UDP is a connectionless way to transmit data. Unlike TCP, you don’t have to spend time on three-way-handshakes to make a proper connection that both of the sides are aware of. But if your packets get lost, nobody is responsible. It’s like playing a game, many tradeoffs similar to every engineering issue.

I gently asked my sister to stop a while, and started receive not timed-out UDP answers back. Resolving problem was fixed. But I had to be convinced that UDP is the best ever been chosen from. I understood the fact the essential parameter was latency. We have to be fast, faster and fastest as possible. Wanted to take time back to understand why it is designed this way and my problem appeared with a solution in milliseconds.

Why DNS is using UDP?

Reliability versus fastness. Remind the rule. If you don’t have the address, ask a nearby name server. Is it implicitly saying “Don’t go too far.”? Probably it is. You’re not on a very reliable connection and if your traffic load is very high, there will be many conjunctions, long delays and large jitters. My dns requests most probably couldn’t even making it to the name server. And since my ISP’s name servers are not reliable, I was using OpenDNS. Translation: I was far far far away from the source.

I fixed the issue. Even crazy downloading is again on, my domains are resolving rapidly at the moment. I’m extremely happy. If you’re using OpenDNS at office or LANs which have more than 20+ clients, make yourself a favor and set up a local name server today.

Realtime Data Processing

Realtime environment have to play with data to make connections, be able to provide smart searching that does not only depend on full-text comparison. Imagine that they have to tokenize text input to post-process what’s going on with the message. Almost requires O(n) on CPU. Twitter has about 1 million users, let’s assume averagely every user enters a new twit once in 3 days and average entry is 100 characters long (doesn’t sound realistic, but let’s be optimistic). It converges to 350k posts a day. 350k times tokenizing the 100 character-long input = 35 million characters are processed during a day.  I tried to tokenize a 100 char string 350k times and it took only 41 seconds since I was using the same string over and over again. With helps of caching, CPU minimizes the memory I/O and it made a huge difference, so my 41 seconds were far from being accurate. But besides tokenizing, there are other operations you have to run. And once you fetch it from memory, you’re done. Therefore, I believe it’s not really an extra load to tokenize the input on the server-side.

But, what would you do if you have to post-process terabytes of imagery? I’m not sure if you are aware of Microsoft’s Virtual Earth 3D but, it is more like Google Earth running on your browser.

A very long time ago, I was making a demo to my friends and showing the Mt. Rainer in WA distinct in 3D mode. Virtual Earth 3D fetches higher quality imagery for forefront. Since there is no colour balance adjustments at VE imagery, many people thought  the level differences on the scene is sort of a corruption and not good looking. I decided to talk to engineers that we can solve this problem with relative histogram equalization (fancy name but easy method). I didn’t sound perfectly realistic, cause our imagery were tens of terabytes and it was very risky to process them all for such a tiny improvement.

Luckily, I recognize client power for the first time and the power it brings out. I was going to add a improvement step to equalize imagery once it is loaded as “it is” to user machine. User’s itself was about to play a role to balance images on the front-end.

Future of the Web: More Realtime Data Needs More Client Power

Twitter example is quite lightweight, 35 million characters/day is not huge as you may guess. As millions started to use realtime equipment passionately and generate a hundred thousands times more content than this, we may have to take advantage of our user’s machines mostly for pre and post processing of data. All of the new client technologies are about the provide a rich environment and framework to let the users contribute to the overall system with scalability. Future is going to be all about making a distribution decision between clients and servers. If you are a server guy who has no idea on the user machines, study your lesson before this balance dominates the world.

Edit: Sorry for quoting VE’s 3D mode with Silverlight, thanks for Jon O’Brein (a Microsoft MVP) for fixing my deadly fault. I was high or something.

I started to code with a fundamental function to find roots of a 2nd order equation and easily understood how programming can reduce the amount of time I’m spending on trivial calculations. The Internet was becoming widely available (at least in the community I was living). There was a technology boom, the access rate to the “new” were increasing wildly. I decided to learn as far as I can and in the end I became a giant language and framework addict, although I had no deep knowledge in anything. But it was driving me because, the particular technology I was interested in was helping me to turn my fancy ideas into concrete products. So, not for doing all for learning the technology’s itself doesn’t make me a software developer now? How dramatic.

Being a software developer with no purpose

It’d really taken me far too long to get aware of the ecosystem of a software-dominated system without formal education. However, before  I had reasons to learn, I had never dreamt of being a professional software developer – cause all alone it was meaningless, especially in a situation when software you’re bringing out doesn’t have any purpose other than making profit. Nobody does have dreams like being the greatest developer in this or that field. People like me usually tend to be remembered with

1. a groundbreaking product, a method changes the concepts, a more efficient way of doing things.
2. being a leader in a specific area to influence other people.

They put meaning into every single duty they are working. I personally don’t look programming jobs as jobs. It’s a great opportunity to access a company’s tools and existing audience to make differences quicker than forming a new start-up, gain respect and deal with financial stuff. But again with purpose, you always have the “If you’re not hiring me, I’ll be doing the same on my own” advantage under the belt obviously.

Software is just a tool, not the ultimate reason. Many people in industry don’t seem to understand it. Of course, the better and deeper you know about the technology, the impact you can make will be larger. Development alone is a very wide and challenging issue, that’s why it is titled as a separate profession nowadays. But instead of thinking totally machine oriented, you have to have a main goal and use tech to fasten it.

I’d love to see specialized development titles instead of everyday titles we face today like: software engineer, software developer, software development engineer and etc. Biotech/Bioinformatics is a great example alone for separating itself from the mainstream tech community. Take  a look at the following job posting:

X is searching for an experienced Software Developer to support the Production Genomics Facility in Y. The mission of the X is applying genomic science to the critical fields of bioenergy, bioremediation and carbon cycle management. The X applies both the latest high-volume sequencing technology and classic Sanger processes to sequence and analyze thousands of large and small genomes…

Skills Required
- Create, manage, and query MySQL databases.
- Develop and utilize Perl classes, modules, and scripts for managing data and performing analyses; and Perl/CGI web pages for providing user access.

Why don’t we see similar ads from most of the software/hardware companies today? Give me a reason to get excited of what you are doing now, so that I can check the if I meet with your qualifications.

Consequently, software development title is artificial, it is not concrete. You basically don’t have a clue about what you’re going to do inside while you are applying. I wish companies were a little bit specific on titles and descriptions. Yes, I am agree with you that this basically applies to many industries. But, software is a supporting tool in many industries alone. So, it is a special case, it’s far more problematic.

Early Starting or Deep Thinking?

I wish the first idea comes to mind was the perfect one. But usually, it is not even close enough to be a good solution – it is often greedy and very straight-forward. The more you learn about the problem and its characteristics, the better and more efficient solution will pop up. If you start coding in the first hour, you will probably never ever finish the task. I’d like to share a case study from Jon Bentley’s amazing book, Programming Pearls.

The story is about Andrew Appel and his experience on reducing the run time of a system from one year to one day. They had to simulate the motions of N objects in 3D space, given their masses and initial positions and velocities. They basically were interested to predict the positions of planets, stars, galaxies 10 years, 100 years, 1000 years later. In a 2D space the input may look like the image on the left: a large set of vectors.

The regular simulation programs divide time into small steps and computes the progress of each object at each step. Due to the existing of gravitational field and mass attractions, the computational cost were proportional to N². Appel estimated that 1000 time steps of such a system with N=10000 objects would require more than one year on a VAX-11/780 or a day on a Cray-1. Andrew had to develop a system far more efficient than a one-year-running turtle. After several speedup improvements, he reduced the runtime to less than a day on VAX-11/780 — almost 400 times faster than the initial setup.

He managed to change the concept on many levels to make such a huge difference.

1. Data Structures: Foremost, O(N²) had to go. He decided to represent objects as leaves on a binary tree; higher nodes were representing the cluster of objects. The force operating on a particular object can be approximated  by the force exerted by the large clusters. This alone reduced complexity to O(N logN) by a factor of 12.
2. Algorithm Tuning: Initial algorithm has to use tiny time steps to handle the rare case that two particles come closer to one another. Usages of tree-based structure enabled investigation of such rare cases possible independently from time steps. As a result, Andrew doubled the time step size and halved the run time.
3. Data Structure Reorganization: The tree that was representing the initial objects was quite bad in representing the later sets. Reconfiguring the tree at every new step was a bit costly but reduced the number of local calculations and halved the total runtime.
4. Code Tuning: Due to additional numerical accuracy provided by the tree, 64-bit floating point number could be replaced by 32 bit single-precision, halved the runtime. Additionally, profiling the application showed that 98% percent of runtime was being spend in one procedure. Rewriting that procedure in assembly  increased the speed by a factor of 2,5.
5. Hardware Extensions: Moving the program to a similar machine with a floating point accelerator halved the total runtime.

Finally new system was requiring only one day to simulate 10k objects. Most of the work done by Andrew Appel were visible without writing a single line of code. If your inventions don’t rely on the statistical results to be proved, you should be able to make all decisions without writing a single line of code. Being able to predict the system’s response on paper can make you the the one makes the differences.

Even in professional environments, people tend to start coding as soon as possible. Initial design doesn’t only lead you functional mistakes and a program with tones of bugs, but may blind you to see the problem from different aspects and representing data in a different ways to fasten the system. Only good estimators can code good software. Therefore, I’m not interested in which new fancy technologies you know, far more interested if you have a wide range from top to hardware, able to see the bottlenecks and improve them on paper. Then, any developer can write the code.

1. What is image compression and why do we use it?
2. A short brief of JPEG compression.
3. A review of Google Maps and Live Search Maps for serving images as the primary content.

Introduction to Image Compression

If you understand the term "compression", it doesn’t mean we are over with the definition. Hold on.

Image compression, the art and science of reducing the amount of data required to represent an image, is one of the most useful and commercially successful technologies in the field of digital image processing. (Digital Image Processing 3rd Ed., Gonzalez & Woods, page 525)

Let’s first try to understand how compression became one of the most commercially successful field in image processing? With the irrepressible popularity of television and Internet (after mid-90s), images and videos become significant elements to represent information. With no compression;  a coloured standard TV broadcast, 640×480 wide with refresh rate of 30 frames per seconds, requires 27,648,000 bytes to be transmitted per second. Even in tomorrow’s technology, supplying a connection of almost 30Mbytes/second just for a TV cast doesn’t seem to be possible with no doubt. It’s no surprise to hear many failed quotes back from early 1900s that television will never be able to find opportunity to be on the market.

Data versus Information

When the issue is compression, it refers to the compression of data. Data is being transferred to carry information. Therefore, we might be able to reduce the amount of data to represent a given quantity of information. A parrot in a very populated barber shop in downtown loves to say "Hello" to every new customer that comes in. How would you transmit the words it spells in text most efficiently?

Statistically hello is the most common word. Representing it in a bit is highly acceptable, instead of transferring 5 characters (5*8 = 40 bits). In the example above, it’s very clear that statistics say "stranger" is the second word we most likely to hear from parrot and so on. Converting (mapping) the string array into a bit stream saves 94% of bandwidth in this case. Huffman coding, which is going to remind you the method above, guarantees you to use minimum possible number of bits if you have statistical information of data.

Image Compression Techniques

Generally, image compression techniques are separated into two columns:  lossy and lossless compression. Lossy methods takes the advantage of capabilities of human vision range, eliminates details and loose information to reduce amount of data. Lossy methods are mostly used for natural images. In lossless compression, encoding process finds a smart way to represent same amount of information in lesser amount of data, just like in the example above with Mr. Parrot. And some may use hybrid models to mix advantages of both sides.

JPEG Compression

JPEG is a hybrid compression method, optionally can perform as totally lossless. It mainly depends on the fact that correlation between close pixels doesn’t change much in natural photos. So, we are able to guess closer pixels around if we know the one in the middle. JPEG’s encoding algorithm is separated into four steps:

1. Blocking the image into little pieces, usually 8×8 pixel blocks – some use 16×16 blocks. Separating images into little pieces will help us the guess the nearby pixels.
2. Discrete Cosine Transform (DCT): In "simple" terms, this process generates a bit stream for each block which starts with the average value of the block continuing the details of how pixels change horizontally and vertically. So, as an addition to the guess, we have extra information to fix it. Therefore, DCT is totally lossless. It only represents the same information in other words. Outputs a stream of 64 numerical elements like: 125 34 –32 43 2 21 –43 1 –3 4… (Smart way to represent information)
3. Quantization: Adjusts precision.  This is where we loose information. Output stream may turn into: 125 35 –30 45 0 20 –45 –5 5… (Human vision range is not that sensitive)
4. Entropy encoding: You may encode the stream coming from quantization with Huffman coding to save bandwidth – just like how we did in the parrot example. (Smart way to represent information)

Maps and Compression

Maps serve images as their primary content. Most of the providers have road, aerial, labelled road, labelled aerial, terrain (Google does), bird’s eye (Live Search Maps does) and etc. In this section, I’m going to discuss mostly the aerial imagery and how many bytes they are spreading to share the same amount of information. Both of the providers have road, aerial and aerial (with labels) image sources.

Google Maps (maps.google.com)

Google Maps choose to separate vector and natural images. Encode vectors as transparent PNGs and aerial images as JPEGs. And adds vector information as an overlay if user prefer to view the area with labels.

Image sizes in the corresponding order are: 27.6KB (JPEG), 13.7KB (PNG), 0KB (overlaid versions of 1st and 2nd image), 25.6KB (PNG). In this case, let’s count the bytes Google consumes on the following actions:

1. Road imagery views: 25.6KB
2. A switch to labelled aerial: 27.6KB + 13.7KB = 41.3KB
3. A switch to aerial without labels: cost free
4. Total cost = 25.6KB +  41.3KB = 66.9KB

Google only seems to make an encoding decision depending on the image’s characteristics, JPEG for aerial, PNG for rest. But unfortunately, this leads to the transmission of repeated information of roads on an aerial switch. Take a look at image 2 and 4 above.

I’m guessing most people don’t tend to switch to aerial soon until they zoom in to street level. So, instead of pushing them to download two separate images for on road mode, Google Maps may choose this method. HTTP requests are costly. And a dozen of them are more costly than costly. A map control usually has to download 8-12 tiles depending on your screen resolution. Just think of the overhead that those 12 tiles are generating.

Live Search Maps (maps.live.com)

We are on the same area, somewhere in the downtown London again with Live Search Maps.

Image sizes in the corresponding order are: 28.52KB (JPEG), 29.82KB (JPEG), 25.6KB (PNG). Repeating the same user actions above for a tile:

1. Road imagery views: 25.6KB
2. A switch to labelled aerial: 29.82KB
3. A switch to aerial without labels: 28.52KB
4. Total cost = 25.6KB + 29.82KB + 28.52KB = 83.94KB

If every user were switching between these map modes back and forth on every zoom level, Google Maps would beat LSM with little difference*. Labels on aerial images don’t looks as sharp as Google’s, but keeps size in an appropriate level although it is encoded to be a JPEG. If users switches to non-labelled aerial very rarely, for example after pointing an area they are searching, this method might be practical and more efficient than Google’s overlaying concept.

Above, there are 200% zoomed versions of labelled aerial tiles from San Francisco. The left image comes from Virtual Earth and the other is Google’s. In my own personal opinion I find Google’s labels more readable than Virtual Earth’s, despite being 22-years-old and topping the heap when it comes to sensitivity in vision.

(*) Note: I repeated the process for 100+ random tiles. Ratios don’t seem to change much.

Custom tiles?

What about custom tile integration with Virtual Earth and Google Maps API? Google’s method allows you to overlay roads on your custom maps (didn’t check it, but it’s not a big deal — they already have isolated labels).

Not using the most straight-forward trick to have a private constructor, I decided to invoke an exception from constructor if there exists more than n instances of that particular class. Luckily, I was coding in Java and had the comfort of a managed environment under the belt. My answer wasn’t graded thankfully but this case became a major concern and I decided to make several experiments back in the old days.

According to what I have seen while debugging, Java simply assigns a number of nulls or zeros to all of the fields of the class unless constructor is successfully executed. Additionally, right after an exception is thrown from a constructor, a null reference is returned and the newly created invalid instance starts to wait for the garbage collector to pick it up and remove the useless object from memory permanently. In short terms, a new instance is created although platform tends to murder it quickly in silent.

What about Unmanaged Platforms?

It was nice to see somebody was taking care of such exceptional situations but what would you do if you were alone? Fault tolerance isn’t just catching all exceptions: (from slides of Bjarne Stroustrup)

1. The program must be in a valid state after an exception is caught
2. Resource leaks must be avoided

This will become a problem where memory management is all up to you. You will have to remove and cleanup resources after an exception has been thrown, otherwise it will cause a leakage in memory and you will have created a zombie object hanging around memory — attached to the mother thread.

Cleaning Up the Mess of C++

An object is not even an object once its constructor finished successfully. So, better try to release resources inside the constructor before you throw an exception. In this case, I’m always using a double-exception throwing pattern that I made up and passionately using it in similar situations I face.

Let’s ask the complier! Two lines of code is always more representative than 10 lines of words. Here below, I’ve written a class called “Foo”, not functional but dangerous and an exception “StreamInitException” was decided to be thrown if there happens a problem while longStreamChar is being initialized. Right after we allocate 10k bytes for longStreamChar, BOOM! Someone pushed the wrong button, somebody shut down the database or trouble makers’ spirits are near. Don’t try to catch it inside the constructor and see what happens. Many orphan kids, once we named them as longStreamChar, are all around and we can’t even access them.

#include <iostream>

struct StreamInitException {
    StreamInitException(char * m){ message = m; }
    char * message;
};

class Foo {
    public:
        Foo(){
            try {
                this->initCharStream();
            } catch(StreamInitException * ex) {
                this->~Foo(); //release resources
                throw ex; // exception originally thrown by initCharStream
            }
        }

        ~Foo(){
            if(this->longCharStream)
            delete this->longCharStream;
        }

        void initCharStream(){
            //create a long char array of 10k
            this->longCharStream = (char*)malloc(10000);
            throw new StreamInitException("Error occurred during init.");
        }
    private:
        char * longCharStream;
    };

int main(){

    Foo * foo = NULL;

    try{
        foo = new Foo;
    } catch(StreamInitException * ex){
        std::cout << ex->message << std::endl;
    }

    return 0;

}

Therefore, I’m handling init related bad moments of the object inside the constructor, deallocate memory etc. and re-throw the same exception finally after I get the hold of the control. Seems acceptable!

Consequently, I have a final question: do you prefer to throw an exception from constructors or search for other workarounds such as assigning the workload to a separate method called Init()?

Does anybody have a clue what is happening behind? Because straight forward actions like switching to my own name servers may not help me with the issue at this moment. The new changes might come to a  deadlock on same cycle. Is there anybody out there who knows what’s happening?