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

Related links

• My CoffeeScript implementation of Conway’s Game of Life
• CoffeeScript
• Conway’s Game of LIfe on Wikipedia

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.

cd jasmine-standalone # folder in which we extracted downloaded archive
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.

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

// 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:

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

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 with provided data", 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 picutre

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);
        expect(callbacks[0]).toBe(callback); // so we need to have first funtion in registered 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);
    });

    it("should provide update method to execute all callbacks with provided data", 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");
    });
});

// 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);
        });
    }

};

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.

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.

Me, explaining our solution

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.

RHoK #3 Basel participants

And of course, next time consider to join

// 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 & 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, I keep seeing this pattern all around. As I understand programming, proper naming of “things” is very important. And one that calls everything around in the terms of 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

// Returns array of positions of current players on the field
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 & lt; rod.men_number; j++) {
            var position = {
                left: left,
                top: j * rod.men_distance + rod.position
            }
            positions.push(position);
        }
    });
    return positions;
}

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://github.com/git/git/raw/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.

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.

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.

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.

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.