Running & Coding

Erlang Riddle for Rubists

2009-06-10T01:12:00.013+03:00

The next "Erlang made stupid simple for Ruby programmers" post & screencast is in the making. I am reading again and again the pages of Software for a Concurrent World and try to synthesize Erlang's essence for the "average" Rubist.

Some stuff is straight forward, like Funs which is the Erlang Funny name for Anonymous functions.

ERLANG:

1> Z = fun(X) -> 2*X end.

#Fun

2> Z(2).

3> Double = Z.

#Fun

4> Double(4).

5> Double(4).

RUBY:

irb(main):004:0> Z = Proc.new { |x| x*2 }

=> #

irb(main):005:0> Z.call(2)

=> 4

irb(main):006:0> Double = Z

=> #

irb(main):007:0> Double.call(2)

=> 4

Great stuff, never had to use it in Ruby - but maybe in Erlang it might serve me, who knows....

Now that is an easy one. Later in the book, Joe Armstrong gives an example of a function that returns all permutations of a given string.

perms([]) -> [[]];

perms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].

I have tried to rewrite it in Ruby, in a form that would mostly imitate what's done here.

That's my best try so far:

def prem(s,nx = [])

return nx.join if s.empty?

s.collect { |b| prem(s-[b],nx+[b]) }.flatten

end

puts prem('dor'.split(//))

output:

dor

dro

odr

ord

rdo

rod

I hate the flatten hack I did there to simulate Erlang's valuse return as one Array.

I dislike having to send prem all his recursive "past" (as "nx").

I think there must be a better way to do it. A better way that will deliver the Erlangian concepts.

Do you think you might have a better way to pronounce the Erlangian magic of this function in Rubish ? If so, please post it here (as a comment) I'd really love to see it!

Whoever has a better solution (me need to like) will get full credits and endless honor (!)

The Screencast: Erlang made stupid simple for Ruby programmers

2009-06-06T22:41:00.003+03:00

Erlang made stupid simple for Ruby programmers receives traffic well beyond my expectations. I therefore went forward and created it as a screencast:

Erlang made stupid simple for Ruby programmers

2009-05-30T21:31:00.014+03:00

Update: This post has amazing traffic so it now has its own screencast

I have a strong gut feeling that Erlang is the next (current) big thing.

I started learning erlang with the very good and well written book by Joe Armstrong, Programming Erlang: Software for a Concurrent world . I am trying to keep a summary of what I am learning and so I started writing it as a little note. Doing so I noticed that I am able to squeeze a lot of pages into few lines and thought that someone else apart from me MIGHT also understand what I meant as I wrote it as if I was explaining Erlang to another Rubist. I hope I am right.

* I have tried to remain superficial and not to get into details in order to keep things as simple as possible to start with.

The list is here, I might also produce a small screen cast and part #2 for this in the coming future. Enjoy!

end every sentence with a dot.

you can write numbers with base declaration: BASE#NUMBER.
example: 15 is like 10#15 or 16#f

erlang has no variables, only constants.

erlang's constants are being called variables.

constants start with a capital letter:
C = 5.
CapitalLetter = 5.

divide floats with "/"
5 / 3 => 1.6667
5.25 / 3 => 1.75

divide integer with "div"
5 div 3 => 1

modulo = reminder = "rem"
5 rem 3 => 2

"string" is written with double-quotes

atom = ruby :symbol is written as is (starts only with lowercase letter)
johnny_walker

'something' acts different then "something" or symbol. still need to figure it out.

kind of array = tuple
defined with {}
used broadly in erlang, also to replace complex data structures you would create a class for in ruby.
NiceTuple = { 10, 45 }.
NicerTuple = { 10, joe, 45, david }.

{X,Y,Z} = {1,2,3}.
X => 1
Y => 2
Z => 3
like multiple assignment in ruby:
x,y,z = 1,2,3
it works just the same in these cases.

{something,X} = {something,5}.
x => 5
BUT
{something,X} = {something_else,5}.
wont set X (!)
"=" sets if left tuple structure fits right tuple structures in length and position of atoms/strings.
{"gran torino",X} = {"gran torino",5}.
X => 5

err: {something,X,X,X} = {something,1,2,3}.

{_,_,_,koko,5,X,_,_} = {i,dont,care,koko,5,123,whats,here}.
X => 123

arrays on steroids = lists
defined with []
[1,2,3,[4,5]]
[i,ate,{a,tasty,cake}]

SmallArray = [3,4].
BigArray = [1,2|SmallArray].
BigArray => [1,2,3,4].

[First_element|All_the_rest] = Array.
[First_element|All_the_rest] = [1,2,3,4,5].
First_element => 1
All_the_rest => [2,3,4,5]

[First,Second,Third|All_the_rest] = Array.
[First,Second,Third|All_the_rest] = [1,2,3,4,5,6].
First => 1
Second => 2
Third => 3
All_the_rest = [4,5,6].

{X,Y,Z} = {1,koko,"loko"}.
X => 1
Y => koko
Z => "loko"

modules: Erlang's basic unit structure, comes in a file
filename.erl
erlang compiles it and then its called
filename.beam

the structure of a .erl file:
-module(file_name).
-export([function_name/1]).

function_name(X) -> 0.
---------------------------
this amazing module should then be called from the erl console with
c(file_name)
and then
file_name:function_name(1) => 0
file_name:function_name(koko) => 0
file_name:function_name(whatever) => 0

a more interesting function:
-module(file_name).
-export([function_name/1]).

function_name(true) -> 'funny';
function_name(false) -> 'not funny'.
-----------------------------
this function returns different values for "true" and for "false"

one nicer example:
-module(file_name).
-export([fib/1]).

fib(0) -> 0;
fib(1) -> 1;
fib(N) -> fib(N-1) + fib(N-2).

to be continued ...

Big oaks from little acorns grow

2009-02-16T07:46:00.013+02:00

I usually focus on programming and the internet world on this blog.
Though I have a lot to say about politics in Israel and in general, I usually avoid this topic, knowing that listening to a different opinion on this is a very rare commodity for those who are emotionally involved. And we all are deeply emotionally involved - Jews, Muslims, Christians, Atheists and other...

Yet I think there's an idea that most of us are not yet involved deeply enough with, that is worth mentioning in these wicked days.

I saw an article in the paper today that some UN committee foresees 50 million jobs to be lost in 2009. 50,000,000 people will lose their jobs. That's a lot.

What I find more interesting is (1) I can't recall who really said it (UN committee? what does that mean?) (2) I can't recall if they meant 50,000,000 jobs lost, or that there will be 50,000,000 unemployed people in the western world (no one really knows what happens in Africa, right?)

Since the newspaper article didn't go into these details and we're left with just this perspective, they might as well just have written in the paper "BE AFRAID." It would have the same effect.

Yet it is also true that old people are losing their pensions, and that too many family people find themselves with debts and with no income.

In such times what's growing more than anything else is a sense of fear and uncertainty - and with that grows the need for strength and certainty (it's a simple equation). In pursuit of strength and certainty, it's so easy to slip into confusion and misunderstanding.

Strength and certainty are not to be found externally. These are inner sources of belief and hope that can give one the strength to go on and actually achieve something in a land of psychological depression and common moral depression.

Remember: There's still a lot of money in the system and plenty of ways to maintain a decent quality of life.

What should we be scared about?

Looking for the strength and certainty externally - in the form of a "Strong Leader" or a "Strong System of Ideas and Ideals" that claims to be so right that we must follow him/her/it, as that promises us Heaven's Joy Here on Earth (or in other life...).

We do need strong leaders and a strong systems of ideas and ideals that can lead people safely through this crisis. But this is a peripheral part of the equation.

Strength is not necessarily the action of force and power. There is amazing strength in silence and tolerance, in compassion and understanding and in NOT-RESPONDING - taking 5 more minutes to think.

It is time to go inside and outside. Finding inspiration inside and outside, in nature's work or in spiritual places (whatever your belief is or is not).

As the waves and winds get stronger and higher, those who are calmer and are "fast on the inside and slow on the outside" will be able to pass through this crisis and remain intact.

Look for the stronger leader - within.

PAW!!!

2008-07-07T02:54:00.007+03:00

http://pawst.com

A search engine that reminds google's "I Feel Lucky", they call it PAW!

you write a subject and PAW! for it, it will show you the TITLE of a found webpage and will load it.

clicking PAW! again will move you to the next search result.

SO, WHAT'S SO COOL ABOUT IT ???

THE RESULTS ARE GREAT!!! I found myself surfing from website to website and revealing wonderful websites along the way!

Juggernaut, an up-to-date tutorial

2008-04-11T01:05:00.021+03:00

April 20 - posted a fix to chapter 9:

Make sure you have all the prerequisites installed:

Rails 2.0.2 or edge
Json gem (gem install json)
EventMachine gem (gem install eventmachine)
Install the GEM -
```
sudo gem install juggernaut
```
Create a new Rails APP -
```
rails koko
```
Enter it's dir -
```
cd koko
```

Install the Juggernaut plugin -

ruby script/plugin install
http://juggernaut.rubyforge.org/svn/trunk/juggernaut

Paste this inside koko/juggernaut.yml -

http://pastie.caboo.se/179083
Paste this inside koko/config/juggernaut_hosts.yml -

http://pastie.caboo.se/179077
Paste this inside koko/app/controllers/chat_controller.rb -

http://pastie.caboo.se/179079
Paste this inside koko/app/views/chat/index.rhtml -

http://pastie.caboo.se/179073
*FOR UBUNTU ONLY (and maybe other linux distors too):
```
export PATH=$PATH:/var/lib/gems/1.8/bin
```
(add it to your bash.profile too)
or use /var/lib/gems/1.8/bin/juggernaut in the next phase

Run the Juggernaut Server -

juggernaut -c juggernaut.yml

"Starting Juggernaut server on port: 5001..." is the answer you than expect

Run the Rails Server -
```
script/server
```
Browse to -

http://localhost:3002/chat?send_to_channel=1&listen_to_channel=1

You will be sending and receiving through the channel numbers specified in the QueryString

You can use either "RAILS SEND" to send through the Rails Server or "JS SEND" to use the Ruby Server only ( YES - it will work with your Rails server down)

Notice that I've "faked" a firebug-like console on the right, to see all Juggernaut logs in realtime even if you're not using firebug.

The input from the listened-to channel is shown on the left box.

Now, open another browser with the same URI and start chatting!

ENJOY!

Resources:
http://juggernaut.rubyforge.org/
http://groups.google.com/group/Juggernaut-for-Rails

Juggernaut, Push Server, The future of the web

2008-04-11T00:17:00.006+03:00

My dear blog, it's been 3 long month since my last post. Forgive me.
I had so many stuff to do:

Coding - have you seen the new forums at SA? (http://seekingalpha.com/symbol/aapl/mb/topics)
Kudos to everyone in SA tech team
Running
Learning Italian
A little more ...

But than - suddenly, unexpectedly, I ran across... The next hottest thing in WEB - JUGGERNAUT!

Yes, treat it as the new Gospel in our business... web.

What is it?
What's new? we had it since ever!
How will it change the web?
How can I start?

1. What is it?

It's more than Ajax.
Ajax is an HTTP connection that's opened especially per request and closes as it ends.
Juggernaut, with Flash OBJECT on the Client Side and Ruby Server (Push Server) on the Server Side, allows you to keep an open connection and thus allow real-time connection.

YU HU!!! what's so amazing about it???

Very high frequency (on my machine ~ 2000 req/second)
Scalability (based on EventMachine)
Low Hosting Costs (less servers and memory is needed than if Ajax was used)

2. What's new? we had it since ever!

Juggernaut does it well, easy, cheap and smart.

Client Side: JavaScript + Flash Object
Server Side: Ruby

3. How will it change the web?

Chat is nice but think of all the collaboration and real-time data services you know, think of it functioning 10x faster.

4. How can I start?

Luckily, Juggernaut code is updated very frequently - improvements are made and bugs are being treated.

Unfortunately, it changed it's already somewhat known API and so the already written tutorials are obsolete.

Luckily, I am going to explain how to get this sweety to work in my next post:

http://www.dorkalev.com/2008/04/juggernaut-up-to-date-tutorial-1042008.html

Kudos to Alex MacCaw from http://www.eribium.org/ for creating and maintaining Juggernaut

"How to Start a Project" or "Chaotic Project Management, part 2"

2008-01-30T19:35:00.000+02:00

How to start a project?

Get a reference point.
Whatever it is.

Good chances are that the project is based on an emotional desire. No one wrote a Specification. Some one knows one part of the project, some one else knows another. There's no one 'oracle', no one place which holds the whole information in an ordinated manner. No constant reference point which one can work by, sometimes no one to ask either.

A few years ago I lived in the country side. One night I went out for a run in the fields. The hour was 22:00 and the fields were much vast and dark than I imagined them to be.

Instead of 20 minutes run, I found myself unable to position, running around in circles (probably, I saw nothing). After a while, when I started loosing patience, I decided to stop choosing different directions every time I believe I run in the wrong direction and instead to find a light source and run towards it. 10 minutes later I found my self near the lights of a small village street far from my home. I continued walking down the street and from there hitch hiked home. The whole adventure took something like 90 minutes.

When you get a project, look for reference points.

Start building a model with what you have. A model shouldn't be a specification document but the actual thing (if it's a program, you should actually program it).

Always try to understand the small details, they will hold the keys to understanding the whole system but never try to implement all of them in the model.

Cling to the big reference points.

What are the main objects of the project?
What can't the project work without?

Build it up together.
Don't try to cover 100% of the cases.
Build the simplest implementation.

Remember, it is cheaper to build 2 tools which do specific functioning than building 1 which does both. It's much pricy to build or buy a Swiss Knife than a simple set of tools for each function needed.

In databases, many times - it's chipper to do 2 SQL queries with a UNION instead of 1 complex one.

Never try to fulfill all the functionalities of the project with one tool. It's cool and interesting but it might cost you your seat. If two functionalities are ment to be processed by one tool, it will naturally happen in a later phase - when similarities of the two different tools will intrigue you to commit this change specifically.

As you continue in the process of building this model, you will naturally see what's central and what's not. It will be possible for you and for your client to ask the right questions and get the proper answers.

Along the way, keep an open eye on the weak points of the model - write them down, think about them, plan and finally refactor.

Chaotic Project Management, part 1

2008-01-18T21:32:00.000+02:00

I always thought that writing a good spec before programming is mandatory.

I like short but frequent discussions where a project spec is being written. I found out that having a spec (Agile, or not) is something mandatory. Ever since I understood I have to demand a spec from the customer, even if I have to sit down with him and write it together (frequently), programming became a much faster and easier task to commit.

It is funny that in our world of 'thinking' people, so many times we don't think and rush to program without a true moment of thinking.

If you know the road, you can reach the target.

If you start programming before having a plan, you might find yourself in a chaotic situation. You spent a lot of time programming stuff that isn't needed at all and now you have 20 waiting tasks with unknown priorities. Chaos. The customer isn't nice anymore, you are frustrated and the project becomes more and more complicated.

In cases where the possibility of getting a good spec is low there's a project management style that has to be considered - the chaotic one.

The Chaotic Project Management

1 In the beginning God created the heaven and the earth.

2 And the earth was without form, and void; and darkness was upon the face of the deep. And the Spirit of God moved upon the face of the waters.

Genesis I, 1-2

Bring the customer to your office for a couple of days or go sit with him in his. Define short tasks together and to them with his constant observation. The customer should understand that for this matter you function as his 'hands' and to the actual programming but what will be is what he asks.

Don't think about performance or beauty of code. Don't think about good DB structure, think about getting it done.

This project management style gets results very fast but it is pricey and demands great patience. It should only be used when you know you can't go a step forward in the project because of lousy communication and bad specs.

It should be done only with customers you have intimate relation with and are ready to go into this adventure with the price it demands.

Many clients don't understand what project they wish to have. This project management style is all about getting to know the project. It's about managing something that has yet been formed ("without form and void").

After a while, you'll have a clearer picture of what the project is and so would your customer.

Now will be a good time for both of you to write a good spec and manage this project in a more conservative way.

http://www.bartleby.com/108/01/1.html#S1

How to form a team, part 1

2008-01-05T21:54:00.000+02:00

Since I started attending seminars with the great Italian coach Patrizio Paoletti, I have been trying to discover the keys that stand behind success stories. Whether it's a small change of habit, the way of a poor man to richness or helping mankind.

Last week I came across such an idea which I sense has more to, than what I understand and will present here.

When you start a project you either do everything by yourself or you take all the decisions by yourself. Either way, all responsibility is yours and all the success and failure too.

(during this post, you are BO)

After a while, you gather up a team with different skills:

This time, you are still the manager of the project but you are also a programmer. You now have more responsibilities under the high responsiblity of "Fulfill the project's goals":

Make the team co-op toward success.
Responsibility for Claudia's quality of work.
Claudia is a less experienced programmer than you and thus you have the responsibility for her current work and for her growth and evolution as a programmer.

After a while, you hire more:

You no longer program but you are still managing.

Derek, Cindy and Joe are the most experienced experts in their fields and thus each of them has the cross-responsibility for his field. Tom for design, Derek for QA and Joe for programming. They are Field Managers.

Paris and Dave are project managers you hired and have the responsibility for each project's success. They are Project Managers.

You, however, have the higher responsibility for Paris and Dave success in their duty and their improvement.

What is the third dimension of this Matrix? Will.

Each person in this matrix has a skill that for which he was hired: Programmer, Designer, QA or Manager. Each person in this matrix has a level of management skills, hopefully the better managers actually get to hold this title as Project Managers or Field Managers.

The third point that each person in this matrix relies-on is his will. Motivation, higher goal or quest - the reason for which I do what I do. Whether it is in order to feed my family or to fulfill my curiosity of the profession, I must be motivated. Yes!!!

Kudos to Koby Menachemi for this insight

...and now to something completely different... Jovanotti -

Standards VS. Performance

2008-01-04T02:17:00.000+02:00

Today I had to create an XML with ~ 7000 records.

The first role looked like this:


Controller
def all_articles
  @articles = Article.find_all
  render :layout => false
end

View - articles.rxml
xml.instruct! :xml, :version => '1.0'
xml.root do
  xml.articles do
    @articles.each do |article|
      xml.article do
        xml.id article.id
        xml.title article.title
      end
    end
  end
end

The size of the XML was ~ 800kb and it took 7 seconds to render.
Horror, ah?

The truth is, after thinking, I don't really need an XML in this specific case. All the data is going to be read by a JavaScript that I can modify to get any format I like.

The solution:


Controller
def all_articles
  ActiveRecord::Base.connection.execute("SET SESSION group_concat_max_len = 999999999;")
  @articles_big_csv = ActiveRecord::Base.connection.execute("select group_concat(articles.id,'>',articles.name SEPARATOR '<') from articles").fetch_row.first   render :layout => false
end

View - aricles.rxml
xml.instruct! :xml, :version => '1.0'
xml.root do
  xml.articles @articles_big_csv
end

The output of "select group_concat(articles.id,'>',articles.name SEPARATOR '<') from articles" is in the format of "ARTICLE ID>ARTICLE TITLENEXT ARTICLE TITLE..."
(I can use the "<>" as separators since I dont allow them in an article name; else I could use any sepeartors I like)

Later, on the parsing JavaScript side I will split the string by '<' to get the rows and each row I will split by '>' to get it's columns.

The size of this output is now 200kb and rails can render it 11(req/s)

(...if you are lucky and your server gzips everything it goes down to 80kb)

What did we do?
1. Smallest size: we didn't use XML standards but a simple primitive string with separators.
2. Fastest tool: we did all the work in MySql which is much faster than Ruby.

Kudos to Roman Krom for the 'let sql do the work for you' philosophy
Kudos to Boris Peterbard for teaching me the group_concat magic

Not Running

2008-01-04T01:23:00.000+02:00

It's been a week since the last time I ran.

Last friday, December 28 2007, I woke up at 6:00am and went for a casual morning run with Arik, a dear friend from work. I already felt a bit dizzy and it was very cold but we ran anyway, a bit slow and with a Fleece I ran for 41 minutes at 156 average heart rate.

When I got back home I cleaned the house and by 1:15pm I fall to bed and slept until 4:30pm.

Saturday already felt worst and Sunday I was already sick.

It's been a week since the last time I ran.

I spent more time in bed and in-front of T.V. this week than any time before in the last 2-3 month.

Except for feeling bad and weak this week, the other expensive "price" I paid this week was of mental slowness. I already watched it before that when I run my mind is in "better shape" and that I can think much clearer but this week it really hit me.

At the end of each day I try to focus and in my head scan over the day that passed, this week it was very hard. Every-time I tried to recall the day that passed, everything was far and faded.

Today I already felt better and got back to regular work day in the office. I was restless and kept chewing things throughout the day. My mouth needed something to play with.

Weeks like this one are the reason I always return to running. It clears my mind, cools my heart and relax my body. After running I can think clearer, I am much more calm and I am not as irritated and annoyed as usual.

Next Thursday I will run 10 km at Tiberias Marathon.

* If you are a hebrew reader, pay a visit to Or's blog

Refactoring: We are not alone!

2007-12-31T23:55:00.000+02:00

http://refactormycode.com
Read this blog, it will make you smile!

I did some testing on the refactorings suggested in:
http://refactormycode.com/codes/2-ruby-simple-loop

testing.rb


def prof(t = 1, output = :puts)
  starting_time = Time.now
  t.times { yield }
  dlta = (Time.now - starting_time).to_f/t
  case output
  when :ret
    "### time: #{dlta.to_s}(s) . req/s: #{(1/dlta)}"
  else
    puts "### time: #{dlta.to_s}(s) . req/s: #{(1/dlta)}"
  end
end

times = []
times << ["(1..10).each do |i|
  puts i
end",
prof(1000,:ret) {
  (1..10).each do |i|
    puts i
  end
}]

times << ["for i in (1..10)
  puts i
end
",prof(1000,:ret){
  for i in (1..10)
    puts i
  end
}]

times <<  ["(1..10).each { |i| puts i }",prof(1000,:ret){
  (1..10).each { |i| puts i }
}]

#times << ["puts (1..10).to_a * '\n'",prof(1000,:ret){
#  puts (1..10).to_a * "\n"
#}]

#times <<  ["puts (1..10).to_a",prof(1000,:ret){
#  puts (1..10).to_a
#}]

times <<  ["1.upto(10) { |i| puts i }",prof(1000,:ret){
  1.upto(10) { |i| puts i }
}]

times <<  ["puts 1,2,3,4,5,6,7,8,9,10",prof(1000,:ret){
  puts 1,2,3,4,5,6,7,8,9,10
}]

times <<  ["10.times {|i| p i+1}",prof(1000,:ret){
  10.times {|i| p i+1}
}]

puts '* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *'
times.collect { |t|
  puts t
  puts '* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *'
}

Two of the suggestions:

puts (1..10).to_a
puts (1..10).to_a * "\n"

don't really work, so I left them out of the tests)

And the results are ...


* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
(1..10).each do |i|
puts i
end
### time: 0.000165467(s) . req/s: 6043.50112106946
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
for i in (1..10)
puts i
end
### time: 0.00018765(s) . req/s: 5329.07007727152
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
(1..10).each { |i| puts i }
### time: 0.00020241(s) . req/s: 4940.46736821303
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1.upto(10) { |i| puts i }
### time: 0.000216612(s) . req/s: 4616.54940631175
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
puts 1,2,3,4,5,6,7,8,9,10
### time: 0.000164026(s) . req/s: 6096.59444234451
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
10.times {|i| p i+1}
### time: 0.000208756(s) . req/s: 4790.28147693958
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Why I love Ruby on Rails and what should be said on it's performance , part 1

2007-12-30T21:48:00.000+02:00

In less than a week, you can establish a working model for your final product.

It is, however, very unwise to consider this is the end of the process.

Ruby on Rails allows ultra-fast development but all this comes in exchange to performance and efficiency.

At the end of the first development period you find yourself with a great working copy but with very low efficiency and as soon as your site starts growing you have to add more servers, more memory, more everything.

What can and should be done in this stage is the infamous 're-factoring' procedure with high attention on performance.

For example for Article and User where each user has many articles and each article
belongs to a user ( 1 -to- many relationship)

If we want to get an article's user email we railslishly write:

Article.find(123).user.email

Which feeds our logs with:


Article Load (0.002447)   SELECT * FROM articles WHERE (articles.`id` = 123)
User Load (0.002856)   SELECT * FROM users WHERE (users.`id` = 8)

This isn't a problem if you have a small application, this isn't a lot ah? 2 are 100% more SQL queries than only 1 query...

Actually, it's okay to live with it as long as you don't need to grow. When you do, you have to learn SQL.

The truth is even basic SQL can save you here (something PHP or ASP developers would never brag about...):


select * from articles inner join users on users.id = articles.user_id where articles.id = 123

Word is around that Ruby on Rails is slow because of Ruby. The truth for large scale websites is that Rails has much more to do with performance than Ruby.

Let's try a Tiny Profiling Utility on the the scenario described above, where in both cases I want to get an author email according according to it's ID:


>> prof(1000) { Article.find_by_sql('select * from articles inner join users on users.id = articles.user_id where articles.id = 123').first['email'] }
time: 0.004523629(s) . req/s: 221.061453094407
=> nil
>> prof(1000) { Article.find(123).user.email }
time: 0.005518112(s) . req/s: 181.221403262565
=> nil
>>

For one simple action we see a difference of around 20% in speed. Take into consideration that more time consumed by the SQL server is more time other queries are waiting in line, etc. etc.
Let's do the previous test for two articles (123 and 567):


>> prof(1000) {
a = Article.find_by_sql('select * from articles inner join users on users.id = articles.user_id where articles.id = 567 or articles.id = 123')
a[0]['email'] + a[1]['email']
}
time: 0.004959934(s) . req/s: 201.615586013846
=> nil
>> prof(1000) {
a = Article.find(567,123)
a[0].user.email + a[1].user.email
}
time: 0.008703669(s) . req/s: 114.894075130844=> nil

Now that's around 40% difference... imagine what would happen in the case of Many-to-Many connection...

The truth is that eager loading in Rails, should solver this issue - but for some reason it's slower... :

>> prof(1000) {
   a = Article.find(567,123, :include => :user)
   a[0].user.email+a[1].user.email
 }
time: 0.006641206(s) . req/s: 150.575061216291
=> nil

Rails is a great framework and Ruby is a wonderful language, use them and learn some SQL too, they work much faster together...Start using it now: http://rubyonrails.com

Don't forget your sql... http://w3schools.com/sql/default.asp

enjoy!

Mongrel: A recipe for Success, part 1

2007-12-28T08:40:00.000+02:00

Take two different good things and combine them together.

Examples:

Wii - Ninetendo's winning game console

Nintendo took two simple technologies:

The Wiimote (http://www.x-arcade.com/newsletter/Wii%20Dupe.shtml)
The second technology that brings it all together is the use of motion sensors. This could be accomplished with the use of Gyros, as Nintendo did buy a sizable amount of shares in the company Gyration, Inc back in September of 2001. But we do know it does use iMEMS® solid state accelerometers that detect motion by way of acceleration which were provided by Analog Devices, Inc. and/or STMicroelectronics. After much prying around at E3, I was told (by Nintendo's Developer Support) that there are three accelerometers at work in the Wiimote. There are also at least two accelerometers used in the nunchuck add-on to detect motion in it as well.
The Machine (http://en.wikipedia.org/wiki/Wii)

Instead of reinventing the wheel (http://en.wikipedia.org/wiki/PlayStation_3_hardware) they took two good technologies and mashed them up.

http://www.msnbc.msn.com/id/16115967/

Ruby 1.9.0

2007-12-28T00:33:00.000+02:00

Have you heard it was released?

http://www.ruby-lang.org/en/news/2007/12/25/ruby-1-9-0-released/

howto install:


autoconf
./configure --prefix=/usr/local/ruby1.9
make
sudo make install

For a long while we were expecting this product that should increase Ruby performance tremendously.
Mind you, I had yet seen a web application running slow because of Ruby. Most of the cases it was misusage of database and memory structures, the major down-pit Rails developers fall into (newbies as well as experts).

Ruby 1.9 is here anyway (dev. version), let's give it a try!

Tiny profiling utility

2007-12-27T23:44:00.000+02:00


def prof(t = 1)
  starting_time = Time.now
  t.times { yield }
  dlta = (Time.now - starting_time).to_f
  puts "time: #{dlta.to_s}(s) . req/s: #{(1/dlta)}"
end

Use prof to measure how long a function or any block of code takes.
Use parameter t>1 to run the block code t times and return the average time per test

Examples:


>> prof { Flight.find_first }
time: 0.002032(s) . req/s: 492.125984251969
=> nil
>> prof { Flight.find_first }
time: 0.00201(s) . req/s: 497.512437810945
=> nil
>> prof(10) { Flight.find_first }
time: 0.001351(s) . req/s: 740.19245003701
=> nil
>> prof(100) { Flight.find_first }
time: 0.0012727(s) . req/s: 785.731122809775
=> nil
>> prof(1000) { Flight.find_first }
time: 0.001415021(s) . req/s: 706.703292742652
=> nil
>> prof(10000) { Flight.find_first }
time: 0.0013922995(s) . req/s: 718.236270285237
=> nil
>>

ActiveRecord::Base#exists?

2007-12-27T01:55:00.000+02:00

class ActiveRecord::Base
 def self.exists?(conditions, unique_id = nil)
   count1(conditions, unique_id)>0
 end
end

Returns true/false if at least one row that follows ceratin conditions is found

Can only be used along with count1
unique_id - used when you still want to allow a certain raw (defined by id...) to be left out of the count. Useful for validations, ie:
User.exists? ['nick != ?',user.nick], user.id

ActiveRecord::Base#count1 - fastest counter ever

2007-12-27T01:43:00.000+02:00


class ActiveRecord::Base
 def self.count1(conditions, unique_id = nil)
   connection.execute("select count(1) from #{table_name} where #{sanitize_sql(conditions)} #{'and id<>'+unique_id.to_s if unique_id}").fetch_row.first.to_i
 end
end

count(1) is the fastest way, as far as I know, for mysql to count table elements.
Why should we use the relatively expensive count(*) when we can use this modest counter?
conditions - can come as ['title = ?','canon'] which than sanitized by sanitize_sql to 'title = "canon"', for example.
All this code can be put in environment.rb and than it extends your ActiveRecord::Base objects, thus it will exetend any Model in your railsish system.
unique_id - used when you still want to allow a certain raw (defined by id...) to be left out of the count. Useful for validations, ie:
User.count1(['nick != ?',user.nick], user.id)>0

Everything here applies to Mysql 5.0.14
(never tested on anything else...)

Kudos to Boris Peterbarg

1	In the beginning God created the heaven and the earth.
2	And the earth was without form, and void; and darkness was upon the face of the deep. And the Spirit of God moved upon the face of the waters. Genesis I, 1-2