Upgrading…

Posted by Nucc

At last I’ve upgraded my blog site to WordPress 3.1.3. I checked many blog engines, but since I didn’t want to change the design and get used to new ergonomic options, I just upgraded to the current engine. The previous one was really old, I installed it around 2007, but the upgrade was easier than booting up in Windows. I had some problem with the Watercool theme, but after downloading the newest version the problem solved.
The reason why I decide to upgrade is I want to share more information to the world. I decided the language will be English, despite the fact Hungarian is much easier for me.

Posted in: Uncategorized Comments(1) June 2011


Object Process Methodology

Posted by Nucc

I’ve uploaded my presentation’s slides about Object Process Methodology to slideshare network, but you can also check it here.

Posted in: English Comments(0) April 2011


Balabit Meetup – Ruby Gems

Posted by Nucc

On Thursday I was talking about Ruby gems on Balabit meetup. I would share the presentation with you that you can browse online on Slideshare or here below.



Posted in: English Comments(0) December 2010


Fitting for the occasion

Posted by Nucc

I share with you my presentation that I took today on Balabit Meetup.

Posted in: English Comments(0) October 2010


How to create relationships between models

Posted by Nucc

I took a presentation on June that I forgot to share with you.

Posted in: English Comments(0) October 2010


How to check your location by Google?

Posted by Nucc

Here is a code snippet to fetch your current location from Google in json format.
http://gist.github.com/618191

Posted in: English Comments(0) October 2010


Alexander technika, avagy önmagunk használata

Posted by Nucc

Tavaly év végén mindennapossá vált a napvégi hátfájás, amit az egész napos asztal feletti munka okozott. Esténként nyújtásra vágytam, valaki húzza szét a gerincem, vagy ropogtassa meg, csak legyen végre valami. Orvos tanácsára vettem egy felfujható fitness labdát, de a gyógytornára való járásra hamar nemet mondtam. Őszinte leszek, a francnak van kedve labdákat emelgetni nap mint nap tíz másik emberrel. Egyik nap Györgyi felhívott, hogy kollégája jár egy emberhez, aki egy technikával képes elmulasztani a fájdalmakat. Na mondom, újabb kuruzsló, csontkovács, köszönöm de nem kérek belőle. Azonban volt egy dolog, ami megfogott, Angliából jött, folyékonyan beszéli az angolt és a németet. Abban az időben pont olyan társaságot kerestem, ahol angol emberekkel lehet beszélgetni erről arról, szóval végül kötélnek álltam. Ha nem is jön helyre a hátam, legalább tanulunk angolul, hát belevágtam.

A srácot Alexnak hívják, és egy olyan technikát oktat, ami Magyarországon nem ismert, nyugati országokban viszont egy igen keresett módszer. Az Alexander technikát (a név ne tévesszen meg senkit, nem Alex fejlesztette ki) külföldön egyetemeken oktatják, és több éves tanulás után válhat valakiből tanár. A technikát Frederick Matthias Alexander (1869-1955) ausztrál származású elődóművész fejlesztette ki, aki egy hajszálprobléma okán kezdte magát megfigyelni egy tükör segítségével, mikor is észrevette, hogy tartása a különböző megnyílvánulásaiban változik, ami a hangjának romlásához vezetett. A technikát jelenleg szinészek és táncosok alkalmazzák, ugyanis megtanít uralkodni a tested felett, továbbá aszmás és allergiás embereken is segít, mivel szabadabbá teszi a légzést.


A technika alapja, hogy míg az életben számos dolgot tanulunk, és teljesen elfogadott, hogy csak rengeteg tanulással lehet elsajátítani, például különböző sportok, zene, olvasás, programozás, addig vannak olyan állandóan használt tevékenységek, amik egész egyszerűen csak kialakultak, úgy mint az ülés, állás, járás. A probléma ott kezdődik, amikor valami oknál fogva (napi 12 óra folyamatos számítógéphasználat) testünkben olyan nem tudatos reflexek jönnek létre, melyek valójában kárt okoznak bennünk, viszont mire a szervezet jelez, már a reflexek beépültek viselkedésünkbe, reakcióinkba.

Ülés során hajlamosak vagyunk előre dőlni, a papír vagy billentyűzet fölé görnyedni, amin egy romló látás csak tovább ronthat (láttunk már sokan monitornál hunyorgó embereket). Milyen folyamatot indít el egy rossz testtartás?

Amikor görnyedünk, nyakunk előre billen, a hátizom feszessé válik. A nyak billenésével működésbe lép a hátsó nyaki izomzat is, aminek merevségét szerintem már sokan átéltétek. (A gyúrás segítségével csupán szoktatjuk az izmokat az erőbírásra, így a különböző háterősítő gyakorlatokkal csupán az érjük el, hogy az izomzat ingerküszöbét kitoljuk.) Mivel a hát görbül, a mellkasra nagyobb teher nehezedik, és alapvető feladatát is nehezebben tudja ellátni, vagyis a légzést. Igen, akármilyen furcsán hangzik, a mellkas feladata a légzés működtetése, mely a tüdőt összenyomja (kifújás), majd pedig szétnyitja (beszívás), pontosan ahogyan a tüzet a fújóka segítségével tápláljuk. Ahogy a tűz pislákolni kezd a levegő hiánya miatt, ugyanúgy szervezetünk is fáradékonyabbá válik, ha nem jut megfelelő oxigénhoz, vagyis a tüdő hatásfoka csökken.

Hat óra ülés után elindulunk haza, a görbe hátunkra kapjuk a két kilós notebookal és egyéb eszközökkel felszerelt hátitáskánkat, mely segít a görnyedtség megtartásában. A görbe hát miatt nagyobb erő nehezedik derekunkra, térdünkre egyaránt, vagyis mire hazaérünk nem csak a hátunk, derekunk és térdünk is fáj.

A probléma, hogy hosszú idő elteltével ez a görnyedtség egy reflexként beépül testünkbe, amiben a legrosszabb, hogy úgy kerülünk ebbe az állapotba, hogy valójában nem is tudunk róla, teljesen természetesnek éljük meg. Azonban ez a rossz beidegződés hatással van az agyra is. Azzal, hogy agyunk kevesebb oxigénhez jut, továbbá a fájdalommal van elfoglalva, ingerültebbé, figyelmetlenebbé válunk, és a gondolkozásunk is lelassul (próbálj meg fájó foggal dolgozni!).

Pár hónap fájdalom után fogod magad, és elmész masszőrhöz, aki segít kilazítani az izmaidat, így nulláról indulva újból görnyedhetsz egész nap, egy hétig megint nem érzel semmit, majd második héten újból előjön a fájdalom. Térded, derekad ugyanúgy terhelve van, már 8 óra alvás sem elég, legszívesebben felakasztanád magad egy szögre, csak legyen valami, hogy nyúlj egy kicsit.



Az Alexander technika ugyanúgy megtanít minket helyesen ülni, állni, reagálni eseményekre, mint ahogy egy teniszező megtanul fonákot, tenyerest ütni, vagy egy gyors ütésre reagálni. A gyakorlatok alapvető célja, hogy a beidegződött reflexeket átalakítsa, mégpedig úgynevezett vezényszavak segítségével. Ilyen vezényszó például az “Engedd, hogy a nyak ellazuljon”, “Engedd, hogy nyúljon a gerinc”, melyekhez kapcsoljuk a megfelelő eseményt, például a laza nyakat, vagy azt, amikor a gerinc nyúlik (ezekhez szükséges az oktató, aki tartja a fejet és figyeli, hogy a nyak laza maradjon, illetve megfelelő óvatos mozdulattal nyakunknál fogva nyújtja a testünket). További célja, hogy reakcióinkat képesek legyünk kontrolálni, például ha csörög a telefonunk nem kell rögtön zsebünkhöz kapni, várjuk meg míg kettőt csörög, majd figyelve mozdulatunkat kényelmesen vegyük fel. Minden hirtelen reakciónál testünk izomzata megfeszül, amit ha egy nap többször megteszünk, könnyen feszültséget okozhat.

Kezdetben egy asztalon feküdve mennek a gyakorlatok, ugyanis fekve van legkevésbé terhelve testünk. Később megtanulunk újra leülni és felállni. Annak ellenére, hogy leülés közben a hátizomnak semmi feladata sincs, mégis nagyon sokan használják hátukat, vállukat mind leüléshez, mind pedig felálláshoz, ami ugyancsak merev, fáradt izomzathoz vezet.

Az első hatás durván egy hónap után érezhető, amikor olyan érzésünk van, mintha valaki elkezdene minket energiával tölteni. Nem tudom leírni, az a tipikus jókedvem van, de fogalmam sincs miért eset. 3-4 hónap után, ahogy a test elkezdi használni az új reflexeket, előjönnek fájdalmak a gerincben, ami a csigolyák távolodásával, a gerinc formályának átalakulásával magyarázható, valójában egy olyan érzés, mint amikor becsípődik egy ideg a gerincben, vagyis nem túl kellemes. Azonban ezen átlendülve testünk ellazul, az utcán sétálva a vezényszavak folyamatosan járnak az ember fejében, nyak ellazul, hát nyúlik, vál enged lefele, derék szélesedik, nyak laza, hát egyenes, … . Ahogy testünk egyenesedik, észrevesszük, hogy hat óra alvás is elegendő, emésztésünk javul (a mellkas nem nyomja a gyomrot), figyelmünk erősebb, hangunk szabadabb (a levegő szabadabban áramlik), ami egyfajta magabiztosságot is ad.



A technika igazi hatásához általában fél év elegendő (ez nőknél általában rövidebb idő), de legalább két év szükséges, hogy hétköznapjainkat, gondolkodásunkat teljesen átformálja. A technikát számos művész, író, filozófus, politikus alkalmazta vagy éppen alkalmazza, például Diana hercegnő, Elton John, Robin Williams, Paul Newman, Keanu Reeves, Kurt Russel, Kepes András. Csak egy helyes testtartás, és az ember élete gyökeresen megváltozik. Állítom!



Posted in: Hungarian Comments(0) October 2010


Header files

Posted by Nucc

On Friday we had a short debate in the room with the guys about the role of header and cpp files. I didn’t support to separate unit tests to header and implementation part, because I guess in this case it’s not necessary. Why?

Data types (i.e. classes) have abstract and concrete aspects. We store the abstract aspects in header files (using c++ this is the .h file) and the concrete aspects in implementation files (cpp file). In the header we define the data type’s signature, export interface (public part of a class), parameters, methods, properties. Using C this kind of approach is shown better because header files can be separate from the implementation well, while in C++ sometimes you must store implementation specific properties in the header (usually in the private space).

The more information we define in the header file in connection with the implementation, the harder to change the implementation later without changing the header file. It can be a problem in a complex and huge software, where changing something in a deeper layer can result more hours compilation time.

In my example I show you an implementation of the stack data type. Stack is a very simple type, we can push elements to it, pop these elements out and get the number of the stored elements. The stack can be implemented in different ways, we can use vector or linked list to make it work.

In this example I’m going to store integer value in it.

  1. #ifndef STACK__H
  2. #define STACK__H
  3.  
  4. class Stack
  5. {
  6. public:
  7.     Stack(const int size);
  8.     ~Stack();
  9.  
  10.     Stack&  push(const int value);
  11.     int     pop();
  12.     int     size() const;
  13.  
  14. private:
  15.     int   *entries;
  16.     int   stack_size;
  17. };
  18.  
  19. #endif

There’s a problem with this header file. Using int *entries assumes we want to use array to store values. However it’s good for shorter stacks, since handling larger stack is not so efficient, because we have to allocate in the memory the whole size of the stack at the beginning. Later, when you want to change it to linked list to it can be more efficient in memory consumption, you must recompile every part of your software that includes this header file.

Using another structure we can change very easy to different implementation without to compile the software again. Considering the next change:

  1. #ifndef STACK__H
  2. #define STACK__H
  3.  
  4. struct _stack_impl;
  5.  
  6. class Stack
  7. {
  8. public:
  9.     Stack(const int size);
  10.     ~Stack();
  11.  
  12.     Stack&  push(const int value);
  13.     int     pop();
  14.     int     size() const;
  15.  
  16. private:
  17.     _stack_impl *impl;
  18.     int         stack_size;
  19. };
  20.  
  21. #endif

stack_impl structure gives opportunity to define properties in the cpp file. Stack_size is a property of the stack, so it can be in the header file.

In the cpp file that’s using linked list, the stack_impl looks like this:

  1. struct Entry {
  2.     Entry   *prev;
  3.     int      value;
  4. };
  5.  
  6. struct _stack_impl
  7. {
  8.     Entry     *first;
  9.     Entry     *top;
  10.     int       size;
  11. };

and with array:

  1. struct Entry {
  2.     int      value;
  3. };
  4.  
  5. struct _stack_impl
  6. {
  7.     Entry *entries;
  8.     int    top;
  9. };

The implementation with linked list (stack.cpp) is:

  1. #include "stack.h"
  2.  
  3. struct Entry {
  4.     Entry   *prev;
  5.     int      value;
  6. };
  7.  
  8. struct _stack_impl
  9. {
  10.     Entry     *first;
  11.     Entry     *top;
  12.     int       size;
  13. };
  14.  
  15. Stack::Stack(const int size)
  16.     : stack_size(size), impl(new _stack_impl)
  17. {
  18.     impl->first = 0;
  19.     impl->top   = 0;
  20.     impl->size  = 0;
  21. }
  22.  
  23. Stack::~Stack()
  24. {
  25.     delete impl;
  26. }
  27.  
  28. Stack&
  29. Stack::push(const int value)
  30. {
  31.     if (stack_size == impl->size)
  32.         throw "FULL";
  33.  
  34.     Entry *entry = new Entry;
  35.     entry->value = value;
  36.     entry->prev  = impl->top;
  37.     impl->top    = entry;
  38.     impl->size++;
  39.     return *this;
  40. }
  41.  
  42. int
  43. Stack::pop()
  44. {
  45.     if (impl->size == 0)
  46.         throw "EMPTY";
  47.  
  48.     Entry *temp = impl->top;
  49.     impl->top = impl->top->prev;
  50.     int value = temp->value;
  51.     delete temp;
  52.     return value;
  53. }
  54.  
  55. int
  56. Stack::size() const
  57. {
  58.     return impl->size;
  59. }

And the implemantation with array (stack2.cpp)

  1. #include "stack.h"
  2.  
  3. struct Entry {
  4.     int      value;
  5. };
  6.  
  7. struct _stack_impl
  8. {
  9.     Entry *entries;
  10.     int    top;
  11. };
  12.  
  13. Stack::Stack(const int size)
  14.     : stack_size(size), impl(new _stack_impl)
  15. {
  16.     impl->entries = new Entry[size];
  17.     impl->top = -1;
  18. }
  19.  
  20. Stack::~Stack()
  21. {
  22.     delete[] impl->entries;
  23. }
  24.  
  25. Stack&
  26. Stack::push(const int value)
  27. {
  28.     if (impl->top+1 == stack_size)
  29.         throw "FULL";
  30.     impl->top = impl->top+1;
  31.     impl->entries[impl->top].value = value;
  32.     return *this;
  33. }
  34.  
  35. int
  36. Stack::pop()
  37. {
  38.     if (impl->top == -1)
  39.         throw "EMPTY";
  40.     return impl->entries[impl->top–].value;
  41. }
  42.  
  43. int
  44. Stack::size() const
  45. {
  46.     return impl->top+1;
  47. }

Using this somewhere (let this be the main.cpp), we can call the stack’s methods:

  1.  
  2. #include <stdio.h>
  3. #include "stack.h"
  4.  
  5. int main()
  6. {
  7.   Stack stack(5);
  8.   stack.push(2);
  9.   stack.push(3);
  10.   stack.push(4);
  11.   printf("pop: %d\n", stack.pop());
  12.   printf("pop: %d\n", stack.pop());
  13.   printf("size: %d\n", stack.size());
  14.   return 0;
  15. }
  16. </stdio.h>

Create the object files using g++:

  g++ -c main.cpp
  g++ -c stack.cpp
  g++ -c stack2.cpp

Finally we create two different executable code:

  g++ stack.o main.o -o linked_list
  g++ stack2.o main.o -o array

So for unit testing I would create only a cpp file and put the class declaration and definition there inline, because it doesn’t have any implementation code that we want to hide. I guess the unit test be simple, perspicuous and brief, so guys, don’t separate it…

Posted in: Uncategorized Comments(0) August 2010


Bundle error

Posted by Nucc

Using bundler it throws the following error after running bundle exec rake spec/Library/Ruby/Gems/1.8/gems/bundler-1.0.0.beta.5/lib/bundler/shared_helpers.rb:128:in `bin_path': can't find executable bundle (Gem::Exception)I’ve tried to find a nice solution for the problem, but finally I made a very dirty workaround to make it work. I created an executable bundle file in [bundle_dir]/bin and now it’s work properly.

Posted in: English Comments(0) July 2010


Párhuzamos rendszerek modellezése OPM segítségével

Posted by Nucc

Posted in: Hungarian Comments(0) June 2010


« Previous Entries