De acum incolo titlul meu (pe langa “Comandant Suprem al Fortelor Imperiale“) este “Programator la Data Solutions“.

De ce?

Pe scurt: pentru a programa.

Pe lung: am inceput treaba la HyperActive ca web developer, si in aceasta perioada am invatat mult, am crescut mult, pana am ajuns in punctul in care ma simt gata sa urc inca o treapta, iar acea treapta o reprezinta lucrul pe software web si aplicatii intranet. Programare.

HyperActive are si va avea in continuare succes ca agentie interactiva, cu clienti si proiecte importante in domeniul advertising-ului si marketing-ului digital, iar eu personal le doresc tot binele din lume. Din pacate satisfactia mea interioara vine din alt tip de proiecte.

Ce am realizat?

Nici nu stiu de unde sa incep.

• Am dobandit foarte multe cunostinte tehnice, atat de programare cat si de administrare a unui server.
• Am optimizat modul de organizare si deployment a proiectelor, pana in punctul in care orice membru al echipei poate face deploy cu incredere la ultima versiune a unui proiect din cateva click-uri.
• Am fost avocatul descentralizarii si organizarii pe echipe de proiect self-managed.
• Am cautat in permanenta cai de imbunatare, atat a codebase-ului cat si a metodelor si proceselor de lucru. Am si reusit de multe ori.
• M-am dat pe reddit.com. Mult :D

Toate astea datorita si impreuna cu partenerul meu de batut cap in cap in gasirea solutiilor, Gabriel Solomon.

Regrete?

Echipa. Fara discutii.

Poate mai important decat realizarile de mai sus, HyperActive mi-a dat ocazia sa beneficiez de sentimentul inaltator de a fi persoana la care colegii tai apeleaza cand au nevoie de ajutor sau cand sunt blocati.

Ovidiu Boc imi spunea mai demult ca satisfactia succesului colegilor tai, succes la care ai pus si tu umarul, o depaseste uneori pe cea a succesului personal. Avea dreptate.

Ce urmeaza?

In primul rand urmeaza acomodarea si stabilirea la noul birou. Apoi un proiect in privinta caruia sunt foarte entuziasmat. Apoi … multa munca, multa joaca, invatam si ne dezvoltam in permanenta, altfel nu merita.

Related posts:

1. Un nou inceput

In the raging, aeon-spanning battle against procrastination, I am constantly on the lookout (while procrastinating, of course) for ways to improve my productivity and help me work more efficiently. This is how I stumbled on The Pomodoro Technique, and gave it a try.

The rundown

At it’s core, the technique consists of splitting your work in 25 minute intervals, with a 5 minute break between each interval, and a longer break (15-30 minutes) after 3-4 such intervals (pomodoros).

In theory, it should help you stay focused and productive, by timeboxing your tasks into undividable chunks and then help you analyze and measure your productivity in uninterrupted pomodoros.

The trick is, if you somehow get distracted during a pomodoro (either by other people or by yourself), that pomodoro no longer counts. Even if you happen to take “just a peek” at reddit’s homepage in the 23rd minute (although you and me both know there is no such thing as “just a peek” when it comes to reddit.com).

After the first few days with just a few finished pomodoros per day, you will do your best to avoid interruptions.

Will it help me avoid said interruptions?

No, it will not. It will only make the measure in which these interruptions affect you crystal clear, by showing you just how little actual uninterrupted work you do each day. The book does have an entire chapter dedicated to interruptions and how to handle them, and it’s a short read.

Is it worth it?

First of all, it’s not a silver bullet. There are no silver bullets. It all boils down to your own resolve in sticking to a pattern and work in a less chaotic manner. I find it worthwhile and plan to keep using it for now, for the following reasons:

• Two pomodoros make an ideal work hour (hour of actual continuous work), which is just the right unit to use as a Story Point to measure User Stories in.
• It helps with estimating and breaking down tasks, because it makes you split longer tasks into smaller, more specific and manageable units (more about this in the book).
• It delivers what it promises: a mechanism to keep you focused and avoid … temptations.

So go ahead, give it a try, but keep in mind, it will be hard at first; it will hurt your feelings, and like with all things that shine a light on existing problems, you will be tempted to give it up pretty soon.

No related posts.

The release date is closing in, you manage to wrap everything up, and launch. You lean back in your chair and think to yourself “ahh, another job well done”.

Then, out of nowhere, after just a few hours in, your task list / inbox gets filled with things like “How can I do X?”, “We have an issue with Y” and the dreaded “Z isn’t working”. You open the list, scan the first few items, and it hits you:

“Wait a minute, we’ve been over these, this is the way this feature was supposed to work, it’s been tested.”.

Ahh, but you see, it wasn’t.

But how could this happen?

Here’s the thing: your customers don’t really test. Your project managers don’t really test. You don’t really test. Not until the lauch date that is. That’s when everyone really starts testing.

“But, we had at least 6 people involved in this project at all times. Surely between them they tested everything”.

Well, not really, no. You see, every person involved in your project has a certain way of  looking at it.

You have a list of features that needs implemented. While you churn out feature after feature, you only tend to test the specific behavior you built into each one. “Right, so the user clicks this, fills out this form, and ends up here.”.

You don’t really try to break your own application, so you only interact with it in the way it’s meant to work. And of course, it works … “on your machine”.

Your project managers don’t test because they don’t have the time for it, because they have that meeting about that other project with that other client in 10 minutes, just pop them an email and they’ll look it up later … They won’t. They’ll be too busy.
They’ll rephrase parts of your email (because really, you suck at writing to corporate clients), and forward it to the customer. And they will not get a chance to test it again … until after the lauch date, when …

… the customer will start testing. The customer, the person you build the entire project for, doesn’t even remotely start testing until after the project has set sail. Why? Because until then, to them, the project is not real yet. It’s “under construction”.

They will open it up, have a peek, and unless something is downright wrong, they will not notice it. They will not follow the individual interaction flows, they will not start using the project like they will use it for real. “Oh, I can see some products, that probably means the entire administering, checkout and billing processes must be working.”.

Most of the problems that will rise from the customer’s lack of testing are those when he expects a feature to work a certain way, but he described it to your project manager at first in a totally different way. And she described it to you in yet another way. And you developed it “your way”.

Who’s fault is it?

No one’s really. All of yours.

• The client is thinking “I pay these people a lot of money, and the product is full of problems, I wanted something else.”.
• The project manager is thinking “It’s that arrogant developer’s fault, I distinctly remember giving him precise instructions on how this should work”.
• We all know what you’re thinking … “These damn mortals better let me get back to reddit.com”.

Who should test?

First of all, nothing beats professional testing. Ideally, you should have dedicated testers, but odds are you will have to make do with what you have available.

So there is good news, and bad news:

The good news is that, when searching for bugs, it’s easy! Grab a few members of your team that don’t work on this particular project. Best to do this with all types of colleagues: other developers, account managers, even the office secretary.

Sit down with them, and politely ask them if they can spare any amount of time to test your product. Then assign them some user roles, and let them loose.

The bad news is that application bugs are the easiest to find and fix. The biggest issues come from what I said earlier: miscommunication.

• The customer is not skilled in describing his needs. Most of the time he doesn’t even know his needs, and this is absolutely normal.
• Your project managers don’t have enough experience in the customer’s business field, or not enough technical skills. So they interpret the customer’s requests, and relay them to you wrongly.
• In-house problems. Trust issues and other problems can seriously affect the way people work together and communicate (more on this soon).

My bet is that shorter release cycles, more customer involvement (the project managers really have to step up here), and enhanced communication can at least lessen the impact of these problems on the typical project. Also, the User Stories and Acceptance Tests agile development concepts fit perfectly.

No related posts.

The easiest thing to do was to use the mod_rewrite, mod_proxy and mod_proxy_http Apache modules. You can easily activate all of them in Ubuntu with:

1

sudo a2enmod rewrite proxy proxy_http

I created an empty folder on the server and placed a .htaccess file with the following lines in it:

1
2

RewriteEngine On
RewriteRule ^(.*)$ http://10.4.2.155/$1 [NC,P]

The [P] at the end of the RewriteRule specifies that the request should be handled by the proxy module so all GET and POST data are preserved. Therefore, all requests made in that directory will be automatically forwarded to my machine.

No related posts.

So if the WSDL location is:

http://example.com:33080/soap/server/path?WSDL

All requests after fetching the WSDL file will be made to:

http://example.com/soap/server/path

The simplest way i could work around this was to extend SoapClient and intercept the constructor and the __doRequest method to inject the port in the location on each request:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<?php
class My_SoapClient extends SoapClient {
 
    public function __construct($wsdl, $options) {
        $url = parse_url($wsdl);
        if ($url['port']) {
            $this->_port = $url['port'];
        }
        return parent::__construct($wsdl, $options);
    }
 
    public function __doRequest($request, $location, $action, $version) {
        $parts = parse_url($location);
        if ($this->_port) {
            $parts['port'] = $this->_port;
        }
        $location = $this->buildLocation($parts);
 
        $return = parent::__doRequest($request, $location, $action, $version);
        return $return;
    }
 
    public function buildLocation($parts = array()) {
        $location = '';
 
        if (isset($parts['scheme'])) {
            $location .= $parts['scheme'].'://';
        }
        if (isset($parts['user']) || isset($parts['pass'])) {
            $location .= $parts['user'].':'.$parts['pass'].'@';
        }
        $location .= $parts['host'];
        if (isset($parts['port'])) {
            $location .= ':'.$parts['port'];
        }
        $location .= $parts['path'];
        if (isset($parts['query'])) {
            $location .= '?'.$parts['query'];
        }
 
        return $location;
    }
}

It works for me, and I would like to know if it doesn’t cover your particular case :)

Related posts:

1. FTL jump … now!

Step 1: Boot from Ubuntu CD

Insert the Ubuntu CD, restart your computer. At the boot screen, select the language and then the first option, “Try Ubuntu without any change to your computer.”

Step 2: install chntpw

chntpw is a Linux utility to (re)set the password of any user that has a valid (local) account

Go to Administration / Software Sources, and make sure the “Community maintained Open Source software (universe)” option is checked. Press “Close”.

You will be prompted to reload the package information. Press “Reload”

Open a terminal (Applications / Accessories / Terminal):

Once the terminal is opened, type the following command in it and press enter:

1

sudo apt-get install chntpw

Step 3: Reset password

Once chntpw is installed, you have to mount the Windows partition. The easiest way to do this is to click the Windows drive in the Places menu (usually the first HDD in the list):

When the Windows drive is opened, make sure to copy the location where the drive was mounted from the address bar, and paste it in the following command:

1

cd /media/A854C956382E2B62/WINDOWS/system32/config/

Now you have the following options:

Reset / change the Administrator password:

1

sudo chntpw SAM

Reset / change another user’s password:

1

sudo chntpw -u your_username SAM

Whichever you type, you will be presented with a list of options:

1
2
3
4
5
6
7

- - - - User Edit Menu:
 1 - Clear (blank) user password
 2 - Edit (set new) user password (careful with this on XP or Vista)
 3 - Promote user (make user an administrator)
(4 - Unlock and enable user account) [seems unlocked already]
 q - Quit editing user, back to user select
Select: [q] >

Pressing 1, enter, y and another enter will remove the user’s password, and allow you to restart the computer and logon to Windows.

No related posts.

Example page
Example script

Step 1: provide the JSON events in HTML:

1
2
3
4
5

var events = [
    {date: '2009-11-05', url: 'http://www.example.com'},
    {date: '2009-11-07', url: 'http://www.example.com'},
    {date: '2009-11-10', url: 'http://www.example.com'}
];

Step 2: extend goog.ui.DatePicker:

1
2
3
4
5
6
7
8
9
10

goog.provide('goog.ui.EventsDatePicker');
 
goog.require('goog.ui.DatePicker');
 
goog.ui.EventsDatePicker = function(opt_events, opt_date, opt_dateTimeSymbols) {
    goog.ui.DatePicker.call(this, opt_date, opt_dateTimeSymbols);
 
    this.events = opt_events;
};
goog.inherits(goog.ui.EventsDatePicker, goog.ui.DatePicker);

Notice how inheritance is handled with Closure. Even though we call goog.inherits(), we must also call the superclass constructor for it to work.

Step 3: highlight events:

goog.ui.DatePicker has a setDecorator() method, that accepts a function as it’s parameter. The function should take a Date object and return a CSS class name to decorate the corresponding cell with.

It’s basically called once for every cell in the picker, and we are going to use this by checking whether an event exists for the date and return “goog-date-picker-event” if so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

goog.ui.EventsDatePicker = function(opt_events, opt_date, opt_dateTimeSymbols) {
    goog.ui.DatePicker.call(this, opt_date, opt_dateTimeSymbols);
 
    this.events = opt_events;
 
    // new line:
    this.setDecorator(this.eventDecorator);
};
goog.inherits(goog.ui.EventsDatePicker, goog.ui.DatePicker);
 
/**
 * Searches the events array and returns the event corresponding to passed date
 */
goog.ui.EventsDatePicker.prototype.findEventByDate = function (date) {
    var dateString = date.toIsoString(true);
    var event      = goog.array.find(this.events, function (event) { return event.date == dateString; });
 
    return event;
};
 
/**
 * Returns a CSS class name to use for cells that have events
 */
goog.ui.EventsDatePicker.prototype.eventDecorator = function (date) {
    var event = this.findEventByDate(date);    
 
    if (event !== null) {
        return 'goog-date-picker-event';
    }
};

Notice the use of goog.array.find() to find the event that matches the date.

Step 4: click events:

We will use the findEventByDate function defined above and DatePicker’s SELECT event to jump to an event’s URL when clicking on it’s date:

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

goog.ui.EventsDatePicker = function(opt_events, opt_date, opt_dateTimeSymbols) {
    goog.ui.DatePicker.call(this, opt_date, opt_dateTimeSymbols);
    this.events = opt_events;
    this.setDecorator(this.eventDecorator);
 
    // new line:
    goog.events.listen(this, goog.ui.DatePicker.Events.SELECT, this.dateClicked, false, this);
};
/**
 * Checks if an event cell was clicked, and jumps to the event's URL if true
 */
goog.ui.EventsDatePicker.prototype.dateClicked = function (event) {
    var date  = event.date;
    var event = this.findEventByDate(date);
    if (event !== null && event.url != '') {
        document.location.href = event.url;
    }
};

That’s it :). It’s a short example, but it covers some of the basic aspects of inheritance, event listeners, and some of the utility methods. Closure looks nice :)

Example page
Example script

Related posts:

1. Update Carousel
2. AJAJ Autocompleter
3. Sizzle si Prototype

After a bit of investigating, it seems that the first step matches all the subsequent ones, so proceeding to the next step in the goal is actually recorded as a page refresh, hence exit page. Our steps where:

1
2

/apartamente-finalizate-in-greenfield
/apartamente-finalizate-in-greenfield/cere-detalii

The solution in this case was to explicitly specify that the step URL matches the ending of the actual URL:

1
2

/apartamente-finalizate-in-greenfield$
/apartamente-finalizate-in-greenfield/cere-detalii$

Note that i encountered this problem with both head match and regular expression match on two different websites.

Related posts:

1. Closure: Extend ui.DatePicker to highlight events

It has some very nice features, including support for multiple Trac repositories, custom ticket filtering based on Trac queries, and many more.

To install and start using Cube°n you will need to:

• Install the plugin, either by manually downloading the files or by adding the update center to NetBeans (Tools -> Plugins -> Settings -> Add -> http://cubeon.googlecode.com/svn/updates/latest.xml) and selecting it from the plugin “Available plugins” list
• Install the patched XML-RPC plugin for Trac:

wget http://cubeon.googlecode.com/files/TracXMLRPC-1.6.6-py2.6.egg
easy_install TracXMLRPC-1.6.6-py2.6.egg

• Make sure you enable the new XML-RPC plugin and the HTTP authentication plugin by adding the following in your trac.ini file:

[components]
tracrpc.* = enabled
httpauth.* = enabled
 
[httpauth]
paths = /login, /login/xmlrpc

That’s it. You can now use the plugin (Window -> Cube°n -> Task Repositories and Task Explorer), and start adding Trac repositories and adding / synchronizing tasks.

No related posts.

Documentatia si codul sunt pe pagina de la Google Code, o sa redau si aici exemplul: Presupunem ca vrem sa rulam functia add cu doi parametri la apasarea tastelor ALT+A:

1
2
3
4

function add(a, b) {
    alert(parseInt(a) + parseInt(b));
}
Hotkeys.bind("alt+a", add, 3, 4);

Pentru mai multe feature-uri, precum si lista de alias-uri pentru taste, consultati pagina proiectului.

Related posts:

1. Prototype: Zoomer
2. Sizzle si Prototype
3. Prototype: Carousel – Update