To solve this problem all you need to do is open application.conf ande set play.pool value to 2 or higher. Default is one and server can’t responde to a request until the first one is finished so confirmation fails.

One common task that you probably want to learn how to do is spliting a string into an array (like explode function in PHP). You can do this by calling “split” method. By default it will split a string on whitespace, but you can pass it a delimiter. Delimiter can be a string or regular expression.

1
2
3
4
5
6
7

animals = 'dog wolf cat lynx tiger'
animals.split # => ["dog", "wolf", "cat", "lynx", "tiger"] 
 
"6534-234-23-45".split "-" # => ["6534", "234", "23", "45"] 
 
calc = "45 + 36 - 25 * 14"
calc.split /\s*[-+*]\s*/ # => ["45", "36", "25", "14"]

Substitute part of a string

We can do this in two ways. First one is by calling “gsub” method upon a string, and this is quite a usual way. Second one may seem strange at first but it’s quite nice actually. You can substitute a substring like this: my_string["string_to_substitute"] = “replacement_string”. Take a look at the example.

1
2
3
4
5
6
7

my_statement = "I like dogs"
 
print my_statement.gsub "dogs","cats" #  => "I like cats" 
print my_statement # => "I like dogs"
 
my_statement["dogs"] = "cats" #  => "I like cats" 
print my_statement # => "I like cats"

Notice that in first case we didn’t make changes upon a string, “gsub” method just returned a new version of a string and left “my_statment” as it is. If you want to make changes upon a string you could use “gsub!” method.
This is a ruby convention, so every time you see a method that ends with “!” you should be careful because it will change the object it is called upon.

String concatenation

You can “glue” one string on another simply with a + or a << operator.
If you want to insert a string in a string, simply use “insert” method, it takes 2 parameters, first is position where to insert the string and second is the string that you want to insert.

1
2
3
4

part1 = "walk"
part2 = "dog"
result = part1 + part2 # => walkdog
result.insert 4, " a " # => walk a dog

Cut off last character

You can cut out last character of your string using “chop” method. “chop” also comes with “chop!” version that will make a change on a string, and not just return a new version of a string.

1
2
3
4
5

string = "Animals"
puts string.chop # => "Animal"
puts string # => "Animals"
string.chop! 
puts string # => "Animal"

CHANGEING CaSE of A STRing

Ruby supports easy case changing for entire strings. It includes changing all characters to lower case using the “downcase” method and changing string to all caps with “upcase” method.

1
2

"A normal string".downcase # => "a normal string" 
"A normal string".upcase # => "A NORMAL STRING"

But ruby can do even cooler stuff. Like capitalizing strings, and swapping case of all characters. When capitalizing strings only first character will be in upper case, it won’t do capitalization for each sentence.

1
2
3

"this is NICE!".capitalize # => "This is nice!" 
"this is NICE! but could be nicer.".capitalize # => "This is nice! but could be nicer." 
"this is NICE!".swapcase # => "THIS IS nice!"

If you just need to set a simple many-to-many relationship the easiest way to do this is with has_and_belongs_to_many. Here is how your models should look like.

1
2
3
4
5
6
7

class Post < ActiveRecord::Base
  has_and_belongs_to_many :tags
end
 
class Tag < ActiveRecord::Base
  has_and_belongs_to_many :posts
end

This association is supported by an additional database table that will store post_id and tag_id for each relationship. This table should be called posts_tags and it will not be created for you, so you will have to create your own migration.

Notice that model names inside join table are in lexical order, so the table will be called posts_tags and not tags_posts (because ‘p’ comes before ‘t’). You can also specify a different name for that table using the :join_table option.

So generate a new migration (you could do this with “rails generate migration create_post_tag_join_table” and enter following code. Then run “rake db:migrate” to make the changes inside your database.

You should use “:id=>false” option in your migration, because join table does not need additional primary key, also notice that this table won’t have “created_at” and “updated_at” timestamps.

1
2
3
4
5
6
7
8
9
10
11
12

classCreatePostTagJoinTable < ActiveRecord::Migration
  defself.up
    create_table :posts_tags, :id => false do |t|
      t.integer :post_id
      t.integer :tag_id
    end
  end
 
  defself.down
    drop_table:posts_tags
  end
end

Accessing related posts and tags is now easy. You can get an array of related tags by calling ‘tags’ method.

1
2

@post = Post.find(1)
@tags = @post.tags

Simplest way to add existing objects is using the << operator. For example:

1
2

@tag = Tag.find(3)
@tag.posts << post

Or if you want to create brand new object you can use a create method. This method returns created object. The object will be saved in databases, and link through join table will be created.

1

@tag.posts.create( {:title => 'New title', :content => 'Hello world' })

Collections also come with delete method. It will remove objects relationship, but will not destroy the object.

1

@post.tags.delete( @tag )

More info can be found inside rails documentation.

Has many through

In case we need to store additional information inside join table, we will need to use a more complicated version of many-to-many relationship. Lets say that we have two models Student and Test. Each student has taken many tests and each test was taken by many students, but each time a student took a test he got a grade. This is where has_many :through relationship comes in.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

classStudent < ActiveRecord::Base
  has_many :grades
  has_many :tests, :through => :grades
end
 
class Grade < ActiveRecord::Base
  belongs_to :student
  belongs_to :test
end
 
classTest < ActiveRecord::Base
  has_many :grades
  has_many :students, :through => :grades
end

Notice that beside setting the has_many :tests relationship, in order to use :through option you need to notify model that it has grades. In other words, you cant ‘go through’ models that you don’t have. Notice that in this case Grade is a normal model, and it must include ID field to work properly. However timestamps may be excluded if you don’t plan to use them.

This relationships behave similar to has_and_belongs_to_many relationship. More info can be found inside rails documentation.

All it does is confirm all subscription requests, and when it recieves data it prints it on screen. It uses Sinatra for handling http requests. It’s not much but maybe someone will find it useful.

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

require 'rubygems'
require 'sinatra'
 
#accepting all requests
get '/' do
 
	puts "response: '"+ params['hub.challenge'] + "'"
 
	content_type 'text/plain', :charset => 'utf-8'
	params['hub.challenge']
end
 
#accepting messages
post '/' do
	puts request.body.read
end

Use render_to decorator instead of render_to_response

:::python
@render_to("list.html")
def list_posts(request):
    posts = BlogPost.objects.all()
    return {"blog_posts": posts}

:::python
def list_posts(request):
    posts = BlogPost.objects.all()
    return render_to_response('list.html',
        {'blog_posts': posts},
        context_instance=RequestContext(request))

Load custom template tags in all templates

:::python
from django import template
template.add_to_builtins('project.app.templatetags.custom_tag_module')

Use relative paths in settings.py

:::python
import os.path
TEMPLATE_DIRS = (
    os.path.join(os.path.dirname(__file__), "templates"),
)

1. Download the openssl-dev packages! Yes... you need them: sudo yum install openssl-dev*
2. Download python2.5
3. Configure it: ./configure
4. Build it: sudo make
5. Alt-install it to make it reside near your current python install: sudo make altinstall

1. Deploy early If you want to avoid the hassle of debugging 100 things at once, deploy your project as soon as possible. By "as soon as possible" I mean right after you create it - when there are no models, views and funky url settings!
2. Commit often You are of course using source control for your project, correct? By committing often you allow for greater granularity of your project. In a way you "isolate" bugs in a particular commit. This makes finding them later on particularly easy.
3. Deploy often Same as #1 - the only way to make sure it works - is to put it out into the wild!
4. Separate production from development. You should have something like this in your settings.py file: if socket.gethostname() == 'server40.online.com': DEBUG = False else: DEBUG = True and feed all your other settings (i.e. database, media, etc) from this variable. This will make for painless deployment.
5. Use dynamic path names Don't just hardcode "C:\Documents" or "/home/user/app" in your settings. Don't be lazy. This is how we do it: import os SITE_ROOT = os.path.dirname(os.path.realpath(__file__)) and then go crazy for all the other path veriables: MEDIA_ROOT = os.path.join(SITE_ROOT, 'core/media') TEMPLATE_DIRS = ( os.path.join(SITE_ROOT, 'core/templates') ) and so on...
6. Checkout source code into production Don't just copy your code to production server with FTP or SCP! Install revision control like git or mercurial on the server, so you can hack away at the code without being afraid of messing things up, and more importantly - not loosing your important "tweaks" that you can only do in production.

Using descriptive names

Ok, this is quite obvious but I will write it anyway. You should avoid using names like “var24″ , “cpnow(x)”, “move” and similar.

x = usr.id
add(x)
show(x)

current_user_id = User.id
add_user_to_admins(x)
show_user_data(x)

Proximity

Proximity is often used in graphical design, if text is grouped together we assume it is related. Be sure to use this. Here is an example of good use of proximity.

marketing_data.compute_quarterly()
marketing_data.compute_annual()
marketing_data.print_data()
 
visitors_data.compute_quarterly()
visitors_data.compute_annual()
visitors_data.print_data()
 
sales_data.compute_quarterly()
sales_data.compute_annual()
sales_data.print_data()

Avoiding magic numbers

All literal numeric values except 0 and 1 should be avoided. Instead you could use a variable with a descriptive name. This way code will be more readable and it will be easier to change later.
Here is one trivial example.

x = 0
 
for x in range(5):
    print "\n"

x = 0
SKIP_LINES = 5
 
for x in range(SKIP_LINES):
    print "\n"

This may seem unnecessary, but imagine a lot longer code with multiple occurrences of skip lines constant. This way you will avoid editing that number more than once if your code needs to be changed, and it’s much easier to understand a piece of code if variables with descriptive names are used.

Logical expressions

You can avoid writing big, multiple lines logical expressions by using boolean variables. Be sure to give descriptive names to those variables. Here is an example of how not to do it.

if  ( post.length > minimum_post_length and post.length < maximum_post_length and
    post.number_of_comments == 0 ):
    do_something()
else: do_something_else()

Now try to read if statement again, isn’t this better? And we really didn’t use much more memory.

post_is_longer_than_minimum = post.length > minimum_post_length
post_is_shorter_than_maximum = post.length < maximum_post_length
post_has_no_comments = post.number_of_comments == 0
 
if post_is_longer_than_minimum and post_is_shorter_than_maximum and post_has_no_comments:
    do_something()
else: do_something_else()

Using multiple if branchings properly

You should always put more common (or normal) cases first, and less common cases and exceptions later. This way normal program flow will be obvious.

current_user = get_user()
 
if not current_user:
    show_error()
else:
 
    if user_is_admin:
        show_admin_interface()
 
    else:
        show_normal_interface()

You should first handle case when there was no errors when trying to get user. And assuming there are lot more normal users than admins you should check if user isn’t admin first.

current_user = get_user()
 
if CurrentUser:
 
    if not user_is_admin:
        show_normal_interface()
 
    else:
        show_admin_interface()
 
else:
    show_error()

Conclusion

So, that’s it! If you have any more ideas, or know better methods of cleaning python code feel free to comment.