ersoft

Also, there is Opbeat (https://opbeat.com), which also does release/deploy tracking (you can see which errors come from/after which release).

You can test and take a look in web developer console.

Payment seems to be done using Stripe Javascript SDK, which makes all the connections using HTTPS.

You can use skydns[1] to implement service discovery based on DNS. It has etcd as a backend and creating/updating a DNS entry is done by creating an entry in etcd with a TTL. Then, you can use DNS the same way you are already doing without service discovery.

[1] https://github.com/skynetservices/skydns

If you are asking about developing in the cloud, there are two options:

https://www.nitrous.io/ or https://koding.com/

On Koding it requires an invite, but I have a couple of invites.

887 git

702 ls

623 cd

618 gs

349 mate

340 ga

313 bundle

251 rake

221 ssh

197 gd

164 cat

159 grep

153 rm

148 rails

131 cap

127 gem

125 exit

122 powder

109 vagrant

98 vim

67 rbenv

66 make

65 zeus

65 ping

63 cp

61 gco

58 mv

55 sudo

51 ps

47 mkdir

43 kill

37 grm

36 echo

33 ruby

30 foreman

29 gdb

26 brew

Maybe they are doing some kind of A/B testing, for going on an only possitive feedback.

You're right, I can be out of date, I didn't code in Django in the past year, only in Ruby on Rails, but still I have the impression that things go much slower on Django release circle compared to Rails

I'm glad to hear they are fixing the annoying bug in 1.5.

About libraries, Python follows the idea that there should be only one way to do something, ruby follows the idea that there should be more ways to do something, this is why there are a lot of alternatives, for example:

Testing: rails built in, rspec, minitest, test-unit, bacon, etc JSON Generation for views: jbuilder, rabl Memcache: memcached, dalli

And many other gems have more than one alternative, which I think it's nice.

As a both Django and Rails developer I suggest you to choose Ruby on Rails.

Rails pluses:

- Has a nice asset pipeline (automatic conversion of CoffeeScript, Sass, Haml, Jbuilder, etc) and concatenation + mignifying.

- Really configurable database migration with a nice DSL. (Django has South which auto generates migration files, but It isn't just as easy to change them)

- Rake tasks (Django also has management commands, but It's easier in using rake)

- multiple environments (development, production, testing), being able to store different configurations (Django does not have this, you can achieve this using some hacks)

- Railscasts.com (great screencasts by Ryan Bates)

- Better release circle, as long as I know in Django didn't appear many features since 1.0 (mostly bug fixes and Python 2.x deprecation warnings)

- more OOP than Django, it really follows MVC pattern, Django is a MVT (Model View Template framework)

- More libraries and more complex and configurable than django libraries. Most Django libraries handling authentication stick on default User class, so it's difficult to subclass it if you require custom fields.

- Model hooks and scopes (I know django has model hooks but they are built using Django signals, not using nice DSL as in Rails)

- Concerns inclusions which guides you to a clean coding style.

- Controller before_filters (very useful when you want to run a filter before multiple actions, eg: check if user is logged in), I know it can also be done using Django middlewares.

Django pluses:

- Django admin (Rails also has a few plugins which try to implement this, but django's is built in and also well documented in their official docs)

- Django built in authentication system (Rails comes with devise library and other alternatives, which is great but not built in)

- Easier to learn (Django follows Python's Zen, "Explicit is better than implicit.", all classes or methods you use must be imported, Rails pollutes global namespace with all classes and namespaces imported from libraries when Gemfile is parsed). It is easier to learn which module each class comes from and it helps you a lot at debugging if you are a begginer.

- Django middleware (you)

- Form based validation (each model can be validated using form class, another minus for Rails is that there was some security vulnerabilities targeting mass assignment on Models)