My Life As a Developer

Another year has passed away

2012-01-12T08:41:00.001+01:00

Today is my 31st birthday and exactly one year we havestarted our current project. We are nearing its first major release and areworking around the clock to finish it.

In the last year I’ve gotten some experience in largeproject running with a geographically distributed and culturally diverse team.I’ve also learned some valuable lessons regarding the art and craft of softwareengineering:

Write technical documentation as often aspossible as short and concise as possible, it will save your ass often as notwhen you least expect it
You have always the time to unit test andrefactor your code, it will save your ass down the line
Be open and clear of your expectations, expectto repeat them often and follow back on each critical item
Love your testers, respect your testers, theyare your most valued and greatest assets which make your life easier and makethe project better
Know your architecture, plan your architecture,and expect to repeatedly repeat it to others in the team
Trust your project manager, he will make yourlife also easier and will make the project better if you let him
Trust your team, grow your team , only then yourjob will get tolerable
Expect to iterate often and always on each itemof your daily job
People forget, people are people and aren’tperfect
Trust, respect, understanding go a long waytowards a completed project
Discuss issues not people or span wars

There is one valuable lessons which I got to understand:

If someone is a value waste on your project andcontinuously responds negatively to feedback and doesn't grow cut him usswiftly as you would an intruder in your home threatening you and your family becausethat person is doing right that to your project, your team and your self

And finally:

Time is your most valued commodity, spend itwell, manage it well.
Find time to read, experiment and learn. Toremain effective you must grow even under the most greatest pressure and timeconstraints.
In time of greatest stress and overworking findtime to be with your family because they are your most greatest ally in the faceof adversity and your most greatest support mechanism, if you turn your back onthem they will turn on you.

Coding Dojo Pula "Agile Architecture" Retrospective

2011-12-14T21:41:00.002+01:00

This was the first time I held the same talk consecutively in two different group. Today I held the "Agile Architecture" talk on the monthly Coding Dojo Pula meetup. There was really quite a crowd, eight ten people, all professionals who started asking questions and discussing topics from the start.
I really like when there is an active discussion during a presentation.
From this presentation and the one before I've learned some lessons which I think are worth noting:

Stories and concrete examples are worth more then bullet points
Break things into multiple slides with real world examples for each slide
Be funny and open, use allegories

A couple of slides which I think are the most fun and illustrate the point:

The only thing I'm sad that no one from the local university deigned to show. Either the talk was to complex or people didn't bother. Really a shame, since we put a lot of effort into marketing the thing.

Probably need to schedule somewhere a more basic, begginer level talk.

EDIT 16.12.2011
Andrej Pintar sent a few of his photos he made at the talk. I'm adding them here to show the mood of the place which really great. On the first photo, on the left me is my colleague from Novatec Dejan Dragaš.

13 IT PRO Agile Architecture Feedback

2011-12-06T20:58:00.001+01:00

Wow, the "Agile Architecture" talk I held for the 13th IT PRO community meeting in Pula went really well. There were around eight people from all walks (some developers, some IT guys and some unaffiliated students) . The talk lasted around an hour and a half with some talk in the between. For half an hour after the talk we had a discussion around the topic.
It was really wonderful. I got a chance to talk about a topic I really like and meet some new people. To boot I was invited to repeat the same talk on the monthly Coding Dojo (Pula) event which will be held on December 14th at 18.30 in the Hacklab club in Rojc.
Some images from the event courtesy of Viktor Ezgeta.

I would also give thaks to the prof. dr. sc Vanja Bevanda from the University of Pula which kindly encouraged some of her students to attend the talk. I'm really glad I could talk to the student population of Pula and would like really to have more students on my talks.

Agile Architecture

2011-11-24T22:47:00.001+01:00

There are two core principles to architecture in an agile environment which worked for me real good :

Document only small slices of the system one at a time at the time you need them
Be as specific as you need without going into too much details

A typical business system, one that is software intensive, is a really big and complex. When developing one such system it is impossible to document everything at once. What I do is to create a general corner stone architectural specification that defines the core architectural areas and principles of the system, a reference architecture around everything will be build and then create a series of small architecture documents (Architectural Notes or Memos) which are slices of architecture targeted at a specific system view or functionality which is developed for a first type. Architecture is a generalized specialization so such documents must convein all the information one needs to implement the designed architecture but not specialized too much in order prevent the multiple variants the same architectural areas can have.

It is important not to design to early , but at just the right time. The goal is reduce the amount of time passed between the design creation and the implementation and to focus the architectural effort on the architecture which is need right at this moment of the currently developed sprint.

Designing and documenting and architecture slice is one part of the whole problem, even when you create such a design at the right time with the right amount of detail the majority of the subsequent effort is spent communicating and reviewing the architectural implementation. If the implementation part is done by the architect and the senior team (such as the core of the system) a significant part of the architects effort is spent disemminating through the development team (or teams) the culture and the ideas required by the architecture design.

Software is plastic, and programming is flexible. Event the most pure architecture can be twisted, scratched and mutated in something recognizable. The best way to insure an architecture to survive is to set up much of its essence in code and build tools which guide the developer down to a certain way of solving problems (which has its own problems , which is why architecture should be approached slice by slice and nothing is one hundred percent fixed in stone and unchangeable) and to integrate its core principles into the development culture of the development team which will ensure it gets adopted by every new team member.

Lots of teams make use of the shared tribal team identity as the only reference how things should be done by the project. This practice is spurned by software engineers, and with good reason, because software cannot be developed with tribal memory and shared culture alone, documentation must exists, tests and build tools must exists in order too enhance the human falabilities to which we all are susceptible : short memory, illness, death, holidays and leaving for a better opportunity. In its essence agile development values people over processes and interaction over rules, it doesn't mean no documentation or processes should be in place. We all are humans, and by definition fallible. Agile architecture should strive to reduce the human error by documenting and the essence of small specific slice of the system such as : grid architecture, background process architecture, form architecture, repository architecture, commenting system architecture etc.

Short is better for software developers, people will more eagerly read a ten page document then a one hundred page document. They will read it more often and learn more from it. It is also really easy to communicate a short document then a large one. Also, less errors are introduced in a short design then in a large one.

The agile manifesto reads as follows:

Individuals and interactions over processes and toolsWorking software over comprehensive documentationCustomer collaboration over contract negotiationResponding to change over following a plan

The agile manifesto clearly indicates that things on the left are more valuable then things on the right, but things on the right have a value. They are second to the things on the left, people have more value to software development over processes and tools, working software is king over documentation. But a balance must be made, without a documentation who will understand what is being developed? Without a set of class diagrams that show the core architecture for a subsystem from top to down and text describing it who will understand the code without someone guiding him through?

Each day when I start my work I say to my self :

Your job is to enable other people to do their job better

I'm a technician and my focus is technology and the development team that works with it. I'm a software engineer by trade and a craftsman by soul and I really think only three things are important in software development:

working software, people and communication

For me agile architecture is that which maximizes those three things.

13th IT PRO Meetup: Agile Architecture

2011-11-23T21:42:00.001+01:00

On Monday 29th 2011 at 19.00 o'clock I will hold a talk for the IT PRO User group on the topic of Agile Architecture. This is something I'm very hot for right now since I get to practice it for the last six months on a very large project with a geographically distributed team.
I will focus on my experiences and what worked best and what didn't in order to present a practical take on the topic.
You can register for the event here , there are only twenty free slots for the talk so please hurry if you want to hear me speak.

ARM Assembly Language

2011-11-09T22:57:00.000+01:00

I've started reading a great book about the ARM assembly programming language. The book can be found on-line here and is a web copy of the same book published in 1987.
Why I'm reading this twenty year old book for an assembly no sane .NET or PHP developer heard about (sure someone did, but the meat and bone of the developer population I mingle in cerentanly didn't hear about it)? The reason is really simple.
I need to learn ARM assembly programming so I can understand the code written in my Operating Systems handbook of the undergraduate Computer Science course I enrolled this year. The book is full with ARM assembly examples how different parts of a system function and I really need to know ARM syntax to fully understand the problem space. The book is of course the venerable "Operacijski sustavi" handbook from FER (2011 edition).
It is not a bed book, but its thick with text which sometimes isn't written well (I'm a published fiction author translated in four languages and published on three continents so I know when something isn't written well, mark me) and requires two readings to understand the rich and very complex sentence structure which could be written more simply if the author actually cared about the reader.

Overtime, dear overtime

2011-10-22T22:50:00.000+02:00

Everybody knows that gut wrenching feeling a person feels when he or she is told to work some overtime, expeciality if its for an undefined period of time. You, me , everyone had that feeling at some point or other. Overtime is often, and justly, negatively perceived in our industry. Yeah, you ship the product on time the client is happy, the management is happy, all those nifty forms and grids are visible and working (sort of) and the load of defects and technical debts lurking underneath are just ready to pup some one sits the next day on the product to test it.

I'm working on a large project. And I had to do large amount of overtime on it. The deal was that the majority was applied voluntary during the time the majority of the team (around eight people) were working normal hours. And I felt really great about that. I had time to refactor several times the code a wrote (I was working on the core of the middle tier system so my refactoring paid several time since we had afterwards a really small amout of defects on the core of the system) , I created Architectural Notes for system features I wouldn't have the time to do during my regular hours, I wrote unit tests and developed system features which were badly needed on the project and I grew and improved my self, the project grow and my company grew and it was all voluntary on my own time and my own schedule. I had time for my regular job, my family and my voluntary overtime.

Chicken and Pigs, a chicken perspective

2011-10-19T22:51:00.000+02:00

I was reading the Scrum guide earlier today and I've read the "Chicken and pig" story. I wasn't a new story for me since I've read it a few years earlier when I first encountered Scrum (I'm just refreshing my memory). For a long time since that first reading I tought and talked about as envisioning my self in the role of the Pig, as someone who is commented to the project and how I should not allow chickens to dictate the way the project is developed (to some degree, even chickens have their powers to make things happen). But what if I'm the chicken on some project? How should I behave?
I think respect is the most important thing. When I'm a chicken I should respect the Pigs work and try to help them in the way they will let me without causing problems for them now or down the road. It is easy for chickens to say things, but is hard pigs to live with them.

How to change SVN password in Zend Studio or Eclipse

2011-09-29T12:32:00.001+02:00

The intertnet is full of blog posts how to change the SVN password in Eclipse or Zend Studio. Unfortunatelly nothing I found on the interet worked. I've deleted the eclipse .keyring file and deleted the svn.auth folder.
Suprisingly the solution is really simple:

1. Change the perspective to "SVN Repository Explorer".
2. On the repository list right-click on the repository and then click on "Location properties..."

Thats it!

A dialog will popup, and right on the first popup you can change your SVN username/password combo.

Working with a distributed team

2011-07-16T18:13:00.000+02:00

I'm currently working as a technical lead on project with a distributed team. It is not the first time I'm working with a distributed team, but it is a the first time the team is so big. We currently have people working in five cities across three countries :

Labin, Croatia
Pula, Croatia
Slavonski brod, Croatia
Beograd, Serbia
Skoplje, Macedonia

You'd think it would be hard to work with such a distributed team, which totals up to ten involved people but it is not.

I really takes a lot of communication, some organization and proper tools. The two basic tools are :

Skype
Teamveiwer

There are two types of skype communication : written and verbal. The written communication is for large meetings and team notices. We have created a team chat where all team members can share information and where all the big meetings occur.

The most important meeting is the daily standup which is done exclusively in written form and can be done in under ten minutes. The trick is for each participant to write her daily report five minutes before the meeting (which is at 9.00 o'clock each day). The report is written using this format:

YESTERDAY:

- #1 thing done yesterday

- #2 thing done yesterday

- #3 thing done yesterday

etc.

TODAY:

- #1 thing will do today

- #2 thing will do today

- #3 thing will do today

ISSUES:

- issue #1

- issue #2

This enables us to track the project progress, to catch early important issues and problems. The team stand-up is usually followed by an hour and a half of one on one vocal meetings where those daily issues are addressed and solved or kicked up the ladder.

Team viewer is another great tool, it works both on windows and linux (which is great since we have both in our team) and enables one or more people to virtually sit at the same machine and work which is great for doing problem solving, peer reviews and distributed pair programming.

One great tool I discovered is the Architectual memo or note, which is a sketch with UML diagrams and some text describing a architectural solution of a part of the application (Grid system, Form system, auto-complete system etc). It takes me about and hour or two to write once I get the idea right and then I can send it to a team mate discuss it with her and then watch it being built.

Night time shadows on open sand

2011-03-03T22:51:00.000+01:00

I feel as in a sex fevered pipe dream of polarized dragons chasing mind shadows across a digital horizont of conflicting diagrams and clashing systems.
My mind is playing depth perception dreams on me. Hand quivering, extended forwards, I cannot grasp what is in from of me. It is as if its beyond and the across my terrestrial self at the same time, as if it started leaving in an non-euclidean space time continuum, where regular rules of out earthly domain do not matter as innocence proves nothing in a gaming future of constant, hateful warfare.
It is the day of surprises and ending and endless driving across the bare Istrian wasteland of rolling hills and idyllic, void filled, villages and townships.
After two hundred and some kilometers I can proudly and tiredly say that I had three presentations today in two different counties in two different regions and two different towns.
The first two were an introduction in Functional testing of web applications with Selenium 1.0 and a sneak peak of the web driver run Selenium 2.0 (which I wrote in Java on Ubuntu). The second was a more advanced presentation of the same topic where I've generated .NET unit test form Selenium IDE and then executed them inside MonoDevelop again on Ubuntu with NUnit and the test worked. Yey me.
The third presentation was the most taxing of all. In Rijeka for the monthly SQL/Dev user group meeting at the Maritime University of Rijeka I've held an introductory session about WCF RIA Services. In all I think the sessions went well. I've made some mistakes with my slides which I will correct for next time and the low point was my virtual machine which literally broke and wouldn't function right so my code example didn't really show in good light.
There was around twenty people in the room and I had a really good time. I've held a mixed presentation where I talked from slide and draw ad hoc UML diagrams on a chalkboard with sliding panels. I've talked with the audience and there was really a lot of questions which I really liked.
Latter we went to an old fashioned, communist style, drinking place where we had a blast talking with each other.
So long my dear fellows, sleep awaits my tired, tired mind.

So long .NET

2011-02-20T12:43:00.000+01:00

Its been a long time since I've written something here. A lot has changed since my last post. It was generally personal stuff that occupied my mind during that time. Business wise nothing new on the horizon.
I've started learning Java again. It is a long time dream of mine to be a Java developer and since I'm about making significant changes in my life I decided to follow my dream.
.NET is a great and cool platform. The IDE is fantastic and the speed the framework is progressing is astounding with the barrage of cool stuff is overwhelming. Recently I've learned WPF, Silverlight, RIA Services and Entity Framework. All cool stuff. But what always bugged my Mikes software it is that you need a whole lot of cash to develop and deploy your solution.
I've always been an open source enthusiast. The ability to develop software with free tools always sided good with my 'have not' upbringing.
So I started relearning Java. And its is progressing really smooth for now since the syntax is so similar to .NET.
On the other note I will conduct a RIA Services for begginers presentation in Rijeka (Pomorski fakultet) on the March 3rd at 17.45.

Project learning and Book learning smackdown.

2010-11-02T21:51:00.000+01:00

During my carreer as a developer I came to realize the learning benefits one gets from doing projects, e.g. solving real life project and the benefits one gets from applying structured learning practices when learning a topic.
Let me explain how I learn first.
Generally once or twice a year I make a sorted list of technologies or topics I'm interested in learning. The topics are sorted by priority and how hard are they to learn. And then I start learning those technologies by moving from he the first item on the list to the last.
When I've picked up a technology to learn I usually by a book or two about it and then I start reading the book while sitting on my computer and working all code examples. This takes a lot of time since I work full time and also have a family but it gives me hand on experience with all aspects of a technology. Unfortunatelly this only gives me some experience, not true proficiency. True proficiency comes form working six months or more in a technology solving real life problems and learning how the technology works in the field, what are its problems and what are the best patters for its utilization.
Projects are really good at being proficient with common tasks in a technology, but do not delve deep in all use cases and technological aspectes of a specific software solution being applied. In some cases I relied only on my project learning to get a grasp on a technology and came completely stack when faced with something new and different for which I didn't have the necessary theoretical background which I would had if I took the time to learn the technology properly.
With book learning I get a real good foundation in a technology but lots of it I don't get to use during the technology life time, so the learning effort is kinda wasted since I don't get to use directly that knowledge practically. On the other side the wide knowledge base usually gets me pretty fast out of tight spots others find impossible to surpass.
In my opinion in order to be a good sofware developer one must do both types of learning :

Project learning , learning a technology by doing a project in it.
Book learning, learning a technology by following a structured learning mechanism such as a book or reference manual.

The real trick is to find a balance between both.

Model/UI Model/UI Controler javascript patter in short

2010-10-31T12:37:00.000+01:00

I've watched today an interesting presentation about functional design patters and I wanted to share it with you my dear and loved reader.

http://www.infoq.com/presentations/Functional-Design-Patterns

Functional programming and functional languages started interesting my from the moment I grokked Javascript. Javascript is an interesting language that blends, in my opinion, good sides from both the object oriented paradigm and the functional paradigm.

Lets face it. Javascript is used mostly for dynamic GUI's on the web and on the mobile platform. User interface events are behavior(action oriented) and the functional style of programming can be very useful in such and environment with some good speed gains. But also the DOM or the UI is an object rich environment , full of entities, relations and etc. Not to mention custom POJSO's (Plain Old Javascript Object) indicating varius states our screen can take or coordinating the behavior of other objects in the same screen.

I generally do something like this. First I define my screen entities, those objects that correspond to specific entities which live happily on my screen:


function Person(name, age, sex)
{
  this.Name = name;
  this.Age = age;
  this.Sex = sex;
}

I will then link those two entities to corresponding UIEntities. UIEntities are those POJSO's that group a set of DOMElements and coordinate their UI logic in respect to the current state of the associated Entity object.

For example:


function PersonUIModel(element,person)
{
    this.Element= element;
    this.Name = this.Element.find("input.person-name");
    this.Age = this.Element.find("input.person-age");
    this.Person = person
}

PersonUI.prototype = {
  validateRequired:function(textBox)
  {
      if (textBox.val()=="")
      {
         textBox.css('border','1px solid red');
         return false;
      }
     
      textBox.css('border','');
      return true;    
  },

  Bind:function()
  {
     var object = this;
     //Populate values
     object.Name.val(object.Person.Name);
     object.Age.val(object.Person.Age);
     
     //Bind events
     object.Name.change(function(e){
        if (!object.validateRequired(object.Name)) return;
        object.Person.Name = object.Name.val();
     });
     
     object.Age.change(function(e){
        if (!object.validateRequired(object.Age)) return;
        object.Person.Age= object.Age.val();
     });

     
  }
}

The previous code piece needs some explanations. First for everything UI related I use JQuery, so all examples here that touch the DOM will make use of its innate capabilities.
The constructor of the PersonUIModel object gets two values an JQuery object named Element which corresponds to the actual HTML rendered with the page and attached to the PersonUIModel for controlling. The second argument is the actual Person entity binded to the HTML through the PersonUIModel object.
For ease of use I've extracted the two actual controls I'll need in separate fields of the PersonUIModel object.
The Bind method is used to start the actual two-way databinding between the Person entity and the HTML associated with the PersonUIModel object. Nothing fancy here except for two things.
Just on the start of the Bind method the this indentifier is associated with the object variable. This is done because of the change handlers latter in the code the context of their anonymous methods relies on the PersonUIModel object. If I would make a call like this in the Age.change event handler :


this.Age.change(function(e){
        if (!this.validateRequired(this.Age)) return;
        this.Person.Age= this.Age.val();
     });

I would receive a nice, fat, juicy error indicating the the validateRequired function doesn't exits on the DOMElement. The 'this' inside the event handler actually points to the textbox associated with the Person.Age property (not the JQuery object but the actual DOMElement). But with the power of closures I magically convert my PersonUIModel 'this' to object (or any other variable name) and everything is fine).
The PersonUIModel objects binds to a html code like this:



<div class='person'>
Name: <input class='person-name' type='text' />
Age: <input class='person-age' type='text' /></div>

Now we are left with the question who creates the PersonUIModel instance and binds it to a Person instance and the related HTML code. This is the role of the PeopleUIControler a specific class that coordinates the lifecycle of PersonUIModels.
The PeopleUIControler has the following roles:

Finding or creating the appropriate DOMElements on the Screen.
Loading and Saving Person models.
Binding Person models to DOMElements through PersonUIModel instances.

This means the the Person model is totally decoupled from the UI in which it is located. The PersonUIModel knows only of its little piece of HTML code and its Person model and nothing else. This means that the PersonUIModel doesn't know about other PersonUIModel's on the screen nor does it have any impact on the HTML outside its little realm.

The PeopleUIControler will look like this:

function PeopleUIControler()
{
      this.People = [];
      this.PeopleUI = [];
}

PeopleUIControler.prototype = {
  btnSave: null,
  btnLoad: null,
  pnlPeople: null,
  Load:function(){
      //Ajax loading ... loads a bunch of Person entities
      this.People = bunchOfPersonEntitesLoadedThroughAjax;
  },

  Save: function(){
     for(var i=0;i < this.People.length;i++)
     {
         var person = this.People[i];
         //Save the person through AJAX
         //....
     }
  },
  Bind:function(){
     var object = this;

     this.pnlPeople=$('.panel-people');

     this.btnSave=$('.person-save');
     this.btnSave.click(function(e){
        object.Save();
     });

     this.btnLoad=$('.person-load');
     this.btnLoad.click(function(e){
        object.Load();
     });

    //Load entities synchronously (just for the sake of the argument)
    this.Load();

    var html="<div class='person'>
Name: <input class='person-name' type='text' />
Age: <input class='person-age' type='text' /></div>";

    for(var i=0;i < this.People.length;++){
      var personUI = new PersonUI($(html), this.People[i]);
      personUI.Bind();
      this.PeopleUI.push(personUI);

      this.pnlPeople.append(personUI.Element);
    }
  }
}

The code for the PeopleUIControler is similar to that of the PersonUIModel. The controled has two methods Load and Save for loading and saving Person entities to a permanent source and a Bind method which binds all elements. The PeopleUIControler ties it self to an html structure that sports a panel for PersonUIModels and two buttons one for loading and saving. When first loading PersonUIModels each model is binded to a generated piece of html and then the same html is appended to the PeopleUIControler panel. The final html code used by the PeopleUIControler would look like this:


<div class='panel-people'></div>
<div>
<button class='person-save'>Save</button>
<button>load<="" <="" button>="" class="person-load" div>=""></button>

Went to Zagreb and maybe lived to tell the tale

2010-10-24T16:33:00.000+02:00

I went to Zagreb today with my colleague Hrvoje Hudoletnjak to the monthly WebUG meeting. There were two topics:

Lightswitch by Gjuro Kladarić, FFZG
Hybrid Mobile Applications by Matija Šmalcelj, Pet minuta

I was really excited to go there. It was an opportunity to learn and to network with some like minded people over the mountain (Istra where I live is separated from the rest of Croatia by a mountain named Učka).
What I was looking for is more Lightswitch education. I just started some Silverlight development my self and the idea of Lightswitch intrigued me. There are a lot of applications being developed in pure code today which could just easily be developed by a Lightswitch-like tool.

In my opinion developers tend to be to high horse about development practices and techniques. The majority thinks if something wasn't developed in pure code, using the hottest techniques and frameworks its something to keep quiet at leat or at worst to be ashamed of.

Latter experience taught me some lessons. For the majority of LOB applications nobody really cares how we do it except us. Now, I'm of the opinion that we should care how we do what we do. But I also think that we can do a good job by not being such asses about the way we do things regularly. For somethings there is no need for unit tests, for somethings database design is just enough. Not to mention that not everything needs to be a three layer architecture and that some forms with code behind and a data store are the proper solution for some LOB applications.

The Lightswitch presentation was purposefully short. It reminded me about Microsoft Access and my faith in the tool just sunk. It seems it wasn't really what I hoped it would be. The presenter repeatedly pointed out that this tools isn't for the regular developer but for fairly advanced administration personel. Ok. I can achieve more with Drupal, CCK and Views.

The second presentation, about Hybrid Mobile Applications was really interesting. The presenter works in a company specialized in social networks and mobile applications and he illustrated the business case for developing Hybrid Mobile Applications, e.g. web applications written for webKit and run inside a native wrapper in order to give an illusion of a native iPhone or Android app.

Whats the deal here? If you want to write a cross platform mobile app you need to write a separate implementation for each platform. One in objective-c for iPhone, one in Java for Android and so on. With Hybrid Mobile applications you just write (or take an open source one) native wrapper e.g. an application that internatlly starts the browser as a control and that resizes its self that all browser specific features are hidden from the screen thus leaving the page content. The real application is written using webkits HTML5 capabilities CSS3 animations, Javascript local storage, geolocation etc.

The application runs inside a single html page and the entire source code is shipped as single build with the wrapper thus by just changing the wrapper one can ship the same code on any native mobile application. The best thing is that the user doesn't know he is using a web application.

The most important thing is to develop the application with no connectivity in mind, which is really easy by the existence of the local storage api that gives to the developer a full fledged relational database to use.

The development is really cheap also. The developer needs a webkit browser (Google Chrome or Safari) an IDE (Eclipse comes to mind) and a couple of mobile frameworks to ease the development effort.

Here are a couple of links given by the presenter:

The presentation gave me a couple of ideas about some project I might do:

A mobile Mantis Bug Tracker interface
Hmm thats all just one ... :(

Of course I still have some learning to do about WPF 4 and MongoDb. I will wait till I learn those with other activities.

I'm too old for this

2010-09-29T07:59:00.002+02:00

I worry to much I'm going to wash out due to my age. I'm currently, at the glorious time of writing this post twenty nine years old and by the Lords grace I'm not a year older. And I worry I'm to old for this job. This makes me really unhappy since I have a small boy and I wonder how I'm going to provide for him since I'm no good at anything else (well I'm mediocre at a lots of things, but that is nor here nor there so we are not going event to discuss it) and this is all I have for now.
I don't know a lot of developers older then me, a few older then forty and none older then fifty. I really do not know what is my future career plan. I generally planned to gradually move to an architecture design position, since I'm naturally inclined to it and its not a development heavy thing. As I grow older, and as people grow older, we cannot learn as easily and as much as we could before. New technologies emerge and if you want to stay in this job you need to spend extra time learning them at your own. But later I just can't mange to force my self to find the computer time for it. Sure I read books and blogs, and pay really carefully to code examples for technologies I'm intereseted. Curretnly I'm reading WPF 4 Unleashed by Adam Nathan and Patterns of Enterprise Application Architecture by Martin Folwer, plus I've read the entire MongoDB on-line documentation. But reading is not enough, you got to feel the code bellow your fingers. You just got to. And I really don't to much.
During my holidays I was to washed out to do anything and I told my self its OK you need to rest. But when I got back to work it continued. Sure I started some small coding on the side for learning purpose, I started reading books and blogs and watching presentations but thats just not enough without coding.
What is going on with me you wander. I think a description of my life after work is in order. When I'm finished working I'm with my family helping with the kid, doing house chores the whole nine yards. I put the kid to the bed and around ten o'clock in the evening I'm done with everything. I then go to eat my dinner (yeah I know its kinda late for that, but thats life) take a shower and I'm free to do as I like. I so want to do some coding but when I just think of sitting in from of my computer, my internal will power just crumbles. So I just watch a TV show or read a book. Very depressing, and very unhappy like for me. And then I start to wonder, this is my age doing this to me. Before I didn't have problems with this. Before I could do this all night old. I'm twentynine years old and I can't muster the will power to do this everynight, whats going to happen in ten or twenty years. How I'm going to learn Java or Erlang, or any other technology I'm going to need?
I just don't know and I'm really not happy about it.

The shock of it all

2010-09-28T11:28:00.000+02:00

Once upon a time when I was 'yay' high (shows to his head, indicating it was very recent) I started writing Selenium tests to test the UI compoenents of my ASP.NET application. As you may know ASP.NET screens are notoriusly not easy to test, expecially if you are lazy (side note: you can extract much of you ASP.NET server side logic in separate classes whithout ties to the ASP.NET application service suing the Class Method pattern.) and the only think a poor developer can do in order to test them (I'm not going into the not testing it at all option or just 'my clicks are enough attitude') is to write some good old UI automation tests.
There is nothing wrong with UI automation tests, mind you, I think they are greate since you are sure you've tested the final integration of your product as shown to the user. What I find appaling is the customers reaction of seeing such tests executed.
Let me tell you - and no, pleas, do not hold your breath - they are blowed away. Amazed. Shocked to the core how good they are. Screens flying, textboxes filled, data showed in grids, filtered and etc. The whole UI testing nine yards. And they want more, they want to start using that in their own projects. It is a presentation ass kicker.
And then we start our fivehundred or more unit-test/functional test suite that executes under a couple of minutes testing almost everything in the application and they are emotionally dead as fish. Oh , its nice can we talk about deadline issues now, please? Right.
I have nothing more to say. I'm appaled. Well, I was anyhow when I was 'yay' high (shows to his head, indicating it was very recent).

Mocking real outside dependencies

2010-09-27T12:37:00.000+02:00

In a project a while back I realized something about mocking and unit testing. In that project I tried mocking every dependency a object could have. The result was that I could write unit-tests for those objects really fast, and that I could verfy their logic very easily. That was all in the spirit of unit testing.
But something kept me nagging, I though that I wasn't getting enough values from my unit tests. Then I started doing functional tests on my services. Nothing was mocked, since the goal was to test the entire stack. Soon as I wrote a couple of tests defects in my code bellow started poping up. I fixed them and felt really good.
I though back what started me thinking that mocking everything was such a good idea. Well I worked on project where my front end integrated with a web services middle tier and I spend countless hours overtime detecting problems that originated from those services while my code worked fine. I wanted to isolate that big outside dependency so that horrible story would not repeat again.
True to my self I just went to the extreme side and mocked everything. Now, if i change the behavior of one class I will not see what other classes are also affected by the change until I go directly to those classes and change the expected behavior of my changed class mock. This is a problem I have no intention to repeat again.
My new golden rule is : "Nikola, mock only real outside dependencies like web services, databases and the like not your core system objects. It will make you happy."

Unit Test pattern: Define once, recreate every time

2010-09-16T19:28:00.048+02:00

"Define once, recreate every time" is a unit-testing design pattern where all outside dependencies and their default return values of the class being tested are defined once, and then recreated every time a different test is started.

When unit-testing classes which have a complex dependency matrix we use faking a lot. We create fake objects, mock or stubs, we define their behavior in respect to the needs of the test. We need to do that for every test. Sure when a common pattern emerges, we create helper methods in order to remove duplicate code. Sometimes we need to have a lot of these helper methods, sometimes we need none and are happy to create are dependencies manually inside each test method.
When unit testing objects those outside dependencies are not really important. How they behave is not important. What is important is how our logic of the class being tested behaves based on the conditions we set for it.
The main proposition of the "Define once, recreate every time" unit-test pattern is that when defining each dependency there is some common code which needs to be written only once, and there is also a common behavioral state which also needs to be defined only once.
In this pattern all dependencies and their return values are defined as common members of the test fixture, e.g. testing class. Those dependencies are created each time a new before a test is being run in the SetUp method of the test fixture. This will ensure that each test, no matter the order its run, will have a clean default state upon which to make its assertions.
If a tests needs to make changes to result values or how a mock will behave with a given set of parameters it can modify those dependencies freely without worrying of breaking some future tests since the default state will be reset each time before each test is run.

In this example we have the following classes and interfaces:

Database

IAccountDataService

AccountDataService

IAccountRepository

AccountRepository

IAccount

Account

AccountRepositoryTest

The following code example will use these technologies:

.NET C#

NUnit

StructureMap

Database. This is the relational, key value, or some other data store where our application permanently stores its data. We really do not want to include it in our tests. It will slow them down, we need to insert and clean up dummy data. It is a lot of work for which we may not have enough resources.
In our case in the database we have the following table:


CREATE TABLE Account 
(
 Id INT PRIMARY KEY NOT NULL,
 Name Varchar(256) NOT NULL,
 Amount Decimal(10,2) NULL
)

The Account table is used for storing data about our IAccount entity which is going to be used all during this example.
IAccountDataService and AccountDataService. The IAccountDataService is the interface we call upon in the rest of the application to store and read data about an IAccount entity from the permanent data storage. The AccountDataService is the concrete realization of the interface that actually gets to go to the database and retrieve the data requested by someone else. We use and interface here in conjunction with an Inversion of Control container in order to be able to mock the AccountDataService class in unit test for those classes of which this class is a dependency since we really do not want to test the AccountDataService class nor do we want to hit the database.
The IAccountDataService would be placed in a separate library, whose only task would be the direct communication with the database. The library will make use of primary types as parameters (integers, string , booleans etc. ) and DataTable as result types in order to abstract the data access layers from the domain library of the application. This will give us several benefits. For one we can safely replace the permanent data source for something else, another database or web service and our contract would not change since would still returns DataTable and receive primary types as values. It also leaves the data access layer blissfully ignorant about our domain layer and the business logic it implements. Our data access layer does one thing and one thing only it reads and saves data as requested without thinking it at all.
The AccountDataService class has the following methods:


   public DataTable Get(int accountId)
   {
       //.. sql retrieval code here
       DataTable result = new DataTable();
       result.Columns.Add("Id",typeof(int));
       result.Columns.Add("Name",typeof(string));
       result.Columns.Add("Amount",typeof(decimal));
 
       //.. get the DataReader
       while(reader.Read()) //This will execute only once
       {
            DataRow row = result.NewRow();
            row["Id"]=reader["Id"];
            row["Name"]=reader["Name"];
            row["Amount"]=reader["Amount"];
            result.Rows.Add(row);
       }       

       return result;
   }

The Get(int):DataTable methods has the task of going to the database and retrieving the data needed to fill a specific entity based on its id.
IAccount and Account. IAccount is our interface for out business entity Account. It may or may not have some business logic in it. As our system will grow it will surely start to have some logic so it is good to prepare it for being mocked in tests.


   public DataTable Save(int id, decimal amount, string name)
   {
      //.. insert or update logic here
      DataTable result = new DataTable(); 
      result.Columns.Add("Id",typeof(int));
      result.Columns.Add("Name",typeof(string));
      result.Columns.Add("Amount",typeof(decimal));

      DataRow row = result.NewRow();
      //in case of a insert the intial value is 0, 
      //but now is the LAST_INSERT_ID of the database
      row["Id"] = id ; 
      row["Name"] = name;
      row["Amount"] = amount;
      result.Rows.Add(row);
  
      return result;
   }

The Save(int, float, string):DataTable method has the task of inserting or updating a single Account record in the database. The save method will be determined by the id parameter of the method. If its values is zero it will be an insert operation, if its something else it will be and update operation. In case of an insert the method will retrieve also the new id of the record and return it in the DataTable containing the newly updated record.
IAccountRepository and AccountRepository. This is our domain repository class for the IAccount entity. It handles all logic related to the reading and saving of a IAccount entity. This is also our class being tested. It has two dependencies. One is the IAccountDataService from which it gets the raw data it needs to make IAccount objects, and the other is the IAccount entity which is passed as argument to it or is returned by it. Both dependencies come to the AccountRepository object through the Inversion of Control container.
The IAccountRepository is located in the same layer as the IAccount entity. Given its dependency to the IAccoundDataService object it doesn't have to worry about the specifics of how the IAccount entity is saved or retrieved. Its only goal is to worry about the business logic of saving and retrieving the IAccount entity. In case of a future development where the IAccount entity will store and retrieve a part of its data structure from somewhere else, e.g. a file saved to the disk it will be the job of the IAccountRepository to coordinate those sets of operations also.
Another good thing of this structure is that the IAccountRepository object is the only interaction point between the data layer of the application and the domain layer. Which means that the entire domain layer is oblivious how the IAccount object is stored. This will enable us during integration testing to switch the permanent storage to another one, if possibly, memory based like Sqlite or just plain objects.
The AccountRepository class looks like this:


public class AccountRepository:IAccountRepository
{
   private IAccountDataService accountDataService = null;
   
   public AccountRepository()
   {
       accountDataService = ObjectFactory.GetInstance();
   }

   private IAccount mapDataRow(DataRow row)
   {
       IAccount account = ObjectFactory.Get();
       account.Id = row.Field("Id");
       account.Name = row.Field("Name");
       account.Amount = row.Field("Amount");

       return account;
   }
}

The IAccountDataService is a private field of the class. It makes senses since it is used by the most of the methods contained in the AccountRepository class. The specific instance of the IAccountDataService used is instantiated in the constructor of the class using the StructureMap inversion of control container. We are working here with interfaces, so during testing we can and will replace the default instance of the IAccountDataService with a fake one for our testing purposes.
The mapDataRow(Row):IAccount method is used through the class to map a DataRow returned by the IAccountDataService to an IAccount instance.
The AccountRepository class has the following methods:


public void Get(int accoundId)
{
   DataTable table= accountDataService.Get(accountId);
   
   if (table.Rows.Count == 0 ) return null;

   DataRow row = table.Rows[0];
   
   IAccount account = mapDataRow(row);

   return account;
   
}

The Get(int):IAccount method is very simple. It calls to the IAccountDataService instance with an integer parameter and transforms the returned data into a IAccount entity if possible. Since we are requesting a entity with a specific id the IAccoundDataService will not return more then one row. In case the IAccount row wasn't found with the given id the Get method will return a null value for higher layers to handle as appropriate.


public void Save(IAccount account)
{
   if (account == null)
   {
      throw new ArgumentNullException("IAccount cannot be null.");
   } 

   var table = accountDataTable.Save(account.Id, 
                                     account.Amount, 
                                     account.Name);

   if (table.Rows.Count==0)
   {
      throw new ApplicationException("No data returned by the data service.");
   }

   DataRow row = table.Rows[0];

   account = mapDataRow(row);
}

The Save(IAccount):void method saves an IAccount instance and then returns a completely filled IAccount instance by reference, e.g. in case of a new IAccount instance the Id property has a value of 0 and is replaced after the Save operation by the newly assigned Id property.
The Save method makes a few checks to make sure everything is all right. First it checks if the IAccount entity is null, in which case it breaks the method execution by throwing an ArgumentNullException. The second check is related to the result returned by the IAccountDataService Save method. If the result returned zero row it throws yet another exception relating to a possible data service error.
IAccount and Account. In this example the IAccount entity servers primarily as a data holder holding data to and from the permanent storage mechanism. As the business domain grows it will also grow with the addition of new fields and domain logic methods. In order to handle this future complexity we used the IAccount interface to facilitate its mocking. Also, to be in sync with the letter of the pattern we are going to mock it also, as it is , besides it being only a collection of three properties. A dependency is a dependency, and the smallest of mistakes can throws us on a wild goose chase in a wrong class searching for bugs that originated somewhere else.
AccountRepositoryTest is our unit-testing fixture for the AccountRepositoryClass. Its basic structure is this:



[TestFixture]
public class AccountRepositoryTest
{
   ...
}

Before we start writing test we need to identify what our dependencies are and what result they will generally provide for us.
The AccountRepository class has two dependencies as specified above. The first is the IAccountDataService interface and the second is the IAccount entity. We should not worry about it right now. A simple mocked object with automatic property handling will do. The IAccountDataService instance in its both methods it returns a DataTable object, this is our result. Both dependencies and the DataTable result need to be defined in advance.


[TestFixture]
public class AccountRepositoryTest
{
   private Mock accountDataServiceMock = null;
   private DataTable dataTable = null;
   private DataRow firstRow = null;
   
   private Mock accountMock = null;
}

We have create a mock object for the IAccountDataService and its result a DataTable and a DataRow object. We have made the DataRow object firstRow available as a private field of the test class since there exits a possibility that in some test we may need to change the data returned by the data row, and calling a direct reference is the easiest way of doing it.
Each dependency and its results need to be instantiated to a clean, default state before each test is run thus preventing one test to influence another by modifying the shared dependencies and results. This is done by using the SetUp method of the unit-testing method. This method is execute every time before a test is run.


[SetUp]
public void SetUp()
{
    dataTable = new DataTable();
    dataTable.Columns.Add("Id",typeof(int));
    dataTable.Columns.Add("Name",typeof(string));
    dataTable.Columns.Add("Amount",typeof(decimal));

    firstRow = dataTable.NewRow();
    firstRow["Id"] = 1;
    firstRow["Name"] = "Marko Horvat";
    firstRow["Amount"] = 44.00;

    accountDataServiceMock = new Mock();
    
    accountMock = new Mock();
    accountMock.SetupAllProperties();

    accountMock.Object.Id = 1;
    accountMock.Object.Name = "Marko Horvat";
    accountMock.Object.Amount= 44.00;

    ObjectFactory.Initialize(x => {
      x.For().Use(accountDataServiceMock.Object);
      x.For().Use(accountMock.Object);
     
 
    });
    
}

Now, we are sure that on every test run we are going to have a clean slate in respect to our dependencies and result values. It is important to note the last code block in the SetUp method. This is a StructureMap initialization pattern where we tell the IoC container which instances to bind when a client piece of code requests a specific type, e.g IAccountDataService. This piece of functionality enables us to embed our fake dependencies in our real class without changing its structure and behavior.
Lets us now write some tests and see how this works in real life:


public void Save_ProperParameters_AccountSaved()
{
   accountDataServiceMock.Setup( x => x.Save(It.IsAny(),  
                                                 It.IsAny(), 
                                                 It.IsAny()))
                          .Returns(dataTable);

   var instance = new AccountRepository();
   var result = instance.Save(accountMock.Object);

   Assert.IsNotNull(result);
   Assert.AreEqual(result.Id, accountMock.Object.Id); // 1
}

This is a test written using the "Define once, recreate every time" pattern. On the start of the test we define the expected behavior of our dependency fake. We tell it that regardless of the input parameters to return the dataTable result we have defined previously. Then we create an instance of the AccountRepository class and with it we executed its Save method using the accountMock member as a parameter.
Now lets write another test, this time we will check the behavior of the Save method in case there are errors:


[Test]
public void Save_ErrorRaised_ThrowsExceptions()
{
    accountDataServiceMock.Setup(x => x.Save(It.IsAny(), 
                                                 It.IsAny(), 
                                                 It.IsAny()))
                           .Returns(new DataTable());

    var instance = new AccountRepository();
    
    Assert.Throws( () => instance.Save(null));

    Assert.Throws( () => instance.Save(accountMock.Object));
    
}

In this test I needed a different behavior from the Save method. I knew it was a new clean instance, for which no behavior was defined so I freely defined a new behavior for the fake. The following two assertions were simple enough. First I sent a null as the IAccount parameter in order to check if the Save method correctly threw theArgumentNullException, and then I checked that if the Save method of the IAccountDataSource returned an empty data source if the repository code correctly threw the ApplicationException. This was possible courtesy of the accountDataSourceMock object.
The "Define once, recreate every time" unit testing pattern offers the following benefits:

Simplifies unit test writing

Increases test writing speed

Reduces the chances of one test modifying the results of another test

What should I learn next

2010-09-15T14:27:00.002+02:00

My wife is a real help to me. Her current contribution is her opinion about my learning schedule for the next six months.
I laid down some choices, what issues are concerning me about each choice and in what order I would like to learn them.
The candidates were:

Oracle

MongoDb

WPF 4

The winners were WPF 4 and MongoDB. WPF 4 will became my new build, virtual machine startup reading and MongoDB will became my evening exercises technology.

Lets ignore them, will ya!

2010-09-13T10:18:00.004+02:00

Once upon a time, on a project far away a young group of engineers dutifully wrote unit tests for almost everything on the project. The project also had some really tricky integration points with other systems. And those integration points were faulty, and those tests broke. So out team of heroes dutifully applied the Ignore tag to those tests covering those integration points which were faulty until they were fixed by their respective teams.
And so the gates of Ignorance were opened, and upon the project a beast was unleashed and its name was laziness since every set of tests which was difficult to fix or it required a fair amount of time to fix the defects it exposed was dutifully sent to the forges of Ignorance by the Ignore attribute.
A man arose from the ranks. He thought him self a leader, a thinker and said no more in his head. Nobody heard him, yet, for he was wise in marking his words right and waiting for the right moment to utter those life changing words.
And so we waited, to see what will become of the project and the stalwart team of young engineers doing their best to test what was easy, and to forget what was hard.

Nine to five

2010-09-12T11:27:00.002+02:00

It took me a while to make my self see and surrender to the fact that not all people I work, I've worked and will work with me in the future, have accepted The Life, or the way of a software engineer or craftsman.
Oh, how I've grown wiser and older. I just might grow a beard and be a guru of some sorts. Certainly there is a niche I can squeeze in a pretend to know what I'm talking about.
But alas, I didn't grow wiser just battered down by the entropy that is the , oh so typical , human philosophy of working from nine to five and then at five o' one forgetting that work even exists.
Well I can understand that. Work is work, and it isn't the whole life. But for the way of a software engineer or craftsman isn't just work , the daily grudge of projects, meetings, coding and testing the constant battle of will and code and the requirements that just won't fit into the application mold. It is just not.
For me it is something different, something more. A thing to be proud of , something to leave for posterity. Is the way of living where you read, learn, exercise your self and improve your self. Year after, year continuously. And the work is the place where you apply your skills, your learning, your spirit into something tangible, something you can be proud of, an achievement.
Am I , or people like me, better then the rest. I think not. We are just different. I often found that people with the nine to five mentality are predictable, they approach each problem in a similar fashion, they apply the same solutions every time, day after day, application after application. On the other hand, the same errors are repeated, the same problems occur nothing is improved until pressure is applied from the outside, or if not they succumb to the technology wave, left behind with outdated knowledge and if something doesn't come by, a new project or a new job where the can learn new skills in a nine to five way they are really frakked up.
This is what scares me the most, as a developer, to let my self loose, to relax and to in a matter of years outdated, jobless, and skill less.
We work in teams. We seldom do any work alone. Teams can be organized differently, they can work differently. But one constant remains often, in teams there are some people that want to improve them self and the the work they are doing and those who just can't see the need to bother to do so.
For this was an enormous amount of stress, battling such teammates day after day until it downed me. I can't change them. I can't force them. I just can behave with my code, my tasks the way I think is right and if they'll follow me the batter or if not I will refactor their code or leave it as is.

To fake or not to fake

2010-09-10T08:49:00.002+02:00

To fake , or not to fake that is the problem now. This is something I just realized after writting around two hundred tests that rely on completely faked dependencies, and around seventy which do not fake nothing. Those non-faking unit tests are those written for the lowest layer of the applicattion, the data access code which tests how my data retrieval code works with a real database with only the data faked. Those tests sometime rely on each other since sometimes one stored procedure or view is used by multiple different sources. And if I change one multiple tests will fall indicating to me or my team where we need to apply out changes also.
But on a faked enviroment, where all dependencies are faked if we change the logic in one dependency and write tests that pass for it we must manually go and look through the code and to find all the places where that dependency is used in order to update it to the newest state of the application. Why? If I didn't change the structure of the dependency or the type of results it returns the tests that use a fake of the dependency will pass since those logic changes will not automatically propagate to those fakes (mocks or stubs it is irrelevant which in this case).
No that is why I push for functional and acceptance tests in order to test the complete stack from ground up without mocking, but still those tests are often left aside since people who have written unit tests have decided that they are unnecessary duplication or effort, or worse botch them in such a was that those tests do not return any meaningful data to us.

How much granularity is enough?

2010-09-08T05:35:00.003+02:00

I worked sometime ago on a small/medium sized ERP project. Once again it was a ASP.NET web application.
In order to write a feature the following steps must had to be taken:

Write a stored procedure, or two

For each procedure write a method in the related data service in the data access layer of the application

For each method in the underlying data access service write one or more methods in one or more repository objects in the logic layer.

Write one or more entities, value objects and aggregates related to the procedure written.

For each function write a method in the appropriate object service on top of the logic layer.

On the front end write a service facade for collecting errors and results from the logic service, once again is a one to one mapping (I used the ObjectDataSource control extensively in this project and we had a centralized message collecting system).

Write the functionality on the screen.

When looked from a theoretical aspect each step made sense. A clear separation of concerns, each object doing its small thing etc. But during the implementation I just often found my self wondering Why am I doing this? Each object has only a small variation from the object bellow. Isn't this to much granular?.
It sure made writing tests easier, since the logic in each object wasn't very complicated so the corresponding tests were easier to write and were written much faster, especially on upper layers where I made extensive use of the Moq mocking framework.

Just unit test?

2010-09-07T00:41:00.002+02:00

I just realized something today. Something deep, and profound and totally astonishing . Well, for me anyway. I realized that maybe, just maybe doing unit tests on project is enough. On most projects I have an influence on I strive to have functional and integration tests besides regular unit test. I just feel is best to cover each layer of the application in one fell swoop with functional tests or acceptance test (it depends really how you do them) with a good coverage of unit test for each object separately.
Today I've done a lot of unit tests. I worked late, and I've done a lot of coding. For class I've done I wrote unit test. And with those tests I covered a lot of functionality of the application. When I reached the user interface there wasn't much to test, everything worked fine since I got the majority of the defects with unit tests on the lower layers.
It seems strange to me since we do tests in complete isolation from each other, so no outside dependencies between tests are allowed. Everything is mocked. But with a real fine granularity of objects for a specific functionality it is possible in my opinion to just have unit tests and cover the majority of the expected functionality of the application.

How to cranck unit tests under pressure, and not feeling dirty at the same time

2010-09-03T15:29:00.004+02:00

It's called doing the right thing.
Well thats what I tell my self it is. When I read "Extreme programming Explained" by Kent Beck I read about a story of his about a project where he introduced extreme programming as a development process. The project went well until the deadline got really close and wished he could just throw XP from the window, hack the project together and completed the project in time to collect a big, fat, juicy bonus. He addmitted he panicked, and then calmed him self down when a colleague told him that nothing really changed, that they should plan for the last two weeks of the project as it were an ordinary iteration, and execute it as such with unit testing and everything.
Now I was in a pinch some time ago. Not something unusual, per self, it seems there is not enough time to ever do a project. The project was then involved was in development for some time, and the deadline of the clients patience got really closer as each week passed.
It was a good project, I've architected it and technically oversaw the development for much of its life time as I was in parallel involved in other enterprises. It got a stable architecture, which followed closely my plan, it got unit tests, inversion of control, mocking ,functional tests and a set of Selenium based acceptance tests.
I event wrote a set of QUnit (a javascript unit testing framework) test for the Javascript classes we used on the project.
The problem was that the we got a week left and still a lot of stuff to do if wanted to do it right, before the final client presentation. Like writing tests, logging code etc.
The pressure started to mount, just finish those damned screens everybody yelled (not really but my minds plays such beautiful tricks on me). Just get it done, write those pesky tests later.
The problem was I was feeling really good about the projects, the tests were written quickly and were really useful to ferret defects and I really didn't want to abandon all those three hundred plus tests to entropy and mocking disregard.
What I decided to do is to change my unit testing strategy:

Test only logic heavy code. If a method has an if, switch or any other control structure I would test it in respect to the general expected behavior which could result from those control structures.
Change focus from data to processes. I left trying to set replicas of real world data, and instead used generic values like "1" for ints and "Any" for strings. This left me with more time and didn't stress my mind to try to figure out real, representative , data sets.
Tell your self is good to copy paste (for now). I had tests which were five to seven lines long each. They all had 30%-40% of the same code base. What I originally do I refactor out the common code in a private method and reduce my overall tests size. The downside of this it takes time do do it. Time which I really didn't have. So I copy pasted.
In a object stack which covers a specific functionality (e.g. GetAllAccounts) do not retest the same functionality on each step, but instead focus really closely to the task of each object in the stack. For example I would focus really hard on querying and inserting data from the permanent storage in the Data Layer of the application, and focus on data transformation and repository logic in the middle tier of the application.

It kinda worked. I cranked a lot of more code this way and found a lot of defects. I wouldn't suggest it as a unit testing strategy for everyday situations but it kinda works when under pressure.

Oh, my learning muse

2010-09-01T09:05:00.002+02:00

I didn't write in four months now. It didn't seem to matter, nothing did which was related to my work. What happened to me?
Well, I've been pushing my self for the last three years very hard. Learning, working and applying my self in order to grow, learn and advance as a software engineer. And then I crashed, emotionally and physically. I become cranky , tired and frustrated.
I started then working from home, so I didn't have to drive for two hours a day on really low grade roads. I saw more of my family, and I was more rested.
One thing led to another, I started to shift my priorities to my son and wife. I started spending more time with them, going out to play by the sea, watching movies reading books, going out. Just living my life.
What was not right, was the nagging feeling that something was not right. A sick rotten feeling that I was leaving out something vital and important to me. My learning and education. My personal growth as a professional.
It got to the point that I felt my brain rot from not use. And I didn't like it. So I started learning again, "Patterns of Enterprise Application Architecture" by Martin Fowler, and "WPF Unleashed 4" by Adam Nathan. The former as my regular reading and the latter as my computer time in the evening and weekends reading.
I feel more right now. I guess. I don't spend as much time at the computer cranking code and learning new stuff as I would like.
Every time I can sit at my machine and learn , it seems it is ten in the evening and I'm to tired, my head hurts and I just want to unwind. It is really hard to keep up.

5th WebUG meeting report

2010-04-12T22:22:00.002+02:00

On the 8th of April 2010 I held a talk on the topic of "Software Engineering" at the 5th Web user group meeting which was a SQL/DEV user group meeting (since Windays 2010 are coming soon). The talk was held in the Microsoft offices on the top of business building in Zagreb in the Dante conference room.
The presentation went well. I was really nervous beforehand. I thought that there is for sure someone in the audience who will spot an error and point it out. Well no one did , or if he did he didn't point it out loud.
There were some technical difficulties at the beginning. The network was hard to get and the camera crew didn't come so the talk wasn't recorded. Bummer.
Everything else went just fine. The talk was well received by the audience, people came to me afterwards to congratulate me or to talk about some finer point in private.
The hosts were gracious enough to accommodate my special dietary habits so they ordered a vegetarian lasagna for me during the networking part of the event. Everybody else got "čevape" which went away pretty fast.
All in all it was a nice event. I meet some good people and I hope to have a chance to present again on a future WebUG meeting.
Here are some photos taken from the talk:

WebUG Presentation: Software Engineering

2010-04-03T19:00:00.002+02:00

Next week on the 8th of April 2010 I will present on the monthly Web User Group meeting in Zagreb, at the Microsoft Croatia offices on the topic of Software Engineering.
Software Engineering is something very dear to me. It is also a very hard topic to condense in an one hour presentation.
For those who want to attend you can find more here http://www.webug.com.hr/.

Key principles of software architecture

2010-03-18T07:19:00.005+01:00

Software architecture is the first and most important design step of software development project where are defined and indentified the key components of a product encompassing the logical structure of the product being built, the technologies used and how they are used and the definition of the key processes handled by the system both business and technological.

Software architecture is software design , but not all software design is software architecture. Architecture implies a high level overview of things. It set the boundaries and key guidelines of the development effort without going into a detailed specification of each implemented use case on the technological or business level.

Every developed system has an architecture. Most software architectures are incidental, matters of accident and small decisions made by different people at different times without accord or shared vision.

Software architecture is both easy and hard. It is easy because it doesn't get into every detail of the system being built, that is for the detailed design effort it is hard because it requires an encompassing vision of each key element of a system and the capability to set it in clear, concise and understandable writing.

As the product changes the architecture will change. Decisions are being made by each key stroke, by each library reference and each guideline not met - no matter how small or temporary.

The software architecture document must be therefore written in a short and concise way with pictures describing each key section of it in order to facilitate rapid understanding and ease of maintenance.

There are muliple way of doing software architecture. A good , and free book published by Microsofts Patterns and Practices covers all aspects of it, the Microsoft Application Architecture Guide, 2nd Edition. I would recommend it to everyone.

A dummy high-level model for a HRM system

When I approach and design a high level architecture document I generally cover the following sections:

Project overview

Project goals

High level architecture diagram

Technology platform

Technology platform - process and techniques used for specific problems

Key processes covered by the product

Other

Project overview. A short overview of the project, usually a project sales pitch describing what is the project, who is the client and what the project is really about. I do not go into great details since there are other documents which are generally built to elaborate on the topic further.

Project goals. Or the project high level requirements are the handful of key things the project must be able to accomplish. This is the basis on which the architecture is being designed on. The architecture must be able to fully satisfy these , generally around five, requirements in order to be successful.

High level architecture diagram. The highlevel architecture diagram is the corner stone of the document. This is actually the picture or the sets of pictures most architectural discussions are done between engineers and which will set the broad strokes of the project. The key goal of the high level diagram is to set the relationships and communication channels between each compoment of a system. It can be done by using a block diagram with squares and arrows indicating componets (applications, modules, databases and etc. ) or it can be done by using UML's component diagrams.

Technology platform. A list of technologies used for the product organized in logical sections describing the goals and reasons for the usage of the technology. It is important to correlate the chosen technologies interdependencies, e.g. all the technologies must work well together and if not the risks must be identified, documented and review by all the architectural key stakeholders of the project.

Technology platform - process and techniques used for specific problems. Description of key usages of each technology. Most modern technologies used for the development of modern systems and products can be used in several ways, buy applying several techniques at ones disposal. For example one can rely heavily on the ObjectDataSource object in ASP.NET for all grid operations or could choose to manually bind data or just to build a normal HTML table with data into it. This important for a data heavy application where data will be often presented in a tabular fashion and this will be the main way a user will interact with the system.

Key processes covered by the product. This correlates directly with the high level requirements set for the product, e.g. the project goals and other critical issues which can applied to the entire product and are critical for its proper functioning. Here we could specify how the system reporting solution will work, how the system will interact with other key systems ( for example with an old dos accounting application critical to the client who can only write to the file system plain text files), how the authentication and authorization system will work , how will the caching solution work etc. Apart from the high level diagram this is the most critical part of the architecture and more so for the client. Often to support a specific process implementation an architectural spike will be developed to prove and disprove a point to the key architectural stakeholders.

Other. Architecture is for the most part a technical discipline done for the product development team. It is purposefully ten thousand feet up from the detailed specification of the product in other to cover, restrict and keep up with the full product life cycle. Each product is a separate beast with its issues and pitfalls, risks and challenges and there a myriad characteristic who could be added to the software architecture for a specific project.

My presentation of the fourth MSCOmmunity Istra

2010-02-25T21:54:00.003+01:00

Last Tuesday I presented at the fourth Microsoft Community Istra meeting in Pula at the Student MMC club. I was the sole presenter due to the fact that my colleague Hrvoje couldn't make it.
I presented on the topic of UML. The presentation consisted of a short introdcution to UML, its origins and uses and then I covered the basics of Class, Package, Activity and Sequence diagrams.
I think the presentation went rather well. I wasn't nervous, the crowd was developers mostly and the ambient suited me just fine (dark, dunk walls, underground bar on the back and you female students searching for a higher insight in life, back room poker and a whole day on going LAN party in the next room).

IT Showoff Zagreb

2010-02-12T13:27:00.000+01:00

Winter came to Istra. Once again the snow fell and the cold came. In Labin, where I work at six a.m. the temperature was bellow zero. And today is the day I'm travelling to Zagreb to the IT showoff conference.
I took the company car, my trusted GPS, a two cd podcast collection and on I went. In Rijeka I picked my colleague and friend Hrvoje Hudoletnjak, who will sit on the evening panel “Web framework show down” at the conference.
And today we went.
As the trip progressed the temperature got progressively worse. Bellow zero, bellow five – oh my god please do not look at the thermometer. The snow, let me tell you about the snow. The highway was deep covered in it. On some parts only one way was opened on each side. The snow was stacked up taller then me, and I’m tall.
But, thanks to my superb driving skills and to a little bit of help from the window unfreezing spray we made it to FER where the conference is being held.
Luck was still on our side. We found a free parking space really fast and really close to the university.
A small part of the university was reserved for the conference. When Hrvoje and I arrived there we where greeted by a long waiting line of people waiting to be registered.
The registration proceeded pretty smoothly. The conference boast with pretty looking hostesses ( a bit sexist , but you know) and it proved true. The girls were pretty and competent and Hrvoje and I were registered quickly.
I got a cd, a pool and a conference program. Well, so much for smack. But it is a free conference. I’m not going to complain.
The conference is organized in two university auditoriums and a hall. The hall is where to social aspect of the conference is being held. Lost of drinks and pretzels are served there as nourishment which is cool.
Of the two tracks I attended the right , “development” track. And I was astounded by the quality of content and presenters. They were really good, fun, instructive and furthermore they freely gave promotional t-shirts to those who asked questions, which in three instances was me.
Yep, I won three t-shirts which of course I will give to my beautiful wife. She is already an Ubuntu user. She looks really nice in geek-wear.

After all is done, the enemy comes to pick the honored fallen bodies

2010-01-30T21:53:00.005+01:00

This week I presented on the two events announced on my previous post. Both were real amazing and great opportunity for me to meet new people and practice my presenting skills (which really needed practice).
The first was the MS Community meeting held on the 26th of January in the Konoba “Idila” in Rakovi near Baderna. For those of you who aren’t from these parts a “konoba” is a local tavern type. If you ever played Dungeons and Dragons or watched a fantasy movie it is the place where the shady old man gives you the quest of your life time (or week in case of my gaming group back at college). It was a real nice place. Cold, dark and mysterious where the mysteries of the Windows XP mode of Windows 7 and the arts of Unit-testing were explained in a dark , dunk room, lit only by the ancient fire place in the center of the dining, drinking, area. The walls were of made of hand chipped stones, rugged and hard, cold from the outside winter.
A place was cleared for us. Twenty chairs, a table and a presentation pod. The ceiling was short, wooden planks running back and forth. I was afraid I was going to hurt my head. I’m tall you see. But no such issues were encountered.
Viktor Ezgeta, presented first on the Windows XP mode in Windows 7. He started first with several slides showing the basics of the Windows XP mode and then continued on a live presentation. Viktor is a fun presenter to have, and it showed in this presentation also. I think everyone got the point there. No missing content for Viktor.

I continued next with my habitual “Unit-Testing: A grease monkey introduction” presentation. It took me longer than agreed but no one objected (well my wife number one had several well meaning objections on my presentational style, which isn’t unusual given her background in journalism and her current work as a researcher in communicology). It went well. I first presented on unit-testing theory and then I showed how unit-testing is done in practice with NUnit.

Afterwards it was the social hour of the evening. We all gathered around an old wooden table, really nice, really cool and rustic and the food was served. Fuži with wild animal meat, and njoki with lambs meat. Of course I got my vegetarian meal which was really nice and animal friendly.
The food was good and so was the talk. As a result me and my colleague Hrvoje Hudoletnjak will present on the next Microsoft user community meeting which will be held in Pula on the 23rd of February 2010.
The second event I present on was the recruitment run held by Novatec New Technologies ( the company I work for) and Systec Automation (the parent company I work for ) in Osijek at the Faculty of Electrical Engineering as part of our new campaign of opening Novatec and Systec offices in Osijek. I presented with a colleague. He covered the Systec side of the presentation and I covered Novatec and the recruitment process.
The presentation was held in the new faculty campus which previously was one of the Osijek’s military bases. The base itself is very ominous, during the opening days of the last war the enemy held the base and opened fire on the city from there and the city hospital which is just on the other side of the street.
It is nice to see such a building disbanded from military use and converted to something which will benefit so many people.
The presentation hall was full with students. Some had to event stand, such was the interest. We really got their attention, so I’m sure many will apply for the position.
Osijek is wonderful city. It was my first time there. I have some friends living there, but haven’t had the time to meet with them. I took a short walk through the city the first night I was there and was impressed with its architecture, the Drava river and parks. The people are really nice and friendly, and didn’t hesitate with instructions where to go when I asked them to. I would really like to go back there and see more of the city, its museums, its bars and theaters (well I am the guy who listens to baroque music when programming, really no surprises there).
In short, I think , both events were a real success and I really hope to present some more in the near future.

Events, events, events

2010-01-22T22:41:00.003+01:00

Well, its conference time in Croatia this time of year. First , there was the second Web User Group meeting a Microsoft Croatia which I attended with two of my colleagues . You can watch the live stream here . It was the first WebUG meeting I attended and I was dazzled by the quality of organization , the presentation and the amount of benefits I got just by attending there (lower cost for attending several local conferences and of course the lower early entry cost for the Developer Bootcamp).
The presentation which I attended was titled “User experience on the web” by Vibor Cipan of FatDUX. The presentation was interesting, educational and all in all a good experience for me.
The pizza afterwards was great too.
There are two events I plan, wish to attend to. The first is the IT Show off conference which will be held on the 12th of February this year in Zagreb which is a free one day developer conference and the second is the above mentioned Developers Bootcamp.
I will held two presentations next week. The first will be held on Friday 29th of January at the Osijek Faculty of Electrical Engineering where I will present the company I work at Novatec New Technologies and our software engineering process. Attendance is of course free.
The second will be held on Tuesday 26th of January in the Tavern Idila in Rakovac near Baderna. I will be the second presenter. The first will be Viktor Ezgeta with “Windows XP mod of Windows 7”. I will present my usual introduction to unit –testing presentation. It will cover the basic unit-testing theory and practice by showing how to use NUnit for unit-testing .NET applications.
For the grand finale, I’m announcing my to WinDays 2010 presentation proposals:

F# : an introduction and,

Domain – driven design in .NET with Visual Studio 2010 modeling projects.

I hope one of the two is taken.

14. SQL & Developers Users Group meeting in Rijeka

2009-12-22T07:45:00.002+01:00

I've recently held a presentation on the 14. SQL & Developers Users Group meeting in Rijeka on the 10th of December 2009 on the topic of unit testing.
Due to the fact that I was the only presenter I had the opportunity to present two talks, one on the theoretical side of unit testing and the other on more practical approaches.
Both talks were successful. The attendees were a mixed bag of old hands and newbees wanting to learn about the topic and art of unit testing. The crowd was small, but that suited me fine since we could talk and explore topics of interests freely.
It was an interesting event for me. I learned a lot about presenting, a skill I have yet to master fully and the attendees later told me that they learned a lot from it which was as good a praise as I needed.

Code Documentation

2009-10-29T09:11:00.006+01:00

Code documentation is the application documentation written directly in the source code of the application. Code documentation is used to document the application API in order to increase developer code understanding and discoverability, to reduce the time needed to implement a particular feature using prebuild components and to decrease the defect rate of defects caused by the lack of proper component understanding.

Code documentation is written before each package, class, property and method name in the source code using a specific syntax which makes use of automatic code documentation tools possible. The syntax for code documentation varies from language to language. It is well supported in most IDEs for most of the mainstream development languages.

There are two distinct benefits when using code documentation with automatic tooling support.

First for IDEs that support code completion (intellisense in Visual Studio) the IDE will automatically parse the code documentation of the piece of the code the developer is currently writing and it will present it to the developer as she is typing the code , this informing him of the intended use of the component being used.

Second tools exist that can create a proper API documentation from the source code of an application using code documentation and the basic language syntax as tools. The documentation thus generated is much easier to grok than fumbling in the IDE with code completion and random file opening and reading. Once again tools exists for that , e.g. Sandcastle,Phpdocumentator, Pydoc,Javadoc and etc. the list goes on and on.

A problem most developers I've encuntered have is that they do not know what to write in the code documentation, even when they have written the component them selves.

When I write my code documentation I use the following model for each component memeber I document (class, property, method, package etc...).

Each documetation item is composed of two elements: THE WHAT and THE HOW. Of the two THE HOW is optional since in some cases it is not needed.

This is best shown by an example



/// <summary>
/// THE WHAT : MovieService is a service provider for using basic CRUD operation on the Movie object permanent repository storage(e.g. database )
/// </summary>
///
/// <example>
/// An instance of the MovieService object is created with its static Create method which will connect the object instance to the proper system Movie repository.
/// 
/// MovieService movieService=MovieService.Create();
/// IEnumerable<Movie>  movies= movieService.Select();
/// </example>
public class MovieService
{
 /// <summary>
 /// THE WHAT: Creates a basic instance of the MovieService object. It does not however intialize the required repository connection for the Movie object.
 /// </summary>
 private MovieService {}
 
 ///<summary> THE WHAT: Creates a basic instance of the MovieService object and intializes the required repository connections for the Movie object.</summary>
 /// <returns> Working MovieService intance</returns>
 public static MovieService Create{return new MovieService();}
 
 /// <summary> THE WHAT: Returns a collection of all Movie objects in the Movie object repostitors.</summary>
 ///  <returns>IEnumerable<Movie> collection </returns>
 public IEnumerable<Movie> Select() {return new List<Movie>();}
}

The THE WHAT ant the THE HOW texts int he previous example are just for the example sake, in real life documentation endeavors they are not needed, and should not be used.

Arhitecture of a thick web application

2009-10-07T22:43:00.005+02:00

A thick web application is a application composed of two parts , one is the server which generates HTML , CSS , Javascript and other elements and sends them over a network using the HTTP protocol towards clients who render the received content on the user machine in the form of an interactive user interface, where all the programming elements are tightly bounded in a single application element residing on the server.
Nowadays thick web applications are not the hip thing to do. Everybody is doing service oriented applications or rich internet applications or even cloud oriented applications. Distributed systems are the in of the moment. Thick applications are seen as antiquated, not performing solutions, unable to cope with the requirements expected from modern systems both in the performance/scalability and the maintainability/coolness sides of things.
Everyone forgets that a few years ago every application was a thick application, and that everybody started their careers learning and writing those types of applications. Of course there are still viable cases for such applications to be developed.
First, they are simpler to understand, develop, deploy and maintain. Secondly they can be developed much cheaper and faster than their distributed counterparts due to the lesser numbers of different parts which need to interact and be set up in order to deploy and maintain the thick system in respect to the distributed one.
I’ve actively developed user experience enhanced (web 2.0) applications both in PHP and ASP.NET (with a side note in Django and Google App Engine for a short time) and I’ve found that the following general application architectures is very suitable for developing thick web applications.
The architecture is composed of the following elements (from the front to the back):
Client side modules (screen). This is the top most tier of the application. Here is what is actually sent and executed to the client. Due to the fact how the majority of web application frameworks are organized here we talk about client side code which drives the behavior of a specific module(screen). In lesser respect we talk also about images, video, flash, HTML, and CSS code.
Client side components. This tier is composed of general client side components (once again we talk here mostly about javascript elements – objects and functions) used once or more in one or more client side modules. A client side component is used only for data carrying and data transformation purposes. The required input is provided by the client side code on the each module, and resolution of the task assigned to the client side component is decided by the client side module using the component. Each component must be simple as possible and must do one thing, and one thing only.
Server side modules (screen). This the first server side tier. This tier has two important tasks: first it must generate client side elements sent to the client in response to their request, and the other it must make use of the services provided by the service tier and the API provided by the Domain tier objects returned by the called services in order to compose them in a viable user task. A user task is a set of operations (a workflow) u user must do on the module (screen) in order to achieve a quantifiable business objective.
This tier is where is decided what service (or services and their interactions) must be used in response to a users operation and what message must be sent back to the user in response. This tier must “know” everything that it needs to know about the business problems it tries to solve to successfully communicate with the user.
Server side components. Server side components are composed of reusable elements (classes, functions, widgets or other similar elements) used one or more times in one or more modules. Each component must be used for data carrying or data transformation, it must rely for its required input on the server side module using it and must not decide what to do with its output , which is left to do for the module making use of the component.
Services. This the first tier on the middle tier side. How it is separated from the other middle tiers is not important. What is important how it is used and how it is structured. Regardless of the programming implementation (functional or object oriented) the Service tier must provide a set of stateless, not dependent services each providing an atomic operation. Services must be grouped together by the business task their can perform when used together, but must not make assumptions about the order they are called or the way messages are sent back and forward between the user and the application.
Services must concern themselves with their required input and expected output. If an error condition occurs (invalid parameter etc) the service must raise and exception (or similar message carrying ) construct which will provide technical data to the front end about the error condition occurred. It must not, however, return a full fledged user message.
Domain This tier is tasked with the modeling of the business domain the application is working on. The domain tier is composed from entities, value objects, events and repositories each interacting with each other in the same manner they interact in the business system used by the application. In order to find out more about the Domain tier please read the excellent book written by Eric Evans Domain Driven Design .
This tier is used by both the server side modules and the services. The services will work with input and output parameters taken from the domain tier, and the server side modules will use them to carry out their associated business tasks.
Infrastructure. This tier is used only by the service tier since it provides low level support for interacting with the underlying system, database, other application services and etc. If you need to open and read a file, or send an e-mail message use this tier. What to do with the read data from the file, or what to put in the e-mail message is the job of the server side and services tiers.
Database. The database, or the backend, is the final tier of our typical thick web application architecture. The database is used for permanent data storage, data storage manipulation, querying and fast retrieval. Only one thing is important regarding the implementation of the database: under no condition put a line of application logic in it, no matter how fast or simple it seems to be. It almost always is a bad decision, which will lead to lower system operation visibility and a nightmare of maintenance problems. Just don’t do it. Really.
How to tie all of this together. It’s both simple and terribly complex. What I’ve found out works best is to first design the domain of the application, then translate it into a data model and data transformation procedures. Secondly to define all the business task which must be carried by a user, group them in related modules and break each task into atomic operations which will be actually written as services using the domain tier of input/output.
When writing services I use the following technique: first I ask my self what questions as the user interface I have in order to successfully complete the business task, and then what operations I must perform in order to do it. As the last thing I define the input and output messages for each task/operation.
The infrastructure tier must be made low level as possible. Really low level stuff. The question I ask my self is what I need from the system (world) around me as the services and what I want to be present but also to forget it ever exists. The answer to both question goes into the infrastructure tier.

Short, short deadline sprint rules for success

2009-10-03T17:51:00.003+02:00

Imagine this situation, its 24 hours before a very important deadline and your project isn't ready. But you must show some progress to the client, something anything to stop them from stopping the project and turning to someone else. What do you?

I've been caught in this situation several times already this year, and will in all probability caught again, and its not easy or simple to handle. For each project I was a technical lead, and the responsibility to actually do the task by the deadline fell to me.

The following rules helped me:

Cash in your relationship chips , you'll need them to motivate your people and make them buy in the effort required of them.

Write a task list of all tasks needed to be carried out in order to successfully meet the dead line, and then filter it out to the bare essential. It's time for brutal reality, not Christmas wish list making.

Take the core, the most difficult and most important stuff on your self. They made you a technical lead for a reason. Now is time to earn it.

Distribute the remaining stuff to each team member according to their capabilities and aptitude.

Make sure no one introduces new (or reopens) new defects into the system. Test the core twice before committing. Break heads if necessary. It's not the time to create more work.

Do not commit unfinished work. It either is done, or it isn't. Only pure 100% completed and tested changes go into the repository. Make sure everyone is on the level with this.

Do standups every four hours in the first twelve hour period, then switch to two hour standups for the remainder of the sprint. Track only completed, not completed progress on the created task list. Look for problems, and replace people who got tired or the tasks assigned to them are to difficult to handle. Pair programming was proven effective in both cases.

On achieving all (or the majority) of the planned task code freeze the repository, and label it as such. Do not allow anyone to commit now unless its a critical defect fix you personally authorized. Break heads if necessary.

After the code was freezed, test everything on your machine. If everything checks out label the code in the repository as such.

Publish the product to the production environment and then check it there once again. If everything checks alright, go home to your family for a head bashing for spending 24 hours on work while your kid won he's first soccer prize (or similar). Be proud of your self for achieving something great and meaningless.

The following rules(principles, steps) work because there is a clear scope of the work to do in a very short amount of time. Everyone is clear on the importance of the work to do and what is the price of failure.

The two most important thins are frequent standups and the written, prioritized task list. Why? Frequent standups remind everyone one the goals and the principles of the work to do. They allow faster knowledge sharing between team members and allow you to get a clear view of the progress achieved thus far, of the problems had and allow you to frequently react to those problems in order to remove the impediments thrown in front of the team.

Remember in the end everything falls to you. You must be the leader, the one that starts first and goes home the last. The one that pushes the code to the production and says is done. At four am there is no one else. Its your responsibility to sleep for two hours and show to work to check if everything is OK with the business people showing the product to the client.

You are the hart and soul of the team. You must show firmness and clarity of vision and command, you must be supportive because without them you are nothing . You are your team, and they are yours for good and for worse.

Best practices in brownfield development

2009-09-21T08:17:00.001+02:00

The wikipedia definition for the term 'brownfield is this : ''In the United States city planning jargon, brownfield land (or simply a brownfield) is land previously used for industrial purposes or certain commercial uses. The land may be contaminated by low concentrations of hazardous waste or pollution, and has the potential to be reused once it is cleaned up. Land that is more severely contaminated and has high concentrations of hazardous waste or pollution, such as a Superfund site, does not fall under the brownfield classification. Mothballed brownfields are properties which the owners are not willing to transfer or put to productive reuse.[2]' .

I couldn't agreed more with this definition, especially about the hazardous waste and pollution parts. Brownfield development in software industry is very common, rarely a developer will develop a system from scratch without dealing with legacy code and applications.

In my opinion brownfield development is hard, and understudied. Every book on software development teaches how to develop a green field project, e.g. a project developed from scratch. Which is good. But no one is taught the essential skills and practices of brownfield development.

And that hurts. Very much.

What are the problems associated with brownfield development? They are many and varied and depend on both technical and human reasons:

Lack of understanding on the underlying reasons why a technical solution was chooses to solve a particular problem.

Lack of any legacy technical documentation and tests.

Developers think they know the 'only right way' to develop software.

Fear and uncertainty of breaking existing, working functionality.

When working on brownfield project I've found the following to be true and very helpful and productive:

Do not try to re-engineering the project when implementing new functionality, when the time comes that will be the only thing you will be doing. That way your will not bog down on useless, defect prone work.

Do it as the other guy, use the same existing infrastructure and follow the same development principles. That way you will not add competing solutions and will achieve a homogeneous environment.

Write a short, concise documentation for each feature you develop. That way everybody will know what you have done and why.

Document key technical solution and practices in the project. Some problems and questions keep reappearing over and over. That way you will save everyone the time and effort of figuring them by them selves.

Write smoke tests (functional or unit) for the core functionality of the project. That way you will always know if the core works or not.

The goal here is to not increase needlessly the complexity of the system, to save time and effort and to quickly gain the core knowledge the other guys had. If the client wanted you to re-engineer their system they would have hired you for that specific goal. It is often better to follow existing practices and procedures than to try to reinvent the wheel and fall in a bottomless pit of defects keeping popping up and deadlines never met.

Another day sprint

2009-09-10T09:39:00.002+02:00

I'm concluding another day and a half development sprint. I started yesterday at five a.m. with a trip to Zagreb which lasted till six p.m. , filled with back to back blood grinding meetings. I've returned to Labin at eleven p.m. and started working on a deadline pressed project with three other developer. We've succesfully deployed the newest application version fifteen minutes ago. Another hour, and I'm crashing and burning into the nearest bed.

What lessons I've learned:

Writing at least functional, or just smoke, tests solves much development problems

Task development is half of well done feature

Regular standup meetings for tracking progresss and quick reactions to changes in the project situation

Wokrin in a virtual enviroment saves time and money, and increases the speed a new developer can join an undergoing project

Power naps help a lot

What is the motivation for doing a day and a half development sprint? For me is the challenge and the opportunity to be a hero, to save the day. To complete something hard and critical, which not many people can do. For others, I don't know exactly, but I recon is the same as me. I feel downright special right now.

Well I am special. so are my colleagues, we are a special team which completed something special. Nobody can take that away from us.

Sharing your knowledge

2009-08-25T21:04:00.001+02:00

Why are developers, and people in general , so prone to entropy? Most of the software developers I know are really quick to throw aways good engineering practices in favor of writing more code. And use the same code writing exercise as an excuse of not doing those practices in the first place.
I have to much work to do! See, how many bugs I have to fix! What do I get from writing all these down, nobody will read that! Testing is stupid, I will be the only one doing it , everyone else doesn't do it!
Oh , how many such sentences I've heard from everyone I talked to. And the energy I spent correcting each and different attitude. Ah! And then to see them fall back to their evil no engineering ways, practically makes me wonder why do I try.
OK, I try , because I really want to teach others what I know and think that should be a practice for all experienced developers, only this way our profession will grow and evolve. I do not gain anything by not sharing and teaching others.
What are the benefits of sharing (for example with your team mates):

You can shuffle boring and uninteresting work to them, while you focus on more challenging stuff

You can discuss problems with someone who understands the topic , and possibly made some learning on their own

You learn by teaching

People around you will write code with greater quality

Teaching others , or sharing knowledge , has its drawbacks :

Time spent teaching others is not time spent on improving you

Teaching others (in my experience) often diminishes your knowledge in the eyes of others , since for them is so easily gained

Teaching is a strenuous and continuous process with unknown results (if you want to see big bangs for you bucks quickly, better be ready for disappointment)

And the greatest truth of all: you can't force people to really learn and implement that they are not interested in. Especially if you do not a rifle on their heads.

Back to work

2009-08-24T06:44:00.000+02:00

'm nervous, really nervous. For the last two weeks I was at home, resting and relaxing on my hard earned holiday. These were the first totally relaxed two weeks of holiday in , I think, more then five years. And now, today, I'm going back to work. And I'm so nervous. Really.

For the past two weeks I haven't studied anything related to the field of Software Engineering. Instead I spent my time with my son Sven and my wife Tijana, I read fantasy novels (Steven Erikson “The Bonehunters”) and prepared a 4E D&D quest for my wife and our two friends. In short I was a lazy bug in all. Now is time to go to work and enter the grinding machine of stress, constant learning, long hours and impossible deadlines (no deadline is impossible, it is just impossible what you want to do in that time span with the resources you have).

How do I cope with this emotion? Well I woke early, I restarted my morning pilates exercises, opened a DNR TV video for Windows Workflow Foundation. During lunch break I will read “Software Engineering” 8th edition, and will begin a new practicing advanced ASP.NET 3.5 in hopes of one day continue with WCF, WPF and F#.

Will I succeed? Will I be my old self and continue my work as usual? Or will I fall victim to laziness and the eternal question: Which is best, fighter or wizard?

Second Opencoffe Istra meeting

2009-08-11T12:38:00.001+02:00

The second Istrian Open Coffee meeting will be held on Saturday 15th at 18:00 hours at the “Cvajner” caffe on the ancient roman square of Pula, on the tip and shorelines of Istra, the greatest peninsula of world. Come and join your fellow developers with excellent coffee, free Internet wireless connection and exhilarating talk about everything web development, web design, business and marketing on the web. Everything goes, as long is remotely related to the web.

To find out more please join the Opencoffee Istra group. There is no shortage of people willing to help a fellow web enthusiast.

A special call is made to all web designers or front end engineers out there. On the last meeting the tip of the scale went to the developer, business side of things. The present web designers felt a bit alone with their tags, photoshops and animated gifs (or should I say flashy thingis). If you are a web front-end enthusiast your are more then welcome on out next gathering.

Do not forget, the next meeting will be held on the 15th of August, at the “Cvajner” caffee in Pula on the ancient roman forum .

Document first , document later

2009-08-07T06:40:00.006+02:00

There is a great debate in my head, what is best – to document first , or to document latter. The wanna be engineer in my head would scream “Document first!”, but my practical side, the one that has been into the trenches, that has seen things, horrible things would say “Document later!”. How to reconcile those two opposing views?

Documents can be generally be placed into two broad categories, those that are:

Generally written before development

Generally written afterwards development

Why do I say Generally? Because in software development nothing is set in stone, and everything is fluid, thus documents cannot be said to have been written always before head or afterwards a piece of software is developed( class, module, library etc.) . A set of documents could be generally written before head, like requirements or the high level architecture, and some are generally written afterwards like in some cases detailed API technical specification.

What makes a document fall into one of the two general categories. Two things :

Type of document

Current state of the software life cycle

The Type of the document generally dictates when a software piece will be written. Like, requirements or the functional specification or something like that which is generally needed before a piece of software is written. And some which cannot be (or can, but albeit very hardly depending on the skill of the developer and the knowledge of the system), like detailed technical specification which is not ever accurate when written first and is ever (hopefully) updated once a particular piece of software is written.

The other most contributing factor is the current state of the software life cycle a team find its self in. When developing a green field software it is generally best to do the documentation first ( I'm not discussing waterfall here, you could develop module after module, and before each module write the technical documentation for it before going into development), but when a team finds it self knee deep in a brownfield development project, which generally doesn't have any documentation what so ever, which isn't even commented properly so you cannot generate an API spec automatically which is remotely useful to anyone, when you need to fix unknown defects, when you need to implement a piece of functionality and don't know how to place it inside the project and how it is to be connected to everything else, writing documentation first could be and exercise in futility since you don't know enough about the system. This will change gradually during brownfield development when you will reach a state where writing design documentation first would be a better choice in terms of quality of work and writing speed place into the construction of the document.

So, what to say to may two different parts? It depends. And that is the only answer I can give them, which places my little self once again on the verge of a nervous breakdown due to over thinking so simple things. But documentation is important, some cannot see that, but those cocky bastards will soon find them selves trying to remember how they did that, or where somebody placed this and how is generally this implemented and so on, and will loose valuable money debugging the thing out of its life in order to find something which would take five flimsy minutes to read. Who is stupid now, ha?!

Database development blues

2009-07-25T22:53:00.000+02:00

In most line of business application there are two major types of artifacts involved : the database and the application. Sometime there are two types of developers, but mostly that is not the case. The same pure smuck that built an entity inside the application will usually write the database and UI code for it.
Well generally I don't think thats wrong. I strongly belive in cross functional teams where each developer can work with equal skill on each application tier. When you work in the outsourcing industry as I do, you quickly came to appreciate those team members who seem to be able to do evertyhing: database modeling, stored procedures, domain objects, html and css layouts, documentation, testing and so on.
The major problem with the approach of one developer doing both the application and the database work is that that developer approaches the database work in the same way as he approaches the development of a typical application. But those two types of artifacts are not the same, they behave differently during each phase of the product life cyle.
The application code is fairly easy to modify, extend and delete where the database code is always resistant to change, and it grows more resistant as the product and its database grows. Why is that?
The database is composed of three different types of artifacts:
Data structure
Programmed logic
Data
Data structure is the logical representation of the types of data stored in the database and their respectiove relations. We call them tables.
The programmed logic is what we say to the database it should do with the data that goes in and out of a table. We call this : stored procedures, functions, triggers, constraints etc. To most developers this is the closest thing to real development they will find in a database project.
The data, well, there is not much to say about that. This is the meat and bones of what a database is to most people. The reason d'etre of a database. Users data, application or system data stored for eternity in a database for all to see and use. Most databases store data about them selves in special databases and tables. Figure that.
Well the thing is with databases that the data stored inside them is the most valuable thing in a line of business project. A developer can frag the entire application code and it wouldn't be even as worse if he fragged the data stored in a database. So, losing or modifying data in a database is not a good thing.
As a database (and its accompanied application code) is being developed the volume of useful, production data inside it grows. Each change to the database structure becomes much hardere, since you cannot loose data (thats why most people try to nail the database structure before starting the development process) , and it gets even worse when the database goes live to live free in the wild of an enterprise IT infrastructure. If you frag the database there you can kiss your ass, head and small fingers good bye because angry people in business suits will descend apon your small little you like vultures on a helpless white rabbit with its back pawns broken. Its that bad.
So working with the database is hard and risky.
The underlying fact with the database is that its always changing. New data is added inside it, changed, deleted. The structure is change, new tables are being added each day. Even the programmed logic changes from time to time. It is always changing regardless of it being in development or in production. While the nice and good application code changes quite rapidly and easily during development but its damn impossible to change when its compiled in an executable and shipped to remote production server in the prairie.
So what to do when you have a line of business product to ship on a rapid development track with database and application work done in parallel by the same people. Well , its simple.
Stop making changes in the database manually. Write scripts.
Repeatable, stable , data saving, scripts.
Then , respect the database. It is not your run of mill .NET application. It requires different development practices.
In database work you done have the write, compile, test life cycle of application development. Once you loose data it is gone, once you mess thing its hard to go back.
Think of a new development process for working with the database. It will repay you ten fold in virgins.

14th SQL/DEV User Group Meeting in Rijeka Review

2009-07-10T13:51:00.002+02:00

I must say it was an interesting trip. Me and my team went to Rijeka yesterday to attend the 14th local SQL/DEV User Group Meeting. We took a company van and proceeded along the eastern Istrian coast to Rijeka. It took us two hours due to extensive working on the repair of the road and hordes of tourists enjoining the scenery.
We arrived an hour latter than planned.
The meeting was held at the "Naval University" of Rijeka. There were around fifteen to twenty people mostly from three to four companies including our own.
The entire event had some good and bad sides. I'll categorize them .

The Good

Interesting and friendly crowd. We all were welcomed there warmly, and the fact that we were the new faces there made no difference. The MVC talk was interesting, rich with data and the speaker was well informed and mostly good. I met Aleksandar Zgonjan of Pro3x there. After the presentation we all moved to a bar near the train station and had a drink there. I met several persons there including Jasmin Ćelić the president of the local programmers guild. We discussed the possibility of met organizing a presentation there.

The Bad

The technical equipment did't work. The projector malfunctioned or it didn't work with windows. I don't know. We started the presentation one hour late when Hrvoje Hudoletnjak brought a new one from work. Because of the that the IronRuby and Ruby on Rails presentation was not held , which was a shame for me because I was interested in it.

Conclusion

All in all it was a good day. Rijeka is a fantastic city, full of life and history. The most fascinating thing was the torpedo exposed in the courtyard of the university. A historical note : the first torpedo was developed in 1905 here in Rijeka in the factory "Torpedo". I touched the damned machine , examined it head to to toe and event fearfully knokced on its point a few times.

14th SQL/DEV User Group Meeting in Rijeka

2009-07-09T14:38:00.003+02:00

I'm thirty minutes away from a trip the fourteenth SQL/DEV User Group in Rijeka. This time its a corporate spornsored trip. Five other colleagues are going with me. We managed to gather up a big van with air conditioning and, event , a corporate sponsored meal. Nice.

The SQL/DEV user group meeting will be organized in the Nautical University of Rijeka and will be composed of two lectures :

ASP.NET MVC development practices

RubyOnRails, Ruby and IronRuby for .NET developers

And of course, after the presentations a gathering will be organized with drinks and snacks with all the attendees which will be an opportunity to meet new people and learn or discuss about interesting ideas and technologies.
I really think these type meetups are important for a developers advancement, since you can learn and hear about development use cases which would normally be hidden from you.
I started thinking about organizing a presentation for the next OpenCoffe meeting. Something short, maybe half and hour long, and interesting. Practical, maybe event daring in the specific way I conduct all my presentations ;)
I haven't decided anything yet. I was wondering to do something on the following themes:

Web UI testing and automation

Web portal development process

Drupal theme development

PHP Unit testing

Building an MVC framework in PHP.

Workflow Foundation

ASP.NET Data binding controls

Don't know. More that I think about it I realize that I know squat. Maybe I should just cover and listen to wiser heads talking.

OpenCoffee Club Pula Meetin One Review

2009-07-05T15:28:00.000+02:00

The summer air was full of heat and sweat. It was heavy, oppressive and devoid of people. The streets were empty. No one was out except from those unfortunate enough to work on the hottest day of this summer or those stupid enough of not having anything else to do that included the sea or something where the air conditioning was turned to the lowest cooling option available and then some.
And there was I sitting on the therace of the "Cvajner" caffee in Pula nervously waiting for the attendees of the first Istrian OpenCoffee meeting. I came twenty minutes last and sat in the coolest spot I could find, ordered my white coffee with sweetener and water , please, and started reading the eight edition of the Software Engineering book.
And then it dawned to me.
How am I going to recognize all those people. And most importantly, how are they going to recognize me? I didn't know the answer to that question. I started to look around. Two tables east of me a group of girls, mostly hot, sat around a laptop and discussed firewire software. Hmm, I thought, the don't look the web developer type. Should I approach them? I decided not. And so I waited.
The first to come were Lucijan Blagonic of PolarNorth.org and Emanuel Blagonic of emanuelblagonic.com/ and Extendis.hr, two brothers who professionally work in web design and user experience design areas of the business. As I feared they didn't recognize me at first as a fellow attendee. My fears were found. I noticed them. They stood on the entrance of the Cvajner cafee and darted open looks around as if searching for Richard Stallmans ghost who, as the popular legend says, developed sometime ago in this same caffee where our first meeting was to be held. I thought they must be fellow attendees, but I was to shy, scared of a public debacle and most worst humiliation to openly approach them so I used the most sly tactic possible. I closed the book I was so pointedly reading almost a moment ago in order to show the cover.
And it worked.
Lucijan and Emanuel noticed me and approached. Thus the first Istrian OpenCoffee meeting kicked off. And it was glorious. Soon others arrived.
First of the rest was Tomo Krajina digresije.info/ and panoye.com and puzz.info. He was followed by Toni Milovan of fwd.hr and mackorisnik.com, and
We started talking almost immediately. What is your specialty? What are your interests? It was the same for every other attendee who came later. The themes were a legion and our knowledge extensive.
I forgot about the oppressing heat, the girls two tables away. We talked until nightfall and then some. We covered a lot of themes , but only a scant few stayed in my memory:

Best web development platform

Open source content management frameworks

UI test automation (I even developed an example on my laptop)

High traffic site optimization

Gimp Vs Photoshop

Tables vs. Divs

Everyone had his own opinion and freely shared it. We joked and no one was barred from talking. The atmosphere was friendly and interesting and I will definitely attend next time.

I was wonderful meeting. We all agreed to meet once a month, and that all the meetings will be organized through our google group OpenCofee Istra.

OpenCoffee Club Pula, first Meeting

2009-07-03T21:27:00.002+02:00

On Saturday 7th in Pula will be held the first Open Coffee meeting for web developer and other related ilk. The meeting will be held at 19:00 hours in the coffebar "Cvajner".
I'm really excited to attend this meeting. I see it as an opportunity to see and talk with people with the same interest in development technologies who are not necessary work related.
A google group for the meeting was created here for those of you who would like more information.

Overworking it, a bit

2009-07-01T04:55:00.002+02:00

Its five past five in the morning. I'm literally sleepless. The amount of work I've been doing recently is crazy. I've been at work for twelve to fifteen hours a day, plus we had two all nighters (twenty three hours of software development in a stretch). And, of course I've had the added bonus of leading a team or two during that time, so it added up on my burn out status.

I'm a wreck.

I rose early because I'm going on a business trip to Zagreb for a meeting with a client, and then to Ljubljana for another meeting with a colleague. Wow! What a trill.

I'm so wasted.

The tiredness is not a problem. I'm coping very good thank you. It's my learning that the problem. I really neglected my studies for the past month. Yesterday I finally finished "Pro WF" after six months of reading. Stupid. Once I read a development book in two weeks.

I must pick my pace or I will be crushed by younger, more time free forces.

What choices do I make to look at my feelings in the growing summer rain

2009-04-30T14:41:00.003+02:00

I've been tasked with my first real leadership position in my current company. I'm a bit struggling with that, since it is new for me and I'm involved with about four to five different projects at the moment.
What made my job easier , and what actually prepared me for that, was the following:
1. My experience as an Insurance Adjuster
2. My occasionally blossoming social life and non verbal recognition of human emotions( it is surprising what people will tell you with their body language)
3. Technical books like "The mythical man month" and "Rapid Development"
4. My project manager, who is also a great teacher
5. Regular stand ups
6. Task management (help you Manager Tools)
8. Learning to ask the right questions (What problems do you have? When are you going to be done?) Surprisingly effective.
9. Delegation, you can't delegate enough! (again, thank you Manager Tools).

The sun and the way UML diagrams fold on my freshly inked skin

2009-03-02T20:42:00.003+01:00

It is my firm belief that any modern developer, being junior or senior needs to know at least the basic of UML 2.x class, sequence and activity diagrams in order to be productive in his workplace and to communicate effectively with his coworkers about one of the most hard and abstract matters known to man, by which I mean the matter of software design.
But what I find in the field today is sorry state of affairs where the majority of developer are not aware that UML even exists, a small percentage of can read it and only a handful can write and express them selves in the fine software modeling language of UML. It is my opinion , as a practicioner of the craft, that each high school that teaches programming and each university that prepares young feeble minds for a career in IT or software development must teach its students the basics of reading and writing of UML.
UML is most critical to understand object oriented design. When a developer is able to express his idea about a system in uml , that developer shows a deep understanding of that idea, and therefore is able to teach to other, implement it by producing qualty code and adapt it to changes which are sure to come in the future.
Code which isn't described by UML (or any other notation for the matter)is hard to read, hard to teach and hard to change. Code that is described by UML isn't any of those things.
But by the God of Chips and Neurons, UML isn't hard to learn either. You just need a manual (e.g. UML distilled by Marting Fowler) a pen and sheet of paper on which you can sketch your first diagrams. I've learned my UML near the sea in Pula where I live. I would put the Fowler book in my backpack, take a notes and a black 0.4 pilot pen and I would venture on foot the Pula's "long see" (lungo mare) a walkaway for tourists and kinds high on booze and midnight sex , and I would sit there by the see and draw my diagrams watching the sun go down deep below the summer sea and enjoy my self learning a powerful tool which made a better developer, a better person and more ... I don't know.. just better than I was before.
That should be enough for any of you sorry asses who haven't had the time to learn a tool as basic as UML.

Automed User Inteface Testing

2009-01-27T20:25:00.004+01:00

User interfaces components are hard to unit test with standard unit testing framework. There are several reasons for that. In my opinion the principal is the fact that user interface components rely heavily on the interaction between the user of the system and underlying framework of business(or other objects) supporting the user interface control. And sometimes, is quite hard to remove the component from its natural environment for testing purposes, as is the case with ASP.NET web components.
The solution to this problem is two fold. First all domain and infrastructure objects should be logically and physically removed from the user interface and unit tested separately using convectional testing methods. This is nothing new, there are numerous design philosophies associated with that (for example the MVC design pattern always so popular with web development frameworks). The second is to to test the user interface component attached to its underlying system base, in a separate - clean - environment specially prepared to for testing purposes using automated unit testing tools.
For example and ASP.NET application whose user interface is composed by a separate web component library and relies heavily on client side code to facilitate heavy user interactions with few page reloads in order to maximize user experience (ah, the oh so popular Microsoft buzz word of the moment) and to reduce stress load on the system. There are five distinct parts to this application:

ASP.NET user interface

ASP.NET web control

ASP.NET web control domain objects (entities, repositories, services and specifications)

Javascript user control attached objects

Javascript domain object

All these parts compose the user interface of this theoretical (and so typical application). First , lets us remove all domain objects. Both client side and server side object can be tested using respective testing environments. Now for the remaining three elements there is no way of testing them separately. And, also there is no practical need. Because the goal of testing user interface components is not to see if each of them works correctly as a separate unit (it is impractical , because the amount of mocking requires a separate framework of its own - often custom made for one project only) , the goal it to test the user interface as one system (logical separated by functionality, just to give some order to the mess) in order to provide to the team and to the customer that the system which is built provides requested functionality.
This is accomplished by using automated unit testing frameworks. One that I especially like is Watin, an open source project under active development which allows any developer to programmatically test the user interface of any web application inside Firefox and Internet Explorer (which we are the two browser mostly tested by web developers).
Watin is a good framework. Of course there is place for improvement, by what is accomplished now is very useful in enterprise strength projects. For anyone who has developed with javascript using this framework will be easy and will come naturally.
I would recommend it for everyone doing serious web development in any environment and with any tools.

Designing proper HTML code

2008-11-20T23:30:00.003+01:00

I think there is a need to engineer HTML code in a web web application, the same way server side and client side code is engineered. I'm posing my self the question how?
For standard programming languages I use UML, but UML can't be applied to HTML. Html denotes the structure of a hyper text it doesn't model interactions or functions. It can't be effectively described with standard software engineering techniques.
HTML code is simple, and short and anybody can learn to do it in one hour. It would seem to the causal user that HTML doesn't need to be specially engineered. I think that is not the case. Every web application is always finally rendered into HTML. All user interactions are defined by how the page is structured in HTML, the way the server side code is structured depends on the way HTML is structured and the ease CSS can be developed also depends on the way HTML is structured. Not to mention cross browser and cross platform portability.
It really matters if a developer uses tables withing tables, or a series of stacked divs. It really meters the decision between table cells and unsorted lists or paragraphs. When put in perspective, most problems I've encountered in my career as a web developer had to do in a way with badly engineered HTML.
I think it is critical to find a way to design and plan markup code for web applications. If we as engineers spend so many hours a day preparing or code and our applications to be of the maximum quality, I think it is imperative to spend the same energy on HTML.
I know what you think. HTML is not serious, it is for kids not engineers. But look around you. Web applications are everywhere, and so it is HTML. Without HTML there would not be the world wide web as we know it. Its simplicity is what it drove web applications inside and outside the corporate firewalls. And neglect to properly engineer HTML code is one of the root causes of the poor qualty many web applications suffer.
It just came to me today, this idea. I spent several days designing several objects in UML, documenting them, writing them, testing them, writing and thinking about unit test, automating them, and it all worked as a charm. But when it got down to HTML and its sister cousin CSS I worked as newb coding like hell without preparing out a head, doing a crap job on a critical part of the application I'm working on. I can't put it there like that. I have to rewrite it tomorrow to increase the quality of the code I'm producing. But how many hours of work would I saved if I engineered my HTML code in the same way I engineered my javascript and C# code?

Learning the devils way : killing the interest first

2008-11-03T11:48:00.002+01:00

I grow tired of the endless stream of SQL going into my head on daily bases. It all looks the same, but with subtle differences. I'm just no so interested to learn what different flavors of create table exist out there. But I must. But I so needed to advance my self career wise.
So I soldier on. Learning T-SQL every day, one hour a day. My personal learning time. And during my project time I'm learning PL/SQL. Of course my project time doesn't allow me much time to learn all that I need about the damned Oracle SQL dialect, so I learn during my break, during my free time at home in the evenings experimenting on the Oracle 10g EX database I've installed on my Ubuntu machine for just that purpose.
But it tires me so. I would rather learn Jquery or Dojo, or read some new PHP book (like PHP in Action from Manning), or continue my studies of Django or learn a new cool language like Erlang or OCaml. But not. I'm stuck with T-SQL and PL/SQL. It is my choice. One that I had to make.

I have a bloody dream of software never written by a sane head

2008-10-29T22:16:00.006+01:00

I have a couple of ideas. Development wise. Something I want to do on the side on my free time usually spent not being with my family but watching stupid tv shows and movies in order to free my mai9nd from all day developing in some stupid, soon to replace programming languages. But I digress.
I had several ideas today:
1. Writing an unit testing framework fro stored procedures in MySQL, written in MySQL for MySQl. I don't think those exists. And I think they are needed for the all continuous integration thingy. and I think uit would be an interesting idea to implement it. If , ever, I'm going to do that I'm going to open source it and host it on Google Code. Way cool idea, I must say. I'm impressed with my self.
2. Writing a microblogging service bus that will connect to other microblogging services of interest pool their data and present disperses them as a part of their aggregate feed.
Here it is how I envisioned it. It would be php based on REST. So simple pot and GET request. no fancy WSDL. XMl would be used to send data over the web each service bus will host data and provide service for one personal microblog (which would be accessed through a client, separately written in whichever technology I or someone chooses). Now the owner of the microblog would in theory register to someone else's microfeed, and pool their data as well as his whenever a microblog feed would be requested by a client (obviously mine and theirs feed would be differentiated). Each microblog would also post a service with commonly used words to link to a cluster of relate microposts, and a service listing other microblogs aggregating feeds from this blog.

3. For my next laptop which I will buy in a couple of years I'm going for a pure virtual platform. Here is what I want. A laptop with a fresh, fast , stable and lite linux install with VirtualBox or something better installed. And then several virtual machine , with various configurations(I may need to run several on the same time) , each used for a separate purpose - testing, development, home use, art... etc. Neat. I just can't wait for 2010 to come. Thats the year I'm going probably to get my new laptop. Maybe. If I'm lucky. Really lucky.
On the personal note, my son who just turned eleven months old and I barely see during the week started walking by him self. So no longer hand holding. No boy he is a home missile bent on general havoc and destruction. I love the little dynamo.
I work for nine hours a day, minimum, and drive for two hours plus one hour for waking up and doing morning stuff nobody needs to know. So I'm gone for twelve hours each day during the bloody week. And that my friends takes a toll, on me on may family on everybody. And of course when I get home I'm next to useless.

Oracle , stored procedures and table statements

2008-10-25T00:41:00.002+02:00

I drive for two hours every day to go to and from the work. In my car I hav an mp3 player and I spend those hours listening to trade podcasts. Mostly .NET rocks, FLOSS weekly and Stack Overflow. There are others , but they are not currently worth mentioning. I heard in one episode of .NET rocks that the internet is killing the software printing industry. They said that less and less people have time to read and study a book on any topic for several months before starting to work with the technology they were studying. Now, everybody uses Google.
Developers usually open their IDE, or editor, read some tutorials and then start coding. When they hit a problem they google the solution for it. Nobody reads. Nobody has the time to learn a technology that will change inside a year. I guess is true. Thats how I started doing it. Learning by googling. And really, I think thats the wrong way to do it.
See, here is my rationale. You can acomplish lots of thing by doing that. But I guarantee that you wont do it right, You are bound to miss some fundamental things. Or you are going to use the wrong solution for the problem you are facing. All things which would be easily avoided if you've taken time to learn a technology properly.
But thats not possible. You have so much to learn, so many possibilites. It is not possible to learn them throughly. It would take you all your working day to just keep up with all of that, I wish I could. But I can't.
What I do is pick a technology, buy a book or two and separate one hour a day, each working day to learn it chapter by chapter. These are technologies I like or think will be critical for my work for a longer period of time. Like SQL Server, or ASP.NET.
Now things will come that will require of me to learn something new just for one project. The technology in question may be extensive, but I don't have the time and the energy to learn it properly. In those cases I resort to Google to be my guide.
And thats what happened with stored procedures and Oracle. See, I'm kinda the db guy for my team. So for our latest project I got stuck doing database work besides my regular web work, Our client uses an Oracle database. We planned several stored procedures to handle all data transactions between the client and the database. Now, I haven't ever worked with Oracle and PL/SQL. And the project was way under way , so I didn't have much time to learn PL/SQL. So I started googling.
My first task was to create two procedures which would create some new tables and destroy them respectively. Some alter table statements were thrown in the mix.
Now , the first problem was that I couldn't do CREATE AND ALTER TABLE statements inside a stored procedure. I had to use EXECUTE IMMEDIATE, which runs all sorts of queries inside the stored procedure.
Now the following problem was that the created stored procedures couldn't create tables becuase my user couldn't explicitly do that . My user , which was handed to me by the client, received its permissions through roles. In order for a stored procedure created by my user to be able to create tables and so , my user must have the CREATE TABLE privilege granted to it specific.
Here is the code:

GRANT CREATE TABLE TO UserName;

CREATE STORED PROCEDURE TestProc
AS
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE TestTable (name VARCHAR2 NULL)';
END;

It took me two whole days to do that. Fantastic. One site that helped me a lot was this.

Incompetent people piss me off

2008-10-21T12:14:00.003+02:00

I'm so pissed when someone in the team does not do their job. I'm so angry. And what angers me most is when I have no power what so ever to compel them to do so. I can say something. I can remind that someone about what they must do, and I can even share the work weight with them which is the stupidest thing for me to do, since I'm not paid to work for two people. I'm not paid to do any of those things either. But I do them non the less.
I'm so pissed off.
I want the project to succeed. I want to advance in my career. I depend on my team mates doing their job so we can all succeed. Software development is not a single player activity. It takes several people to finish an average project. It doesn't take one, it takes several. But what if some of them do not want to do their job. What if some want to sit in their chair, do nothing except reading funny papers on the internet and saying: I don't know anything, I don't know how to do that bla ... bla... bla...
Move your ass, god dammit. You retarded morons. Why did you even applied for this job if you didn't want to work and commit your self? Why! There are plenty of government founded jobs for those type of people. Leave room for someone who wants to work.

Fighting to learn

2008-10-20T12:39:00.003+02:00

Learning things is hard. It takes time and resources, not to mention will. The older I get the harder it is. I think that's true for every body. I just read a blog post from Ethan Vizitei and I couldn't agree more with what he said. I don't know. This is something that was bothering me for a long time. See I'm a learner. I like to learn, I want to learn. I want to better my self.
I've been doing it since I was a boy. Learning to program, learning to write, learning a new trade or skill. Always learning, always being a target of those who do not. I had a rough child hood. My learning separated my from my peers. People do not like those who separate them selves from the mold. I knew things , I wanted to know things and people reacted violently when I showed my knowledge. Verbally and physically.
Bastards.
When I grew older and bigger, when I started lifting weights people stopped being physical with me . I moved away, started working in the industry and baam. They still were there, those who refuse to learn.
Its OK, that's their decision. I accept that. But the sheer amount of energy those people used to deter others from learning and introduce new things is amazing. I just always kept finding my place in knowing what others didn't (not something unusual per se) for the sheer fact I willed my self to explore and learn those things. How can anyone evolve as a software developer if not by constantly learning new things?
It's just tiresome talking with those people. Explaining things to them, listening to their half baked rationale why things should remain the same. It is so hard, it is so depressing and so fruitless. You can change people, you just cant... But refusing to learn, refusing evolve is not something I will settle for.

I wanna learn Java

2008-08-21T20:05:00.003+02:00

I wanna learn Java. I want it so bad. Well not really that bad , but I was always interested in working with this technology. But I never got around to learn it.
See I had this career development plan in my head. I wasn't about where or what I would be doing, instead it was about what technologies I would use and when. I started my professional career with PHP, then I've migrated to Python and now too C# .net, which was something I didn't plan for. I've always had a fondness for open source cross platform technologies. Too me, locking your self to a specific operating system is not what a modern developer should do. With so many options out there , too me, what makes the most sense is to develop in technology that is OS agnostic, instead to lock your self in a proprietary technology and thus reducing your employment chances in case of loosing your job. Is good to be flexible.
So why Java? Why not be happy with .NET, is the same thing only different package? Too me this is a philosophical question. Do I want to make my money locking my self to a company that I really do not admire, or do I want to earn my bread working in something that is open, portable and positive?
Well to me today the only logical choice is Java. And in couple of years I want to be known as a Java developer.

Web applications as web services

2008-07-31T21:44:00.002+02:00

My running theory is that a typical web application is in reality a web service - distributed and reliant application. It is no surprise , I think all experienced web developers know it. On one side we have the server machine which runs HTTP server that is handles traffic to and from our server side application. The technology that is used to build the server side application is irrelevant. Nowadays you can use almost any programming language known to man to build a server side application. It is a matter of taste, really and of course client expectations. What is important is the fact that our application responds to request trafficked through the web server with code that is transmitted to the client using the HTTP protocol, and which is "compiled" into an client application inside the browser Virtual Machine. That client application is then able to send request back to the server for a new set of code which in turn will replace the existing application with a new one.
Well, that was true in the past, and not so much today (I'm talking about web apps here, not pages - I make a distinction between the two) because we have WEB 2.0 client apps that send request to the server for periodic updates for the client side code without the need for the complete user interface deconstruction we always experienced in the past, with what the ASP.NET guys called the old post-back model.
So if we think about our web apps in this way is no wonder that we need a team to build even the smallest of web apps. Excpecially if we wanted to build them right.
Web application developers experience a host of problems regular developers don't even know about. First there is the whole browser compatibily issue. CSS, HTML and javascript do not render on different browser, different browser verisons or event different operating systems in the same way. A piece of client side functionality that works in Firefox on Windows wont work on IE. If we are building a big app, we need specialized teams for each browser family in order to provide the maximum stabiliy and user coverage for our apps. Thats one problem we all know and hate for the life of us. But one problem that is often overlooked and not discussed out loud is the fact that HTML as a UI generating language was not designed to build UI for web applications. The original goal of the language was to ease the disemminationa and aviability of scientific papers between scientist. Not building applications.
And thats a big problem. If you've ever done javascript heavy applications you often encountered problems and you had to generate tons code to solve them , just because you wanted to implement a functionality that would take in desktop application several lines of code to implement.
I'm really glad that with HTML 5 they are going to fix or attempt to fix the problem. And what Micrsoft did with XAML in Silverlight and WPF and Mozilla with XUL is a real step towards the solutions of the problem. Thats how real web applications should be build in the first place. Why do I need to regenerate the entire UI with every click of the mouse, and why do I have wait so much time for stuff that should be handled on the client. The only thing that should be shuffled across the net is Data, not code to be compile again and again on my computer. It is not practical, it is not functional and it is not friendly. And what really bothers is me is the notion that building web applications is easy, is fast and simple and that kids could do it and its not real software engineering work. And what bothers me the most is that the notion often comes from people who know absolutely nothing about web apps.
First you have to wrap your head around the service generated and absolutely reliant client, than you have to learn and really understand five different technologies , of which four are have several critical difference based on the virtual machine they are executed upon (HTML, CSS, JavaScript and XML). The only simple thing (simple in the fact that you have to know one variation at the time ) is the server side language.
And you can do so much with the web, and it really pains me to see that people don't really understand it and to see so much problems that arise from that ignorance that could be easily solved if the applications in questions were developed with little more understanding what it takes to build a web project.
To build a web product you need to have to following people:
A web designer
A graphical artist
A javascript engineer
A RIA animator
A RIA programmer
A server side engineer
A database administrator
A system administrator
A really, really good architect
And what is important a leader with a vision and understanding what the platform requires of the people that are building atop it.

Fun at work

2008-07-25T09:47:00.003+02:00

It's not all hard work in my life. There is also fun at play. At work, I mean. I have plenty of fun at home with my family . My son , Sven, just started walking and I'm so happy watching him stumble with his first steps. He is so cute. But I digress, my family is not the theme of this post.
My work is.
See, when someone here celebrates a birthday is customary to throw a small party in the office. And since I work in a company that has more then three hundred people is party all the time (well at least once a month, because not all people actually celebrate their birthday or want to throw a party at work- but most do). Since my PM is often away, his desk is empty so people use it as a place to host the food and kick start the party.
This is quite nice, because my appetite is insaciable and having scores of food behind me really is handy when working. Plus is free, which is an even greater bonus.
I've posted a picture of the last party( which was , emm, today not one hour ago.. plenty of food left behind me). The picture shows the desk behind mine littered with cookies and juices:

My take on MVC

2008-07-20T21:05:00.004+02:00

MVC , or Model - Viewer - Controller is very popular on the web framework market. It has become one of the selling points for web based applications and framework. Everybody has or has to have it in order to beat he competition.
It seams if you don't implement the MVC pattern in your application you are not serious. And we all know that the most important thing in software development is being serious. If you are a member of a fringe developing group (PHP, Python, Perl, Ruby and so on... ) you have cerantainly being labeled as not serius as a software developer by your more serious and respectable colleagues in .NET, C++ or Java land. And they are right. Given the fact that all the big, technologically unsavy client go to them to buy software. It really matters. Its a fact of life. If you wanna develop in the big league you must be serious (and therefore program in serious programming languages and use serious developing techniques).
I've being developing with PHP for over four years now. I've started working with PHP 4 and switched over to PHP 5 when it hit mainstream. I loved the OOP capabilities it offered. In the beginning my web apps were plagued by a mirad of simple and annoying problems. Liking issues, navigational issues, code and markup mixed together, character encoding problems and so on. It got better over time, and what really made my apps better, more easier to develop and maintain was the use of the Model - Viewer - Controller design patter.
Every one and his grandmother has his take on MVC . I've developed mine, and I think I got it pretty much right. Everything revolves around one file. That file will be the single point of entrance of the application. In most cases it will be index.php since it's a natural entry point for every PHP base web site.
Beside the index.php I will create a directory structure that will consist of three directories : Contoll, Model , View. And one other file config.php for various configuration options.
It will look like this :

/
/Control
/Model
/View

/template

/config.php
/index.php

The code for the index. php file is this:

session_start();
session_regenerate_id();
/**
* @author Nikola Stjelja ;
* @copyright GPL2
*/

//Load configuration
include('config.php');


//Get the control
include('Control/control.class.php');

//Get the model
$model=Control::get_model();

//Load the page
$model->load_page();

//load the view
include('view/view.class.php');

//show the template
View::show_template($model->template,$model->data);


?>;

Each request in your application will go through this file. First the configuration will be loaded. The config.php file will contians only configuration options. It is best to set those options as constants. The the Control class will be loaded. It is a static class, e.g. it doesn't have instances. It has only one public method get_model() which will return the model object. The model object has one public method load_page() and two public proprieties template and data, which are loaded as argument to the View static class. The View class handles any templating your application has to do in order to present its content to the client requesting it. The entire entry point of our application has no more that 29 lines , it is simple and readable. It shows you exactly what part of the application does.
The beauty of it is that the application logic can become quite complex but the underlying system will remain simple to use and understand. Needless to say that the most of the work is done inside the model object. Here is the abstract Model class each model object must inherit from:

/**
* @author Nikola Stjelja ;
* @copyright GPL2
*/

/**
* Main application logic. This class is inherited by all Model classes.
*/
abstract class Model{
//Template file name
 public $template='template.tpl.php';

//Array with the all data viewable as variables inside the template
 public $data=Array('title'=>'MVC Application');

/**
 * Class consturctor
 */
 abstract public function __construct();

/**
 * Prepares the page to be displayed.
 */
 abstract public function load_page();

/**
 * This method prepare super global variables for usage
 */
 protected function sterilize($var)
{
 $var=(strip_tags($var));
 if (get_magic_quotes_gpc()) $var=stripslashes($var);
 return $var;
}

/**
 * Class destructor
 */
 abstract public function __destruct();
}

?>

As you see the class is quite simple. It provides a simple interface that anyone can understand and use. The load_page is the main class method servers as the main class logic controller. The Control static class implement the Factory patter. It's main goal is to create the adequate model object based on the web page query. This is a very simple navigational mechanism. It allows to the developer great freedom in how to set up the site navigation. It's also very simple and short. The Control class may be extended with extra classes that check if the user is logged in or if the user accessing a resource has the right to do so.

/**
* @author Nikola Stjelja 
* @copyright GPL2
*/

/**
* This is a static class that checks for a specific query string, and
* upon it returns the expected model object.
*/
class Control{
private static $choice;

/**
 * Get the choice from the $_GET
 */
 private static function get_choice(){
self::$choice=trim(strip_tags(urldecode($_GET['q'])));
}

/**
 * Based on what date is contained inside the choice propriety return the
      * model object
 */
 public function get_model(){

//preuzmi izbor
  self::get_choice();

switch(self::$choice){

 
 //default model
   default:
  include('model/model.class.php');
  return new Model();

}
}
}


?>

After both the Control and Model objects have done their job comes than the time for the View class to do its. It views class takes two parameters inside its show_template method. Both parameters come from the Model object, the template name and the data array. The main job the View class is to find the template file, fill it with variables . The rest is upon the template file it self. Normally the developer can implement his or her favorite templating system quite easly. But I like to stick with pure php. With discipline you can write a pretty readable template file just using ifs thens and whiles.

/**
* @author Nikola Stjelja 
* @copyright GPL2
*/

/**
* Connects the template file with model provided data
*/
class View{

/**
 * Loads and shows the chosen template
 */
 public static function show_template($template,$data){
  while(list($k,$v)=each($data)) $$k=$v;

//Load the template
  include("templates/$template");
}


}
?>

The template is a standard php file. It receives its variables from the $data array generated by the model object.

How I started

2008-07-15T21:45:00.001+02:00

I started developing when I was ten years old. I lived in Umag, Istria with my parents and my yunger sister. I just received my first computer , the venerable C64. My father bought it for from a guy who worked in the marina, and smuggled it from abroad at my fathers request. My father has, and had a lot of connections. That will be for a man who for years was the sole insurance seller for a small town in Istria.
It was a grey, silent day. One of many like it in Umag. Winters were always hard. Empty streets, vast empty spaces where no one alive throdded and smiled. Not unlike summers where the streets were full of people, mostly foreigners who came here to enjoy their summer vacations. My father decided to buy ma computer after my constant pestering and nagging to buy me one. My best friend at the time had one , and I always loved to play games at his house whenever we visted his family. Finally my father decided to give in and by me a computer, to be exactly he decided to buy me a Commodore 64, just like the one my friend had. So, here we were, just outside the town marina, a gray winter day dying around us, and my father just gave a slip of deutche marks to a guy I never saw before, and most cerentainly will never see again, and in return he got a brain new commodore 64.
It was a dream come true. My mother, of course disapproved when she found out what had my father done. But it was over. The corner stones of my career as a software developer were set.
I started by playing games. All the classics , bought or copied from pirate collections bought legally at the time from a magazine in Belgrade. It was a different, different time. And I was young and living the life. I never grew over games, but I wanted more. I wanted to create them. I've created several board games at the time, me and the children from the apartment building played them together outside my apartments door, but I wanted to create computer games.
The C64 box came with dutch manual. It explained the basic of BASIC, how to write statements, how load and save programms. It was my mother who helped me out at first. She wrote with me my first 'Hello World' applications. She wrote with me my first 'IF THEN ELSE' structure.
She soon couldn't keep up with me. I always loved to write, and I also became interested in RPGs. I never played them, and never could in my little, redneck town. I read about them in a kids magazine. My imagination became so feverish with the possibilities RPGs offered that I just wanted to play them , write them.
My first games were a cross over between chose your adventure books and rpgs. The were short, written inside a day in BASIC, and morbid. My imagination ran wild. Of course, they are lost now, sacrificed to my adolescence.
The last thing I wrote for my C64 was an arcade. I just figured out how to do primitive graphics reading code from the back of the manual. The game was simple. The hero 'Super Nikola' chased the bad guy who was his dark opposite across the screen. I never finished it.
Times finally got us.
The war came, the famine, the fear. The big fucking scare. I stopped playing with my computer, and made my self busy with playing invisible. I'm from mixed ancestry, and in war time Croatia that was the wrong thing to be. So I survived.
After scary years things normalized in my part of the country. We were near the Italian-Slovenia border, so no war came to us. Only a flood of refugees from all over. My father got fired, and he and my mother decided to start a company. I started working there at the tender age of twelve years old. Just during vacation time. Manning the office, selling insurance and of course learning to use a brand new 486.