Co mi się podoba w...Javie?

Hai all!

Piszę sobie od niedawna w Javie, praktycznie całkowicie się na nią przerzucając. I muszę przyznać jestem zadowolony. Nawet bardzo.

Po pierwsze:
W Javie mam zdefiniowane wszystko, absolutnie wszystko czego potrzebuję do programowania. Rzeczy których nie ma łatwo można samemu zaimplementować. Chwilami programowanie wygląda jak uzupełnianie formularza ;)
Po drugie:
Niby w Javie mamy mocne typowanie. A jednak. Nic nie broni by zrobić z niej język "dynamiczny". Wszystko dzięki typowi object. Zamiast robić 10 zmiennych różnych typów wystarczy jedna(choć to też marne tłumaczenie-zazwyczaj korzysta się ze stosów czy kolejek i linked list-a te już muszą mieć typ object :)). Jest to również lekarstwo na typy generyczne(jak ktoś jest uczulony) i chwilami na overrloading'i metod.
Po trzecie:
Pełna obiektowość. No może nie pełna, bo nie mamy możliwości zrobienia czegoś takiego jak w Ruby'm:
5.toStr
ale bardzo się przydaje. Np.wyrabia dobre nawyki etc.
Po czwarte:
Przenośność. Tutaj chyba nie trzeba zbyt dużo tłumaczyć.
Po piąte:
Prawie każdy obiekt posiada iterator, a to pozwala na znaczne ułatwienia.
Po szóste:
Prędkość. Wbrew powszechnej opini, Java nie jest wolnym językiem. Potrafi wykonać niektóre operacje dużo szybciej niż gcc! Po za tym nie jesteśmy zmuszeni do kompilowania kodu non-stop, a dzięki projektowi gcj możemy tworzyć natywne dla systemu binarki. btw. jeszcze ta opinia o prędkości, którą wiele osób propaguje pochodzi z czasów pierwszych edycji Javy, czyli jeszcze bez JIT'a i hot-swapping'u.

Hm... to już chyba koniec iteracji...tfu, wyliczania :)
PS: Rozpoczyna się seria bardziej sensownych wpisów :) Niedługo opowiem jak skonstruować bardzo przejrzysty parser dowolnego języka oraz jak stworzyć maszynę witrualną. Niestety zanim to się stanie chcę ukończyć Lynx'a.

while i...when

Witam!
Rzadko się spotyka języki tak zaprojektowane, że implementują funkcyjność bez szkody dla obiektowości. Takim językiem na pewno nie jest OCaml gdyż bardzo upośledza on sam siebie...(F# jest już ładniejszy).
Nemerle zaś bardzo dobrze radzi sobie z obiektowością(używając stałych!). Bardzo ciekawym przypadkiem rozwiązania pewnego problemu na 2 sposoby jest liczenie linii w pliku tekstowym:

class LineCounter
 {
   public static Main () : void
   {
     //  Open a file.
     def sr = System.IO.StreamReader ("SomeFile.txt");   
     mutable line_no = 0;                                
     mutable line = sr.ReadLine ();
     while (line != null) {            
       System.Console.WriteLine (line);
       line_no = line_no + 1;           
       line = sr.ReadLine ();
     };                                  
     System.Console.WriteLine ("Line count: {0}", line_no);
   }
 }

Jest to typowo imperatywne rozwiązanie problemu. Teraz zobaczmy sobie przykład wykorzystania when.

class LineCounterWithoutLoop
 {
   public static Main () : void
   {
     def sr = System.IO.StreamReader ("SomeFile.txt");
     mutable line_no = 0;
 
     def read_lines () : void {            
       def line = sr.ReadLine ();
       when (line != null) {               
         System.Console.WriteLine (line); 
         line_no = line_no + 1;           
         read_lines ()                    
       }
     };
 
     read_lines ();      
 
     System.Console.WriteLine ("Line count: {0}", line_no); 
   }
 }

Jak widać mamy bardzo ładny przykład :)
When działa podobnie jak while jednak bez skoku :) Wykonuje kod dopóki, jednak nie skacze na początek(po wykonaniu kodu) jeżeli warunek jest prawdziwy. To bardzo ciekawy lukier składniowy, sprawiający, że można praktycznie odejść od imperatywizmów i skupić się na rekurencji :)

Jak dziala pop i push?

Jeżeli zawsze byłeś ciekawy jak działa pop i push oraz jak można je zastąpić, to zapraszam do czytania ;)

Jeżeli miałeś kiedykolwiek styczność z asm'em to wiesz czym są segmenty oraz stos. Myślę jednak że warto by choć trochę zainteresować. Czym jest stos można spokojnie poczytać na wikipedii. O segmentach nic chyba nie było. Powiem tyle że dla nas najważniejszy jest segment stosu(SS-Stack Segment). Wskazuje on na początek stosu. W naszym przypadku będzie to 100h.Przyjmijmy że każdy argument wrzucany na stos ma 2 bajty(wiem nie jest tak ale zbyt długo rysowałem schemat żeby tera zmieniać :P). Wszystko wrzucamy "od tyłu"(lub od góry, różnie można interpretować). Operowanie na stosie czyli push wrzucające coś na stos oraz pop ściągające z rejestru do stosu to po prostu odejmowanie i dodawanie adresów. Push można zamienić na:
;PUSH
sub esp, wielkosc
mov [ss:esp], co
Gdzie wielkość w naszym przypadku bedzie miała wartość 2. ss:esp to adres ostatniego elementu stosu.
Zobaczmy prosty przykład. Na stos wrzucamy zawartość AX i DX:

;push AX
sub esp,2
mov [ss:esp],ax 
;push DX
sub esp,2
mov [ss:esp],dx

Jak będzie wyglądał stos:

Uff...namęczyłem się trochę z tym rysunkiem ponieważ robiłem go w mtPaint :P
Dobrze. Jak widzimy adres maleje o wielkość(czyli 2)-0xFE(dec.254) do 0xFC(dec.252). Jako że wrzuciliśmy rejestry 16 bitowe wszystko powinno się zmieścić.
Jak działa pop?
Jak wiemy pop zdejmuje ze stosu ostatni element i wrzuca go do jakiegoś rejestru. Czyli działa odwrotnie do push. Dla przejrzystości pokażę przykład:

;POP 
mov gdzie, [ss:esp]
add esp, 2

Do gdzie przesuwamy ostatni element stosu. Potem dodajemy do ESP 2 czyli ustaloną przez nas wielkość. Sprawi to że stos przeskoczy na nasz "umówiony" adres 254 czyli na przedostatni element.