Przetestowałem 17 19 przeglądarek pod kątem szybkości interpretowania kodu JavaScript. Użyłem do tego najpopularniejszego benchmarka JavaScript: SunSpider JavaScript Benchmark.

Testy były przeprowadzone w miarę niezmiennym środowisku z domyślnymi ustawieniami przeglądarek i dodatkami, których używam na codzień. Każdy z testów był przeprowadzony dwa razy, a wyniki obliczone na podstawie średniej.

Pod uwagę wziąłem także najnowsze bety najpopularniejszych przeglądarek – w przypadku każdej z nich widać wyraźną poprawę wydajności – co cieszy…

Najpierw wyniki dla systemu Windows XP.

Lp. Przeglądarka Wersja Średnia (ms) Wskaźnik
1. Safari 4 beta 528.16 1225 1
2. Google Chrome 1.0.154.48 1485 1,2
3. Firefox 3.1 beta 3.1b3 2214 1,8
4. Firefox 3 3.0.7 3886 3,2
5. Opera 10 alpha build 1139 4524 3,7
6. Safari 3.1.1 525.17 4850 4
7. Opera 9 9.64 5336 4,4
8. MSIE 8 beta 6001.18372 rc1 7200 5,9
9. MSIE 7 7.0.5730.11 44905 36,6

Legenda:

  • Przeglądarka – nazwa przeglądarki
  • Wersja – wersja przeglądarki
  • Średnia – średnia czasów (w milisekundach) wykonywania testów
  • Wskaźnik – pokazuje ile razy przeglądarka jest wolniejsza od najszybszej w tabeli

Teraz wyniki dla Mac OS X.

Lp. Przeglądarka Wersja Średnia (ms) Wskaźnik
1. Safari 4 beta 5528.16 1203 1
2. Shiira 2.2 build 80118 1498 1,2
3. Chromonium 0.9 7.1.1 1815 1,5
4. Firefox 3.1 beta 3.1b3 1973 1,6
5. Firefox 3 3.0.7 3975 3,2
6. Flock 2 2.0.2 4108 3,4
7. Opera 10 alpha build 6166 6299 5,1
8. Opera 9 9.64 7434 6,1
9. Camino 1.6.6 13793 11,3
10. Firefox 2 2.0.0.18 15939 13,0

I jeszcze uwspólnione dane w jednej tabeli. Dane zostały przeliczone na podstawie uśrednionego wskaźnika (aby były wiarygodne, ponieważ testy dla Mac OS X i Win XP były przeprowadzane na różnej klasy komputerach).

Lp. Przeglądarka Wersja System Średnia (ms) Wskaźnik
1. Safari 4 beta 5528.16 OS X 10.5 1203 1
2. Safari 4 beta 528.16 Win XP 1225 1
3. Google Chrome 1.0.154.48 Win XP 1485 1,2
4. Shiira 2.2 build 80118 OS X 10.5 1498 1,2
5. Chromonium 0.9 7.1.1 OS X 10.5 1815 1,5
6. Firefox 3.1 beta 3.1b3 OS X 10.5 1973 1,6
7. Firefox 3.1 beta 3.1b3 Win XP 2214 1,8
8. Firefox 3 3.0.7 Win XP 3886 3,2
9. Firefox 3 3.0.7 OS X 10.5 3975 3,2
10. Flock 2 2.0.2 OS X 10.5 4108 3,4
11. Opera 10 alpha build 1139 Win XP 4524 3,7
12. Safari 3.1.1 525.17 Win XP 4850 4
13. Opera 9 9.64 Win XP 5336 4,4
14. Opera 10 alpha build 6166 OS X 10.5 6299 5,1
15. MSIE 8 beta 6001.18372 rc1 Win XP 7200 5,9
16. Opera 9 9.64 OS X 10.5 7434 6,1
17. Camino 1.6.6 OS X 10.5 13793 11,3
18. Firefox 2 2.0.0.18 OS X 10.5 15939 13,0
19. MSIE 7 7.0.5730.11 Win XP 44905 36,6

Myślę, że dane mówią same za siebie, a komentarz jest zbędny. Zastanawiające jest to, że Apple potrafi zrobić najszybszą przeglądarkę na swój system i system konkurencji, natomiast Microsoft sobie nie poradził jak trzeba.

Napawające optymizmem są wyniki wersji beta przeglądarek – widać, że deweloperzy przykadają do szybkości dużą wagę.

Czy w firmie, w której pracujesz jest dział testerów? Jeżeli jesteś z Polski, to jest bardzo duże prawdopodobieństwo, że takiego działu nie masz. Co dziwniejsze jeszcze, że im większa i poważniejsza firma, tym mniejsze szanse na istnienie działu testerów! A to dziwne!

Poniżej prezentuję 5 najbardziej prawdopodobnych powodów, dla którego w firmie, w której pracujesz nie ma działu testerów, razem z komentarzem. Powody i uzasadnienia pochodzą w dużej mierze ze świetnego artykułu Joela Spolskyego (Top Five (Wrong) Reasons You Don’t Have Testers).

Więc zaczynamy.

1. Błedy w oprogramowaniu wynikają z lenistwa programistów.

“Zatrudnienie testerów w naszej firmie spowoduje, że programiści przestaną sami testować to co tworzą i w kodzie będzie więcej błędów” – Mogło by się wydawać… Błędy w oprogramowaniu (bugi) powstają w kodzie w związku z tym, że programista ich z jakiegoś powodu nie zauważył. Programista to też człowiek, a nie ma ludzi nieomylnych. Najczęściej wystarczy, aby druga osoba spojrzała na kod/produkt aby wyłapać większość błędów. Często zdarzają się sytuacje w których coś, działające na 100% u programisty nie działa u testera. Podczas konfrontacji okazuje się, że testerka podczas rejestracji w przykładowym systemie wybierała inną płeć niż programista co w efekcie implikowało różnice.

2. Moje oprogramowanie jest dostępne on-line. Mogę naprawiać błędy od ręki.

Mogłoby się wydawać… Prawdą jest, że wprowadzanie poprawek w systemach będących on-line jest z jednej strony nieco łatwiejsze niż w przypadku aplikacji desktopowych, jednak z drugiej jest znacznie trudniejsze, ponieważ działamy na żyjącym organizmie, w momencie kiedy wprowadzamy poprawki, użytkownicy korzystają z naszej aplikacji, używają naszego serwisu. Takie poprawki “na szybko”, najczęściej wykluczają przeprowadzenie testów regresywnych i bardzo często prowadzą do stworzenia kolejnych błędów. Błędy takie są widoczne od razu dla użytkowników, co zmniejsza ich satysfakcję i prowadzi do punktu następnego:

3. Użytkownicy przetestują mi oprogramowanie.

Nie powinno się tak nawet nikomu wydawać… Z takim podejściem nie wróżę sukcesu. Jeżeli coś użytkownikowi przestaje działać – idzie do konkurencji – to w najlepszym przypadku. W gorszym, idzie do konkurencji i zaczyna rozpowiadać o naszej firmie brzydkie rzeczy, co powoduje zmniejszenie przypływu nowych użytkowników, bądź utratę większej ilości aktualnych. W jeszcze gorszym przypadku, użytkownik podczas korzystania z naszej aplikacji traci swoje dane (jakąś swoją pracę), lub jego dane osobowe zostają np. przypadkowo wysłane mailem do 100000 innych użytkowników co prowadzi do sprawy w sądzie i innych kłopotów – a tego nie chcemy. Specjalnym przypadkiem są tutaj beta-użytkownicy – jednak jest to specjalnie wyselekcjonowana grupa użytkowników, którzy świadomie podejmują pracę na niefinalnej wersji oprogramowania.

4. Nikt z odpowiednimi kwalifikacjami nie chce pracować jako tester.

Nie jest to do końca prawdą. Z jednej strony trudno jest o dobrego testera. Z drugiej jednak testy funkcjonalne nie wymagają wysokich kwalifikacji. Najlepszymi testerami funkcjonalności, są ludzie nie związani bezpośrednio z IT, warto pomyśleć o zatrudnieniu studentów kierunków humanistycznych, którzy są w stanie znaleźć bardzo dużo problemów w tworzonym przez nas oprogramowaniu.

Jest prawdą natomiast, że trudno o pracowników potrafiących uruchamiać i przeprowadzać testy jednostkowe oraz inne testy wymagające znajomości specjalistycznego oprogramowania, platform i języków skryptowych. Z drugiej strony jednak sam znam kilku dobrych testerów, którzy bardzo chętnie będą kontynuować swoją karierę jako testerzy.

Ostatni z powodów, najpopularniejszy i najbardziej bzdurny:

5. Nie stać mnie na testerów.

I jednocześnie najłatwiejszy do obalenia. Testerami w firmie mogą być praktykanci, studenci odbywający praktyki oraz np. uczniowie szkół ponadpodstawowych za niewielkie pieniądze. Ile testerzy by nie kosztowali – zawsze są tańsi niż programiści (mówimy o testerach funkcjonalności, a nie np. specjalistów od przeprowadzania testów użyteczności). Nie opłaca się, aby programiści poświęcali swój czas na testowanie, skoro w tym czasie mogą poprawiać błędy, oraz rozwijać oprogramowanie.

W początkowym stadium “zespołu testowego” warto prowadzić rekrutację, mimo kompletu testerów, i szybko wymieniać tych, którzy nie nadają się na testerów. Poza tym średnio tester pracuje na swoim stanowisku ok. 3-4 miesięcy, więc rotacja w takim zespole jest spora.

Nie warto jednak proponować swoim przyszłym programistom stanowisko testera na czas “wdrożenia”, ponieważ mogą znudzić się zadaniami testowymi i możemy stracić dobrego programistę.

Dodatkową opcją są agencje pracy tymczasowej i pracy dla młodzieży (np. http://www.timework.pl), gdzie za niewielkie pieniądze można zatrudnić młodych ludzi do prostych prac.