Droga opozycjo - czas coś zmienić.

Droga opozycjo nie związana dziwnymi układami z PiSem (tak Kukiźniątka - o was piszę).

Drugi raz pod rząd przerżnęłaś wybory i wcale mnie to nie dziwi. W czasie poprzednich wyborów popełniliście duży błąd chcąc grać z doświadczonymi wyjadaczami w grę, w której są znacznie lepsi od was - w rzucanie oskarżeń i to was pogrążyło. Teraz choć próbowaliście grać w inną grę - w bądźmy tak bardzo opozycyjni jak tylko się da, znowu przegrałaś, bo to kolejna gra w której oni są lepsi. Błagam, jeśli trzeci raz chcesz grać z nimi w jakąś grę, wybierz wreszcie taką, w którą jesteś lepsza.

Co tym razem spowodowało, że PiS wygrało wybory? Po pierwsze program w stylu “wszystko co robi PiS jest złe i my zrobimy dokładnie na odwrót” się nie sprawdza. Co więcej nie sprawdza się już od jakiegoś czasu i naprawdę warto by było wziąć to pod uwagę. Owszem, większość z tego co PiS robi to jakiś obłęd, który wreszcie musi komuś wypalić w twarz. Niestety nie do końca wiadomo komu, ani też kiedy. Na razie świetnie im idzie wprowadzanie programu Białoruś+. Putin w każdym razie na pewno jest zadowolony z postępującej na arenie międzynarodowej izolacji naszego kraju. Jeśli w końcu zdecyduje przysłać i do nas swoje słynne “zielone ludziki” wszyscy potraktują nas jak Ukrainę i pozwolą mu na robienie co mu się tylko zamarzy, bo teraz z jakiejś niezrozumiałej przyczyny Jarozbaw ze wszystkich sił oddala nas od UE. Droga opozycjo - stwórz wreszcie swój program, który nie będzie bezmyślnym odbiciem programu Twojego oponenta. Jeśli on mówi “A”, to nie musisz od razu mówić “Z”, bo pomiędzy tymi literkami jest jeszcze sporo innych. Jeśli PiS mówi “nie chcemy tu uchodźców” nie mów od razu “przyjmiemy każdą ilość”. Powiedz “przyjmiemy tylko fachowców z rodzinami”, albo coś w tym stylu. Jeśli oni mówią “Stop LGBT” nie każ Schetynie z miejsca lizać migdałki Biedroniowi (nazwiska użyte bez konkretnego powodu, zamiast pierwszego może być dowolny polityk opozycji uznawany za hetero, zamiast drugiego dowolny znany gej), zamiast tego powiedz “to też są ludzie, mają inne upodobania łóżkowe, ale to nie powód, żeby ich tępić” i wystarczy. Oczywiście są sprawy, gdzie zdecydowany sprzeciw był jak najbardziej na miejscu (np. akcja z sądami), albo i takie, gdzie jak najbardziej trzeba było się zgodzić (ACTA 2). W przypadku niektórych akcji lepiej też po prostu się nie odzywać (np. strajk niepełnosprawnych), bo to tylko podkreśla elastyczność poglądów polityków wszystkich opcji.

Dlaczego musicie wygrać? Przede wszystkim mam wrażenie, że PiS jako partia populistyczna jest kompletnie niezdolny do przeprowadzenia jakichkolwiek niepopularnych reform. Wszyscy już wiemy (choć niektórzy z nas się łudzą, że będzie inaczej), że obniżenie wieku emerytalnego będzie jednym z powodów, dla których po wyjściu z wieku produkcyjnego czeka nas wgryzanie się w parapet, a już teraz prognozuje się, że wielu emerytów nie będzie stać na utrzymanie nawet własnego mieszkania (w sumie już dziś wielu z nich jest trudno). Ja się nie łudzę, że będzie inaczej, a co więcej widzę na własne oczy, że drugi filar się nie sprawdza, bo większe (czytaj: jakiekolwiek) zyski miałbym gdybym tą forsę, co mam w drugim filarze wpakował na konto oszczędnościowe. Rozdawnictwo pieniędzy pod postacią różnych programów w stylu Gówno+ też powinno się jak najszybciej skończyć, bo kolejny kryzys gospodarczy uderzy najprawdopodobniej gdzieś w przyszłym roku. Z tym PiS też nie da sobie rady - oczywiście nie zrozumcie mnie źle - jak najbardziej chciałbym zobaczyć jak ten okręt tonie, tylko nie chciałbym przy okazji zatonąć razem z nim. Musimy też przeprowadzić rozwód naszej energetyki z węglem, być może sprywatyzować część służby zdrowia (może same przychodnie?). Trzeba w końcu też rozdzielić państwo od kościoła, bo obecna relacja jest zwyczajnie chora. O losach państwa nie zawsze decydują legalnie wybrani posłowie, a goście w czarnych sukienkach, którzy nie odpowiadają przed nikim.

Coraz częściej słychać poważne głosy z waszego własnego grona, które mniej więcej mówią o tym samym co i ja. Może wreszcie czas ich posłuchać, bo jeśli Adrian zostanie na drugą kadencję, to może z nami wszystkim być słabo.

P.S. Tak jak patrzę sobie po statystykach, to mam wrażenie, że mojego bloga czytają już tylko ludzie, którzy chcą zareklamować swoje strony porno i jacyś goście z Rosji… Jeśli jesteś tu z jakiegoś innego powodu daj znać.

Non omnis moriar

Igor czekał już od godziny. Skrzypienie łóżka dobiegające zza drzwi skończyło się dobrych kilkanaście minut temu. Siedemnaście gwoli ścisłości, jak tylko upewnił się, że skończyli w prawej dolnej części pola widzenia uruchomił stoper. O ile znowu nie wtarabani się temu gnojkowi do łóżka za maksymalnie pięć minut powinna wychodzić.

Nuda była koszmarna, żaden z jego ulepszonych zmysłów nie wyłapywał niczego podejrzanego. Powleczone metalem oczy bacznie przeczesywały okolicę wyszukując zagrożeń, czegoś do roboty. Skrzypnęły drzwi na końcu korytarza i co na moment zwróciło jego uwagę. Na korytarz wytoczył się jakiś facet, pewnie pijany, albo naćpany. Obijając się o ściany wąskiego korytarza zaczął powoli iść w stronę Igora. Hałas jaki przy tym robił prawie zagłuszył delikatny szmer buta przesuwającego się po wykładzinie. Nie zdążył odwrócić głowy, gdy oberwał w nią jaką rurką. Bardziej go to zaskoczyło, niż zamroczyło, ale to wystarczyło napastnikowi do zadania drugiego uderzenia. W duchu Igor bardzo się ucieszył, że zdecydował się na zabieg metalizowania kości, dzięki któremu jego czaszka zniosła zabójczy cios bez szwanku, a on sam zachował jasność myślenia.

Wzmocnione implantami mięśnie zareagowały zgodnie z wielotygodniowym szkoleniem i wyprowadziły potężny cios prosto w podbródek napastnika. Sądząc po odgłosie pękających kości tego tutaj już miał z głowy. Odwracając się nakazał swojemu modułowi komunikacyjnemu ostrzec Panią. W czasie gdy walczył z pierwszym napastnikiem facet wcześniej udający pijanego zdążył nabrać już całkiem poważnego rozpędu i wyciągnął zza pazuchy nóż. Szybka identyfikacja noża dokonana przez jego koprocesor bojowy wyświetliła się na środku jego pola widzenia - BROŃ ZABÓJCZA NAWET DLA WYPOSAŻONYCH W PANCERZE PODSKÓRNE. To nie była wiadomość, którą Igor chciał przeczytać. Zamarkował zamach ręką, po czym wyprowadził potężne, wspomagane kopnięcie w podbródek atakującego. Napastnik jednak nie dał się kompletnie zaskoczyć i zszedł z drogi uderzenia, które zamiast jego żuchwy trafiło w ramię. Efekt może nie był całkiem po myśli Igora, ale wystarczył do przewrócenia przeciwnika i wtrącenia mu z dłoni noża.

W wyniku uderzenia Igor zachwiał się trochę i stracił może sekundę na odzyskanie równowagi. Gdy tylko to się udało kolejne polecenie wydane przez jego mózg odblokowało niewielkie działko zamocowane tuż powyżej jego nadgarstka. Igor nie lubił go używać, ponieważ rozrywało mu to skórę i powodowało całkiem poważny ból. Na szczęście Pani była bardzo dobrą klientką i nigdy nie żałowała grosza na zabiegi mające odtworzyć skórę, ponieważ zawsze warto było mieć broń, której przeciwnik kompletnie się nie spodziewał. Gruchnął strzał i leżący na podłodze napastnik złapał się za twarz. Wspomagany elektroniką słuch Igora zdradził jednak, że facet żyje i poza przyspieszonym biciem serca raczej mocno nie odczuł tego strzału. Igor odrobinę się zaniepokoił. Nadzieja, że trafił na kompletnie nieprzygotowanych amatorów właśnie gdzieś sobie prysła. Wydał polecenie, aby implant zmienił amunicję na przeciwpancerną, ale to chwilę trwało. Atakujący w tym czasie zdążył zerwać się na równe nogi i ponownie natrzeć na Igora. Połowa jego twarzy pozbawiona była skóry. Igor widział wyraźnie matową czerń pancerza podskórnego od nosa, aż do prawego ucha. Gdy zwarli się w uścisku ochroniarz wydał polecenie koprocesorowi bojowemu aby wykonał analizę taktyczną. Po krótkiej chwili w polu widzenia pojawił się komunikat: WALKA WRĘCZ NIEWSKAZANA - SZANSE NA ROZSTRZYGNIĘCIE 5%. “Dzięki Sherlocku” pomyślał Igor i wywołał polecenie ciągłej analizy. Napastnik też powinien wiedzieć, że w ten sposób nie wygra, musiał więc coś jeszcze mieć w zanadrzu. Wreszcie kątem oka dostrzegł trzeciego napastnika - to pewnie był główny zamachowiec. Wreszcie koprocesor bojowy wyświetlił komunikat - ANALIZA TAKTYCZNA ZAKOŃCZONA, PRZEJĘCIE KONTROLI NAD NOSICIELEM. Zanim Igor zdążył w jakikolwiek sposób zareagować ręka z działkiem na chwilę oderwała się od eks-pijaka, wycelowała i wystrzeliła w głowę zamachowca. Pocisk gładko wszedł w czoło mężczyzny i wychodząc z drugiej strony zostawił malowniczy rozbryzg na ścianie, którą też zresztą przebił. Ułamek sekundy później implant Igora złamał mu kość przedramienia, dzięki czemu mógł ją wycelować w pierwszego napastnika. Kolejny strzał wymierzony przez komputer i tym razem kula weszła pomiędzy żebrami i utorowała sobie drogę aż do mózgu, który do społu ze sklepieniem czaszki zapaskudził Igora i ścianę za nim. Igor szybko wstał i przyjął pozycję bojową. Komunikat w polu widzenia zgasł i odzyskał kontrolę nad swoim ciałem. Ból złamanej kości będzie mu dokuczał jeszcze przez jakiś czas. Może jednak wstawić tam dodatkowy staw i bardziej wzmocnić kości? Zastanawiając się nad tym stanął tyłem do drzwi których miał pilnować, ustawił timer na 75 sekund i rozpoczął nasłuch na pełnej mocy swoich elektronicznych zmysłów.

Skanując otoczenie w termowizji zobaczył tylko kilku innych klientów hotelu kulących się na podłodze w swoich pokojach. W uszach słyszał jak jakiś facet cicho szlochał i kobietę, która chyba miała atak paniki bo jej serce niesamowicie szybko waliło.

Gdy minął wyznaczony przez niego czas wysłał wiadomość do Pani.

- Trzech napastników, wszyscy nie żyją. Spokój od 80 sekund. Czy wszystko w porządku?

Odpowiedź nadeszła błyskawicznie:

- POMÓŻ MI!

Igor tylko wierzgnął nogą do tyłu wyłamując drzwi i odwrócił się zanim jeszcze na dobre wpadły do wewnątrz pokoju. Na środku pomieszczenia stało wielkie łoże, a na nim leżała Pani. Miała szeroko otwarte oczy i oddychała szybko. Z jej ręki ciekła krew, a za łóżkiem leżały zwłoki jej niedawnego kochanka z dziurą po kuli w głowie.

- Zabierz mnie stąd Igorze - wyszeptała.

- Tak jest. - odpowiedział.

Igor podszedł do kobiety, dotknął jej złącz neuralnego i wydał polecenie połączenia się z jej koprocesorem bojowym. Uśpił, a raczej odłączył jej świadomość kasując z pamięci wszystko co zaszło gdy maszyna przejęła kontrolę. Zawsze to lepiej, gdy ochraniany sam może się obronić w krytycznej chwili, ale dla osób bez przeszkolenia takie przeżycie może być bardzo traumatyczne. Przejąwszy kontrolę nad ciałem Pani nakazał swoim implantom wezwanie policji i przekazanie im pełnego raportu, który w międzyczasie został wygenerowany poprzez koprocesor wspomagający.

Gdy dotarli do domu Pan już na nich czekał. Gdy Igor z Panią tylko pojawili się w drzwiach tak samo jak wcześniej Igor nad Panią, tak samo teraz Pan przejął kontrolę nad Igorem, ale nie był na tyle litościwy, aby odłączyć mu świadomość. Trwało to zbyt krótko, aby Igor mógł temu przeciwdziałać. Gdy skończył Pan wykrzyczał:

- Dlaczego ty wreszcie nie zdechniesz kurwo?!

Po czym zza paska wyszarpnął pistolet i strzelił. Pierwsza kula nie trafiła idealnie i ześlizgnęła się po opancerzonym policzku Pani. Druga była już lepiej wycelowana i przebiła jej czoło. Igor ciągle połączony neuralnie z Panią dokładnie poczuł jak umierała, ale nie mógł z tym nic zrobić. Pan wziął pistolet, popatrzył na ochroniarza swojej żony i pokręcił głową. Podskórny pancerz Igora był sporo grubszy od tego, który miała Pani, więc o ile pistolet nie był załadowany specjalną amunicją raczej niewiele by zdziałał. Pan chyba zdawał sobie z tego sprawę, bo westchnął, włożył sobie pistolet do ust i nacisnął spust.

C# samouczek część IV, czyli znam już trochę zmienne i co mogę z nimi zrobić.

W poprzednim odcinku objaśniałem czym są zmienne i co można do nich wpakować. Czego nie wyjaśniałem, to jak z kolei z tych zmiennych korzystać. 

Aby zadeklarować jakąś zmienną musimy w kodzie podać jej typ, oraz nazwę (identyfikator). O ile typy już znamy, o tyle o nazwach jeszcze nic nie wspomniałem. Nazwa naszej zmiennej musi składać się z liter (ale tylko łacińskich, bo amerykanie, którzy opracowali ten język są nieufni wobec liter, których nie ma w ich alfabecie) i może zawierać cyfry, lub znaki “_” lub “@” (chociaż tego drugiego zdecydowanie nie polecam, a wyjaśnię szerzej, gdy dojdziemy do operacji na łańcuchach znaków). Nazwa nie może zaczynać się od cyfry. Generalnie zasady te odnoszą się do wszystkiego co można w C# sobie nazwać po swojemu i nie będę już do nich wracał. Gdybyśmy chcieli więc oznajmić naszemu programowi, że ma stworzyć 32 bitową zmienną całkowitoliczbową i nadać jej imię Zuzanna robimy to tak: 

int Zuzanna; 

Zadeklarowanej w ten sposób zmiennej nie powinniśmy odczytywać (poprawnie ustawiony kompilator zresztą, czy też środowisko programistyczne wskaże nam to jako błąd), ponieważ w tym momencie zawartość tej zmiennej może być dość przypadkowa, ponieważ tworząc zmienną po prostu rezerwujemy sobie na nią pamięć i tyle. Żeby móc więc ją odczytać, najpierw wypadałoby coś do niej zapisać. Aby zapisać coś naszej Zuzannie wystarczy posłużyć się operatorem “=” (operatorów jest trochę więcej, ale o tym jak zwykle - później). 

Zuzanna = 22; 

Zuzanna ma więc wartość 22. Ale to są dwie linijki kodu, a programiści są znani z tego, że aby zaoszczędzić kilka minut czasu są zdolni poświęcić nawet kilka godzin, dlatego wpadli na to, że właściwie wszystko (a więc deklaracje i przypisanie wartości) można zrobić za jednym zamachem. 

int Zuzanna = 22; 

Okazuje się, że z tym lenistwem i oszczędzaniem linijek kodu można pójść nawet dalej i zrobić tak: 

int Zuzanna = 22, Adrian = 23; 

Tak moi drodzy, można nie tylko zadeklarować dwie zmienne na raz, ale też i od razu je zainicjalizować (czyli przypisać im jakąś wartość początkową). Mamy więc już aż dwie zmienne, czy można coś z nimi zrobić? W końcu komputer to po angielsku “maszyna licząca” tak więc możemy coś sobie policzyć na tych zmiennych. Możemy dodeklarować trzecią zmienną “wynik”. 

int wynik; 

I tenże wynik może być np. różnicą wartości Zuzanny i Adriana. 

wynik = Adrian - Zuzanna; 

W tej chwili wynik odejmowania Zuzanny od Adriana, albo wynik odejmowania wartości ukrytych pod tymi identyfikatorami zostaje zapisany do zmiennej “wynik”. Aż się prosi o to, aby sobie trochę rzecz uprościć i za jednym zamachem zadeklarować zmienną i zapisać jej wartość. 

int wynik = Adrian - Zuzanna; 

Nasuwa się więc pytanie, skoro takie jednolinijkowce przechodzą tak bezboleśnie, to czy można w jednej linijce zadeklarować dwie zmienne, zainicjalizować je i wykorzystać do inicjalizacji kolejnej? Otóż nie. Programiści odpowiedzialni za język C# (albo raczej jego architekci) jeszcze nie doszli do tego, że komuś mogłoby to ułatwić życie. Ja osobiście wolę w jednej linijce deklarować i inicjalizować tylko jedną zmienną, bo w razie co łatwiej jest ją wyrzucić. 

Ok. Wiemy już jak deklarujemy zmienne, a czy wiemy gdzie w kodzie można to zrobić? Odpowiedź brzmi prawie wszędzie, ale dokładne miejsce zależy od tego do czego nam ta zmienna będzie służyć i gdzie ma być dostępna. Co do zasady nasze zmienne powinny być niedostępne tam, gdzie nie są potrzebne. Posługując się więc naszym programem z rozdziału drugiego (lekko tylko zmodyfikowanym) postaram się wyjaśnić różnice. 

1  using System;                          

2  using System.Collections.Generic;      

3  using System.Text;                     

4                                         

5  namespace HelloWorld                   

6  {                                      

7                                         

8   class Program                         

9   {                                     

10                                        

11     static void Main(string[] args)    

12     {                                  

13                                        

14       Console.WriteLine("Hello World");

15     }                                  

16   }                                    

17 }                                      

Specjalnie zostawiłem kilka pustych linii aby łatwiej było sobie wyobrazić, że tam właśnie wylądują nasze deklaracje.

Linia 4 - tutaj nie możemy deklarować zmiennych. Nie i już. Możemy oczywiście próbować, ale kompilator się na nas obrazi i nie zechce podjąć współpracy. 

Linia 7 - zmienne umieszczone tutaj będa dostępne dla całej przestrzeni nazw “HelloWorld” (bo taka jest jej nazwa). Przestrzeń nazw pozwala nam połączyć ze sobą w logiczną całość kilka klas, aby było łatwiej się do nich odwoływać. Na tak małym przykładzie trudno jest niestety dostrzec sensowność takiego rozwiązania, ale przydaje się to np. gdy łączymy kilka małych projektów w jedną dużą całość - wtedy nawet gdyby te projekty używały tych samych zmiennych to dzięki poupychaniu ich w różne przestrzenie nazw nie będziemy mieć żadnych konfliktów (choć bardziej niż zmiennych dotyczy to nazw klas). 

Linia 10 - zmienna umieszczona tutaj będzie dostępna dla wszystkich elementów danej klasy (a właściwie instancji tej klasy - ale o tym jak zwykle - później) bez ograniczeń. Pozostałe obiekty mogą używać tych zmiennych tylko gdy są one oznaczone jako publiczne za pomocą słowa kluczowego public przed deklaracją typu, natomiast elementy wewnątrz tej klasy będą mogły sobie używać tej zmiennej do woli. Generalnie nie jest zalecane bezpośrednie wystawianie zmiennych, ale o tym jak sobie z tym poradzić opowiemy sobie, gdy dojdziemy do programowania obiektowego. 

Linia 13 - zmienna zadeklarowana tutaj będzie dostępna tylko wewnątrz funkcji (prawidłowa nazwa, to “metoda”, ale ja po prostu pierwsze kroki w programowaniu stawiałem w Turbo Pascalu i tam było takie fajne rozgraniczenie, że to co nie zwraca wyniku, to procedura, a to co zwraca - to funkcja, potem w C wszystko już było funkcją i jakoś w nazewnictwie na tym się zatrzymałem, bo ludzie już nie wiedzą co to jest procedura, ale jeszcze pamiętają czym jest funkcja, więc generalnie wiedzą o co mi chodzi) w której została zadeklarowana i choćby się skały zesrały nic już z tym nie można zrobić, chyba, że zwrócimy ją jako wynik funkcji. Zgadliście - o tym też będzie później. O czym trzeba pamiętać, że po zakończeniu wykonywania się funkcji zawartość zmiennych jest nie do odzyskania. Każde nowe odpalenie funkcji zaczyna “na świeżo” (program może zwolnić pamięć przydzieloną dla tych zmiennych, co też prędzej czy później się dzieje). 

Dowolny (no prawie dowolny) blok kodu zamknięty nawiasami klamrowymi wewnątrz funkcji - zmienna będzie dostępna tylko w tym bloku kodu, a po jego opuszczeniu zostanie “zapomniana”, a przydzielona jej pamięć będzie prędzej, czy później zwolniona. W przypadku operowania na zmiennych, które zajmują dużo pamięci można posiłkować się deklaracją takiej zmiennej z użyciem słowa kluczowego using, co pozwala na zwolnienie pamięci natychmiast, gdy nie jest już potrzebna. Taki blok kodu możemy zastosować tylko wewnątrz funkcji i wyglądać on może np. tak: 

using (JakasBardzoDuzaKlasa jakisBardzoDuzyObiekt = new JakasBardzoDuzaKlasa()

{

  jakisBardzoDuzyObiekt.JakisSkomplikowanyKodDoWykonania();

}

Na koniec - dobra rada. Wymyślając nazwy dla swoich zmiennych człowiek dość szybko ulega pokusie, aby zastąpić je pojedynczymi literami - bo przecież działa, ale generalnie nie polecam, no może poza sytuacjami, gdy zmienna naprawdę potrzebna jest tylko “na chwilkę”. Na co dzień jednak lepiej, aby nazwa zmiennej odzwierciedlała do czego też owa zmienna ma służyć. W przykładzie powyżej zastosowałem dwie metody nazewnictwa zalecane przez autorów C#. PascalCase stosujemy do elementów dostępnych publicznie i polega na nazywaniu tych elementów zgodnie z ich funkcją zaczynając od wielkiej litery i tak, jeśli mamy gdzieś publiczną funkcję która policzy nam wiek Zuzanny powinniśmy ją nazwać np. ObliczWiekZuzanny. Z kolei do elementów prywatnych, a więc dostępnych tylko dla klasy w której się akurat szarogęsimy zalecany jest tzw. camelCase. Różni się tylko tym, że pierwsze litera jest literą małą - w związku z tym, gdyby nasza funkcja była metodą prywatną powinna się nazywać obliczWiekZuzanny. Gdyby jednak, jakimś cudem zdarzyło się Wam zdryfować w kierunku języków w których nie mamy jako takich typów zmiennych, albo mamy tzw. typowanie słabe (nie wprost), wtedy nieoceniona jest tzw. notacja węgierska, czyli camelCase lub PascalCase poprzedzone pierwszą literką typu - czyli gdyby nasza metoda zwracała wartość całkowitoliczbową nazywałaby się iObliczWiekZuzanny.

W następnym odcinku - operatory matematyczne i logiczne.

W poprzednim odcinku - typy zmiennych.

P.S. Haifisch - cover lepszy od oryginału.

C# - samouczek, część III - proste typy zmiennych i po co komu te cholerne zmienne.

Zacznijmy od tego, czym jest zmienna. Otóż zmienna jest odnośnikiem do pamięci, który akurat przechowuje dane mogące nam się z różnych przyczyn przydać. Mówiąc bardziej po ludzku - to takie nasze myślowe pudełko i jak to z pudełkami bywa, można coś do niego włożyć, przechować i wyjąć gdy będzie potrzebne. Można też gdzieś wysłać gdy jest taka potrzeba. 

Czym są więc typy zmiennych? Typ zmiennych mówi nam jak program ma interpretować dane, które w tej pamięci siedzą. Nie jest wiedzą tajemną, że każda informacja jaką nasz komputer w sobie przechowuje ma postać cyfrową - najczęściej zer i jedynek, natomiast zmienne pozwalają nam zinterpretować te liczby bądź jako ciąg znaków, bądź liczbę, bądź odpowiedź na pytanie o życie wszechświat i całą resztę (nawiasem mówiąc - to 42). 

W przypadku C# powinniśmy sami określać jaki rodzaj danych mają nasze zmienne (i chociaż da się to trochę obejść, to strasznie utrudnia to poprawianie kodu, który zawiera błędy logiczne), co (wracając do pudełkowej analogii) znowuż możemy sobie wyobrazić jako te nieszczęsne styropianowe wkładki, które powodują, że do naszego pudełka włazi tylko jeden konkretny produkt. Niestety tutaj przydatność pudełka jako analogii kompletnie się kończy, ponieważ ze zmiennymi możemy zrobić kilka sztuczek, które nie udadzą się z żadnym kartonikiem, dlatego zacznijmy już nasz krótki przegląd zmiennych. 

Typy całkowite. 

Typy całkowite pozwalają nam przechowywać liczby całkowite. Ponieważ informację o tym, jak wygląda liczba całkowita większość z nas zdążyła zapomnieć gdzieś w 4 klasie szkoły podstawowej przypomnę, że to po prostu liczba, która nie posiada części ułamkowej. 

Najprostszym typem całkowitym jest byte i jego koleżka sbyte (w C# wielkość liter ma znaczenie, więc aby uniknąć konfliktu z moim edytorem tekstu będę się starał nazwy pisane małą literą umieszczać gdzieś w środku zdania). Jak już sama nazwa wskazuje zajmują w naszej cennej pamięci dokładnie jeden, ośmiobitowy bajt (bajty nie zawsze muszą być ośmiobitowe, choć takie się najczęściej stosuje). Nasuwa się pytanie, czym więc się różnią? Literka “s” w sbyte bierze się od angielskiego “signed”, co w tym wypadku oznacza “ze znakiem”. Dzięki temu sbyte umożliwia nam zapisanie liczby ze znakiem. Pierwszy bit zużyjemy więc na opisanie czy nasza liczba jest dodatnia, czy ujemna, zostanie nam więc jeszcze 7 bitów do zapisania liczby. Każdy bit może przyjąć dwa stany - zero lub jeden, a więc możemy zapisać na nim 2 do 7 kombinacji czyli 128. Jedna kombinacja odpada nam na zapisanie liczby zero, dlatego maksimum jakie możemy zapisać to 127. Ponieważ zero nie ma znaku (komputery jednakże dla ułatwienia przyjmują zero za dodatnie), to dla zakresu liczb ujemnych nic nie musimy zabierać i zostaje nam 128 kombinacji. Dlatego pełny zakres sbyte to od -128 przez 0 do 127. Dla odmiany byte nie przechowuje żadnej informacji o znaku i każdą liczbę zapisaną w tym typie zmiennych traktuje jako dodatnią. Mamy więc do dyspozycji 8 bitów, a więc 2 do 8 potęgi kombinacji, czyli 256, minus jedna kombinacja na zapisanie liczby zero. Daje nam to zakres od 0 do 255. 

Przebrnęliśmy jakoś przez te najprostsze typy, ale zasada co do zakresu jest zawsze podobna. I tak przechodząc do zmiennych całkowitych szesnastobitowych mamy short i ushort. Zderzamy się tutaj z rzeczą bardzo, bardzo często spotykaną w wielu językach programowania. Jest ona straszna i czasem doprowadza do białej gorączki - niekonsekwencja. Tym razem ktoś wymyślił, żeby lepiej nie dodawać dodatkowej literki “s” przed nazwą typu który może być ujemny. Zdecydowano dodać “u” od “unsigned” (czyli "bez znaku") przed typem, który nie może ujemny (chociaż tak naprawdę to byte jest tutaj czarną owcą). Reszta podobnie - w short 1 bit na znak, 15 na liczbę co daje nam zakres od -32768 przez 0 do 32767. W ushort wykorzystujemy pełne 16 bitów co daje nam do dyspozycji zakres od 0 65535. 

Następne w kolejności zmienne 32 bitowe to ulubiony przez wszystkich int i jego rzadziej stosowany brat uint. Podobnie jak poprzednio dla int dysponujemy 31 bitami na liczbę plus jeden na znak, co daje nam dość konkretny już zakres od -2 147 483 648 do 2 147 483 647 (z zerem włącznie) i nie mniej poważny dla uint od 0 do 4 294 967 295. 

Na koniec zostają nam już tylko 64-bitowe potwory long i ulong. W pierwszej zapiszemy liczby od -9 223 372 036 854 775 808 do 9 223 372 036 854 775 807, a w drugiej nie mniej poważny zakres od 0 do 18 446 744 073 709 551 615. Są to już naprawdę poważne liczby, ale mimo to mogą się okazać za małe, niestety aby wykroczyć poza nie trzeba już złożonych typów danych i raczej nie planuję poruszać tego tematu w tym samouczku. 

Typy zmiennoprzecinkowe 

Nie samymi jednak liczbami całkowitymi człowiek żyje i czasem musi popełnić jakiś ułamek. Aby uporać się z tym zadaniem wymyślono typy zmiennoprzecinkowe i tej nazwy raczej nie pamiętacie z matematyki, a to dlatego, że to nie to samo co liczby rzeczywiste poznane w szkole. Generalnie rozchodzi się o sposób zapisu w tzw. notacji naukowej. Gdzie np 125,68 zapiszemy jako 1,2568*10^2.

Zapis bitowy liczby zmiennoprzecinkowej to generalnie koszmar, ale warto mieć w pamięci, że ponieważ bity przyjmują tylko dwa stany wszystko rozchodzi się o podnoszenie dwójki do odpowiedniej potęgi. Z ułamkami jest podobnie, tylko jako podstawę przyjmujemy nie 2, a ½ (czyli 2 do -1) i sumujemy ułamki, aż wyjdzie mniej więcej to co trzeba. Im więcej mamy tych ułamków do dyspozycji tym dokładniej będzie opisana nasza liczba. Niestety trudności sprawiają już nawet bardzo nieskomplikowane liczby jak np. ⅕. W zapisie dwójkowym to by było mniej więcej tak: 0 * ½ + 0 * ¼ + 1*⅛ + 1*1/16 = 3/16 ~ ⅕. Im więcej wstawię ułamków, tym bliżej będę pożądanej wartości, ale nigdy jej w 100% nie osiągnę i zawsze gdzieś pojawi się to nieszczęsne zaokrąglenie. Dlatego w ich przypadku istotniejsza jest precyzja zapisu (więcej ułamków) niż zakres. To wszystko jednak nie wyjaśnia dlaczego te liczby nazywają się zmiennoprzecinkowymi - otóż samo zapisanie ułamka to nie wszystko. W końcu liczby rzeczywiste nie ograniczają się do zakresu od 0 do 1. Aby problem rozwiązać, a sprawy nieco skomplikować znowu musimy gdzieś dorzucić bit znaku, a i jeszcze trzeba by zapisać część całkowitą no i gdzieś przechować wykładnik potęgi… Krótko mówiąc koszmar i tyle. 

Mając jednak to wszystko na uwadze trzeba pamiętać, że liczby zmiennoprzecinkowe są prawie zawsze obarczone pewnym błędem i wiele wielu operacji na tych samych zmiennych tylko sprawę pogarsza. 

Wracając jednak do meritum w C# znajdziemy trzy podstawowe typy zmiennych zmiennoprzecinkowych:

float o zakresie od ±1.5 x 10^(−45) do ±3.4 x 10^(38) i dokładności ~6-9 cyfr

double dające od ±5.0 x 10^(−324) do ±1.7 x 10^(308) i dokładności 15-17 cyfr

decimal w zakresie od ±1.0 x 10^(-28) do ±7.9228 x 10^28 i dokładności 28-29 cyfr

Ponieważ w pamięci komputera zapis tych liczb jest bardzo różny w kodzie musimy podawać jakim dokładnie typem się posługujemy. Aby więc pomóc kompilatorowi rozróżnić jakiego typu jest liczba 0.1 dodajemy na jej końcu odpowiednie literki: f lub F dla float, d lub D (albo po prostu liczbę z kropeczką) dla double i aby dobrze nam się kojarzyło z mamoną - m lub M dla decimal.

Których więc używać? Najszybsze są zmienne typu float, ale też najmniej dokładne. Najdokładniejsze są zmienne typu decimal i z tego tytułu zalecane jest ich używanie przy obliczeniach finansowych, ale ze względu na rozmiar operacje na nich są najwolniejsze - no i za ich pomocą można przechować najmniejsze liczby. Złotym środkiem jest double, który daje średni czas operacji, niezłą dokładność i największy zakres. Niestety oficjalna dokumentacja milczy na temat ilości zajmowanej pamięci przez poszczególne typy, nie mniej jednak należy założyć, że im większa precyzja, tym większy rozmiar. Najprawdopodobniej jednak mamy 32 bity na float, 64 na double i 128 na decimal. 

Typ znakowy. 

I na koniec bliski koleżka typu byte czyli char. Podobnie jak on zajmuje w pamięci 1 bajt, ale jest interpretowany nie jako liczba, a jako znak. Dokładniej pojedynczy, niesformatowany znak z rozszerzonego zakresu ASCII. Same w sobie używane dosyć rzadko, ale za to nieocenione, gdy weźmie się stadko takich znaków i ułoży z nich napis np. “Koniec tej części samouczka, bo już mnie palce bolą od pisania”. 

Lekcja już wyszła dosyć długa, choć temat należał raczej do tych prostszych, nie mniej jednak warto byłoby poruszyć jeszcze jedną kwestię. Otóż jak i gdzie mamy powiedzieć naszemu programowi, że chcemy użyć jakiejś zmiennej? O tym będzie w następnej części (no i pojawią się jakieś przykłady). 

W poprzednim odcinku: Witaj świecie!

W następnym odcinku: Deklaracje zmiennych. 

P.S. Elisium - remix od Daxxa (tego z Ravebusters) oryginał (też bardzo dobry) od Jestera

Tajemnica czarnych lakierek.

Wiatr delikatnie poruszał firanką. Kołysała się rytmicznie w przód i w tył jak wahadło. Lubił takie noce.

Odstawił kieliszek w którym zostało kilka ostatnich kropel whiskey, a po chwili namysłu zaniósł go do kuchni i wstawił na górną półkę zmywarki. Wrócił do pokoju, rozejrzał się i przestawił fotel. Zawsze był pedantem i nic nie mogło tego zmienić. Nie chciał zostawić po sobie większego bałaganu niż było trzeba, nawet jeśli nigdy już tu nie wróci. Ostatni raz spojrzał na swoje mieszkanie. Spędził w nim wiele lat, być może nawet zbyt wiele. Upewnił się, że drzwi zostały zamknięte na klucz, zapewne minie kilka miesięcy zanim ktoś się zorientuje, że go nie ma. Wracając do salonu gładził ścianę przedpokoju czując opuszkami palców jej delikatnie chropowatą teksturę i chłód betonu. Nie mógł powstrzymać się od dotknięcia futryny z lakierowanego orzecha, ale w końcu dotarł do drzwi balkonowych. Wyszedł na balkon ostatni raz podziwiając panoramę miasta. Upadek z tej wysokości będzie trwał naprawdę długo i nawet trochę cieszył się z tej perspektywy. Cofając się do wnętrza mieszkania rozchylił firanki do końca - przecież nie chciał którejś z nich zahaczyć i pociągnąć za sobą, wyglądałby wtedy jak idiota.

Doszedłszy do końca pokoju wykonał “w tył zwrot” jakiego nie śmiałby wyśmiać najbardziej okrutny kapral musztrujący swoje koty. Dostawił nogę i przez niewielki ułamek sekundy stał jakby w pozycji “na baczność”. Gdy tylko stopa dotknęła miękkiego dywanu stała się punktem odbicia dla pierwszego kroku. Kolejny krok, potem bieg. Już za chwilę będzie po wszystkim. Każde dotknięcie podłoża to wspomnienie. W tym fotelu całował szyję Anny (a miała naprawdę piękną szyję), przy tamtej lampie kochał się z… a cholera wie jak jej było na imię, ale jej piersi pamiętał dobrze. 

Wreszcie osiągnął próg balkonu i ostatnie wspomnienie związane z tym miejscem mignęło mu przed oczami tak szybko, że bardziej przypomniał sobie emocje jakie mu towarzyszyły niż zobaczył tamto wydarzenie. Może to był Nowy Rok? Teraz już za późno. Wybił się wysoko i szczupakiem przeskoczył barierkę. Mijając ją szybko zerknął czy przypadkiem nie przyczepiła się do niego ta nieznośna firana, ale na szczęście zobaczył tylko czerń swoich butów.

Zimne powietrze zaczęło uderzać w jego twarz i zakradać się pod koszulę. Ręce wyciągnął na boki, aby ustabilizować swój lot ku ziemi. Światła miasta, ulica w dole, pojedynczy, maleńcy ludzie, wszędobylskie samochody, niektóre w ruchu, większość zaparkowanych. Spokojnie przyglądał się temu wszystkiemu i chłonął te widoki po raz ostatni. W końcu już nigdy więcej nie skoczy z tego balkonu. Powietrze w okół niego przyspieszało porywając poły jego marynarki. Miał nadzieję, że wytrzyma, bo nie pomyślał wcześniej aby ją zapiąć. Zresztą zapięta czasem przeszkadzała. Równe płyty chodnika zbliżały się coraz szybciej oświetlone pomarańczowym światłem latarnii. Mrugnął i w tym ułamku sekundy znalazł się już ładnych kilka pięter niżej. Chyba osiągnął prędkość graniczną, bo w ogóle nie odczuwał już przyspieszenia. To jeszcze chwila, jeszcze moment. Uśmiechnął się do siebie wiedząc co za chwilę go czeka. Jeszcze sto metrów, jeszcze pięćdziesiąt.

Już!

Rozpostarł swoje nietoperze skrzydła. Gdy je rozkładał poczuł jak rozrywają koszulę, ale na szczęście marynarkę tylko rozchyliły. Trudno, koszula i tak była gówniana. Kupi sobie lepszą. Gdy skrzydła złapały wiatr, zmienił trochę ich kąt ataku i z człekokształtnego kamienia spadającego ku nieświadomej niczego powierzchni ziemi stał się Ikarem, który przehandlował z diabłem anielskie skrzydła z łabędzich piór na rzecz szatańskich skrzydeł nietoperza.

Jeśli ktoś z ludzi przechadzających się chodnikiem pod nim coś poczuł, to najwyżej niespodziewany podmuch wiatru wiejącego z góry. Zanim taki zaskoczony przechodzień spojrzał w górę zbadać co spowodowało taki ruch powietrza jego już dawno tam nie było.

Do wschodu słońca miał jeszcze kilka godzin, do tego czasu zdąży spokojnie przelecieć nad granicą i uwić sobie nowe gniazdko, być może na kilka kolejnych dziesięcioleci, być może krócej jeśli będzie miał pecha. Tylko też musi znaleźć sobie mieszkanie gdzieś wysoko, żeby móc ponownie poczuć ten wiatr na sobie. Trochę to utrudnia powroty z polowania, ale jeśli tylko nie ubrudził się krwią mógł w zasadzie spokojnie wracać windą. 

Trasę zaplanował sobie już dawno temu, w pamięci miał wszystkie mapy, pamiętał każdą drogę i rzekę wzdłuż których miał lecieć. Pamiętał o każdym punkcie obserwacyjnym. O tam, w dole, dokładnie przed sobą widział światła lotniska. W uszach szumiało mu powietrze, coraz głośniej i głośniej.

- Wieża tu lot H1450 chyba właśnie jakiś ptak wpadł nam do silnika. Prosimy o pozwolenie na awaryjne lądowanie na pasie jeden osiem.
- Jest jeden osiem, lądujcie i niech bóg ma was w swojej opiece.
- Przyjąłem. Dzięki. 

A tajemnicy resztek czarnych lakierek w silniku samolotu, który lądował awaryjnie na pobliskim lotnisku, nigdy nie wyjaśniono. 

C# - samouczek, część II - “Witaj Świecie!” czyli omówienie składni na podstawie najprostszego programu

Jakoś tak przyjęło się, że ucząc się nowego języka wypada stworzyć na nim jakiś program. Tradycyjnie jest to aplikacja, której jedynym zadaniem jest przywitać w imieniu użyszkodnika świat. Ponieważ tradycja ta jest nieszkodliwa - i ponieważ tak twierdzi tytuł tego wpisu - także i ja nie zamierzam porzucić tego zwyczaju.

Zacznijmy więc coś kodzić - w poprzednim wpisie poleciłem IDE Microsoftu znane szerszej publiczności jako Visual Studio (wersja dla użytkowników prywatnych ma swojej nazwie słowo Community i jest wystarczająca dla zdecydowanej większości zastosowań). Aby stworzyć program, który umożliwi nam powitanie ze światem musimy w pierwszej kolejności stworzyć sobie nowy projekt (screeny są z VS 2017, ale dla innych wersji zasada jest podobna):

i wybrać jego typ:

Warto od razu wyrobić sobie nawyk porządnego nazywania swoich aplikacji i biblioteki - inaczej szybko grozić nam będzie organizacyjny burdel, który może być szczególnie bolesny, gdy będziemy chcieli znaleźć kawałek kodu do ponownego wykorzystania. Po kilku miesiącach w morzu katalogów ConsoleApp (lub podobnych) jest to nieco trudniejsze niż się człowiek spodziewa. Idąc więc za swoją radą nazwę swój program HelloWorld. 

Po kliknięciu OK naszym pełnym samozadowolenia oczom ukaże się kod prawie gotowego programu. Należy go uzupełnić o dosłownie jedną linijkę by dotrzeć do celu. Aby tego dokonać musimy wiedzieć nie tylko co napisać, ale też i gdzie. Przyjrzyjmy się więc temu, co już mamy:

1  using System;

2  using System.Collections.Generic;

3  using System.Text;

4  

5  namespace HelloWorld

6  {

7      class Program

8      {

9          static void Main(string[] args)

10         {

11         }

12     }

13 }

A jak widać trochę się tutaj dzieje. Na początek na warsztat bierzemy pięć pierwszych linijek:

1  using System;

2  using System.Collections.Generic;

3  using System.Text;

4  

5  namespace HelloWorld

Pierwsze co rzuca się w oczy to słowo kluczowe “using”. Oznacza ono, że posiłkować się będziemy instrukcjami zawartymi klasach, bądź bibliotekach poza przestrzenią nazw zdefiniowaną w piątej linijce naszego programu. Czym są klasy i biblioteki zajmiemy się ciut później. Na tą chwilę wystarczyć powinna wiedza, że ułatwiają one współdzielenie kodu pomiędzy wieloma aplikacjami, a biblioteki dodatkowo mogą być napisane w innym języku niż ten w którym piszemy. Przestrzeń nazw, to takie ustrojstwo, które ułatwia nam trochę smarowanie kodu rozpisanego w kilku klasach. Możemy wtedy trochę mniej szczegółowo opisywać gdzie dokładnie znajduje się instrukcja, której chcemy użyć. Żeby było śmieszniej tak naprawdę już w tych pierwszych linijkach odwołujemy się nie tylko do biblioteki “System”, ale też i do zdefiniowanych w niej przestrzeni nazw “Text” oraz “Collections” i zawartej w niej podprzestrzeni “Generic”. O tym, że schodzimy w dół po zależnościach świadczą użyte w nazwie kropki. 

Jeśli cały powyższy akapit brzmi dla Ciebie jak bełkot możesz to sobie póki co w głowie przedstawić jako różne grupy instrukcji, które nie są normalnie zdefiniowane w czystej wersji języka i nie zagłębiać się w szczegóły. 

Każdy wiersz “Using” kończy się średnikiem, który oznacza koniec instrukcji. Chociaż wydawałoby się, że instrukcję kończyć powinien znak końca linii (czyli tzw. ENTER), to jednak tak nie jest. wielokrotne spacje, tabulatory, czy “entery” właśnie są przez język właściwie ignorowane w większości przypadków. Jak to się więc przekłada na pisanie kodu? Otóż tak, że zarówno taki zapis:

using System; using System.Collections.Generic; using System.Text;

jak i taki zapis:

using 

    System;

using 

    System.Collections.Generic;

using 

    System.Text;

Będą poprawne. Na pierwszy rzut oka może się to wydawać zbędnym utrudnieniem, ale w tym szaleństwie jest metoda - dzięki niej można tak przedstawić kod, aby jego czytanie było w miarę wygodne. Osobiście dość często korzystam z możliwości zapisania wywołania funkcji w kilku wierszach w sytuacji, gdy pokazanie całego kodu wymagałoby przesuwania widoku w oknie na boki.

Następnie mamy mały, ale dość istotny znak:

6         {

oraz jego nieodłączny braciszek:

13        }

Oznaczają one blok kodu. Nie ważne jaki blok - jakiś. To może być zawartość klasy, funkcji, czy zestaw instrukcji do wykonania po spełnieniu jakiegoś warunku. Każdy otwierający nawias musi mieć zamknięcie, każdy zamykający - najpierw musi być otwarty. Od tej zasady nie ma wyjątków, ale na szczęście ani IDE, ani tym bardziej kompilator nam tego nie przepuści. Trzeba zwracać naprawdę dużą uwagę gdzie i jak umieszcza się nawiasy klamrowe - beztroskie ich rozrzucanie tu i tam skończyć się może kilkugodzinną sesją grzebania w kodzie z hasłem “bo mi tu nie działa!”. Aby się nie zagubić w tym bałaganie bardzo pomocne są wcięcia - bloki kodu będące na tym samym poziomie mają identyczną głębokość wcięcia. IDE Visual Studio będzie się starało w tym pomóc, ale nie zawsze sobie samo poradzi.

Wreszcie dochodzimy do:

7      class Program

C# jest językiem obiektowym i naprawdę wszystko jest w nim obiektem. Aby powstał taki obiekt, potrzebna jest instrukcja jego wykonania i tą instrukcją jest właśnie klasa. W tej linii definiujemy więc klasę program, która jest przepisem na wykonanie obiektu. Tak jak w życiu - jeden przepis możemy wykorzystywać wiele razy i tak samo jest w programowaniu obiektowym - jedna klasa może “dać życie” wielu obiektom. Do tego co można zrobić z klasami (i po co) jeszcze wrócimy. Na tą chwilę wiemy już jak ją zadeklarować.

Na koniec zostaje to co najważniejsze:

9          static void Main(string[] args)

10         {

11         }

Deklaracja funkcji. Dzieje się tu naprawdę dużo. Najpierw mamy tutaj słowo kluczowe “static” oznacza ono, że funkcja którą deklarujemy może być wywołana bez tworzenia jakiegoś konkretnego obiektu z naszej klasy. Drugie słowo kluczowe “void”. Normalnie w tym miejscu deklaracji funkcji powinien stać typ zmiennej jaki zwróci nam funkcja. Ponieważ jednak typów zmiennych jeszcze nie znamy (niektórzy być może jeszcze nie wiedzą co to jest zmienna - spokojnie, będzie wyłożone później) nie chcemy, aby nasza funkcja zwracała cokolwiek, albo aby dosłownie zwróciła nam nic - “void” to w angielskim “pustka”, czyli nasze upragnione nic. Następne słowo “Main” to nazwa naszej funkcji. W językach z rodziny C, czy też C-podobnych jest to funkcja wywoływana zawsze na starcie programu. Następnie “(string[] args)”. Tutaj naprawdę dużo się dzieje i bez zahaczenia o typy zmiennych (i to złożone) ciężko będzie dokładnie wytłumaczyć co się dzieje. Wytłumaczę więc rzecz póki co po łebkach, a z czasem wszystko stanie się jaśniejsze. Otóż w tym nawiasie definiujemy co ma być wejściem dla naszej funkcji (najczęściej dane, choć nie zawsze), ale dla nas póki co najwazniejsze, że ten nawias może być też pusty. W tym konkretnym wypadku będą to argumenty jakie można wpisać po wywołaniu programu w linii poleceń.

Skoro więc jesteśmy w głównej (“Main”) funkcji naszego programu, to właśnie tutaj napiszemy linijkę kodu , która pozwoli przywitać nam świat. Wpychamy się więc pomiędzy nasze nawiasy klamrowe i piszemy:

Console.WriteLine(“Hello World”);

Zacznijmy od tego, że wielkość liter jest ważna w większości języków programowania i C# niej jest tutaj wyjątkiem. Czasem może to prowadzić do pomyłek w kodzie, bo łatwiej nam zapamiętać tekst tak jak on brzmi, a nie jak jest napisany. Na szczęście tutaj też IDE okaże się nam wielce pomocne podpowiadając, które nazwy są dostępne z uwzględnieniem wielkości liter. W przypadku VS najważniejszym wg mnie skrótem klawiszowym jest Ctrl+spacja. Włącza on podpowiedzi, które pozwalają szybko ogarnąć jak jeszcze można pomęczyć nasz kod. Dobra, tyle naskrobałem, a ani słowem nie wytłumaczyłem o co chodzi w linii kodu jaką każę wam wpisać.No to jedziemy. “Console” jest to klasa statyczna (czyli zawierająca same funkcje statyczne - a co to jest już wiemy), która pozwala nam pastwić się nad konsolą, czy jak kto woli wierszem poleceń. “WriteLine” dosłownie znaczy “PiszLinię” i dokładnie to robi - wypisuje linię tekstu na konsoli, natomiast jako argument naszej funkcji wpisujemy w nawiasach “Hello World” (razem z cudzysłowami, a dlaczego - o tym przy okazji typów zmiennych).

Możemy teraz radośnie kliknąć ikonkę:

lub wcisnąć klawisz F5.

Zachurkocze, zafurkocze coś tam mignie jakieś czarne okienko i natychmiast zniknie, a w okienku pod kodem przeczytacie coś w stylu:

(kod 0 oznacza, że nasz program skończył się prawidłowo).

Niektórzy z was - ci nie mający okazji dobrze poznać specyfiki systemu Windows - mogą poczuć się oszukani, no bo jak to?! Program się skończył, a nic nie było widać. Otóż było widać - przez ułamek sekundy w czarnym okienku, które nam mignęło na ekranie. Nie trzymając nikogo dłużej w niepewności podpowiem jak się dobrać do tego wyniku. Przesuwamy wzrok na prawą część ekranu i klikamy prawym przyciskiem myszy “Rozwiązanie XXX” (gdzie XXX to nazwa naszego projektu), a następnie wybieramy:

Co otworzy nam okienko eksploratora w lokalizacji, gdzie znajduje się nasz projekt. Musimy jednak dostać się do folderu “Debug” który można odnaleźć według schematu poniżej (lądujemy w folderze zaznaczonym niebieskim tłem, a chcemy się dostać do folderu zaznaczonym niebieską, nieregularną figurą, która miała być piękną elipsą.

Gdy już tam będziemy trzymając klawisz SHIFT klikamy prawym przyciskiem myszy gdzieś w polu naszego okna i otrzymujemy (w zależności od zainstalowanych programów zawartość okienka może się różnić od trochę do bardzo, bardzo):

I klikamy “Otwórz tutaj okno programu PowerShell” - w Windows 7 będzie to coś bardziej w stylu “Otwórz wiersz poleceń tutaj”, ale jako, że siódemki już jakiś czas nie używam, to dokładnie nie pamiętam (ósemki nie używałem wcale, więc kompletnie nie wiem co tam wypisuje). Jeśli wyskoczy nam niebieskie okienko wpisujemy:

.\helloworld 

(wielkość liter nie ma znaczenia), a jeśli czarne to możemy radośnie pominąć dwa pierwsze znaki (przy założeniu, że komputer ma standardową konfigurację).

Jeśli nic nie wybuchło i kod został prawidłowo przeklejony (bo nie wierzę, żeby ktoś go przepisał - a warto, bo wtedy IDE fajnie siecze podpowiedziami) to wtedy nasz program się z nami przywita.

Gratulacje - omówiliśmy Twój pierwszy program (mój jakoś nie - ja jakoś zaczynam naukę nowych języków od napisania symulatora oddziaływań grawitacyjnych, ale ja to w ogóle dziwny jestem).

W następnym odcinku - proste typy zmiennych i po co w ogóle komuś te nieszczęsne zmienne.
Poprzedni zaś odcinek był wprowadzeniem.

P.S. Intergalactic Highway