Examples of crashes we observed:

/vendor/rails/actionpack/lib/action_controller/routing/route.rb:205):2:
   [BUG] Segmentation fault
/opt/ruby-enterprise-1.8.7-2011.03/lib/ruby/1.8/yaml.rb:133:
   [BUG] Segmentation fault
/vendor/rails/activesupport/lib/active_support/vendor/i18n-0.3.7/i18n/
   backend/base.rb:257: [BUG] Segmentation fault
/vendor/rails/actionpack/lib/action_view/template.rb:226: [BUG] Segmentation fault
/opt/ruby-enterprise-1.8.7-2011.03/lib/ruby/gems/1.8/gems/pauldix-sax-machine-0.0.14/
   lib/sax-machine/sax_document.rb:30: [BUG] Segmentation fault
/vendor/rails/activesupport/lib/active_support/memoizable.rb:32: [BUG] Segmentation fault

After banging my head against the wall for a week I found a solution (even two) and what might seem to be a likely reason for the segfaults. Two “suspects” – lack of available memory and incorrect version of libxml were ruled out. What seems to be the actual reason is the total size of the localisation files in config/locales loaded upon startup:

$ du -shb config/locales
1665858    config/locales

$ cd config/locales
$ find . -type f | wc -l
805

So ~1.6Mb in 805 files give occasional segfaults. Adding 200Kb of localisation files more started giving 100% segfaults on script/console startup.

Now I’ve found two workarounds for this problem.

1. Recompile REE with –no-tcmalloc flag

./ruby-enterprise-1.8.7-2011.03/installer --no-tcmalloc

Note that on 64-bit platforms tcmalloc is disabled by default.

2. Enable large pages feature in tcmalloc

This is described in tcmalloc documentation as: “Internally, tcmalloc divides its memory into “pages.”  The default page size is chosen to minimize memory use by reducing fragmentation. The cost is that keeping track of these pages can cost tcmalloc time. We’ve added a new, experimental flag to tcmalloc that enables a larger page size.  In general, this will increase the memory needs of applications using tcmalloc.  However, in many cases it will speed up the applications as well, particularly if they allocate and free a lot of memory.  We’ve seen average speedups of 3-5% on Google applications.”

There’s a warning – “this feature is still very experimental”, but it works to solve the problem with too many localisation files.

To compile REE with tcmalloc with large pages enables I just edited ruby-enterprise-1.8.7-2011.03/source/distro/google-perftools-1.7/src/common.h – replaced

#if defined(TCMALLOC_LARGE_PAGES)
static const size_t kPageShift  = 15;
static const size_t kNumClasses = 95;
static const size_t kMaxThreadCacheSize = 4 << 20;
#else
static const size_t kPageShift  = 12;
static const size_t kNumClasses = 61;
static const size_t kMaxThreadCacheSize = 2 << 20;
#endif

with

static const size_t kPageShift  = 15;
static const size_t kNumClasses = 95;
static const size_t kMaxThreadCacheSize = 4 << 20;

On production servers I opted for no tcmalloc for now – but I hope there’ll be a better way to deal with this issue soon.

Rails are providing developers with really excellent abstractions, but it’s always good to know what’s under the hood and how it all works.

There are a few things that might potentially cause bugs in your code, or waste your time (speaking from my own experience). So here goes:

1. Beware of globally keyed fragments

Let’s take example from Rails tutorial:

<% cache do %>
  All available products:
  <% Product.all.each do |p| %>
    <%= link_to p.name, product_url(p) %>
  <% end %>
<% end %>

Now if you need to deal with a multi-language site you might want to make cache fragment language dependent. What might seem a convenient solution:

<%- cache([user.locale.to_s]) do -%>

will turn into a source of very interesting problems. While calling the cache method without parameters will automatically create a controller/action specific cache key, calling it with a key will make this fragment a globally keyed fragment. Cache key in the first case is going to look like “views/localhost:3000/controller-name”, and in the other case “views/en” – this is not as unique identifier any more.

While automatic cache key naming provided by rails is very convenient, it is very easy to run into a problem with duplicate cache key names used in different places.

2. Another pitfall of automatic cache key naming is that you shall never assume that when creating a cache with global key you can later find it using e.g. telnet interface to memcache. Example – add

<%- cache('unique_cache_key') do -%>
<%- end -%>

in your view and then try to read directly from memcache:

$ telnet localhost 11211
GET unique_cache_key
END

At the same time

GET views/unique_cache_key

will work. It’s easy to make this mistake trying to check or delete cache keys directly from memcache when using Rails cache methods.

3. delete_matched is not supported by memcached (see rails/activesupport/lib/active_support/cache/mem_cache_store.rb)

In practice that means that if you’re using memcached as Rails cache engine and trying to delete or expire fragment cache using standard Rails methods and regexp – you’ll fail.

expire_fragment(/base\/xyz.*/)

will fail miserably. Ideal solution is not to use explicit cache expiration, but rather create cache keys in such a way that doesn’t require expiration. Alternatively it’s possible to use extensions implementing delete_matched for memcached (haven’t tried it myself though).

Tip: one very useful tool for checking memcached is peep by Evan Weaver – allows you to peek into the cache and see what’s really cached and how it is used.

I’d like to say big thanks to the organisers of the conference (especially CJ @cjkihlbom) – everything went really smooth, even though there’s been 150 people attending this year compared to 90 last year.
Some points that I’d really like to highlight are:

• a lot of time to meet people and discuss: 30 minutes talks followed by 30 minutes breaks, no q&a – those who had questions had an opportunity to talk to the speakers during the breaks
• venue was great (of course, the boat – there was enough space for everyone to move around, but at the same time it was compact enough not to get lost also everyone had an opportunity to have lunch and dinner together
• “job board” a huge white board where anyone can post information about open positions in their companies – it got filled withing firts few hours – job market is really hot
• lightning talks that any participant can give – 5 minute talks in the end of the day – it was really great
• real coffee espresso, latte, cappuccino, americano – you name it – professional baristas were at your service
• 5K Nordic Ruby run organised on the second day’s morning

Day 0

The conference started with a party on Göthenborg ship. It was a great way to get to know the speakers and participants in an informal setting.

Day 1

“GitHub Flavored Ruby” was by Tom Preston-Werner (@mojombo) from GitHub.

Tom had a hard task of waking up the auidence after yesterday’s pre-conference party, and he succeeded in this task. Tom explained what is a README driven development that he and some of his colleagues in GitHub are using – a golden mean between waterfall and cowboy coding.
Start a new project with writing a README file, where basic design principles and conventions will be described, and don’t forget to update it as the architecture changes.

Another interesting topic was TomDoc – code level documentation – a better alternative than RDoc/Yard, designed for hackers/humans, not for machines to read.

Modularisation was yet another subject – Tom explained how at GitHub they try to split the code into independent modules to reduce complexity of the system.
Grit is a good example of that – a module for Ruby-Git interaction was written even before the rails code for GitHub.

Other examples of modles created in GitHub (and open-sourced) are: resque, jekyll, proxymachine and chimney, albino, gollum, bart, camo, failbot, giraffe, nodeload (in node.js), ernie (in erlang), stratocaster (for event feed), ghromosome (which is apparently not used anymore, but worth mentioning just because of the fun name).

And naturally for versioning of the components Tom proposes to use Semantic versioning.

A few notes from the after-talk discussion with Tom and others:
- Github uses git powered deploys – instead of copying the new release from git and then changing symlink to current release, they use single directory and do direct git updates – rollbacks are also easy to do using git fucntionality
- it’s possible to deploy Github from Campfire by giving deploy command to a robot
- to avoid downtime – build_cache is executed on a local machine before deploy and pushed to the servers during deploy
- GitHub is still running on Rails 2.3, Tom’s estimate for migration to Rails 3 is ~2 weeks of “stop commits and migrate” (the estimate seems to be pretty consistent – I’ve been talking to several people about it)
- experience from a fairly large web-app developers: MySQL to Postgres migration took 3 weeks

“API Design Matters” was by Anthony Eden (@aeden) from DNSimple

Central points from Anthony’s presentation:
- APIs outlive their implementation (“Think about the children” when designing APIs
- Design APIs so that they are easy to extend
- 5 Cs: consistent, clear, convenient, concise and complete
- The best API is no API
- If you’re a software developer – you are and API designer
- And use semantic versioning that Tom was talking about

Reading recommendations:
- Jasmine Blanchette “The little manual of API design”
- Joshua Bloch “How to design a good API and why it matters”

“Bridging the gap – Using JavaScript in Rails to write DRY rich client applications” by Thorben Schröder (@walski), KOPFMaschine

An interesting talk about using Java Script from Ruby code and the other way around.
Implementing validations on the client side reduces amount of round-trips and speeds up user interaction, but since smart people can hack JavaScript and bypass client-side validations, also server side validations are necessary. To avoid writing validations twice use The Ruby Racer,  CommonJS and CommonJS models to DRY your code and write validations only once and use them from both Ruby and JS code. Pretty smart, huh?

“Limited Red Society” by Joseph Wilk (@josephwilk)

Slides: http://www.slideshare.net/josephwilk/the-limited-red-society-8367200

Kanban is limiting number of tasks the team has in progress at any given moment. Joseph described in his talk how to apply this methodology to testing.

It’s important to have metrics for your testing and it’s important to visualize them. How much time do you spend in “red” when your tests are failing, which modules in your code are changed most often, are they the same that usually fail tests, are there any oscillating test cases that pass then fail then pass again?

One thing to be noted – some metrics have limited lifespan – measure what you’re interested in and then throw them away.

Reading recommendations:
“Refactoring in Ruby”
“Refactoring. Ruby Edition” Kent Beck

“Must It Always Be About Sex?” by Joshua Wehner (@jaw6)

Links from the talk: http://pinboard.in/u:jaw6/t:nr2011/

Minorities and women are under-represented in our community. Black man is more likely to be hit by lightning than become a computer science professor.
75% of women engineers leave profession because they are not socially accepted in the working culture. In the beginning of computer era programming was mostly a job for women.
Do you think that your application is mobile friendly if you have iPhone optimised version? Think again – the most popular phone with a web browser is Nokia 1100 – more than 250 million phones sold to date,
and that kind of devices are the only way how most people in Africa or India access the Internet.

What do we need to do to change current situation?

Just today I came across an article on the same subject: Two 11-year-old entrepreneurs learned the hard way what it’s like to be a minority in tech during Startup Weekend

“Infinite data – finite solutions” by Randall Thomas (@daksis) from Engine Yard

Quick dive into Bayesian statistics. That is the technology that helps to filter out spam from your inbox: “Keeps spam at Bayes”

Bayes + DAG (Directed Acyclic Graph) = BBN (Bayesian Belief Network)

Probably the most scientific talk of the conference and two great demos: reconstruction of Bach’s first invention using BBN (amazing stuff) and analysing whiskey properties

Book to read: “Robust Nonparametric Statistical Methods”
Site to check: Eliezer Yudkowsky
Tool to check: Weka – analysis tool – live example how to analyze properites of whiskey.

A great collection of links on Bayesian Networks:  https://gist.github.com/1031597

“Taking Back Education” by Joe O’Brien (@objo)

Education. We are in the top 5 to 2% of the developers by just being here – attending the conference.
Why education system sucks? There’s a clear need for apprenticeship institute.

Harward Business Review research indicated that team IQ depends on diversity, not on IQ of individual members.
Adding a women to the team cnsistently improves team performance (good reference for Diversity problems talk by Joshua)

In the end of the first day there was a series of “lightning talks”.

* Anthony Eden (@aeden) proposed to use DNS protocol for resolving dependencies. Definitely idea worth studying.
* Twitter will be native on all iOS devices – think about it, and what do you want to do with it.
* Stephen Sykes – obfuscated code for fun and ruby quiz – really, really fun – see the slides here: http://www.stephensykes.com/obfu_lightening.pdf
* Emily Bach (backconsulting.com) shared her experiences in teaching TDD
* Theo from Burt talked about his experiences and lessons learned from scaling:
- build two of everything from the start – will help with horizontal scaling later
- fail fast (Göthenburg ship made it to China and back to Sweden and sank a hundred meters from the home harbour, Vaasa is a lot better example – it sank right after it was deployed
- queues
* Tom from GitHub talked about Hubot – a Campfire robot they wrote in node.js and keep developing just for fun – absolutely amazing stuff, every team should do that
* David from Streamio (one of the sponsors of Nordic Ruby) did a “shameless self-promotion” of his company
* Alex who has been doing a great job filming the conference talked about making a movie – what it takes
* Antony Sastre – talked about photography – really inspiring, Antony was a web developer, then left the field and was doing photography for living for two years, now came back to web development
* Nikolai (@nikolayb) Is this a bad idea? Deploying always to production on a site with millions of page views per day, one branch always – test code on a live service? Somehow it works…
* Paul Wilson (@paulanthonywils) talked about Agile Delivery Network – doing better government IT, and here’s a bunch of links from his talk: https://gist.github.com/1035392
* Paul Campbell (@paulk) talked about whenever.js and made it public on GitHub in the end of his talk http://whatever-js.heroku.com/#1, https://github.com/paulca/whenever.js

Day one ended with a BBQ dinner at the River Cafe.

Day 2

Paul Campbell who ended Day 1 with his lightning talk also started Day 2 with a autobiographical talk “In search of me fein” (myself in Irish).

7 days in my life, zombie movies and finding inspiration
Technologist, developers, live in a bubble – we have no problems finding jobs, we can travel, we can choose where we live and work. It’s not like that outsie of our industry.

“Actors on stage” by Elise Huard (@elise_huard)

Slides: http://www.slideshare.net/ehuard/ruby-hollywood-nordic

We have multiple cores in our processors now – how do we benefit from it?
MRI is the only Ruby where parallel threads are executed time-scliced in one real thread.

Cellucloid – a concurrent object framework for Ruby.

Languages that implement actors: Erlang, Scala (Actors are in standard library), Closure (Actors called Agents)

Mats hates threads
Should there still be a better cuncurrency primitives in MRI? shall we create a branch of Ruby to implement it?

“Beyond Ruby” by Jakob Mattson from Burt (@jakobmattsson)

Slides: http://jakobmattsson.tumblr.com/post/6664704401/beyond-ruby

Bold statement: Ruby is not a dynamic language. Not everyting in Ruby is an object, despite what many books claim.
E.g. dot (.) or “or” (||) operators cannot be redefined. Or operator doesn’t evaluate second argument if the first one is true.
Ruby is not as moldable as it could be.
It would be cool to implement calling by name – passing expression along with the context to the callee and letting it decide whether to evaluate it or not.
Io language is probably 80% there. A new language needs to be invented. And coding it would not be that difficult – because if it is
truly dynamic, then most of it can be implemented in itself.

“Fewer constraints” by Ryan Smith (@ryandotsmith) from Heroku

Slides: http://dl.dropbox.com/u/1579953/concurrency_deck_with_notes.pdf

Continuing the theme that Elise started this morning. How to improve performance of your application by parallelizing.
Amdahl’s law – adding processors gives only marginal speed-up. “Even though we have 10 workers
available to us, we are only seeing a speedup factor of 5.2, with 20 workers it get only to 6.9″.

Real life example – improving queue performance. Using Fuzzy FIFO instead of traditional queues FIFO implementation.
Example with using spinlock in PostgreSQL to implement it. See queue_classic on github.

“Mountain Dew and My Trail of Tears” by Aaron Patterson (@tenderlove) from AT&T Interactive

Aaron discussed in depth how to work with legacy code.

- use “ruby -w” to see the warnings in your code, warnings can be used by developers to inform about upcoming deprecations
- Liskov substitution principle (LSP)
- Single responsibility principple
- Method extraction
- Object#extend
- Code seams
- sleep sort: http://dis.4chan.org/read/prog/1295544154

Recommended reading: Working effectibely with legacy code

“Legacy” by Chad Fowler (@chadfowler)

Chad started with playing a recording of Beethoven – this is legacy. Miro is legacy. Gaudi is legacy too, and the only reason to visit Barcelona.

Legacy is good.

Nobody will remember your work when you die. There are still systems in use written 25 years ago – why don’t we write that kind of code anymore?
Average lifespan of a business software is 5 years (figure is probably made up)

Recommended reading:

Michael Feathers “Your Code.. it’s Alive..”
Richard P. Gabriel “Design Beyond Human Abilities”

What kind of software lasts – either small (cell-size) or systems consisting of cell-sized software (like UNIX).

Force heterogenity – languages, OSes, frameworks – will change over time. If it’s hard to force heterogenity – do it all the time.

“Must.Try.Harder” by Keavy McMinn (@keavy)

An absolutely fascinating and inspirational talk from a woman who decided to train for an IronMan from pretty much zero.
She did it. A rare inspirational example of how to go outside your comfort zone and achieve a goal that looked impossible.

Other conference notes:

Fredrik Rubensson: http://www.highlevelbits.com/2011/06/nordic-ruby.html
Andreas Ronge / Jayway:  http://blog.jayway.com/2011/06/19/notes-and-thoughts-from-a-great-conference/

GD Support         enabled
GD Version         bundled (2.0.34 compatible)
GIF Read Support   enabled
GIF Create Support enabled
PNG Support        enabled
WBMP Support       enabled
XBM Support        enabled

Making sure that JPEG libraries are installed

sudo aptitude install libjpeg libjpeg-dev

and reconfiguring PHP with –with-jpeg-dir flag (the rest of the compilation process remains the same as here)

./configure --enable-fastcgi --enable-fpm --with-mcrypt --with-zlib
--enable-mbstring --with-openssl --with-mysql --with-mysql-sock
--with-gd --without-sqlite --disable-pdo --with-jpeg-dir=/usr/lib

and then restarting nginx

sudo /etc/init.d/nginx restart

helped to solve the problem.

Of course there’s always an option to use github. And if you’re working on an open source project, or want to concentrate on coding and not system administration, github is a lot better option than setting up and managing your own git server (I’ve been so impressed by @defunkt‘s presentation on #frozenrails, that started recommending github to everyone But if you already pay for a virtual machine somewhere (like Linode), then setting up your own git server might be a viable option, especially that it is sooo easy.

The following instructions have been verified on Ubuntu 10.04 Lucid Lynx, but should work at least on Ubuntu 9.04 and 9.10 just as well.

Let’s start with installing gitosis itself. Issue the following command on the server:

sudo apt-get install gitosis

This will create a new user ‘gitosis’ and prepare a structure for repositories in /srv/gitosis. Now let’s initialize a gitosis-admin repo – it is used for managing repositories and access rights.

sudo -H -u gitosis gitosis-init < ~/tmp/my_public.key

You need to have a public key for accessing it. If you don’t have one yet, you can use

ssh-keygen -t rsa

command on your local machine to generate public/private key pair. Copy public key to the server before initializing gitosis-admin repository.

Now with gitosis-admin repo initialized on the server – let’s clone it to the local computer.

git clone gitosis@myserver.com:gitosis-admin.git

If you see an error like:

Permission denied (publickey).
fatal: The remote end hung up unexpectedly

That is most likely because you restricted access to you server via ssh to only certain users, and gitosis is not one of them. Edit /etc/ssh/sshd_config, find AllowUsers line and add gitosis to the list.

Now that you have successfully cloned gitosis-admin repo to your local computer, you can add  new users and new repositories.

To add new repository, edit gitosis.conf and add lines like:

[group myrepo]
writable = myrepo
members = user@computer

After that commit and push the changes to gitosis-admin project:

git commit -a -m "Added myrepo repository"

Now you can clone this new repository to your local machine (note .git added to the name of the repository):

git clone gitosis@mygitserver.com:myrepo.git

To allow new user to access your repository, get this user’s public key, copy it to gitosis-admin/keydir as newuser@computer.pub, then edit gitosis.conf and add newuser@computer (without .pub) to the list of members:

[group myrepo]
writable = myrepo
members = user@computer newuser@computer

Now add new files and commit and push changes to git server (make sure you really add all files and don’t forget to push – these are quite common mistakes when adding new users).

git add .
git commit -m "Added user newuser"
git push

With a freshly cloned empty repository you’ll need to add you first files, do a commit and push origin master:

vim README.txt
git commit -a -m "Added readme"
git push origin master

Now you can git pull and git push as much as you like.

Committed some changes, didn’t push them, and need to amend the commit:

git commit --amend -a -m "Commit message"

Committed some changes, pushed them, and need to amend the commit, do the revert operation instead, since someone might’ve already used your changes.

Committed some changes, didn’t push them, and need to undo the commit:

git reset --hard HEAD^

This will just toss away the last commit completely.

Commited some changes, pushed them, and need to undo the commit:

git revert HEAD

This will automatically create a new commit, reverting the changes from the previous

Our team is distributed to the extent that sometimes all four of us are located in different places during our meetings – but time zones difference is in most of the cases withing 1-2 hours. Up until recently some of us didn’t have a permanent office and had to participate in daily scrum meetings, and sprint planning/reviews from public open spaces.

We tired to use Skype, but flakiness of wireless in some locations and sometimes just insufficient bandwith quickly rendered it as a non-viable option. Even with commercial telco systems it is quite often that people spend first 10 minutes of the meeting on making sure that everyone is on the line and can hear the other party – can be really frustrating, especially when the meeting is supposed to last for 15 minutes.

In the end we started using Google Talk for daily scrum meetings and for sprint planning / reviews as well. Works really good – keeps reports short and to the point. No time is lost on setting up voice connections and exchanging “can you hear me – you are breaking up”.

I believe two major factors that contribute to success use of chat are that:
1. the team is small and
2. everyone is in equal position

When a part of the team is located in the same physical space and there is just one or two people on the other side of the telephone – most important discussions tend to take place face-2-face, and remote members of the team are excluded. Using chat ensures that those team members who happen to be in the same office are talking to each other the same way as if they were remote.

It would be interesting to hear experiences from other teams that are running scrum with chat as primary means of communication.

I previously wrote on this subject a year ago, when Android was announced, and three years ago, when I was really disappointed by a pretty much dead S60 applications market.

This time it started with a great presentation by Teemu Kurppa (a mastermind behind mobile Jaiku) at MobileDevCamp Helsinki – “Platform = Stage. How to choose a mobile development platform?“. It is a must see for every mobile developer.

Teemu compares the number of “educated users” for S60, iPhone and J2ME enabled phones, and illustrates that they are cardinally different from absolute numbers of sold devices/potential customers advertised by companies behind those technologies.

Even if iPhone/iPod Touch has the smallest number of sold devices, it has 3x times the number of “educated users” than its nearest competitor (S60), and “educated users” are the real potential customers with the money and intention to buy.

Teemu also compares the distribution channels – Apple App Store vs. S60 Download and user experience when downloading and installing applications.

By far iPhone/iPod Touch coupled with App Store is the absolute winner as a development platform, if you want to maximize your target audience and profits. But there will be two major disruptions this year, trigerring a ripple effect in mobile development pond – Nokia’s global Ovi Store launch and Google’s Android Market launch in Europe.

However as Ewan MacLeod reports Nokia’s Ovi Store got more than a cold reception from mobile developers in the Bay Area, who were unimpressed by “400 million Ovi compatible handsets by Dec 2010″ proposition.

Mike Rowehl in his rant “Please Don’t Mistake My Apathy For A Lack of Understanding” explains the reasons behind his choice of iPhone as a preferred development platform. Addressing Nokia, RIM and Microsoft, Mike wrote “Once things change, once you get your stores developed, released, and proven as a good commercial channels to end users – then we can talk again. Until then we’re all just going to keep laughing at you and developing for iPhone”. He got a reassuring comment from Lee Williams, executive director of Symbian Foundation, which I do hope is the first sign that at least Nokia starts caring about developer’s needs.

iPhone was the buzzword of 2008, but I am still closely following Google’s Android development. I was really impressed by a successful example of one of my friends, who concepted, developed and published mobile application for Android in about a month of evening coding – without any prior mobile development experience, let alone Android experience. Android documentation and community, encouraged and supported by Google, allowed this to happen.

Apple’s App Store success (1 bln downloads quoted) indicates that there is a lot of moeny in 3rd party application market, and there will be a fierce competition between Google, Apple and Nokia for developers attention. The one that succeeds will have to forget about having the largest number of devices on the market, and concentrate on three really important things:

• providing a good distribution channel with a fair revenue split
• educating users about possibility to install mobile applications
• creating a decent development platform, with a good toolset, comprehensive documentation and active community

With Apple being now a clear leader, and Android a strong challenger with large potential, it is going to be an uphill battle for Nokia to regain trust of mobile developers and deliver on promises of Symbian Foundation and Ovi Store.

Jyri Engeström wrote some time ago about the case for object-centered sociality: “‘social networking’ makes little sense if we leave out the objects that mediate the ties between people”. I could not agree with him more. The glue of each community is something that unites them – common interest, social object. When you join new social network, you typically start by building your social graph – re-establishing links to the real people you know, checking if they have already registered, inviting those whom you would like to see in the new environment. But there must be something beyond the initial phase of building the social graph. And this is the problem that haunts giants like Facebook and MySpace. You cannot possibly have common interest with everyone, and you don’t want to share the same things with everyone.

While Facebook is still growing strongly, it’s morphing into some sort of a generic social utility. Thanks to the Platform API there are all kinds of applications available on Facebook, some of them creating social objects (like Circle of Moms or Cities I’ve Visited), but it feels like true passions of people are quite rare in generic networks. When it comes to your most important hobbies, you might want to share your thoughts and data with other likeminded people and not necessarily with all aquaintances on Facebook. This is one of the reasons why specialized social networks are thriving. Dogster.com and catster.com are two perfect examples of such networks with very strong social objects. Mark Andreesen‘s creation Ning – a place where everyone can build own social network – already has hundreds of thousands of networks.

As Stephen Johnston said “Plenty of improvement ideas are in the pipeline, and the key one for me will be to build up a sense of community of Nokia early adopters and use them as lead innovators to help us know what we should be working on next.”

From my point of view the most important change would be that of the spirit of development in Nokia, so that beta culture really grows roots, and more interesting and innovative projects have a chance to emerge from our own developers and see the light of day.

William L.McKnight, 3M chairman of the board, formulated management principles already in 1948 where he encouraged 3M management to “delegate responsibility and encourage men and women to exercise their initiative.”

This is one principle I see us in Nokia adopting this very moment.