When comparing Django vs Slim, the Slant community recommends Django for most people. In the question“What are the best web frameworks to create a web REST API?” Django is ranked 6th while Slim is ranked 12th. The most important reason people chose Django is:
Django's philosophy of batteries included means that experienced developers won't have to plan too much ahead on what kind of application infrastructure they need and instead just start developing web applications quickly.
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Developing a simple prototype can be very fast
Django's philosophy of batteries included means that experienced developers won't have to plan too much ahead on what kind of application infrastructure they need and instead just start developing web applications quickly.
Pro ORM support out of the box
Django supports Object-Relational Mapping. With models defined as Python classes which are actually subclasses of Django's django.db.models.Model
.
Each attribute of the model is then represented as a database field. Queries are lazily executed and Django gives developers an automatically-generated database-access API.
Pro Top notch documentation and help from community
The official Django documentation is probably some of the best around. Well written, thorough and they explain every little detail of the framework. Django is also a very popular tool, with an extensive community and a lot of experienced developers that have been using it for years. This means that there are a lot of guides and tutorials out there for new and experienced developers alike.
Pro Highly customizable
Django is in itself a highly customizable web framework. The database, template framework and ORM can all be swapped out.
Pro Has an admin panel out of the box
Django comes with a highly customizable admin panel and authentication out of the box. This makes the development and production of a simple CMS extremely easy.
Pro Mature software with many plugins developed over the years
Django was first released in 2005, it has had a lot of time to mature and become better with each release. It also has by far the largest community out of all python frameworks who have continuously over the years built and maintained many powerful plugins.
Pro Clear and defined MVC organization
Django follows some pretty well established MVC patterns. With everything in place and where requests follow a clear path through urlresolvers, middleware, view and context processors.
Pro Simple database management
Just a few lines of code can instruct Django to create all the tables and fields required in your database automatically. Schemas are managed with "migrations", that are also created automatically, and can be rolled out from your development box and implemented on production systems with just a single command.
This performs any database changes required, from table creation, indexes, renaming fields, and pre-populating initial data. Each migration builds on the previous migrations, so you can trace the evolution of your data and even recreate the layout of your database at any point in the lifecycle of your application.
Pro Well organized and thorough documentation
Slim's documentation is well organized and detailed, every concept is thoroughly explained and it is very helpful for both advanced users and beginners.
Pro A good starting point
Slim is minimal and that is a good thing if you want to start from there. It can be easily extended and even supports popular packages that are used in Laravel (like Illuminate\Database (eloquent)) for example.
Pro REST based
REST fans will love the REST based architecture.
Pro Supports tie-ins for Rack-like middleware
Rack is an interface used in Ruby frameworks used to group and order modules, which most of the time are Ruby classes, and specify between them.
Slim uses a simple concept for it's middleware. By wrapping HTTP requests and responses it unifies the middleware into a single method call.
Pro Useful classes
Contains classes for managing requests, responses, cookies, logging, views, HTTP caching, and more.
Pro Flexible
Slim doesn't demand that you stick to a fixed folder structure. As long as you load Slim the right way you can do anything from there the way you like it.
Pro Extremely lightweight
Paired with swoole it's a micro service powerhouse.
Pro Open source
The Slim Framework is open source and is released under the MIT public license
Pro Extremely customizable
You can add any dependency, package or class that you want to use as a contained dependency.
Pro Supports Php 5.3 and PHP 7
Pro Makes it easy to understand the way some abstract functions and classes are built
In Django most things are abstracted, you just call some function or class without knowing how they were built, but with Slim, you end up understanding the way some abstract functions and classes are built.
Pro Hooks for executing code at different points in its life-cycle
Slim supports code hooks for executing functions at different points in time during the application's lifecycle.
Cons
Con Can feel bloated for small projects
Django's sheer scale and functionality can feel clunky and bloated for small applications. It has too many bells and whistles which can get in the way when developing a small scale application.
Con The documentation does not cover real-world scenarios
It is a larger documentation indeed, however is not deep and covers non real problems or even don't show any examples. You'll be better with Google or Stackoverflow
Con Routing requires some knowledge of regular expressions
Given a GET request for /topics/426/viewpoints/1/sections/create
, how does Django decide which bit of Python code is invoked to handle it?
It compares the request path to your giant pile of regular expressions.
And then if there's some other regular expression starts matching /top
and all your requests for /topics/
start going there, good luck figuring out why. You won't be informed of any conflict until you notice you seem to be getting the wrong pages back.
The structure of URL paths is almost universally hierarchal. There is no call to have anything as ridiculously flexible (and notoriously hard-to-read) as regular expressions to organize request routing.
Con Template errors fail silently by default
If you make a typo in a template variable, or change a view so that variable is no longer passed to the template, you won't get an error message pointing out that something has gone wrong. That reference will just be treated as if it is an empty string instead.
There is a way to configure this, but since so many templates have been written assuming this behavior, nobody ever enables template errors because it would break so much of the existing support tools (e.g. the built-in admin interface).
Con Very little consistency among different versions
There have been quite some changes that break the compatibility between Slim 2 and Slim 3. Even if you learned how to work with the Slim 2, you will find that Slim 3 requires re-training.
Con Dependency injection is too weak
It is not really dependency injection, but just a configurable container.
Con Needs strong bases to create dependencies
The dependency container schema of Slim is one of the biggest PROS and CONS of the framework. It is true that this schema brings so much flexibility to add anything, but another thing that is true is that you need to have strong bases of patterns, and an extensive knowledge of your libraries to convert it into a Slim dependency.
Con Too minimal
While it's true that Slim is a microframework, it's still too minimal. When used for throwaway projects or simple prototypes, it's perfect. But in the long run, it becomes less and less useful and you end up in implementing a full custom framework in trying to tackle all the missing features.