In search for the next abstraction

Programming Languages Are Simply Not Powerful Enough

2012-04-26T22:09:00+02:00

These days I’m reading Thinking Forth. A gem among programming classics now available for free under CC license. It is remarkable in the way it explains the thinking principles behind building elegant programs. The book is based on Forth programming language, which has very small amount of primitives and even for someone who never had experience with Forth before it is not blocker to grasping the essence.

It is known since the early ages of programming, most elegant programs are built as layers of "languages" or "dictionaries". These are represented by abstractions in a program in order to facilitate expressing the ideas in a way that is more related to the domain. Although this looks very native and obvious, it is extremely hard to reach to the level where this becomes natural in practice. Aforementioned Thinking Forth dedicates parts to explaining this principle.

Over my programming experience I have noticed one undeniable fact. Application development starts becoming significantly harder in the moment when level of abstraction in the application gets insufficient. I called it locking application down to the level of abstraction.

Motivation for this post comes from a quote:

In fact, you shouldn’t write any serious application in Forth; as a language it’s simply not powerful enough. What you should do is write your own language in Forth (lexicons) to model your understanding of the problem, in which you can elegantly describe its solution

One simple example from everyday life: Imagine that you don’t have in your vocabulary notion of a sum. Therefore, if you would like to tell someone to do a sum of some things you would always have to express the process of summation in details instead of just telling and then you sum these numbers. If you would like then to express more complex concepts that are based on summation, you would not be able to because you will be locked down to the level of abstraction which is broken. Your language will not be powerful enough to express complex ideas.

As the quote says, which ever is your favorite programming language, it is just not powerful enough to express complex concepts. It has a ways to enable you to define primitives and means to combine them in order to build higher levels of abstraction, but it is our job to express the abstractions of the domain for the best economy of the expression.

For the further reading there are valuable resources going deeper in this topic like Structure and Interpretation of Computer Programs which is probably one of the best resources on principles of reasoning about elegant program design.

One exceptionally good resource is the Guy Steel’s keynote from OOPSLA’98 conference about Growing a Language. It clearly shows how language encapsulates power of expression or lack of it and how it affects our ability to make beautiful and elegant programs. As well it shows how ubiquitous the concept of growing a languages is.

“Nobody Cares About Your Software” Is a Very Dangerous Point of View

2012-02-11T12:47:00+01:00

I work for the company that is building its own software for the purpose of bringing some value to its users. So, we don’t sell software but we sell what software does.

I noticed that people are regularly throwing overgeneralizations and telling that bringing value is the only important thing. At the end that is not false. What is usually missing is understanding how quality of software that is meant to bring value affects the process of producing the value. By making decisions about the software platform you are inducing heavily the ways you convey the value. You are enabling yourself to communicate some messages but from the other side you are restricting yourself for the others. Most probably lot of technical decisions on the platform will heavily affect how you bring the value to the end user.

Lets dissect overgeneralized Nobody

Most of the people are big generalizators. When they want to say something, it is easier to tell it in more general way, because getting into details need explanations and can remove focus from the point. That works for some cases, but there are cases when we can’t simplify things more than the problem allows.

Nobody in this case means Nobody that is willing to pay for our service cares about how it works in the background until it is satisfying their expectations. In case of web development, simply said Your users don’t care about your software

When does it happen that our users have to care about our software

Lets see, why would our users be forced to care about the software. That usually happens when software starts to get into their way. Lets take one invented example sketch.

Imagine two step process of filling the form on your website. You fill in the first step, then click next to go to the next step and fill the in second step. You did not fill in properly second step and the process returned you to refill first step again in order to do everything correctly. Wat!!! Your website just made my day. And the days of lot of other customers.

The history of this feature usually goes something like this:

Product owner comes with really great idea of multistep form, and with the deadline for yesterday.
Engineers explain that their framework don’t really support multistep forms, but they will make it work somehow.
They make it work somehow, exactly as described above.

Here is important to see the relation of the state of this particular software and technical explanation of this problem with the effect on the user. And obviously, user really doesn’t care that your framework doesn’t have expected features and that you don’t really know or have no time to implement it properly.

5 Whys of this problem

Why does user have to go to the first step again?

Because we didn’t have time to properly implement the multistep form behavior.

Why didn’t you have time to implement it properly?

Because our framework didn’t support this option and we had to implement it in a very short time.

Why didn’t you choose framework that has a bit more features?

Because we didn’t really get time to plan properly migration to a new framework. We took someting that we where most familiar with.

Why didn’t you take your time for such an important decision?

Well, there are other things to do, and we just thought this is going to be enough for now and did not think that much about future. We thought that we’ll be able to add features we need, but then we got understaffed and we didn’t find new employees fast so we had to do everything in a hurry ….

Why is that, it looks more like a management and staffing issue

Because, you know, in our company we have attitude that Noboday cares about software, we only care about bringing value to our users

The other part of Nobody

At the beginning we extracted User of our software from the Nobody that we introduced at the start of the story. So, if we said that user doesn’t want to care about our software, what should others in the process than do.

Well, in my opinion that is what building business that is relying on a software product to deliver some user value is all about. Others should care that user can fulfill his goal by using software and not caring about software itself. In fact what user is paying us for is to care about the things he doesn’t want to care. Unfortunatelly, when user starts to feel that software is getting into his way, lack of care for software has probably got too far away to fix in an easy way.

Just to prove my point I have to list some responsibilities of standard roles in a company that produces software of any kind.

Management should care that service company provides is satisfying and that users are not leaving for the competition. They should as well care that software is maintainable with reasonable price because they pay that maintainence at the end, stable and reliable and that it produces more happy than unhappy uses, easy to understand and documented well so they can expand the team fast, people are educated for the position they do so they don’t introduce stupid things into the codebase, environment is optimized for long time work of this kind, motivation is high … mostly non-technical things that make life of people that produce software confortable and make environment in which software is built stable and predictable.

Product owners should care that they can use software as the modeling tool for easy prototyping and trying out new ideas, that quality of the product is not restricted by the software fallacies, that software is not just visible implementation but as well statistics gathering tool through which they can develop business ideas and prove some theories they might have ….

Engineers should do their best to learn and understand the software building and how to produce more quality, maintanability, flexibility and stability with the least effort involved and with lowest resources. We as engineers should as well really understand the domain we are working on and be aware of the environment in which we operate, company strategy and short and long terms goals … and lots of other things.

Goal of listing all of these responsibilities is not to make proper or correct list but to give a glimpse at the fact that lot of them are related to actual state of the software, its health and health of the environment specific for software production.

At the end I come to the baseline of the article. It is my opinion that in a business that is bringing value to the user using software product all we have to do is to make users of our software not care about the software. And the way to achieve this is that you as company that is giving software tool to the users should care about that software so they don’t have to.

Random Hacks of Kindess comes to Zürich

2011-10-12T22:39:00+02:00

After great weekend I spent during RHoK #3 in Basel I decided to join the RHoK Switzerland organization and help making next event in Zürich even more awesome.

Last Tuesday, I had a pleasure to present next Random Hacks of Kindness event in front of the Zürich Webtuesday community and here I wanted to share slides from that presentation with a bit of context.

TL;DR for the impatient

RHoK #4 is going to happen in Zürich on 3rd and 4th of December 2011. You should join because it is never bad time to invest your time and expertise for the good cause. You can join by registering through Eventbrite form on the official event page. You can see more details about the RHoK community on the official web site. For following up with new information follow @rhokch on Twitter

RHoK presentation Zurich webtuesday

View more presentations from ivan.jovanovic

So, what makes RHoK different

Comparing to other hackaton based activities that I noticed, RHoK stands out with the systematic orientation towards permanent and sustainable impact over longer future. It is obvious to see that for a weekend of hacking big problems can’t be solved. Knowing that RHoK tends to attack this problem particularly by building strong relation to organizations and individuals that are closest to the problems being solved. In Basel, for example, we had on site representatives from Caritas Switzerland and Humanity Road. This way, from one side RHoK helps Subject Matter Experts (as we call them) be strong problem owners and drivers for the change, and from the other side RHoK brings needed knowledge to attack these problems with high quality.

Of course, you can bring your own idea to the event and try to motivate others to join you bringing it to life or you can just hack on it yourself. Only constrait is that at the end of the weekend you’ll have to present what you did and explaing why it matters to be solved.

RHoK is a competition event

The weekend event itself is a competition. At the end of the weekend, you will, with your team, present what you came up with. Our sponsors provide prizes for the winners. So if you are competitive even more reasons to come.

Bringing needed knowledge to the problem

The way hackatons usually happen is around focused communities. For example, Ruby/RoR community meets once a month and hacks on things they are interested in, usually not oriented towards the humanity related problems. Although this is great, this approach lacks some pieces in order to sustainably solve big real world problems. RHoK as a concept tries to bring ALL the knowledge needed not only the technical one. That is why we try to motivate product owners, designers, user interaction experts, thinkers or activists to participate in various parts of the process as a part of the team attacking particular problem. This way we think we can make teams last longer than a weekend and drive the solution to the state when it is being used in production.

RHoK #4 Zürich, 3rd and 4th of December 2011

What we provide is a venue, infrastructure, food and refreshements. At the beginning of the event we’ll get an overview of the problems that we might attack during the weekend. All the problems are placed on the official RHoK website in the problems section. For some of the problems we’ll have on-site representatives, for some of them you might want to pair up with a team from another RHoK event from the list or you might bring your own problem and attack it alone or with other participants that decide to join you.

Stay up to date with new information about the event

Official Random Hacks of Kindness website
RHoK Switzerland Twitter account @rhokch
RHoK Zürich event page - http://www.rhok.org/event/zurich-switzerland
Contact us directly @ivanjovanovic or @thesuperlogical

There’s an RFC for That

2011-10-02T23:39:00+02:00

Too often I see colleagues developers employing Google and lurking around random results to find answers on some typical web development questions as "What does must-revalidate in Cache-Control does?", or "Is ETag header forcing revalidation?" and similar. Usually it ends up in deciphering random answer on Stack Overflow or some other community web site.

First, of course that there is huge amount of knowledge out there and very smart people answering with deep insight on every of these questions. But still, they do present most often only their interpretation of certain clearly defined and described standard. Answers also often know to be either incomplete or plainly wrong. Second, most often these kind of responses are representing how things are implemented in certain technology, Rails for example of any other. That way usually you don’t come to the answer of why but how something is done. And to grow knowledge I always tend to go deeper and understand why something is done in certain way.

Take HTTP protocol as example, it is defined in RFC2616 where everything you need to know about it is written. It has a bit unfriendly writing style, but once you get used to it you can see that it is in fact very clear and unambiguous. Other benefit of getting used to read RFC documents is that they are written in similar style and once you get used to you can benefit from vast amount of them. At the end RFC are the rules which define most of the web implementation in wide use on the net. Let the HTML5 mess aside ;)

CoffeeScript implementation of Conway’s Game of Life

2011-08-02T00:00:00+02:00

Over the weekend I wanted to get a bit deeper into the CoffeeScript and get around how it feels working with it. I gave myself task to do something simple but inspiring. Therefore I implemented simple version of Conway’s Game of Life to be played in browser. Go here to see how it looks like.

CoffeeScript

CoffeeScript is a little language that compiles into JavaScript. Underneath all of those embarrassing braces and semicolons, JavaScript has always had a gorgeous object model at its heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way.

In other words, CoffeeScript is an attempt to replace JavaScript syntax with a better one based on experiences from Ruby and Python worlds. Beside that it introduces couple of new abstractions which natively do not exist in the vanilla JavaScript like classes, list comprehensions, return of multiple values from function etc.

CoffeeScript brings a lot of relaxation on the original JavaScript syntax and makes writing it at first weird experience but only until you get used to it. Afterwards it gets obvious that it takes much less to write the same thing in CoffeeScript than in plain JavaScript.

My observations on developing with CoffeeScript

First and obvious observation is that with CoffeeScript you need additional tool in your toolset which will continuously compile your work to JavaScript. I used Jasmine for writing tests and I based my setup on this gist which proposes using guard Ruby gem for tracking changes and compiling CoffeeScript files into JavaScript ones.

It looked a bit weird at start, but after couple of hours playing it started getting better. One thing I had always to do is to look in the actual compiled JavaScript to see how to do some things i.e. how to pass index to function that maps an array. But it was intuitive enough that I almost didn’t need official documentation. Here I have to tell that it might not be as intuitive to people without experience with writing Ruby and Python code or lack of understanding for rather mathematical

(a, b) -> a + b

function notation.

At the end I really liked it. Problem that I was solving didn’t need using some advanced CoffeeScript constructs like classes but one that I used like multiple return values from the function really show how much you can get out of language if you have some basic tools implemented within.

Last several months I was developing mostly in the Rails framework and since Rails 3.1 is going to have CoffeeScript enabled by default I suppose I’ll give CoffeeScript a chance again in next months and write more about experiences developing more complex things again in future.

Code is on GitHub

You can find the source code for the implementation of the game on GitHub

Introduction to JavaScript BDD testing with Jasmine library

2011-07-22T00:00:00+02:00

If we look at the developments in the software testing area, step beyond in evolution after TDD is, so called, BDD (Behavior Deriven Development). It is hard to describe BDD in couple of sentences. Excerpt taken from Wikipedia says:

BDD focuses on obtaining a clear understanding of desired software behaviour through discussion with stakeholders. It extends TDD by writing test cases in a natural language that non-programmers can read. Behavior-driven developers use their native language to describe the purpose and benefit of their code. This allows the developers to focus on why the code should be created, rather than the technical details, and minimizes translation between the technical language in which the code is written and the domain language spoken by the business, users, stakeholders, project management, etc.

If this looks a bit complicated, in one sentence it would mean: BDD helps programmers and non-technical stakeholders understand each other better and develop software which will be the most representative model of the problem solved by writing the software itself.

Jasmine: BDD for your JavaScript

Jasmine is a library for BDD testing of your JavaScript. It offers range of possibilities to describe software functionalities by simple and descriptive tests, which is one of the basic principles of BDD based development. This way tests usually serve as the most accurate software documentation. More about Jasmine library on the GitHub repository.

After you download standalone Jasmine distribution from here you’ll find in the archive all you need to write your first tests together with the example of your code organization. The most important fie is SpecRunner.html which, when run in browser, will execute tests and give you report about the state of the tests. SpecRunner.html is very simple and self explanatory. lib folder contains Jasmine library, src folder contains code to be tested and spec folder contains actual software specifications as tests.

Further, I will implement simple object that can register multiple callback functions and call them with given data. Something like simple observer. I will always first write tests and then implement functionality to make tests pass.

Example of simple JavaScript observer with Jasmine tests

We start from the downloaded archive for standalone Jasmine library. We need to delete example code provided with the library to implement our own example.

rm src/*
rm spec/*

Also, from SpecRunner.html file we delete references to just removed scripts. Therefore, part which includes them stays empty like this:

…

  <!– include source files here… –>

  <!– include spec files here… –>

…

First test

In TDD and BDD philosophy one rule is essential for success.

First you write the test which will at the beginning fail, then you implement code which should satisfy specification described by test. Then, you execute test and continue with implementation until test passes. When that happens you know that implementation is OK.

According to this we create file to place our tests in spec/ObserverSpec.js and we define first test to simply check existence of the observer object.

lang.js

describe("rs.ji.observer" function () {

    it("should be present in the global namespace", function () {
        expect(rs.ji.observer).toBeDefined();
    });

});

And we add this specification to SpecRunner.html to execute it:

<!– include spec files here… –>
<script type="text/javascript" src="spec/ObserverSpec.js"></script>

If we now open SpecRunner.html in some browser (i.e. Google Chrome) we will see one failing test.

It is important to take a look in how our test looks like. If you read the test you’ll see how descriptive it is and how with simple words expresses how our code should behave, although example is very simple. Here it takes some creativity of the developer to make tests really valuable but more than that is important that developer have deep understanding of the dictionary and terminology of the domain for which software is developed because understanding of the domain should be heavily embedded in the test definitions.

Next step is to implement the code which will satisfy test. We will create file src/observer.js

lang.js

// defining so called namespace objects so I can namespace observer into
// rs.ji.observer
var rs = {};
rs.ji = {};

// observer implementation
rs.ji.observer = {};

And we will add it to SpecRunner.html:

[html] <!– include source files here… –> [/html]

If we run SpecRunner.html again, we can see that our test passes, it is green :)

Rest of implementation

Now, when we know for the principle "First failing test, then implementation" we can add new functionalities to our simple example. We add next test:

    it("should be able to register callback function", function () {
        // define function to be placed into the observer register
        function callback() { return null; }
        rs.ji.observer.register(callback);
        var callbacks = rs.ji.observer.getCallbacks();
        expect(callbacks.length).toBe(1);
        expect(callbacks[0]).toBe(callback);
    });

And implementation that makes this test pass:

rs.ji.observer = {
    callbacks: [],
    register: function (callback) {
        this.callbacks.push(callback);
    },
    getCallbacks: function () {
        return this.callbacks;
    }
};

We want to check if we can register multiple callbacks. This functionality should be supported already, but we write test to confirm this:

    // before every test we reset array of callbacks
    beforeEach(function () {
        rs.ji.observer.callbacks = [];
    });

    it("should be able to register multiple callbacks", function () {
        function callback1() { return null; }
        function callback2() { return null; }
        rs.ji.observer.register(callback1);
        rs.ji.observer.register(callback2);
        var callbacks = rs.ji.observer.getCallbacks();
        expect(callbacks.length).toBe(2);
        expect(callbacks[0]).toBe(callback1);
        expect(callbacks[1]).toBe(callback2);
    });

Programmers often use print, echo and friends to test code for certain functionalities. That takes time as for writing a test, but from other side tests are possible to be executed all the time after this initial check is done even when we move to implement something else.

If we run SpecRunner.html in browser, all tests should pass.

Last thing our observer should do to satisfy its basic purpose is to update callback functions with some new information. That means it should be able to call them with some data. To define this functionality we write new test:

    it("should provide update method to execute all callbacks", function () {
        window.callback1 = function () { return null; }
        window.callback2 = function () { return null; }
        spyOn(window, 'callback1');
        spyOn(window, 'callback2');
        rs.ji.observer.register(window.callback1);
        rs.ji.observer.register(window.callback2);
        rs.ji.observer.update("data string");
        expect(window.callback1).toHaveBeenCalledWith("data string");
        expect(window.callback2).toHaveBeenCalledWith("data string");
    });

Here we use some advanced techniques of spying on methods (SpyOn) in order to see if some method is called while other is executed.

As a helper, we will add jQuery library to src/jquery.js location and add it to SpecRunner.html file:

<!– include source files here… –>
<script type="text/javascript" src="src/jquery.js"></script>
<script type="text/javascript" src="src/observer.js"></script>

And we implement code to satisfy the test:

// observer implementation
rs.ji.observer = {
    callbacks: [],
    register: function (callback) {
        this.callbacks.push(callback);
    },
    getCallbacks: function () {
        return this.callbacks;
    },

    // added update method to inform registered callbacks
    // uses jQuery to iterate over the array
    update: function(data) {
        $.each(this.callbacks, function (i, callback) {
            callback.call(null, data); // call every callback with provided data
        });
    }
};

Complete picture

That is it, now we have full implementation of simple observer with tests that can pretty clearly describe functionalities of the software we developed and they can as well prove in every time that needed functionalities are working OK by executing them in the browser (or different browsers to see if they will work in all of them). Complete files:

describe("rs.ji.observer", function () {

    beforeEach(function () {
        rs.ji.observer.callbacks = [];
    });

    it("should be present in the global namespace", function () {
        expect(rs.ji.observer).toBeDefined();
    });

    it("should be able to register callback function", function () {
        // define anonymous function to be placed into the observer register
        function callback() { return null; }
        rs.ji.observer.register(callback);
        var callbacks = rs.ji.observer.getCallbacks();
        expect(callbacks.length).toBe(1);
        // so we need to have first funtion in registered callbacks
        expect(callbacks[0]).toBe(callback);
    });

    it("should be able to register multiple callbacks", function () {
        function callback1() { return null; }
        function callback2() { return null; }
        rs.ji.observer.register(callback1);
        rs.ji.observer.register(callback2);
        var callbacks = rs.ji.observer.getCallbacks();
        expect(callbacks.length).toBe(2);
        expect(callbacks[0]).toBe(callback1);
        expect(callbacks[1]).toBe(callback2);
    });

    it("should provide update method to execute all callbacks", function () {
        window.callback1 = function () { return null; }
        window.callback2 = function () { return null; }
        spyOn(window, 'callback1');
        spyOn(window, 'callback2');
        rs.ji.observer.register(window.callback1);
        rs.ji.observer.register(window.callback2);
        rs.ji.observer.update("data string");
        expect(window.callback1).toHaveBeenCalledWith("data string");
        expect(window.callback2).toHaveBeenCalledWith("data string");
    });
});

And the observer implementation

// defining so called namespace objects so I can namespace observer into
// rs.ji.observer
var rs = {};
rs.ji = {};

// observer implementation
rs.ji.observer = {
    callbacks: [],
    register: function (callback) {
        this.callbacks.push(callback);
    },
    getCallbacks: function () {
        return this.callbacks;
    },
    update: function(data) {
        $.each(this.callbacks, function (i, callback) {
            callback.call(null, data);
        });
    }

};

Why (I think) Khan Academy really matters.

2011-06-09T00:00:00+02:00

Today I made first translation to Serbian on Khan Academy and this post is about why I loved doing it and why I think it really matters.

If you havent heard of Khan Academy yet you should immediately get out that rock you are hiding under. No joke, Khan Academy is a big thing. Watch this TED talk to see how amazing is what Salman Khan is doing. I was really happy when I saw that John Resig of jQuery fame has joined their crew to help bringing this extraordinary mission to the next level. It is really extraordinary, especially for the times of today when everything is in profits and money. But it doesn’t matter only because of that.

I come from Serbia, country which is in kind of development. Last 20 years where not that good for us. Degradation of every part of society to the critical level happened during that time. People mostly without jobs, hope and will to go forward despite the fact that time passes by them fast. Yes, time passes by and developed world is changing even faster every day. And if you stand still for 20 years, you can imagine how far world goes in front of you. It goes so far that you, from your own point of view don’t understand any more all that modern development and trends.

So the big question for countries like Serbia is how do they catch up with the modern world. How do you learn things you have to know when you don’t have access to good and innovative education, have no great people to lead the country because they are all spread around the world. Well, there are options. And improving education of people is in the core of all of them. In this context Khan Academy really matters. Not as final solution but more as announcement of future where education is going to be much less institutionalized and much easier spread across the globe, especially in the countries which need this the most.

Internet has evolved to a point where it is becoming a platform for spreading something more than Facebook and Farmville. Recently I watched TED talk of Chris Anderson on how web video powers global innovation and I could not agree more. And Khan Academy proves this in practice on a high scale and is able to motivate thousands to join the train of global education improvement and to bring it to the higher level. This might lead to looking at the education in whole lot different ways than before and using peoples potential most efficiently to solve problems of underdeveloped communities. It brings some hope at least.

Currently I live in Switzerland, country blessed by the best standard in the world and really great performance in every aspect, from administration to education. One thing I see here is that people are not aware enough how others in the world live and when aware it is on the level of general empathy and not on the level of doing something with it. Paradoxically, countries like this can give the most to the world, not only by sharing money but experiences and knowledge about their success as well. Internet in this case might be a great leverage for small and great ones to influence world wide.

Considering all of this, I though I could be one among this army of good people to help on this idea. I’ll try to contribute on this topic as much as I can in my spare time and motivate others to do the same. Translating as much videos to Serbian would be one of primary goals and promoting the idea as well.

Random Hacks of Kindness - building a better world commit by commit

2011-06-06T00:00:00+02:00

It was long time ago since I realized that every discussions about this or that technology falls into water without putting it in the context of the real-world problem. And, unfortunately, real world today doesn’t lack problems. What it lacks are people of good will to solve them, or at least good people lack organization and coordination in order to efficiently solve these problems. Random Hacks of Kindness project was started with idea to address this problem.

RHoK works by bringing together experts in development and volunteers with a broad set of skills in software development and design to solve problems defined by NGOs and other institutions which work in the area of disaster management.

Last weekend RHoK happend for the first time in Switzerland. Frank, driven by his experience from RHoK #2 in Berlin, organized great event in Basel and gathered around 20 of us to attack some of the RHoK problem definitions we found interesting. On the following video you can see presentations of all the teams, their problem definitions and explanations of solutions.

I worked with Max, Phillip, Felix, Thomas and Chad from SecondMuse on the problem defined by Caritas Switzerland. Overall idea was to gather different sources of scientific GIS data for different global community risk related information like percentage of child hunger per country or intensity of cyclones in coastal areas and to present this information in usable way on one map with some tools to examine data more deep. Technically, the most difficult part of the problem is the fact that, as far I could understand, GIS area lacks standardization of data exchange file formats, and getting head around this domain in 2 days is really hard. We did not finish much on the practical side, but we examined the problem from technical side and came to deeper understanding of the problem domain and some ideas how it can be solved properly in future. One visible thing we made is half-working prototype of Google Map with two custom tile layers, more like proof of concept for our idea.

Oleg, who worked on the Person finder problem, gave great overview of the whole RHoK Basel event on his blog.

Beside great time, meeting great people and working on challenging problem I found that participating to this event additionally boosted my motivation to get deeper into non-technical side of problems of communities around the world. Also I became more aware how important is to motivate people to put some effort into solving this kind of problems and how easy is to help if proper environment is set and some basic organization is provided.

On the line of organization, I liked that we could give the input about how we could improve the event organization for future. I found couple of possible optimizations of the process which might help me achieve better results next time:

As software developer I’m sensitive to quality of requirements. Problem definitions, as given today, are definitely not the best to work with. If we could involve engineers in the problem definition process before problem definition comes for implementation it might help to get more done during the short and intense 2 days of hacking. And even more important maybe is to have the problem owner present in place for all time during the event. This not only helps team but even more helps them to understand the problem better for future.
The way teams are formed is not the most efficient. Although, getting together with group of completely unfamiliar people is personally great and can lead to lot of innovation, it makes continuity a bit harder. Working with people you know and trust is from other side more efficient but can lead to not that innovative approaches. If these could be combined in a way I’m sure we could achieve better results and insure better continuity which is essential for finishing the project to some usable state. Therefore I’ll try to make effort to form a team for next RHoK and try to stick to a problem until it is finished at least in the basic version.
Event should be promoted to the broader audience and involve more different professions like designers, usability experts, product owners, scrum masters and other involved in agile software development which is I believe the most appropriate for this way of attacking problems.
In future whole RHoK idea should be expanded to involve problem areas other than disaster management. I would personally be the most interested in problems related to online education of countries in development, and others certainly have their own preferences as well. This way we might gather much bigger community around it.

And of course, next time consider to join

Am I stupid, or is that = this stupid?

2011-04-27T00:00:00+02:00

JavaScript development has got really much momentum and its popularity is peaking. In the moment of design it was probably never foreseen as such success. Maybe that is why we have to satisfy to using only its "Good Parts". There are lot of compromises with it, in order to make programming it a success overall. One thing that I always found weird is usage of that = this concept. JavaScript guru Douglas Crockford explains on his website this concept of preserving connection of method with parent object regardless of the context of invocation. In practical usage I saw this pattern used for essentially the same reason but on other places. Consider this example (code purpose and quality in general do not matter that much)

// Returns array of positions of current players on the field
tofu.Table.prototype.getPlayerPositions = function() {
    var positions = [];
    var that = this
    $.each(this.rods,
    function(i, rod) {
        var left = that.getRodDistance(i)
        // produce positions for all players
        for (var j = 0; j &amp; lt; rod.men_number; j++) {
            var position = {
                left: left,
                top: j * rod.men_distance + rod.position
            }
            positions.push(position);
        }
    });
    return positions;
}

The main point here is that we try to preserve reference to parent object with var that = this because $.each(this.rods, … ) will overwrite reference to local variable this. In that case we access closure reference that to refer to our original object.

And there is a problem,

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

this and that might not be considered much smart ;) Can’t we have a name for that reference. Considering same example with small change in code I think it looks more natural than before and more readable and self explainable

1 width=’100%’>// Returns array of positions of current players on the field class="nx">tofu.Table.prototype.getPlayerPositions = function() { var positions = []; var table = this $.each(this.rods, function(i, rod) { var left = table.getRodDistance(i) // produce positions for all players for (var j = 0; j &amp; lt; rod.mennumber; j++) { var position = { left: left, top: j * rod.mendistance + rod.position } positions.push(position); } }); return positions; class="p">} >

Getting around first steps with Git

2011-03-25T00:00:00+01:00

So, your pain threshold limits are exhausted by everyday use of your current version control software (SVN, CVS anyone?). You are looking for another solution to version control problems and you start exploring Git. You heard that it is really cool, but now you’re getting hands on to figure out how cool it really is. For start, you should know that Git is different. Your current mindset will drive you into using it the same way you used SVN, but very soon you’ll find out that if you don’t start working on your mindset, using Git can become more a problem than a solution. Fortunately, Pro Git book is available online for free and I highly recommend going through it with understanding. If there is a list of things to understand and clarify at start that I would recommend:

Git basics
track -> edit -> stage -> commit -> push file lifecycle
fetching vs pulling changes from remote origin
every Git repository of a project represents part of one common history, your local branches are just one part of it, remote origin as well and repositories of your colleagues too.
working with branches properly and efficiently
managing configuration of your local repository and global Git configuration

I’m new to Git and I had some basic questions to answer for myself, and afterwards I saw others asking again the same things. If I would take a couple of them to answer that would be these.

Git autocompletion

Great tool to explore and learn Git commands during your everyday work. It is easy to set up and invaluable to have it. First download the git-completion.bash file

cd # to go to your home folder
curl \ 
  https://raw.github.com/git/git/master/contrib/completion/git-completion.bash -O

and then add this line to your ~/.bash_profile or however you name your profile file

source ~/git-completion.bash

Checking out remote branch

Someone pushed new branch to remote repository and you are having tough time to start working on it. Use

git fetch

this will fetch all remote branches and put them in local repository

git checkout -b local-branch-name origin/remote-branch-name

will check out branch and set tracking between local and remote branch properly for you.

Pushing and pulling only to and from current branch

After you have finished your work on a branch, you want to push your changes. But git push command by default pushes changes from all branches if no other parameters are given. It can be configured in general to push only current branch with

git config push.default current

Regarding puling is a bit more complicated, since this is the option to be set for each branch. Probably it can be generalized. For example, you can have a remote branch called funky-branch which is on the origin remote repository and local branch with same name funky-branch. Then we can pull only its changes if we set following config options for this local branch

git config branch.funky-branch.remote origin
git config branch.funky-branch.merge refs/heads/funky-branch

now git pull works without pulling other branches along the way. There are of course numerous more questions to answer regarding Git, but when you touch the ground with your own feet, you’ll get to answer them really quickly since it has a great documentation and an active community. Git is extremely powerful and incredibly fast tool which enables us to make some really complicated development scenarios easy to manage. On the other hand it can often look like a kind of magic since there is a bit more to understand of it comparing to centralized version control solutions. One thing that is obvious after some weeks of everyday usage of Git is that it fits really good to the way my mind works during development. If you still have doubts, give it a try, it might even help :)

Making current git branch visible in your command prompt

Git is known for powerful branching possibilities. Although, it is hard to shuffle between branches and to always know in which you are currently. There is simple solution to this. You can add name of current branch to your command prompt by adding this to your shell profile script.

# Set up git branch information in command prompt
parse_git_branch() {
  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/[\1]/'
}
# Example of use of the function in command prompt $(parse_git_branch)
PS1="\w\$(parse_git_branch) $ "

After resourcing your shell profile you’ll see current checkout branch name in command prompt whenever you enter git workspace folder.

Selecting only part of a change for commit

Usually changes we make are not perfectly clean, or currently changed files contain at least two unrelated changes. Git provides the way to select only a part of all the changes and stage them for commit. It is done by using:

git app -p

Then you would have a change to decide on every group of lines weather to include it or not, you can even split it to parts so you can select more granular way …

Cleaning up repository with garbage collection

Git doesn’t do garbage collection on the repositories by default which has couple of advantages. Commands don’t lose time to prune objects all the time and you have kind of history to refer to locally. But, over time it gets slower, which can be fixed with activating garbage collection.

git gc –prune
// or check `man git-gc` for more information about git garbage collection

Getting up to more speed

Here you can find extensive list of resources for learning Git with selection of top 10 sites that provide the best resources online. After you have finished the basics you can proceed with more advanced topics. This great post from Markus Prinz can help you with optimizing Git for more advanced and more personalized workflows.

TextMate for PHP development

2010-12-29T00:00:00+01:00

If you want to improve your productivity and programming skills in general, getting to know better the tools you use every day is one of the important things to invest your time in. Keyboard shortcuts of your favorite editor are especially important and using them in your daily routine will save you lot of hand movements towards mouse, lot of context switching and will help you focus on what is important. I use TextMate for everyday PHP development and I find it excellent. There are some features that more complex IDEs provide out of the box, but after you get used to work with TextMate and learn how to be productive you can hardly find better option. Keyboard shortcuts are one of its good parts and key to boosting your productivity. There are some general purpose shortcuts that will work on any type of document, therefore on PHP files as well. Regarding the notation: A + B means press in same time, A -> B means type A and then after it press B

mate filename1 filename2 - you can always start TextMate from command line and give list of files/folders to open
open projectname.tmproj - if you saved your TextMate project to a file, which is good way to preserve custom project configuration, you can open it from shell with standard OSX open command
Cmd + T - search for file in the project
Cmd + Shift + F - search for a given string through all files in the project
Cmd + F - regular search for a given string in current file
Ctrl + S - faster way to search for strings in current file. Notice the input text box at the bottom of you TextMate window. Hit Esc to get out of fast search mode.
Cmd + Shift + T - search for a function/class name in current file
Cmd + Ctrl + R - see where the current file is in the project folder tree.
Ctrl + W - select whole word under cursor
Ctrl + Shift + A - gives you the list of SVN commands to execute on current file or folder if it is selected in project file tree.
Ctrl + Shift + G - gives you the list of Git commands to execute on current file or folder if it is selected in project file tree.
Alt + Mouse Selection - selecting in vertical blocks has never been easier, and editing afterwards as well :)
Set of shortcuts for doing fast search and replace
- Cmd + E - set keyword to be replaced
- Shift + Cmd + E - set replacement word
- Ctrl + Cmd + F - replace in current file
- Ctrl + Shift + Cmd + F - replace in selection only

Great thing about TextMate is its possibility to be customized for specific needs by adding so called bundles. TextMate comes with default PHP bundle embedded. You can see all the functionalities it provides in TextMate -> Bundles -> Bundle Editor -> Show Bundle Editor or Ctrl + Alt + Cmd + B as shortcut. Here are some interesting ones from this bundle or useful for development in general

Esc - hitting escape after you typed couple of letters will do code completion from the symbols defined in current editing file. Will work as well for native PHP functions. Just start typing mk and hit escape then and it will complete it as mktime :)
Alt + Esc - this will give you list of possible completions. After selecting one of them, you’ll get full function signature injected in the document.
Ctrl + H - will give you PHP documentation related to the selected word in your current editing document.
Ctrl + Shift + V - will check your file for syntax validity.
Shift + Cmd + D - will jump to file that is included in the current PHP file.
doc -> Tab - if you type word doc above class/method/function and hit Tab after it, you will get documentation block for the related entity.
Cmd + Shift + R - will run your file with current system PHP executable. This is very nice when you just test something and want to see the output, but don’t want to get out to shell and command line.
Alt + F1 - documentation about function signature in the form of tooltip. If you forgot weather $haystack or $needle goes first as the param in the array function this is easy way not to search through extensive documentation.
Shift + Ctrl + T - if you like to place lot of TODO, FIXME or CHANGED meta information in your comments for later addressing, this will help you find them quickly and navigate through them easily.

Beside these shortcuts there are a lot of snippets triggered by hitting Tab after typing its abbreviation. For example doc_f -> Tab will create new function together with doc block. You can see list of all of them in the mentioned bundle editor in the section for PHP bundle. It is pretty easy as well to create your own specific snippets. Many more general or specific shortcuts can be found online e.g. as printable cheat sheets. Or in TextMate manual. The best way to adopt them is to take them one by one and pay attention to use it regularly, as soon as it is at the back of the brain start with new one until you become TextMate productivity wizard.

Then I saw the tests, now I’m a believer.

2010-11-24T00:00:00+01:00

These days I was working on a small feature that had to be added to an application here at local.ch. The application was originally written by some other developers and it was first time that I looked at that code. Everything would be OK, and I would not write this post at all if at one moment I didn’t feel strong need to rewrite the application completely. To be clear, it is not kind of need that draws motivation in "Not my code, I’m smarter than others." source of frustration. Point is that this code really needs refactoring in order to grow in future and remain maintainable while adding new features to it. But that is by itself not a problem, what code doesn’t need refactoring, especially your own! And if you have no constant need to refactor things that could mean you didn’t learn anything since last time you saw that code.

The problem becomes obvious and bit more acute when you figure out that, despite the fact that we try to keep our micro applications pretty simple with least possible code and logic, you don’t have all clues about how that piece of software works. Then you become aware that amount of time needed to get into all the bits of included functionalities is way bigger than just refactoring the code. Therefore, you lose peak of your motivation since you instantly visualize all the non-engineering time you need to invest in gathering information instead of just doing it. But of course, when just doing it, at the end it should have the same function as before, I guess. So without some proof that you didn’t degrade functionality, just do it approach would be even worse than not doing it.

And where would you expect to find up to date documentation in such case? Browsing the Wiki … not ;)

While letting you think a bit, I’d tell you that at local.ch we are passionate about agile practices and testing in particular. We always try to cover our code with reasonable amount of coverage and quality of tests. Since I joined, I accepted this as a fact and acted in that sense, but was not believer in testing in the religious way. Not until I imagined ideal world where I would go to test cases and could understand all functionalities implemented in the code that these tests cover. And in more ideal world, I would be able to drop the code, leave the tests and write new code which would be proved as correct in the moment all tests get green again. But not when tests are written in the way to reflect bad implementation choices in the code and not thoroughly though through. Then you have to throw the tests as well and you are back at the start point.

I could imagine that in mentioned idealized model of the world you could continuously improve quality of the code, reduce price of its maintenance, add new features and experiment with different ways of implementing the same thing while exploring new approaches to solving old problems. And all that while being sure that you didn’t break function of software that might in a case pay your salary at the end of the month.

Yes, and "The Beatles" are now in iTunes. Lucky us, the whole world has changed.

Webtuesday at local.ch offices

2010-04-14T00:00:00+02:00

Every first Tuesday of a month, Zürich oriented web community gather for an evening of tech talks and some beer for, so called, webtuesday. Yesterday, we had pleasure to host event at local.ch for the first time as unofficial opening for the community after movement to new offices. As Harry tweeted already during the event, it was pretty packed. I was personally happy to see lot of people coming since this was only my second webtuesday since I started working for local.ch 6 months ago.

Packed webtuesday @localch offices (by Harry Fuecks)

This time Patrice and Chris from memonic.com gave great talk on the current state of the architecture and tools that are behind their startup. Since both of them worked for local.ch before (Patrice as Lead of Frontend Development, Chris as backend Java developer) it was interesting to see how much they kept and where they improved along the way. Interesting point was the choice of the language for their startup. At local.ch, we are kind of separated on frontend and backend development, before all, by the languages we use. Shortly, PHP on the frontend and Java in backend with HTTP communication in between, XML result got from backend parsed by XSL to produce HTML. At Memonic they decided to bring that together and make gap between backend and frontend development smaller by choosing Python as common language. Having experience with the Scrum and challenges which this kind of separation between frontend and backend carries, I see this as reasonable decision. I was surprised to hear that none of them had professional experience with Python before founding Memonic. Their architecture is highly web service oriented. The way Patrice conceptually sees the architecture can be paraphrased like this:

“I see web services in our architecture as classes are used traditionally, or maybe better, as components of the traditional framework”

end of lousy paraphrase :). So, if we take Zend Framework for example: imagine that instead of having Zend_Auth, Zend_Session, Zend_Log, Zend_Mail … and sending messages to their objects, you have web services that expose interfaces over HTTP. On the slides Patrice provided can be seen in smaller detail way their architecture is broken into smallest possible web services that communicate among each other. Web services are based on wsgiservice (Python WSGI framework to create REST web service) library that is open sourced by Patrice. One thing I was interested is what is the performance loss in HTTP communication overhead between components. In current state of the load they do not see it as problem and they see using HTTP features as e.g. caching more valuable than performance loss introduced. Here are some links, if you are more interested to find out about local.ch, webtuesday or memonic.com.

A year behind my back

2009-09-16T00:00:00+02:00

The year is behind me since I wrote last post. A lot, mostly good, has happened.

First and most important I have finished my studies. Now I can proudly say that I’m an Electrical Engineer in the field of Automation and Control Engineering. But wait, how does Senior Web Developer position relates to that? Let that be a topic for further evaluation :) Let just say that in one moment I had to decide what interests me more.

Somewhere at the beginning of February, after almost year and a half, our cooperation with Tilllate ended. Thanks to the Maarten, Leo, Silvan, Cyprian, Jia-yong Ou, Michael, Thilo and others for being friendly, positive and smart to create great surrounding to work in. I have raised my skill to much higher level and learned a lot about programming in high-traffic, heavy-loaded environment and gained much wider view on software development than I had before. I’d like to specially thank to Tilllate Chief Software Engineer Maarten Manders for having confidence that I will do proper job with some crucial parts of Tilllate, I hope I succeeded.

During the March I have started looking for a new job, preferably in Switzerland. After evaluation of open positions in the market I have applied for a position of frontend engineer in local.ch. In May I went to Zurich on the interview and until the beginning of the June I was offered a job. I accepted the offer and there was just one little thing standing between me and Zurich, the procedure of getting working permission for the non-EU citizen. Hard times for me :) To cut the story (since writing this post took some time and things happened meanwhile) I got my working permission after several months. Now I’m waiting for Swiss entrance visa and until the end of October I should start on my new job in Zurich. Currently I’m looking for a temporary flat in Zurich where I could reside for couple months before I find real place to live and bring my wife to Zurich too.

As it is in real life, some stories are at the beginning, and some are at the end. While writing this post, I’m spending last days in youngculture. It was great experience and pleasure, before all, for me to work with some of the most advanced developers in Belgrade in very high-quality working environment. I met friends for the whole life here and my two years in Belgrade will stay clearly positive experience. However, youngculture headquarters is based in Zurich, and people that I worked with regularly travel to Switzerland, so I presume I won’t miss them too much :) I’m ready for beer or two whenever you call!!!!

The year has passed so fast that I almost did not notice it. Just heard "whuush" sound somewhere around birthday. I had no time to devote to the things I like as blogging and out-of-work internet existence, but I hope that next year will change that. I planned to reorganize this domain and blog so I could efficiently present what I’m working on and things I like. I hope as well that starting new job will give me the chance to reconsider some priorities in life and bring some fresh air as well.

PHP debugging with FirePHP

2008-08-31T00:00:00+02:00

I really like when I stumble upon a creative and useful piece of software that could improve my everyday development process. I remember when I started using FireBug it was great help in the HTML/CSS/JavaScript development and debugging.

I’ve just found out FirePHP, FireBug plugin that enables the developer to send log messages from PHP code to FireBug console. Quite helpfull I can say :) It consists of Firefox extension (mentioned FireBug plugin) and small PHP logger that you actually use in your code to communicate with the FireBug console. Logger comes in procedural and object-oriented fashion so if you are striving towards exceptional performance of your PHP app, or just still old-school PHP4 (R.I.P.), then man you have your choice :) Otherwise use OO PHP5 logger class. I’ve manage to set the demo, that goes within the PHP library, in a couple of minutes and I’m looking forward for using it in the future.

Thanks guys for great work. Official FirePHP website

Another cool thing that comes with the FirePHP is its integration posibilities with CakePHP, CodeIgniter, Drupal, ExpressionEngine, Kohana, PRADO, Symfony, TYPO3, Zend Framework. So there is some for anyone.

Moving to Ubuntu or Windows sucks!

2008-08-12T00:00:00+02:00

While writing this post, post-intallation update on my fresh Ubuntu installation is under its way. It was long time ago I started to feel constraints of Windows as web development environment. So, very logical step was to move to something more developer friendly than user (read dummy) friendly. After testing Ubuntu with VMware player I decided to go step further and use WUBI (Windows Ubuntu installer) to intall Ubuntu as Windows application in a folder that will act as separate filesystem for my linux installation.

Yes, I know it is not perfect solution, but since I’m running it on Toshiba laptop I was worried about drivers and related staff and didn’t want to stay even without the Vista crap (TM). After all installation was smooth and harmless and it seems that everything works as expected for now. Setting the development environment is the next challenge I’ll take. Apache, MySQL, SVN … here I come :)

Preserving ordering with WHERE IN() clause in MySQL

2008-04-01T00:00:00+02:00

Today I ran into the code that pulls from database list of elements with

SELECT * FROM table WHERE id IN(2,5,3,16,22,56,48)

where order of ids is important to be preserved after results found. When using SELECT this way you will get the results for every id but ordered by id in ascending order. I was looking around and found neat solution to make MySQL work for you to preserve the order of returned results. With ORDER BY FIELD clause like here

SELECT * FROM table WHERE id IN (1,5,2,13,4)
ORDER BY FIELD(id, 1,5,2,13,4)

you can keep the initial ordering. What is the catch. This way id field can not be used as indexed. Therefore,

EXPLAIN SELECT * FROM table
WHERE id IN (1,5,2,13,4) ORDER BY FIELD(id, 1,5,2,13,4)

would give you the information that it is using filesort for results ordering which is not so nice. In general, when you have ids as the array with the ordering you need, it probably needs less resources to reorganize them in memory instead of letting MySQL doing it with filesort.