Historia zaczęła się rok temu, gdy aktywnie prokrastynując celem ucieczki od projektu, który został mi “na wrzesień”, trafiłem na interesujący post na devBlogach – “Niebezpieczne Java-Szkoły”. Sam artykuł, którego lekturę gorąco polecam, wspomina o Lispie w kilku miejscach, ale jedna wzmianka okazała się decydująca. “Beating the Averages” Paula Grahama.

Tak, słyszałem wcześniej o Lispie. To ten język, w którym nawiasy tworzą większość kodu. Wygląda jak mleko z powrzucanymi obciętymi paznokciami. To najdziwniejszy język, w jakim można pisać kod, zaraz po BF i Whitespace. Tego typu opinie. A tu nagle pewien człowiek twierdzi w porywającym eseju, że Lisp jest najpotężniejszym językiem programowania dostępnym obecnie. I przedstawia argumenty. To przykuwa uwagę.

Blub programmer
Jedną z najważniejszych myśli eseju Paula Grahama jest to, że języki programowania różnią się w mocy. Myślę, że intuicyjnie zdawałem sobie z tego sprawę od jakiegoś czasu, ale nigdy nie myślałem o tym świadomie. Właściwie, muszę się do czegoś przyznać. Do tego momentu, zgodnie z terminologią eseju, byłem typowym “Blub programmerem” (jeżeli Czytelniku jeszcze nie przeczytałeś tego eseju, to gorąco zachęcam do lektury). Mój ulubiony język programowania (tak się złożyło, że był nim C++) jest najlepszy. Wszystko co jest na niższym poziomie to niepotrzebne męczenie się. Wszystko, co jest na wyższym poziomie (zwłaszcza Java, za którą nie przepadałem) i tak można zaimplementować w C++. Właściwie cały mój świat programistyczny skupiał się wokół C++, Javy (która jak dla mnie jest bloatware’m), C# i PHP. Programowanie funkcyjne? Nie słyszałem nigdy o czymś takim.

Wielkie obietnice

Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.

Powyższy cytat, przytoczony przez Paula a pochodzący z “How To Become A Hacker” Erica Stevena Raymonda, był intrygujący. Przeczytałem więc inne eseje – w tym “Revenge of the Nerds”, “What Made Lisp Different”. Na innej stronie znalazłem też “The Nature of Lisp”. Wszystko to przyswojone “na raz” robi mętlik w głowie, ale pewne trendy zaczynały stawać się widoczne.

Widziałem trochę kłótni, dysput i artykułów na temat wyższości jednych języków nad drugimi (C++ vs. Delphi i C++ vs. Java były moimi ulubionymi sporami). Zwykle fani danego języka twierdzą, że jest on lepszy od języka przeciwników. Ale nigdy wcześniej nie widziałem, żeby ktoś twierdził, że ich język jest najlepszy, najpotężniejszy, że Bóg stworzył za jego pomocą wszechświat. Tylko Lisp odważył się zająć miejsce ponad wszystkimi. Zwykła arogancja? A może uzasadniona*?

W dużym skrócie, najważniejsze argumenty stawiane przez zwolenników Lispu to:

• Język ten jest unikatowy w swojej możliwości wyrażania myśli przez programistę. Dzięki umiejętności przepisywania własnego kodu źródłowego w czasie kompilacji można zmieniać sam język w taki sposób, żeby dopasowywał się do rozwiązywanego problemu. Programując w Lispie człowiek używa najpotężniejszego języka programowania dostępnego obecnie.
• Sam proces poznawania i zrozumienia Lispu czyni człowieka lepszym programistą, niezależnie od języka jakiego przyjdzie mu później używać (ten argument zdaje się też pasować do teoretycznych, matematycznych stron informatyki; biorąc pod uwagę pochodzenie Lispu, może to nie jest zbieg okoliczności).
• Kolejne języki programowania powstające obecnie stopniowo zdążają do Lispu, implementując różne cechy, które w tym ostatnim były dostępne od wielu lat. Nauka Lispu jest więc strategicznie najlepszą opcją, bo język ten zawiera wszystkie ważne elementy semantyczne innych języków, a wciąż ma cechy, których nikt inny nie powielił (np. makra).

To wszystko brzmiało dla mnie bardzo intrygująco – zwłaszcza, że nie chciałem (i dalej nie chcę) skończyć jako klepacz biznesowego kodu w Javie. Bardzo zaciekawiony postanowiłem więc nauczyć się Lispu i sprawdzić doświadczalnie, czy te wszystkie zapewnienia jego zwolenników są uzasadnione.

Eksperyment
Przez ostatni rok uczyłem się Lispu w wolnych chwilach (czasem nawet spychając ‘przyziemne sprawy uczelni’ na dalszy plan). Chociaż póki co zdążyłem napisać w nim jedynie małą grę i kilka drobnych narzędzi, to mogę dziś powiedzieć, że odniosłem wiele korzyści, często nie związanych stricte z naturą języka Lisp.

• Odkryłem, że tam daleko, poza C++, Javą i C# jest cały wielki świat programowania. Że programowanie zorientowane obiektowo nie jest receptą na wszystko (świadomie bądź nie, ale wcześniej w to wierzyłem); są inne paradygmaty programowania, które w wielu miejscach są bardziej odpowiednie.
• Poznałem programowanie funkcyjne. Chociaż Lisp nie jest językiem funkcyjnym (jest wieloparadygmatowy), to wiele wzorców pisania kodu – związanych z pracą na listach i drzewach oraz funkcjach wyższego rzędu i wyrażeniach lambda – stanowi podstawę funkcyjnego tworzenia oprogramowania (która to jest tematem na zupełnie osobny wpis). Gdyby nie Lisp, najprawdopodobniej w ogóle nie zainteresowałbym się Erlangiem, i nie pisałbym w nim dziś oprogramowania.
• Zrozumiałem, że C++ w programowaniu zorientowanym obiektowo nie mówi ostatniego słowa. Common Lisp tak na prawdę pokazał mi, że model obiektowy może być zrobiony wokół zupełnie innych założeń, być większy i bogatszy.
• Nabrałem wstrętu do pisania rzeczy, które powinien pisać za mnie komputer. Jak powiedział Olin Shivers, “I object to doing things that computers can do.” Przykładowo, wśród programistów C/C++ (a także innych języków, np. Erlanga) znana jest niechęć do używania makr preprocesora. W wielu przypadkach jest ona uzasadniona, jednak dzięki “Lispowemu sposobowi myślenia” zacząłem traktować preprocesor jako przydatne narzędzie generowania kodu w czasie kompilacji.

Nauka Lispu miała też potężny efekt uboczny:

• Zacząłem dostrzegać wpływy Lispu wszędzie. Tak, wiem – niektórych to denerwuje. Odruchowe zwracanie uwagi, że “XYZ zgapiło to z Lispu!”. Te skojarzenia nie są jednak nieuzasadnione. Dobrze oddaje to “10-ta zasada programowania Greenspuna”:
  

  Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.

  Na to, jak ten sposób myślenia udziela się programistom Lispu, samokrytycznie zwrócił uwagę Slobodan Blazeski w artykule o Haskelu:

  (…) The reasons vary but it probably has something with lispers’ being spoiled brats. They’re damn hard to impress. You show them the cool feature that your favourite language has and they either already have it, have something better or they’ve already seen it and decided it’s not such a good idea as you might think.

A droga długa jest; nie wiadomo, czy ma kres…
W dalszym ciągu intrygują mnie możliwości Lispu, których jeszcze w ogóle nie poznałem. W szczególności makra i metaprogramowanie. Chciałbym też dokładniej sprawdzić, czy Lisp jest faktycznie tak wygodnym narzędziem do pisania eksperymentalnych aplikacji jak pisał Paul Graham**. Przede mną jeszcze daleka droga. W dalszym ciągu nie umiem używać makr ani rewelacyjnego systemu wyjątków w Common Lisp. W szczególności, jeżeli chodzi o lekturę, to chciałbym skończyć SICP, a następnie przeczytać “On Lisp”, “Let Over Lambda” i “Art of Metaobject Protocol”. Do dnia dzisiejszego Lisp dał mi jednak bardzo dużo, i nie żałuję, że zacząłem się go uczyć. Dzięki niemu wyszedłem z “zastoju” informatycznego i odkryłem wiele nowych dziedzin i rozwiązań, o których wcześniej nawet mi się nie śniło.

(przypisy)
* – Podobnie do mnie czuł się pewien człowiek, którego Paul Graham cytuje na swojej stronie

“I have heard more than one LISP advocate state such subjective comments as, “LISP is the most powerful and elegant programming language in the world” and expect such comments to be taken as objective truth. I have never heard a Java, C++, C, Perl, or Python advocate make the same claim about their own language of choice.”

- A guy on Slashdot. What theory fits this data?

** – W czasach, gdy Paul pisał swój esej, języki takie jak Python, Perl czy Ruby nie były powszechnie używane w taki sposób jak dzisiaj; obecna ilość i rozmiar projektów powstających w językach dynamicznie typowanych wysokiego poziomu, posiadających REPL jest argumentem za tym, że miał rację.

Kanały RSS subskrybuje się za pomocą wszelkiego rodzaju czytników RSS – dostępnych on-line, off-line czy nawet wbudowanych w przeglądarkę. Subskrybcja ta nabiera prawdziwej mocy w połączeniu z czytnikami wbudowanymi w programy pocztowe – można wtedy przeglądać pocztę i większość istotnych dla nas informacji w sieci wewnątrz jednego programu. Jest to szczególnie wygodne dla osób stosujących w życiu coś mniej lub bardziej przypominającego GTD – wtedy wszystkie ważne informacje i sieciowe ciekawostki same trafiają do miejsca, gdzie znaleźć się powinny – do skrzynki spraw przychodzących.

Potężną zaletą “korzystania z RSS-ów” jest zwolnienie z obowiązku pamiętania o sprawdzaniu zmian na stronach. Każda rzecz, o której trzeba pamiętać zajmuje nam “RAM” i zabiera “cykle procesora” w głowie, które lepiej przeznaczyć na przykład na pracę, którą aktualnie wykonujemy. Pół biedy, jeżeli rozprasza nas regularna, acz przelotna myśl o sprawdzeniu, czy znajomy blogger nie napisał nowego postu. Są sytuacje, w której wymaga się od osób, by były na bieżąco z informacjami – na przykład sekretariaty czy dyrekcje szkół powinny wiedzieć o wszystkim, co ogłaszają kuratoria. Konsekwencje przeoczenia jakiejś informacji mogą być ogromne; ryzyko to jest jednak znacznie mniejsze, gdy wszystkie aktualizacje “wpadają” w jedno miejsce obok poczty elektronicznej.

Tam, gdzie RSS-ów nie ma…
Zdarza się, że autorzy strony zapomną, lub z innych powodów nie umieszczą na stronie kanału RSS. W takiej sytuacji pomóc mogą serwisy typu page2rss, które “przerabiają” zmiany na stronach na kanał RSS. Zrobiłem tak ze stroną wydziału uczelni, na której studiuję i w końcu już jestem na bieżąco z informacjami organizacyjnymi.

Oprócz zwykłych stron internetowych serwujących informacje są też przeróżne usługi, które oferują bądź powinny oferować kanał RSS. Przykładem jest serwis GitHub, który udostępnia w ten sposób historię ostatnich commit’ów. Osobiście też bardzo zadowolony jestem z kanału RSS z pewnego serwera FTP współdzielonego przez dużą grupę osób – ale takie “dobrodziejstwo” wymagało już odrobinę brudnej zabawy z PHP. Osobiście chciałbym zobaczyć kiedyś kanał RSS z “Ściany” (ang. Wall) na Facebook‘u; podobno ktoś podejmował takie próby, ale Facebook je zwalczył (“prywatność”, takie tam). Byłaby jedna strona mniej do codziennego sprawdzania.

Negatywna strona RSSów
Oczywiście, “nie ma róży bez kolców” – głównym problemem RSS-ów jest coś, co jest też ich największą zaletą – nowa treść trafia nam “prosto przed nos”. Mając wszystkie ciekawe teksty i nowinki w jednym miejscu można bardzo łatwo zacząć – mniej lub bardziej szkodliwie – prokrastynować. Jak każde narzędzie, jakie dają nam nauka i technika, tak i kanałów RSS należy używać rozważnie – ale to już nie jest temat tego postu.

* – RSS nie jest jedynym protokołem tzw. syndykacji w Internecie. Niemniej jednak termin RSS jest używany czasem w rozumieniu różnych protokołów, podobnie jak w przypadku obuwia – “adidasy” niekoniecznie muszą być wyprodukowane przez firmę Adidas. W tym znaczeniu używam skrótowca RSS w powyższym tekście.

Gdybym miał podsumować Erlanga w kilku hasłach, byłyby to: niezawodność, współbieżność (concurrency), lekkie procesy (lightweight processes), język funkcyjny, interaktywność. Język ten powstał w laboratoriach firmy Ericsson (tak, tej od Sony Ericsson) i pozwolił jej osiągnąć w jednym ze swoich projektów niezawodność tzw. nine nines, czyli 99.9999999% – innymi słowy, w ciągu roku system był niesprawny nie dłużej niż ok. cztery setne sekundy! Taki poziom bezawaryjności jest osiąganlny dzięki pewnym bardzo ciekawym koncepcjom, o których chciałbym napisać w przyszłości.

Nie będę się w tym poście rozpisywał o innych mniej lub bardziej znanych projektach zrealizowanych w Erlangu (w o tym klasycznych, używanych wręcz marketingowo przykładach Facebook’a czy Amazonu). Warto moim zdaniem wspomnieć tu jeszcze o jednym – edytorze modeli 3D o nazwie Wings 3D, napisanym w całości w Erlangu. Jest to o tyle specyficzny przykład, że Erlang jako język nie jest stworzony do pisania aplikacji przeprowadzających ogromne ilości obliczeń matematycznych w czasie rzeczywistym, a jego funkcyjność średnio pomaga przy programach trzymających duże ilości wewnętrznego stanu. A do czego ten język się nadaje najlepiej i jakie ciekawe rozwiązania zostały dla niego pomyślane – to już temat na kolejne posty.

W niektórych językach (np. w C++, o czym niedawno pisałem) funktorów używa się do naprawienia braku naturalnego wsparcia dla funkcji first-class. Jednak Common Lisp takie wsparcie ma, więc zasadnicze pytanie brzmi: po co nam funktory w języku, w którym funkcja jest takim samym typem danych jak każdy inny?

Zadajmy sobie inne pytanie – co robimy z funktorami?

1. Przekazujemy je do funkcji wyższego rzędu, takich jak map czy reduce.
2. Ponieważ są to obiekty, możemy trzymać w nich dodatkowe informacje lub umożliwiać wykonywanie na nich dodatkowych operacji.

Wyobraźmy sobie, że piszemy bibliotekę do obliczania minimum zadanej funkcji matematycznej*. Niektóre metody potrzebują jedynie znać wartości naszej funkcji w kilku punktach. Inne potrzebują także pochodnych lub gradientu. Chcielibyśmy takie informacje trzymać “razem” z naszą funkcją, móc uzyskać do nich dostęp w razie potrzeby (na tym etapie nie zastanawiamy się nad sposobem ich wyliczenia czy przechowywania). Nasza matematyczna funkcja powinna więc być obiektem. Z drugiej strony, chcemy mieć możliwość użycia jej jak normalnej funkcji w języku programowania – choćby po to, by nie mnożyć dziwnej składni tylko dlatego, że chcemy “na boku” przechowywać dodatkowe informacje. W C++ przeładowalibyśmy operator() – spełniając w ten sposób wymagania 1) i 2) naszego funktora.

Deklaracja i użycie wyglądałyby na przykład tak:

Powiedzmy raz jeszcze, co chcemy uzyskać w Lispie – chcielibyśmy mieć obiekt funkcja, który dałoby się wywołać jak funkcję, pisząc: (funcall funkcja 100)**, oraz przekazać do funkcji wyższego rzędu, np.: (map 'list funkcja dane), ale równocześnie chcemy uzyskiwać z niego pewne informacje, np. (first-derivative funkcja).

Rozwiązaniem jest użycie Metaobject Protocol do zmiany typu klasy z standard-class na funcallable-standard-class. Przykładowo (w Clozure Common Lisp***):

Definiujemy również metodę zwracającą pierwszą pochodną:

Od teraz obiekty klasy math-object są “funcallable” – mogą być przekazane do funcall, co oznacza, że mogą być argumentami funkcji wyższego rzędu. Spełniamy tym samym wymagania 1) i 2) naszego funktora.

Pozostaje tylko pytanie, jaki kod wykona “wywołanie” naszego obiektu? Kod ten możemy ustawić za pomocą set-funcallable-instance-function. Wygodnie jest zrobić to w konstruktorze. W Lispie, konstruktor klasy tworzymy dodając metodę after o nazwie initialize-instance.

Dodaliśmy parametr kluczowy code, który pozwala nam tworzyć obiekty w następujący sposób:

Jeżeli chcemy, aby nasz funktor był widziany jak funkcja globalna i używany ze składnią normalnego wywołania funkcji, możemy napisać:

Wydaje się, że konieczność zaprzęgania Metaobject Protocol sprawia, iż stworzenie funktora jest czymś skomplikowanym w stosunku do np. C++. Należy jednak pamiętać, funktory w Lispie zwykle nie są potrzebne – same funkcje są first-class i można je przekazywać oraz zwracać jak każdy inny typ. Konieczność łączenia z funkcjami dodatkowych danych i operacji jest – wydaje mi się – czymś rzadkim. I nawet nie jestem pewien, czy nie znalazłaby się lepsza abstrakcja dla tego problemu.

Przypisy
* – problem nie jest wcale taki błahy ani wzięty z powietrza – w tym semestrze miałem na studiach cały przedmiot poświęcony znajdywaniu minimum funkcji na różne, niekiedy dość dziwne sposoby.
** – składnia (funcall funkcja argumenty) jest naturalnym sposobem wywoływania funkcji przekazanej w zmiennej w Common Lisp. Język ten, w przeciwieństwie do Scheme, pozwala funkcjom i zmiennym nosić te same nazwy – dlatego nie możemy napisać po prostu (przekazana-funkcja argumenty) (tak jak zrobilibyśmy w Scheme), gdyż Lisp będzie szukał symbolu przekazana-funkcja w przestrzeni nazw funkcji.
*** – jest trochę zamieszania z Metaobject Protocol w różnych implementacjach Common Lispu. Sam symbol funcallable-standard-class znajduje się w pakiecie specyficznym dla danej implementacji. Dla Clozure Common Lisp jest to pakiet CCL (tak jak w przykładzie), w SBCL prawdopodobnie SB-MOP. Powstał projekt Closer mający na celu ujednolicenie Metaobject Protocol pomiędzy różnymi implementacjami Common Lispu, ale nie miałem okazji jeszcze z niego korzystać.

Powiedzmy, że chcę znaleźć fragment dokumentacji opisujący składnię BETWEEN. Proste zapytanie postaci: BETWEEN site:http://www.postgresql.org/docs/ nie zwróci nic przydatnego, gdyż wyraz ‘between’ pojawia się wielokrotnie w tekstach jako zwykłe angielskie słowo. Przydałby się sposób na wytłumaczenie Google’owi, że chodzi nam konkretnie o BETWEEN, a nie o between. Ktoś na szczęście o tym problemie pomyślał i powstała aplikacja Case sensitive (CS) Google search, która filtruje wyniki wyszukiwania pod kątem wielkości liter.

Jedna uwaga dotycząca samego wyszukiwania z pomocą tego narzędzia – w przypadku, gdy wpisujemy zapytanie z operatorami, typu BETWEEN site:http://www.postgresql.org/docs/, trzeba sobie ręcznie poprawić filtr wyszukiwania tak, by nie próbował znaleźć operatora site: i dalszej części zapytania w wynikach wyszukiwania.

Edit
Jak słusznie napisał w komentarzu Reg, polecenia SQL nie muszą być pisane wielkimi literami. Niemniej jednak wiele osób tak czyni (w tym dokumentacja do Postgresa) i dzięki temu możemy wykorzystać tę różnicę w zapisie (wielkie litery dla SQL vs. małe dla normalnego angielskiego) do odfiltrowania całej masy niepotrzebnych wyników. Oczywiście, najpierw trzeba zmusić Google do rozróżniania wielkości liter .

• Game State One Star General
• Game State Supreme Commander
• Game State Field Marshall
• Marszałek Polny Stanu Gry

Teraz rola tak nazwanej klasy jest jasna .

Tej sztuczki używałem pracując na Windows Vista – polecam spróbować . Więcej szczegółów na temat samego paska QuickLaunch można też przeczytać na blogu TechNet.

Po szczegóły, screeny, źródła i download – zapraszam na stronę projektu!

Postmortem

Jedną z sugestii na 2010LGDC było, by każdy na koniec napisał postmortem swojej gry. Poniżej zamieszczam tekst w oryginale (wzbogacony jedynie o linki i bez poprawiania błędów) – dla tych, którzy nie boją się czytać długiego tekstu po angielsku .

Hi,

This is a postmortem for my 2010LGDC entry, called “Cloze-Call”. It derives its name from Clozure Common Lisp, in which it was written (more on that topic in Section 2). It is also a reference to a phrase, “close call”, which means achieving something or escaping by a narrow margin, which corresponds to the ball maneuvering between planets.

The game itself is a very simple “Gravity Pong”. Your goal as a player is to shoot a ball into a hole. The ball must not collide with any of the planets that are on screen. To make things more fun, all planets attract the ball by means of gravity force.

1. What did I learn?
Common Lisp, first of all. It is my first real project in Lisp. I started learning this language in summer 2009, but (thanks to university) I didn’t have much time to write some real programs.

Using ASDF – at least a little bit.

That my old design concept for Game State Manager code (which I used for years in at least three other languages) has flaws to get ????

2. What went right?
Setting up the environment. I am working on 32-bit Windows 7. Even though I had to try out SBCL (which crashed on SDL examples), CLISP (too slow), ECL (also too slow) and SBCL on Ubuntu before ending up with well-working lispbuilsder-sdl and Clozure Common Lisp, I am surprised that the installation and setting up process wasn’t that complicated and things actually worked first-time. I spent two days before the Challenge on setting up SDL and working environment.

Graphic Design. This project confirmed what I actually learned recently – it is important to sacrifice some time and get decent-looking graphics / media for your product (be it a game, or anything else) and make it look nice. I’d be very unhappy if this game had circles and squares instead of those pictures, which I found on OpenGameArt.org.

Fixed-step physics. I am using and promoting fixed time step approach to simulation in computer games, and it’s the first time I really saw how good it is. During first physics test I had a fixed initial velocity vector for the ball, and I could see how it always travels the same path and lands in the same place.

The game. It isn’t finished, but it is playable and has most of the game mechanics implemented. I had to cut down on features as I was running out of time, but I shipped.

3. What went wrong?
Transparency in SDL – I made some little voodoo and made planets use alpha channel, but the same trick didn’t worked for any other image. I’m still confused why it’s not working, and this phenomena is responsible for ugly Victory/Defeat screens.

Watching movies – I’d have at least few more hours to work on my game if I haven’t found myself some stuff that I really, really wanted to watch.

Bad naming conventions. I heard it’s hard to give names to vector-math library functions. I done it wrong, and had to look for a bug for almost an hour. My vector math library that I wrote for this game had two kinds of functions – some were returning a new vector with the result of an operation, and some modified their arguments. In particular, I had (negative-vector) which returned a new vector representing inversed input parameter. The complimentary function was (negate-vector), which just negated its parameter. I used the latter instead of the former in physics code, and spent almost an hour trying to discover why graphics was flickering.

6 days instead of 7. If I were more careful and wrote 2010-04-01 23:59GMT+1 instead of 2010-04-01 00:00GMT+1, I’d have one more day to work. I found my mistake about a day after signing up and decided not to change my initial declaration.

4. What’s lispy about my entry?
It is in Lisp . It is not that common to see a game in Lisp .

Few lambdas and high-order functions here and there. I think that my code is more like C++ with Lisp-syntax. But I guess, as for a first Lisp project, it’s not that bad.

5. What interesting algorithms or designs did I use?
My good, old Game State Manager abstraction that I use everywhere. It simplified managing different game screens. Apart from that, I guess everything else is typical stuff you’ll find in any computer game.

At first I wasn’t sure if I want to take part in the Contest. I have lot of stuff to do at university (and other places as well), I don’t know that much Common Lisp, ect. etd. But, I thought, it would be a good occasion to actually learn much Lisp in short time, and write another game. I decided to sacrifice some university lectures and now I’m happy I did it. I’d like to thank David O’Toole for inviting me to #lispgames and encouraging me to take part in the Challenge. And I’d like to thank all of you #lispgames guys for support and nice time wasted (I should have been coding, not chatting ) on IRC .

Przed lekturą drugiego rozdziału wspomnianej książki postanowiłem napisać sobie prosty, dwustanowy, jednowymiarowy automat komórkowy i wygenerować opisywane przez Wolframa obrazy. Implementacja zajęła piątkowe popołudnie i wieczór, a w rezultacie powstał program symulujący automat komórkowy z dowolną trójelementową regułą oraz renderujący obrazy.

Poniżej chciałbym zaprezentować kilka najciekawszych przykładów tego, co potrafi stworzyć tak prosty automat komórkowy. Nieco dalej wyjaśnię, na czym polega numeracja reguł. Na samym końcu chciałbym też opowiedzieć o programie, który napisałem.

Reguła 30

Reguła 18

Reguła 151

Reguła 124

Reguła 225

Numeracja Wolframa
Numeracja reguł, zaproponowana przez Wolframa w A New Kind of Science, jest bardzo prosta. Automat, na którym pracujemy oblicza stan nowej komórki z trzech innych – z tej bezpośrednio nad sobą, oraz z lewego i prawego sąsiada komórki nad sobą. Wystarczy zaobserwować, że mając do dyspozycji trzy komórki, z których każda może przyjąć dwa stany (zapalona albo zgaszona), uzyskujemy 8 możliwych układów. Dla każdego takiego układu definiujemy zasadę – czy nowa komórka ma zostać zgaszona, czy zapalona. Łącząc takie zasady dla wszystkich ośmiu stanów uzyskujemy jedną regułę opisującą wszystkie możliwe sytuacje spotkane w omawianym automacie komórkowym.

Łączenie zasad w numer reguły jest oparte o operacje bitowe. Jeżeli potraktujemy trójki komórek jako liczby binarne, gdzie stan ‘zapalona’ oznacza 1, a stan ‘zgaszona’ oznacza 0, uzyskujemy naturalną numerację od 0 do 7. I teraz jeżeli zasada oparta o daną trójkę mówi, ze nowa komórka ma być zapalona, to ustawiamy bit odpowiadający ‘numerowi’ trójki komórek na 1, a jeżeli nowa komórka ma być zgaszona – to na 0. Uzyskany numer zasady jest liczbą ośmiobitową, a więc z zakresu od 0 do 255.

Jeżeli sam opis był zbyt zagmatwany, to mam nadzieję, że powyższe zdjęcie wyjaśniło sprawę .

Symulator automatu komórkowego
(Pobierz symulator)
Sam symulator to prosty program w Common Lispie, który pisałem przez piątkowy wieczór. Trzon designu stanowiły schematy narysowane kredą na betonie przed pizzerią oraz kod rozpisany na pudełku od pizzy . Program ten umie przeprowadzać symulacje dla jednowymiarowego, dwustanowego automatu komórkowego o dowolnej szerokości na podstawie reguł sprawdzających trzy sąsiadujące ze sobą komórki.

Główny program wypisuje swoje wyniki w postaci tekstowej, jednak dopisałem też nakładkę, która umie generować obrazy i zapisywać je do plików. Korzysta ona ze znanej programistom gier biblioteki SDL za pośrednictwem bindingów lispbuilder-sdl.

Krawędzie i warunki początkowe
Jest jedna ważna rzecz, o której na tym etapie trzeba wspomnieć. Jak w każdym automacie komórkowym, tak i w tym pojawia się problem krawędzi, czyli tego, jaką wartość ma przyjąć lewy sąsiad pierwszej komórki oraz prawy sąsiad ostatniej. W przypadku mojej implementacji, komórki ‘z poza planszy’ przyjmują domyślnie stan ‘zgaszony’, pusty.

Uważny czytelnik zauważy, że wygenerowane przeze mnie obrazki różnią się miejscami od przykładów z książki Wolframa – wynika to z tego, że symulacja odbywała się na automacie o szerokości 800, gdzie bardzo szybko dochodziła do głosu obecność krawędzi. Zdjęcia zamieszczone w A New Kind of Science są wolne od wpływu krawędzi – najprawdopodobniej ‘krawędź’ jest gdzieś bardzo daleko .

Wszystkie obrazki zostały wygenerowane przy tych samych warunkach początkowych, jakie stosował Stephen Wolfram w A New Kind of Science – startujemy ze wszystkimi komórkami zgaszonymi, i zapalamy jedną dokładnie na środku.

Symulator – pobieranie i użycie
Pobierz symulator (źródła).
Przykład użycia (za pomocą specjalnych funkcji do prostego testowania):

• static_cast
• const_cast
• dynamic_cast
• reinterpret_cast

Rzutowania w stylu C wyglądają natomiast tak: (typ)argument, lub tak: typ(argument).

Jeden z ciekawych problemów, który może się pojawić u programisty stosującego rzutowania w stylu C ilustruje poniższy fragment kodu:

Ten kod wbrew pozorom nie robi tego, na co wygląda. Nie jest to stworzenie obiektu Foo typu Object, z rzutowaniem parametru na typ int. C++ przyjmuje zasadę, że wszystko co wygląda jak deklaracja funkcji ma być w pierwszej kolejności potraktowane jak deklaracja funkcji. I w tym przypadku kod ten deklaruje nam funkcję o nazwie Foo, zwracającej obiekt typu Object i przyjmującej jeden parametr typu int.

Może na co dzień nie spotkamy się z takimi ekstremalnymi zjawiskami, ale rzutowania w stylu C++ mają kilka dobrych cech, o których warto wiedzieć:

• Są dużo bardziej przyjazne dla grep’a i innych narzędzi wyszukujących w tekście. O wiele łatwiej jest znaleźć wszystkie wystąpienia static_cast niż rzutowań opartych o nawiasy okrągłe, które czasem mogą przypominać np. wywołanie funkcji albo tworzenie nowego obiektu. Poza tym, w jaki sposób znaleźć wszystkie rzutowania niezależnie od typu, na który się ono odbywa?
• Są dużo bardziej przyjazne dla vgrep’a (dla ludzkiego oka ) – łatwiej je wypatrzeć w gąszczu nawiasów; z resztą w większości IDE są kolorowane jako słowa kluczowe. Weźmy przykład poniższego kodu:
      int offset = (int)(T*)1 - (int)(Singleton <T>*)(T*)1
      ms_singleton = (T*)((int)this + offset);

  i porównajmy go z tym:

      int offset = reinterpret_cast<int>(reinterpret_cast<T*>(1)) -
      reinterpret_cast<int>(static_cast<Singleton <T>*>(reinterpret_cast<T*>(1)));
      ms_singleton = reinterpret_cast<T*>((reinterpret_cast<int>(this) + offset));

  Wariant C++ nie jest ani trochę piękniejszy, ale przynajmniej można od razu policzyć ile jest rzutowań i jakiego rodzaju. Poza tym, składnia wywołania funkcji pozwala od razu ogarnąć, które wyrażenia są rzutowane.

• Jak widać powyżej, są długie, rozwlekłe i brzydkie. I bardzo dobrze. Rzutowania to coś, czego nie powinno się stosować bez wyraźnej potrzeby, więc jeśli programiście przeszkadza pisanie takiego kodu, to tym lepiej dla projektu.
• Lepiej rozdzielają odpowiedzialność – każdy z rodzajów rzutowania w C++ jest odpowiedzialny za inne zadanie. Dzięki temu kod lepiej wyraża intencje autora (np. widząc w kodzie const_cast masz pewność, że programista chciał jedynie zdjąć lub założyć modyfikator const albo volatile).
• Mają spójną składnię. Rzutowania w stylu C mogą występować w dwóch wariantach – z typem w nawiasie oraz w składni “konstruktora”, z rzutowanym argumentem w nawiasie. Sam fakt, że w tym samym programie możemy natknąć się na oba warianty powoduje, że myśl o wyszukiwaniu ich w kodzie jest przerażająca.

Zainteresowanych tematem rzutowania odsyłam do świetnego artykułu Reg’a poświęconego temu tematowi. Chciałbym zaznaczyć jednak, że nie zgadzam się z jego wnioskiem numer 2, tj.

Nie ma praktycznych przesłanek, by rezygnować ze stosowania eleganckiego, zwięzłego rzutowania w stylu C na rzecz rozwlekłych operatorów static_cast i reinterpret_cast.

Wydaje mi się, że w tym poście zawarłem wiele praktycznych przesłanek za rezygnacją z rzutowania w stylu C.

“o ile w ciągu zeszłego (2005) roku nic się nie zmieniło to ANSI Common Lisp jest jedynym językiem obiektowym spełniającym wymagania organizacji ‘Object Managment Group’ (tej od CORBY i UML-a). “

Szymon

Problem pokemonizacji tekstu sam w sobie nie jest wart poświęcania mu miejsca, ale chciałbym wykorzystać tę okazję by pokazać kilka ciekawych rzeczy w Common Lispie.

Zacznijmy od końca. Funkcja

mogłaby w C++ być napisana jako:

std::transform z C++ i map z Common Lispu to przykłady tak zwanych funkcji wyższego rzędu*. Jak nietrudno się domyśleć, zadaniem użytych przez nas funkcji jest przejście przez cały napis znak po znaku i zastosowanie na każdym elemencie funkcji przekazanej jako parametr. Zauważmy, że nie napisaliśmy tutaj żadnej iteracji, żadnej pętli for – myślimy w kategoriach “przejścia funkcją po napisie”. Taki przeskok myślowy jest bardzo cenny; w C++ zalecane jest (mniej błędów się robi) używanie algorytmów z biblioteki STL, które umieją w różny sposób stosować przekazane funkcje na elementach pojemników (polecam przeglądnąć nagłówek <algorithm>).

Skoro mamy już trzon naszego rozwiązania, warto pomyśleć nad samą funkcją pokemonizującą. Według oryginalnej definicji problemu funkcja ma sprawiać, że wynikowy tekst będzie miał co drugą literę wielką. Przyjmijmy automatycznie, że pozostałe litery mają być małe. W naszym rozwiązaniu funkcja pokemonizująca musi więc zmieniać swoje zachowanie w kolejnych wywołaniach – powinna zamieniać litery raz na małe, a raz na duże. Musimy więc w funkcji ukryć stan. Dla przypomnienia, w Common Lispie mieliśmy funkcję:

Zadaniem funkcji (get-pokemonizer) jest zbudowanie funkcji pokemonizującej pojedynczy znak. Sama funkcja pokemonizująca zaczyna się od wyrażenia (lambda ..., które oznacza po prostu stworzenie funkcji anonimowej (nienazwanej). Zanim uzasadnię, dlaczego potrzebny jest generator takich funkcji, chciałbym znów odnieść się do kodu z C++ i porównać kody odpowiedzialne za samą zmianę znaku.

W komentarzach zawarty jest odpowiadający kod w Common Lispie. Czytelniku, zastanów się przez chwilkę – co z powyższą funkcją w C++ jest nie tak?

Odpowiedź: stan jest globalny. Wyobraźmy sobie, że chcielibyśmy używać tej samej funkcji wielokrotnie. Do tego jeszcze czasem w osobnych wątkach. Widać wyraźnie, że wiele wywołań funkcji pokemonize_char() będzie pracowało na tej samej zmiennej globalnej, która trzyma stan. Przejście na zmienną statyczną nie rozwiąże problemu – jedynie ograniczy widoczność stanu (co jest dobrą rzeczą). W C++ wypracowano jednak rozwiązanie – jest nim stworzenie obiektu funkcyjnego (inaczej funktora). Jest to obiekt przeciążający operator(), czyli operator wywołania funkcji. Taki obiekt może skutecznie udawać prawdziwą funkcję, a jednocześnie trzymać w sobie stan. Lepsze rozwiązanie naszego problemu w języku C++ wyglądałoby więc tak:

W tym momencie wywołania pokemonize_string() są już thread-safe. Musieliśmy w tym celu napisać kod tak, by przy każdym wywołaniu pokemonizacji napisu tworzony był nowy obiekt funkcyjny z własnym stanem.

Wróćmy teraz do Common Lispu. Powyższy kod C++ jest odpowiednikiem rozwiązania w Lispie, więc możemy je ze sobą dokładnie porównać. Dla przypomnienia:

Wspomniałem wcześniej, że zadaniem funkcji (get-pokemonizer) jest stworzenie funkcji pokemonizującej pojedynczy znak. Odpowiednikiem tej funkcji w C++ jest konstruktor funktora Pokemonizer. Jest jednak zasadnicza różnica między funkcjami C++ i Common Lispu – w tym drugim języku funkcję są tzw. obiektami first-class. Oznacza to między innymi, że taką funkcję można przechowywać w zmiennej, przypisywać i zwracać z innych funkcji. Dlatego nasz generator pokemonizerów po prostu zwraca funkcję. Innymi słowy, funkcje w Lispie posiadają te cechy, które w C++ musimy symulować za pomocą obiektów funkcyjnych.

Pozostaje jeszcze powiedzieć, w jaki sposób osadzamy stan w naszej funkcji pokemonizującej. W Lispie możemy zastosować tak zwane domknięcia. Jest to bardzo interesująca technika programistyczna. Zauważmy, że przed stworzeniem samej funkcji pokemonizującej (wyrażenie (lambda ...) definiujemy zmienną ((let ((upkemonize nil)) ...). Mówiąc językiem C++, nasza anonimowa funkcja znajduje się w zakresie zmiennej upkemonize. Co więcej, ona korzysta z tej zmiennej.

Powtórzę jeszcze raz – anonimowa funkcja, która ma zaraz zostać zwrócona z generatora używa zmiennej, która została stworzona w tym generatorze w momencie jego wywołania. upkemonize to zwykła zmienna lokalna. Nowy pokemonizer pracuje na obiekcie, który – według C++’owej intuicji – przestał istnieć tak szybko, jak tylko swoje działanie skończył generator. To może być lekko mind-blowing na początku. Dla mnie było.

Ilekroć generator zostanie wywołany, powstanie nowa zmienna upkemonize, która na stałe zostanie związana ze zwróconym pokemonizerem. Ten ostatni trzyma w niej swój stan; z jego punktu widzenia ta zmienna jest zewnętrzna, ‘globalna’. Taką technikę programistyczną nazywamy domknięciem – funkcja “domyka się” nad zmienną zadeklarowaną na zewnątrz niej.

Kilka wniosków, które wynikają z powyższych rozważań:

• Funkcje wyższego rzędu są bardzo eleganckim sposobem krótkiego zapisywania algorytmów dotyczących całego zbioru danych. Zamiast ręcznie pisać pętle kopiujące, zmieniające czy dzielące duże grupy danych możemy użyć funkcji przyjmujących funkcje jako parametr, by w jednym wyrażeniu zapisać nasze rozwiązanie. W C++ spotykamy się z nimi często w STLu.
• Funktory to sposób emulacji mechanizmu funkcji jako obiektów first-class – czyli czegoś, co jest fundamentalną właściwością Lispu. Możliwość traktowania funkcji jak każdego innego typu danych jest bardzo przydatna.
• Common Lisp zawiera mnóstwo cech, które w C++ wymagają strasznego kombinowania – funkcje jako obiekty first-class, wyrażenia Lambda** i domknięcia to tylko niektóre z nich.
• Można pisać bardzo, bardzo długie elaboraty o prostych problemach

* – Ściślej mówiąc, C++ tylko sprytnie emuluje funkcje wyższego rzędu – taka funkcjonalność nie jest wbudowana w język.
** – Wyrażenia Lambda, czyli tworzenie funkcji anonimowych, są elementem nowego standardu języka C++ o nazwie roboczej C++0x.

Z samego IGK relacji i zdjęć jest już dość sporo, więc póki co nie będę się dokładał . Na konferencji brałem też udział w Compo, ale ponieważ nasz projekt konkursowy jest w trakcie modyfikacji (postanowiliśmy w swoim zespole opublikować go jako skończoną grę), to wrócę do niego gdy prace dobiegną końca.

Pobyt na IGK (a konkretniej, rozmowy z Warsztatowiczami) uświadomił mi, że wielu koderów nie zdaje sobie sprawy, iż tradycyjna (gimnazjalna ) metoda pisania pętli głównej nie jest zbyt dobra. Inni boją się przejścia na tak zwaną symulacje stałokrokową, ponieważ wydaje im się, że jest ona bardzo złożona i niewiele wnosi. Prawda jest jednak taka, że stały krok czasowy jest konieczny, jeżeli na dłuższą metę chcemy mieć jakąkolwiek sensowną fizykę w grze! Z tego powodu postanowiłem napisać artykuł, który został wczoraj opublikowany na Warsztacie. Artykuł ten, zatytułowany “Jak należy pisać aktualizację stanu gry”, poświęcony jest całkowicie tematowi symulacji stałokrokowej. Mam nadzieję, że przyda się on zarówno początkującym jak i zaawansowanym programistom gier. Zapraszam do lektury i komentarzy!

Opis dokumentu (a zarazem biblioteki) głosi:

The C Object System (Cos) is a small C library which implements high-level concepts available in Clos, Objc and other object-oriented programming languages: uniform object model (class, meta-class and property-metaclass), generic functions, multi-methods, delegation, properties, exceptions, contracts and closures.

Oparta o Common Lisp Object System architektura COS’a pozwala nam więc używać technik obiektowych daleko wykraczających poza te zaimplementowane w C++ czy Javie.

Poniżej zamieszczam kodu oparty o jeden z przykładów w bibliotece, deklarujący klasę string z metodami do jej tworzenia i usuwania. Widać wyraźnie wpływy CLOS’u.

Cytując z MSDN:

The #include directive tells the preprocessor to treat the contents of a specified file as if those contents had appeared in the source program at the point where the directive appears.

Tak. #include to jest copy-paste. Ta dyrektywa nie robi nic innego, tylko zwyczajnie wkleja podany plik w miejsce siebie samej. Nie ma w tym żadnej dodatkowej magii – kompilator będzie widział dołączony plik dokładnie tak, jakby programista ręcznie wpisał jego zawartość w miejscu dyrektywy #include. Z tego faktu wypływa kilka istotnych wniosków:

1. Pliki nagłówkowe nie są niczym specjalnym. Nie muszą mieć rozszerzenia .h/.hpp, mogą mieć rozszerzenie .kolorowe-kredki – nikomu to nie robi różnicy, ponieważ pliki nagłówkowe nie są kompilowane.
2. Użycie #include nie ogranicza się do “dołączania plików nagłówkowych”. Ponieważ jest to tylko i wyłącznie kopiuj-wklej zawartość podanego pliku, można napisać na przykład coś takiego:
   float dane[] = {
   #include "dane.txt"
   };

   W praktyce, taka konstrukcja jest nawet dość mądra – dane, zwłaszcza generowane automatycznie, lepiej trzymać na zewnątrz niż bezpośrednio w kodzie.

3. O plikach nagłówkowych należy myśleć jak o kopiowaniu-wklejaniu kodu. Przyjęcie takiego punktu widzenia pozwala łatwo zrozumieć i wyczuć, dlaczego stosujemy deklaracje #ifndef/#endif oraz dlaczego nie umieszczamy w nagłówkach kodu funkcji innych niż inline.

Jak widać, w #include nie ma żadnej magii. Trzeba tylko na tę dyrektywę patrzeć we właściwy sposób. Preprocesor C/C++ jest bardzo prostym narzędziem. A #include jest bardzo prostym copy-paste’m.

Wyobraźmy sobie, że pracujemy ze skanerem do kodu źródłowego. To takie małe ustrojstwo, które czyta wyrażenie typu: x = a+3; i rozpoznaje składowe: identyfikator, operator=, identyfikator, operator+, liczba. W szczególności chcemy podać do tego skanera własne słowa kluczowe. Autorzy skanera przygotowali do tego specjalną funkcję:

Funkcja przyjmuje dwa argumenty – identyfikator, jakim chcemy nazywać nasze słowo kluczowe w kodzie oraz string ze słowem kluczowym. Przykładowo, gdybyśmy chcieli skanować kod języka Ada, moglibyśmy dodać następujące słowo kluczowe:

Od teraz kiedy skaner rozpozna słowo kluczowe begin w analizowanym pliku, my dostaniemy token o identyfikatorze :begin.
Wszystko wygląda super; zaczynamy dodawać kolejne słowa kluczowe:

Programistę uczulonego na powtarzanie się może zacząć powoli denerwować, że przekazujemy dwa nazwane argumenty do funkcji, chociaż de-facto wyglądają one tak samo – identyfikator nosi taką samą nazwę jak słowo kluczowe. Pytanie, czy nie dałoby podać tego identyfikatora tylko raz?

Oczywiście da się. Możemy napisać funkcję, która nas wyręczy w pisaniu. Ale w Lispie możemy też poprosić kompilator, żeby wygenerował odpowiedni kod za nas. Napiszmy makro:

Teraz słowa kluczowe możemy dodawać tak:

Prawda, że mniej pisania? .

Nie wchodząc w szczegóły, w powyższej definicji makra rzeczy poprzedzone znaczkiem ` zostaną wstawione bezpośrednio do kodu źródłowego, a wewnątrz nich rzeczy poprzedzone znaczkiem , zostaną obliczone w czasie kompilacji (dokładniej w tzw. fazie ekspansji makr), a w kodzie znajdzie się wartość tych obliczeń. Przykładowo, wyraźenie ,(string what) w czasie kompilacji zamieni identyfikator na odpowiadający mu string. Powyższe linijki rozwiną się więc do:

Ładny mi bajer…, ktoś powie – Przecież preprocesor w C też coś takiego umie!.
Tak, to prawda – nasze makro jedynie “rozmnożyło” ten sam argument przekazywany do funkcji w dość prosty sposób. Ale – wracając do problemu – wciąż piszemy ręcznie wywołania funkcji dodających pojedyncze słowo kluczowe. Takie wypisywanie wywołań funkcji nie jest do końca tym samym, co zadeklarowanie: chcę dodać następujące słowa kluczowe: …. Dużo lepiej byłoby móc po prostu napisać:

i za jednym zamachem zdefiniować wszystkie słowa kluczowe Ady . Znów, możemy napisać funkcję, która w pętli wywoła dodawanie słowa kluczowego, ale pisanie takiej pętli za każdym razem, gdy chcemy dodać nowe rzeczy nie jest tym samym, co powiedzenie: chcę dodać następujące słowa: …. Poza tym, dlaczego to kompilator nie mógłby tego wszystkiego zrobić za nas?…

… Otóż może. Oto definicja makra add-keywords:

Bez wchodzenia w szczegóły – bo nie to jest celem tego wpisu. Powyższe makro wykona w czasie kompilacji pętlę po wszystkich swoich argumentach, która zwróci w formie listy wyrażenia (add-keyword ,word), a które – jak pamiętamy – same są makrami, i chwilę później zostaną rozwinięte w wywołania naszej skomplikowanej funkcji dodającej słowa kluczowe do skanera. Mając takie dwa makra, pojedyncze wywołanie dodające wszystkie słowa kluczowe zostanie w czasie kompilacji rozbite na odpowiednie wywołania funkcji zaprezentowanej na początku. Zamieniliśmy dużo wpisanych ręcznie pojedynczych wywołań funkcji na dwa makra i jedno wywołanie! Tego już tak łatwo w C nie zrobimy .

Ten mały i stosunkowo prosty przykład makr Lispu miał pokazać ważną cechę tego języka – ponieważ można w nim wykonać dowolny kod w czasie kompilacji i przerabiać w ten sposób sam kompilowany kod, to można łatwo rozszerzać język i dopasowywać go do rozwiązywanego problemu. Dwoma prostymi makrami stworzyliśmy narzędzie dodające hurtem słowa kluczowe. A to już doskonale odpowiada wyrażeniu: Chcę dodać te słowa: ….

Dwa słowa na koniec. Windowsowej binarki do ClozeCall na razie nie będzie – mam na razie z tym małe problemy . Ale każdy, kto ma u siebie zainstalowaną implementację Common Lisp, może sobie pograć .

Wahałem się, czy wziąć udział w konkursie – przecież i tak jest sporo innych rzeczy na głowie. Teraz stwierdzam, że było warto. W czasie prac nad grą nauczyłem się bardzo wielu rzeczy o Lispie. I zaprzyjaźniłem się z Emacsem .

Osobiście poważnie zastanawiam się jeszcze nad wzięciem udziału. Jedynym sensownym terminem startu byłby 24 lub 25 marca. Pomimo tego, że uczelnia przyciska to jednak konkurs ten jest bardzo kuszącą propozycją .

Szczegóły projektu. Miłej zabawy .

QED, bo tak nazywa się biblioteka, powstała jako wynik frustracji po słabym zaliczeniu pierwszego terminu. Opakowuje ona całe to przykre i bolesne w użyciu API IPC UNIX’a do postaci prostych klas i funkcji C++. Większość zadań da się zrobić bez ani jednej linii kodu w czystym UNIXowym API .

Biblioteka QED oraz przykładowe zadania z laboratoriów / kolokwium.

Biblioteczka ta zawiera:

• Uproszczony lexical_cast
• Obiekty do łatwego synchronizowania operacji na std::ostream(tak, na std::cout też!) w programach wielowątkowych
• Funkcję do pobierania czasu z milisekundową rozdzielczością
• Pomocnicze makra zastępujące powtarzający się w kółko kod
• Pomocnicze funkcje do wygodnego fork() (łącznie z przepinaniem STDIN i STDOUT dziecka); fork-exec idiom trzeba sobie zrobić samemu, ale co to za problem wywołać sobie funkcję exec() .
• Klasy izolujące nienazwane i nazwane pipe’y (FIFO), semafory, pamięć współdzieloną i kolejki komunikatów
• Inne pomocnicze funkcje

Mam szczerą nadzieję, że kod ten przyda się przynajmniej tym z Czytelników, którzy już za rok (albo i wcześniej) zmierzą się z Systemami Operacyjnymi na IS .

Dlaczego taka nazwa? QED oznacza elektrodynamikę kwantową – bardzo pokręconą dziedzinę fizyki, o której czytałem sobie “do obiadu” w okresie prac nad powyższą biblioteką. Q.E.D. to też łaciński skrót oznaczający Quod erat demonstrandum (“Co było do udowodnienia”) – co dobrze współgrało z moją frustracją po pierwszym terminie (na zasadzie: “no, na drugim pokażę!”).

Dla niewystarczająco przekonanych, przykład kodu:

Oto kod procesu, który odbiera informacje z kolejki komunikatów, obcina im dwa ostatnie znaki i wysyła je inną kolejką komunikatów.
Teraz, wyobraź sobie, że piszesz w czystym UNIX API .

Poniższy kawałek kodu oblicza funkcję Ackermanna:

Zadanie na rozgrzewkę: jaką wartość przyjmą poniższe wyrażenia?

Prawdziwe wyzwanie: rozważmy poniższe funkcje:

Jaką matematyczną definicję posiadają powyższe funkcje? Na przykład, funkcję k(n) można zdefiniować jako: k(n) = 5n².

Do rozwiązywania powyższych zadań nie trzeba nic kompilować – wystarczy kartka papieru i trochę cierpliwości . Kompilator może się przydać do sprawdzenia wyników.

Życzę powodzenia!

Write in C

The Eternal Flame AKA God Wrote in Lisp Code

Przez ostatnie miesiące sporo się działo. Głównie były to rzeczy związane z bardzo zajmującym semestrem na studiach. Do wielu z tych spraw będę chciał wrócić – w tym do nowych projektów oraz ciekawych języków i technologii, jak na przykład Erlang.

Jak nietrudno się zorientować, zwariowałem. Zakochałem się. Dostałem po głowie**. Zacząłem się uczyć języka Lisp . Dokładniej poznaję dialekt Common Lisp, aczkolwiek ze Scheme też mam czasem do czynienia. Lisp jest w tej chwili moim głównym kierunkiem rozwoju, więc będzie stale odwiedzał ten blog (a już teraz na dobre zamieszkał w jego designie ).

Zmiany techniczne
Główna zmiana (z tych wyraźnie widocznych) dotyczy sposobu wyświetlania kodu. W końcu wyrzuciłem iG:Syntax Hiliter; w tej chwili wpięty jest plugin CodeColorer. Oprócz tego, że jest nowszy i ładniejszy, to wspiera też więcej języków niż jego poprzednik (przede wszystkim Common Lisp i Scheme ).

Umarło pr0.pl, niech żyje pr0.pl
Na koniec chciałbym bardzo podziękować Paszczakowi za około pięć lat prawie bezawaryjnego hostingu na własnym, domowym “szafoserwerze”. Była to bardzo cenna przysługa, zwłaszcza, że parę lat temu o darmowy hosting wysokiej jakości było trudno. Mam jednak nadzieję, że ta zmiana wyjdzie wszystkim (w tym temu blogowi) na dobre.

* – to jest temat na osobną historię.
** – niektórzy powiedzą, że przysłowiowym jabłkiem Newtona. Inni, że cegłą.

Na dzień dzisiejszy chciałbym tylko ogłosić powstanie nowego projektu zespołowego – Artificial Sea. Jest to praca zaliczeniowa z jednego z przedmiotów; powód, dla którego ogłaszam to teraz a nie przed skończeniem jest głównie psychologiczny – publiczne oświadczenie zwykle bardzo dobrze motywuje . Aktualne prace można śledzić na stronie i blogu projektu. Wyprzedzając ten ostatni mogę nadmienić, że projekt wykorzystuje silnik graficzny OGRE 3D .

UWAGA! SPOILER WARNING!
Gorąco polecam zagrać w tę grę przed lekturą tego wpisu, gdyż dalej znajdują się informacje, które mogą wpłynąć na rozgrywkę.

Rozgrywka w całości skupia się na starszej kobiecie odwiedzającej cmentarz. Z punktu widzenia klasycznych gier komputerowych nie ma w The Graveyard zbyt wiele do roboty. Cała gra streszcza się do przejścia fragmentu cmentarnej alejki, zatrzymania się na ławeczce, wysłuchania krótkiej piosenki i wyjścia z cmentarza; nie ma jako takiego celu gry. Całe sedno przekazu skupia się na środowisku oraz na osobie bohaterki – starszej kobiety, która do chwili przedstawionej w grze prawdopodobnie straciła już wszystkich, których znała bądź obchodziła.

Powiem szczerze, że z początku miałem problemy, żeby wczuć się w tę historię. W szczególności nie przemówiła do mnie zawarta w grze piosenka. Ale im dłużej myślałem o The Graveyard, tym bardziej ciągnęło mnie z powrotem i dwóch-trzech kolejnych podejściach złapałem klimat.

Niewątpliwie The Graveyard wymaga nieco więcej zaangażowania umysłowego niż typowa gra. Żeby dobrze odczuć przekaz trzeba się chwilkę zatrzymać, ‘pooddychać’ światem gry, wsłuchać się w dźwięki, melodię i słowa.

Gra jest dostępna w darmowej wersji trial oraz pełnej, w cenie 5$. Nie kupiłem pełnej (ktoś mnie nauczy, jak się obsługuje PayPale i takie tam?), ale z tego co przeczytałem w Internecie to jedyną różnicą jest bardzo specyficzne i zaskakujące jak na grę komputerową zakończenie.

Autorzy gry opublikowali dość obszerny i ciekawy post mortem, który omawia nie tylko kwestie związane z projektowaniem gry i rozwojem pomysłu, ale także ze zdobyciem funduszy na realizację, z odbiorem gry przez graczy i z ostateczną sprzedażą. Polecam lekturę .

Wrong.
Wiadomo, że słowo goto jest w Javie zarezerwowane i nie może być użyte przez programistę. Na poziomie języka programowania nie ma dostępu do tej instrukcji, jednak jest ona dostępna bezpośrednio z poziomu bytecode’u. Fakt ten został w ciekawy sposób wykorzystany przez programistów projektu f2j mającego na celu przetłumaczyć biblioteki FORTRANa na Javę.

FORTRAN jest językiem, w którym korzystanie z goto było na porządku dziennym. Brak omawianego mechanizmu w Javie stanowił poważne utrudnienie przy tłumaczeniu kodu FORTRANa na Javę. Programiści wymyślili więc bardzo sprytny sposób – generując kod Javy wstawiali w miejsce goto instrukcje zastępcze, które po skompilowaniu były na poziomie bytecode’u zamieniane na prawdziwe wywołania “złowrogiej instrukcji”. Swoje wysiłki opisali w ciekawej publikacji.

* – Czytelnik słusznie dostrzeże tu nutkę sarkazmu.

Operatory and i or
Operatory logiczne and i or (odpowiedniki && i II z C++) NIE wchodzą w tzw. krótkie spięcie – to znaczy, że w przypadku wyrażeń logicznych postaci A or B czy A and B oba składniki obliczane są niezależnie od tego, jaka jest ich wynikowa wartość logiczna. Dla kontrastu przypomnę typowe zastosowanie ‘krótkiego spięcia’ z języka C:

Ada posiada jednak operatory, które zachowują się jak odpowiedniki z C++ – są to and then i or else. Początkujący programiści Ady powinni zwrócić na ten fakt szczególną uwagę.

max(), min() i numeric_limits<>
W większości języków funkcje max() i min(), zwracające największy / najmniejszy element z podanych, zwykle umieszczane są w jakichś bibliotekach – w Adzie zostały osadzone bezpośrednio w typach. Dzięki temu piszemy np. Integer'Max(123, 256). Idea ta sięga głębiej – cechy liczb czyli coś, co w C wpisywaliśmy “z palca” a w C++ załatwialiśmy z pomocą std::numeric_limits również jest osadzone w typach. Przykłady dostępnych wartości:

(przepraszam za byle jakie kolorowanie składni – czas poszukać lepszego pluginu)
Lepszy plugin znaleziony

Ogólna koncepcja atrybutów typów jest w tym języku dość rozbudowana – z ciekawszych zastosowań:

Instrukcja null
Interesującą koncepcją jest instrukcja pusta – null. Ada zmusza nas do użycia jej wszędzie tam, gdzie chcielibyśmy po prostu nie robić niczego – np. wewnątrz pustych funkcji.

Switch
Ada wymusza, by instrukcja case (znana w C++ jako switch) obsługiwała wszystkie dopuszczalne możliwości – w przypadku, gdy nie chcemy obsłużyć pewnych wartości, musimy odwołać się do do wariantu others (znanego w C++ jako default). Konstrukcja case‘a jest też dużo wygodniejsza niż jej odpowiedniki w najbliższej rodzinie C++’a – niech zilustruje to przykład:

Warto zwrócić uwagę na sposób łączenia wariantów za pomocą znaku | oraz określania wariantów będących przedziałami.

Key parameters
W różnych miejscach języka występują pod różnymi nazwami – chodzi oczywiście o powiązania pomiędzy nazwami zmiennych a wartościami. Dzięki temu możemy np. zwięźle inicjalizować obiekty:

Lub czytelniej wywoływać procedury:

W obu tych przypadkach kolejność przekazywania zmiennych do wyrażenia jest inna niż kolejność, w której zostały one określone w strukturze / nagłówku procedury. W tym drugim przypadku daje to możliwość wygodnego przekazywania tylko części parametrów opcjonalnych. Jest to moim zdaniem jedna z lepszych cech tego języka.

Zagnieżdżone funkcje
Ada pozwala zagnieżdżać funkcje i procedury wewnątrz innych funkcji i procedur. Tak naprawdę Ada rozdziela część deklaracyjną od samego ciała danej funkcji, dzięki czemu można tworzyć np. procedury lokalne dla innych procedur, typy danych lokalne dla procedur, etc. Powiem jednak szczerze, że nie miałem jeszcze okazji wykorzystywać w jakiś szczególny sposób tej funkcjonalności w żadnym z języków, w których się ona pojawiła.

Funkcje a procedury
Z punktu widzenia Pascala – różnica słowa kluczowego. Z punktu widzenia C++ – kwestia nazewnictwa (procedurą nazywamy funkcję, która nie zwraca wartości). W Adzie jest inaczej – funkcja nie może wyprowadzać wartości na zewnątrz przy użyciu argumentów out i inout; ponadto musi zwracać wartość i wolno jej występować w kodzie tylko jako element wyrażenia. Przykład:

Innymi słowy, wartość zwracana nie może pójść donikąd.

Operator /=
Operator /= (odpowiednik != z C++) jest generowany automatycznie, gdy przeciążony operator = (odpowiednik == z C++) zwraca wartość boolean.

Czym jest nowa linia?
Wygląda na to, że wczytując z pliku tekstowego Ada automatycznie zamienia sekwencje znaków nowej linii wg Unixa (ASCII 10) i Windowsa (ASCII 13 + ASCII 10) na znaki ASCII 30. Cytując ze skryptu “Wstęp do programowania w języku Ada’95″:

znaki ograniczające linie tekstu w systemie Unix (Character’Val (10)) i w systemie DOS, Windows (Character’Val (13)& Character’Val (10)) są interpretowane w taki sposób, że są zawsze zamieniane na znak (Character’Val (30))

Jest to o tyle ciekawe, że ASCII 30 to znak sterujący RS, czyli Record Separator.

Na dzień dzisiejszy Ada ma jak dla mnie tylko jedną poważną wadę – absolutny brak sensownej dokumentacji w sieci. Pomimo Pascalowej składni i braku darmowych wygodnych narzędzi pod Windowsa jest językiem bardzo interesującym i szczerze mówiąc nie zdziwiłbym się, gdyby dalej była używana w miejscach takich jak medycyna czy wojsko, w których niezawodność oprogramowania czasu rzeczywistego jest kluczowa. A – cytując Fusa – jest przytłaczający dowód na to, że sprzęt wojskowy jest niezawodny: wciąż żyjemy.

W związku z tym, że wokół mnie dzieje się obecnie bardzo dużo ciekawych rzeczy związanych z informatyką to na pewno pojawi się też i więcej tekstów; główny przypływ nastąpi jednak najprawdopodobniej po przeprowadzce.

Serdecznie pozdrawiam też Czytelnika z IS2009, którego miałem okazję spotkać na środowym wykładzie z PUKu .

PS. W ramach relaksu polecam rozwiązanie sobie zadań z konkursu Nokia Siemens Networks na Targach Pracy AGH – wyglądały one mniej więcej (podaję z pamięci) tak:

Nie ma powodu, żeby mieć tą samą myśl dwa razy; chyba, że bardzo lubisz ją mieć.

David Allen, Getting Things Done

Powszechnym zjawiskiem stało się posiadanie organizerów – najczęściej różnego rodzaju i rozmiaru kalendarzy w mniej lub bardziej twardej oprawie, które znajdują swoje stałe miejsce w niezliczonych plecakach, torebkach i samochodach. Notatniki te możemy dostać w sklepach papierniczych, biurowych, a nawet i w spożywczych – zwykle wiąże się to z wydatkiem kilkudziesięciu złotych. Pomijając kwestię właściwego używania tych narzędzi (po zimny prysznic odsyłam do Getting Things Done), zapewne nie każdy zdaje sobie sprawę, że w pełni funkcjonalny i elegancki organizer można zrobić samemu za kilka złotych.

Hipster PDA
Pomysł ten, zaproponowany Merlina Manna na 43Folders, sprowadza się do pliku karteczek o rozmiarze niewiele większym od karty kredytowej spiętego klipsem do papieru. Taka prosta konstrukcja ma swoje zalety w stosunku do konwencjonalnych organizerów – zarówno papierowych jak i cyfrowych:

• Elastyczność: Brak narzuconej struktury oznacza, że notujemy co chcemy i jak chcemy.
• Wygoda: Klips do papieru pozwala otwierać notes na wiele różnych sposobów, oraz rozłożyć go, przetasować i wymienić karteczki – na przykład zarchiwizować stare notatki lub dołożyć nowy papier.
• Funkcjonalność: Możemy wyjąć karteczkę z notatkami i bez obaw dać ją komuś innemu.
• Pewność: Nigdy nie skończy się mu bateria, nie grozi mu awaria z powodu wstrząsów.
• Bezpieczeństwo: Raczej mała szansa, że ktoś będzie chciał go ukraść.

Oczywiście Hipster PDA złożony z czystych kartek może okazać się niewystarczający – w końcu jak może zastąpić elegancki kalendarz czy listy adresów, które znajdują się w sklepowych oragnizerach?

D*I*Y Planner i Hipster PDA
D*I*Y Planner (DIY to z angielskiego ‘zrób to sam’) Douglasa Johnstona to zbiór bardzo dobrych darmowych szablonów do budowy własnego organizera. Pośród nich znajdują się m.in.:

• Kalendarz dzienny, miesięczny i roczny
• Checklisty dla agend, zadań i projektów
• Listy zakupów i wydatków
• Różne karty związane z zarządzaniem biznesem i projektami
• Karty związane z powieściopisarstwem i innymi kreatywnymi czynnościami
• Szablony pozwalające tworzyć własne karty do organizera

Oryginalnie zestaw ten powstał z myślą o dużych organizerach, jednak autor stworzył też wersję specjalnie dla Hipster PDA. Jedyne, co trzeba zrobić, by zamienić plik papieru w potężny organizer dostosowany do indywidualnych potrzeb, to… ściągnąć D*I*Y Planner Hipster PDA Edition i wydrukować interesujące nas karty.

Implementacja
Używam Hipster PDA już od ponad dwóch lat i miałem przy tym okazję wielokrotnie sprawdzić, że jest to przydatne narzędzie – chciałbym więc podzielić się kilkoma uwagami związanymi z implementacją.

Konstrukcja Hipster PDA sprowadza się do ściągnięcia wspomnianego pakietu kartek, wydrukowania interesujących egzemplarzy i odpowiednim pocięciu – na jedną kartkę A4 dostajemy cztery wkładki do Hipster PDA. Warto przy tym wszystkim zalaminować (koszt: ok. 4zł) pierwszą i ostatnią kartę (okładki) – dzięki temu będą one sztywniejsze i szersze od reszty, co skutecznie ochroni notes przed zniszczeniem w kieszeni. Klips do papieru nie może być zbyt duży, gdyż wtedy przeglądanie notesu byłoby niewygodne. Dobrze jest też mieć dedykowany długopis lub ołówek do noszenia razem z notesem. Mój obecny Hipster PDA wygląda tak:

Mój Hipster PDA – w kawałkach

Ten sam Hipster PDA po złożeniu, z dedykowanym dla niego ołówkiem automatycznym

Jest to już drugie podejście do tego organizera – o ile za pierwszym razem trzymałem tam kalendarz dzienny, miesięczny i całą masę przeróżnych list, o tyle teraz skupiłem się przede wszystkim na używaniu Hipster PDA jako podręcznego notesu do zbierania informacji (gdzie się podział kalendarz i dlaczego tak jest lepiej to temat na osobny wpis) i przenoszenia specyficznych danych (ostatnio dołączyłem zestaw kodów EAN-13 do najczęściej kupowanych przeze mnie produktów spożywczych).

Hipster PDA, znany szczególnie w kręgu tzw. GTD-owców, to bardzo dobra alternatywa dla konwencjonalnych organizerów. Jest tani, bazuje na papierze i można – a nawet trzeba – nosić go wszędzie ze sobą.

Wykorzystuj moc powłoki

Powyższa rada pochodząca z “Pragmatycznego Programisty” zapewne jest oczywista dla użytkowników systemu UNIX, jednak osoby pracujące pod Windowsem często nie zdają sobie sprawy, jak wielkim usprawnieniem jest dobry zestaw narzędzi konsolowych. Powszechnie wiadomo, że procesor poleceń CMD.EXE nie grzeszy funkcjonalnością, jednak istnieją sposoby poszerzenia możliwości systemu Windows w zakresie aplikacji konsolowych.

Użytkownicy wersji Enterprise lub wyższych systemu Windows Vista i Windows 7 dysponują funkcją Subsystem for Unix-based Applications (w skrócie SUA, znane też jako SFU lub Interix). Ten element systemu komunikuje się bezpośrednio z jądrem systemu Windows i pozwala aplikacjom Uniksowym działać obok zwykłych aplikacji systemu Windows. Ponieważ API Uniksa działa tutaj równolegle do WinAPI można powiedzieć, że system rozdwaja się i po części staje się Uniksem – narzędzia z tego systemu działają na Windowsie natywnie, bez pośredniej emulacji.

SUA pod Windows 7 radzi sobie zarówno w tradycyjnej konsoli jak i z aplikacjami X-Window.

Po aktywacji i ściągnięciu potrzebnego pakietu SUA zawiera jedynie podstawowy zestaw narzędzi. Całą resztę – w sumie ponad 400 różnych programów – możemy pobrać ze strony SUA Community. Wśród dostępnych aplikacji znajdziemy m.in. ls, awk, grep, perl, ssh, xterm czy vim. SUA nie zawiera serwera X – ten ostatni musimy ściągnąć sami. Istnieją darmowe i płatne alternatywy; ja obecnie korzystam z Xming.

Użytkownicy innych wersji systemu Windows ’skazani’ są na pakiet Cygwin. Korzystałem z niego pod Windows 2000 i Windows 2003 Server; pakiet ten spisywał się znakomicie. W dużym skrócie, Cygwin to zestaw DLLek emulujących interfejs unikowych bibliotek C i zapewniający kompatybilność z POSIX. W oparciu o nie skompilowano całą masę przeróżnych narzędzi unikowych – począwszy od coreutils i binutils, przez interpretery Perla, Pythona, kompilator TeX, na narzędziach i Window Managerach dla X-Window skończywszy. Dostępnych składników systemu jest wielokrotnie więcej niż w przypadku SUA. Całość wyposażona jest w dość wygodny (aczkolwiek niezbyt prosty w obsłudze) instalator pozwalający w dowolnej chwili aktualizować lub wgrywać nowe pakiety.

Xterm’y Cygwina pracujące równolegle z aplikacjami Windows 2000.

Aplikacja X-Window składająca się z dwóch programów nie wchodzących w skład pakietu Cygwin, lecz ściągniętych i skompilowanych osobno ze źródeł.

Używałem Cygwina przez liceum oraz początek studiów i mogę powiedzieć, że – po odrobinie zabawy w upiększanie i dostosowywanie – jest to wspaniałe narzędzie. Niestety, pod systemem Windows 7 występuje poważny problem z działaniem aplikacji Cygwinowych – zgaduję, że jest to spowodowane randomizacją przestrzeni adresowej wprowadzoną wraz z Windows Vista. Częstość i przypadkowość awarii praktycznie dyskwalifikuje Cygwina jako narzędzie pod Windows 7; chyba, że ktoś zna metodę jak doprowadzić produkt Cygnusa do ładu.

Cechą wspólną obydwu pakietów jest konieczność rekompilacji każdego dodatkowego narzędzia, którego zechcemy używać – uniksowe binarki nie mogą ‘tak po prostu’ uruchamiać się pod Windowsem. Ponadto domyślnie oba posiadają nieaktualne zestawy narzędzi – na przykład GCC starsze niż kierunek, na którym studiuję. Wybija się tutaj SUA – narzędzia ściągane z SUA Community są stosunkowo nowe. Pod Cygwinem jednak dostępnych narzędzi jest dużo więcej – wliczając brakujący w SUA serwer X. W obecnej chwili mam też małe problemy z uruchomieniem kolorowania kodami ANSI Escape w xterm’ie pod SUA – z Cygwinem nie było tego problemu.

Alternatywą dla powyższych dwóch rozwiązań jest pakiet Perl Power Tools będący implementacją podstawowych narzędzi Uniksa w języku Perl. Inną opcją jest też pakiet UWIN. Pod Windowsem mamy też oczywiście PowerShell’a; jest to narzędzie oparte o zupełnie inne założenia niż system Unix. Różnica ta daje mu możliwości, z którymi warto się zapoznać.

Ktoś mógłby zapytać: dlaczego nie zainstalować Linuksa na wirtualnej maszynie? Otóż nawet istnienie współdzielonych folderów nie daje tej swobody użycia narzędzi UNIX przy pracy nad projektami w systemie Windows. W przypadku wirtualnej maszyny mamy wyraźne rozdzielenie systemu-gospodarza i systemu-gościa; mieszanie funkcjonalności obu systemów przy pracy nad jednym projektem, choć technicznie możliwe, jest dosyć skomplikowane.

Chociaż SUA w obecnej chwili wymaga Windowsów w wersji dostępnej dla niewielu, warto być świadomym istnienia tego pakietu – może przyjść czas, w którym będzie on dostępny także na tańszych wersjach systemu, może też przyjdzie zetknąć się z nim w pracy zawodowej. Niezależnie od tego, które z omówionych narzędzi jest dla nas dostępne warto zastanowić się, czy nasze obecne i przyszłe projekty nie mogłyby skorzystać z potęgi narzędzi Uniksowych pod systemem Windows.

PS. Tak, przesiadłem się na Windows 7 .

Telneting into your rocket is sort of fundamentally cool.

Wiele języków – Lisp, Python, Perl czy Ruby posiadają tzw. pętlę wczytaj-wykonaj-wypisz – z angielskiego Read-Eval-Print Loop, czyli w skrócie REPL. Chodzi oczywiście o tryb interaktywny, w którym możemy wpisywać wyrażenia w danym języku, które są natychmiast wykonywane a rezultaty działania zwracane. Poza oczywistym zastosowaniem jakim jest mądrzejszy kalkulator REPL może przydawać się też do debugowania kodu, często pracującego. Python ma nawet swojego on-line REPLa do wypróbowania .

PHP jest językiem, na którego temat można znaleźć bardzo wiele negatywnych opinii – jednak pomimo tego i tak jest szeroko wykorzystywany do tworzenia aplikacji webowych. Biorąc pod uwagę specyfikę działania skryptów PHP – są one wykonywane od nowa ‘na czysto’ przy każdym zapytaniu HTTP – REPL mógłby być dla tego języka przydatnym narzędziem; szkoda tylko, że autorzy tego nie uwzględnili (ściślej rzecz ujmując PHP posiada tryb interaktywny wywoływany parametrem -a, ale z bliżej mi nieznanych powodów tryb ten jest raczej krytykowany).

Podczas opracowywania wyników Eksperymentu powstał problem – jak pracować na danych, których samo wyciągnięcie z bazy i przetworzenie zajmuje (na localhost’cie) ok. 1.5 minuty? Zwłaszcza kiedy jeszcze na początku nie wie się, co się chce osiągnąć? W takich sytuacjach przydaje się REPL – i na szczęście takowy dla PHP został stworzony.

phpsh to projekt Facebook’a, będący Open-Source i napisany głównie… w Pythonie. Szczegóły pod adresem:
http://www.phpsh.org/ Całość wykonana jest bardzo ładnie i dobrze wykorzystuje możliwość wyświetlania w konsoli kolorowego tekstu. Po rozpakowaniu na serwerze działa po prostu ‘z marszu’  .

Dalsze poszukiwania pozwoliły znaleźć trzy kolejne projekty: php shell, phpa oraz pozwalający na zdalną pracę przez przeglądarkę (i potrafiący wyświetlać wyjście w HTMLu) PHP Interactive. Niech więc każdy wybierze co lubi (ja zamierzam raczej zmienić język  ).

Przydatność narzędzia jakim jest REPL jest nieoceniona, wypadałoby zacytować pracownika NASA JPL dotyczący awarii na pokładzie sterowanego zdalnie pojazdu kosmicznego:

Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem.

Edit 15.09.2009 17:39
Fus donosi, że nawet C# ma swojego REPL’a. Podjęte też zostały próby stworzenia takiego narzędzia dla C i C++.

Jedyną rzeczą, która mogłaby zawierać takie informacje jest zapytanie HTTP wysyłane przez przeglądarkę do serwera. We wstępnych badaniach wykluczyliśmy możliwość użycia nagłówka Referer do rozróżnienia zapytań – co prawda Referer przy elementach osadzonych ma zwykle wartość odpowiadającą osadzającej stronie, ale taki sam nagłówek uzyskamy klikając w link znajdujący się na takiej stronie. Z pozostałych nagłówków żaden nie ma na celu informować o rodzaju zapytania. Okazuje się jednak, że takie rozpoznanie jest możliwe – trzeba podejść do sprawy statystycznie. Podejrzenia dość szybko padły na nagłówek Accept…

Eksperyment, w którym w zeszłym tygodniu około 200 (+/-50) osób wzięło udział pozwolił mi zebrać trochę danych statystycznych. Obiektem zainteresowania było zapytanie HTTP wysyłane przez przeglądarkę przy próbie pobierania obrazka JPG i PNG celem osadzenia go na stronie (<img src=…) lub bezpośredniego wyświetlenia. W centrum zainteresowania znalazł się nagłówek Accept – jedyny, który okazuje się przenosić istotne dla nas informacje.

Wyniki
Nagłówek Accept pozwala przeglądarce określić, jakiego typu multimediów spodziewa się w odpowiedzi na swoje zapytanie. Okazuje się, że przeglądarki spodziewając się elementu do osadzenia na stronie często wysyłają w tym nagłówku inne typy, niż w przypadku obrazków pobieranych do wyświetlenia bezpośredniego. Spójrzmy na przykład na ten wykres dla przeglądarki Firefox:

Wykres ten przedstawia szansę wyświetlenia danego wpisu w nagłówku Accept w zapytaniu o obrazek osadzony (EMBEDDED) lub do wyświetlenia bezpośredniego (LINK). Różnica w zawartości nagłówków jest wyraźnie widoczna. Wykres jest znormalizowany – przeskalowany tak, że wartość 1 odpowiada sytuacji, gdy dany nagłówek wystąpił w każdym zapytaniu danego typu. Okazuje się, że w przypadku Firefoksa rodzaj zapytania mamy jak na dłoni, wystarczy spojrzeć w nagłówek Accept! Przyglądnijmy się więc wykresom dla innych przeglądarek:

Opera nie daje nam najmniejszych szans – w każdym zapytaniu wysyła identyczny nagłówek Accept.

Internet Explorer jak zawsze sprawia dużo radości – z jednej strony odróżnienie rodzaju zapytania zdaje się być trywialnie proste, z drugiej strony IE ma dziwną tendencję zasypywania nas specyficznymi wpisami w nagłówku. Najbardziej zabawny jest image/pjpeg, który w jednym zapytaniu potrafi wystąpić dwa razy obok siebie. Nie rozumiem przyczyn tego zjawiska, ale występuje w wersjach IE od 6 do 8. Ale obiecano mi już, że zostanie to zgłoszone do Microsoftu .

Tutaj bardzo prosto – tak samo jak w IE, zapytania osadzone mają bardzo krótki nagłówek Accept

Ten wykres przedstawia przeglądarki przedstawiające się jako Mozilla, które nie zaklasyfikowały się nigdzie indziej. Wykres jest analogiczny do tego od Firefoksa (tak na prawdę część z przeglądarek na tym wykresie to źle rozpoznane Firefoksy – przyczyny tego zjawiska omawiam dalej). Podobała mi się w tym wszystkim Mozilla, która przedstawiła się jako “ROBOT DO WYKRADANIA KONTENTU” .

Google Chrome także nie robi problemów przy rozpoznaniu typu zapytania.

W przypadku nierozpoznanych przeglądarek sprawa troszkę się zaciemnia, ale wciąż można zidentyfikować przeważające tendencje, które pozwalają rozróżnić rodzaj zapytania.

Dla podsumowania, oto zapytania dla wszystkich przeglądarek na raz:

O samym Eksperymencie


Powyższy wykres przedstawia wszystkie główne rodziny przeglądarek zidentyfikowane przez skrypty (proszę nie zwracać uwagi na wartości numeryczne – odnoszą się ilości zapytań wygenerowanych przez daną przeglądarkę). Identyfikacji przeglądarek dokonywała funkcja get_browser() w PHP. Co prawda funkcja ta dość skutecznie rozdzieliła przeglądarki, jednak mimo wszystko pozostawia wiele do życzenia (mówiąc mniej formalnie – jest skopana) – nie radzi sobie z niektórymi wariacjami Firefoksa, Safari czy Chrome na systemach Apple. Dużo lepiej z deszyfrowaniem nagłówka User-Agent zdaje się radzić sobie jedna ze stron w Internecie.

Serdecznie dziękuję wszystkim, którzy poświęcili swój czas i wzięli udział. Bardzo miłym akcentem było wrzucenie linku do Eksperymentu na Wykop. Ponadto dziękuję wszystkim tym, którzy zachęcali znajomych do wzięcia udziału. Pozdrawiam też użytkowników Linksa i Lynxa . Szczególne podziękowania dla kolegów ze Stosowanej oraz wszystkich gości z Blip’a!

Zastosowania
Mając możliwość rozpoznania celu zapytania o dany zasób możemy odpowiednio zareagować. Przykładowe zastosowania tej wiedzy to:

• Lepsze sprawdzanie, czy ktoś nie hotlinkuje naszych zdjęć/obrazków – klasyczne używanie nagłówka Referer jest nieskuteczne i denerwujące dla osób korzystających z Google Images.
• Serwowanie różnej treści zależnie od rodzaju zapytania – chyba głównie dla zabawy
• Wybiórcze stosowanie przekierowań – serwowanie ramek maskujących adres w przypadku zapytania bezpośredniego oraz używanie np. przekierowania proxy w przypadku zapytań osadzonych.

Proof of concept
Miał być, ale nie ma – próbując z Paszczakiem zaktualizować browsercaps.ini na serwerze coś zepsuliśmy . Z tego powodu na razie przykładu działania nie będzie – dość powiedzieć, że u mnie lokalnie działa . Na podstawie zebranych danych wygenerowałem tabelkę w PHP pozwalającą napisać sobie skrypt rozpoznający rodzaj zapytania.

Co dalej?
Powstają coraz to nowe wersje przeglądarek, a wraz z nimi prawdopodobnie będzie zmieniać się zawartość nagłówka Accept. Można spróbować stworzyć system rozpoznawania zapytania oparty o filtr bayesowski lub wykorzystać inne metody pozwalające na bieżąco aktualizować stan wiedzy na temat używanych wartości nagłówków.
Danych, które zebrałem nie było strasznie dużo, ale jeżeli ktoś chce poddać je dalszej analizie to chętnie je udostępnię .

Edit
Dla wytrwałych bajka o zdecydowanie pokręconych stringach User Agent

Edit 2
Wykresy, o które prosił dr_bonzo:
http://temporal.pr0.pl/blog/materialy/posty/eksperyment/odwrocone
Czytelniej ? zginęły przy zmianie serwera, powinny być gdzieś w backupie.

mod_rewrite i przepisywanie URL
Kluczem do stworzenia systemu skracania adresów jest możliwość ‘przepisywania adresów’ – dzięki temu nasz system będzie umiał obsłużyć adresy postaci: http://moj.system.skrotow.pl/skroconyurl. Do tego celu można wykorzystać na przykład bardzo popularny moduł mod_rewrite serwera Apache. Krótko i konkretnie temat ‘ładnych linków’ omówił na swojej stornie porneL. Przykład .htaccess, którego obecnie używam (nazwy związane z serwisem zmienione ):

Występuje tu kilka rzeczy, których nie omówił jeszcze porneL. Po pierwsze, dyrektywa RewriteBase – pomaga ona w poprawnym działaniu przepisywania adresów w przypadku, gdy nasza strona znajduje się w podkatalogu na serwerze. Z tą dyrektywą jest zwykle trochę zabawy, więc proszę okazywać cierpliwość . Nie znam prostego (w kilku zdaniach) wyjaśnienia jej roli – jeżeli ktoś umie takowe sformułować, to zachęcam do uczynienia tego w komentarzu!

Po RewriteBase mamy dwie linie dokonujące usuwania slashy z URI w ramach procesu przekształcania adresu do postaci kanonicznej. Istotne (zwłaszcza dla Google) jest tutaj przekierowanie 301. Kolejne trzy linijki sprawdzają, czy żądany adres nie jest fizycznie istniejącym plikiem lub katalogiem. Podobny kod można na przykład znaleźć w .htaccess Wordpressa. Jeżeli żądany adres nie pasuje do żadnego istniejącego pliku lub katalogu na serwerze, to wywoływany jest nasz skrypt (index.php) z parametrem adres zawierającym całą końcówkę wpisaną przez użytkownika.

To tyle tytułem wprowadzenia do .htaccess na praktycznym przykładzie – na temat tego modułu jest bardzo dużo materiałów w sieci – myślę, że każdy sobie poradzi. Mając już adres wpisany przez użytkownika należy jakoś odesłać mu właściwą treść. Możemy to zrobić na kilka sposobów:

Przekierowania HTTP
Przekierowania te dość dokładnie omawiałem w jednym z ostatnich postów. Jest to najbardziej podstawowy sposób oddania komuś żądanego zasobu ze ’skróconego’ (przez termin ’skrócony adres’ w tym tekście rozumiem każdej długości alias w serwisie skrótowym – nawet, jeśli jest dłuższy od oryginalnego URL ) adresu. Wybór kodu powinien zależeć od tego, jaką rolę pełni skrócony adres – 301 gdy zdecydujemy się przypisać go na stałe do miejsca docelowego, 302 lub 307, gdy adres docelowy może ulec zmianie.
Właściwości tej metody to:

• Takiego przekierowania można używać także do elementów osadzanych, np. w tagach <img>
• Nie można zamaskować adresu docelowego – jest on widoczny w pasku adresu przeglądarki.
• Zwłaszcza w przypadku użycia kodu 301 PageRank przelewa się na adres docelowy (ale ostrożnie z tym).
• Opiera się w całości na protokole HTTP, więc musi być wspierana przez wszystkie przeglądarki.

Ciekawostka – serwis tnij.org zdaje się odsyłać nagłówek 301 Moved Permanently, a nie 302 Found lub 307 Temporary Redirect.

Przekierowania “meta refresh”
Innym rodzajem przekierowania, wykonywanym całkowicie po stronie klienta, jest wymuszenie odświeżenia adresu przez przeglądarkę przy użyciu znacznika <meta>. Przykładowy kod wygląda następująco:

Generujemy taki kod, podstawiając odpowiedni adres. Cyfra 0 może zostać zastąpiona inną – określa ona czas w sekundach, po jakim przeglądarka powinna dokonać odświeżenia strony z nowym adresem.
Własności tej metody:

• Nie można zamaskować adresu docelowego – jest on widoczny w pasku adresu przeglądarki.
• Chodzą wieści, że Google umie czytać ten typ przekierowania z kodu HTML – ale na rewelacyjny przelew PageRank bym nie liczył.
• Może nie być wspierane przez wszystkie przeglądarki. Dlatego też powinno się umieścić w dokumencie informację o linku dla przeglądarek nie wspierających tej metody.
• Znikoma przydatność.

Ponieważ w tym przypadku znacznik <meta> nadpisuje istniejący w HTTP nagłówek Refresh, istnieje też wariant tej metody nie wymagający umieszczania dodatkowego znacznika w dokumencie HTML – możemy zamiast tego wysłać dowolny HTML i wygenerować odpowiedni nagłówek HTTP w skrypcie. Przykład:

Osobiście ciekawi mnie, jak przeglądarka zareagowałaby w przypadku zapytania o osadzony element (<img src="... >), gdyby odesłać jej obrazek razem z nagłówkiem Refresh. Być może sprawdzę to przy najbliższej okazji.

Przekierowania Javascript
Metoda podobna do meta refresh – wysyłamy stronę ze spreparowanym JavaScript’em, który automatycznie przekierowuje użytkownika pod inny adres.
Cechy techniki:

• Nie działa z elementami osadzonymi.
• Wiele crawlerów nie umie obsługiwać JavaScript’u – wyszukiwarki nie zobaczą przekierowań.
• Niektórzy nie posiadają lub celowo wyłączają obsługę JavaScript’u w przeglądarce.
• Teoretycznie można próbować użyć jej do zamaskowania adresu docelowego zasobu w pasku adresu – niestety nie znam się aż tak na JavaScript, żeby podać przykład.

Maskowanie adresu – metoda ramek
Użycie znienawidzonego znacznika <frameset> pozwala bardzo skutecznie zamaskować adres docelowy strony, na którą przekierowujemy (i przy okazji zmienić jej tytuł). Wystarczy wygenerować taki oto HTML:

Własności tej metody:

• Pozwala zamaskować adres docelowy i wymienić tytuł.
• Nie działa z elementami osadzonymi – z oczywistych przyczyn.
• Standardem są już skrypty pozwalające stronie automatycznie ‘wyskoczyć z ramki’ – i wtedy nici z maskowania adresu.
• Może być przyczyną kontrowersji i ataków ze strony niedouczonych webmasterów stron docelowych.

Tę technikę spotykamy się wbrew pozorom dość często – na stronach takich jak Wykop.pl czy nawet Google Images. Takie strony po prostu dodają dodatkową ramkę z własnymi informacjami .

Przekierowania ‘proxy’
Najbardziej bezpośrednią metodą wyświetlenia cudzego contentu pod swoim adresem jest pobranie jej przez nasz serwer i oddanie użytkownikowi. W PHP pomóc nam w tym może funkcja readfile(). Metoda jest bardzo prosta w teorii i gwarantuje zamaskowanie adresu, jednak rodzi też szereg trudności technicznych:

• Jeżeli oddajemy w ten sposób stronę internetową to najprawdopodobniej posypią się wszystkie relatywne odnośniki do obrazków, skryptów i CSS – dostaniemy goły, nieużyteczny dokument HTML.
• Jeżeli oddajemy coś innego niż zwykły tekst to musimy ręcznie określić typ MIME zwracanego zasobu. A ponieważ zasób jest nie u nas, to możemy albo zgadywać ten typ (np. po rozszerzeniu), albo odczytywać dopiero po ściągnięciu. Innymi słowy – dodatkowa robota.
• Cała treść przechodzi przez nasz serwer, skutecznie go spowalniając (już nie mówiąc o ewentualnych limitach downloadu).

Wspominam o tej technice, gdyż ma ona także dużo dobrych właściwości:

• Kompletne zamaskowanie adresu zasobu.
• Działa z elementami osadzonymi.
• Pozwala nam modyfikować zasób i sposób jego przetwarzania (np. można wymusić na przeglądarce wyświetlenie okienka “Zapisz jako…”).

Wspomniane przeze mnie problemy techniczne można oczywiście obejść, ale pytanie czy nie jest to przerost formy nad treścią .

Trochę ten post wyszedł przydługi… . A teraz obiecany na początku…

Eksperyment HTTP
Chciałbym w tym miejscu podziękować wszystkim osobom, które już wzięły udział i rozgłaszały Eksperyment wśród innych. Ruch pierwszego dnia był spory; jakaś dobra dusza nawet wrzuciła link na Wykop . Zebrałem już dość dużo danych, jakieś 85% tego, co założyłem jako minimum. Dlatego jeżeli ktoś jeszcze nie brał udziału, to zapraszam, a jeżeli już brał to zachęcam o podrzucenie linka innym osobom! Myślę, że wyniki opracuję w najbliższych dniach. Dla zaostrzenia apetytu powiem tylko, że eksperyment ma duży związek z tematem tego posta .

Aktualizacja – 14.09.2009
Wyniki już są .

Drodzy Czytelnicy, w ramach prac nad pewnym projektem i poszerzaniem wiedzy n/t HTTP przeprowadzam mały eksperyment statystyczny. Każdy z Was może wziąć w nim udział i tym samym zrobić coś dla dobra Galaktyki! . Wystarczy jedynie wejść na podaną niżej stronę eksperymentu i po załadowaniu kliknąć w oba obrazki (mają podłożone linki).

Strona Eksperymentu

W eksperymencie tym zbieram tylko troszkę danych na temat zapytania HTTP wysyłanego przez przeglądarkę. Wyniki i opracowanie podam po zebraniu odpowiedniej ilości danych, czyli – miejmy nadzieję – w ciągu kilku najbliższych dni. Jednocześnie bardzo prosiłbym o nie znęcanie się nade mną przez fałszowanie wyników lub hackowanie strony. Wystarczy wejść, kliknąć dwa razy i wyjść .

Z góry dziękuję wszystkim, którzy zechcą wziąć udział w eksperymencie! Wyniki wkrótce!

Ważny Edit!
Dziękuję tym, którzy tak ochoczo zareagowali na wezwanie do wzięcia udziału! Jednocześnie mam prośbę – jeżeli ktoś ma zainstalowane w systemie kilka przeglądarek WWW, to zachęcam do wejścia na stronę Eksperymentu każdą z nich z osobna! Dzięki temu zebrane zostanie więcej istotnych danych .

Przekierowania HTTP
Jak wiadomo, fundamentalny dla WWW protokół HTTP zawiera kody odpowiedzi (opisane w sekcji 10 specyfikacji RFC2616), którymi serwer WWW informuje przeglądarki o tym, co przeglądarki mają dalej robić. Nas w tym miejscu interesują kody serii 3xx (sekcja 10.3 RFC). Zadaniem tych kodów jest przekierowanie przeglądarki pod inny adres docelowy. Kody te mają też wpływ na crawlery wyszukiwarek, które przecież starają się udawać ludzi. Powiemy sobie o:

• HTTP 301 Moved Permanently
• HTTP 302 Found
• HTTP 303 See Other
• HTTP 307 Temporary Redirect

Gdy serwer dokonuje przekierowania to oprócz odpowiedniego kodu statusu i opisu wysyła także nagłówek Location zawierający adres, pod który ma udać się przeglądarka. Przykładowa odpowiedź-przekierowanie HTTP, które przeniesie przeglądarkę na stronę Google, może wyglądać następująco:

HTTP/1.1 301 Moved Permanently
Kod ten tworzy permanentne przekierowanie pod adres docelowy. To tak, jakbyśmy powiedzieli przeglądarce: “URI, o które prosiłaś znikło. Być może nigdy go nie było, a na pewno nigdy nie będzie. Nie będę dostarczać żadnej treści dla zapytania o to URI, więc zaktualizuj swoje zakładki podanym niżej adresem i nie zawracaj mi już więcej głowy. Nigdy więcej.”.

Przekierowania 301 używamy najczęściej przy przeniesieniu całej strony, gdy chcemy poinstruować ludzi i crawlery o zmianie lokalizacji. W szczególności powinniśmy to zrobić, jeżeli zależy nam na utrzymaniu dotychczasowej pozycji strony w wyszukiwarkach. Google rozumie kod 301, ale stronę trzeba przenosić z głową.

Kod 301 jest przekierowaniem ‘na zawsze’ – URI raz oznaczone tym numerem nie powinno być nigdy więcej używane w innym celu. To znaczy, że mamy obowiązek go utrzymywać – przynajmniej jeśli zależy nam na Page Rank – tak długo, jak to tylko możliwe (tak, trzeba płacić i za starą domenę ). Nie powinno się też nigdy zmieniać miejsca, do którego odsyła to przekierowanie. Kodu 301 powinniśmy używać też do tzw. sprowadzenia adresu do postaci kanonicznej (pozwala uniknąć problemów z wyszukiwarkami, w tym podwójnego widzenia treści dla adresów z www i bez www). Przykład użycia pliku .htacccess i mod_rewrite do zapewnienia postaci kanonicznej adresu:

Należy zwrócić uwagę na fragment R=301 w ostatniej linijce – oznacza to, że do zmiany adresu zostanie użyte przekierowanie 301.

Aby przekierowanie 301 zostało wykonane poprawnie musimy wysłać przeglądarce tekst z kodem i statusem – w przeciwnym razie wykonane zostanie domyślne przekierowanie 302 Found, o którym niżej. Tyczy się to szczególnie PHP, gdzie już chyba zwyczajem stało się pisanie:

Taki kod wykona przekierowanie 302. Poprawnie sformułowane w PHP przekierowanie 301:

HTTP/1.1 302 Found
Przekierowanie 302 jest chyba najbardziej nadużywanym przekierowaniem w sieci – głównie z powodu tego, że jest to przekierowanie domyślne, które zostanie wykonane jeżeli samodzielnie nie wykonaliśmy innego przekierowania. Problemy dotyczą głównie niewłaściwego używania 302 w miejscu, gdzie powinno być 301 – częściowo z niechlujstwa, a częściowo – wg Simon’s Pamphlets – z różnych mitów rozpowszechnianych w środowisku SEO. Pomyłkowe użycie 302 zamiast 301 jest niegroźne zarówno dla człowieka jak i przeglądarki, ale może wyrządzić krzywdę pozycji strony w wyszukiwarce.

Kod 302 Found (w HTTP/1.0 zwany 302 Moved Temporarily) służy do wskazania tymczasowej lokalizacji zasobu. Ponieważ jednak przekierowanie może się zmieniać, specyfikacja sugeruje, by klienci dalej używali tego adresu, którym przyszli, a nie tego, który dostaną z przekierowania. Jeżeli chce się z jakiegoś powodu odesłać użytkownika na inną stronę – czy to wewnętrzną, czy zewnętrzną w stosunku do naszego serwisu – to możemy użyć właśnie tego kodu. W PHP wygląda to tak:

Poza niewielkimi różnicami w specyfikacji dotyczącymi cache’ingu kody 302 obu wersji robią w zasadzie to samo. I chociaż dotychczasowe (9.3) RFC (10.3.3) nie pozwalały zmieniać przy przekierowaniu metody zapytania (np. z POST na GET), większość przeglądarek to właśnie robi (przeważyły prawdopodobnie względy bezpieczeństwa) – kod 302 jest interpretowany tak jak 303. Aby można było rozróżnić, kiedy serwer chce wykonać przekierowanie ze zmianą metody zapytania na GET a kiedy bez zmiany, wprowadzono w HTTP/1.1 dwa dodatkowe kody – 303 See Other i 307 Temporary Redirect. Ponieważ przeglądarki oraz crawlery potrafią już ‘rozmawiać’ protokołem HTTP/1.1, to poza szczególnymi przypadkami gdy z jakiegoś powodu musimy ‘bawić się’ w HTTP/1.0 możemy spokojnie korzystać z nowych kodów.

HTTP/1.1 303 See Other
Według RFC2616 (10.3.4) celem istnienia tego kodu jest przede wszystkim umożliwienie wynikom zapytania POST możliwości przekierowania do innych zasobów. W momencie otrzymania kodu 303 przeglądarka powinna zmienić metodę zapytania na GET. Poprawne użycie w PHP:

Kodu tego powinniśmy używać w skryptach wywoływanych zapytaniem POST – po przetworzeniu żądania powinny one wykonywać przekierowanie 303 na stronę, która wyświetli nam wyniki. Dzięki temu, gdy użytkownik odświeży stronę, zapytanie POST (mogące mieć przecież jakieś skutki uboczne!) nie zostanie wykonane ponownie (Firefox w takich sytuacjach pyta, czy ponownie wysłać dane). Jest to o tyle istotne, że zgodnie ze specyfikacją do wprowadzania zmian (edycja, usuwanie, itp.) w zasobach strony powinniśmy używać metody POST, nie GET (celowo pomijam tutaj PUT i DELETE – architektura REST, która je wykorzystuje, nie jest jeszcze aż tak popularna).

HTTP/1.1 307 Temporary Redirect
Kod 307 to nasz najlepszy przyjaciel, gdy potrzebujemy wykonywać przekierowania do tymczasowych zasobów. W przeciwieństwie do 303 nie zmienia metody zapytania – kod 307 zachowuje się tak, jak powinien był się zachowywać w przeglądarkach 302. To właśnie tym kodem chcemy się posługiwać, więc warto zadbać o jego poprawne wysłanie, żeby przypadkiem nie wyszedł nam 302:

Jednym z zastosowań przekierowania 307 jest przekierowywanie kanałów RSS/Atom do usługi FeedBurner.

Podsumowanie – kiedy używamy którego kodu?

• HTTP 301 Moved Permanently – gdy zasób został na stałe przeniesiony pod inny adres. Przekierowania 301 powinniśmy utrzymywać włączone tak długo, jak to możliwe i nigdy nie poddawać ich recyclingowi.
• HTTP 302 Found – gdy musimy borykać się z protokołem HTTP/1.0.
• HTTP 303 See Other – gdy skrypt, który otrzymał zapytanie POST chce wyświetlić jakieś wyniki – powinien wtedy wykonać przekierowanie 303 na stronę z wynikami. Unikniemy dzięki temu ponownego wysłania zapytania POST przy odświeżeniu strony.
• HTTP 307 Temporary Redirect – wszystkie sytuacje, gdy robimy tymczasowe przekierowania. Skracanie nazw URI, odesłanie do innej strony, przekierowanie RSS/Atom na FeedBurnerm itd.

Dodatkowe informacje

• Omówione przekierowania operują bezpośrednio na poziomie protokołu HTTP. Oznacza to, że możemy ich użyć do przekierowywania np. obrazków osadzanych w tagach <img>.
• Osobom używającym .htaccess do sprowadzania adresu do postaci kanonicznej (w tym np. usuwanie bądź dodawanie ‘www’ przed nazwą) polecam upewnić się, że używają przekierowania 301 a nie domyślnego 302.

Zainspirowany Gynvael’em i innymi postanowiłem utworzyć też dział Code Snippets, w którym znajdować się będą różne drobne i – miejmy nadzieję – przydatne fragmenty kodu. Jako pierwszy umieszczam drobną klasę PHP realizującą u mnie w projekcie przekierowania oraz obsługę wybranych kodów 4xx i 5xx.

Hasła geometryczne
Widziałem nie raz osoby stosujące geometryczne wzorce do zapamiętania jakiegoś hasła. Przykładowo, hasło “123wsx” może być trudne do zapamiętania jako ciąg znaków, jest natomiast bardzo proste do zapamiętania jeśli zobaczymy w jaki sposób wpisuje się je na klawiaturze komputera. Podobnie, widziałem alarm zakodowany w taki sposób, że ciąg liczb nie ma żadnego znaczenia, natomiast klawisze układają się w łatwy do zapamiętania wzór. Nie jest to oczywiście zbyt bezpieczne – hasło typowo geometryczne jest teoretycznie łatwiej podpatrzeć ‘z za pleców’ niż każde inne. Być może łamiąc hasła powinno się oprócz najpopularniejszych wyrazów uwzględniać także najpopularniejsze wzory geometryczne .

Źródła wiedzy
Kilka miejsc, które mogą się przydać do zdobycia wiedzy w wielu dziedzinach, głównie ścisłych:

• “Ważniak” - znany i używany przez polskich studentów kierunków informatycznych zbiór materiałów podzielonych na wirtualne kursy. Coś jak wirtualna uczelnia
• Wykłady Feynmana – udostępnione on-line wykłady dr Richarda Feynmana (tego Feynmana). Wspominał o nich Alex w swoich notatkach. Nie sprawdzałem jeszcze tego osobiście, ale wygląda na coś bardzo wartościowego.
• Open Course Ware – czyl MIT on-line. Wspomniał o tym Bartosz Zajączkowski na swoim blogu.

Kolejna rzecz do sprawdzenia .

Blip i Google
Od około miesiąca eksperymentuję z serwisem Blip. W ciągu tego czasu mój profil blipowy wypozycjonował się ’samoistnie’ na pierwsze miejsce w Google’ach przy pytaniu o moje nazwisko. W podobny sposób wyszukując jednego z moich kolegów po nazwisku znajdziemy Twittera już na drugim miejscu. Tak błyskawiczne pozycjonowanie się serwisów mikroblogowych może być niebezpieczne dla każdego, kto zaczyna tam wypisywać nieprzemyślane głupoty .

Ah, w chwili przygotowywania tego posta do publikacji znalazłem na Wykopalisku artykuł poruszający temat oświecenia Linuksa .

Wczoraj (w niedzielę, 19.07.2009) w Krakowie dobiegł końca pierwszy turnus Lata w Teatrze. Tematem przewodnim był Pan Twardowski oraz cienie. Dzieci, wspólnie z artystami, zrealizowały serię bardzo interesujących prac obejmujących musical, teatr cieni czy konstrukcję makiety Księżyca (fani Warhammera by się nie powstydzili ) i trzech całkiem dobrze działających katapult. Organizatorem krakowskich zajęć jest Teatr Figur (strona padła, bo się rachunków nie zapłaciło ).

Cieszę się, że taka akcja ma miejsce w Polsce. Zarówno nasi młodsi podopieczni mogą na tym wiele skorzystać (krakowskie przedstawienia były wykonane na prawdę rewelacyjnie) jak i starsi mogą się czegoś nauczyć – obcowania z kreatywnością nigdy za wiele. Ja się nieźle ubawiłem więc polecam wszystkim . A tak w ogóle o Lecie w Teatrze dowiedziałem się dzięki łapance ulicznej, którą przeprowadzała grupa dziennikarska.

“Widok prezentera” dostępny w PowerPoint 2007 (i podobno także w PowerPoint 2003) udostępnia nam na ekranie naszego komputera:

• Zegary – jeden z nich mierzy czas trwania prezentacji, drugi – pokazuje aktualną godzinę
• Notatki – adnotacje do slajdów wyświetlane są z prawej strony – można w nich umieścić te same punkty i uwagi, które zwykle mamy na kartce
• Zakreślacze i pismo odręczne – możemy szybko przekształcić wskaźnik myszki w narzędzie do pisania odręcznego lub zwykły zakreślacz (taki gruby pisak, którym studenci lubią bazgrać po kserówkach

Poniższy screen ilustruje użycie “Widoku prezentera” oraz jego funkcji zakreślacza.

Ktoś powie, że papier jest wygodniejszy – jestem skłonny się zgodzić. Typowa forma prezentacji (także biznesowych!), jaką dotąd widziałem sprowadza się do postawienia laptopa na stoliku lub ławeczce. Korzystanie z komputera staje się dla prelegenta niewygodne i nieeleganckie (trzeba się schylać). Wydaje mi się jednak, że problem ten można obejść jeśli tylko się chce. Ponadto technologie takie jak ekrany dotykowe oraz laptopy-tablety (które można po prostu trzymać w ręce) mogą pomóc i ostatecznie wyrzucić nadmiarowy papier z prezentacji multimedialnych.

A co mają zrobić użytkownicy OpenOffice? Pod Windows można skorzystać z narzędzia ZoomIt pakietu SysInternals (czyli de-facto Microsoftu), który pozwala w sposób wygodny powiększać fragmenty obrazu oraz rysować po nich i wprowadzać tekst. Program ten radzi sobie dobrze z dwoma monitorami i może przydać się nie tylko podczas prezentacji w Impressie .

Niedługo wrócę z końcówką reportażu i jakimiś nowymi tekstami, a na razie wszystkim Czytelnikom życzę słonecznych wakacji .

Wrzuciłem troszkę nowych zdjęć do galerii. Pojawiły się też pierwsze filmiki, ale o tym później . W tej części reportażu opisuję osobiste zmagania z robotem Graupnera, które okazały się wielkim sukcesem (“I’m making a note here: HUGE SUCCESS”) i doprowadziły do sytuacji, w której robot z zamontowanym aparatem cyfrowym rozbijał się po sklepach w Galerii Krakowskiej .

Kalibracja czujników odległości
Przede mną znajdowały się czujniki odległości. Z instrukcji po niemiecku dowiedziałem się tylko tyle, że działają na podczerwień i mierzą odległość w granicach 4-30cm. Jego obłsuga, podobnie jak każdego innego analogowego czujnika na tej płytce sprowadzała się do wywołania funkcji, która zwracała wartość od 0 do 255. Nigdzie w dokumentacji nie podano, jak mają się te wskazania (0..255) do odległości wyrażonej w metrach (nie była podana tzw. charakterystyki czujnika). Zmierzyłem ją więc eksperymentalnie. Po stwierdzeniu, że większe wartości występują, gdy wykryty obiekt znajduje się bliżej czujnika posłużyłem się linijką i poniższym kodem:

Jak nie trudno zauważyć, regulując parametr FORWARD_THRESHOLD zmieniałem moment, w którym uruchamiały się silniczki. Po rozciągnięciu składanej kilkumetrowej linijki mierzyłem więc czujnik ręką, badając w którym momencie zaczyna on wskazywać zadaną w FORWARD_THRESHOLD wartość. W ten sposób uzyskałem 10 punktów, układających się w mniej-więcej w eksponentę .

Pomiary nie były szczególnie dokładne, ale biorąc pod uwagę, że przedział od 2 centymetrów do ponad 1.5 metra mieści się w zakresie od 0 do 150 stwierdzam, że przybliżenie jest wystarczające . Wartości powyżej 150 nie mierzyłem częściowo z braku potrzeby, a częściowo z tego, że różnice między kolejnymi wartościami wynosiłyby teoretycznie ułamki centymetra. Uzyskane pomiary błyskawicznie zweryfikowałem w praktyce i okazały się one wystarczająco dobre, by robot mógł się poruszać w terenie. Postanowiłem więc napisać…

Proste AI robota
Rzeczywiście, chociaż w konstrukcji jest ono stosunkowo proste, to w praktyce przerosło (pozytywnie) moje oczekiwania. Inteligencję robota zapewniała prosta maszyna stanów**. Konstrukcję robota i skończoną maszynę stanów ilustruje poniższy schemat:

Robot, którego programowałem

Ten prosty system okazał się niewiarygodnie skuteczny w terenie. Pierwsze testy na arenie pokazały, że ściany i ręce małych dzieci są dla robota praktycznie niegroźne (jedyny problem sprawiały duże roboty, które miały korpus powyżej linii czujników). Niezłym wyzwaniem była nawet próba złapania robota na tej arenie, by go wyłączyć . Jednak na prawdę ciekawie zrobiło się gdy robot, uzbrojony w aparat cyfrowy, wyruszył na spacer po Galerii. Samodzielnie poruszał się między ludźmi (ku wielkiej uciesze kilkulatków), zwiedził też kilka sklepów. Poniżej dwa filmiki – jeden z areny, drugi z jazdy po Galerii:

Gdzieś pomiędzy tym wszystkim obsługa zaczęła mi podsuwać informacje, że ponoć te roboty mogą być zdalnie sterowane. Pytali się mnie, czy nie byłbym im w stanie tego uruchomić…

Ciąg dalszy nastąpi…

Przypisy:
* – Przeraża mnie fakt, który zaobserwowałem, że sporo osób zetknęło się z pojęciem interpolacji w szkole lub na studiach i kojarzą ją jedynie z ‘dziwnymi wzorami’ Lagrange’a i Newtona, podczas gdy nie umieją w żaden sposób wyobrazić jej sobie w praktyce. Wspomnę coś na ten temat niedługo, stay tuned .

** – Niektórzy Czytelnicy mogą nie być zaznajomieni z koncepcją maszyny stanów skończonych (ang. Finite State Machine). Żeby nie sypać skomplikowanymi definicjami z Wikipedii, powiem krótko – prostym (i typowym) przykładem FSM jest… żarówka w pokoju. Jako obiekt ma dwa stany wewnętrzne – może być zapalona lub zgaszona. Zależnie od stanu inaczej się zachowuje (zapalona – świeci i grzeje się, zgaszona – nie świeci i stygnie). Ustalone są też przejścia między stanami – używając włącznika możemy przełączyć żarówkę ze stanu świeci się na stan nie świeci się i odwrotnie. Projektując FSM rysuje się często grafy podobne do tego, który znalazł się też w tym poście.

Dodatek (w jakiś tam sposób) wykrywa stronę wyszukiwania Google i w elegancki sposób dokleja obok Wolframa – działa więc zarówno przy wpisywaniu zapytania bezpośrednio na stronie Google jak i przy skorzystaniu z listy wyszukiwarek na pasku narzędzi przeglądarki.
Have fun

EDIT (13.06.2009)
Wygląda na to, że od dzisiaj plugin nie działa jak trzeba – w momencie, gdy wygenerują się wyniki Wolframa, użytkownik zostaje nagle przeniesiony na stronę wyszukiwania WolframAlpha. Efekt ten występuje od kilku-kilkunastu godzin co potwierdza zarówno komentarz Plokina, recenzja na stronie pluginu jak i fakt, że wczoraj rano – jak to się mówi – jeszcze mi działało . Podejrzewam, że to Wolfram – świadomie lub nie – zepsuł plugin zmieniając coś na swojej stronie. Anyway, chwilowo, plugin nie działa .

EDIT (14.06.2009)
Plugin znów działa – poprawka zapewne dokonała się po stronie Wolframa, gdyż nie ściągałem nowej wersji a na stronie pluginu nie ma wzmianki o naprawieniu problemu.

Oto kolejna część reportażu z imprezy Stulecie Robotów. W ramach testu plugina NextGEN Gallery wrzuciłem kilka pierwszych zdjęć z tego wydarzenia. Niedługo pojawią się filmiki, stay tuned…

Roboty dostaliśmy w dość rozsypanej postaci – przez pierwsze pół godziny grzebaliśmy w pudełkach szukając zasilania i programatora do szkieletu, który zdawał się być najprostszą w pełni działającą konstrukcją. Po uruchomieniu mechaniki przyszedł czas na programowanie; odnalezienie się zajęło jakieś kolejne pół godziny. Niestety, robot po wgraniu programu wyprawiał nieopisane cuda z silniczkami. Próba rozwiązania tego problemu zajęła mi praktycznie cały czas do 19:00. Pomagał w tym Stanisław, który pojawił się w międzyczasie w Galerii. Robot jednak nie zaczął działać poprawnie; musieliśmy go w końcu zostawić i opuścić galerię.

Roboty Graupnera

Platforma Graupnera różni się zasadniczo od Lego Mindstorms i Fischertechnika – w przypadku dwóch ostatnich konstrukcja robota to plastikowe klocki, natomiast ten pierwszy to pełnoprawny metalowy robot zrobiony z przykręcanych / mocowanych części. Sercem układu sterującego, nazwanego SoccerBoard, jest procesor ATmega128. SoccerBoard pozwala na podłączenie aż sześciu różnych silników (trzy z nich typowa konstrukcja wykorzystuje do poruszania się), 8-miu wejść cyfrowych oraz 8-miu wejść analogowych. Dodatkowo pierwsze cztery wejścia analogowe i cyfrowe mogą służyć za wyjścia mocy, którymi można np. zasilać żaróweczki. Przydatnym do debugowania programów mogłaby się okazać możliwość podłączenia małego wyświetlacza LCD – gdyby ktoś na festiwalu taki wyświetlacz miał.

Roboty Graupnera oparte są o platformę niemieckiej firmy qfix. Całość programuje się w C++ przy użyciu specjalnie przygotowanego prostego API. Razem z oprogramowaniem robota instalowany jest Programmer’s Notepad, w którym proces kompilacji i programowania układu został uproszczony do naciskania klawiszy F5 i F6.

Korzystając z chwili wolnego (nie mieliśmy tego dnia zajęć) udałem się do Galerii by kontynuować próby poprawnego zaprogramowania SoccerBoard’a. Analizowałem dokładnie API qfix’a i studiowałem pojedyncze bity na portach, które ustawiały funkcje mające wpływ na silniczki. Wreszcie doszło do tego, że znalazłem w Internecie SDK i zainstalowałem je na swoim laptopie. I wtedy przypadkiem odkryłem prawdziwą przyczynę błędnej pracy układu – niewielka lista rozwijana, która – jak mi się zdawało – służyła tylko do wyboru języka, dla którego kolorowana będzie składnia kontrolowała także model programowalnego chipa. Narzędzia kompilacji i nagrywania programu, dostępne pod klawiszami F5 i F6, były zależne od wyboru dokonanego na tej liście. Tak zostałem największym idiotą Galaktyki .

Dzięki powyższemu odkryciu udało mi się w końcu w pełni poprawnie zaprogramować robota (wszystkie hacki, które zainstalowałem w API qfix’a okazały się w tym momencie niepotrzebne ). Niestety, musiałem w tym momencie opuścić Galerię ale przynajmniej było pewne, że robot Graupnera może być łatwo i przyjemnie zaprogramowany. Postanowiłem powrócić…

Ciąg dalszy nastąpi…

Ponieważ jestem studentem i właśnie mam sesję, postanowiłem się pouczyć i tak zawędrowałem na wspomniany festiwal . W najbliższych kilku postach postaram się zrelacjonować to wydarzenie. Pojawi się trochę zdjęć i filmów, których jeszcze nie zrobiłem bo byłem zbyt zajęty psuciem robotów

Dwa z nich przypominają transformersy i poruszają się na dwóch nogach,

Posadzony przed klockami Fischertechnik znalazłem jakąś instrukcję i zacząłem konstrukcję podstawowego modułu jeżdżącego. Nie było to takie proste zadanie, pierwszy raz widziałem takie klocki na oczy . Otrzymałem procesor sterujący, baterię oraz dostęp do kabli i oprzyrządowania. Gdy robot był już gotowy, miły człowiek z obsługi festiwalu posadził mnie przy komputerze i poinstruował jak korzystać z oprogramowania. Po podpięciu procesora robota do PC przez kabel USB zaczęła się zabawa .

Robot mojej konstrukcji

Narzędzia Fischertechnik
Narzędzia Fischertechnik – podobnie jak Lego Mindstorms – pozwalają na tworzenie aplikacji przez wyklikiwanie schematów blokowych w dedykowanej aplikacji. Program, z którego korzystałem pozwalał pracować na pięciu poziomach zaawansowania – z każdym kolejnym dostawało się do dyspozycji więcej opcji. Poziom podstawowy to bardzo prosty interfejs, w którym można wyklikać prosty program. Dostępne opcje to m.in. zaczekanie na przycisk (dokładniej: wejście cyfrowe), sterowanie pracą silnika (dokładniej: wyjścia sterującego ). Za pomocą niektórych bloczków program mógł się rozgałęzić lub zapętlić. Kolejnym poziomem zaawansowania był poziom ‘podprogramów’ – w tym trybie pojawiały się dodatkowe, bardziej złożone bloczki oraz można było wyklikiwać własne funkcje (w postaci podobnych schematów blokowych), które następnie stawały się bloczkami i można było z nich korzystać w programie. Kolejne trzy poziomy to dodatkowe bloczki (m.in. operacje na zmiennych, dość zaawansowane konstrukcje logiczne) i lekkie skomplikowanie interfejsu. Niezastąpione okazało się okienko podglądu aktualnego stanu robota, dzięki któremu można było mieć zarówno podgląd wszystkich wejść analogowych i cyfrowych w czasie rzeczywistym (tak długo, jak robot był podpięty do komputera), jak i można było sterować każdym z wyjść sterujących bez konieczności wgrywania nowego programu. W całym tym procesie jedna tylko rzecz mi bardzo przeszkadzała – komputery pracowały na systemie w niemieckiej wersji językowej; nie był to wielki problem, ale za to denerwujący.

Robot
Ostatecznie wyposażyłem swojego robota w dwa przyciski, które służyły za czujniki zderzenia z przeszkodą. Następnie stworzyłem program, dzięki któremu robot ‘patrolował’ teren poruszając się z niewielką szybkością do przodu, a w przypadku naciśnięcia któregokolwiek z przycisków błyskawicznie odskakiwał i omijał punkt zderzenia (dokładniej cofał się, skręcał w odpowiednią stronę, reorientował i podjeżdżał – zakreślając coś na kształt dużego U). Ten prosty kod okazał się być wystarczająco dobry, by robot mógł zostać pozostawiony na arenie, gdzie toczyły się walki – potrafił poruszać się bardzo długo bez pomocy człowieka i nie blokował się (głównie dlatego, że jedno z kółek było krzywe i robot nie jechał zwykle idealnie po prostej).

Kilka słów o elementach elektronicznych w zestawach Fischertechnik, przynajmniej tych dostępnych na festiwalu. Jedynym wejściem dla robota okazał się być wspomniany przycisk. Służy on za wejście cyfrowe – ma dwa stany. Ponadto za wejście możnaby uznać pewne bliżej niezidentyfikowane urządzenie przypominające fototranzystor; nie udało mi się go jednak uruchomić. Z elementów wyjściowych dołączone były silniki oraz żarówkowe światełka. Oba te rodzaje urządzeń korzystają z tych samych wyjść. Sama płytka sterująca posiada wejścia analogowe mierzące napięcie (jedno mierzy rezystancję) i pozwala podłączyć jedynie cztery urządzenia wyjściowe (to i tak o jedno więcej niż Lego Mindstorms).

Wybiła godzina 19:00 i trzeba było się zbierać. Od obsługi dostałem informację, że mają też trzeci rodzaj robotów, programowalny w C++ i że mogą go udostępnić następnym razem, jeśli będę chciał. Ponadto z rozpędu zgubiłem na wystawie rolkę Duct Tape (na szczęście na wykończeniu).

Ciąg dalszy nastąpi…

Ostrzegam, że poniższy post będzie zrozumiały tylko dla niektórych Czytelników .

• Technik (duże T) – człowiek o ogromnych umiejętnościach i wiedzy naukowo-technicznej, którą wykorzystuje dla dobra drugich. Dobrego Technika cechują nieszablonowe pomysły i umiejętność radzenia sobie w każdej sytuacji. Celem jego działania jest pomaganie innym ludziom, których dobro stawia ponad swoje własne wygody. Kieruje się szlachetnymi pobudkami. Technik często jest nierozumiany przez zwykłych ludzi, którzy patrzą na niego z przymrużeniem oka i nierzadko unikają bliższych kontaktów (zasada: w razie dobrze mieć Technika pod ręką, ale nie za blisko). Na obecność Technika w pobliżu zwykle wskazują zjawiska takie jak anomalie czasowe, ’samoistne’ rozwiązywanie się problemów, dziwne ‘przypadki’ (znane jako zjawisko WPT*), oraz nagłe pragnienie opuszczenia pomieszczenia**.
• TRC – Organizacja zajmująca się badaniami nad czasem oraz rozwojem i wykorzystaniem zaawansowanych technologii dla szeroko rozumianego dobra Galaktyki.
• Licencia Technicia – prawo Techników do wykonywania działań w sposób, który pozornie łamie powszechnie znane prawa fizyki (także uniwersalna odpowiedź na pytanie: jak to zrobiłeś?).

Temat społecznych konsekwencji powyższej definicji Technika podjął niedawno Stanisław Wawszczak.

* – WPT, czyli Wewnętrzne Przeczucie Technika, które tak na prawdę nie jest przeczuciem. Zgodne z twierdzeniem, że ‘najłatwiej przewiduje się przyszłość, gdy się ją samemu tworzy’.
** – TRCowska definicja Technika opiera się na swobodnej interpretacji postaci Techników z powieści Asimov’a pt. “Koniec Wieczności”.

W tamtym wpisie poruszyłem szereg problemów, które można streścić do jednego pytania: której normy używać, dlaczego, i co nam to tak właściwie daje ilościowo?. Wiąże się to też z próbą odpowiedzi na pytanie “ile to jest źle uwarunkowane?”

W ramach pracy dodatkowej na studia zbadałem ten temat dokładniej i podjąłem próbę udzielenia odpowiedzi na te i inne pytania. Mam nadzieję, że poniższy dokument rozjaśni kwestię norm, uwarunkowania macierzy, dokładności obliczeń numerycznych. Praca ta została sprawdzona przez doktora prowadzącego laboratoria z Metod Numerycznych i nie zawiera “elementów które by jakoś bardzo raziły”. Mam więc nadzieję, że będzie to wartościowe źródło dla zainteresowanych tematem osób.

Pobierz opracowanie.

Mile widziane będą komentarze, uwagi oraz wskazanie ewentualnych błędów.

Powiem szczerze, że pierwszy raz w życiu widziałem taką frekwencję – przysłano aż 28 prac. Większość z nich była grywalna, a niektóre były na prawdę godne podziwu.

Prace, które szczególnie mi się spodobały (kolejność alfabetyczna):

• BrutalComputer wyprodukował prostą, ale klimatyczną i wciągającą strzelankę.
• Gynvael Coldwind stworzył bardzo grywalnego Tower Defense.
• KK zaprezentował bardzo wciągającą, dynamiczną platformówkę z grafiką w stylu ASCII-Art
• Maskl został autorem Commandosów – gierka szalenie grywalna, spójna i klimatyczna.
• Mi-Ku pokazał nam gierkę z zabawną fizyką .
• Reg napisał szalenie wciągający symulator hodowli. W nocy po Compo kilka osób grało w tę grę i ścigało się na dochody farmy .

Na koniec kilka słów o mojej pracy. Można ją pobrać poniżej:
(link do gry).
Napisana została w Javie i LWJGL, powinna działać zarówno pod Windowsem jak i Linuksem. Dołączone są skrypty uruchamiające.

Screen z gry (kliknij aby powiększyć)

Gra nie ma swojego tytułu. Gatunkiem klasyfikuje się do experiential gameplay. Gracz kieruje krową, która posiada emocje – główne uczucia to uczucie smutku / radości oraz zabawy / wściekłości (skutków tego ostatniego nie zdążyłem zaimplementować ). Są też stany pośrednie – krowa może być bardzo smutna, smutna, neutralna, wesoła lub bardzo wesoła. Równocześnie może być też rozbawiona gonieniem świnek . Krowa, która włóczy się po pastwisku smutnieje z nudów – aby poprawić jej humor trzeba przejść na ‘lepszą trawę’. Emocje krowy ilustrowane są przez grafikę twarzy.

Na planszy pojawia się też stado świń, kierowanych za pomocą prostego algorytmu stadnego. Uciekają one przed graczem, równocześnie starając się zachować spójność grupy, nie wpadać na siebie i dążyć do wspólnego celu znajdującego się niedaleko lewej krawędzi mapy.

Gra ta nie ma swojego celu – experiential gameplay tego nie wymaga. Ideą było zilustrowanie uczuć krowy, której humor zależy od tego gdzie się znajduje i co robi.

Omawiane gry dostępne są do zagrania na Kongregate:

• I Wish I Were The Moon
• Storyteller

Ponadto ten sam autor stworzył też:
Night Raveler and the Heartbroken Uruguayans: The Game oraz The Trials.

Kolejnym ciekawym tytułem jest The Majesty of Colors autorstwa Gregory’ego Weir. Ta gra poświęcona jest tematyce snu, a zainspirowana została m.in. przez I Wish I Were The Moon. Autor napisał też ciekawy postmortem Majesty. Interesującą pozycją zdaje się być też Stars over Half Moon Bay Roda Humble poświęcona gwiazdom na nocnym niebie, kreatywności i filozofii, niemniej jednak jest ona trudniejsza w odbiorze (przynajmniej mnie sprawia kłopot). Rod jest też autorem specyficznej gry The Marriage, która jednak wymaga wysilenia wyobraźni.

Niedawno natknąłem się też na kolejną gierkę, którą mógłbym zaliczyć do ‘gatunku’ experiential gameplay. Minigra zatytułowana Sprinter to prosta ilustracja koncepcji biegania, w której do kontroli sprintera używamy dwóch klawiszy. Idea podobna do tej, którą opisał Daniel we wpisie o experiential gameplay.

Experiential gameplay to w pewnym sensie też gatunek eksperymentalnego gameplay. Nie jest to jednak zwykła demonstracja, proof-of-concept mający pokazać, że dany pomysł ma szansę się sprawdzić. To gry skupione na doznaniach innych niż te z gier retailowych, zasypujących nas adrenaliną i przemocą. Ze wszystkich experiential games, które widziałem najbardziej podobały mi się te, które poruszają temat uczuć – jak I Wish I Were The Moon i Storyteller.

Osobiście sam przymierzałem się do gierki tego typu, niemniej chwilowo pomysł zawiesiłem – częściowo z braku czasu, a częściowo… z braku szybkich narzędzi developerskich. Na Warsztacie by się pewno obrazili, jakbym gierkę wyklikał , Flasha obsługiwać jeszcze nie umiem… Myślę ewentualnie o Javie i LWJGL, bo tam mam gotowego frameworka i nawet szybko się w tym pisze gry, ale to wszystko jest kwestią przyszłości.

Czytelniku, jeśli natkniesz się na inne gry tego typu (albo stworzysz takową!) to bardzo proszę, daj mi szybko znać .

Chciałbym w tym miejscu polecić wszystkim bibliotekę LWJGL (Lightweight Java Game Library). W dużym uproszczeniu składa się ona z bindów OpenGL i OpenAL pod Javę, funkcji do obsługi wejścia z klawiatury i myszy oraz garści drobnych klas narzędziowych. Wspiera tworzenie gier zarówno jako aplikacji jak i apletów. Główną zaletą jest przede wszystkim uporządkowanie wejścia, audio i grafiki w jednej bibliotece, dzięki czemu możemy szybko zabrać się za tworzenie gry z pomocą dobrych, wieloplatformowych bibliotek. Więcej informacji, przykłady, dokumentacja zamieszczone są na stronie projektu: http://www.lwjgl.org/. Testowałem, działa świetnie (niedługo wrócę do tego tematu, bo zamierzam opublikować projekt zaliczeniowy z Programowania Obiektowego, którym była gra pisana w Javie z pomocą LWJGL).

Jeśli Czytelniku niepokoisz się kwestią wydajności języka, proponuję Ci zagrać w grę, która mnie ostatecznie przekonała do sensowności pisania gier w tym języku i mocno zareklamowała LWJGL:
http://fabiensanglard.net/Prototyp/index.php
Osobiście nie spodziewałem się zobaczyć tyle FPS w JAKIEJKOLWIEK grze opartej o Javę, ale na szczęście nie jest tak źle jak kiedyś mi się wydawało.

Mimo wszystko jednak Java jest językiem różniącym się od C++ w koncepcji zarządzania pamięcią, co w przypadku programowania gier ma duże znaczenie. Trzeba pisać kod dużo ostrożniej i w sposób przemyślany, żeby unikać niepotrzebnego kopiowania obiektów (w miarę możliwości unikać go w ogóle – wszystko alokowane dynamicznie) oraz aliasowania się nazw zmiennych (plątające się przypadkiem po różnych obiektach referencje do składowych innego obiektu; jest to ogólna, dla mnie upierdliwa, cecha wielu języków nowszych od C++, np. PHP5). Niewątpliwie niewygodny jest też brak możliwości przeciążania operatorów.

Dla tych, którzy szukają całych silników graficznych mam dobrą wiadomość – istnieją porty Irrlicht’a i Ogre pod Javę .

Dedykuję Słoneczku i starym czasom, które minęły.

Podstawy Użytkowania Komputerów (I semestr)
Pobierz prezentacje
Zaliczeniem z najlepszego jak dotąd przedmiotu z najlepszym jak dotąd prowadzącym była prezentacja multimedialna oraz specyfikacja projektu technicznego. Ta druga zaginęła gdzieś w czeluściach Internetu (była robiona grupowo na jakiejś Wiki u Asmodeusza na serwerze). Na temat prezentacji multimedialnej wybrałem wstęp do programowania gier. Nie dane było mi jej jednak przedstawić publicznie .

Podstawy Informatyki (I semestr)
Pobierz paczkę
W ramach zaliczenia przedmiotu oddałem trzy programy. Pierwsze dwa – konwerter kodu Morse’a i baza danych na drzewie binarnym – nie są warte uwagi (może za wyjątkiem sztuczki zastosowanej w bazie, by ułatwić sobie kasowanie elementów z drzewa ). Trzecim programem jest wyjątkowo dopieszczony symulator gry w życie. Opisy w Readme.

Analiza Danych i Probabilistyka (II semestr)
Pobierz PCA
Program ten ilustruje problematykę analizy i redukcji głównych składowych. Oddany w terminie zdobyłby lekką ręką 6.0, jednak z powodu spóźnienia ocena była niższa . Opis w Readme.

Na pierwszym roku stworzyłem jeszcze troszkę nie wartej publikacji drobnicy, która dała 6.0 i zwolnienie z języka C. Analogiczną ocenę i zwolnienie z C++’a dał framework Anything-A (retrofit Anything) .

Trwa drugi rok, do tej pory wrzuciłem już jeden z projektów zaliczeniowych i sporo drobnicy, która powstała w trakcie nauki. Z gotowych projektów może podrzucę za jakiś czas projekt zaliczeniowy z Programowania Obiektowego (gra w Javie). Ponadto, obecny – czwarty już – semestr zdaje się być wyjątkowo nasycony projektami; niewątpliwie nowych prac powstanie więcej .

Wniosek jest oczywisty – pojedyncze notatki w programie OneNote nie nadają się do tworzenia bardzo długich dokumentów ze sporą ilością multimediów. Na szczęście nie jest to większy problem – wystarczy nie pakować wszystkiego do jednej notatki, ale tworzyć ich kilka (OneNote radzi sobie dobrze z drukowaniem całych sekcji na raz).

Mówi się, że funkcja ta ‘jest upierdliwa, bo trzeba potwierdzać każdą drobną czynność’. Ale czy rzeczywiście? Zazwyczaj potwierdzenie wymagane jest jedynie w przypadku instalacji oprogramowania (użytkownicy Windows XP są zapewne i tak przyzwyczajeni do komunikatów wyskakujących przy plikach .exe…) i zmiany ustawień systemowych, które mogą mieć wpływ na szeroko rozumiane bezpieczeństwo komputera. Rozumiem, że niektóre osoby (głównie gracze) instalują programy dość często, ale jakoś nie wyobrażam sobie ilości instalowanego oprogramowania, przy której jedno kliknięcie więcej stawałoby się na prawdę męczące.

Tak prawdę mówiąc (tutaj ukłon w stronę wszelkich Apostołów UNIXa), to UAC jest w pewnym sensie odpowiednikiem UNIXowych poleceń su i sudo, które pozwalają nadać konkretnej aplikacji uprawnienia innego użytkownika (w szczególności administratora). W systemach UNIXowych zaleca się, by użytkownik korzystał z konta o uprawnieniach ‘zwykłych’, a w przypadku wyjątkowej potrzeby (instalacja, zmiana ustawień) nadawał konkretnej sesji / aplikacji tymczasowo wyższe uprawnienia przy użyciu su. Środowiska graficzne typu KDE/Gnome potrafią nawet zapytać użytkownika o pozwolenie na uruchomienie konkretnej aplikacji z prawami administratora (i ewentualnie o hasło), jeśli jest to konieczne. Zauważmy, że niewiele się to różni od UAC oraz Windowsowego ‘Uruchom program jako’.

Korzystanie z UAC podnosi bezpieczeństwo systemu, bo jeżeli cokolwiek potrzebuje za dużych uprawnień, to się o tym dowiemy. Tak zupełnie na marginesie, pozwala nam to też oceniać program pod kątem tego, co on tak na prawdę robi – mało prawdopodobne jest, żeby np. edytor tekstu wymagał uwierzytelnienia przez UAC…

Osobiście pracuję pod Windows Vista Home Premium już ponad rok i jak na razie mnie ta funkcja nie przeszkadza . Dlatego zachęcam wszystkich do ponownego spojrzenia na UAC i nawet jeśli nie włączenie go to zastanowienie się, czy rzeczywiście jest to tak ‘upierdliwa’ funkcja. Może są jeszcze inne konkretne powody, dla których ludzie decydują się wyłączyć UAC? Czytelniku, jeśli znasz taki to napisz o tym w komentarzu .

PS. Użytkownicy PowerShell‘a po zainstalowaniu PowerShell Community Extensions otrzymują m.in. polecenie su (alias na Elevate) .

Obok zmiany układu klawiatury mamy też pokrewną funkcję – zmiana używanego języka. Typowy system Windows w Polsce ma zainstalowany język polski; czasem zdarza się też język angielski oraz inne. Przełączenia między językami (a więc równocześnie między układami klawiatur używanymi w różnych językach) można dokonać za pomocą podobnej kombinacji lewy ALT+SHIFT. Omyłkowe jej naciśnięcie powoduje zjawisko ‘zniknęły mi polskie znaki’ – obcojęzyczne układy klawiatur zazwyczaj nie mają polskich znaków diakrytycznych pod klawiszem ALT.

Fakt, że bardzo mało osób zdaje się wiedzieć o przyczynie powyższych anomalii znakowych wydaje mi się związany przede wszystkim z brakiem wyraźnego powiadamiania użytkownika o zmianie układu klawiatury. Aktualnie używany język i układ reprezentowany jest przez małą ikonkę z prawej strony paska zadań, obok tzw. obszaru powiadomień (zwane także tray, chodzi to miejsce, gdzie mamy słoneczko z Gadu-Gadu ) i zegara systemowego. Przełączenie układu klawiatury powoduje jedynie dyskretną zmianę napisu na wspomnianej ikonce, co samo w sobie wystarczy, żeby większość osób nie zorientowało się, że naciśnięcie CTRL+SHIFT / ALT+SHIFT cokolwiek robi. Może kiedyś ktoś zwróci Microsoftowi na to uwagę, a na razie pozostaje jedynie wyłączać te skróty lub wiedzieć, że one istnieją i informować o tym znajomych, którzy nie wiedzą .

Podsumowując w formie krótkiego FAQ:
Zniknęły mi polskie znaki, co mam zrobić? Stuknij w lewy ALT+SHIFT.
Zamiast ‘y’ wpisuje mi się ‘z’, co mam zrobić? Stuknij w CTRL+SHIFT.
Da się to jakoś naprawić na stałe? Można wyłączyć reagowanie na powyższe klawiszowe. W systemie Windows Vista kliknij prawym przyciskiem na wspomnianą w poprzednim akapicie ikonkę i wybierz menu Ustawienia…; w zakładce Zaawansowane ustawienia klawiszy (pod Windows XP zakładka Ustawienia) można zmienić lub wyłączyć reagowanie na oba powyższe skróty.

* Ok, przesadziłem z tą konsekwencją – np. w przypadku IE7 pozycja Opcje internetowe menu Narzędzia nie kończy się wielokropkiem… Prawdopodobnie nowe pokolenie programistów zapomina o takich rzeczach (i nowe pokolenie QA też).

Kolejną ciekawą rzeczą, którą wtedy usłyszałem to historia o obozach wojskowych szkół średnich. Podobno jeden z uczestników tego obozu stwierdził, że największym marzeniem (i de facto celem?) jego życia jest zdobyć na polu bitwy bliznę na skos przez całą twarz.

Ciekawe, czy są to tylko specyficzne przypadki, czy też podobne poglądy i przemyślenia ma więcej osób? Przypomina się w tym miejscu piosenka Stacie Orrico:

There’s gotta be more to life…
Than chasing down every temporary high to satisfy me

Wszystkim stałym i niestałym Czytelnikom życzę miłej lektury devBloga na nowym silniku .

Poradnik Softimage|XSI Tips&Tricks
Opublikowałem tutaj w formie artykułu poradnik, który zamieściłem na forum Informatyki Stosowanej. Mam nadzieję, że przyda się każdemu, kto zaczyna lub będzie zaczynał modelowanie w XSI (zwłaszcza na projekt zaliczeniowy).
Link do poradnika

Animacje
Wiele grup oddało animacje na bardzo wysokim poziomie, dzięki czemu ostatnie zajęcia z grafiki komputerowej (spędzone na prezentowaniu projektów) były bardzo ciekawe i wesołe. Poniżej kilka prac, które szczególnie mi się podobały:

A na koniec moja:

• Metoda Sukcesywnej Nadrelaksacji (teoria i praktyka)
• Metoda eliminacji Gaussa z całkowitym wyborem elementu głównego (teoria i praktyka)
• Wyprowadzenie i omówienie wzorów na interpolację SPLINE stopnia drugiego (teoria i praktyka)

Dodatkowo zamieszczam też erratę do dotychczasowych zadanek. Na wszelki wypadek wymienione w niej błędy zostały poprawione w sprawozdaniach dostępnych w chwili obecnej na moim blogu.

Mam nadzieję, że te dokumenty – podobnie jak poprzednie – okażą się dla kogoś przydatne i/lub ciekawe

Na konferencję przybyliśmy po godzinie 15:00, w trakcie trwania wykładu pana profesora Krzysztofa Zielińskiego pt. “Free Software in Services Computing Infrastructure Implementation”. Powiem szczerze i otwarcie, że z tego wykładu nic nie zrozumiałem . Obfitował w dużą liczbę angielskich biznesowych terminów i schematów wprowadzanych przy założeniu, że wiemy o co chodzi. Jedyne, co udało mi się wyłapać to informacja, że te wszystkie wielkie-i-ważne-rzeczy implementuje się w Javie.

Kolejnym prelegentem był znany nam już z zeszłego semestru dr GJN – doktor Grzegorz J. Nalepa. Wygłosił wykład pt. “Free Software at AGH UST – a personal perspective”. Wykład bardzo ciekawy i równocześnie humorystyczny; przede wszystkim bardzo przystępny dla wszystkich odbiorców. Jako studenci EAIiE mieliśmy dodatkowy komfort, bo z wieloma omawianymi rzeczami mamy styczność na codzień. Ogólne wrażenia: bardzo pozytywne .

Następne przemówienie nosiło tytuł: “Internet – przestrzeń wolności? Czy tylko dzięki otwartym rozwiązaniom?”, a wygłosił je pan Łukasz Wejchert, prezes Onetu. Ważnym elementem tego wystąpienia było omówienie architektury Onetu oraz sposobu, w jaki radzą sobie z problemami bycia najczęściej (po Naszej-Klasie) odwiedzanym portalem w Polsce. Onet wyróżnił się w popołudniowej części (co się działo rano, nie wiem) bardzo pragmatycznym podejściem do kwestii wolnego i komercyjnego oprogramowania – ogólny klimat był bardzo pro-free software’owy, podczas gdy pan Łukasz podkreślił, że jego firma korzysta z tego oprogramowania, które jest w danym przypadku bardziej praktyczne. Po przemówieniu nastąpiła specyficzna sesja pytań i odpowiedzi. Dyskusja bardzo szybko przerodziła się w spór polityczny na temat wolności słowa; w moim odczuciu niektóre osoby skorzystały z faktu, że na sali pojawiły się kamery telewizyjne, wy wygłosić kilkuminutowe przemówienia na temat swoich poglądów. Na szczęście w pewnym momencie dwóch studentów AGH sprowadziło rozmowę z powrotem na tematy techniczne i burza emocji ucichła.

Potem wyszedłem po ciasteczka i spóźniłem się na przemówienie premiera RP Waldemara Pawlaka . Przemówienie ciekawe, ale w moim odczuciu trudne do zrozumienia dla studenta nie znającego klimatów i terminologii politycznej.

W międzyczasie sala zaczęła się napełniać (a raczej przepełniać) i nastąpiło wyczekiwane przez wszystkich wystąpienie pana Stallmana w przemówieniu pod tytułem “Copyright vs Community in the Age of Computer Networks”. Stallman zwrócił uwagę na ciekawe problemy, jakie wynikły w związku z rozwojem techniki kopiowania danych – począwszy od przepisywania książek ręcznie, przez prasę drukarską, a na współczesnej technice cyfrowej skończywszy. Od strony formy pan Stallman prezentował bardzo elegencką i zrozumiałą wymowę angielskiego, ale równocześnie specyficzny język, moim zdaniem wręcz propagandowy. Stosował bardzo dużo górnolotnych haseł oraz wysnuwał kontrowersyjne etycznie i moralnie wnioski. Ogólnie ujmując celem wykładu było zapoznanie nas z (i ewentualnie przekonanie do) poglądem pana Stallmana na rzeczywistość, niekoniecznie czysto informatyczną. Wykład zakończył się sesją pytań oraz aukcją, na której za ok. 400zł sprzedano maskotkę antylopy GNU, a za 700zł książkę Stallmana zawierającą jego przemyślenia.

Stallman bardzo intensywnie podkreślał różnice między free software, a open-source (jeden z poprzednich mówców został nawet w sposób nie-wprost publicznie upomniany przez Stallmana za zbyt małe podkreślanie tej różnicy), wywołując przy okazji pod koniec kolejną polityczną dyskusję.

Ogólny nastrój popołudniowej części konferencji był mało informatyczny, a bardzo polityczny. Moje odczucia wyglądają następująco: konferencja to taki wykład, tylko większy, są ważniejsi i bardziej znani prelegenci, jest więcej słuchaczy, materiał jest trudniejszy, dużo mniej zrozumiały i dużo mniej przydatny do czegokolwiek.

PS. Stallman spytany o to, jak przeżył atak Ninja z XKCD odpowiedział, że w chwili ataku nie znał tego odcinka komiksu i nie rozumiał dowcipu, który został mu wytłumaczony dopiero później .

PPS. Tyle się na konferencji mówiło o Free Software, ale jak okiem sięgnąć, wszyscy na laptopach mieli Windows Vista .

PPPS. I dało się wejść na konferencję bez wcześniejszej rejestracji na stronie .

Sprawozdanie III – Układy równań liniowych (teoria)
Sprawozdanie III – Układy równań liniowych (praktyka)

Sprawozdanie IV – Aproksymacja (teoria)
Sprawozdanie IV – Aproksymacja (praktyka)

EDIT – Errata
Sprawozdanka już dorobiły się erraty – jak się błędów zbierze więcej, to poprawię i podepnę nowe pliki. Na razie zostało mieć tylko nadzieję, że prowadzący z Metod Numerycznych nie zauważą .

• Sprawozdanie IV (Aproksymacja) – Teoria, str. 3, ak.1 – wykreślić zdanie w nawiasie (“warto zauważyć, że …”) – ostatecznie nie jestem pewien tego twierdzenia.

Ten post jest matematyczny więc ostrzegam, że nie każdy może mieć ochotę go czytać . Mnie by się nie chciało

Ostatnimi czasy na studiach daje mi w kość przedmiot zwany Metodami Numerycznymi. Niedługo poprawa kolokwium, egzamin połówkowy i takie tam inne . W związku z tym zacząłem zgłębiać temat uwarunkowania macierzy i doszedłem do dość dziwnych obserwacji.

Zacznijmy od podstaw teoretycznych, czyli jak definiujemy uwarunkowanie macierzy:

gdzie zapis ||A|| oznacza normę macierzy A. Norm możemy ustalić wiele; w przypadku macierzy stosuje się często normy: wierszową, kolumnową i spektralną. Nie będę tu ich tłumaczył, szkoda miejsca .
Wobec powyższego powstaje naturalne pytanie: której normy użyć do obliczeń współczynnika uwarunkowania?

W wykładach i książkach (Fortuna ) niewiele znalazłem, Wikipedia też nie pomaga. Jako leniwy ale kreatywny student postanowiłem nie szukać intensywnie odpowiedzi po forach matematycznych, tylko przeprowadzić małe badania. Zadałem pytania:

• Właściwie jak to jest z tymi normami? Czy dla danej macierzy te trzy normy są identyczne albo chociaż podobne?
• Jak różnią się od siebie współczynniki uwarunkowania macierzy w zależności od wybranej normy?

W znalezieniu odpowiedzi pomógł MATLAB. Skrypt, którym przeprowadziłem badania można pobrać tutaj: [SKRYPT] (Octave-compatibile ). W doświadczeniu tym generowałem po 10 losowych macierzy NxN, gdzie N zmieniało się od 2 do 300. Pozwala to tak z grubsza wyrobić sobie jakąś opinię na temat tego, jak rosną normy i współczynniki uwarunkowania zależnie od rozmiaru macierzy.
Poniżej garść obrazków z MATLABa:

Wnioski:

• Normy wierszowe i kolumnowe (rys. 1, odpowiednio czerwona i zielona linia) są do siebie podobne, rosną mniej więcej liniowo.
  Norma spektralna (niebieska linia) również rośnie z grubsza liniowo wraz z rozmiarem macierzy, ale robi to dużo wolniej od pozostałych.
• Normy macierzy odwrotnych do macierzy A są raczej niewielkie, trzymają się blisko zera, ale rozsiane są bardzo chaotycznie. Gdzieniegdzie jakaś norma wyskoczy bardzo wysoko.
• Współczynniki uwarunkowania dla norm wierszowych i kolumnowych (rys. 2, kolory jak na poprzednim) są bardzo zbliżone do siebie, podobnie jak same normy. Uwarunkowanie dla normy spektralnej jest o rząd wielkości mniejsze (rys. 3, to samo w skali logarytmicznej na osi y).
• Współczynniki uwarunkowania dla wszystkich norm razem rosną i maleją (rys. 4, tzn. wzrost współczynnika uwarunkowania dla norm wierszowej i kolumnowej wiąże się ze wzrostem tegoż współczynnika dla normy spektralnej).

Pomimo powyższych przemyśleń dalej pozostaje dla mnie nierozwiązaną jedna kwestia: której normy używać do policzenia uwarunkowania macierzy w metodach numerycznych, kiedy chcę określić uwarunkowanie zadania? Może mi ktoś z Czytelników pomoże .

Pierwsze zdjęcie przedstawia przód pilota. Drugie zdjęcie przedstawia tego samego pilota, przy naciśniętym przycisku. Widzimy, że dioda, której światło jest nie widoczne gołym okiem, została doskonale zarejestrowana przez aparat. Znajomość tej sztuczki przyda się każdemu do testowania sprawności pilotów od sprzętu RTV. W ten sposób można chociażby łatwo sprawdzić, które przyciski nie stykają (albo czy panowie z serwisu faktycznie naprawili nam pilot).

Zastosowania są oczywiście szersze – zjawisko to wykorzystuje się w kamerach CCTV do ochrony obiektów – w nocy taka kamera może pracować w trybie czarno-białym i doświetlać teren podczerwienią. Podobnie spotykane coraz częściej wideofony zawierają zestaw diod LED, które służą do oświetlania podczerwienią, dzięki czemu kamera dobrze rejestruje rozmówcę niezależnie od zewnętrznego oświetlenia (np. w nocy). Jeden z moich kolegów przeprowadził niegdyś eksperyment – za pomocą diody podczerwonej wysokiej mocy (3W chyba) mógł widzieć przez wyświetlacz aparatu cyfrowego obiekty w odległości ok. 2-3 metrów w kompletnej ciemności.

W ostatnim miesiącu na AGH odbyły się dwa seminaria (taka mądra nazwa na wykład) na temat tworzenia gier, zorganizowane przez koło naukowe Glider a prowadzone przez pracowników firmy Reality Pump. Na pierwszym spotkaniu omówiono różne techniki sztucznej inteligencji w grach oraz ich zastosowanie w aktualnie tworzonej przez Reality Pump grze Two Worlds: The Temptation. Drugie spotkanie było ogólnym wstępem w świat tworzenia gier typu retail (dużych produkcji, które trafiają na półki sklepowe). Można było też dowiedzieć się, w którym kierunku mogą rozwijać się początkujący twórcy gier oraz jak i dlaczego zacząć pracę z XNA. Dodatkowym elementem spotkania była prezentacja gry Two Worlds: The Temptation, połączona z sesją pytań.

Wykłady te są dla mnie bardzo miłą niespodzianką i z radością informuję, że nie jest to koniec – koło naukowe Glider planuje dalszą współpracę z panami z Reality Pump; na stronie koła niedługo pojawi się ankieta, za pomocą której wybrany zostanie temat kolejnego spotkania. Wszystkich zainteresowanych będę informował o terminach i miejscach, jak tylko się o nich dowiem .

Oczywiście nie wszystko było różowe; pomimo zapewnień, że wykłady są dla wszystkich, choćby minimalne doświadczenie z grami i programowaniem grafiki jest potrzebne, by zrozumieć żargon, którym posługują się prowadzący. Jest to być może ‘zboczenie zawodowe’, którego wspomniani prelegenci już nie zauważają, ale w wykładzie często pojawiały się angielskie terminy i wyrażenia, takie jak ‘raytracing’, ‘gameplay’, ‘LOD‘ czy ‘NPC‘, które skutecznie utrudniły odbiór osobom ‘nie z branży’.

Podsumowując – wszystkich obecnych i przyszłych game developerów zapraszamy na AGH .

Jak wiadomo , skrótem do zmiany nazwy zaznaczonego pliku jest klawisz F2. Po jego naciśnięciu najczęściej wpisujemy nazwę, po czym wciskamy ENTER i wybieramy inny plik, lub od razu klikamy na tym pliku. Potem kolejne F2 lub kliknięcie, co zabiera nam jakąś sekundę. Zamiast tego, gdy skończymy wpisywać nazwę, wystarczy nacisnąć klawisz TAB, by przeskoczyć na kolejny plik, od razu w trybie zmiany nazwy. Czyli wklepujemy nazwę, TAB, i wklepujemy kolejną . Hope that helps.

Niedawno odkryłem ciekawe narzędzie – DropBox. W założeniu jest to prosta metoda przechowywania i współdzielenia plików. Jak w praktyce to działa?
Wchodzimy na stronę http://getdropbox.com/ i ściągamy klienta. Dostępny jest on w wersjach dla Windows, Linux i Mac. Po instalacji w systemie Windows zakładamy konto, podając swój adres e-mail (używany jako login na stronę), hasło i inne opcjonalne dane. Przy instalacji można też wybrać lokalizację katalogu DropBox.

No dobrze, ale o co chodzi? Mamy w systemie teraz specjalny katalog, który jest automatycznie synchronizowany ze stroną DropBox. Wszystkie pliki wgrywane są automatycznie na serwer, wszystkie zmiany przesyłane metodą inkrementalną (dogrywane są jedynie zmienione fragmenty). Do podkatalogu Public wrzucamy pliki, które chcemy udostępniać całemu światu. Tak jak ten . Podkatalog Photos pełni rolę zbioru galerii fotograficznych (wrzucamy foldery), które również może oglądać każdy, komu damy odpowiednie linki. Wreszcie istnieje możliwość tworzenia i współdzielenia katalogów z innymi użytkownikami DropBox. Oznacza to, że każda zmiana w takim katalogu będzie synchronizowana u wszystkich osób, które mają do niego dostęp.

Wszystkie te rzeczy są zintegrowane z Eksploaratorem Windows (o pozostałych systemach wiem tylko tyle, że na pewno integruje się z GNOME), dzięki czemu obsługa całej mechaniki DropBox’a to po prostu przerzucanie plików między swoimi folderami, a folderem DropBox. Program dodaje do menu kontekstowego swoje podmenu z kilkoma użytecznymi funkcjami, jak np. Copy Public Link.

DropBox oferuje dwa rodzaje kont. Darmowe ma ograniczoną pojemność do 2GB, płatne – do 50GB ($9.99 / miesiąc lub $99 / rok). Cały projekt jest na razie w fazie beta (chociaż patrząc na Google, słowo “beta” chyba straciło już swoje znaczenie…), więc można spodziewać się jeszcze wielu zmian (omawianych na forum DropBox’a).

Dziękuję tym, którzy pomagali.
Tym, dzięki którym to jedno marzenie choć na chwilę stało się rzeczywistością.

I przede wszystkim, dziękuję Słoneczku.
Nie widzę już nic, nic a nic, biało mi.
Idź dalej niezłomnie, a mnie zostaw sny.
Nic nie jest stracone, skończone też nie,
Gdy droga przed Tobą, a sam jesteś w tle.

Na uwagę zasługuje fragment w opisie tego filmiku na Youtube.
“The sound should be slightly better on this version – we’ve tried to get round YouTube’s new extreme audio dynamic range compression by layering a 20kHz sine wave over the top of the soundtrack.”
To jest podejście prawdziwego Technika! Chak de planet~! .

Tymczasem będąc zachwycony jednym z filmików promocyjnych postanowiłem zmajstrować tapetkę z Mirror’s Edge, której nie mogłem znaleźć w sieci. Proponuję trzy wersje – bez napisów, z logiem gry lub z logiem gry i copyrightem EA . Obrazki są w oryginale 1280×720, ale dodałem dodatkowe 30 pikseli do wysokości w postaci czarnego paska, dzięki czemu tapeta ładnie wygląda w rozdzielczości 1280×800 (ustawiamy opcję wycentruj, a nie rozciągnij!).

Pozdrawiam .

“I’m doing science” – tj. wciąż jestem studentem. Nie wiem jak długo, ale jeszcze .

Nie obiecuję na razie nic konkretnego na devBlog’u. Bo też i niewiele w dziedzinach technicznych ostatnio czyniłem.
Ponieważ na Warsztacie modny jest ostatnio temat VFS, to wrzucam linka do formatu PAK używanego w grach z serii Search and Rescue 4. Taki mały reverse engineering, którym zajmowałem się kiedyś z kolegą (chciało się poprawić SAR’a ).

PS. Projekt ten został raz dyskretnie wspomniany na Warsztacie .

Ostatnimi czasy niektóre osoby z rozmów ze mną mogły odnieść wrażenie, że trochę wypadam z gamedev‘u, skłaniam się ku innym dziedzinom informatyki. Zobaczymy jak to będzie w przyszłości, ale na razie decyduję się wciąż być w temacie. W tym celu zakupiłem długo oczekiwany szósty tom znanej serii Perełki Programowania Gier.
…no dobra, zakupiłem pod wpływem przypływu euforii . Po dwóch wstępnych przekartkowaniach stwierdzam, że ten tom jest dla mnie osobiście szczególnie interesujący; oprócz mojego ulubionej pierwszej części, dotyczącej programowania ogólnego, pojawił się bardzo ciekawy dział czwarty – Skrypty i systemy sterowane danymi. Dodatkowy komentarz do książki wystawię dopiero jak zapoznam się z treścią przynajmniej tych dwóch działów tematycznych. Teraz nadmienię jedynie, że ładnie pachnie .

PS. Dodam tylko, że nie kupiłbym tej książki gdyby nie spostrzegawczość Asmodeusza, który prawie instynktownie wyczuł jej obecność na wystawie gdy przechodziliśmy obok księgarni .

Jak widać, komunikat zawiera historię wywołań funkcji, które doprowadziły do miejsca wystąpienia błędu (tak zwany call-stack).

Napiszmy dwa pomocnicze makra oraz przykład użycia

Makra te ujmują kod zawarty między nimi w blok try-catch. Kiedy chcemy zasygnalizować wystąpienie bardzo poważnego błędu, który powinien spowodować przerwanie działania programu, wówczas rzucamy wyjątek. W chwili złapania wyjątku w makrze UNGUARD, nazwa podana do makra GUARD zostaje zapisana w systemie obsługi błędów ( to proszę napisać sobie samemu ), po czym wyjątek zostaje rzucony dalej. Jeśli zabezpieczymy w ten sposób wiele funkcji, to rzucony wyjątek przeleci przez nie wszystkie aż do miejsca, w którym zostanie obsłużony i zatrzymany. Takim miejscem może być np. pętla główna gry. Przykład:

Z metodą tą wiążą się też pewne niedogodności:

• Każdą chronioną funkcję / blok kodu trzeba zawierać w makrach GUARD/UNGUARD
• Blok try/catch powoduje zwiększenie czasu wykonania funkcji
• Utrudnione lub wręcz uniemożliwione jest używanie w kodzie wyjątków w celach innych niż obsługa błędów krytycznych, powodujących awaryjne zakończenie pracy programu

Równoważone są one jednak przez korzyść wynikającą ze znajomości dokładnej historii wywołań funkcji prowadzącej do miejsca wystąpienia błędu. Oczywiście makr tych nie stosujemy we wszystkich możliwych funkcjach; na przykład nie powinno się ich używać w prostych funkcjach wymagających bardzo dużej wydajności (np. iloczyn wektorowy).

Możliwe usprawnienia podanego przykładu:

• Zastosowanie dyrektyw #ifdef / #else / #endif do warunkowej kompilacji makr GUARD/UNGUARD, dzięki czemu można będzie je łatwo wyłączyć
• Stworzenie dodatkowej pary makr GUARD_SLOW i UNGUARD_SLOW, które będą automatycznie wyłączane w wersji wydaniowej (patrz punkt poprzedni), a które stosowane będą w funkcjach wymagających możliwie wysokiej wydajności
• Połączenie chronienia funkcji z własnymi makrami Assert/Verify, dzięki czemu przerywając pracę programu uzyskamy dokładne informacje o miejscu naruszenia asercji i drodze do tego miejsca. Własne makra Assert/Verify opiszę w przyszłości.
• Połączenie makra GUARD z loggerem, dzięki czemu nazwa funkcji będzie automatycznie dopisywana do komunikatu. Jest to duże udogodnienie, jeśli ktoś zapisuje nazwy funkcji do loga.
• Przerobienie makr, by system działał w oparciu o Unicode (w przypadku kodu, który w całości jest oparty o to kodowanie znaków)

Osobiście z powodzeniem stosuje koncepcję chronienia funkcji w kodzie od dość długiego czasu. Zintegrowała się ona na stałe z silnikami i frameworkami, których pisania się podejmowałem. Z wymienionych wyżej usprawnień nie udało mi się jedynie połączyć chronienia funkcji z loggerem.

Odkąd Flash stał się popularną technologią, namnożyło się w sieci reklam, które tańczą, grają, śpiewają oraz kradną zasoby systemowe. Czasem to tylko denerwuje, a czasem nawet spowalnia przeglądarkę lub zupełnie uniemożliwia pracę.

Postanowiłem ten problem jakoś rozwiązać. Chciałem napisać plugin do FireFox’a, który zablokuje ładowanie animacji Flash a w ich miejsce wyświetli małą ikonkę, której kliknięcie spowoduje załadowanie animacji na życzenie. Plugin powinien pozwalać na dodawanie niektórych animacji lub witryn do ‘białej listy’ tak, żeby nie trzeba było klikać przy każdym wejściu na stronę. Postanowiłem jednak sprawdzić najpierw, czy ktoś czegoś takiego nie zrobił wcześniej…

… i ku mojej radości rzeczywiście dokładnie taki plugin powstał. Nazywa się FlashBlock. Niestety, jest wciąż to wersja rozwojowa, jednak jest kompatybilna z FireFox’ami 2.x.x. Działa wyśmienicie i nareszcie mam spokój od denerwujących animacji flash .
Strona projektu:
http://flashblock.mozdev.org

Microsoft Office OneNote, o którym wspominałem już kiedyś na devBlogu, jest bardzo przydatnym narzędziem do organizowania pracy i zbierania różnych informacji. Na uwagę zasługują przede wszystkim wygoda użycia i duża funkcjonalność. Oto tylko kilka ciekawszych cech i zastosowań tego programu, z którymi warto się zapoznać:

Windows + N – szybkie notatki. Użycie tego skrótu powoduje otwarcie małego okienka z nową notatką w OneNote (coś na wzór samoprzylepnych karteczek post-it). W okienku tym możemy zanotować co chcemy, a potem je zamknąć. Wszystkie tak stworzone notatki automatycznie zapisują się w dziale “Unfiled Notes”.

OneNote dobrze skaluje treść strony, żeby sensownie zmieścić się na kartce. Oczywiście jeśli tekstu jest za dużo, to kartek do druku będzie więcej, ale OneNote stara się optymalnie zagospodarować przestrzeń skalując przy drukowaniu treść.

Łatwość tworzenia notatek – wystarczy kliknąć w dowolnym miejscu ‘kartki’ i pisać. Teksty można pisać w dowolnym miejscu i rozmieszczać względem siebie w dowolny sposób. Użycie bardziej przypomina edytor grafiki niż program tekstowy. Łatwo też rysuje się schematy przy użyciu prostych narzędzi rysunkowych.

Wygoda formatowania tabelek i list. Klawisz TAB w sposób automagiczny pozwala nam tworzyć tabelki bardzo łatwo i przyjemnie. Obsługa jest intuicyjna. Także tworzenie list wypunktowanych i numerowanych jest o wiele prostsze niż w normalnych edytorach tekstowych. Używając klawisza TAB/SHIFT+TAB można zmieniać ‘głębokość’ danego punktu w listach. Podobny efekt można uzyskać przy użyciu myszki.

Intuicyjna obsługa myszką. Wszystkie elementy można przeciągać, łączyć ze sobą i rozdzielać. Myszką można bardzo intuicyjnie zmieniać głębokość list wypunktowanych.

Screen Clipping, dostępny pod skrótem Windows+S pozwala nam zarysować na ekranie ramkę, której zawartość zostanie wklejona do OneNote jako nowa notatka w ‘Unfiled Notes’. Ot, taki zrzut dowolnej części ekranu.

Świetne wsparcie dla schowka. Przyznam, że ta cecha OneNote zrobiła na mnie największe wrażenie. Wkleić można praktycznie wszystko. Obrazki, teksty, nawet całe strony WWW – OneNote zachowa ich formatowanie, a na dole umieści dodatkowy komentarz podający źródło. Przykładowo, wklejenie schematu z programu MS Visio powoduje osadzenie w OneNote wektorowego obrazku z tym schematem.

Dodanie OneNote jako wirtualnej drukarki pozwala na drukowanie dowolnego dokumentu wprost do OneNote. Jest to bardzo przydatne do obchodzenia problemów ze schowkiem w niektórych programach albo brakiem funkcji eksportu grafiki. Osobiście eksport schematu z Visio do pliku JPG robiłem przez wydrukowanie go do OneNote i z OneNote zapisanie jako grafikę.

Zaawansowane opcje tworzenia notatek pozwalają ograniczyć rozmiar do rozmiaru różnego rodaju papieru.

Office 2007 ma bardzo ładne czcionki ClearType

Zostało więc tylko pytanie – skąd wziąć OneNote? Odpowiedzi mam dwie. Jeśli jesteś studentem to sprawdź, czy Twoja uczelnia współpracuje z Microsoftem w programie MSDN Academic Alliance. Jeśli tak, możesz za darmo ściągnąć OneNote 2007. Jeśli nie, zostaje opcja kupienia pakietu Office 2007 w promocji za ok. 300zł (pod warunkiem, że promocja jeszcze trwa).

Wygląda strasznie, nie?

Jest to jeden z najbardziej denerwujących mnie osobiście składników systemu Windows. Bardzo łatwo przez przypadek zrestartować sobie system. Piszemy sobie kod i możemy potwierdzić komunikat np. klawiszem ‘N’, nawet go nie zauważając. Windows ma też denerwującą tendencję do zaczynania po krótkiej chwili odliczania do przymuszonego restartu. Dziś rano odszedłem na chwilę od komputera tylko po to, by robiąc sobie śniadanie usłyszeć dźwięk PC-Speaker’a sygnalizujący mi, że komputer się boot’uje.

Dzięki tej ‘użytecznej’ funkcji łatwo możemy stracić pracę, czas i postrzępić sobie nerwy. Pytanie – co zrobić z tym problemem?

Jest kilka metod, żeby pozbyć się tego problemu. Na jednej ze stron podano następujące dwie:

Wyłączyć jednorazowo usługę Windows Update
W konsoli (albo start+uruchom) wpisujemy: net stop wuauserv lub net stop "automatic updates". Możemy też posłużyć się MMC. Po wyłączeniu usługi Windows Update możemy spokojnie pracować, po czym dokonać restartu systemu kiedy nam się spodoba. Po restarcie usługa aktualizacji i tak się włączy .

Wyłączyć auto-restartowanie w opcjach group policy.
Używamy do tego MMC. Uruchamiamy gpedit.msc i przechodzimy do:

W dostępnych tam opcjach możemy albo włączyć No auto-restart for schedule Automatic Updates installations, albo ustawić Re-prompt for restart with scheduled installations na jakiś długi czas, np. 1440 minut.

Istnieje jeszcze jedno rozwiązanie, podane na innej stronie. Należy wyłączyć Windows Update (patrz sposób pierwszy), zakończyć wszystkie instancje procesu wuauclt.exe, i dokonać następującej zmiany w rejestrze:
W kluczu HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\ Windows\WindowsUpdate\AU tworzymy (lub zmieniamy, jeśli istnieje) wartość NoAutoRebootWithLoggedOnUsers na 1.

Rady podstawowe

• Za specyfikację odpowiedzialna jest jedna osoba. Za jej dostępność, za wprowadzane do niej poprawki. Osoba ta rozwiązuje też sytuacje konfliktowe. Przykład z wykładu – kiedy przychodzi Project Manager do programisty i mówi, że ma być tak a tak, a on na to – “sorry, ale ta żaba to no way”. Osoba odpowiedzialna za spec’a podejmuje ostateczną decyzję co ma być.
• Specyfikacja jest jednolita dla zespołu. Project Manager, programiści, QA, dostawca pizzy – wszyscy korzystają z tego samego dokumentu.
• Należy stosować jakiś sposób oznaczania rzeczy, które są niejasne, zostaną uzgodnione w przyszłości. Przyjęło się oznaczać takie miejsca magicznym FIXME.
• Specyfikacja przedstawia system z punktu widzenia użytkownika. Nie opisujemy szczegółów implementacji, ale to, jak system działa i wygląda dla tego, kto z niego korzysta.

Składowe specyfikacji

• Wprowadzenie – ogólny opis systemu, tzw. The Big Picture. Co to jest, do czego to ma służyć.
• Scenariusze Użycia – jak użytkownik może korzystać z systemu, opisane na konkretnych przykładach, z konkretnymi (nazwanymi) uczestnikami. Ot tata Adam ma syna Jasia, którego chce zapisać do przedszkola (jeśli piszemy system elektronicznej rejestracji do przedszkoli). Co robi? Jak zachowuje się nasz system?
• “niecele” – czyli to, czego system na pewno NIE będzie robił. Jest to bardzo ważne dla naszego klienta, a dla nas jest gwarancją spokojnego snu. Ot, przykładowy klient przychodzi do nas z pretensjami, czemu właśnie wyprodukowany system nie robi tego-a-tego. Pokazujemy mu spec’a i mówimy, że ‘jest tu wyraźnie napisane, że system tego robić nie będzie; a pan się pod tym podpisał…’ . Jest to często pomijana, a tak na prawdę kluczowa składowa dobrego spec’a. Wraz z dobrym określeniem tego co system będzie robił, pomaga zarysować granice funkcjonalności projektu.
• Opis – czym jest projekt, z punktu widzenia. Tu ma miejsce podział systemu na różne fragmenty. Ale uwaga – to nie jest miejsce na Elizę Orzeszkową – mimo wszystko trzeba pisać o konkretach i unikać opisów pogody nad Niemnem.
• Składowe systemu – szczegółowy opis fragmentów, na jakie podzieliliśmy projekt. Jak powinny wyglądać, jak mają działać – ale cały czas z punktu widzenia użytkownika. Pożądane są tu wszelkiego rodzaju rysunki, screeny, concept art’y, itp.

Porada końcowa
Luźne stwierdzenia w spec’u są jak najbardziej pożądane. Oczywiście przesadzać nie można, ale odrobinę sensownego humoru nie zaszkodzi.

Tyle moich notatek z wykładu. Jak dane mi będzie zdobyć więcej informacji, to również się nimi podzielę. Poważnie też zastanawiam się nad zamieszczeniem notatek i wniosków z poprzednich wykładów dr Bułki – dotyczących prezentacji multimedialnych i przekazu reklamowego w ogóle. Ze swojej strony odniosę się jeszcze do terminu “niecel”. Nie mogliśmy znaleźć na wykładzie żadnego dobrego polskiego określenia. Ale tak w tej chwili wydaje mi się, że lepiej brzmiącym słowem – aczkolwiek troszkę mniej mówiącym – byłoby ‘antycel’.

Tutaj warto wspomnieć o ciekawej pomyłce. Lista tematów wymieniała Arkanoida dwukrotnie, za każdym razem pod nazwą “Archanoid”, którą to potraktowano jako nazwę gatunku. Jestem przekonany, skąd wzięła się ta skądinąd ciekawa pomyłka; tylko co na to powie Koshmaar .

Dzięki RaV‘owi odkryłem dziś nowy telefon – Neo1973. Jest to projekt rewolucyjny. Mamy do czynienia z wygodnym w obsłudze telefonem (ekran dotykowy + stylus) kategorii tych ‘lepszych’ modeli. Różnica między nim a pozostałymi jest jedna, i bardzo ważna. Telefon ten pracuje pod kontrolą Linuxa i pozwala w dużym skrócie na zrobienie z nim co się tylko podoba. Pracujemy na nim jak na normalnym Linuxie – tj. możemy chociażby skorzystać z konsoli czy kompilować i instalować własne programy w różnych językach programowania. Polecam przeglądnąć