[Interop-dev] Software design

Federico Capoano (spam-protected)
Sat Apr 7 13:55:48 CEST 2012

When I develop things I like to check out how other successful open
source projects managed to build things.

Let's take a look at *pinax*.

/"Pinax is an open-source platform built on the Django Web Framework. By
integrating numerous reusable Django apps and providing starter projects
and infrastructure tools, Pinax takes care of the things that many sites
have in common so you can focus on what makes your site different. Pinax
has been used for everything from social networks to conference
websites, and from intranets to online games."/

We are indeed building something like pinax but for networks.
I tried pinax and there are few things which I really like and I think
we could emulate in this project.

Pinax is basically a set of libraries and django apps, with very basic
or nonexistant html templates.
Why no html templates? Because not everyone wants the same template,
same design, same functionalities. Also the plugins you choose determine
your design so it is not possible to make an html template that is good
for every case.

But how can you see how it works if it doesn't have any html templates?
Here it comes the interesting thing, Pinax includes also a set of
example projects that are out of the core, these example projects
include also html templates, with a clean design and some basic user
interface functionalities.
You can basically copy and paste one of those example project, configure
the settings file, create the database for it with:
*python manage.py syncdb
*and then run the development server
*python manage.py runserver*
and then see it on http://localhost:8000

This is really awsome, for these reasons:

  * it gives you many functionalities out of the box
  * but it doesn't force you to use them
  * you can infact modify the example project, rename it, change the
    design, make it something completely different
  * you can also directly build something new from scratch using the
    several apps available with pinax
  * you can use additional django apps, and some interesting additional
    django apps are developed by the pinax team
  * you don't loose compatibility with the basecode. By using the
    example projects you are infact not modifying pinax's code. When a
    new version comes you just update the core of pinax hopefully it
    will still work.

I think the web interfaces will have to be standalone apps, it could
also be compared to the "example project" of pinax.
It's very possible that different communities might develop different
web interfaces. So for that reason maybe the core apps should not
contain any design or user interface functionality other than skeletons.

I'm taking a look at nodewatcher, I see some steps in that direction
have been taken.
Nodeshot instead is a monolithic piece of code, not abstract at all. It
focuses more on the user interface, so I guess it could become one of
the web interfaces available for the framework we will develop.

I also suggest to take a look at this django ecommerce framework:

They write:

    */If you don’t have the time to read/
    /Check out the most important facts/*

    /*KISS*: Keep It Simple, Stupid. The process of using a shop is
    simple - reading the code should be too./

    /*Djangonic*: The shop should run on Django, not alongside it. We
    should not reinvent ways to solve problems Django already solves for
    us, such as settings management./

    /*Modular*: Most shops have specificities. Instead of trying to
    solve all problems, let's have a clean core for which people can
    write modules./

    /*For developers*: Django-Shop will not be an "out-of-the-box" shop
    solution. People will have to write templates for it. Shipping an
    example shop is not out of the question, but it must be well
    separated from a code perspective./

    /*Community friendly*: This should be developed by and for the
    Django developers community. If we end up having no traction, that
    means there is no reason for this project to exist./

    */What it definetely should not have/*
    */The no-no’s/*

    /*Livesettings*: Sorry./

    /*Shipping and maintaining templates in the basic codebase*: This is

I quite agree with all these statements and I would be happy to improve
my way of coding in order to follow this pattern.

The point about the django community is interesting. We are developing
this for wireless communities, but what if some people in the django
community might like this project? They might offer their expertise in
helping out! I think that would be great. Also we have to consider that
we don't have many django developers in our wireless communities. Here
in Italy there are 2 guys other than me that can do stuff in django, but
they don't have much time available. Moreover they don't really like web
stuff, they prefer networking. It would be cool if we could find django
experts that would be interested in the project and would help us out.
They might not know much about wireless communities but maybe they might
need some apps in the core so they might want to help out in developing
something they need.

*Federico Capoano*
Web Designer & Web Developer
Portfolio/Blog: nemesisdesign.net <http://nemesisdesign.net>
Twitter: @nemesisdesign <http://twitter.com/nemesisdesign/>
PGP Key ID: 308BD46E
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.funkfeuer.at/pipermail/interop-dev/attachments/20120407/338e2928/attachment.html>

More information about the Interop-dev mailing list