public class MemoryTransaction : IDisposable
    {
        #region Static members

        private static ConcurrentDictionary<int, ConcurrentStack<MemoryTransaction>> transactionStack = new ConcurrentDictionary<int, ConcurrentStack<MemoryTransaction>>();
        private static object locker = new object();

        public static MemoryTransaction Current
        {
            get
            {
                if (transactionStack.ContainsKey(Thread.CurrentThread.ManagedThreadId) && transactionStack[Thread.CurrentThread.ManagedThreadId].Count > 0)
                {
                    MemoryTransaction result;
                    transactionStack[Thread.CurrentThread.ManagedThreadId].TryPeek(out result);
                    return result;
                }
                else
                    return null;
            }
        }

        #endregion

        #region Private members

        private Stack<object> myTransactionLogObjects;
        private Stack<byte[]> myTransactionLogStates;

        #endregion

        #region Constructors

        public MemoryTransaction()
        {
            var stack = transactionStack.GetOrAdd(Thread.CurrentThread.ManagedThreadId, new ConcurrentStack<MemoryTransaction>());
            transactionStack[Thread.CurrentThread.ManagedThreadId].Push(this);
            myTransactionLogObjects = new Stack<object>();
            myTransactionLogStates = new Stack<byte[]>();
        }

        #endregion

        public void SaveObject(object instance)
        {
            if ((null != instance) && (false == instance is ValueType) && (instance.GetType().IsSerializable))
            {
                if (false == myTransactionLogObjects.Contains(instance))
                    lock (locker)
                    {
                        myTransactionLogObjects.Push(instance);
                        myTransactionLogStates.Push(instance.Serialize());
                    }
            }
            else
            {
                throw new ArgumentException("Provide existing instance of Serializable class");
            }
        }

        private void RecoverObject(object instance, object copy)
        {
            Type t = instance.GetType();
            PropertyInfo[] propInfos = t.GetProperties();
            lock (locker)
            {
                foreach (PropertyInfo info in propInfos)
                    if (info.CanWrite && info.PropertyType.IsSerializable)
                    {
                        info.SetValue(instance, info.GetValue(copy, null), null);
                    }
            }
        }

        public void Commit()
        {
            lock (locker)
            {
                myTransactionLogObjects.Clear();
                myTransactionLogStates.Clear();
            }
        }

        public void Dispose()
        {
            ConcurrentStack<MemoryTransaction> stack;
            MemoryTransaction current;
            transactionStack[Thread.CurrentThread.ManagedThreadId].TryPop(out current);
            // Clean transaction stack for current thread if empty
            if (transactionStack[Thread.CurrentThread.ManagedThreadId].Count == 0)
                transactionStack.TryRemove(Thread.CurrentThread.ManagedThreadId, out stack);
            // Restore state for all saved objects
            while (myTransactionLogObjects.Count > 0)
            {
                RecoverObject(myTransactionLogObjects.Pop(), myTransactionLogStates.Pop().Deserialize());
            }
        }
    }

Jak widać, ilość kodu nie powala na łopatki, stopień skomplikowania również. Dodatkowo wykorzystywana jest dodatkowa klasa pomocnicza, która dodaje dwie metody rozszerzające (Serialize na object i Deserialize na byte[]) które realizują (de)serializację binarną (System.Runtime.Serialization.Formatters.Binary). Użycie transakcji wygląda identycznie jak TransactionScope (więc można w prosty sposób powiązać STM z transakcją na bazie danych – wystarczą tylko drobne modyfikacje powyższej klasy):

using (MemoryTransaction mt = new MemoryTransaction())
{
    // Tutaj robimy nasz misz-masz...

    // Commit robimy jeżeli wszystko OK, w przeciwnym wypadku automatyczne wykonany zostanie Rollback
    mt.Commit();
}

Zostaje jeszcze samo zapisywanie obiektów. Można to zrobić co najmniej na dwa sposoby – albo jawnie w bloku transakcji, wywołując mt.SaveObject(naszObiekt), albo na poziomie obiektu podczas ustawiania wartości jego pól (np. przy zmianie znacznika typu IsDirty, a właściwie przed jego zmianą) – wywołujemy wtedy MemoryTransaction.Current.SaveObject(this);. Jak widać nie jest to bardzo uciążliwe, należy jednak zawsze zadbać o „ręczny” zapis stanu obiektu – inaczej rollback nic nie zmieni.
Jedną z pozytywnych cech poniższej implementacji jest względne bezpieczeństwo w przypadku aplikacji wielowątkowej (thread safety). Każdy z wątków posiada własny stos transakcji, więc raczej nie ma możliwości „przeplatania się” transakcji. Ponadto krytyczne zapisy i odczyty wykonywane są podczas locka – co niestety ujemnie wpływa na wydajność, ale bezpieczeństwo jest w tym wypadku najważniejsze.
Inną pozytywną cechą jest możliwość tworzenia zagnieżdżonych transakcji – więc nie ma niebezpieczeństwa „wysypania” transakcji poprzez np. wywołanie metody która uruchamia własną transakcję. Ważnym aspektem tego zachowania jest kwestia rejestracji obiektu nie tylko w bieżącej, ale również w nadrzędnych transakcjach – co w podanej implementacji nie jest zaimplementowane, jednak nie jest trudne do osiągnięcia.

Zatem jak widać możliwe jest stworzenie mechanizmów zbliżonych do „prawdziwego” STM, które nie utrudnią nam za bardzo życia i pozwolą na utworzenie względnie bezpiecznej aplikacji bez powtarzania niepotrzebnych fragmentów kodu. Jak każde uproszczenie ma swoje zalety i wady – do tych drugich należy zapewne ograniczone zastosowanie i niekorzystny wpływ na wydajność. Spadek wydajności w stosunku do niestosowania transakcji w przypadku niezbyt skomplikowanych obiektów (nie zawierających złożonych obiektów typu listy) sięga 30-50% dla optymistycznej, pozytywnie zakończonej operacji. Czy jest to dużo, czy mało – to już rzecz typowo subiektywna – wszystko zależy od konkretnych potrzeb. Oczywiście nie mogę zagwarantować, że implementacja ta jest w 100% poprawna i zawsze zadziała bez zarzutu – jednak w moich testach jeszcze mnie nie zawiodła i miejmy nadzieję, że będzie tak dalej

Co powinno być pierwsze – view czy view model?

Odpowiedź jest jedna, czasem podważana przez niektórych przedstawicieli programistycznego świata. Otóż brzmi ona tak: View. A dlaczegóż tak?

Zacznę może od poprawnej nazwy wzorca MVVM – powinna ona brzmieć VVMM, czyli View -> ViewModel -> Model. Dlaczego taka kolejność jest tak ważna? Otóż wszystko wynika ze słowa – klucza związanego z tym i innymi wzorcami – separacji. Każda z tych warstw powinna być możliwie najluźniej związana z warstwą o poziom niższą, natomiast o warstwie „2 dalej” nie powinna nic wiedzieć (dotyczy to szczególnie widoku). Ważny jest również kierunek strzałek – określa on kierunek powstawania kolejnych warstw. Każda strzałka daje również możliwość przecięcia – łącznie z możliwością całkowitego wyeliminowania powiązań między warstwami. Osiągnięcie tego jest jak najbardziej możliwe i wcale nie tak trudne, jak się z początku wydaje. Korzystając z jednego z wielu dostępnych frameworków wspierających MVVM można w dość krótkim czasie skonstruować elegancką aplikację, która w dodatku będzie miała przejrzysty i czytelny kod.

Narzędzia

Jednym z takich „wspomagaczy” jest dostarczany przez zespół Microsoft Patterns & Practices framework Prism (wcześniej zwany również jako Composite Application Guidance) wraz z bibliotekami IoC (Inversion of Control) Unity lub MEF. Dostarcza on zestaw niezbędnych klas i interfejsów (np. commands, behaviours, regions), które ułatwiają budowę aplikacji nie tylko zgodnej z MVVM, ale również modularnej, składającej się z luźno powiązanych ze sobą projektów. Jeżeli tworzymy rozbudowaną aplikację biznesową to warto się przyjrzeć temu rozbudowanemu narzędziu. Oczywiście dostępne są również inne biblioteki (np. bardzo ciekawy MVVM Light Toolkit) i wybór konkretnej z nich jest kwestią potrzeb i preferencji związanych z konkretnym projektem.

A dlaczego tak? cz. 1 – blendability

Wracając do podziału na warstwy i ich kolejności – dlaczego taka kolejność ma takie znaczenie? Odpowiedź może nie wydawać się oczywista, ale nie wymaga żadnej tajemnej wiedzy, aby ją zrozumieć i zastosować. Po pierwsze – dlaczego widok powinien być niezależny od view modela, ale jednocześnie tworzyć jego instancję? (i to w code behind!)

Taka kolejność wynika ze ścisłego związku ze strukturą aplikacji w WPF/SL. Jako że widok to w 95% deklaratywny kod XAML (pozostałe 5% to fragment tworzący VM w code behind oraz kod klasy bazowej widoków), który może być tworzony zarówno w Visual Studio, Expression Blend jak i innych narzędziach (jak np. Kaxaml czy Notepad ), nie było by rozsądnym tworzenie i wiązanie go z poziomu kodu logiki aplikacji. Znacząco utrudniało by to (lub wręcz uniemożliwiało) projektowanie interfejsu niezależnie od logiki działania aplikacji. Przy odpowiedniej separacji mamy możliwość wygenerowania danych testowych i projektowania niezależnie od implementacji (której może w ogóle jeszcze nie być), co w przypadku Expression Blend jest wyjątkowo proste i wygodne. Dodając do tego ignorowanie code behind przez Blenda mamy pierwszą część odpowiedzi, która w dodatku zostanie poparta przez następną część.

A dlaczego tak? cz.2 – testability

Mając widok, który w razie potrzeby tworzy sobie (prawdziwy lub mockowany przez designera) view model, jesteśmy w stanie całkowicie uniezależnić logikę działania od interfejsu użytkownika. Taką możliwość daje nam VM, który nie ma żadnych bezpośrednich zależności z widokiem (a konkretniej jego implementacją). Zgodnie z wcześniejszą tezą jesteśmy w stanie uciąć powiązanie pomiędzy VM a pozostałymi warstwami i wykonać niezależne (automatyczne) testy logiki działania aplikacji. Wymaga to oczywiście przygotowania mockowanych modeli danych, jednak nie powinno to stanowić większego problemu. W ten sposób otrzymujemy trzy niezależne warstwy i każdą z nich jesteśmy w stanie osobno tworzyć i testować. Dodatkowo przy odpowiedniej konstrukcji warstwy te są niezależne od pozostałych komponentów aplikacji nie związanych bezpośrednio z MVVM, jak np. usług dostarczających dane i logikę biznesową czy konwerterów i stylów wspomagających konstrukcję UI.

Problemy i rozwiązania

Podstawowym problemem przy separacji pomiędzy V a VM jest kwestia nawigacji w aplikacji oraz reakcji na działania użytkownika. W tym przypadku z pomocą przychodzą takie narzędzia jak Region Navigation, Behaviour no i oczywiście Delegate Command, dostępne w bibliotece Prism. Umożliwiają one (pewnym, acz wcale nie wielkim nakładem pracy) stworzenie warstwy pośredniczącej w komunikacji pomiędzy logiką a interfejsem, która będzie w wygodny i jednocześnie zgodny z MVVM sposób przekazywać informacje pomiędzy V a VM. W razie wątpliwości lub chęci poszerzenia swojej wiedzy polecam lekturę (dostępnej za darmo na stronie Prisma) książki Developer’s Guide to Microsoft Prism. Dostarcza ona solidną dawkę informacji na temat konstrukcji aplikacji kompozytowych, zarówno jeżeli chodzi o UI, jak i strukturę całej aplikacji, a w dodatku napisana jest w dość przystępny i przejrzysty sposób. Ale oczywiście nic nie zastąpi praktyki, więc najlepsze co można zrobić aby dobrze zrozumieć wzorzec MVVM to usiąść i napisać choćby prostą aplikację, wykorzystując dostępną (lub zdobytą np. z podanej lektury) wiedzę. Powodzenia!

1. Instalacja Aptana Studio 3 lub Eclipse i PyDev

Tu nie ma za bardzo co opisywać – wchodzimy na stronę wybranego środowiska, ściągamy i rozpakowujemy / instalujemy. Nic prostszego.

2. Instalacja Django

W celu instalacji Django najlepiej posłużyć się virtualenv i instalatorem pip – myślę, że Google bez problemu odpowie, jak to zrobić, jeżeli jeszcze nie wiesz. Jeżeli masz już skonfigurowane swoje wirtualne środowisko Pythona, wykonujemy po prostu:

pip install Django

Oprócz samego Django możemy chcieć zainstalować dodatkowe biblioteki, jak choćby South czy PIL – wszystkie bez problemu instalujemy za pomocą pip. Jeżeli korzystamy z Ubuntu, warto wcześniej mieć w systemie zainstalowane build-essential, oraz w przypadku instalacji PIL biblioteki developerskie dla JPEG – np. libjpeg8-dev. Po instalacji niezbędnych pakietów możemy przejść do konfiguracji debuggera.

3. Konfiguracja debuggera

Ten punkt warto zacząć od ustawienia interpretera Pythona z naszego virtualenv. W tym celu wchodzimy w ustawienia Eclipse (w moim przypadku Window -> Preferences), wybieramy Pydev -> Interpreter – Python. Tworzymy nowy interpreter, podając wybraną przez nas nazwę oraz wskazując ścieżkę do pliku bin/python z katalogu naszego wirtualnego środowiska. Stosujemy wprowadzone zmiany (Apply), dodając ewentualnie ścieżki do dodatkowych bibliotek według własnych potrzeb. Zamykamy ustawienia i możemy tworzyć nowy projekt Django (New -> Other -> Pydev / Pydev Django Project) – podczas jego tworzenia odradzam zaznaczanie tworzenia katalogu src, a także proponuję od razu wybrać nasz wcześniej stworzony interpreter i odpowiednią wersję Pythona (w Ubuntu 10.10 mamy domyślnie 2.6).
Po stworzeniu i wstępnej konfiguracji projektu klikamy na niego PPM w Pydev Package Explorer i wybieramy Properties. W opcji PyDev – PYTHONPATH, w zakładce External Libraries dodajemy (poprzez przycisk Add source folder) katalog plugins/org.python.pydev.debug_*/pysrc (gdzie * to wersja zainstalowanego PyDev) i zastosowujemy wprowadzone zmiany. Następnie w tym samym oknie wybieramy Run/Debug Settings i dodajemy nową konfigurację. Wybieramy nasz wcześniej stworzony projekt, jako main module podajemy plik manage-debug.py (do znalezienia na django-snippets, można też wybrać „zwykłe” manage.py, ale nie wiem, czy wtedy wszystko zadziała jak należy ). W zakładce Arguments podajemy runserver --noreload w polu Program arguments. Jako working directory wskazujemy katalog, w którym jest plik settings.py (Other -> Workspace…).
W celu usprawnienia pracy, możemy w zakładce Common dodać nasze ustawienie do przycisku na pasku (Display in favorites menu).

4. Uruchamianie debuggera

Przed uruchomieniem naszego projektu uruchamiamy serwer debugowania PyDev (menu Pydev -> Start debug server). Następnie możemy uruchomić nasz projekt (z przycisku debugowania wybieramy naszą wcześniej stworzoną konfigurację). Przy pierwszym uruchomieniu Aptana może zapytać o instalację dodatku do Firefoxa, którego zainstaluje automatycznie – jedyne wymaganie to instalacja „ręczna” Firebuga – o ile go jeszcze nie masz. I tyle! Możemy już ustawiać pułapki, przeglądać zmienne etc. Miłego i owocnego debugowania!

Mam świetny pomysł, rzucam wszystko i pędzę go realizować

Czyli jeden z najczęstszych błędów. Wydaje ci się, że twój pomysł jest wyjątkowy, że zrobisz coś niesamowitego, a na dodatek wiesz, jak na tym zarobić! Super, ja też. I setki, jak nie tysiące innych osób. I co z tego wynika? Absolutnie nic. Bez wstępnej chociażby realizacji twój pomysł jest wart tyle, co nic. Dlaczegóż tak jest? Sam pomysł jest tylko ziarenkiem, które trzeba zasadzić, wyhodować, pielęgnować i cierpliwie czekać, aż urośnie i da owoce. Ziarno, którego nie zasadzisz i nie nakarmisz, nie wykiełkuje, nie urośnie i nie stanie się dojrzałą rośliną. Podobnie jest z pomysłem. Dopóki nie zaczniesz go realizować, nie poświęcisz mu ogromnej ilości czasu i sił, będzie on tylko pomysłem. Co więc zrobić, aby nasz pomysł przerodził się w dojrzały projekt, który zaowocuje (mniej lub bardziej) udaną realizacją?

Przede wszystkim potrzeba poświęcić mu sporo czasu. I to nie tylko na rozmyślanie, ale na konkretne projekty, na realizację, na testowanie pomysłów. Być może trzeba zarwać kilka nocy, przegapić wiele ciekawych imprez, przez jakiś czas być zupełnym odludkiem (nie licząc kontaktów z ewentualnymi współtwórcami). Być może trzeba poświęcić sporo przyjemności aby odłożyć sporą sumę pieniędzy, największą, jaką jesteś w stanie uzbierać. Dlaczego? Bez tych dwóch elementów nie będziesz w stanie funkcjonować po opuszczeniu dotychczasowej roboty (no, chyba że jesteś szczęśliwym studentem i/lub masz hojnych sponsorów). Działający projekt, nawet tylko w jakiejś części, jest niezbędny, aby uświadomić sobie, czy to rzeczywiście ma sens. A pieniądze – to chyba oczywiste. Za coś trzeba żyć, zwłaszcza jak musisz opłacić mieszkanie, wyżywić się czy utrzymać firmę (co w polskich realiach jest koszmarem, marnującym mnóstwo czasu i pieniędzy, ale o tym kiedy indziej). Jeżeli wydaje ci się, że starczy ci na pół roku życia – masz realne pieniądze na 3 miesiące. Dodatkowo nie można zapomnieć o ewentualnych kosztach związanych z utrzymaniem projektu (jak chociażby serwery, domeny, sprzęt czy niezbędne oprogramowanie, etc.), które w przypadku wzrostu popularności mogą zacząć drastycznie rosnąć – w dodatku nie koniecznie liniowo z przychodami. Dlatego jeżeli rzeczywiście chcesz, aby twój start-up przerodził się w coś dochodowego, warto o tych kwestiach pamiętać i podejść do nich na poważnie.

Nie mam pieniędzy, ale to nie problem, pieniądze zawsze się znajdą

Owszem, jeżeli projekt będzie dobry, zapewne się znajdą. Pod warunkiem jednak, że do tego czasu nie umrzesz z głodu, nie wyrzucą cię z mieszkania i nie zrobisz sobie długu na kilka lat spłacania. Zgodnie z prawem Murphy’ego wszytko to, co może pójść źle, pójdzie źle. I to się niezwykle sprawdza jeżeli przełożymy to na finanse. Jeżeli uważasz, że za wszystko zapłaci Unia, albo sponsorzy rzucą hojną ręką tysiące czy nawet miliony, a masz tylko pomysł, to jesteś w głębokim śnie i pora się obudzić. Owszem, można pozyskać fundusze unijne, jednak wiąże się z dużymi komplikacjami formalnymi i mocnym usztywnieniem dalszych działań (zapomnij o elastyczności czy dostosowywaniu się do potrzeb rynku – to, co było w projekcie, musi być, choćby okazało się totalną klapą). Można również szukać pieniędzy wśród aniołów biznesu czy VC, ale bez działającego projektu i jasnej wizji finansowania i osiągnięcia znaczących zysków znalezienie inwestora graniczy z cudem. Niby każdy o tym wie, ale jednak większość z nas o tym zapomina, wierząc w siłę swojego pomysłu. Dlatego tak ważne jest zabezpieczenie finansowe – ten minimalny wkład, który trzeba wnieść, aby szanse powodzenia twojego start-up’u były znacząco większe od okrągłej, tudzież eliptycznej cyfry.

Oczywiście jest jeszcze milion innych czynników, które mają wpływ na to, że nasz start-up odniesie sukces lub okaże się klęską – za każdym razem trzeba rozważyć wszystkie za i przeciw, zrobić sobie bilans i sprawdzić, czy to rzeczywiście ma sens. Jednak zawsze trzeba pamiętać, że podstawą jakiegokolwiek sukcesu jest ciężka praca, do której należy podejść z należytą starannością i dozą solidnej motywacji. Tak więc – jeżeli jeszcze, drogi czytelniku, nie zniechęciłeś się do swojego pomysłu – rękawy za łokcie, klawiatury w dłonie i niech noc będzie długa! (a moc niech będzie z wami )

1. Podstawowe komponenty – procesor, grafika, porty video

W tej części bez niespodzianek. Procesory i karty graficzne Intela należą do najlepiej wspieranych podzespołów pod Linuksem. Dzięki sterownikom open source od Intela możemy cieszyć się bardziej niż przyzwoitą wydajnością procesora Core i5 460M oraz – niestety – dość przeciętną wydajnością zintegrowanej w nim karty graficzną GMA. Jednak z grafiką jest jeszcze niewielka nadzieja – najnowsze sterowniki Intela mają przynieść znaczącą poprawę wydajności, co według testów powinno pozwolić uzyskać wydajność zbliżoną do tej pod Windowsem. Jednak pomijając przeciętną wydajność (w codziennej pracy wystarczającą, ale do jakiegokolwiek 3D zdecydowania za słabą) wsparcie jest na wysokim poziomie – wszystko działa od razu po instalacji systemu, nie ma problemów z zewnętrznymi ekranami (testowane po D-Sub i DVI, DisplayPort jeszcze znalazł żadnego kompatybilnego urządzenia, z którym mógłbym go połączyć), w 2D oraz w akcelerowanym pulpicie 3D wszystko działa jak należy.

2. Pamięć, dysk Seagate Momentus XT

Oczywiście na takim sprzęcie może być używany tylko 64-bitowy system (instalacja wersji 32-bitowej jest czystym marnotrawstwem czasu i wydajności), w związku z tym wsparcie dla 8 GB (maksymalna oficjalnie wspierana ilość pamięci dla tego modelu) nie stanowi problemu i wszystko działa jak należy. Dodatkowo, dzięki zainstalowaniu 500 GB dysku Seagate Momentus XT z 32 MB cache i 4 GB cache SSD do odczytu (w miejsce standardowego Momentusa 320 GB 7200 rpm) wydajność systemu potrafi naprawdę pozytywnie zaskoczyć. Dzięki mechanizmowi podwójnego cache czas dostępu do najczęściej wykorzystywanych danych jest zbliżony do dysków SSD, dzięki czemu np. Firefox czy Eclipse działają zaskakująco szybko. Jedyną uwagą jest konieczność aktualizacji firmware dysku (i najlepiej również BIOSu komputera) ze względu na problemy z kompatybilnością uniemożliwiające poprawną instalację i działanie systemu (zarówno Windows jak i Linux).

3. Pozostałe porty – audio, USB i inne

Jeżeli chodzi o zewnętrzne porty, to mamy tutaj pewne drobne problemy. Jeden wynika z samej konstrukcji komputera, a drugi – najprawdopodobniej z błędu w sterowniku, jednak obydwa dotyczą tego samego gniazda – czyli wyjścio-wejścia audio. Przede wszystkim kupując ten model wraz ze stacją dokującą należy mieć świadomość, że gniazda audio w docku nie będą działać, ot tak, po prostu, bez komentarza. Natomiast podłączenie np. zewnętrznych głośników czy słuchawek będzie wiązało się z koniecznością przełączenia w aplecie preferencji dźwięku aktywnego wyjścia audio. Jak będziemy chcieli wrócić do wbudowanych głośników – znów to samo. Dosyć uciążliwe i irytujące, miejmy nadzieję, że kolejne wersje sterowników naprawią ten problem. Problemów nie ma za to z portami USB, działają bez zarzutu, zarówno wbudowane, jak i te w stacji dokującej. Nie miałem okazji sprawdzić portu eSATA, natomiast porty Ethernet również bez problemu działają, zarówno w sieciach 100, jak i 1000 MBit/s.

4. Sieć – WiFi, Ethernet, Bluetooth

Jeżeli chodzi o wykrycie i działanie sprzętu sieciowego, to po raz kolejny należy pochwalić Intela za sterowniki open source – wszystko działa od razu po instalacji Ubuntu bez ściągania żadnych dodatkowych sterowników. Wydajność sieci jest bardzo dobra, WiFi (Intel Advanced-N 6200) w trybie N (z routerem 300 Mbit) pozwala osiągnąć transfery dużo lepsze niż po kablu w trybie Fast Ethernet, a sieć kablowa (Realtek Gigabit) działa jeszcze lepiej Bluetooth również od początku jest prawidłowo wykrywany, jednak nie bawiłem się nim na tyle, żeby sprawdzić wszystkie możliwe tryby pracy – zakładam jednak, że działa bez zarzutu. Problem natomiast pojawia się z samym WiFi – dość często przy mocniejszym obciążeniu karta bezprzewodowa potrafiła zwiesić cały system. Być może jest on już rozwiązany, gdyż dawno się z nim nie spotkałem, jednak sam fakt jego zaistnienia jest niepokojący. Nie ma za to problemów z łączeniem się z różnymi rodzajami sieci – zarówno w trybie b, jak i n, zabezpieczonymi WPA-PSK jak i WPA Enterprise, a zasięg i stabilność połączenia są bardziej niż przyzwoite.

5. Klawisze dodatkowe, touchpad i TrackPoint

Z dodatkowych klawiszy jak na razie na pewno nie działa wyłącznik mikrofonu, nie sprawdzałem również mapowania niektórych klawiszy z Fn. Natomiast bez problemu działa regulacja głośności i wyciszenie oraz regulacja jasności – czyli te najważniejsze, nie ma również problemów z klawiszami odtwarzania umieszczonymi „pod strzałkami”. Również sam touchpad (swoją drogą wyśmienity) i TrackPoint (również bez zarzutu, jak na ThinkPada przystało) sprawują się znakomicie i nie ma problemów z ich obsługą.

6. Pozostałe urządzenia

Czytnik kart SD – działa bez problemu, nie sprawdzałem z kartami xD i MemoryStick, które ponoć również  obsługuje. Kamerka również nie sprawia problemów, działa ze Skype i innymi programami, a jakość obrazu jest bardzo dobra. Co najbardziej mnie zaskoczyło – po zainstalowaniu fingerprint-gui udało mi się uruchomić czytnik linii papilarnych, który działa zarówno przy logowaniu, jak i przy potwierdzaniu operacji w trybie roota (sudo – zarówno przez GUI jak i z linii komend). Stacja dokująca (ThinkPad Mini Dock Series 3) poza wspomnianym wcześniej problemem z portem audio działa również bez problemu – system reaguje prawidłowo podłączenie i odłączenie, przełącza obraz i montuje podłączone urządzenia tak, jak być powinno.

7. Praca systemu, uruchamianie i zamykanie, usypianie, hibernacja, bateria

Uruchamianie systemu w mojej konfiguracji trwa na prawdę krótko, i zwykle nie ma z tym żadnych problemów, podobnie jest z usypianiem i hibernacją. Piszę zwykle, gdyż czasem zdarza się, że system się nie włączy prawidłowo i trzeba go wyłączyć siłą. Na szczęście nie zdarza się to często, więc problem ten nie jest specjalnie uciążliwy. Jeżeli chodzi o baterię (w moim przypadku akumulator SANYO o pojemności nominalnej 56,2 Wh, rzeczywistej przekraczającej 61 Wh) to sprawa ma się bardzo różnie. Nie raz udaje się osiągnąć przebiegi rzędu 4 godzin, jednak zwykle jest to raczej bliżej 3 – wszystko zależy oczywiście od obciążenia, poziomu podświetlenia i innych parametrów pracy. Można było by się spodziewać nieco dłuższego czasu pracy, jednak biorąc pod uwagę wydajność zainstalowanych komponentów nie ma specjalnych powodów do narzekań. Oczywiście można zainstalować baterię 9-komorową, co powinno zdecydowanie wydłużyć czas pracy na baterii.

Podsumowanie

Ogólnie nie ma większych problemów z pracą tego modelu pod Ubuntu 10.10, z nadzieją, że w najnowszej edycji, która ma się ukazać w ciągu najbliższych tygodni, będzie jeszcze lepiej. Zarówno wydajność, jak i wsparcie dla sprzętu jest na bardzo dobrym poziomie, głównie dzięki staraniom niezależnych developerów oraz przyjaznej Linuksowi polityce firm Intel i Lenovo. ThinkPady od początku były jednymi z najlepiej wspieranych laptopów pod Linuksem, i w tej kwestii (na szczęście) niewiele się zmieniło. Zatem mogę śmiało polecić zarówno ten model komputera, jak i instalację na nim Ubuntu (czy innej dystrybucji).

Pierwszy problem przed którym staje programista większości języków – w czym mam to pisać? Czasy pisania stron w Notatniku już dawno się skończyły (uffff…), jednak nie zawsze jest jasne co w zamian. Jeżeli chodzi o Django to wybór jest spory (a gdzież nie jest?) – właściwie każdy edytor /każde IDE/ dla Pythona powinno dać radę. Ale to nie znaczy, że będzie rozwiązaniem odpowiednim. Po eksperymentowaniu z PyCharm (całkiem przyjemnym i funkcjonalnym, ale stosunkowo drogim jak na początki), zacząłem szukać dalej – NetBeans, którego używam do PHP wsparcie do Pythona i Django ma bardzo nieoficjalne i nie do końca takie, jakiego się spodziewałem po doświadczeniach z wersją PHP; Eric – dość rozbudowane IDE do Pythona, ale niestety pewne rzeczy nie do końca działały, jak należy; no i pozostał Eclipse… A jako że Eclipse, to trzeba było zaprząc do tego całą masę pluginów, debugger jakoś podłączyć itp. itd… Ale na szczęście znalazło się gotowe rozwiązanie – Aptana Studio 3. Wszystko co należy jest na miejscu – wsparcie dla Pythona, Django (uruchamianie komend, tworzenie projektu, składnia, kolorowanie szablonów) i cała moc Eclipse. Po zainstalowaniu i wstępnej konfiguracji (czcionki, kolory itp.) można było tworzyć pierwsze projekty. Już jest OK.
Kolejnym krokiem była konfiguracja debuggera, którą postaram się omówić w następnym poście, oraz instalacja tego, czego nie było w Aptanie – w moim przypadku była to tylko wtyczka MercurialEclipse. Po tych czynnościach voila – mamy w pełni funkcjonalne środowisko developerskie dla Django. Mamy kolorowanie i podpowiadanie składni oraz całą listę innych niezbędników wydajnego programisty, mamy debuggera, mamy zarządzanie całym projektem (w sensie plikowym) wraz z wsparciem dla kontroli wersji, a to wszystko w całkiem znośnej oprawie A co mnie najbardziej zaskoczyło to prędkość działania – o ile dotychczas Eclipse uważałem za najwolniejsze IDE na świecie, o tyle najnowsza wersja dobrze skonfigurowana i działająca na współczesnym sprzęcie działa bez zarzutu – prędkością bije VS2010, co kiedyś było nie do pomyślenia

I na tym kończę dzisiejszą historyjkę, następnym razem postaram się coś bardziej przydatnego napisać, a póki co wracam do pracy, Django czeka!

• ThinkPad L412
• Zasilacz 65W kompaktowych rozmiarów
• Baterię 6-cell 57Wh, Krótką instrukcję, odrobinę kartonów, folii i na tym koniec

Zestaw podstawowy, bez żadnych fajerwerków, gdyż te miały się kryć w środku czarnego pudełka z solidnego, choć nie do końca odpornego na palcowanie plastiku. Jego wnętrze kryło bowiem procesor Intel Core i5 460M o całkiem solidnej wydajności i zintegrowanej grafice, 2GB pamięci RAM DDR3 (a to dopiero początek) oraz dysk Seagate Momentus 7200.4 o pojemności 320GB, ponadto super wygodną klawiaturę, touchpad + TrackPoint, czytnik lini papilarnych i kilka innych bajerów. Jakiś niedosyt? Oczywiście! Chwilę później w środku wylądowały dwie kości GoodRAM DDR3 1333 o pojemności 4GB każda (dając w sumie 8GB pamięci operacyjnej co łatwo obliczyć) oraz hybrydowy dysk Seagate Momentus XT 500GB z 32MB cache i 4GB buforem flash. Oczka się zaświeciły? Mi i owszem, w momencie gdy dostarczony z laptopem Windows 7 Professional nie chciał wystartować na nowym dysku. Wujek Google wskazał, że problem w braku kompatybilności dysku z resztą sprzętu. Rozwiązanie? Upgrade firmware dysku i oprogramowania Lenovo i wszystko ruszyło.
I to jak ruszyło! O ile syntetyczne testy nie pokazują aż tak drastycznej różnicy w stosunku do poprzedniego sprzętu, o tyle odczuwalna prędkość działania całości jest niesamowita. Wszystko działa tak jak powinno, bez zbędnego oczekiwania, bez zastanawiania się, bez opóźnień. A o to przecież chodzi zabieganemu człowiekowi, żeby po prostu pracować, a nie czekać na to, aż komputer znajdzie dla niego czas
Jeżeli chodzi o pierwsze wrażenia to na tym poprzestanę – ciąg dalszy opowieści wkrótce – w planach opis współpracy L412 z Linuksem i być może inne równie nudne posty

Legenda:
R_k : końcowy procent rabatu wyliczony kaskadowo
R₁ … R_n : kolejne rabaty do wyliczenia

Dla niezorientowanych: kaskadowy sposób naliczania rabatów polega na tym, że każdy kolejny rabat liczony jest od ceny umniejszonej o dotychczas naliczone rabaty. Dzięki temu sprzedawca zyskuje nawet kilka cennych procent ze swojej wyjściowej ceny

Mam nadzieję, że wzór przyda się tej mniej matematycznie myślącej części społeczeństwa (większości?), choć oczywiście zachęcam do samodzielnego wysilenia szarych komórek.

Or is it?