Wyświetlacz kursu bitcoina

Dawno nic tutaj nie publikowałem, niestety z braku czasu też nic nowego do opublikowania nie mam. Ale wrzucę coś czego jeszcze na tym blogu nie było, a jest to tekst, który pierwotnie został opublikowany w portalu majsterkowo.pl (stąd znaki wodne na zdjęciach).

Artykuł ten przedstawia projekt łączący w sobie kilka różnych technik, które wzajemnie ze sobą współpracują. Projekt, który jest opiszę jest to zewnętrzny wyświetlacz przedstawiający aktualny kurs kryptowaluty Bitcoin. Używając przedstawionych technik można z powodzeniem zrealizować wiele innych gadżetów, jak na przykład stację pogodową, wyświetlającą aktualne dane o pogodzie pobierane z internetu.

Do zrealizowania projektu użyłem:

  • płytki “Arduino Duemilanove”, która dostarcza nam programowalny mikrokontroler
  • wyświetlacza Oled o rozdzielczości 128×64 punkty
  • aplikacji dostarczanej wraz z Arduino, służącej do programowania mikrokontrolera
  • języka Ruby, do pobierania danych z internetu i wysyłania ich do Arduino
  • publicznego API dostarczanego przez serwis bitmarket.pl
  • komputera PC z systemem operacyjnym GNU/Linux (Ubuntu 14.04)

Arduino nie posiada żadnych modułów, poza wyświetlaczem OLED, zatem do pobierania danych z sieci, będziemy używać aplikacji uruchomionej na komputerze PC. Komunikacja z Arduino będzie się odbywać poprzez port USB.

Końcowy rezultat będzie wyglądał tak:

Wyświetlanie tekstu

Na początek podłączymy wyświetlacz do Arduino. Nazwy punktów są wypisane na obu płytkach (Arduino i wyświetlacza). Połączeń dokonujemy według schematu:

Następnie podłączamy Arduino do komputera, przy pomocy kabla USB i napiszemy prosty program, dzięki któremu sprawdzimy czy wyświetlacz jest podłączony poprawnie i działa.

Tworzymy nowy szkic w aplikacji do programowania Arduino i importujemy biblioteki:

  • Adafruit GFX Library
  • Adafruit SSD1306

Biblioteki dodajemy poprzez menu “Szkic > Include Library > Manage Libraries”. Jeśli nie znajdziemy tam potrzebnej biblioteki, należy sciągnąć ją z internetu i dodać przy pomocy opcji “Szkic > Include Library > Add .ZIP Library”.

Do szkicu wklejamy poniższy kod:

#include <SPI.h>
#include <Wire.h>

#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>

#define OLED_DC 11  //OLED -- D/C
#define OLED_CS 12  //Not connected
#define OLED_CLK 10 //OLED -- SCL
#define OLED_MOSI 9 //OLED -- SDA
#define OLED_RESET 13//OLED -- RST
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

void setup()
{
display.begin(SSD1306_SWITCHCAPVCC);
display.clearDisplay();

display.setTextSize(1.2);
display.setTextColor(WHITE);
}

void loop ()
{
display.setCursor(0,30);
display.clearDisplay();
display.println(random(0,100));
display.display();
delay(1000);
}

Program należy skompilować i wgrać do Arduino. Jeśli wszystko przebiegło pomyślnie, po chwili na ekranie OLED podłączonym do Ardunio zacznie się wyświetlać losowa liczba z zakresu <0,100>. Liczba będzie się zmieniać co sekundę.

Wyjaśnienie kodu:

Na początku dołączamy potrzebne biblioteki:

#include <SPI.h>
#include <Wire.h>

#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h> 

Następnie ustawiamy piny zgodnie z połączeniami jakie zrobiliśmy między Arduino i wyświetlaczem:

#define OLED_DC 11  //OLED -- D/C
#define OLED_CS 12  //Not connected
#define OLED_CLK 10 //OLED -- SCL
#define OLED_MOSI 9 //OLED -- SDA
#define OLED_RESET 13//OLED -- RST
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

Tworzymy metodę setup, w której inicjalizujemy obsługę wyświetlacza oraz ustawiamy rozmiar i kolor czcionki.

void setup()
{
display.begin(SSD1306_SWITCHCAPVCC);
display.clearDisplay();

display.setTextSize(1.2);
display.setTextColor(WHITE);
}

Teraz tworzymy metodę loop, która wykonywana jest cyklicznie przez Arduino:

void loop ()
{
display.setCursor(0,30);
display.clearDisplay();
display.println(random(0,100));
display.display();
delay(1000);
}

W metodzie tej mamy następujące polecenia:

setCursor – ustawia kursor w pozycji x,y

clearDisplay – czyści ekran

println – wypisuję linię tekstu

random(0,100) – losuje liczbę całkowitą od 0 do 100

display – wyświetla to co zostało “narysowane” od ostatniego wyczyszczenia ekranu

delay(1000) – “usypia” na 1000ms, czyli następne wykonanie metody loop nastąpi po upływie jednej sekundy.

Komunikacja Arduino z komuterem

Dane do wyświetlenia na ekranie będą dostarczane poprzez port szeregowy, zatem do programu musimy dodać jego obsługę.

W metodzie setup dodajemy:

Serial.begin(9600);

while (!Serial) {
; // wait for serial port to connect. 
}

Prędkość transmisji ustawiliśmy na 9600. Dla naszej aplikacji nie potrzebujemy wyższej prędkości.

Natomiast metodę loop przerobimy tak, żeby wyświetlała na ekranie odebrany przez port szeregowy tekst:

void loop ()
{
 display.setCursor(0,30);
 if (Serial.available()) {
  display.clearDisplay();
  display.println(Serial.readString());
  display.display();
 }

 delay(1000);
}

Całość kodu na ten moment wygląda następująco:

#include <SPI.h>
#include <Wire.h>

#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>

#define OLED_DC 11  //OLED -- D/C
#define OLED_CS 12  //Not connected
#define OLED_CLK 10 //OLED -- SCL
#define OLED_MOSI 9 //OLED -- SDA
#define OLED_RESET 13//OLED -- RST
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

void setup()
{
 display.begin(SSD1306_SWITCHCAPVCC);
 display.clearDisplay();
 display.setTextSize(1.2);
 display.setTextColor(WHITE);
 Serial.begin(9600);

 while (!Serial) {
   ; // wait for serial port to connect.
 }
}

void loop ()
{
 display.setCursor(0,30);
 if (Serial.available()) {
   display.clearDisplay();
   display.println(Serial.readString());
   display.display();
 }

 delay(1000);
}

Po skompilowaniu programu i wgraniu go do Arduino, możemy przetestować komunikację z urządzeniem. Do tego celu bardzo przydatny jest “Szeregowy monitor”, który znajdziemy w aplikacji do programowania Arduino, w menu narzędzia.

W “szeregowym monitorze” ustawiamy prędkość transmisji na taką jaka była zapisana w kodzie programu, czyli 9600. Następnie w pierwszym polu wpisujemy jakiś tekst, np. “abc” i klikamy “Wyślij”.

W tym momencie tekst “abc” powinien wyświetlić się na ekranie oled.

Przesyłanie danych do Arduino, program w języku Ruby

Napiszemy teraz prosty program w języku Ruby, który na początek będzie pełnił funkcję podobną do tej, jaką pełnił “Szeregowy Monitor”. Zatem zadaniem tego programu będzie: wysłać do arduino krótki tekst.

Oto kod programu:

require 'rubygems'  
require 'serialport' # use Kernel::require on windows, works better.  

#params for serial port  
port_str = "/dev/ttyUSB0"  #may be different for you  
baud_rate = 9600  
data_bits = 8  
stop_bits = 1  
parity = SerialPort::NONE  

sp = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)  
sp.write(“Text from Ruby”)

Istotne jest ustawienie prawidłowego portu. W moim przypadku jest to /dev/ttyUSB0

Skrypt zapisujemy w pliku controler.rb i uruchamiamy poprzez polecenie ruby controller.rb.

Jeśli wystąpi błąd jakiejś biblioteki, należy ją doinstalować i uruchomić polecenie ponownie.

Na pewno wymagana jest biblioteka ruby-serialport (dostępna w repozytorium ubuntu).

Jeśli wszystko poszło sprawdznie, na ekranie oled zobaczymy tekst “Text from Ruby”.

Pobieranie danych z internetu i przesyłanie ich do Arduino

Została nam ostatnia część aplikacji: pobranie kursu Bitcoina w skrypcie Ruby i przesłanie go do Arduino. Celowo pominę takie kwestie jak sprawdzanie poprawności odpowiedzi API, czy walidacja otrzymanych danych, aby skupić się na tym, co jest istotne dla wykonania naszego zadania.

Na początek zmienię nieco wywołanie metody println w naszej aplikacji Arduino, aby wyświetlał się tekst “BTC/PLN: ” przed wartością otrzymaną ze skryptu Ruby.

display.println(„BTC/PLN: ” + Serial.readString());

Ostateczny kod programu dla Arduino wygląda następująco:

#include <SPI.h>
#include <Wire.h>

#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>

#define OLED_DC 11  //OLED -- D/C
#define OLED_CS 12  //Not connect
#define OLED_CLK 10 //OLED -- SCL
#define OLED_MOSI 9 //OLED -- SDA
#define OLED_RESET 13//OLED -- RST
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

void setup()   
{                
 Serial.begin(9600);

 while (!Serial) {
  ; // wait for serial port to connect.
 }

 display.begin(SSD1306_SWITCHCAPVCC);  // Switch OLED
 display.clearDisplay();  // Clear OLED

 display.setTextSize(1.2);
 display.setTextColor(WHITE);
}

void loop ()
{
 display.setCursor(0,30);
 if (Serial.available()) {
display.clearDisplay();
   display.println("BTC/PLN: " + Serial.readString());
   display.display();
 }

 delay(1000);
}

Teraz zmodyfikujemy skrypt Ruby.

Dodajemy potrzebne nam biblioteki, do pobierania zawartości z url’a oraz do parsowania jsona (odpowiedź api jest w formacie json).

require 'open-uri'
require 'json'

Dodajemy również parametr ‘url’, którego wartością jest adres api, z którego będziemy pobierać dane:

url = ‚https://www.bitmarket.pl/json/BTCPLN/ticker.json’

Następnie zamiast metody serial.write dodajemy pętlę:

while true do  
 open(url) {|f|
   content = f.read()
   data = JSON.parse(content)
   sp.write(data["last"])
 }

 sleep 2
end

Pętla wykonywać się będzie w nieskończoność (do momentu przerwania programu). Wewnątrz pętli:

  • Otwieramy url, open(url). Połączenie zapisujemy w zmiennej f
  • Pobieramy content z urla używając metody f.read(), content zapisujemy w zmiennej content
  • Parsujemy json’a (JSON.parse(content)) i wynik parsowania zapisujemy w zmiennej data.
  • Wyciągamy z data klucz last i przesyłamy go portem szeregowym do Arduino sp.write(data[„last”])
  • Wykonujemy sleep 2, czyli następny przebieg pętli wykona się po upływie dwóch sekund.

Ostateczny skrypt ruby wygląda następująco:

require 'rubygems'  
require 'serialport' # use Kernel::require on windows, works better.  
require 'open-uri'
require 'json'

url = 'https://www.bitmarket.pl/json/BTCPLN/ticker.json'

#params for serial port  
port_str = "/dev/ttyUSB0"  #may be different for you  
baud_rate = 9600  
data_bits = 8  
stop_bits = 1  
parity = SerialPort::NONE  

sp = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)  

#just write forever  
while true do  
 open(url) {|f|  #url must specify the protocol
   content = f.read()
   data = JSON.parse(content)
   sp.write(data["last"])
 }
 sleep 2
end

Jeśli wszystko poszło sprawnie, na ekranie OLED zobaczymy aktualny kurs kryptowaluty Bitcoin do PLN w formacie: “BTC/PLN: 915.0”. Czas uśpienia obu aplikacji możemy wydłużyć, ponieważ API Bitmarket.pl nie odświeża danych tak często, żeby był możliwy odczyt nowej wartości co dwie sekundy. Z drugiej strony, krótki czas uśpienia będzie przydatny w przypadku innych API, które oferują odświeżanie danych w czasie rzeczywistym.

Konkluzja

Napisaliśmy kod aplikacji Arduino oraz skrypt Ruby, które wykonują zadanie założone w projekcie. Po opanowaniu wiedzy przedstawionej w artykule, napisanie samodzielnie obu części nie powinno zająć więcej niż pół godziny. Dodatkowo nauczyliśmy się, jak podłączyć wyświetlacz OLED do Arduino, oraz jak go używać.

 

W celu dalszego kształcenia się polecam dorobić następujące funkcjonalności:

  • Wyświetlanie symboli graficznych na wyświetlaczu oled (metoda display.drawBitmap() oraz narzędzie Img2Code, służące do konwersji bitmap na kod (dostarczane wraz z biblioteką)
  • Ostatnich 10 wartości i rysowanie ich wykresu (zapis ostatnich wartości można rozwiązać po stronie Ruby, aby ograniczyć użycie pamięci Arduino).
  • Pobieranie danych z innych api, np. danych pogodowych
  • Niezależna aplikacja Arduino (nie wymagająca komunikacji z komputerem). Np. Licznik rowerowy – będziemy do niego potrzebować czujnika magnetycznego do zliczania obrotów koła oraz baterii/akumulatora do zasilania urządzenia.

 

Transmisja online z akwarium

Córka niedawno dostała rybki, a że zaczęły się ferie i wyjechała na kilka dni do dziadków, to bardzo za swoimi pływającymi przyjaciółmi tęskni. Postanowiłem więc, że jej pokażę co u jej podopiecznych.

Podłączyłem kamerkę (webcam) do mikrokomputera Raspberry pi, skonfigurowałem daemon motion przekierowałem port na routerze, żeby transmisja była dostępna z zewnętrznego IP i voilà, rybki pływają w przeglądarce.

Następnie wysłałem dziadkom linka w formacie http://ip:port i można podglądać podopiecznych 🙂

National Geographic, nie szukacie programistów?

Konstruktywny luz

Trwają poszukiwania nowego projektu dla mnie. Odbyły się już jakieś rozmowy, niektóre moim udziałem, niektóre nie, reszta zostaje kwestią dogadania się na poziomie managerskim.

Ja tymczasem dostałem zadania szkoleniowe, najpierw z Vue.js, a dziś również z Ionic’a. I bardzo fajnie mi się nad tym pracuje: bez ciśnienia, bez deadlineów, sporo mam czasu na przetestowanie różnych rozwiązań, na eksperymenty. Taki komfort psychiczny sprzyja nauce nowych rzeczy. Ciężko było by się tego wszystkiego nauczyć po godzinach, albo na „żywym” projekcie klienta.

Zaczynam rozumieć nowoczesny frontend, dużo lepiej już przemyślany niż to co widziałem wcześniej w jQuery, czy jeszcze wcześniej w Prototype. Teraz mamy nowe podejścia: Two-way binding, komponenty, własne elementy DOM, oddzielenie frontu od backendu, wszystko to są fajnie wymyślone rzeczy, mamy jednak problem z przesytem rozwiązań. Króluje kilka popularnych frameworków: React, Angular, Vue, między wszystkimi są podobieństwa i są różnice, również między poszczególnymi wersjami tego samego frameworka różnice potrafią być olbrzymi. Pojawia się więc pewien zamęt, jeśli nie używa się tylko jednego rozwiązania – pewne kwestie się mieszają np. gdy przechodzę z projektu w Vue do projektu w Angularze. Być może z czasem wyłoni się zdecydowany lider, na razie mamy jednak problem dobrodziejstwa.

Mimo wszystko, myślę że nadal zostanę w głównej mierze programistą backendowym, bo to mi po prostu najbardziej pasuje. Robiąc zadanie szkoleniowe w Laravel + Vue.js, które miało mnie nauczyć Vue.js, złapałem się na tym, że w pewnym momencie „odleciałem” przy refactoringu kodu php w aplikacji – zacząłem upiększać, ulepszać, dopisywać kolejne testy, choć nie taki był cel zadania. Cóż, z naturą nie wygrasz – dotyczy to także natury programisty.

Wydawać by się mogło, że taki okres przejściowy między jednym projektem długoterminowym a drugim, to raczej okres zwolnienia tempa, ale świątecznej przerwie od komputera potrzebowałem się czymś zająć, żeby nie schodzić poniżej pewnego poziomu koncentracji.

Jako ciekawostkę na koniec tego posta dodam, że podczas rozmów z potencjalnymi klientami poznałem pierwszego Duńczyka. Pracowałem już ludźmi z różnych stron świata: Niemcy, USA, Egipt, Indie, Hiszpania … zawsze taka Dania to coś nowego 🙂

Muzykujący programista, programujący muzyk.

W swojej karierze zawodowej zetknąłem się z wieloma programistami będącymi również muzykami. Choć te dwie dziedziny wydają się zupełnie odmienne, to w rzeczywistości muzykowanie kształtuje mózg człowieka w specyficzny sposób wpływając na umiejętności przydatne w innych dziedzinach, również w programowaniu.

Na potwierdzenie powyższej tezy załączam film. Warto obejrzeć!

Czy istnieje również zależność odwrotna, czyli wpływ programowania na umiejętności muzyczne? Zapraszam do dyskusji.

Mały edit: ten krótki artykuł był napisany w całości na tablecie, przy pomocy klawiatury ekranowej – nie polecam, zwłaszcza ludziom takim jak ja, którzy bez klawiatury nie potrafią funkcjonować 😉

Nowy rok, nowe projekty

No i zinkrementował nam się rok, obecna wersja to 2018.

Robię sobie zadania szkoleniowe z Laravel + Vue.js przy okazji zmagając się z Dockerem. Spodziewam się niebawem dostać nowy projekt od nowego klienta. Może coś więcej we frontendzie podziałam, może nie, kto wie 😉

Zauważam ostatnio taki trend, że klienci coraz częściej zaznaczają w ogłoszeniach, że w grę wchodzą tylko freelancerzy, „agencjom dziękujemy”. To samo powiedział mi jeden z moich byłych klientów, chciałby mnie zatrudnić ale tylko bezpośrednio. Cóż może kiedyś wezmę to pod uwagę, ale na razie jestem przywiązany do mojego płacodawcypracodawcy i nie do końca podoba mi się nazywanie mojej firmy agencją. Czy mam zaburzoną perspektywę, bo patrzę na firmę tylko od środka? Tego nie wiem, ale wiem że na razie nie chcę się znaleźć na zewnątrz.

Święta Bożego Narodzenia 2017 na wykresach

I po świętach.

W tym artykule nie będzie refleksji o bogu, rodzinie czy życiu. Będzie za to chłodna statystyka.

Dochodzę do wniosku, że gdybyśmy mieli w Polsce jeszcze jedno święto o skali konsumpcji porównywalnej z Bożym Narodzeniem, to stalibyśmy się pierwszą gospodarką świata. Z pomocą Google Trends postanowiłem pokazać jak w skali roku kształtują się wyszukiwania haseł najbardziej popularnych w czasie świąt.

Prezent

Prezentów szukaliśmy przez cały rok, jednak już w listopadzie zaczęła się tendencja wzrostowa, która utrzymała się do świąt. Czyli część z nas kupiła prezenty nieco wcześniej, nie czekając na ostatnią chwilę, ale byli i tacy, którzy szukali także w ostatnich dniach przed wigilią. Co warto podkreślić, ten trend nie zmienił się w ciągu ostatnich 3 lat:

Pierogi

Bo któż nie lubi dobrze przypierożyć 🙂

Karp

Karp, wiadomo, nie ma lekko w okresie świątecznym.

Barszcz z uszkami

Trend barszczu z uszkami był bardzo gwałtowny w tygodniu poprzedzającym święta.

Makowiec

Makowiec próbował walczyć w okolicy świąt wielkanocnych, jednak nie osiągnął nawet 1/4 tego co w Boże Narodzenie.

 

PyGame – pierwsze podejście do tworzenia gry 2d

W ciągu ostatnich kilka miesięcy przetestowałem mniej lub bardziej dogłębnie kilka bibliotek do tworzenia gier 2d, w celu znalezienia tego optymalnego dla mnie. Najlepsze efekty jak dotąd dawał mi język Lua i framework LÖVE, jednak dziś rolę lidera mojej klasyfikacji objął bezdyskusyjnie Python i biblioteka PyGame.

PyGame daje dużą szybkość uczenia się oraz znikomą ilość problemów związanych z samą biblioteką, zatem mogę się skupić na problemach dotyczących mechaniki mojej gry. Podstawy Pythona oraz tworzenia gier 2d posiadłem już wcześniej, natomiast PyGame ma dobrą dokumentację, łatwo dostępną choćby poprzez wyszukiwarkę Google, więc bez przeszkód na starcie, zacząłem pisać. Oto co udało mi się uzyskać po pierwszych kilku godzinach pisania (mocno przerywanych innymi zajęciami):

Grafiki kupiłem w serwisach Fotolia oraz GameDevMarket

Zaimplementowane elementy:

  • wyświetlanie grafik
  • animacja postaci
  • sterowanie postacią (point and click)
  • przechodzenie postaci pomiędzy piętrami (ukryta klatka schodowa)
  • menu startowe z elementami GUI

Wszystko zaimplementowałem obiektowo, wydzielając takie klasy jak:

  • game
  • player
  • menu
  • levels/level1
  • gui/click_pointer
  • gui/menu_button

Zapewne klas tych pojawi się znacznie więcej w dalszych iteracjach refactoringu. Warto zaznaczyć, że od razu napisałem kod tak, żeby można było napisać klasy kolejnych poziomów i podłączyć je, bez zmian w kodzie samej gry.

Kod gry udostępniłem publicznie na GitHub:
https://github.com/jakubthedeveloper/kuba-pygame1

A oto algorytm jaki zastosowałem do przechodzenia postaci między piętrai do punktu docelowego:

 

Razu pewnego była sobie gra.

Był rok 2007.

Miałem na koncie pierwsze napisane programy i strony www. Dziwnym trafem jako kompletny amator dostałem do napisania stronę klubu sportowego, który rok później został mistrzem polski. W tym momencie chciałbym z całego serca przeprosić tych, którzy po mnie ten serwis poprawiali, albowiem już po paru miesiącach od jego stworzenia poczyniłem taki progres, który pozwolił mi zrozumieć dlaczego napisałem to źle i jak powinienem to napisać poprawnie.

Dłubałem strony www dla ludzi, którzy w internecie dopatrywali się szansy rozwoju ich potransformacyjnych biznesów. . Było również coś co nie dawało mi spokoju, dopóki nie spróbuję: Stworzyć własną grę komputerową.

Miałem już za sobą pewne epizody związane z dumnie dziś nazywanym game-devem, jednym z nich była praca zaliczeniowa w studium, na którą napisałem aplikację w C++ i OpenGL w której można było chodzić po wirtualnym pokoju, w którym na ścianie wisiało moje zdjęcie, a w wirtualnym telewizorze wyświetlał się szum typowy dla analogowej telewizji, który generowany był stworzonym przeze mnie algorytmem, lubiłem się pochwalić tym co umiem, choć niewielu to wówczas rozumiało. Po tamtym projekcie zaliczeniowym nie pozostał mi nawet screenshot, szkoda. Na egzaminatorach wywarłem ogromne wrażenie, ale to nie było jeszcze to czego oczekiwałem. Dostałem solidną lekcję pod tytułem: Pisanie gier to bardzo pracochłonna praca. Wiedziałem, że stworzenie mechanizmu sterowania kamerą lub postacią, modeli, tekstur, dźwięków itd. to zbyt wiele, żeby w pojedynkę napisać grę 3d która może pójść do ludzi. Wówczas 2d mnie nie interesowało, ponieważ panował boom (hype) na 3d i nikogo już 2d nie interesowało. Błąd, bo po latach odkryłem potencjał dwóch wymiarów i musiałem się nauczyć sporo rzeczy, które mogłem poznać już kilka lat wcześniej.

W tym samym czasie nastąpił również inny boom: stały dostęp do internetu. Fakt, w 2007 roku internet już nie był żadną nowością, ale dopiero wtedy stał się rzeczą oczywistą w domu, już nie tylko w kafejkach internetowych czy na uczelniach. Pojawił się w domach ludzi nawet na wsi, a co za tym idzie, wszyscy zaczęliśmy spędzać coraz więcej czasu na tzw. surfowaniu.

Zaistniałe okoliczności oraz nabyte przeze mnie umiejętności zbiegły się w taki sposób, że postanowiłem napisać grę, która działa tylko w przeglądarce. Pomysł na zasadę działania całego silnika gry jakoś sobie poukładałem z tego co już umiałem. Tematyki długo nie szukałem, padło na politykę, z jej jasnymi i ciemnymi stronami.

Miałem tematykę, miałem pomysł na funkcjonalności, miałem pomysł jak to rozwiązać technologicznie, siadłem do pisania.

Pisałem kod w każdej wolnej chwili, kiedy tylko byłem w domu. Zaczynałem popołudniem, kończyłem o 2-3 w nocy. Zdarzało się i do wschodu słońca zasiedzieć. Wówczas każda kolejna działająca funkcjonalność była dla mnie nagrodą. Wiele opcji gry pisałem po kilka razy, zanim doszedłem do w pełni działającej funkcjonalności. Wtedy nie było jeszcze stackoverflow czy podobnych serwisów, gdzie programiści mogli znaleźć potrzebną pomoc, zatem eksperymentowałem.

Grę uruchomiłem produkcyjne w Październiku, roku 2007, początkowo rozesłałem link po rodzinie i znajomych przy pomocy Gadu-Gadu, które było wówczas standardem komunikacji.

Nastąpiła lawina: pierwszych kilka osób rozesłało link po swoich kontaktach, ci wysłali dalej i po niedługim czasie liczonym w tygodniach, miałem kilkuset użytkowników, z których aktywnych co najmniej raz dziennie była znacząca ich część. Dziś już nie pamiętam dokładnych liczb, pamiętam za to że musiałem się nauczyć naprawiać na gorąco zgłaszane błędy (stąd dziś mam mniejszy stres robiąc hotfixy). W krótkim czasie nauczyłem się co najmniej 50% tego co dziś umiem i to nie tylko w kwestiach typowo programistycznych. Do moich nowych umiejętności zaliczyłem między innymi:

  • organizacja pracy nad naprawianiem błędów i wprowadzaniem nowych funkcjonalności
  • systematyczność pracy
  • utrzymywanie maksymalnego zaangażowania w projekt
  • zarządzania serwerami
  • komunikacja z graczami
  • uczenie się tego jak gracze odbierają różne części interfejsu (user-experience, UX)

Gra pochłonęła mnie całkowicie, włącznie z tym, że z rodziną i znajomymi komunikowałem się przy pomocy wbudowanego w grę czatu. Gdziekolwiek nie byłem powtarzałem sobie w głowie wymyślone nowe funkcjonalności oraz rozwiązania problemów. Później w nocy implementowałem to wszystko przez co chodziłem ciągle niewyspany.

Byłem w takim wieku, w którym dobrze jest już mieć zarys tego, z czego będzie się żyć. Miałem kilka opcji bo działałem w muzyce, ogarniałem trochę elektronikę, głównie w kwestii audio, robiłem strony www, potrafiłem nagrać zespół muzyczny, znałem również miejscowe skupy złomu oraz butelek :p Chyba nie było takiego przełomowego momentu w którym założyłem sobie, że będę próbował zarobić na mojej grze, to wyszło jakoś płynnie, najpierw jakieś reklamy płatne za klik lub wyświetlenie, później jakieś programy partnerskie, aż w końcu nadeszły płatności sms a później również przelewy online.

Tylko że ja nie chciałem moim graczom czegoś zabierać robiąc opcje, które są dostępne tylko po zapłaceniu. Jak się później okazało, była to dobra decyzja, bo wiele innych gier padło właśnie w momencie kiedy wprowadzili opcje, dostępne wyłącznie dla płacących. U mnie płatności dawały pewien „boost”, który był jeszcze lepszy gdy odpowiednio się użyło wpłaconych środków, np. inwestując w giełdę wewnątrz gry.

Jak już wspomniałem o giełdzie to napiszę o niej nieco więcej, choć nie była to pierwszoplanowa funkcjonalność gry. Dzięki tej wirtualnej giełdzie nauczyłem się o co w ogóle w giełdzie chodzi, później poznałem mechanizmy wpływania na giełdę przy pomocy kształtowania pseudo-losowości. Spora lekcja analizy matematycznej i statystyki. Ciekawostką było to, że nazwy spółek giełdowych były przerobionymi nickami moich znajomych i rodziny, np. kolega Jurgen mógł się pochwalić, że to od jego ksywki pochodzi „Fabryka Dziurkaczy Dziurgen”.

I w tym miejscu chciałbym zakończyć moją opowieść, choć nie jest to jeszcze koniec historii gry, a zaledwie jej początek, ale o dalszej części będzie innym razem, a będzie to historia o zmianach życiowych, wzlotach, upadkach, poznanych ludziach i zajechanych klawiaturach.

Do następnego.

Problemy z internetem, a w planach dwa dni szkoleń online

Pechowo zaczął mi się dzień.
Mam dwa dni szkoleń online (w sensie: ja się szkolę, nie ja prowadzę), a tu na dzień dobry problem z internetem. Całej historii nie będę opowiadał, bo jest to nudna opowieść o wciskaniu ludziom usług, których nie potrzebują i problemach z odkręcaniem tego później. Powiem wam za to jak sobie radzę w takich awaryjnych sytuacjach.

Po pierwsze: zgłaszam awarię najszybciej jak to możliwe. Zgłosiłem o godzinie 7 rano, a technicy byli „już” o 10:30 w dodatku z błędną informacją o tym co mają zrobić :/ Olać ich, kiedyś naprawią.

Po drugie: Telefon z opcją uruchomienia routera USB. Łączę się z LTE, podłączam komputer do telefonu przez USB i mam awaryjny internet kablowy. Przez 3 godziny szkolenia na zoomie, zjadło mi ok. 580MB transferu danych. Sporo, ale dla mnie ciągłość dostępu do netu jest ważniejsza niż zużyty transfer. Wiem, że telefon mógłbym zastąpić modemem LTE, jednak przez 99% czasu taki modem mi nie potrzebny, a telefon w zupełności wystarcza.

Niestety tu gdzie mieszkam nie ma kablówki, bo to właśnie kablówkę najlepiej wspominam, jeśli chodzi o stabilność łącza.