jablan.radioni.ca

gnome-panel is dead, long live gnome-panel!

Thu, 17 Nov 2011 09:43:00 +0100

gnome-panel is dead, long live gnome-panel!:

TL;DR: You can reorganize your gnome panel by using Alt when right-clicking. Whew.

Solving delay when ssh-ing

Thu, 22 Sep 2011 09:38:34 +0200

Solving delay when ssh-ing

Matching successive records using self-join

Mon, 12 Sep 2011 18:58:07 +0200

SQL joins can be really powerful once you got the hold of them. Especially interesting could be self-joins, i.e. joining the table onto itself.

Let’s say you have a table of daily temperatures:

create table temperatures (
  id serial,
  date date,
  temp numeric(4,2)
);

insert into temperatures (date, temp) values ('2011-09-01', 30);
insert into temperatures (date, temp) values ('2011-09-02', 28);
insert into temperatures (date, temp) values ('2011-09-03', 27);
insert into temperatures (date, temp) values ('2011-09-04', 32);
insert into temperatures (date, temp) values ('2011-09-06', 26);

select * from temperatures;

 id |    date    | temp  
----+------------+-------
  1 | 2011-09-01 | 30.00
  2 | 2011-09-02 | 28.00
  3 | 2011-09-03 | 27.00
  4 | 2011-09-04 | 32.00
  5 | 2011-09-06 | 26.00
(5 rows)

Say that we want a query which would, for each day, calculate the difference between that and the previous measurement.

We will start with a simple query to get all date’s temperatures:

select date, temp from temperatures order by date;

    date    | temp  
------------+-------
 2011-09-01 | 30.00
 2011-09-02 | 28.00
 2011-09-03 | 27.00
 2011-09-04 | 32.00
 2011-09-06 | 26.00
(5 rows)

Ok, that’s easy. Now we will expand this table with other dates, but we can narrow our query to only get dates prior to the current one:

select t1.date, t1.temp, t2.date
from temperatures t1
left join temperatures t2 on t1.date > t2.date
order by t1.date, t2.date;

    date    | temp  |    date    
------------+-------+------------
 2011-09-01 | 30.00 | 
 2011-09-02 | 28.00 | 2011-09-01
 2011-09-03 | 27.00 | 2011-09-01
 2011-09-03 | 27.00 | 2011-09-02
 2011-09-04 | 32.00 | 2011-09-01
 2011-09-04 | 32.00 | 2011-09-02
 2011-09-04 | 32.00 | 2011-09-03
 2011-09-06 | 26.00 | 2011-09-01
 2011-09-06 | 26.00 | 2011-09-02
 2011-09-06 | 26.00 | 2011-09-03
 2011-09-06 | 26.00 | 2011-09-04
(11 rows)

Now we have matched every date with all previous dates. (An important thing to note is that 2011-09-01 doesn’t have matched record. That’s because there is no date prior to 2011-09-01 in the table). So, for example, for 2011-09-04 we have all three, 01, 02, and 03. matched. We need just the most recent one, i.e. 03.

We will now use a trick to achieve this. We will add another join to eliminate all the dates but the most recent one:

select t1.date, t1.temp, t2.date, t3.date
from temperatures t1
left join temperatures t2 on t1.date > t2.date
left join temperatures t3 on t3 < t1 and t2 < t3
order by t1.date, t2.date, t3.date;

    date    | temp  |    date    |    date    
------------+-------+------------+------------
 2011-09-01 | 30.00 |            | 
 2011-09-02 | 28.00 | 2011-09-01 | 
 2011-09-03 | 27.00 | 2011-09-01 | 2011-09-02
 2011-09-03 | 27.00 | 2011-09-02 | 
 2011-09-04 | 32.00 | 2011-09-01 | 2011-09-02
 2011-09-04 | 32.00 | 2011-09-01 | 2011-09-03
 2011-09-04 | 32.00 | 2011-09-02 | 2011-09-03
 2011-09-04 | 32.00 | 2011-09-03 | 
 2011-09-06 | 26.00 | 2011-09-01 | 2011-09-02
 2011-09-06 | 26.00 | 2011-09-01 | 2011-09-03
 2011-09-06 | 26.00 | 2011-09-01 | 2011-09-04
 2011-09-06 | 26.00 | 2011-09-02 | 2011-09-03
 2011-09-06 | 26.00 | 2011-09-02 | 2011-09-04
 2011-09-06 | 26.00 | 2011-09-03 | 2011-09-04
 2011-09-06 | 26.00 | 2011-09-04 | 
(15 rows)

What’s this? Even more records! We join with t3, but in such way that the date from t3 must be between dates from t1 and t2. But if you note the “missing” bits in t3.date column, you will see that for some date pairs from t1 and t2, there is no t3.date. That’s the records where t2.date is right before t1.date. We need only that records. So, we’ll just add WHERE clause to discard all the records where t3.date exists:

select t1.date, t1.temp, t2.date, t3.date
from temperatures t1
left join temperatures t2 on t1.date > t2.date
left join temperatures t3 on t3 < t1 and t2 < t3
where t3.date is null
order by t1.date, t2.date, t3.date;

    date    | temp  |    date    | date 
------------+-------+------------+------
 2011-09-01 | 30.00 |            | 
 2011-09-02 | 28.00 | 2011-09-01 | 
 2011-09-03 | 27.00 | 2011-09-02 | 
 2011-09-04 | 32.00 | 2011-09-03 | 
 2011-09-06 | 26.00 | 2011-09-04 | 
(5 rows)

Right! Back to 5 rows, with just right values in t2.date column. Now all we have to do is add the temperature difference, and we’re done:

select t1.date, t1.temp, t2.date, t1.temp - t2.temp as diff
from temperatures t1
left join temperatures t2 on t1.date > t2.date
left join temperatures t3 on t3 < t1 and t2 < t3
where t3.date is null
order by t1.date, t2.date, t3.date;

    date    | temp  |    date    | diff  
------------+-------+------------+-------
 2011-09-01 | 30.00 |            |      
 2011-09-02 | 28.00 | 2011-09-01 | -2.00
 2011-09-03 | 27.00 | 2011-09-02 | -1.00
 2011-09-04 | 32.00 | 2011-09-03 |  5.00
 2011-09-06 | 26.00 | 2011-09-04 | -6.00
(5 rows)

That’s it. :)

Publish photos from GMail to Picasa

Sun, 11 Sep 2011 17:54:00 +0200

You have received a bunch of photos to you GMail account, and you want to publish them to your Picasa web album, but you hate having them downloaded to your machine, and then again uploaded to web, especially knowing that both Gmail and Picasa are Google’s applications. Wouldn’t it be nice if Gmail had an option to, besides download, upload the photos directly? Unfortunately, no such option.

There’s a workaround though. Go to your Picasa web account, go to photo settings page, there you will see an option to enable “email to Picasa”, by setting a special email account at @picasaweb.com. Just enable it, go to your Gmail, and simply forward your email with attached photos to newly created email address. You will get your photos imported to Picasa almost instantly.

7 krugova pakla

Thu, 23 Jun 2011 15:35:23 +0200

(ili “7 razloga za pravdanje krađe para od poreskih obveznika preplaćivanjem državnih sajtova”)

Nakon reakcija iz branše na po ko zna koji preplaćen državni sajt, palo mi je na pamet da sistematizujem i klasifikujem sve vrste griža savesti koje se javljaju, kao i načine za njihovo suzbijanje.

Da počnemo od najbanalnijih, ali i najtežih za suzbijanje…

7. Primate platu od države

Ovo je lagano. Ne sečete granu na kojoj sedite. Daleko bilo da podignete svoj glas i otvoreno kažete šefu da to ne košta toliko i da nije u redu što je nabacio posao svom kumašinu nego da je trebalo da se raspiše tender. Ne samo da biste ostali vi bez posla, nego i vaša žena i pašenog, koje ste ugurali na državne jasle preko poznanstva.

6. Dobili ste posao od države

Jasno - ne grizeš ruku koja te hrani. Konkurencija je gadna, vi ste naprimali kadar, ima tu i nešto slabijih programera, treba vremena (i para) dok se uhodaju, iznajmili ste fensi kancelarije, treba to pokrpiti. Pa nećete valjda u starkama raditi posao za Vlast?!

5. Niste dobili još nijedan posao od države, ali radite na tome

Pratite tendere, ortačite se sa perspektivnim partijskim kadrovima, pravite “socijalnu infrastrukturu” za buduće poslove. Ovaj posao su maznuli drugi, ali sledeći je vaš, kad ministarstvo gde radi vaš budući kum dođe na red. Ne želite da se sutradan postavi pitanje da li ste naplatili previše. I ako se postavi, pokazaćete prstom na svoju računicu od prošle godine gde ste matematički precizno dokazali da ni prethodnih N sajtova nikako nije preplaćeno.

4. Radite za strance i to dobro naplaćujete

Kada ste prethodni put stranom partneru lupili cifru triput veću nego što mislite da vaš rad zaista vredi, jako ste se iznenadili kad je pristao. Ali, kontate, tamo stručnjaci skupi, vi kvalitetni i pouzdani, nema razloga da vas grize savest. Lako ste se navikli na “zapadnu platu” u Srbiji. Ali pomalo vam je glupo kad vidite da se ovde ljudi prodaju za sitne pare, samo obaraju cenu u branši. Ko vam garantuje da sutra vaš strani partner neće uzeti baš nekog od njih za duplo manje nego što mu vi fakturišete. Zato neka, 50k€ i nije neka cifra za švajsovani Džumla templejt, kad malo bolje razmislite.

3. Radili biste, al n’ umete

Nikako vam nije jasno kako vaš ortak sastavi sajt za nedelju dana. Vi malo natucate Fotošop, nešto uspete u Drimviveru da nakrpite, PHP razumete kad je lepo napisan. Ej, nije to laka stvar napraviti sajt. Ljudi uče to programiranje po 10 godina, te fakulteti, te sertifikati… Treba imati rispekt za taj uložen rad (i novac). Te uložene pare i to uloženo vreme moraju se u jednom trenutku isplatiti… Džaba se vi danas mučite da učite, jedno po jedno, ako sutra to neko neće znati da ceni i plati.

2. Nekako želite da nosite kravatu

Stalo vam je da ortacima iz srednje koji su vas stalno zajebavali pokažete da ste postali neko i nešto. Hoćete da vas cene, da vas cice gledaju sa poštovanjem, da možete da smuvate i neku “pravu ribu” a ne samo bubuljičave wannabe sponzoruše i debele metalke. Da skinete najzad te starke, godine prolaze, nema više zezanja, dosta furanja nerd-imidža, treba se skinuti matorima s gajbe, kupiti neki pristojan auto. A šta je 50k€, potroši se začas. A cilj opravdava sredstvo.

1. Jednostavno ste konformista

Većina sa Tvitera tako misli a vi ne želite da se konfrontirate. :)

Limundo, sitnice koje smetaju

Wed, 15 Jun 2011 09:26:13 +0200

Redovno koristim Limundo i, iako je u pitanju sasvim funkcionalan sajt sa sada već vrlo velikim komjunitijem, ima par stvari koje čine da Limundo i dalje odaje utisak nedovršenog i poluamaterskog proizvoda. U pitanju su sitnice koje bi bilo lako ispraviti, a znače puno:

Two-level security

Ne želim da moram da se logujem uvek kad pristupam sajtu. Ni GMail ne zahteva logovanje pri svakom pristupu. Umesto toga, treba omogućiti dva nivoa pristupa: prvi nivo sa trajnom sesijom za “soft” pristup sajtu - posmatranje svojih i tuđih aukcija, čitanje pošte, i drugi nivo, sa dodatnim logovanjem i kratkotrajnom sesijom - za postavljanje aukcija, bidovanje itd. Ovaj sistem koriste i GMail i Amazon, recimo.

Auth token u email linkovima

Ako mi Limundo pošalje email (npr, kada primim novu poruku), želim da se klikom na link u mejlu automatski prijavim u prvi security nivo na Limundu, bez potrebe da kucam svoj username i password ponovo. Sama činjenica da imam pristup svom mejlu znači da imam pristup i svom Limundo nalogu.

Automatsko produžavanje aukcije pri bidovanju u poslednjim minutima

Popularni “fazon” na Limundu je bidovanje u poslednjim sekundama aukcije. Na ovaj način kupci se dovode u neravnopravnu situaciju (od aukcije pravi se igra na sreću), a predmet prodaje ne uspe da dostigne punu vrednost, tako da je i prodavac, a posredno i Limundo s obzirom da radi na procenat, oštećen.

Aukcija treba da se automatski produži za par minuta, ako je ponuda postavljena u poslednjim minutima (tako npr. funkcionišu neki onlajn sportski menadžeri tipa hattrick.org). Na taj način predmet će prirodno dostići svoju tržišnu cenu a niko od kupaca neće se osećati frustrirano ako je bio spreman da ponudi višu cenu od ostalih.

Izmena lozinke treba da ide kroz verifikacioni link

Trenutno bilo ko ko zna moju email adresu može da promeni moju šifru. To nije ok. Umesto ovog, u mejlu koji dobijem kad kliknem “zaboravio sam šifru”, treba da stoji jedinstveni link kojim potvrđujem izmenu šifre, tj. šifra treba da se promeni tek kad ja, vlasnik email naloga, odradim svesnu akciju. U suprotnom, šifra treba da ostane ista kao ranije.

First Natty and Unity impressions

Wed, 04 May 2011 11:36:00 +0200

I was curious about the new UI included in latest Ubuntu release called Unity so I decided to give it a shot. I haven’t reinstalled my main working machine (10.10 still working there), but I took 10-20 GB off MacbookPro’s hard drive to install it there.

Installation went smoothly, Ubuntu even recognized the MacOS on the other partition and offered whether it should replace it (boy that was tempting!) or install alongside with it. Upon installation, everything went well, I got Unity right off, it is in fact written as a Compiz plugin, so, you got Compiz, you can have Unity and vice versa, no Compiz (say, no adequate graphic card or adequate driver), no Unity.

I had some problems installing Broadcom Wifi drivers, had to experiment and google a bit, but eventually it started working.

After the install, I just removed couple of applications I don’t use (everything using Mono, for example, Gwibber, Empathy, Shotwell etd), and installed couple I use (Kupfer, Pidgin, gThumb, Exaile). Natty occupies some 280 MB in memory upon boot. Seems rather modest to me.

Now about Unity, as it’s the biggest change new Ubuntu brings.

It may look intimidating to the users used to traditional Gnome interface. Top panel, although similar, is not your old Gnome panel. Right-clicking doesn’t work. Icons on the right are not panel applets, but indicators (not the same). So you might feel frustrated by expecting for it to behave the way you used to.

Launcher

On the left, you’ll see the launcher. If you used Mac OS or Windows 7, you’ll know what you have, same icons reused both for favourite applications you would like to be able to launch easily, and for currently running applications. I always liked that on Mac, I like it here as well. The only thing that annoyed me on Mac seems to be solved here: if you have more than one window opened for an application, you don’t see it on Mac, and if you want to pick one from them, you need to press and hold the icon until a (text) menu appears. In Unity you 1) have one small arrow on the left of the icon per every window opened, and 2) another click on the icon shows the thumbnails of the opened windows in that app, and you can pick one easily. The launcher hides automatically if some of your windows covers it, or if you maximize any window.

There’s a nice feature in the launcher: each icon is assigned a keyboard shortcut - Super+1 for the first icon on the top, Super-2 for the second etc. If you have couple of icons fixed there (say, for a file manager, terminal, browser and a chat application, you can switch between them really quickly, lot faster and more accurate than using Alt-Tab (which, of course, still works). There is also Super-W, which displays thumbnails of all open windows, and couple of other shortcuts.

Windows

Application menus are moved away from application windows, to the top panel. Again, MacOS users will feel at home here. Very sane decision, to save space by not displaying menubars of inactive windows.

Maximized windows are really maximized. All you will see is the top panel. No window bar - close, minimize and maximize buttons and window title are, again, moved to the top bar.

Dash

Dash is something like Gnome menu replacement - you get it when you either click top left ubuntu button, or tap Super key once. It’s convenient for searching and launching applications and documents. You might find it useful if you are a power user, but I guess some inexperienced users would expect to see all installed applications which they would browse at a single place. I, personally, prefer Unity’s type-and-search approach, but it’s inferior to existing applications dedicated to it, and here I must praise Kupfer again, a brilliant application for power users (I believe Quicksilver is the original application for Mac). I would really like to see integration of Kupfer and Unity as it could easily serve as the “engine” which powers dash search.

Cons

The biggest problem I see with Unity is the fact that it relies and requires video acceleration. Combine that with the fact that often you can’t rely on graphic drivers to exist or work on your specific hardware, you can’t guarantee that Unity will work on any hardware around.

Also, there are some aesthetic annoyances, unaligned buttons and images here and there, it just feels a little unpolished.

There is no centralized place for customizing look and feel. You can’t add, remove and rearrange app indicators as you could gnome’s panel applets. Right click is often unused.

General impressions

After couple of days of active Unity usage I really don’t feel restrained in any way by it, and I believe I will continue using it on my primary machine. Also, I believe it will improve in time, both in terms of aesthetics, features and customization. But generally, as a power user, I find it more friendly than the old Gnome.

Couple of hints

Install ccsm (CompizConfig Settings Manager), you’ll be able to tweak some Unity’s features there.
If your touchpad supports it, you can use three-finger scroll for moving windows around, and four-finger tap for invoking Dash.
Check this list, you might find something that suits you.

Upozorenje za Zvezda/Partizan mts prepaid pakete

Thu, 28 Apr 2011 11:09:55 +0200

MTS prepaid brojevi (Zvezda/Partizan) imaju problem sa primanjem SMS poruka. Danas sam bio u korisničkom servisu i ni službenik nije uspeo da primi SMS poruku na novi prepaid broj (kartica je ispravno aktivirana i prima i šalje glasovne pozive).

Vidim po internetu da nisam jedini sa istim problemom.

Appeasing programming language gods

Wed, 27 Apr 2011 22:30:00 +0200

Just recently, a fellow coder wrote the following tweet:

you know what function #php is missing? preg_file_get_contents - get only the content part which matches the pattern

I’m not usually reacting to such appeals, but I felt this is very suitable to try to explain what’s so deeply wrong about PHP, and not as much with PHP but with the whole attitude in communities around certain platforms. I said that that statement is wrong on so many levels, so here I’ll try to address some of them.

`language == function`

This is so symptomatic in PHP - identifying the language with the function set provided with it. That tells helluva lot about the language (or, rather, the lack of one). Hey, I thought languages are there to allow you, the programmer, to actually create the functions you need.

Micro-specification

Instead of having few very poweful functions which you can combine to achieve your goal, you rely on myriad of tiny, ultra-specialized functions crafted to perform a single specific task. You need function to get lines from a file that match a pattern? All you really need is:

The possibility to iterate through lines of a file
The possibility to select items from an iterator based on a given criteria
The possibility to perform regex on a string
And a language powerful enough to combine the above three elegantly (no, C’s function pointers doesn’t count)

Something like this (Ruby, but any decent modern language has something similar):

File.foreach('pi.c').select{|line| line =~ /print/}
#    ^               ^                  ^ ...which match the given regex
#    |               | ...select only those lines...
#    | iterating through every line of a file...

See? Not even worth putting in a separate method.

Relying on gods’ mercy

Waiting for the language creators (or, in extreme cases, a comitee) to accept something which would make your life easier is frustrating, time-wasting and plainly insulting. Such gods should be overthrown, caught and imprisoned. Good gods just should give us the basic tools, a hammer and a chisel, and we’ll make the rest ourselves.

Parsing search query in Ruby

Wed, 27 Apr 2011 13:44:45 +0200

Here’s a regular expression you can use if you want to parse a user’s search query, along with some Ruby to put the result into neat Hash. The query supports prefixing with plus or minus, adding string prefix (a la Google’s site:www.site.com) and quoting whole phrase for exact matching:

def parse_query s
  s.scan(/((\S+)\:\s?)?([+-])?(("(.+?)")|(\S+))/).map{|match|
    Hash[
      [nil, :prefix, :plusminus, nil, nil, :phrase, :word].zip(match).select(&:all?)
    ]
  }
end

so that:

parse_query 'foo +bar -baz "dev pro talk" site:devprotalk.com category:cat1'

returns:

[
  {:word=>"foo"},
  {:plusminus=>"+", :word=>"bar"},
  {:plusminus=>"-", :word=>"baz"},
  {:phrase=>"dev pro talk"},
  {:prefix=>"site", :word=>"devprotalk.com"},
  {:prefix=>"category", :word=>"cat1"}
]

Reverse a string using regexps

Sat, 23 Apr 2011 12:55:05 +0200

I know you have always wondered how would one reverse a string without using loops or any kind of iteration, using, say, regular expressions and recursion. So stop wondering you:

class String
  def r_revert
    sub(/(.+)(.)/){$2 + $1.r_revert}
  end
end
'jablan'.r_revert
#=> 'nalbaj'

or, if you prefer recursive lambdas instead of monkey-patching:

l = ->(s){s.sub(/(.+)(.)/){$2 + l.($1)}}
l.('jablan')
#=> 'nalbaj'

tačka zvezda: Šta ćemo i kako ćemo

Sun, 17 Apr 2011 12:05:21 +0200

tačka zvezda: Šta ćemo i kako ćemo:

omegawm:

Preporučiću vam jednu izvanrednu knjigu o radu, stvaranju, zdravom razmišljanju i dobrim i lošim navikama. Napisana je narodski, jasno i koncizno, 1908. godine.

Mislim da je dovoljno pročitati predgovor ovde.

Pored opštih lekcija o vrednoći, štednji i urednom životu, autor recimo…

Get first and last line from a file

Tue, 29 Mar 2011 16:46:45 +0200

I needed to get only first and last line from a file (actually, not a file, but rather output from another command). head -1 and tail -1 can be used to get either first or last, but how to combine the two at the same time? Here’s how. Enter tee:

cat somefile | grep something | tee >(head -1) >(tail -1) > /dev/null

Neat, huh?

Random Mac/OSX PITA list

Wed, 23 Mar 2011 16:57:00 +0100

Ok, here’s my entirely private, subjective, random list of Pains In The Ass that I experienced while I was trying to get used to using OSX on a Macbook. While I spent years working in Windows as well, I mostly tend to compare experiences with Linux, allegedly notorious for its desktop (un)friendlyness.

The list is unordered, some things bothering more, some less.

No way of changing the UI, only two, marginally different “skins”, that’s it. Let me say I’m not some design-obsessed lunatic that changes his desktop appereance every day or two, but I like to be able to set it once the way I like it (colours, fonts, window decorations, iconsets etc) and use it that way.
No localization to my native Serbian language. Again, I’m far from a nationalist in any possible sense, but I like my language and I like the possibility to use it on my computer, as much as I use it when talking to people around me.
Again, non-US keyboard layout is not easy to use. Application don’t remember their individual layout, serbian layout is nonstandard so it has to be tweaked using third party tools etc.
There is a set of application that you are kind of encouraged to use. Music player - use iTunes. Image viewer - use built one. Text editor - buy TextMate. There are alternatives, but they are far from anywhere close to the mainstream ones. In Linux, there are really plenty of alternative software. Not always 100% bug-free and not always 100% features there, but there’s always hope that either application A, B or C will get the feature you need, or application D will emerge with it. No such thing on Mac.
I like to see the name of the song currently being played. In Linux, there’s Panflute applet that hooks to a number of music players. I had no luck finding similar tool for Mac.
XWindows apps look and feel crappy (gimp and inkscape for example).
Package management is inferior to apt.
Every possible 3rd party application, no matter how trivial, is commercial.

Now, some hardware issues

Keyboard is designed to look nice, but the keys lack tactile feedback (flat surface) and they are way too fragile (broke two before I adapted, and I hate having to adapt).
Sharp front edge where the wrists are resting. Not sharp enough to really cut you, but uncomfortable for sure.
No way to make use of integrated graphic card in OS other than OSX.
Only two USB ports.
Non-standard port for external monitor.

Clojure's interpose and interleave in Ruby

Thu, 03 Mar 2011 21:58:00 +0100

These days I’m reading a great book titled “Seven Languages in Seven Weeks” by Bruce Tate, currently I’m on Clojure, and I am really surprised how easy it is to follow, knowing Ruby beforehand.

In chapter on lazy evaluation, I noticed couple of methods that didn’t have their exact counterparts in Ruby, and I was curious how hard would it be to implement them. So, there they are.

interpose works similarly to Ruby’s join, just more generic: its result is not String, but lazy sequence of elements from the starting sequence, with object given as argument inserted in between each two.

Here it is, implemented in Ruby:

module Enumerable
  def interpose obj
    Enumerator.new do |yielder|
      self.each_with_index do |elem, i|
        yielder.yield obj unless i == 0
        yielder.yield elem
      end
    end
  end
end

p [:lather, :rinse, :repeat].cycle.interpose(:and).take(5)
#=> [:lather, :and, :rinse, :and, :repeat]

interleave works similarly to Ruby’s zip, but this one also works on lazy sequences, not Arrays, as in Ruby, meaning that you can apply it to indefinite sequences as well. Here it is in Ruby:

module Enumerable
  def interleave another
    this = self.to_enum
    another = another.to_enum
    Enumerator.new do |yielder|
      loop do
        yielder.yield this.next
        yielder.yield another.next
      end
    end
  end
end

p (0...2).cycle.interleave((0...3).cycle).take(20)
#=> [0, 0, 1, 1, 0, 2, 1, 0, 0, 1, 1, 2, 0, 0, 1, 1, 0, 2, 1, 0]

Both examples are taken directly from Bruce Tate’s book.

Zašto je PHP bolji od Rubija

Thu, 24 Feb 2011 18:30:00 +0100

[Prevod članka Alija Nadžafa, britanskog programera. Original je ovde: Why PHP is better than Ruby]

21.2.2011.

PHP je bolji od Rubija. Eto, rekao sam. U ovom članku ću vam objasniti zbog čega, i usput verovatno iznervirati neke hipi fanove od dvadeset i kusur sa japankama i Mekovima.

U Rubiju sve je objekat… čak i literali!

Ovo je prosto bolesno. Ne znam kako Rubi developeri mogu da sebe nazivaju programerima. U PHP-u nismo pobornici standardnog interfejsa. Mi slavimo svoju šarolikost. Da li je plast, igla ili igla, plast? Da li treba da zovemo metodu nad objektom ili da ga prosledimo funkciji? Ili treba da radimo i jedno i drugo i kodiramo različitim stilovima da bismo učinili život veselijim?

U poređenju sa svakodnevnom avanturom provaljivanja kako PHP radi, Rubi je dosadan. Uzmite kao primer funkcije za rad sa stringovima. Da biste uradili najobičniju zamenu stringa u Rubiju, morate da pozovete metodu na svom stringu, a ne da ga prosledite funkciji za rad sa stringovima. Kakav objektno orijentisani krek je pušio Matz? To ubija svako uživanje u programiranju!



Pored toga, imam osećaj da su developeri Rubija bili posebno duhoviti kad su smišljali jezik. Hajde da odemo dotle da se složimo da je sve objekat. Ali i klase? “Klase su objekti klase Class”? Neko sigurno umire od smeha na račun ovih ubogih Rubi developera.

Sintaksu Rubija je nemoguće razumeti!

Rubi poseduje takve sumanute i uvrnute začkoljice koje normalno ljudsko biće nije sposobno razumeti. Pogledajte ovo, recimo:

class Address
  attr_accessor :name, :line1, :line2, :county, :postcode, :country

  def Address.valid_postcode?(string)
    #true for valid postcode, false otherwise
  end

  def initialize(data)
    if data[:postcode]
      raise "Invalid postcode" unless Address.valid_postcode?(data[:postcode])
    end
  end
end


Ovaj kod je potpuno nerazumljiv… Kao prvo, nigde nema vitičastih zagrada. Vitičaste zagrade me čine sigurnim i voljenim, a ja ovde ne vidim nijednu. Takođe, gubim osećaj ravnoteže kad nemam zagrade. Iako je suviše zagrada loša stvar (ne podsećajte me na to koliko mrzim LISP), naravno da su nam neophodne za grananja? Argumente funkcija? Zar niko ne uočava ludilo ovde?!

PHP mi omogućava da vežbam svoju veštinu slepog kucanja a Rubi ne

Kao zaluđenik za slepo kucanje, volim da se vežbam. Problem sa Rubijem je što mi dozvoljava da radim iste stvari koje mogu u PHP-u, samo sa mnogo manje kucanja. Pogledajte ovaj primer jednostavne klase sa geterima i seterima u PHP-u, a zatim u Rubiju:
    
class Address
{
    private $name;
    private $line1;
    private $line2;
    private $county;
    private $postcode;
    private $country;

    public function getName() {
        return $this->name;
    }

    public function getLine1() {
        return $this->line1;
    }

    public function getLine2() {
        return $this->line1;
    }

    public function getCounty() {
        return $this->county;
    }

    public function getPostcode() {
        return $this->postcode;
    }

    public function getCountry() {
        return $this->country;
    }

    public function setName($newName) {
        $this->name = $newName;
    }

    public function setLine1($newLine1) {
        $this->line1 = $newLine1;
    }

    public function setLine2($newLine2) {
        $this->line2 = $newLine2;
    }

    public function setCounty($newCounty) {
        $this->county = $newCounty;
    }

    public function setPostcode($newPostcode) {
        $this->postcode = $newPostcode;
    }

    public function setCountry($newCountry) {
        $this->country = $newCountry;
    }
}


A sada pogledajte istu stvar sa istim pristupom u Rubiju…

class Address
  attr_accessor :name, :line1, :line2, :county, :postcode, :country
end


Ovo je previše kratko da bi bilo kome bilo od koristi. Ako tako lako mogu da pravim klase sa public geterima i seterima na svom poslu, prsti će mi odumreti i neću imati ništa za vežbanje. Hoću da mi se tastatura dimi pošto otkucam definiciju klase, a tri patetične linije Rubi koda nisu ni od kakve koristi.

Takođe, bagovi koji su posledica grešaka u kucanju su vrhunac mog dana i preferiram sintaksu koja mi omogućava da napravim što više takvih. Batalite taj svetogrdni Rubi kod sa svojom konciznom i izražajnom sintaksom. Usredsredite se na ove tople i sigurne vitičaste zagrade. Eto, tako je bolje…

Rubi vam ne dozvoljava da pravite proizvoljne public atribute na objektima!

Jedna od pobedničkih stvari kod PHP-a je po defaultu mogućnost da postavite proizvoljni javni (public) atribut na objektu. Pogledajte sledeći PHP kod:

class Address {
      // vidi gore..
}

$address = new Address();
$address->xCoordinate = 54;
$address->yCoordinate = 73;


Ovo znači da možete da ugurate proizvoljne podatke u objekat gdegod želite u svom kodu! Povrh toga, ne morate da to deklarišete, dokumentujete ili ukažete na to na bilo koji način. Slobodno pišite kod u ostalim delovima sistema koji se oslanja na to da su ove public vrednosti postavljene. Ovo je odlično za očuvanje posla, jer niko osim vas neće moći da razume kako vaš kod radi.

Rubi vam dozvoljava da redefinišete klase, gdegod vam padne na pamet, uključujući i one iz standardne biblioteke!

U Rubiju, možete da uradite ovo:

# klasa za cele brojeve u Rubiju
class Fixnum
  def +(adder)
    self - adder
  end
end
## tako je rođaci, upravo sam pretvorio sabiranje u oduzimanje


Mora da nešto nije u redu sa jezikom koji vam dozvoljava da podrijete osnovna pravila aritmetike!

Šalu na stranu, developeri su po definiciji glupi. I zli. Dajte im priliku, komitovaće suvu konjsku balegu u svn i naprosto se ne može računati na njihovo ponašanje. Ako im pružite mogućnost da menjaju osnove jezika kako im se ćefne, sami tražite frku od svih glupih i zlonamernih developera iz vaše firme.

U nekim ekstremnim slučajevima, primećeno je da Rubi developeri u svom prirodnom okruženju umeju da prave čitave poddijalekte jezika, prilagođavajući jezik svom određenom domenu. Štagod radili, ne dozvolite ovakve jeretičke gluposti u svojoj organizaciji.

Zaključak

Sve sam ispričao, Rubi je nemoguće razumeti, a daje developerima naizgled potpunu kontrolu nad jezikom. Najiskrenije vam predlažem da još jednom razmislite pre nego pokušate da naučite Rubi. To je slično zombi infekciji, dok kažete keks koristićete git za čuvanje koda, radićete od kuće u Textmate-u i bizarne funkcionalne paradigme će početi da se uvlače u način na koji pišete PHP.

Upozoreni ste.



Acer Aspire One D255 review
Thu, 30 Dec 2010 14:18:32 +0100
I needed a cheap netbook to replace my old 7-inch Asus eeePc, already semi-broken, part of its display permanently dead, some keys not working anymore, others pulled out. It is our kitchen computer, used by wife and kid, and main criteria was to be as cheap as possible, so I wouldn’t have to despair if it gets its keys extruded, or milk spilled over.

Asus Aspire One D255 (single-core Atom) is the cheapest netbook around, although others aren’t much more expensive, all sharing similar features - single core Atom processor, 10-inch screen and 160GB hard drive. When deciding which one to buy, main concerns were around number of USB ports, and quality of keyboard and touchpad. At one point I was also hoping to be able to buy it with Windows, and then reuse the license on another computer, but I found out I am not allowed to do that, so it didn’t matter which OS it came with, as I would reinstall Ubuntu anyway.

Aspire One is available in around a dozen different variants, slightly different casing, different OS’s and hard-drive sizes. I heard there are two-core variants, but I haven’t see any of them offered in Serbia.

This D255 comes with bare minimum of features, 160GB hard drive, 1.66 N450 Atom, 1GB of RAM and 3-cell battery (most of the time, the computer is attached to mains, so I didn’t care much about the battery life). Nice thing are 3 USB ports (2 on the left, one on the right side), so I wouldn’t worry about attaching mouse, external keyboard and a USB drive at the same time (an issue I hate with insanely priced Macbook Pro, for example).

So, here are my impressions after installing Ubuntu and working on it for a while:

Keyboard is big enough to comfortably work on (as much as physical size of the netbook itself allows), but the keys are strangely shaped: their surface seems wider than the basis, crosscut resembling letter T. This probably means that it’s easier to accidentally pull out the key while typing (say, if your finger or a fingernail gets stuck between keys). I had similar problem with macbook’s keyboard, and this one seems even more prone to the problem. I’d give it 3/5.

The touchpad is big enough, concerning the space constraints below the keyboard. I dislike the fact that it’s not separated more clearly from the surrounding surface (only two thin lines which can barely be sensed under a finger), so it’s easy for your finger to get outside the sensitive area. Left and right click are performed using a single button, also a bit hard to hit precisely. Also 3/5.

The screen is glossy but of poor quailty - you can see vertical stripes between pixels on a light background. The backlight is LED and it’s uniform across the whole screen, that’s ok. 3/5 again.

The rest of the features are pretty standard so there’s no point in discussing them separately. Atom is powerful enough to surf and play some movies and music. Single core means that the machine can get stuck sometimes.

It has integrated video card, but it works ok for basic needs: Compiz works outside of the box, and there are no visible glitches during video playback, both in a window or fullscreen.

During a normal work, the machine doesn’t get hot at all, the bottom is pleasantly warm to the touch.

Speakers are placed a bit awkwardly - below the palm rest, but turned downwards, on the bottom of the casing. This means that if you place the computer on a soft surface (say, your lap), the sound will get damped. I am not sure if other netbooks use the same idea, but it doesn’t look right to me.

Now - the software. It comes with the Linux preinstalled (I think some variant of Moblin, or Linpus). It looked interesting, quite unusual for a Linux, but I didn’t bother to investigate it much, I just was a bit annoyed that I couldn’t find a button for shutdown or a restart. I installed Ubuntu 10.10 right away. I used a USB flash drive as the netbook doesn’t have optical drive. I had some problems with grub (Error 17), but it resolved by updating grub manually.

Maverick Meerkat runs smoothly on Aspire One, the only thing doesn’t work is card reader (I will try to find a solution and post about it later). Oh, I haven’t tried webcam at all, I don’t know if it works.

That’s about it, here are general impressions:

Pros:

Price
Runs Ubuntu smoothly
Cons:

Keys seem fragile
Vertical stripes visible on screen
Inadequately placed speakers



Imate novi pasoš, a treba vam nova lična
Wed, 29 Dec 2010 16:33:05 +0100
Pre mesec-dva sam postavio pitanje na ES-u u vezi vađenja nove lične: interesovalo me je šta treba od dokumenata, pod uslovom da sam već vadio novi (biometrijski, crveni) pasoš.

Evo da odgovorim sam sebi: državljanstvo nije potrebno. Izvod iz matične knjige nije potreban, pod uslovom da ste prilikom vađenja pasoša prilagali novi, trajni izvod (roze boje). Ako ste pasoš vadili pomoću starog, zelenkastog, “ne starijim od 6 meseci” izvodom, trebaće vam novi.

Naravno, potrebne su i dve plaćene uplatnice, o tome više na sajtu MUP-a.


StackOverflow-style syntax highlight on Tumblr
Sat, 11 Dec 2010 22:28:00 +0100
There are several articles on how to enable (client-based) syntax highlighting on Tumblr. None of these solutions worked for me, as each requires setting class on pre or code tags manually for coloring JS snippet to recognize areas to colorize. This is not simple in my case, as I am using Markdown as markup language, and generating HTML tags (and their attributes, such as class) is out of control there.

So I decided to slightly modify existing solutions to suit my needs. I took prettify module and combined it with small jQuery snippet of my own, which prepares existing HTML (created using Markdown) for prettification, by dynamically assigning prettyprint class to code blocks.

If you want to do the same, just customize your theme’s HTML to include following lines:





And that should be all it takes to get your code nicely highlighted!


"Each with previous" in Ruby
Sat, 11 Dec 2010 18:10:00 +0100
I often need a variant of Enumerable#each method, with a “twist”: sometimes I want to have previous element available along with the current one, most often for comparison between the two. Here’s a trivial example:

array = [
  {name: 'foo', value: 15},
  {name: 'foo', value: 6},
  {name: 'bar', value: 2},
  {name: 'bar', value: 7},
  {name: 'bar', value: 14},
  {name: 'baz', value: 4},
  {name: 'baz', value: 1}
]

array.each_with_prev{|prev, curr|
  # Want to display name only before the first record in the group
  puts curr[:name] unless prev && prev[:name] == curr[:name]
  puts "    #{curr[:value]}"
}
foo
    15
    6
bar
    2
    7
    14
baz
    4
    1


And here’s (very simple, inject based) implementation of each_with_prev:

module Enumerable
  def each_with_prev
    self.inject(nil){|prev, curr| yield prev, curr; curr}
    self
  end
end