For your info, I submitted two talk proposals about web2py at Pycon in
the hope that one will be accepted (I do not really want to give two
talks). Here are the two descriptions:
PROPOSAL 1: web2py, why you love it or hate it
When it comes to web framework there is a well defined minimal set of
features we expect from them: the ability to handle cookies, sessions,
database connections, render data in HTML and other protocols, notify
error messages, redirect a visitor to another page, provide
authentication, authorization and web services, help the developer
with debugging, testing, packaging and deployment of applications.
While separately each of these tasks is trivial, together they may
give rise to a complex workflow and potential security issues or
performance issues.
Some frameworks leave a lot of choice to the developers on how to
perform those tasks. Web2py takes a different approach and it
constraints the developers more in an attempt to simplify web
development, increase security and promote good practice. Yet some of
the decision may seem odd to the average Python programmer and need to
be explained, considering that web2py is becoming a popular framework
with 50 contributors, 100 distinct downloads per day, 1400 registered
users, 30000 google group messages.
The general philosophy of web2py is to abandon “explicit is better
then implicit” every time it conflicts with “do not repeat yourself”.
The practical design decisions, consequence of this philosophy, are
that:
* Application code does not import the modules of the framework
but the framework executes the application code in a well defined
environment.
* Although you can use imports as you would normally do in every
python program, many of the web2py keywords and environment variables
are already defined in the context in which code is executed.
* Everything has a default (every model has a default interface,
every action has a default view, every parameter has a default
setting)
* Although web2py is modular, it is more than the sum of its part.
This means the various modules are much more intercorrelated than they
are in other web frameworks.
Some of those decision were the result of a compromise and have side
affects.
In our talk we will provide a brief introduction to web2py, discuss
its internal architecture, the file hierarchy and the pros and cons of
our design decisions.
PROPOSAL 2: Opening Databases to the Semantic Web
Authors
Massimo Di Pierro and Chris Baron
About the Semantic Web
The Semantic Web is an attempt to describe the meaning of the
information posted on the web in a format that is understandable to
both people and machines. An embodiment of the semantic web is the
idea of linked data proposed by Sir Tim Berners Lee, credited for the
invention of the web. The idea of linked data is that of exposing data
as well as relations between data. Atomic data consists of URL address
where atomic information resides. The atomic data is labeled using a
Web Ontology Language. Relations between the data is described using a
an XML based schema called Resource Description Framework RDF.
Motivation for this Talk
The amount of information posted online is rapidly growing beyond the
point where humans can comprehend it and more and more we will need
automated agents to be able to find, collect, and summarize
information for us. Most of this information already exists in
structured form, in relational databases. There are many RDF parsers/
serializers for Python but we moved one step further: We created a
mechanism for tagging database tables, fields and relations so that
information in any database can be exposed automatically in RDF,
without coding.
Our contribution
web2py is a web framework that includes a Database Abstraction Layer.
Normally its main purpose is to generate SQL code dynamically and
transparently for multiple database back ends. web2py also includes
the ability to serialize the output values of the a controller action
into multiple formats (html, json, xml, etc.).
In this talk we show how it is possible to use the web2py DAL to
attach metadata to the database information using the Web Ontology
Language and how this data can be used to serialize the result of
select into RDF, on demand, and expose this functionality as a
service. Using this technology any web2py application can became a
node of the semantic web. Not all tables and records will be exposed
in RDF, only those appropriately tagged and those the visitor is
allowed to access based on web2py’s Role Based Access Control
mechanism.
Our tagging system is powerful enough to translate one-to-many and
many-to-many database relations into RDF expressions.
In principle the same ideas exposed here can be used with other web
frameworks and other Database Abstraction Layers and/or Object
Relational Mappers.Timeline:
Timeline
* Introduction to the semantic web: 5 minutes
* How to create and expose a database model in web2py: 5 minutes
* Markup a model using OWL: 10 minutes
* Build a complete working test case: 10 minutes
References
[1] http://www.ted.com/talks/tim_berners_lee_on_the_next_web.html
[2] http://en.wikipedia.org/wiki/Semantic_Web
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"web2py-users" group.
To post to this group, send email to web2py@googlegroups.com
To unsubscribe from this group, send email to
web2py+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/web2py?hl=en
-~----------~----~----~----~------~----~------~--~---
