# Talk:Drumbeat/p2pu/courses/wikiwysiwyg

Well this is a first draft of everything that I could fit into words.

It's probably too scary in its present form. Hopefully it will evolve into something friendly soon.

I am not aiming for perfection, making a mistake and correcting it later takes less energy than trying to make this perfect.

I'm moving technical details to the talk page, because it probably causes confusion and maybe someone will propose a simpler mechanism.

# Global Plan

Need an hands on example ASAP. Too much discussion and meta-discussion at the same time.

Jason Kealey, in a personal communication, proposes the following example:

RegexPal [1] a regex tester that could be integrated within a WikiWYSIWYG process that teaches regular expressions.

I will construct a visual representation of this ASAP.

Need a simple explanation of what this is.

How does this move from abstract idea to a concrete manifestation?

Feedback from 6 people now: Réjean Charpentier, James Caveen, Michel Beaulieu (suggested Git), Jason kealey, Leo Alvarez (implicitly Jeannette M. Wing) and Guillaume Alain. Thanks!

# Builder point of view

I asked a personal friend for feedback and he was patient enough try to understand what I was thinking, and this is how I eventually described it to him:

## Hypothesis

The main hypothesis (written H) goes like this:

Let S be a snapshot of a hosted process (a simple tutorial or teaching a definition is a process).

Let U(S) be a user's modification of the process S.

H : [ diff[S, U(S)] == how the user learns ] = true

The diff[] is the same diff you can use in the history section of a wiki.

## Example of a definition teaching process

1. Suppose we start a process that has the goal to teach the definition of the Open Web.

S = Definition of the Open Web

Def.: The Open Web is blablabla

2. User1 downloads this process and tinkers with it (in order to assimilate it)

U(S) = Definition of the Open Web (U's point of view)

Def.: The Open Web is blublublu

3. diff[S, U(S)] = blablabla vs. blublublu (this is how the user learns, he/she is telling us he/she thinks the Open Web is blublublu)

4. This process goes on for a while with many users participating.

5. Eventually it is hoped that useful consensus and dissenting definitions will be formed (it is not Open if there is no room for disagreement). That is we can partition all U(S) into equivalence classes.

This already happens on Wikipedia (articles converge to consensus that fits within policies). The fun part is when we apply this to every other aspects of Open Web Development cycles (there are many different cycle philosophies)

## Example of a code teaching process

1. Suppose we start a process that has the goal to teach a HTML5 Hello World application

S = HTML5 Hello World code snippet

2. User1 downloads this process and tinkers with it (in order to assimilate it)

U(S) = HTML5 Hello World code snippet (U's point of view)

3. diff[S, U(S)] = May or may not be different. A difference here can reveal an alternative way to write a HTML5 Hello World code snippet. No difference does not necessarily mean the user has learned therefore we should encourage users to break things and make mistakes. If the user understands how/why the code snippet was broken, the user will surely understand (or at least accept until it gets clearer) the published code snippet.

4. This process goes on for a while with many users participating.

5. Eventually it is hoped that useful consensus and dissenting code will be formed (it is not Open if there is no room for disagreement). The concept of dissenting code becomes clear when you visualize one super optimal but unreadable code snippet and one super readable but not optimal code snippet.

## Technical Details

### Revision Control

TODO: Separate the paradigm from the interface (SVN, Bazaar, Git, Mercurial are interface applications while revision control is a paradigm). The following tutorials are only for the interfaces. A first glance of the paradigm can be found on Wikipedia [2]

Here is list of distributed version control systems that could be used for WikiWYSIWYG (a more comprehensive list can be found on Wikipedia [3]

1. SVN (most open source projects use this one, but it's not distributed).

2. Bazaar [4]

3. Git [5]

4. Mercurial (Mozilla uses this one so probably coherent for us to use it also). Tutorial [6]. Book by Bryan O'Sullivan [7]

No matter which is chosen, it is good for new users to become aware that there are other systems.

### Compilation

There is a nice tutorial in Ubuntu's Community Documentation [8]

### Open Web Development

Django tutorials [9]

### Databases and query languages

Curious new users will hit database concepts really fast. I remember playing with PostgreSQL and JDBC, but I am not in a position to assess what should be covered here.

Sqlite [10] seems like a reasonable choice for teaching the concepts. Probably also for the WikiWYSIWYG proof of concept.

### Other tutorial chains

#### Tutorial chaining processes

The guys over at TeachingOpenSource.org (John Britton!) [11] have a related idea in terms of organizing tutorials and linking to them.

I am thinking more of modeling tutorial and definition chains, code snippets, requirements, use cases, etc. Then placing these in database which would let users query for them (using collaborative meta-data). Kinda like the Django polls tutorial, but orienting the questions towards Open Web Development. Maybe someone else is working in this direction too, I'll find out about it soon enough :)

Also having a rating feature for users to quantify their learning experience (this is rampant on every site) and share it with others.

#### Modeling tutorials

TODO: search for them

# User point of view

We're going to have to find a balance between theory and practice here. There is probably a different balance for each user: 50-50 for some, 20-80 for others, etc. Again, this is not a complete list, some points can be removed or reworded.

1. How do we treat definitions of Open Web Concepts? Link to courseware? Link to Wikipedia? Examples?

2. Probably need to start with version control tutorials, followed by compiling tutorials, then open web dev tutorials (django? I'm checking these out atm).

3. Need a tutorial chain for the most common use cases. For example, when a user clicks on a link in a webpage: we could have a tutorial chain explaining how links are rendered on the screen, how this results in packets of information being sent on the internet, what a server is, how the server reacts to these packets, how it sends back new packets, how these packets get to the browser, how the browser deals with these new packets, and how the new page appears on the screen. This tutorial chain should be connected to everything else the user would need in order to understand and see it in action.

4. Need for a Hello World Section for each language: HTML, CSS, php, JavaScript, perl, etc. (these already exist, which do we chose?)

5. Need for an explanation on the difference between a Hello World application and a full fledged application. Many little applications can be "glued" together to form very functional applications. There are many different ways to "glue" applications together. There are different types of "glue". Need a more concrete explanation of this "gluing" concept.

6. Jeannette M. Wing's tutorials on computational thinking and thinking about computing [12]. Is this open courseware?

# On the type of help that is needed

Please be advised that I "judge" help based on ego (or lack of it). The more ego I smell in your help, the less chance it has of getting in here. New users don't need to know how great you are, or how many badges you have, or whatever mechanism that would impose your superiority.