Zapewne zauważyliście, że ubiegłe 12 miesięcy było pełne artykułów o community i pochodnych. Przywołując na chwilę nomenklaturę serialową – byliście świadkami sezonu o społeczności front-end. Mimo że tekstów technicznych pojawiło się niewiele, to nie żałuję tego. Udało się wywołać kilka bardzo pozytywnych przemian i ruchów oraz scementować to, co zaczęło się w 2010 w postaci darmowych szkoleń i konferencji Front-Trends.

W 2011 zapoczątkowałem spotkania meet.js, z czego jestem najbardziej dumny. Dziś idea darmowych meetupów front-endowych działa prężnie w 4 miastach (Poznań, Warszawa, Kraków, Wrocław), a w kolejce czekają następne dwa i tylko kwestią czasu jest, kiedy od nieśmiałego flirtu przejdziemy do czegoś poważniejszego. Wisienką na torcie był meet.js Summit – pierwsza darmowa konferencja o front-endzie, która pokazała, że warto przychodzić na konferencje, ale i też być ich aktywnym uczestnikiem. Wielu jej prelegentów jeszcze niedawno drżało na myśl o pierwszym występie przed większą publicznością. Dziś wręcz palą się do kolejnych prelekcji. Z nadzieją będę wypatrywał ich na zagranicznych scenach. Już dzisiaj pojawiają się na nich (lub dopiero pojawią): Maciej Małecki, Michał Budzyński czy Kamil Trebunia.

Na Summicie pokazaliśmy również sponsorom, że na takie wydarzenia przychodzi mnóstwo osób – i to nieprzypadkowych. Konferencje to doskonałe miejsce, by spotkać utalentowanych ludzi, którzy stale chcą się rozwijać i poszukują najświeższej wiedzy. Dzięki wsparciu firm takich jak Mozilla, Allegro czy Cognifide, odczuwam satysfakcję, że za tę cenę (a w zasadzie jej brak) zbliżyliśmy się do poziomu niektórych komercyjnych eventów tego typu.

Gdyby spytać mnie o mój prywatny ranking, to chyba najciekawszym wydarzeniem lokalnych meet.js była prezentacja Bartosza Szopki o CSS 3D i impress.js, który bije rekordy popularności. Tak, ten event powstał właśnie po to, by tacy magicy jak Bartosz mogli pokazać jak świetną robotę odwalają. Również Krzysztof Szafranek na Summicie pokazał się z dobrej strony i czekam na więcej na innych konferencjach.

W 2011 z Pawłem Czerskim zrobiliśmy również pierwszą edycję Falsy Values – warsztatów i konferencji o JavaScript. Wydaje nam się, że w tej części Europy potrzebne są dobre warsztaty tematyczne i będziemy kontynuować to wydarzenie, choć być może dopiero za rok. Przy okazji czapki z głów dla Pawła – podejście do detali i kreatywność jakie prezentuje, przyczyniła się w dużej mierze do sukcesu eventu. Sama nazwa była moim zdaniem strzałem w dziesiątkę. Cieszę się, że mogę współpracować z takimi utalentowanymi ludźmi.

Właśnie, o ludziach było tutaj mnóstwo. Poczułem się w obowiązku przeznaczyć im skromne łamy mojego bloga, bo miałem mocne przekonanie, że wielu zdolnych front-endowców w naszym kraju po prostu w tej branży nie widać. Powstała więc seria o Ludziach Front-endu z PorneLem, Marcoosem, Kacprem, Piotrem Zalewą oraz AKAI i kilka wpisów zachęcających do wzięcia się za front-end na poważnie.

Jeśli chodzi o teksty, to chyba najbardziej dumny jestem z artykułu „Stan społeczności front-end w Polsce w dobie HTML5″. Dużo pracy, ale i wielka satysfakcja z tego, że udało się przedstawić to, czym żyje obecnie polski front-end. A było tego sporo.

Bo tak naprawdę mamy wielu interesujących ludzi w tej naszej branży. Poznałem ich w 2011 dziesiątki, a może setki. Wielu z nich jestem wdzięczny za ciepłe słowa w stosunku do pracy, jaką wykonuje – nawet nie wiecie, jak fajnie jest usłyszeć na jakimś evencie o tym, że ktoś nauczył się JavaScriptu z moich materiałów.

Dziś mogę powiedzieć, że mam wielu znajomych ze sceny front-end. Chyba najlepsze, biorąc pod uwagę towarzyską część konferencji, było Front Row – tam pierwszy raz udało się zamienić słowo z wieloma postaciami z Krakowa, który jest dla mnie swoistą stolicą polskiego fornt-endu (choć o to miano walczy też dzielnie Poznań). Wcześniej, na konferencjach, które organizowałem jakoś nie było do tego sposobności.

Tutaj pojawia się też wątek JSNews.pl. Uruchomiliśmy ten portal z założeniem przekazywania ciekawych informacji o front-endzie i JavaScript. Niestety polegliśmy, jeśli chodzi o wolny czas dla tego projektu. Nie ma jednak tego złego, co by na dobre nie wyszło. JSNews przeistoczyło się w grupę na Facebooku, gdzie obecnie zapisanych jest prawie 400 developerów. Codziennie toczymy zażarte, ale i dowcipne dyskusje o JavaScripcie i podobnych. Momentem przełomowym związanym z tą grupą było spotkanie meet.js Weekend w Poznaniu – przyjechało na nie kilkanaście osób, poznaliśmy się dobrze, a historie z nim związane będą pamiętane jeszcze bardzo długo.

Na blogu pojawiły się również konkursy. Brawa dla Autentiki, która przetarła szlak i zorganizowała dla Was pierwszy taki konkurs z nagrodami.

Z ciekawych faktów związanych z poprzednim rokiem, kupiłem JavaScript.pl z zamiarem oczyszczenia tej domeny z niezwiązanej z tematyką treści. Jeśli chodzi o prywatne sprawy, jestem bardzo zadowolony, że mogłem pomóc kilku osobom – przede wszystkim wielu z nich znalazło pracę po moim poleceniu. Odczuwam z tego powodu dużą satysfakcję. Fajnie też, że pojawił się ze mną wywiad na mamstartup.pl.

Co do spraw technicznych – w roku 2012 mam zamiar przypomnieć się ludziom, że potrafię jeszcze tworzyć interesujące projekty – choć głosowy Debugger był według mnie ciekawym eksperymentem. Pierwsza połowa roku powinna być pod tym względem niezmiernie ekscytująca. W 2011 roku zaś opublikowałem 3 prezentacje – o ECMAScript 5, o HTML5 i CSS3 i JavaScript: Make the right choices. Ta pierwsza ma już ponad osiem tysięcy wyświetleń! Było mi też dane dać prelekcję na Hackfeście w Poznaniu! Przeprowadziłem również kilka komercyjnych szkoleń dla największych firm IT w Polsce i muszę stwierdzić, że bardzo podoba mi się taka forma spędzania czasu. Praca z ludźmi jest o wiele ciekawsza niż kodowanie, choć to temat na inny artykuł.

W roku 2011 było też kilkadziesiąt/kilkaset maili bez odpowiedzi – niestety nie jestem już w stanie odpowiadać na wszystkie. Nie udzielam również pomocy ze skryptami, choćbym chciał, to niestety żyję za coś innego. Wydaje mi się, że nastał moment w moim życiu na lepsze zorganizowanie swojego czasu – biorę na siebie ostatnio o wiele za dużo, choć lubię się sprawdzać w nowych rzeczach.

Każdy rok definiuje u mnie lista pomysłów do zrealizowania. Jeśli takich nie będę miał, mogę powiedzieć, że dany rok będzie nudny. Co do 2012 jest przeciwnie – jest ich sporo, wiele wyklarowało się pod koniec roku 2011, dlatego z nadzieją spoglądam w przyszłość. Oby udało się zrealizować wszystkie z nich!

Twitter

Przypominam, że najświeższe informacje o konferencji znajdziecie na Twitterze: @falsyvalues. Oficjalny hashtag konferencji: #falsyvalues.

Workshopy

Najważniejsza informacja – należy przynieść ze sobą laptopa!

Miejsce

Workshopy zlokalizowane będą przy Al. Jana Pawła II 27 w siedzibie Golden Floor (należy szukać głównego wejścia naprzeciwko Hali Mirowskiej przy Coffee Heaven). Planujemy również oznaczyć to miejsce bannerami.

Konferencja odbędzie się w Kinie Femina w sali C. Do naszej dyspozycji są dwa piętra na lunch i przerwy kawowe, być może również zaplecze za salą (szczególnie ważne dla palaczy ;-))

Rejestracja każdego dnia rozpoczyna się od 8 rano. Workshopy, jak i konferencja trwają od 9 do 17. Aby ułatwić nam zadanie, fajnie byłoby, gdybyście przyszli z wydrukowanymi biletami.

Z ciekawostek, jeśli ktoś poczułby potrzebę – przy venue workshopów jest wspomniane Coffee Heaven, natomiast naprzeciwko Kina Femina – Starbucks oraz KFC.

Impreza

W czwartek od 19 w klubie Rabarbar w Warszawie odbędzie się główna konferencyjna impreza dzięki firmie Pusher – tzw. Pusher Party! Uczestniczyć w niej będzie mógł każdy – jeśli kupiłeś bilet tylko na dzień konferencji nie ma problemu, przyjdź z biletem i rozkoszuj się darmowymi drinkami i przekąskami od naszych sponsorów. Z Golden Floor do Rabarbaru jest tylko kilka przystanków tramwajowych!

Jeszcze raz wielkie dzięki dla sponsorów: Mozilli, Nokii, DevMeetings, Pushera oraz Gadu-Gadu!

I tak, skromny prezent od Ferrante, a mianowicie wejściówkę na dzień konferencji Falsy Values (piątek 20 maja) dostają:

• pim
• Tomasz Kowalczyk
• procek
• Vokiel
• sher
• czarodziejmarx
• zx
• ludwik

Do zobaczenia!

Niniejszym chciałbym podziękować jeszcze raz Mozilli, dzięki której w tym roku możemy rozdać o wiele więcej wejściówek! Jesteście świetni!

Powiem szczerze, że miałem duży dylemat pomiędzy jeszcze jedną pracą. Generalnie, co zadecydowało to mała wielkość kodu, brak nadmiarowych klas czy tagów i jeden szczegół – obecność wrappera na wszelki wypadek. Ten css jest po prostu dobrze napisany i działa. A propos – na stronie Opery możecie przetestować go pod Operą Mini.

Punktowaliśmy przede wszystkim to, czy używacie najświeższych ficzerów CSS3. Tak więc można było użyć przede wszystkim dwóch rzeczy: display: box oraz calc. Potem było działanie na urządzeniach mobilnych – wiele przysłanych rozwiązań tego nie wspierało. Liczyła się też schludność kodu. Jeśli ktoś dodawał mnóstwo niepotrzebnych id to był oceniany niżej (to musiało być jednym z kryteriów z powodu wąskiej tematyki, mimo że identyfikatory nic nie robiły). Było też jedno rozwiązanie na table-cell oraz różne kombinowanie z marginesami czy z position.

Jeszcze raz przepraszam za opóźnienie. Ostatnio wróciłem do szkoleń z JS, pracuje też nad wieloma rzeczami naraz, co w połączeniu dało taki a nie inny efekt. Niemniej, chciałbym podziękować za kilkanaście rozwiązań. Większość z nich była na wysokim poziomie, chociaż pojawiło się kilka na podstawie float – zachęcam ich autorów do sprawdzenia nowości.

Oto najszybszy kod jego autorstwa:

/**
 * Funkcja rozwiązująca zadanie konkursowe
 *
 * @version 201103061820
 * @author Yann Kowalsky
 * @param array input Jednowymiarowa, posortowana rosnąco tablica unikalnych
 * liczb całkowitych.
 * @return array Tablica z niepowtarzającymi się liczbami dodatnimi, których
 * wartość absolutna pojawiła się w tablicy dwa razy.
 */
window.solve = function(input) {
	var output = [];
	var length = input.length;
	var a, b; // "cache"

	// iteruje tablicę input od początku i od końca, porównując kolejno
	// wartość bezwzględną elementów
	for (
		var i = 0, j = ~- length, a = - input[0];
		(a = - input[i]) > 0;
		++ i
	) {
		// mały boost - po pierwsze zatrzymaj się tu, bo i tak nie spotkasz
		// wartości równych, po drugie - j przy następnym przebiegu pętli for
		// będzie startowało od ostatniej wartości, a nie od początku
		while (a < (b = input[j])) {
			-- j;
		}

		// wartość bezwględna taka sama
		if (a == b) {
			output[output.length] = b;
			// output[output.length] szybsze od output.push()...
			-- j;
		}
	}

	return output;
}

Kilka słów na temat rozwiązań. Przede wszystkim należało użyć algorytmu nie korzystającego z pomocniczych struktur. Kilka algorytmów odpadło też ze względu na modyfikację tablicy z wejścia np. input.pop();. Najczęstszym rozwiązaniem z kolei była iteracja po tablicy dwa razy w celu sprawdzenia ponownego wystąpienia liczby, co nie jest najbardziej wydajnym sposobem (2n do n^2).

Warto też powiedzieć, że JavaScript ma nieco inne właściwości niż choćby C++. Tu liczy się każda operacja. Dostałem bardzo oryginalne rozwiązanie oparte na wyszukiwaniu binarnym:

    var solve = function(arr){
        /*
            performs binary search on given array
            runs in log(n) where n is amount of elements in array
            @parameters:
                val       - searched value
                arr       - array where we seach, must be sorted in ascending order
                startLow  - optional, specifies starting low index of area of array where to perform search, defaults to 0
                startHigh - optional, specifies ending index of area in array where to search for given element,
                            defaults to arr.length - 1

            @returns:
                if searched value is in array, returns index of searched element in given array range which is >= 0
                if searched value is not in given array, returned value is < 0, and is equal to (last checked index + 1) * (-1)
        */
        var binSearch = function(val, arr, startLow, startHigh){
            var stopFnct = function(low, high){ return low > high;};
            var foundFnct = function(arr, idx, val){ return arr[idx] == val;};
            var _newBinSearchFnct = function(val, arr, startLow, startHigh){
                return _binSearch(val, arr, startLow, startHigh, stopFnct, foundFnct);
            }
            binSearch = _newBinSearchFnct;
            return binSearch.apply(null, arguments);
        }

        /*
            searches for the index of oelement in sorted array so that searched element value is <= val and next element's
            value in array is greater than val (>val)
            for example:
                >>>  diviseSearch(3, [1, 2, 3, 4, 5])
                2
                >>> diviseSearch (3, [1, 2, 4, 5])
                1

            runs in log(n) where n is amount of elements in array

            @parameters:
                val       - value that should divide array
                arr       - array where we seach, must be sorted in ascending order
                startLow  - optional, specifies starting low index of area of array where to perform search, defaults to 0
                startHigh - optional, specifies ending index of area in array where to search for given element,
                            defaults to arr.length - 1

            @returns:
                if searched value is in array, returns value >= 0 which represents index of searched element in given array range
                if searched value is not in given array then funciton returns -1
        */
        var diviseSearch = function(val, arr, startLow, startHigh){
            var stopFnct = function(low, high){ return low > high;};
            var foundFnct = function(arr, idx, val){ return arr[idx] <= val && arr[idx + 1]>val;};
            var _newDiviseSearch = function(val, arr, startLow, startHigh){
                //M3 return _binSearch(val, arr, startLow, startHigh, stopFnct, foundFnct);
                var res = _binSearch(val, arr, startLow, startHigh, stopFnct, foundFnct);
                if(res<0){
                    return -(++res);
                } else {
                    return -1;
                }
            }
            diviseSearch = _newDiviseSearch;
            return diviseSearch.apply(null, arguments);
        }

        /*
            It performs binary search with custom function which checks whether proper index is found.

            Searches for value of index pointing to element in given array in the way so that the minimal amount of index changes
            would be required so that given function would succeed on changed index value. Assumes that:

                IF idx1 < idx2 AND solution isn't found in idx1 THEN
                for all idx3, so that idx3 < idx1, the solution for idx isn't found either
            AND
                IF idx1 > idx2 AND solution isn't found in idx1 THEN
                for all idx3, so that idx3 > idx1, the solution for idx isn't found either

            @parameters:
                val       - value that will be passed to foundFnct, it's meaning depends on foundFnct
                arr       - array where we seach, must be sorted in ascending order
                startLow  - optional, specifies starting low index of area of array where to perform search, defaults to 0
                startHigh - optional, specifies ending index of area in array where to search for given element,
                            defaults to arr.length - 1
                foundFnct - function that gets arguments: arr, idx, val. Meninng of these arguments is as follows:
                                arr - array where search is performed
                                idx - index that we ask if it may be the solution
                                val - value passed by the user
                            it should on the basis of given arguments determine whether currently checked index is solution
                            or not
                stopFnct  - function that takes two arguments: low, high. Mening of these arguments is as follows:
                                low - the lower index of the area in the searched array,
                                high - the upper index of the area in the searched array
                            on the basis of given arguments, it should determine whether to stop for searching
                extra_params - not used, but may be extended further for returning extra data (extra_params may be
                               passed as reference to object, and on that object will be added extra information about search (e.g.
                               checked indexes, checked values etc.)

            @returns:
                if returned value is < 0, then it's absoulte value represents ((index of array where foundFnct succeed) + 1)
                if returned value is >= 0, then it represents last checked index

        */
        var _binSearch = function(val, arr, startLow, startHigh, stopFnct, foundFnct, extra_params ){
            var length = arr.length,
            low = startLow || 0,
            high = startHigh || length - 1,
            idx, last_idx;

            for(var floor = Math.floor;;){
                idx = (high + low) / 2; //calculate middle index
                idx = floor(idx);
                last_idx = idx;

                // in the if-else block below, on the first position should be checking
                // whether foundFnct succeed, because foundFnct may succeed if arr[idx] < val or arr[idx] > val
                if(foundFnct(arr, idx, val)){
                    return -(idx + 1);
                } else if(arr[idx] > val){
                    high = --idx;
                } else { // arr[idx] < val
                    low = ++idx;
                }

                if(stopFnct(low, high))
                    return last_idx;
            }
        };

        var do_solve = function(arr){
            var swap = function(){
                var old_sLow = sLow, old_sHigh = sHigh, old_sIdx = sIdx;
                sLow = hLow, sHigh = hHigh, sIdx = hIdx;
                hLow = old_sLow, hHigh = old_sHigh, hIdx = old_sIdx;
            }

            var ret = [],
            length = arr.length,
            divIdx = diviseSearch(0, arr),
            midEl = arr[divIdx];

            if(divIdx === -1)
                return [];

            var smaller_amount = divIdx;// calculate amount of negative and positive elements in array
            if(midEl != 0)
                smaller_amount += 1;
            var higher_amount = length - smaller_amount,
            sLow = 0, sHigh = divIdx, sIdx,
            hLow = divIdx + 1 , hHigh = length - 1, hIdx;
            if(midEl == 0)
                sHigh--;

            if(smaller_amount == 0 || higher_amount == 0)
                return [];

            if(higher_amount < smaller_amount)
                swap();

            var searched, res, toAdd,
            ret = new Array(Math.ceil(length/2)),
            retCount = 0;
            for(var i=sLow, abs = Math.abs; i<=sHigh; i++){
                searched = -arr[i];
                res = binSearch(searched, arr, hLow, hHigh);
                if(res < 0){
                    res *= -1;
                    res -= 2;
                    ret[retCount++] = abs(searched);
                    hHigh=res;
                }else{
                    hHigh=res;
                    if(hLow == hHigh)
                        break;
                }
            }

            return ret.slice(0, retCount);
        }

        solve = do_solve;
        return solve.apply(null, arguments);
    }

Okazało się jednak, że to przerost formy nad treścią.

Z innych ciekawych rozwiązań:

function solve(i){return(i+'').match(/-(\d+)(?=.*?,\1\b)/g).map(Math.abs)}

Zamiana tablicy na stringa i potem wyszukanie powtarzających się wartości. Sprytne, niestety dość wolne.

Inny bardzo JavaScriptowy kod to:

function solve(arr) {
    return arr.filter(function(v,i,a){ return a.indexOf(-v) !== -1 && v>0; });
}

Korzysta z dobrodziejstw JS 1.6+, niestety jest dość wolny.

Warto też wkleić kod szybkich rozwiązanń: HrynKa:

/**
 * funkcja realizujaca zadanie konkursowe z http://ferrante.pl/2011/03/02/wygraj-ksiazki-o-javascript-i-html5/
 *
 * Algorytm opiera sie na iteracji tablicy z obu koncow. Pozycja w tablicy przesuwana jest na kolejna (ku liczbom o
 * mniejszych wartosciach bezwzglednych) z tej strony, z ktorej wartosc bezwzgledna liczby pod dana pozycja jest
 * wieksza. Dojscie do zera, z ktorejkolwiek strony, konczy dzialanie.
 *
 * @author Maciej "HryneK" Hryniewicz

 * @param array data posortowane rosnaco unikalne liczby calkowite
 * @return array liczby dodatnie, ktorych wartosc absolutna pojawila sie dwukrotnie w tablicy wejsciowej
 */
window.solve = function (data) {
	var ans = [], // dane wyjsciowe
		ans_len = 0, // ilosc elementow w tablicy wyjsciowej - dla recznej realizacji .push()
		idx_a = 0, // "lewa" pozycja w tablicy
		idx_b = data.length - 1, // "prawa" pozycja w tablicy
		a, // wartosc bezwzgledna "lewej" liczby
		b; // wartosc bezwzgledna "prawej" liczby

	if (idx_b < 1) {
		// w tablicy wejsciowej sa mniej niz dwa elementy
		return [];
	}

	a = -data[idx_a], // na razie zakladamy, ze liczba jest ujemna
	b = data[idx_b]; // na razie zakladamy, ze liczba jest dodatnia

	if (a <= 0 || b <= 0) {
		// w danych wejsciowych nie ma dodatnich i ujemnych wartosci - wynik jest pusty
		return [];
	}

	while (true) {
		while (a > b) {
			if ((a = -data[++idx_a]) <= 0) {
				return ans;
			}
		}
		while (a < b) {
			if ((b = data[--idx_b]) <= 0) {
				return ans;
			}
		}
		if (a == b) {
			// @todo jak .push() przyspieszy, to podmienic i usunac komentarze
			ans[ans_len++] = b; // szybsze niz .push()

			// bierzemy kolejna "prawa" liczbe (mozna byloby brac nastepna lewa - w zaleznosci, czy
			// spodziewamy sie miec wiecej ujemnych czy dodatnich liczb w danych wejsciowych)
			if ((b = data[--idx_b]) <= 0) {
				return ans;
			}
		}
		// wartosci bezwzgledne nie sa rowne, wiec znowu "lewa" jest wieksza - zaczynamy kolejny obieg
	}
}

Piotrka Koszulińskiego:

var solve = function(input) {
 var a = 0,
	  b = input.length - 1,
	  av, bv, output = [];

 if (b < 1) return [];

 av = Math.abs(input[0]);
 bv = Math.abs(input[b]);

 while (a < b) {
  if (av > bv) {
	av = Math.abs(input[++a]);
  }
  else if (av < bv) {
	bv = Math.abs(input[--b]);
  }
  else {
	output[output.length] = av;
	av = Math.abs(input[++a]);
	bv = Math.abs(input[--b]);
  }
 }

 return output;
};

Czy Przemka Ciężkowskiego:

window.solve = function (input) {
	 var output = [], length = input.length;
	 if (length > 1){
				var l = 0, r = length - 1, abs = Math.abs, tmp1 = abs(input[l]),
tmp2 = abs(input[r]);
				do{
						  if (tmp1 > tmp2){
									 tmp1 = abs(input[++l]);
						  }else if (tmp1 < tmp2){
									 tmp2 = abs(input[--r]);
						  }else{
									 output[output.length] = tmp1;
									 tmp1 = abs(input[++l]);
									 tmp2 = abs(input[--r]);
						  }
				}while (l < r);
	 }
	 return output;
};

A oto zestaw danych, na którym testowaliśmy:

var testArr = [];
var testArr2 = [];
var testArr3 = [];
var testArr4 = [];
var testArr5 = [];
var testArr6 = [];

for (var i = -10; i < 10; i++) {
	testArr.push(i);
}

for (var i = -100; i < 100; i++) {
	 testArr2.push(i);
}

for (var i = -500; i < 100; i++) {
	testArr3.push(i);
}

for (var i = -10000; i < 10000; i++) {
	testArr4.push(i * 2);
}

for (var i = -50000; i < 50000; i++) {
	testArr5.push(i);
}

for (var i = -3000000; i < 3000000; i++) {
	if (Math.random() > 0.5) {
		testArr6.push(i);
 	}
}

Oczywiście w grę wchodziły również styl i długość kodu. Co się jednak okazało, najszybszy kod był jednym z najkrótszych i bardzo dobrze napisanych. Gratulujemy zwycięzcy!

Przy okazji konkurs okazał się dużym sukcesem – oto statystyki wpisu o nim:

Oto prezentacja:

Możecie również ocenić moje „wystąpienie” na Speakerrate.com.

Jestem dość zadowolony z jego przebiegu, ale mam też świadomość, że nie uniknąłem kilku problemów technicznych, które pewnie będą widoczne w materiale filmowym, jaki postaramy się wkrótce opublikować. W każdym razie, prezentacja miała być bardzo poglądowa i nie skupiać się na szczegółach. Mam nadzieję, że to się udało i choć część osób sprawdzi uważniej, jakie ficzery niosą za sobą słówka HTML5 oraz CSS3.

Zapraszam również na JSNews.pl, gdzie trochę wiecej info o przyszłości meet.js.

Prelegenci:

- Zbyszek Tenerowicz (jquerymobiledictionary.dyndns.org) – o jQuery Mobile
- Krzysztof Szafranek (Nokia, szafranek.net) – o silniku fizycznym Box2d w JavaScript
- Kamil Trebunia (Zynga) – o audio w HTML5
- Rafał Kukawski (Nokia, kukawski.pl) – o Indexed DB API
- Damian Wielgosik (ferrante.pl) – „od jQuery do HTML5 i CSS3″

Nieco więcej o spotkaniu na JSNews.pl.

Jeśli piszę o sprawach prywatnych, to prawie zawsze mają one jakiś związek z technologiami. Nie inaczej spróbuję podsumować rok 2010.

Trzeba przyznać, że zaczął się intensywnie, serią trzech szkoleń z zaawansowanego JavaScriptu, poznaniem mnóstwa ciekawych ludzi, ale przede wszystkim jako takim sprostaniu publicznym występom. Całość zaaowocowała Just Advanced JavaScript, ściągawce z języka, która ma dziś prawie 6 tysięcy wyświetleń. Szczerze powiedziawszy żałuję nieco tej nazwy, powinna być nieco bardziej wyrafinowana, tym bardziej, że często słowo zaawansowany mógłby zastąpić rzeczownik osobliwości języka. Niemniej udało się osiągnąć namiastkę czegoś, do czego dążę od kilku lat – książki o JavaScript. W roku 2011 chciałbym nieco poważniej podejść do tego tematu, bo nieco ustabilizowałem czasowo swoje życie zawodowe.

Właśnie, rok 2010 to ostateczne pogodzenie się z faktem, że korporacje nie sprzyjają — przynajmniej mi — rozwojowi i realizowaniu pomysłów. Szukając swego miejsca (chyba trafiło mnie też lekkie wypalenie), opuściłem po 1,5 roku kontraktu Nokię na rzecz pracy zdalnej z jednymi z moich idoli jakimi są Peter Michaux oraz Garrett Smith. Teraz to ja ustalam, gdzie i kiedy chcę pracować. Koniec ze służalczymi 40 godzinami tygodniowo. Po drodze było też kilka innych interview, z których powstało parę pomysłów na notki, czekających w kolejce do napisania. Między innymi o tym, że łatwiej dostać się do korporacji, niż do startupu. Co tylko dobrze świadczy o startupach.

Jeśli mogę też Wam coś doradzić, wyjedźcie, poznajcie inne kraje, innych programistów. Zdobywajcie doświadczenie. W Polsce na naprawdę godnych, europejskich warunkach (pensja, komfort pracy, know-how) pracuje się jedynie w Roche Polska i kilku innych firmach, o których tylko słyszałem. Jest ich niewiele, więc jeśli nie chcecie zostać przeciętniakami, rozejrzyjcie się dookoła. Świat stoi przed nami otworem.

Kontynuując, w poprzednim roku udało się również doprowadzić do końca konferencję Front-Trends, z czego jestem bardzo zadowolony, ponieważ spełniło się jedno z moich marzeń. Z drugiej strony, nie wszystko pod względem organizacyjnym było perfekcyjne, aczkolwiek Christian Heilmann wystawił nam dość wysoką notę. Liczę, że uda się zorganizować następną edycję, pozbywając się znanych nam usterek.

W 2011 roku planujemy z Pawłem Czerskim także Falsy Values – prawdziwą, 100% konferencję o JavaScripcie, opartą w dużej mierze o mnóstwo workshopów z ludźmi, którzy znają się na swoim fachu. Będę też ja ze swoimi dwoma workshopami z podstaw JavaScriptu, aczkolwiek nie wiem, czy to zdanie nie kontrastuje za bardzo z poprzednim…

Co do front-endu jako takiego, w 2011 mam zamiar rozruszać naszą skostniałą scenę front-endu, aczkolwiek wiem, że będzie ciężko. Pierwszym krokiem do celu jest JSNews Meetup. Chciałbym, by idea ta rozpowszechniła się w innych miastach, jak na razie jednak pozostaje osobiście podłożyć fundamenty pod to, miejmy nadzieje, fajne spotkanie. 2010 pokazał, że tkwi w nas potencjał. Pisząc te słowa, o ironio, właśnie przerwał mi mój znajomy, zagadując na komunikatorze:

kurde
za duzo sie w tym js dzieje
moglbym non stop ogladac nowe demka/patrzec w kod/czytac newsy
i jakies githuby

Wszystko wskazuje na to, że rok 2011 to kolejny okres dominacji JavaScriptu, a przecież już w 2010 było bardzo dobrze. W związku z tym, w minionym roku odpaliliśmy nawet JSNews.pl. W roku 2011 prawdopodobnie czeka nas reorganizacja sposobu przekazywania treści, ponieważ nadal szukamy najbardziej optymalnej dla nas metody publikacji.

Rok 2010 to dla mnie także bolesne przekonanie, że niewielu jest grafików-freelancerów, którzy swoją pracę traktują serio. Tym śmieszniejsze są dla mnie artykuły w Wyborczej o oczekiwaniu na przelewy. W 2010 ogólnie długo czekałem — najdłużej na oddanie spóźnionych prac przez grafików lub w ogóle na jakikolwiek kontakt.

Podsumowując jednak, 2010 to najintensywniejszy dla mnie rok w całym moim życiu. Jestem z niego zadowolony, jednak mam przeczucie, że będą jeszcze lepsze i jestem gotów do działania, ponieważ w kolejce czeka mnóstwo pomysłów. Życzę więc sobie i Wam udanego Nowego Roku!

Niniejszym chciałbym podziękować też personalnie osobom, z którymi współpracowałem oraz tym, którzy najbardziej pozytywnie zapisali się w mojej pamięci w 2010 roku. Są to: Piotr Zwoliński, Paweł Czerski, Kamil Trebunia, Rafał Kukawski oraz ekipy startupów ankietka.pl (warto czekać na ich nową wersję) i Stadiony.net.