(warning: rough notes!)

create nginx config file/apache rewrite rules BEFORE running install.php script (googled this and it was pretty straight copy-paste from what others have done for nginx). the rest of what follows is with nginx, FWIW.

nginx virtual host config. note the try_files and rewrite directives replace the apache mod rewrite rules. i think the theme location is redundant, but not 100% sure.

server {
       listen 80;
       server_name social.p2pu.org;
       root /srv/www/p2pu.org/social;
       access_log /var/log/nginx/social.p2pu.org_access.log;
       error_log /var/log/nginx/social.p2pu.org_error.log;

       index           index.php index.html;
       fastcgi_index   index.php;

       location /theme {
            root   /srv/www/p2pu.org/social;
        }

       location ~ .php {
                include /etc/nginx/fastcgi_params;
                keepalive_timeout 0;
                fastcgi_param   SCRIPT_FILENAME  $document_root$fastcgi_script_name;
                fastcgi_pass    127.0.0.1:9111;
       }

       location / {
                try_files $uri $uri/ @statusnet;
       }

       location @statusnet {
                rewrite ^(.+)$ /index.php?p=$1 last;
                break;
       }

}

for some reason statusnet still creates the config variable

$config['site']['path'] = "install.php"

which is obviously wrong. this results in the first user getting a profile url (stored in the db!) which contains install.php as a prefix, eg.:

<a href="http://social.p2pu.org/install.php/jessykate">http://social.p2pu.org/install.php/jessykate</a>

(there is a little hint in the install docs about urls being stored in the DB (side note: urls– IN THE DATABASE?! oh god, php, this is why i fear you).

but once the fancy urls are working, NEW users’ links are ok… so, to fix that first admin user’s links, we can just hack the db… login as root or the statusnet user an investigate:

mysql> use p2pu_statusnet;
mysql> show tables;
mysql> describe user;
mysql> select nickname, uri from user;
+-----------+-------------------------------------------+
| nickname | uri |
+-----------+-------------------------------------------+
| jessykate | http://social.p2pu.org/install.php/user/1 |
| jessytest | http://social.p2pu.org/user/2 |
+-----------+-------------------------------------------+
2 rows in set (0.00 sec)

aha, see the uri field for the first user…! there’s also the profile table:

mysql> describe profile;
mysql> select id, nickname, profileurl from profile;
+----+-----------+----------------------------------------------+
| id | nickname | profileurl |
+----+-----------+----------------------------------------------+
| 1 | jessykate | http://social.p2pu.org/install.php/jessykate |
| 2 | jessytest | http://social.p2pu.org/jessytest |
+----+-----------+----------------------------------------------+

these are the only two i found… so, let’s update them:

mysql> update user set uri="http://social.p2pu.org/user/1" where nickname="jessykate";
Query OK, 1 row affected (0.01 sec)
Rows matched: 1 Changed: 1 Warnings: 0

and double-check the change:

mysql> select nickname, uri from user;
+-----------+-------------------------------+
| nickname | uri |
+-----------+-------------------------------+
| jessykate | http://social.p2pu.org/user/1 |
| jessytest | http://social.p2pu.org/user/2 |
+-----------+-------------------------------+
2 rows in set (0.00 sec)

and the other one:

mysql> update profile set profileurl="http://social.p2pu.org/jessykate" where nickname="jessykate";
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

verify:

mysql> select id, nickname, profileurl from profile;
+----+-----------+----------------------------------+
| id | nickname | profileurl |
+----+-----------+----------------------------------+
| 1 | jessykate | http://social.p2pu.org/jessykate |
| 2 | jessytest | http://social.p2pu.org/jessytest |
+----+-----------+----------------------------------+
2 rows in set (0.00 sec)

voila. double check by checking the links on the directory page, and we are done.

Vanessa and i had a back-and-forth this week, reflecting about P2PU’s
learning concept called challenges. for context, p2pu currently separates
content into groups and challenges. challenges are sets of explicit tasks that
peers mark as complete and can obtain badges (and potentially other types of
recognition) for completing. groups (study groups, courses) use challenges when
they want to demonstrate specific knowledge, skills or capabilities. recently,
i wrote an introductory programming challenge, and vanessa (together with
Audrey Watters) is running a challenge about writing for the web.

one observation i’ve made while exploring participation in challenges is that
there are many challenges that are interesting to read but i don’t see the
point or value in completing the specific tasks as laid out. i end up wanting
to pick and choose from the items– and i do. this suggests why i think many
people never finish challenges. the pattern is, we see a challenge where the
first few tasks appeal and are accessible to us, so we follow/adopt the
challenge, and then the later ones don’t resonate as much, or aren’t as easy,
so we don’t complete them. participation peters out.

we are often designing tasks within challenges to become progressively harder,
but challenges aren’t meant to teach you stuff (that’s what groups, and the
web, and life, are for), so even if in the best case scenario your challenge
inspires people to go off and do or learn something new, you’re still basically
losing your audience at that point.

both of these issues relate to a key assumption that i am beginning to feel is
wrong: that we need to keep people’s attention. learning is an incredibly
personal thing. the best way to offer flexible learning pathways is to make
each discrete learning unit as small as possible, allowing the learning path to
evolve and iterate. vanessa refers to resnick’s learning spiral, which
iteratively revisits the steps imagine --> create --> play --> share -->
reflect --> imagine .... one way to see challenges is as discrete opportunities to
demonstrate learning at each iteration through the cycle.

one approach to this would be to have single-task challenges. these could be
larger in scope, and correspondingly more open-ended. for example, focusing on
the output but not the methodology, or the methodology but not the output.
being more open-ended would encourage a broader diversity of approaches. it
also scales better because it creates less work for the challenge mentors: with
the Twitter API challenge, i spend a lot of time ensuring that everyone who
posts to the first “introduce yourself” task feels welcome. but most of that
work goes unrewarded, with most people never completing the subsequent task
(it’s fairly clearly an exponential falloff rate).

with a single-task challenge, mentors get to spend their time interacting with
peers about their ideas and content. and importantly, there is no
expectation by either the mentors or participants about retaining participants’
attention. the main difference from our current approach is that the unit of
accomplishment and recognition is tied to this single task.

a practical example of my own participation waning came up when i decided to
adopt vanessa and audrey’s exciting writing for the web challenge. i like
writing for the web, and the idea of having a community of peers around doing
that. i think i could show that i have done a certain amount of writing for the
web and have basic proficiency at it. but some of the specific tasks laid out
in their challenge interest me, while others do not. or maybe it just happens,
for example, that i don’t have a blog post i want to critique. can that
tell us something about challenge design?

the problem, of course, isn’t that writing a critique is a bad exercise. it’s
that it’s one of many possible exercises that would be equally appropriate. but
because challenges are broken down into tasks, we tend to make them extremely
prescriptive. and yet we know– in fact, arguably p2pu is founded on the
idea– that there are arbitrarily many paths to a given level of proficiency.
this suggests that we should be experimenting with less prescriptive
challenges, challenges that are more open ended, and expecting more from our
peers.

as kimo said in there’s no speed limit “the standard pace is for chumps -
the system is designed so that anyone can keep up.” when i designed the twitter
api challenge i definitely fell into this trap. i was actively trying to
ensure that anyone could keep up. that’s not bad in and of itself; what’s bad
is that our notion of “keeping up” is rooted in a system where inspiration is
the exception, not the rule. the result is that learners are babied and the
challenge is less fun. it turns the participants into consumers instead of
creators, and we reinforce the very cycles of dispassionate, passive learning
we are trying to move away from.

on the other hand, when learning new stuff on the web i definitely seek out
detailed summaries and step-by-step introductions. it’s not that providing
detailed breakdowns is a problem. it’s the assumption that those breakdowns
should map in ANY way onto actions taken by the learner. that is, the problem
is that we turn breakdowns into prescriptions. this limits our learning
material and processes to introductory levels of learning, limits the
sophistication of ideas we can achieve together, and correspondingly limits our
community, too.

in summary, my takeaways after working with challenges for a few months are the
following:

1. create single-task challenge content
2. separate action from consumption: absolutely do create rich and
   detailed learning materials, but offer it as guidance instead of
   prescriptions.
3. create a cultural emphasis on mentorship and recognition

i’m feeling pretty excited about these conclusions, and have gone ahead and
tried a new challenge in the single-task format. the third item on the
list above now becomes even more important, because it keeps the community
element focused squarely in the group aspect of p2pu– which is exactly what it
was designed for.