Niniejszym przedstawiam Wam tutaj postępy moich poczynań na platformie mobilnej z systemem WP7. Konkretnie, to rozpocząłem pisanie aplikacji do zarządzania wydatkami w języku polskim! Oficjalna strona projektu, którego szumna nazwa brzmi „Wydatkomierz” dostępna jest razem z opisem i pełnymi kodami źródłowymi tutaj:

http://code.google.com/p/wydatkomierz/

Aplikacja wkrótce pojawi się w mobilnym sklepie Microsoftu i będzie dostępna do pobrania i używania dla wszystkich posiadaczy komórek z tym systemem za darmo;) I jeszcze długo będzie za darmo, bo wiele podstawowych rzeczy jest w niej do zrobienia w porównaniu z konkurencyjnymi rozdmuchanymi niekiedy aplikacjami w Marketplace w języku angielskim.

To co ma wyróżniać tę aplikację od innych, to przede wszystkim:
- polski interfejs (nie zauważyłem jak dotąd zbyt wiele ciekawych aplikacji w języku polskim)
- łatwość obsługi (na daną chwilę nie widzę potrzeby wykorzystywania przez większość użytkowników mechanizmów tak jak: cykliczne przelewy, przypomnienia o transakcjach, wybór różnego rodzaju kont itp. itd.)
- prostota prezentacji i analizy zapisywanych wydatków głównie pod kątem kategorii, do których należą

Chciałbym jednocześnie zaprosić wszystkich chętnych programistów, którzy chcieliby rozwijać się w stronę programowania aplikacji mobilnych, do dołączenia do rozwijania wyżej przedstawionej aplikacji! Każdy z Was będzie mile widziany. Zarówno Ci, którzy posiadają komórki z systemem WP7, ale i Ci, którym wystarczy pisanie na emulatorze;) Na stronie projektu w zakładce „Issues”:
http://code.google.com/p/wydatkomierz/issues/list
znajduje się już teraz szereg zadań i funkcjonalności, o które przydałoby się rozszerzyć obecną wersję aplikacji tak, aby jeszcze bardziej była przydatna zwykłym śmiertelnikom.

Json Serialization

For serialization, I am using Json.Net it is quite popular and stable library. All my objects that are being serialized, implement IJsonable interface. This gives me easy way to find and check if particular class is serialized somewhere.  It is very important information. At my company we had recently problem with some objects because someone wasn’t sure if one of the class is serialized or not. This caused some “unsupported” behavior on the server that was desterilizing data.

This interface contains only one method returning just object. With this solution, I can return either anonymous type or another class, typically DTO ( Data Transfer Object ) that contains only simple easily serialized data (eg. Value Types ).

Example:

This is quite simple model. It contains four simple types and DashBoardControlType, it is just an Enum. Method ToJson() is used to create anonymous object. In this example I am creating anonymous type.

This object is then used with Json.Net library to create JSON string.

One of the problems with serialization is that errors are noticed on the runtime. If my program compiles it doesn’t mean that I won’t have any problems. One of the common mistakes in classes being serialized, is too complex logic. For instance one class can have some value dependent on some external dependency. Creator of this class assumed that it will be serialized only in context that has connection to this dependency. Someone without broad knowledge of the system could forget about this and use this class in another context that is lacking access to it.

Good example of that kind of situation is accessing State of the application through the HttpContext. Our class has a property that on the get method is accessing HttpContext. I won’t see the problem if class will be used in my scenario, but later if someone will try to serialize this class in other environment that doesn’t have access to the HttpContext, a null reference exception will be thrown. It is really important to test if this kind of situation happens. To check it, I am using very simple test.

Testing Serialization

Let’s discuss this simple test procedure.

With IJsonable interface and reflection, I can easily obtain all the types of the classes to test. Simple Linq query filters out all the classes in specified assembly, within specified namespace with defined IJsonable interface. Then for each class Activator is used to create instance of the class. Newly created object is serialized and If there is an error, name of the type is added to the list.

This test is using NUnit framework. Unit test runner provides perfect environment, that lacks all dependencies, so there will be errors if someone makes a class that will for example access HttpContext directly.

With this simple check we can almost be sure that we won’t get any stupid errors and we can easily see that something is wrong with our model.

Continuous Tests

Running tests each time, I am making a change can become … pain in … With Resharper it is much easier, but still sometimes I will forget to do this and then beautiful message from our Jenkins server will notify me about some fail. It would be a lot better if this information would be instant. There is a solution to this called Continuous Tests.

I started using Mighty Moose recently. It is a plugin to Visual Studio that creates a test runner in the background. This runner analyses all the changes made in the code and on simple CTRL+S (Save) ,if it detects that recent change in the code affects tests, lined test will be executed automatically.

For example in serialization logic, discussed in this post, this kind of instant information can be critical. Each time I change something in the model ( some property for example ). Test is performed automatically and I will get information if this works or not. This is even better in situation when one of my colleagues is changing something inside my code. He won’t be always aware that this code is covered by unit tests, and Continuous Tests runner will notify him about this and also will inform him automatically if this change is failing tests.

It provides a lot of cool stuff. Best features ? Simplified navigation with Ctr+T and Shift+Alt+T, code inspections and great code generation.

One of the neat features I recently discovered, is switch / case generation from enum type.

Writing this switch manually would take like five minutes to write . With R# we can do this almost instantly just with Alt+Enter.

Today in work I got a nice task.

For given 

Make a RegExp to transform each line and Path value, In a way that not minified javascript files (without min.js extension) should point to /min/ folder.

For Example:

Should Transform to:

Because I love experimenting with Regular Expressions. I happily dropped everything and started looking for solution . This seemed pretty simple … but … i had to spent like 30 min to find it.

Solution

Expression

Most important part of this solution is (?!.*min) . This expression will try to look for min word in matched data and if it wont find it there whole match is discarded.

For further replacement procedure, I m specifying two matched groups that will be used to construct new Path. (?<path>.*)/(?<end>.*) This will match everything to last possible “/” and make group named path, then every character after “/” is put into end group.

Replace Expression

Replace expression uses matched groups like simple variables to construct new Path.

The end result is

Making RegExp is like scientific discovery or complex mathematic problem. You have to really think a lot to find a nice solution.

For experiments I recommend

Rad Software Regular Expression Designer

Jednym z podstawowych problemów jaki napotykają początkujący programiści SharePoint jest zmiana nazwy wyświetlania dla wbudowanego pola Title.  Pole to jest obowiązkowym polem typu Text, umożliwia zatem przechowywanie ciągów znakowych o długości do 255 znaków. Bez problemu może być wykorzystane zatem do przechowywania takich danych jak np. imię czy nazwisko pracownika bez potrzeby tworzenia kolejnego dedykowanego pola. Ponadto, na liście, po najechaniu myszką na to pole uzyskujemy dostęp do menu kontekstowego pozwalającego m.in. edytować dany element listy. Przydałoby się więc, aby zawierało ono bardziej opisowy nagłówek niż “Title”, czy też “Tytuł”.

Dla pól utworzonych w Content Type’ie bez problemu można zmienić nazwę wyświetlania (Display Name) w stosunku do znajdującej się w zdefiniowanej kolumnie (Site Column) poprzez nadpisanie właściwości DisplayName. Sytuację te możemy zobaczyć na poniższych ekranach:

W definicji kolumny widać, że dla pola PersonName jako Display Name ustawiony został tekst “Nazwisko”, natomiast w referencji użytej w Content Type nazwa ta została zmieniona na “Nazwisko content type”.

Przechodząc do utworzenia nowego elementu listy widzimy, że nazwa “Nazwisko content type” została wyświetlona zarówno w widoku wszystkich elementów listy oraz na formularzu dodawania nowego elementu.

Na liście kolumn witryny znajduje się natomiast zgodnie z oczekiwaniami nazwa “Nazwisko”.

Nieco inne zasady obowiązują jednak jeśli chodzi o zmianę nazwy wyświetlania kolumny Title. Przede wszystkim, aby odwołać się do tej kolumny przy definiowaniu Content Type’a należy znać jej GUID. W tym celu polecam użycie narzędzia SharePoint Manager 2010 dostępnego pod adresem http://spm.codeplex.com/ 

W celu zmiany nazwy wyświetlania musimy dysponować właściwie trzema GUID’ami – dla kolumn Title, LinkTitle oraz LinkTitleNoMenu. Po dodaniu referencji w Content Type dla tych pól jak na obrazku poniżej moglibyśmy oczekiwać zmiany nazwy pola:

Niestety jednak jeśli chodzi o Content Type nie przynosi to pożądanego skutku:

Umieszczenie tych referencji w Content Type pozwoli natomiast na automatyczne wygenerowanie referencji do pól przy tworzeniu List Definition, dzięki czemu nie trzeba ich ręcznie kopiować. W samej definicji listy trzeba jeszcze, poza referencją do pól, dodać definicję tych pól (tak jak została ona automatycznie dodana dla utworzonego wcześniej pola PersonName):

Po takich zmianach widzimy, że nazwa pola uległa zmianie zarówno w widoku listy, jak i na formularzu dodawania nowego elementu (pamiętać należy jednak, że w Content Type nazwa ta bez zmian jest wyświetlana jako Title):

Destrukcja

Podobno czasem bywa, że aby coś zbudować, trzeba coś zniszczyć. Tak zrobimy i tym razem i tworzenie  nowego, lepszego świata zaczniemy od… usunięcia Emacsa i wszystkiego co z nim związane z systemu. Większość osób instaluje edytor z dystrybucyjnego repozytorium. Takie rozwiązanie jest wygodne, ale ma kilka przykrych konsekwencji. Przede wszystkim repozytoria często zawierają nieaktualne wersje, a wbrew pozorom Emacs rozwija się całkiem szybko, więc łatwo pozostać w tyle. Drugą sprawą są zależności, które instalują się przy okazji – nie zawsze wiadomo co to jest. Różne dystrybucje wykorzystują różne rodzaje repozytoriów, a więc ewentualne przeniesienie naszego środowiska pomiędzy dystrybucjami może sprawić niepotrzebny kłopot. Odpowiedzią na te problemy jest kompilacja – proces sporo trudniejszy, no ale coś za coś. W każdym razie pacman -R (czy co tam kto używa) do rąk i do dzieła! Ważne, aby wszystko usunąć – nie tylko podstawowy edytor, ale również wszystkie pakiety wspomagające – dodatkowe mody itd.

Budowanie

Po słodkim zniszczeniu pora zacząć budowanie nowego świata. Pierwszym krokiem będzie sklonowanie najnowszej wersji z repozytorium:

git clone git://git.savannah.gnu.org/emacs.git

a następnie kompilacja i instalacja:

./autogen.sh
./configure
make
sudo make install

i gotowe! Nasz nowy, błyszczący Emacs jest gotowy. W przypadku gdybyśmy chcieli zaktualizować naszą kompilację należy wyczyścić stare efekty, pobrać zmiany i powtórzyć cały proces:

make clean
git pull
./autogen.sh
./configure
make
sudo make install

Prace wykończeniowe

Nie od dziś wiadomo, że to prace wykończeniowe zajmują najwięcej zasobów – tak też jest w tym wypadku.

Dodatki

„Goły” Emacs, mimo że bardzo rozbudowany, nie posiada wszystkiego, co potrzebne do szczęścia. Z tego powodu na pewno chcielibyśmy wyposażyć naszą kompilację w szereg dodatków. Wszystkie dodatkowe moduły warto trzymać uporządkowane, w jednym miejscu. W ten sposób przeniesienie ich na inny system będzie wymagało zaledwie skopiowania pojedynczego katalogu. Genialne w swej prostocie, prawda? Osobiście preferuję przechowywanie dodatków w katalogu ~/.emacs.d, w którym utworzyłem sobie dwa katalogi: modules i themes, które odpowiednio zawierają moduły i motywy graficzne.

Konfiguracja

Skonfigurowanie Emacsa, skrojone do indywidualnych potrzeb jest zadaniem dosyć skomplikowanym. Zajmę się tym w kolejnej notce z serii emacsowej. Na chwilę obecną proponuję obejrzeć mój plik konfiguracyjny, który jest dosyć obszernie skomentowany.

Uruchamianie

Gdy mamy już wszystko elegancko skonfigurowane można swobodnie zacząć używać Emacsa, ale… wpisanie w konsoli „emacs” jest passe, demode i w ogóle bleee. Osobiście, w trakcie uruchamiania systemu odpalam Emacsa w trybie daemona:

emacs --daemon

Wtedy Emacs będzie pracował zawsze w tle, a jego uruchomienie za pomocą polecenia:

emacsclient

będzie się odbywało niemal natychmiastowo. Istotną zaletą takiego podejścia jest ciągłe przechowywanie sesji no i wysoka efektywność i wygoda. Wadą natomiast może być konieczność rozsądnego zarządzania buforami, które nie zamykają się same. W tym miejscu warto również stworzyć dla powyższego polecenia wygodny alias – w moim wypadku jest to po prostu e. e nazwa_pliku uruchamia mi ramkę Emacsa z plikiem gotowym do edycji i jest to co najmniej tak wygodne jak vim ;>.

Na zakończenie

Używanie Emacsa w ten sposób jest bardzo wygodne i już wiem, że nie zamienię go na nic innego :). Serdecznie polecam wszystkim spróbowanie takiego podejścia. Niedoświadczonym proponuję sklonowanie sobie mojego repozytorium z dotfiles:

git clone git://github.com/luksow/dotfiles.git

Można tam znaleźć mój katalog .emacs.d, plik konfiguracyjny Emacsa .emacs oraz plik .bash_rc z ustawieniami aliasów.

Powodzenia!

Część praktyczna…

O szczegółach trudnych początków można było przeczytać wcześniej. W czasie wakacji skoncentrowałem się na tworzeniu praktycznej części pracy. Podczas analizy systemu Google Chrome OS napotkałem na pewien nierozwiązany problem. W Linuksie brakuje mechanizmu, który pozwalałby na ograniczenie dostępnego zbioru wywołań systemowych. Tego typu narzędzie pozwala na działanie w myśl zasady najmniejszego uprzywilejowania i powstrzymywanie ataków ze wstrzykiwaniem kodu. Istniejące rozwiązania są niewystarczające – posiadają zbyt małe możliwości, są niewydajne lub niebezpieczne. Z tego powodu ochoczo zabrałem się za stworzenie rozwiązania, które może sprostać oczekiwaniom projektu Chrome OS i pozostałej części społeczności :).

W związku z powyższym stworzyłem moduł, który pozwala pogrupować zadania w grupach kontrolnych, a następnie zdefiniować dostępny dla nich zbiór wywołań systemowych. Tym samym można zabronić procesom np. otwierania i tworzenia plików, zmieniania uprawnień, forkowania itd. Na uwagę zasługuje wydajność rozwiązania. Użycie modułu spowalnia zadania o nie więcej niż 5%, co jest zdecydowanie dobrym wynikiem na tle rozwiązań konkurencyjnych.

Sama implementacja nie była łatwa. Przy okazji tworzenia mechanizmu musiałem dogłębnie poznać działanie kilku elementów jądra, a także uważać na różne subtelności takie jak właściwa synchronizacja czy optymalizacja.

…teoretyczna…

Oprócz pierwszego rozdziału o mechanizmach bezpieczeństwa systemu Chrome OS, musiałem napisać jeszcze z 70 stron :). Dalsza część tekstu powstawała w minionym semestrze, a jej treść w zasadzie odzwierciedlała postępy w pracy. Drugi rozdział dotyczył zatem istniejących rozwiązań oferujących usługi ochrony dostępu do wywołań systemowych i dlaczego są złe ;>. Dalej było standardowo – rozdział pt. „Projekt”, w którym rozważałem możliwe podejścia do tematu, „Implementacja”, w której skoncentrowałem się na specyfice programowania w przestrzeni jądra oraz „Testowanie”, w którym przeprowadzałem dosyć hardkorowe testy wydajnościowe. Na koniec pozostało napisanie wstępu i zakończenia i gotowe! Wygląda to jak spacerek, ale tak naprawdę to był maraton. Pisanie tekstów technicznych jest trudne, nawet bardzo trudne. Praktyka w pisaniu na blogu to niewiele, ponieważ styl języka jest całkowicie inny. Ostatecznie udało się jednak złożyć pracę na czas, 3 dni przed terminem.

…i rezultaty

Oprócz tytułu zawodowego, udało mi się zdobyć coś (ideologicznie) wartego znacznie więcej – wiedzę. Mogę śmiało powiedzieć, że udało mi się znacznie rozmnożyć moje zasoby wiedzowe, co uznaję za największy sukces całego procesu dyplomowania. Mówiąc krótko – jestem dumny z wykonanej przeze mnie pracy i chyba nie ma w tym nic złego. Mam też nadzieję, że równie przyjemnie będzie mi się pracowało nad pracą magisterską.

W tym miejscu zachęcam do przeczytania przynajmniej fragmentów mojej pracy (jak tylko zostanie ona opublikowana), a także śledzenia wszelkich „ubocznych” efektów dyplomowania :).

Semestr

Na ten semestr został mi już tylko jeden przedmiot – algorytmy heurystyczne. Niewiele mogę jednak o nim napisać, gdyż (niestety?) nie bardzo się do niego przykładałem z powodu zaangażowania w pracę inżynierską. Ot przedstawienie, podsumowanie wiedzy o metoda metaheurystycznych i trochę obrzydliwej matematyki. Na plus można zaliczyć fakt, że udało mi się przy okazji poznać nowy język – R, potrzebny do realizacji projektu.

Na oddzielny akapit zasługuje seminarium dyplomowe, na którym każdy uczestnik miał okazję opowiedzieć o swojej pracy dyplomowej. Inicjatywa całkiem fajna, bo rozwijającą. Ogromna różnorodność tematów pozwala doszkolić się z innych, niż własna, dziedzin. Przyczepić można się tylko do dwóch rzeczy. Przede wszystkim każdy uczestnik miał tylko 20 minut na prezentację, co jest śmiesznie małą ilością czasu. Ciężko w 1/3 godziny przedstawić efekt wielu dni pracy, ale widocznie „tak musi być”. Druga sprawa to jakość przygotowanego przez uczestników materiału – często co najmniej „słaba”. Niemniej jednak, takich inicjatyw powinno być więcej. Niech nie tylko wykładowcy mają prawo głosu :).

Praca inżynierska

Zdecydowaną większość semestru spędziłem na pracy nad dyplomem. Poważny risercz, dużo pisania – zajmowało to kupę czasu i co ważniejsze chęci i siły. Z tego też powodu zaniedbałem całkowicie bloga. Po spędzeniu kilku godzin dziennie na pisaniu, perspektywa tworzenia (dobrowolnie) notki na bloga powodowała u mnie niemal odruch wymiotny. W każdym razie, efekt mojej pracy jest (przynajmniej dla mnie) więcej niż zadowalający. Kompletny, funkcjonalny moduł jądra oraz około 90 całkiem treściwych stron pt. „Nowoczesne mechanizmy bezpieczeństwa w systemie Linux” są zwieńczeniem niemal roku pracy. Co jednak najważniejsze praca została oceniona na bardzo dobry z wyróżnieniem czyli nie tylko mi się podobała :).

Studia, studia… i po studiach

Udana obrona – studia ukończone na bardzo dobry z wyróżnieniem zakończyły inżynierski etap mojej edukacji. Nie mam ochoty ich podsumowywać, gdyż myślę, że byłoby to nierzetelne. Prawdziwy obraz moich studiów tworzą komentarze do poszczególnych semestrów, do których linki można znaleźć poniżej:

• Semestr 1
• Semestr 2
• Semestr 3
• Semestr 4
• Semestr 5
• Semestr 6
• Semestr 7

I started with GTD (Getting Things Done). Applied and tried it for about a year, but …. Well as usual I overcomplicated this simple solution with time estimations, time tracking. It started to feel like, I was spending most of the time maintaining GTD lists. It was getting more and more complicated. Something was wrong it shouldn’t supposed to work like that. My precious time was wasted on “management”.

Again I had to change my planning. GTD wasn’t for me. I stumbled upon one of the presentation in Krakow by Paweł Brodziński about Kanban. Presentation about project planning on cork board seemed cool and nice, I bought cork board some stickers and tried something new.

In this post, I will describe my current time/task management workflow which is at the moment working quite fine ( maybe because of the “new thing” hype ).

Long Term Planning

First of all let’s start with something that everyone should do from time to time. Long Term Planning. Before doing anything else, I am thinking about what I m going to do this month, year and what kind of goals, I want to accomplish, in the long run. This is really important, because it lets me think about my life and where should I go next.

I divide stuff into four areas:

1. Personal – friends, family, girlfriend etc.
2. Physical – health, fitness, activities etc..
3. Technical  – programming, math, algorithms etc.
4. Social – planning, speaking, teaching, managing etc..

Of course I will change this list a bit in the course of the year. But those are always minor tweaks. Also those points will provide nice knowledge about myself in the future.

It is really important to have a game plan of your life . Life is very complicated and most of the time we can only adapt to the situations. Control can be easily lost. With long term plans, I feel more secure for such situations.

Personal Kanban

I mentioned Paweł Brodziński  and Kanban with some try and errors, I managed to create my own workflow for tasks. Cork board and sticky notes are really awesome.

This is my awesome board. I Divide it into four areas.

1. Waiting – tasks that are waiting to be done
2. Doing – tasks that. I am currently working on
3. Done – tasks that have been finished in the current week
4. Week log – place for finished tasks from previous weeks, there are four stacks for each week, so I have log of what I did in this month

Between areas Doing and Done, I have two narrow openings that can contain only two tasks. Those are things that, I am working atm.

Sticky notes are in different color and of course this also has it’s purpose. Tasks are divided into six groups.

• red – important
• green – learn
• blue – blog
• pink – events,speaker
• orange- projects
• yellow – personal

There are also tasks that have two colors like on this screen. That means that this task is in two groups and in this case, when I finish the project I will write a blog post about it

Cork Board vs Software

At first I was a bit reluctant to use cork board and old fashioned sticky notes.

Now I only can only say that it is awesome

• Cork board is always visible. You don’t need to switch windows or buy new screen.
• It has limited space. So I am not able to add hundreds of not important tasks
• it forces you to do something physical, move your body. That’s quire engaging and brain loves it.

There is only one problem with this. What to do with recursive tasks ? Tasks that are repeating all the time. For those tasks I m using an android app called Due Today. It is really awesome and handy. Maybe in the future, I will find way to incorporate this logic into board.A lot will change, and I will adapt some things but that’s the beauty of this. By try and error I m creating something that feels good at the moment and is quite motivating (because I feel the freshness in it)

Before doing the changes we need :

1. fancybox script

2. inlinepopups plugin

InlinePopups has to be activated on editor init function. This plugin will force popups to show as a separate element on the page instead of new window, which is a default action

Changes to the inline popups editor_plugin.js

After this simple change default popup will be replaced with fancybox.

TinyMCE Popup inside fancyBox

There is one problem with this solution. Out of box if you have inline popups plugin you can run multiple popups ,like one popup for file browser and another for custom image browser. With changes inside inline popups that supports fancybox you are not able to open two popups because fancybox doesn’t support multiple instances running in the same time. One of the solutions would involve opening first fancy back after closing second fancy.

First we will explore ViewEngines and HTML response generation,then we will move into the custom View Engine World. If you are interested dear reader then “Stay while and listen …”

ViewEngine

ViewEngine is responsible for HTML generation that is sent back to the client. Programmers with Asp.Net background should be familiar with WebForms Engine that uses <% %> syntax and WebControls . There are other ViewEngines like RazorEngine, which is quite popular right now, but we won’t discuss this here as it is not important for this post.

Pic 1. Simplified Request/Response cycle

Every  ViewEngine implements IViewEngine interface

  public interface IViewEngine

  {

    ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache);


    ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache);


    void ReleaseView(ControllerContext controllerContext, IView view);

  }

This interface contains method responsible for ViewEngineResult generation,

ViewEngineResult class is a simple data container holding information about ViewEngine we are using and instance of View class.

View class is an implementation IView interface which is very simple and contains only one method.

  public interface IView

  {

    void Render(ViewContext viewContext, TextWriter writer);

  }

This is a very simple interface  that contains Render method which has access to TextWriter that should be used to write data that will be displayed in a response sent back to client. This is almost like Render method inside WebControls.

Ok lets go back to ViewEngine. Unfortunately, or to be honest that is a very good decision, WebFormViewEngine is not directly implementing IViewEngine.

  public class WebFormViewEngine : VirtualPathProviderViewEngine

There is another layer in form of VirtualPathProviderViewEngine. This class is implementing IViewEngine and is responsible for adding “physical path” support, if you want to use files stored on your server’s file system you should create custom ViewEngine that extends this class.

Summarising:

Pic 2. Simplified WebFormsViewEngine Request/Response

Simple Custom ViewEngine

Ok so we “hopefully” know how the whole ViewEngine stuff works, so lets do our own one. Yey \o/

Our first ViewEngine will be very simple and we will call it HelloWorldViewEngine.

    public class HelloWorldViewEngine : IViewEngine

    {

        public ViewEngineResult FindPartialView(ControllerContext controllerContext,

             string partialViewName, bool useCache)

        {

            return new ViewEngineResult(new HelloWorldView(), this);

        }


        public ViewEngineResult FindView(ControllerContext controllerContext,

              string viewName, string masterName, bool useCache)

        {

            return new ViewEngineResult(new HelloWorldView(), this);

        }


        public void ReleaseView(ControllerContext controllerContext, IView view)

        {

            IDisposable disposable = view as IDisposable;

            if (disposable == null)

                return;

            disposable.Dispose();

        }

    }

ReleaseView method is a copy/paste code from Microsoft Code. As you can see this method should be used to dispose View instance.

FindPartialView and FindView methods are only returning DummyViewEngineResult. Unfortunately we had to create our own implementation of IView interface called HelloWorldView because WebFormView uses physical files and I couldn’t get it  to render something.

    public class HelloWorldView : IView

    {

        public void Render(ViewContext viewContext, TextWriter writer)

        {

            writer.WriteLine("Hello World");

        }

    }

This View is very simple and prints out only “Hello World” message. Cool

In order to use this “awesome” ViewEngine we have to register it inside Global.asax file.

        protected void Application_Start()

        {

            AreaRegistration.RegisterAllAreas();

            ViewEngines.Engines.Clear();

            ViewEngines.Engines.Add(new HelloWorldViewEngine());

            RegisterRoutes(RouteTable.Routes);

        }

First we are clearing all the Engines that are currently used and then we are adding our own custom one.

Hopefully on the start you will see beautiful “Hello World” message .

DBViewEngine

I  will make Database based on RavenDB just 4fun and in order to use it for the first time.

RavenDB ?

Raven is a .NET Linq enabled Document Database, focused on providing high performance, schema-less, flexible and scalable NoSQL data store for the .NET and Windows platforms.

In short NoSql :

Pros

• Good when your app is used for many Reads
• Scalability benefits 
• No strict schema
• Less problems with data mappings

Cons

• Bad when your app is used for many Writes

I won’t get into details about RavenDB so lets start implementing our first version of DBViewEngine.

RavenDB DAL

In order to retrieve data we will make a simple DAL.

Page Entity

For this simple scenario we are persisting objects only with ViewName and HTML data.

    public class Page

    {

        public string Html { get; set; }

        public string ViewName { get; set; }

    }

Html is an actual data that will be rendered by browser.

GetPageByViewName

       public Page GetPageByViewName(string viewName)

        {

            using (var session = _store.OpenSession())

            {

                return session.Query<Page>().Where(x => x.ViewName == viewName).FirstOrDefault();

            }

        }

A simple function to get page by viewname this one will be used by the engine to get the data about the page.

In DB we gonna store two pages About and Home. They will only display simple message like “Welcome to the about page”.

ViewEngine

So now the best part. How to link ViewEngine with DB.

IViewEngine interface has a definition of FindView method. This method has all the data we want right now including ViewName parameter. So let’s implement this method.

        public ViewEngineResult FindView(ControllerContext controllerContext,

                string viewName, string masterName, bool useCache)

        {

            var page = new PageDal().GetPageByViewName(viewName);

            return new ViewEngineResult(new DBView(page), this);

        }

Little test:

Url – /Home/About

And yuppi we have a message indicating that this is a correct site.

Source Code

Conclusion

Asp.Net MVC architecture is quite easy to modyfi and extend. In this post we analysed how we can implement our different ViewEngine which is using RavenDB as a source of the files,

Po zapoznaniu ze zmianami jakie na nas czekają przy budowie Content Type’ów przy pomocy Visual Studio 2011 zobaczmy jakich zmian możemy się spodziewać jeśli chodzi o tworzenie list. Zacznijmy zatem od dodania nowego elementu do projektu:

Pierwszą zmianę widzimy już na tym etapie, a mianowicie nie dostajemy już wyboru, czy chcemy utworzyć List Definition czy List Instance. Miejsce tych dwóch elementów zastąpił jeden nowy o nazwie “List”. Po dodaniu tego elementu widzimy w Solution Explorerze, że w projekcie utworzona została struktura taka, jak byśmy dokonali w starym stylu dodania List Definition wraz z instancją listy:

Po dodaniu nowej listy przechodzimy do nowego designera, który ma za zadanie pomóc nam przy tworzeniu list:

Do dyspozycji otrzymujemy trzy zakładki: List, Views oraz CommonProperties. Ostatnia zakładka odpowiedzialna jest za ustawienie właściwości listy takich jak Nazwa listy, jej opis oraz url pod jakim lista znajdzie się na serwerze. Możemy również zdecydować, czy chcemy umieścić listę na Quick Launch’u oraz czy lista ma być ukryta czy też nie.

W pierwszej zakładce, której widok został przedstawiony na powyższym obrazku, mamy możliwość dodania istniejących kolumn, zarówno tych zainstalowanych na serwerze, jak i dopiero co utworzonych w projekcie VS. Mamy również możliwość dodania Content Type’a do listy:

Do listy o nazwie PersonsList dodany został utworzony w poprzednim wpisie na blogu Content Type o nazwie ContentType1. Po tej czynności widok kolumn listy został uzupełniony o te, które zawarte zostały w dodanym Content Type’ie – w tym przypadku jedna kolumna o nazwie Person Name.

Przechodząc do dobrze znanego nam pliku schema.xml widzimy, że zmiany zostały poprawnie odwzorowane w tym pliku, co zwalnia nas, przynajmniej w standardowych przypadkach, z konieczności ręcznej edycji wspomnianego pliku:

W kolejnej zakładce designera dla list możemy zdefiniować nowe widoku dla listy lub zmodyfikować istniejące:

Również w tym przypadku zmiany poprawnie odwzorowywane są w pliku schema.xml:

W pierwszej odsłonie swoich zmagań z SharePoint’em chciałbym przedstawić pokrótce zmiany, jakie czekają na programistów SharePoint w nowej wersji Visual Studio (na dzień dzisiejszy jest to Microsoft Visual Studio 11 Version 11.0.40825.2 PREREL). Omawiane przeze mnie zmiany dotyczyć będą udogodnień wprowadzonych przy tworzeniu Content Type’ow oraz list. Już na pierwszy rzut oka widać tutaj zmiany na które z pewnością wielu programistów od dłuższego czasu czekało, bowiem nowa wersja VS oferuje nam designera, który ma na celu ułatwienie definiowania wcześniej wymienionych elementów. Z koncepcją designera dla Feature’ów i paczek dane było nam już się zaznajomić wraz z wersja VS2010, szkoda, że w owym czasie nie został wprowadzony również designer dla Content Type’ów a także wspomnianych już przeze mnie list.

Zobaczmy zatem najpierw jakie możliwości daje nam Visual Studio 2010, zaczynając od utworzenia projektu:

Po wybraniu opcji “New Project” możemy utworzyć poza pustym projektem również szereg elementów składowych jak np. Content Type, czy List Definition bez konieczności umieszczania ich w projekcie SharePoint’owym. Wybierzmy jednak pusty projekt (podświetlona na szaro opcja na powyższym obrazku). Po jego utworzeniu, chcąc przystąpić do budowy Content Type’a dodajemy do projektu nowy element wybierając opcję Content Type:

Jak można łatwo sprawdzić VS zajęło się dodanie nowego Content Type’a do istniejącego w projekcie Feature’a (o odpowiednim scope – web).  Jako tym bazowy został wybrany Item – po dwukrotnym kliknięciu w projekcie na nasz Content Type edytor przenosi nas do edycji pliku Elements.xml:

Przystępując do budowy Content Type’a musimy zdefiniować nową Site Column wypełniając odpowiednie pola oraz generując nowy GUID dla tej kolumny. Następnie należy dodać referencję do zdefiniowanej Site Column. Nie jest to zbytnio skomplikowana czynność, w momencie gdy mamy jednak wiele kolumn czynność ta potrafi zabrać trochę czasu, a jakakolwiek pomyłka przy przeklejaniu kodu uniemożliwi poprawne zainstalowanie Content Type’a:

Zobaczmy teraz jak proces ten może usprawnić nowe VS. Zacznijmy ponownie od utworzenia nowego projektu. Już na tym etapie da się zauważyć zmiany, bowiem w nowej wersji liczba elementów które możemy utworzyć bez tworzenia najpierw pustego projektu jest bardzo ograniczona (widzimy jedynie możliwość utworzenia dwóch rodzajów Web Part’ów):

Z kolejnych elementów możemy skorzystać standardowo dodając nowy element do projektu. Tutaj warto zwrócić uwagę na pojawienie się nowego elementu jakim jest Site Column, od której to zaczniemy tworzenie Content Type’a:

Po dodaniu Site Column o nazwie PersonName otwierany jest automatycznie plik Elements.xml, warto jednak zauważyć, że wiele z pól zostało już wypełnionych przez Visual Studio.

Widzimy na powyższym obrazie m.in., że domyślnie założony został typ tekstowy, wygenerowany został GUID, a także słowa składowe nazwy zostały odpowiednio rozdzielone i wpisane do DisplayName. W dalszym ciągu definicja taka wymaga dalszej customizacji, jak np. zmiana typu itp. ale widać już postęp w porównaniu do poprzedniej wersji VS.

Przystąpmy dalej do budowy Content Type’a – po dodaniu tego elementu do projektu otwierany jest … no właśnie, w tym przypadku nie xml, ale nowy designer (warto zwrócić uwagę na to, że na etapie tworzenia domyślnie jako typ bazowy wybrany jest Item, dzięki czemu nie musimy za każdym razem przestawiać drop downa z domyślnego typu dla VS 2010 jakim było Announcements):

W kolumnie DisplayName możemy wyszukiwać spośród dostępnych na serwerze Site Columns oraz jak widać także wśród tych stworzonych przez nas w projekcie. Po odnalezieniu odpowiedniej kolumny automatycznie wypełniany na podstawie definicji są kolumny Type oraz Required. Dzięki tej funkcjonalności, jeśli już posiadamy odpowiednie kolumny, to budowa Content Type’a  sprowadza się do ich wyklikania w designerze. Nic nie stoi na przeszkodzie, żebyśmy sprawdzili kod jaki wygenerował designer przechodząc do pliku Elements.xml – nie ma tutaj jednak większego zaskoczenia – zbudowany został on tak jakbyśmy sami wprowadzili odpowiedni kod:

Widać więc, że nowe Visual Studio stara się ułatwić nieco życie programistom SP i chociaż częściowo odciągnąć od konieczności ręcznej edycji plików xml. Nie jest to zapewne milowy krok (nadal brakuje np. wyboru typu dla Site Column) ale zmiana ta powinna zostać doceniona jako krok w dobrym kierunku. W kolejnej odsłonie przekonamy się jakie zmiany czekają na nas w związku z tworzeniem list.

There was a problem with Swedish characters “ö,ä,å” and also especially pound currency character which was used in one of the regular expression in the app. With my operating system, configured with the English culture settings using CodeBase 1250, those characters where changed and there were couple of runtime errors. We had to change the encoding to UTF8 that’s one of the solutions. UTF8 has a bigger character set.

There is an option in Visual Studio File –> Advanced Save Options that can be used to change encoding but it’s only usable for scenarios with one file. In this situation I had to change couple thousand of files. To fix this problem I have found a nice solution that uses PowerShell .

Script:

  1: function ChangeEncoding ($baseDirectory)

  2: {

  3:         $allFiles = Get-ChildItem $baseDirectory -include *.aspx,*.ascx -recurse

  4:               | where-object { -not $_.PSIsContainer}

  5:         foreach( $file in $allFiles){

  6:             $fileContent = get-content $file.FullName -force

  7:             $fileContent | set-content -encoding utf8  $file.FullName -force

  8:         }

  9: }

 10: ChangeEncoding("BaseDirectoryPath") 

This script iterates through all the files in directories and their directories and rewrites them with correct encoding. It’s not the best solution but it works.

Little Explanation:

Get-ChildItem $baseDirectory -include *.aspx,*.ascx –recurse 

Gets all the files with specified extensions  (aspx and ascx) , recurse option enables search through all the files in directories and subdirectories

where-object { -not $_.PSIsContainer} 

Used to exclude directories from the files list.

This script loads the file to a temporary variable because we have to read and write the same file. Pipelined solution would be cleaner but it reads and writes the data one line at time. You can’t write and read on the same file at the same time.

Fortunately there is a solution. Chrome provides simple parser command which can tag dynamically loaded JS. 

<script type="text/javascript">

....

//@ sourceURL=createOrder.js 

</script>

This line tells the chrome debugger that this whole script inside the script tag should be interpreted as a createOrder.js file. You can find the file on the debugger list and easily set up breakpoints or check the code.

If you are working with Asp.Net MVC and Razor Engine use Write function

<script type="text/javascript">

....


@{Write("//@ sourceURL=createOrder.js");}


</script> 

Technologies and Tools used in Project:

NLog + Sentinel

NLog is awesome ! It’s easy and flexible. I will stick with it in my projects. Every app should implement logging mechanism because it simplifies development and cuts time spent on debugging code. Sentinel is a tool used to view generated logs. It supports for NLog and log4net. Sentinel is still in early development phase and needs improvements but it’s ok.

In my scenario i had a dual screen setup ( monitor + laptop screen). Laptop was used as a log windows with sentinel.

NHibernate + FluentNhibernate

NHibernate has step learning curve ( at least for someone like me with noob skills in ORM’s) but its great, flexible and greatly simplifies Data Abstraction Layer implementation. I had couple of situatioon when, I had to do massive changes in the DB. With DAL in NHibernate it was easy task. For NH mappings i have used FluentNhibernate. This lib has some flaws and problems like weak sql stored procedure support but i really don’t like the idea of xml files.

NUnit + RhinoMock

Whole DAL is covered by unit tests (all the repository methods and service methods). I m using NUnit because this was my first test framework and i got used to it. In this project i have used for the first time Mocking Framework. Why RhinoMock well, I am reading Ayende’s Blog and thought that’s this one will be good at the beginning. There are currently more than 120 tests.

Automapper

I m using Automapper to convert between different classes. My DAL is behind WCF services and, I’m using DTO’s as a transfer class. With Automapper conversion from NH entity to DTO is really simple.

Ninject

This was my first time experience with DI frameworks. It works really well and is quite simple but recently i found a performance comparison and Ninject is very slow compared to other solutions. I was using Unity at work and, I m gonna try it with other projects.

Architecture

This is a simple architecture of my app.

Graphical Design

Log in Screen

Main Page

Course Page

I am using Adminica Template. Great Stuff !

It was quite a big project for me. I learned a lot and tried different solutions. After my graduation i will work maybe on it as a open source project.

Semestry początkowe, czyli kurowa wszystkich nauk

Na chyba każdej uczelni technicznej pierwsze semestry składają się głównie z matematyki. Algebra, analiza, logika, statystyka – to standard. Semestry te są też podobno najtrudniejsze i na nich odpada najwięcej osób. Na mojej kochanej Uczelni z matematyki dawano nieobowiązkowe zestawy zadań, które później robione były na ćwiczeniach. Jak się okazało, najskuteczniejszym podejściem do sprawy było po prostu robienie ich samodzielnie wcześniej. Owszem, zabierało to dużo czasu: dzień przed ćwiczeniami widywałem wschody słońca, przy piwku i zeszycie z całeczkami; owszem było to nudne, a czasem wręcz niesamowicie irytowało; ale owszem – dawało to wybitne wyniki: dzień przed kolokwium wystarczyło przejrzeć wykonaną wcześniej pracę, a samo kolokwium wydawało się dziecinnie proste. Do matematyki podejście jest więc proste: ćwiczyć, ćwiczyć i jeszcze raz klepać schematy – a zaliczenie przyjdzie bez problemu.

Warto jeszcze wspomnieć dwa słowa o wykładach i ćwiczeniach. Na wykładach bardzo często dyktowana jest książka (z dokładnością do takich samych przykładów). Można więc pokusić się o absencje, jednak wtedy trzeba taką książkę załatwić, albo wziąć od kogoś notatki. Ja mimo wszystko uczęszczałem na wykłady, głównie dlatego że najmilej czyta mi się swoje własne pismo i żartobliwe rysunki :P. Co do ćwiczeń, to warto chodzić – głównie po to, żeby zweryfikować swoje rozwiązania i załapać punkty za aktywność.

Semestry dalsze, czyli pozostałe dobrodziejstwa inwentarza

Pozostałe przedmioty na studiach (pamiętajmy, że ciągle mówimy o informatyce) można podzielić na takie, które wymagają wiedzy (np. architektura komputerów, systemy operacyjne, grafika komputerowa) i takie które wymagają klepania schematów (np. teoria obwodów, teoria informacji, automatyka, optymalizacja). Co do drugiej (gorszej, nota bene) kategorii strategia jest taka sama jak dla matematyki – trzeba się po prostu tych schematów nauczyć, a później na kolokwium/egzaminie wyklepać. Tutaj niebywale przydaje się bank kolokwiów i egzaminów z ostatnich lat do poćwiczenia. Poza tym, nie trzeba chyba wspominać, że wiele zadań się po prostu powtarza :). Nauka schematów jest żmudna, ale nie jest trudna, dlatego też chodzenie na wykłady z przedmiotów „schematycznych” jest raczej zbędne – chyba że ktoś naprawdę lubi patrzeć jak się oblicza kolejną całkę na tablicy.

Dosyć już jednak narzekania, przejdźmy do przedmiotów wymagających wiedzy, czyli bardziej złożonej materii. W trakcie 6 semestrów nauki udało mi się wypróbować dwie strategie – opiszę więc każdą z nich.

Noc przed, zasada indukcji, od zera do bohatera

Strategia ta jest bardzo prosta. Zakłada ona, że da się wszystkiego nauczyć na egzamin/kolokwium w nocy przed takowym. Zwykle nie ma wtedy mowy o spaniu, trzeba mieć dużo samozaparcia i wytrwale siedzieć i czytać. Strategia ta działa i jest praktykowana przez wiele osób – z sukcesami. Ma ona jeden szkopuł – niestety trzeba mieć pewną, podstawową wiedzę wyniesioną z wykładów (albo z książek, tudzież doświadczenia). Dla przykładu uczenie się algorytmów „od zera” w 8 godzin jest zbyt męczące psychicznie = niemożliwe. Z drugiej strony, mi z podstawami sztucznej inteligencji się udało – z zerową wiedzą wyniesioną z wykładu ;). Skuteczność tej metody zależy więc od materii i osobistych predyspozycji.

Zastanówmy się teraz nad czymś takim: „a co jeśli jednego dnia mam n kolokwiów?” (n > 1). Słynna zasada indukcji studenta mówi, że jeśli student jest w stanie nauczyć się do n kolokwiów w nocy przed, to jest też w stanie nauczyć się do n+1 kolokwiów. Dlatego jeśli jesteś w stanie przygotować się do kolosa na noc przed, to z dwoma, trzema… też nie będziesz miał problemów :). Tutaj jednak warto wiedzieć o zasadzie Pareto. Noc może nie starczyć, aby nauczyć się na 100%, jednak pewien (poniekąd 20%) wkład w każdy z n podproblemów da nam wysoki (poniekad 80%) wynik.

Co natomiast robić, jeśli na wykładach nie pojawialiśmy się w ogóle, a kolokwium/egzamin zbliża się nieubłaganie? Cóż, innego wyjścia nie ma, jak tylko kuć wytrwale nie przez jedną, a np. przez trzy kolejne noce. „Od zera do bohatera” w 3 dni wydaje się być osiągalne, niezależnie od poziomu skomplikowania materii. Może to być jednak wyjątkowo wyczerpujące i niemiłe. Spróbowałem raz – udało się, ale rzeczywiście było niemiło.

Systematyczność

Systematyczność – tego słowa nienawidzą wszyscy uczniowe. Nauczyciele nieustannie, od lat powtarzają – ucz się systematycznie, a wyniki przyjdą same. Po 5 semestrach wykorzystywania zasady „noc przed”, na 6 semestrze postanowiłem spróbować (eksperymentalnie) uczyć się systematycznie każdego przedmiotu. Nie ze wszystkimi się udało, bo niektóre były zbyt ohydne, ale jednak z większością tak :). Efekty? Znakomite. Wyniki oscylujące w okolicy 100% były normą. Koszt? Ogromny. Wymagało to wytrwałego chodzenia na wykłady i codziennej powtórki (około dwugodzinnej) tego, co udało mi się tam nauczyć. Dostrzegłem też pewien pozytywny efekt uboczny: w końcu czułem, że do przedmiotów, które lubie przykładam się w stopniu zadawalającym.

Aurea mediocritas

„Jak więc żyć, drogi Łukaszu?” słyszę pytania z tłumu. Już stoicy znali na nie odpowiedź: złoty środek. Dla przedmiotów ze schematami należy uczyć się schematów – najlepiej tak, aby mechanicznie je odtwarzać, gdy ktoś o nie pyta. Dla nudnych, nieciekawych przedmiotów wymagających wiedzy warto stosować taktykę „olewczą”, czyli uczyć się na noc przed. Do przedmiotów interesujących i lubianych najlepiej uczyć się systematycznie.

W ten sposób pielęgnujemy swoje pasje i zainteresowania i zaliczamy kolejne przedmioty, utrzymując przy tym stan frustracji na rozsądnym poziomie.

Disclaimer

Przedstawione powyżej metody działały dla mnie znakomicie. Nie tylko pozwalały gładko zaliczać kolejne przedmioty, ale również dawały dobre wyniki (jeśli mierzyć je wysokością oceny). Warto jednak pamiętać, że nie każdy ma taki sam styl nauki. Niektórzy nie są wstanie przesiedzieć nocy nad książką, innym wystarczy tylko chwilowe spojrzenie na coś i już to potrafią. Do tego, moje doświadczenia opieram wyłącznie na moich studiach, które mogą być specyficzne, ze względu na kierunek czy wydział/uczelnię. Należy więc wypracować indywidualny tryb pracy, a powyższe metody potraktować jako pewną możliwość. Sukcesu więc nie gwarantuję, jednak z całego serca życzę :).

ABSTRACT FACTORY, czyli Metoda fabrykująca

Cel:
Określenie interfejsu dla tworzenia obiektu z pozostawieniem podklasom decyzji o wyborze klasy tworzonego obiektu

Stosowalność:
Używamy go, gdy:
- Klasa nie jest w stanie przewidzieć klas obiektów, które musi tworzyć.
- Klasa chce, aby jej podklasy określały obiekty, które tworzy.
- Klasy delegują odpowiedzialność do jednej z kilku pomocniczych podklas i chcemy zlokalizować wiedzę o tym, która z tych podklas jest aktualnym delegatem.

Konsekwencje używania:
- Metody fabrykujące eliminują potrzebę umieszczania w kodzie klas specyficznych dla aplikacji.
- Potencjalna wada FM – klienci mogą być zmuszeni do specjalizowania klasy Twórcy tylko po to, żeby stworzyć szczególny Konkretny Produkt.
- Dostarczenie „wskazówek” podklasom
- Połączenie równoległych hierarchii klas

Diagram: