After the completion of the ‘Gentle Introduction to GIS’ resource (available here) work that we did in 2009, Nwabisa Kakaza and I wrote an article on the training resource which now appears in PositionIT (a local GIS industry publication). For your reading pleasure, the article is downloadable here.

When I started off this internship, I had little practical experience of Open Source software. I had heard about it, and knew that it was an interesting, expanding field for a collective good, but hadn’t an opportunity to delve in deeper through my education career.

This internship has given me that opportunity and exposed me to a whole range of Open Source tools, especially those related to GIS. The programme was run so that touched on a variety of sections, explaining basic concepts and applying this information to practical projects. The sections could later be built on, beyond the internship. The training also included work from live projects running at Linfinti Consulting, which was a rewarding experience because it involved interaction with clients and handing over a product at the end of the day.

The days usually began with a session from Tim or Anne explaining what we would be covering that day. They explained all the necessary theory in a down-to-earth, and understandable way, ensuring that we understood. And after that we would get busy with our clicking, typing, learning and building. They would patiently assist us when we got stuck, and help us get to the root of the issue when there were bigger problems.

Tim and Anne were both excellent, knowledgable and practical teachers with tremendous enthusiasm for Open Source GIS, which has left me inspired.

Some of the new tools and concepts I was exposed to:

• Concepts of FOSS and the FOSS GIS stack
  
• Linux operating system – some bash, basic tools and software on Linux
• PostGIS – (first time I’ve used a geodatabase through open source and seen its practicality!)
  
• Qgis – user interface, new symbology and cartography, plugins (very useful!)
• Programming - coding in Python to create our own Qgis plugins, coding standards, SVN
• Open source community support – through IRC, mailing lists and forums
• GRASS - introduction to the interface and commands, and practical application in flood simulation
• Mapserver, Openlayers – exporting QGIS projects to mapfiles, editing symbology of the mapfiles, displaying through OpenLayers
  
• HTML, CSS, Javascript (JQuery) – linking these up, and building a webpage
• Joomla CMS

Tim also expained how all these sections were connected and added to one another, and we got to see this through our own practical work.

I really enjoyed and learnt a lot, and would like to thank Tim, Anne, Marcelle and Robert for the valuable time I spent here. It’s a sad goodbye to the team and office, but I am hoping that the new skills that I have learnt here will contribute positively to the future.

Looking foward to FOSS GIS growing in Africa! \o/

- sam

Interns

Its been a busy month. A few months ago I set things in motion by advertising for interns to come and work and learn about FOSS GIS at linfiniti.com. In tandem with that I invited Anne Ghisla to come out to South Africa from Italy to act as mentor for the interns.

When Anne arrived we interviewed various candidates and selected two – Robert Makondo and Samantha Lee Pan. You will no doubt read postings from them elsewhere on this blog as I have encouraged them to start writing articles and sharing their learning post publicly.

The aim of the internship programme is simple: transfer real-world FOSS GIS skills to interns so that we can build up the skills base in South Africa and eventually greater Africa. One day I would love to be running a kind of academy where we have a continual succession of interns from all over Africa participating in our internship programme and taking FOSSGIS skills and enthusiasm back to their place of work or study. What we are doing now is a small step in that direction.

Unfortunately Samantha (Sam) could only stay with us for the month of February as she is going into permanent employment next month. I decided to bid Sam farewell by taking the group out for a morning at the Lion and Rhino park about 30 minutes from our Linfiniti Offices in Lanseria, near Johannesburg, SA. Of course being a bunch complete geogeeks we did a GPS drive as we went (i.e. we captured our route using the new GPS plugin for QGIS that Marco and I wrote). Here is a little map of our trip (click for larger image)!

Capturing data in this way is a fun and entertaining way to expose interns to the process of primary data capture. The location was also a great choice as some in our group had never before seen lion, buffalo, wild dogs and other charismatic wild animals.

Sam and Robert sat in the back and learned to operate the GPS and the GPS Tracker plugin for QGIS.

We finished our little outing with a short walk to look at the hippos wallowing in a pond. Heres a shot of us all on the hippo viewing platform (sorry we couldnt get the hippos into the shot too ).

Next week we will say ‘goodbye’ to Samantha and ‘hello’ to Petronella, a Zimbabwean lady who will be joining us as an intern for the months of March and April. We will also be joined for the week by two other interns from the start-up company of my friend Andiswa Silinga. Andiswa is going to be getting her interns to do some digitising work using FOSSGIS so they will come to Linfiniti for occasional visits to get up to speed with the FOSSGIS way of doing things.

Training Environment

One of the cornerstones of my setup for providing a training environment has been LTSP (the Linux Terminal Server Project). I have blogged previously about my testing experiences with LTSP. For the LTSP server, I purchased one fairly good spec quad core pc which then acts as a server for up to four thin clients. I bought 3 Fujitsu Futro 100 units for thin clients which connect to the LTSP server. The system works admirably well and we have had ‘nary a hiccup over the month of solid production use. There have only been a few small issues. The GIMP for example causes X to hang when opening a file.

Using thin clients has many advantages – it is extremely simple for users to share files since they are all logged on to the same system. Also, there is only one server / machine to manage. We can get connected to the internet using a single 3G modem which we plug in to the server and then everyone on the thin clients gets internet access.

Since buying the Futro clients I have also being experimenting with using other clients. I dug out a very old and mostly dead thinkpad laptop and set its bios to do etherboot. I plugged it in to the power (its battery is long since deceased) and into an external CRT monitor (its lcd display has also given up the ghost) and voila we have another client for our network. I will probably avoid using old desktop PC’s for this purpose since they consume a lot of power and make a lot of noise, but if you are in the position where you want to maximise value and minimise your landfill contribution, using old desktop pc’s would also work fine.

One more thing I wanted to mention is the the iTalc application that you can run on top of LTSP. iTalc lets you view a gallery of connected thin clients, broadcast a message to any client, share your screen or a window with all clients (e.g. while doing a demo), lock, reboot etc. the clients. I think if I scale up to a classroom environment, it really is going to prove to be a great option.

Morning Sessions

We have established a pattern of having morning ‘geekout’ sessions of around an hour long where we discuss a topic for the day. I don’t rigidly plan what the topics will be – they either relate to some work we are trying to produce, something I have been thinking about, or another piece of the FOSSGIS jigsaw puzzle I want to let the interns know about. Here is a pic of our whiteboard doodlings from such a session:

Mentors

After the morning ‘geekout’ session we task the interns with some work for the day and then I usually run off to a client or try to knuckle down to some work. Anne continues providing mentorship to the interns through the day. The system works really well – although if I had one complaint it would be that my productivity has been reduced somewhat by the extra activities surrounding the interns. I really can’t praise Anne enough here – if it wasn’t for her, having interns would probably consume far larger amounts of my time. She is patient and enthusiastic and she instills her sense of FOSSGIS enthusiasism into the interns. I will be really sad to see Anne go at the end of March. However, I’ve had a couple of other folks in europe interested in providing mentoring services so stay tuned for the musings of other FOSSGIS celebrity guest mentors on this blog!

Biting off more than I can chew

Maybe we are biting off more than we can chew trying to launch a internship / mentoring programme from such a small company, but the wheels of government and NGO support and funding turn slowly and I wield little to no influence in the circles where decent funding gets allocated for these activities. So in the spirit of Open Source we are starting something small (like a little bit of code to scratch and itch) and hoping that others will pick up on it and let us expand the concept out to the larger African audience out that is starving to get a leg up in a GIS world dominated by expensive proprietary software that does them no favours.

Note: Edited Feb 27 to fix some 2am typos and bad grammar.

Over the last few months I have been working hard to get an internship programme going here at Linfiniti Consulting. Part of our mission is to build up local skills in FOSS GIS. The internship programme is an adjunct to other initiatives like providing free training courses, open days and so on.

We have hired Anne Ghisla (Italian QGIS and GRASS geek) to come over to South Africa and spend two months mentoring our interns.

The interns were offered a two month period during which they would receive a monthly stipend to cover their living expenses, and receive on-the-job experience in the practical use of FOSS GIS to solve real world problems.

Robert Makondo studied computer science in Pretoria and worked for a year as an intern at the State IT Agency (SITA). Robert is a relatively newcomer to FOSS and FOSSGIS but is already showing great enthusiasm in learning the new tools of the trade!

Samantha Pan is from Cape Town where she studied GIS at UCT. Samantha has used GIS during her studies but is new to the world of FOSSGIS (which she is adapting to extremely well!). Unfortunately Samantha is only staying with us for one month but we hope she will use the skills she learns here in her future place of work.

Having the mixture of CS and GIS disciplines in our interns is really nice since they complement each other well and can problem solve together. I think Anne is really enjoying her stay here in South Africa and mentoring our interns. We will be sad to see her go at the end of March .

If any readers out there are interested in coming to South Africa for a few months to help with mentoring interns please let me know! We will cover your costs and provide accommodation. In return you get to help bridge the digitial divide between Africa and the western world, while at the same time having a great experience in a different country!

Introduction

PyWPS is a great project by Jachym Cepicky and Intevation to provide an open (Open Source and Open Standards) implementation of the OGC Web Processing Service spec. In this article, I will give a quick run through of getting up and running enough to have the obligatory “Hello World” service running.

Check out and install PyWps

The source code for PyWPS can be checked out here (I’m using trunk here which is perhaps not a good idea in a production environment):

svn co https://svn.wald.intevation.org/svn/pywps/trunk pywps-trunk

Also we need to install a couple of dependencies:

sudo apt-get install libapache2-mod-python python-htmltmpl python-magic

Update 6 Jan 2009: python-magic package required as of pywps V3 r878

Right now we can go on to build and install pywps:

sudo python setup.py install

Next we copy or symlink the pywps into your cgi-bin directory:

cd /usr/lib/cgi-bin/
sudo ln -s /usr/local/bin/wps.py .

Apache Configuration

Now you need to configure your apache to set up the correct environment for PyWPS:

sudo vim /etc/apache2/sites-enabled/000-default

For clarity I have added comments to the apache virtual host configuration. Note that on your system you will need to adjust some of the paths shown here to suite.

  ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
  <Directory "/usr/lib/cgi-bin">
    #Next two lines added by Tim for PyWPS
    SetEnv PYWPS_CFG /etc/pywps.cfg
    SetEnv PYWPS_PROCESSES /home/timlinux/dev/python/wps-processes/clip
    PythonPath "['/home/timlinux/dev/python/',
                 '/home/timlinux/dev/python/wps-processes/clip']
                 + sys.path"
    AllowOverride None
    #Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    #changed from above for pywps
    Options +ExecCGI -MultiViews +FollowSymLinks
    Order allow,deny
    Allow from all
  </Directory>
  #Alias and dir below added for pywps
  Alias /wps_outputs/ "/tmp/wps_outputs"
  <Directory "/tmp/wps_outputs/">
      Options Indexes MultiViews FollowSymLinks
      AllowOverride None
  </Directory>

The important part here is that you are setting your PYWPS_CFG path and you python path, and relaxing the cgi-bin permissions a little to allow following symlinks.

PyWps Settings Configuration

As you may have noticed above, pywps uses a file in /etc/pywps.cfg to store all of its global settings. Adapting the settings I have used below should get you started quickly:

[wps]
encoding=utf-8
title=PyWPS Development Server
version=1.0.0
abstract=Dev version of PyWPS. See http://pywps.wald.intevation.org
fees=None
constraints=none
serveraddress=http://localhost/cgi-bin/wps.py
keywords=GRASS,GIS,WPS
lang=eng,ger

[provider]
providerName=Linfiniti Consulting CC.
individualName=Tim Sutton
positionName=GIS Consultant
role=Developer
deliveryPoint=Lanseria
city=Johannesburg
postalCode=000 00
country=za
electronicMailAddress=tim@linfiniti.com
providerSite=http://linfiniti.com
phoneVoice=False
phoneFacsimile=False
administrativeArea=False

[server]
maxoperations=3
maxinputparamlength=1024
maxfilesize=3mb
tempPath=/tmp
# Dont specify this if you have set it up in the apache config
#processesPath=
outputUrl=http://linfiniti.com/wps/wps_outputs
outputPath=/tmp/wps_outputs
debug=true

[grass]
path=/usr/lib/grass/bin/:/usr/lib/grass/scripts/
addonPath=
version=6.2.1
gui=text
gisbase=/usr/lib/grass/
ldLibraryPath=/usr/lib/grass/lib
gisdbase=/home/user/grassdata
#home=/var/www/

Note that the grass section is present, although the use of grass within pywps is entirely optional.

Implementing your own processes module

The last thing we need to do before being able to see pywps in action is to write our processess module. The processes module is basically just a directory filled with python classes, each of which can expose a service endpoint.

First lets set up some structure:

mkdir -p /home/timlinux/dev/python/wps-processes
cd /home/timlinux/dev/python/wps-processes

This is our top level processes directory. Under that we will now create a module:

mkdir -p clip
cd clip

I called mine ‘clip’ because after we are done, I plan to deploy an image and vector clipping service so I am planning for the future.

echo '__all__ = ["helloWorld"]' > __init__.py

Note that if you want to deploy more than one process, add the additional ones (separated by commas) after the “helloWorld” process.

Next create your process class (mine is unsurprisingly called helloWorld.py):

from pywps.Process.Process import WPSProcess
from types import *

class Process(WPSProcess):
  """Main process class"""
  def __init__(self):
    """Process initialization"""

    # init process
    WPSProcess.__init__(self,
      identifier = "helloWorld",
      title="Hello World",
      version = "0.1",
      storeSupported = "false",
      statusSupported = "false",
      abstract="Pass me a message, I'll pass one back to you",
      grassLocation = False)

    # process inputs
    #simple input
    self.message = self.addLiteralInput(identifier = "message",
      title = "Your message",
      type = StringType)

    # literal output
    self.textOut = self.addLiteralOutput(identifier="text",
        title="Just some literal output",
        type = StringType)

  def execute(self):
    """Execute process."""
    myReply = "Well hello there : " + str(self.message.value)
    self.textOut.setValue(myReply)

This is probably one of the most simple process implementations you could write. It takes a single parameter and returns a string.

Testing

Make sure to reload your apache instance before testing e.g.:

sudo /etc/init.d/apache reload

Now you can test.I had to chop these into two lines to fit into my blog page, but you should use a single line url for the purpose:

http://localhost/cgi-bin/wps.py?Service=WPS&

Version=1.0.0&Request=GetCapabilities

The above performs a basic capabilities test for your server. You should get a response that looks something like:


<?xml version="1.0" encoding="utf-8"?>
<wps:Capabilities service="WPS" version="1.0.0" xml:lang="eng"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:wps="http://www.opengis.net/wps/1.0.0"
xmlns:ows="http://www.opengis.net/ows/1.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
http://schemas.opengis.net/wps/1.0.0/wpsGetCapabilities_response.xsd"
updateSequence="1">
<ows:ServiceIdentification>
<ows:Title>PyWPS Development Server</ows:Title>
<ows:Abstract>Development version of PyWPS. See http://pywps.wald.intevation.org</ows:Abstract>
<ows:Keywords>
<ows:Keyword>GRASS</ows:Keyword>
<ows:Keyword>GIS</ows:Keyword>
<ows:Keyword>WPS</ows:Keyword>
</ows:Keywords>
<ows:ServiceType>WPS</ows:ServiceType>
<ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
<ows:Fees>None</ows:Fees>
<ows:AccessConstraints>none</ows:AccessConstraints>
</ows:ServiceIdentification>
<ows:ServiceProvider>
<ows:ProviderName>Linfiniti Consulting CC, South Africa</ows:ProviderName>
<ows:ProviderSite xlink:href="http://linfiniti.com"/>
<ows:ServiceContact>
<ows:IndividualName>Tim Sutton</ows:IndividualName>
<ows:PositionName>GIS Consultant</ows:PositionName>
<ows:ContactInfo>
<ows:Address>
<ows:DeliveryPoint>Lanseria</ows:DeliveryPoint>
<ows:City>Johannesburg</ows:City>
<ows:PostalCode>000 00</ows:PostalCode>
<ows:Country>za</ows:Country>
<ows:ElectronicMailAddress>tim@linfiniti.com</ows:ElectronicMailAddress>
</ows:Address>
</ows:ContactInfo>
</ows:ServiceContact>
</ows:ServiceProvider>
<ows:OperationsMetadata>
<ows:Operation name="GetCapabilities">
<ows:DCP>
<ows:HTTP>
<ows:Get xlink:href="http://localhost/cgi-bin/wps.py?"/>
<ows:Post xlink:href="http://localhost/cgi-bin/wps.py"/>
</ows:HTTP>
</ows:DCP>
</ows:Operation>
<ows:Operation name="DescribeProcess">
<ows:DCP>
<ows:HTTP>
<ows:Get xlink:href="http://localhost/cgi-bin/wps.py?"/>
<ows:Post xlink:href="http://localhost/cgi-bin/wps.py"/>
</ows:HTTP>
</ows:DCP>
</ows:Operation>
<ows:Operation name="Execute">
<ows:DCP>
<ows:HTTP>
<ows:Get xlink:href="http://localhost/cgi-bin/wps.py?"/>
<ows:Post xlink:href="http://localhost/cgi-bin/wps.py"/>
</ows:HTTP>
</ows:DCP>
</ows:Operation>
</ows:OperationsMetadata>
<wps:ProcessOfferings>
<wps:Process wps:processVersion="0.1">
<ows:Identifier>helloWorld</ows:Identifier>
<ows:Title>Hello World</ows:Title>
<ows:Abstract>Pass me a message, I'll pass one back to you</ows:Abstract>
</wps:Process>
</wps:ProcessOfferings>
<wps:Languages>
<wps:Default>
<ows:Language>eng</ows:Language>
</wps:Default>
<wps:Supported>
<ows:Language>eng</ows:Language>
<ows:Language>ger</ows:Language>
</wps:Supported>
</wps:Languages>
<wps:WSDL xlink:href="http://localhost/cgi-bin/wps.py?WSDL"/>
</wps:Capabilities>


http://localhost/cgi-bin/wps.py?Service=WPS&request=DescribeProcess

&version=1.0.0&identifier=helloWorld

This will result in something like this which describes our hello world service:


<?xml version="1.0" encoding="utf-8"?>
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0"
xmlns:ows="http://www.opengis.net/ows/1.1"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd"
service="WPS" version="1.0.0" xml:lang="eng">
<ProcessDescription wps:processVersion="0.1" storeSupported="False" statusSupported="False">
<ows:Identifier>helloWorld</ows:Identifier>
<ows:Title>Hello World</ows:Title>
<ows:Abstract>Pass me a message, I'll pass one back to you</ows:Abstract>
<DataInputs>
<Input minOccurs="1" maxOccurs="1">
<ows:Identifier>message</ows:Identifier>
<ows:Title>Your message</ows:Title>
<LiteralData>
<ows:DataType
ows:reference="http://www.w3.org/TR/xmlschema-2/#string">string</ows:DataType>
<ows:AnyValue />
</LiteralData>
</Input>
</DataInputs>
<ProcessOutputs>
<Output>
<ows:Identifier>text</ows:Identifier>
<ows:Title>Just some literal output</ows:Title>
<LiteralOutput>
<ows:DataType
ows:reference="http://www.w3.org/TR/xmlschema-2/#string">string</ows:DataType>
</LiteralOutput>
</Output>
</ProcessOutputs>
</ProcessDescription>
</wps:ProcessDescriptions>


From the process description we can see that our service takes a single text input and returns a single text output.

Finally we can try to invoke the service itself:

http://localhost/cgi-bin/wps.py?Service=WPS&request=execute&

version=1.0.0&identifier=helloWorld&DataInputs=[message=Tim]

Which returns:


<?xml version="1.0" encoding="utf-8"?>
<wps:ExecuteResponse xmlns:wps="http://www.opengis.net/wps/1.0.0"
xmlns:ows="http://www.opengis.net/ows/1.1"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
http://schemas.opengis.net/wps/1.0.0/wpsGetCapabilities_response.xsd"
service="WPS" version="1.0.0" xml:lang="eng"
serviceInstance="http://localhost/cgi-bin/wps.py?service=WPS&request=GetCapabilities&version=1.0.0"
statusLocation="http://localhost/wps/wps_outputs/pywps-125414601825.xml">
<wps:Process wps:processVersion="0.1">
<ows:Identifier>helloWorld</ows:Identifier>
<ows:Title>Hello World</ows:Title>
<ows:Abstract>Pass me a message, I'll pass one back to you</ows:Abstract>
</wps:Process>
<wps:Status creationTime="Mon Sep 28 15:53:38 2009">
<wps:ProcessSucceeded>PyWPS Process helloWorld successfully
calculated</wps:ProcessSucceeded>
</wps:Status>
<wps:ProcessOutputs>
<wps:Output>
<ows:Identifier>text</ows:Identifier>
<ows:Title>Just some literal output</ows:Title>
<wps:Data>
<wps:LiteralData dataType="string">
Well hello there : Tim
</wps:LiteralData>
</wps:Data>
</wps:Output>
</wps:ProcessOutputs>
</wps:ExecuteResponse>


You can see in the above output that the string I passed the service was returned to me in the form of a nice greeting.

Conclusion

In the course of an hour or two, you can have a simple PyWPS service running. The creation of new services should be trivial from this point on. I will no doubt post a follow up showing PyWPS doing something more substantial in the future. If you are thirsty for more, do check out the intevation PyWPS documentation pages.

Some time ago on the QGIS IRC channel, Dane Springmeyer (thanks Dane!) walked me through the basic concepts of GeoDjango, an Open Source web application development framework with a geospatial twist. I often remark to people that I think Desktop Applications are the way to go in the 3rd world where lack of Internet connectivity kills the user experience in web applications. At the same time, being pragmatic, I try not to completely ignore the web space, and if there ever was a compelling reason to do stuff on the web, for me it is GeoDjango.

This week I ran a free three day django training course for 3 ‘guinea-pigs’ (or should I be calling them ‘crash test dummies’ ? ). I covered not only Django, but also Subversion, as I wanted to instill the practice of using managed source code into the attendees at the same time as sharing the joys of Django. We finished off the 3 days by collaboratively working on a GeoDjango application.

It was quite remarkable how quickly they all were able to pick up the concept of Django, and they were soon building functional web applications within the first few hours of the course. I’m incredibly grateful to Graeme, Casey and Clinton for attending the pilot of my course and helping me to square up the training materials I have been preparing in anticipation of offering similar courses in the future. I’m going to put the training materials online for general enjoyment in a couple of days, once I have finished shoring up some loose ends. In the mean time here is the parting feedback I received from the attendees…

“Django is my first exposure to frameworks. I think it is great. Frameworks are tools that in my opinion should be mandatory in any development environment due to the time they save in skill aquisition and normal everyday usage. I am very keen to experiment more with Django and implement my own apps. The course was fantastic. I think it is very good to learn while doing. The idea of working on our own app and then in the end doing a collaborative effort is very novel to me and a very good idea. A very worthwhile use of time.”

– Casey Stephens CSIR-SAC (Centre for Science and Industrial Research, Satellite Applications Center)

“Thank you for the opportunity to learn Django. The course content was great and really informative. Promoting FOSS4G within government, it is very important to learn about new technologies in which to offer my clients. The lessons learnt from this course, understand programming!!! I think that if I was more in tune with programming standards, syntax and ‘programese’ I would have been more productive. With that said, you do not have to be programming whiz to get by. Django’s documentation is great and full of information. With a lecturer like yourself, Django is easy to understand and use.”

– Clinton Papenfus, SITA (State Information Technology Agency)

“Tim ran a really interesting (Geo)Django course at his most scenic smallholding outside JHB. Three of us, with varying levels of skill and enthusiasm, spent three days digging into the wealth of capability that exists in the framework. I guess I started thinking it would be almost trivially easy to work with django, and indeed it is. But it is also hard! The wonderful flexibility of the framework means that there are always different ways to do things, each with varying degrees of ‘good practice’. So, I guess I really need to use the toolset on a real live project, because if I don’t do it soon, I am likely to forget the insights I gained. Tim’ approach to teaching Django worked for me – lots of time to define ‘applications’ and write code. It feels informal and unstructured, but you actually end up covering a whole lot more ground and in line with the mantra of *doing* being more powerful for learning than *showing*, one comes away with enough knowledge to get cracking on projects of ones own. Novel for me was the strong use of svn and trac in a course – dead easy for participants to share/ view each others work and struggles! Tim had a cracking course idea for the end – a mini code sprint involving all the participants working on a single application. Aside from being fun, it gave a sense of how the Django framework allows work to be divvied up according to skillsets/interests. All in all, a unique, fun and insightful course in a lovely relaxed setting. Oh, and thanks to Marcelle for putting up with us and hogging Tim!”

– Graeme McFerren, CSIR-MERAKA (Centre for Science and Industrial Research, Meraka Institute)

We (my wife and I) have been teaching our neighbour, Sibongile (‘Bongi’) to use a computer over the last few months. We recently employed Bongi for a few evenings for the Gentle Introduction to GIS project we were contracted to do. The project involved creation of educational GIS materials for teachers and scholars and was based on QGIS. Bongi did some narration work on some of the screen casts we made. A domestic worker in her early 30′s, Bongi had never touched a computer before we started, had no idea what a keyboard is, a mouse is, clicking, dragging etc. It’s not an atypical scenario here in Africa where many people grow up on the wrong side of the digitial divide.

The one technology that has made it across the divide is the use of cellphones. Almost everyone has a cheap grayscale Nokia something or other – something like you were probably using 10 years ago. Cellphones are a good entry point into introducing the idea of a digital device as a communications tool.

Starting to train someone from scratch is a novel experience for the trainer as well as the trainee. For one thing it means that since the person has no idea of what software is to start with, they also have no idea what proprietary software is versus Free Software. Naturally that means we can make their first computing experience a FOSS one (I’m talking Ubuntu here!) rather than one based on Windows. Imagine the potential this brings, with so many people left on the other side of the digital divide, they could all be experiencing the digital world for the first time as a Free one.

The first thing Bongi learned to do is to type. I didn’t explain anything except how to log in, open Klavaro (an open source touch typing tutor) and start typing. A month or two later she has worked through all 42 or so lessons in Klavaro and in the interim, we have tought her to use the mouse, what drag and drop is, what windows are and how to resize, minimise, maximise and close them. I have been trying to teach her in a generic way – i.e. not how to use specific programs but how to learn to use any program. I teach her to look for familiar things if she encounters a new program – maybe some text formatting buttons on a toolbar will give her queues that she can format text. Save, open and close buttons indicate that she can manage her work. When she is not sure what to do, I have shown her to use the right click context menu to discover functionality, and the help menu to read up more. I told her that learning a computer should be like moving to a new city – you need to walk around and discover the place, find which areas you like. If you find places you like, you will revisit them more often and become more familiar with them. Learning by discovery is an important part of being flexible and able to adapt to a changing digital landscape.

Bongi still has a long way to go, but already she has come a long way. One of the interesting things has been trying to explain what a computer is actually useful for. I showed her some educational programmes that she can use to teach her 5 year old daughter new things. I showed her a word processor, spreadsheet, presentation package and drawing app (all OpenOffice tools). While the basic functionality is apparent I think it will take her a while to see how these tools can be applied to her own life. Near the beginning I gave her a computer that I wasn’t using and a friend donated her an old CRT screen. Yesterday I gave her an old digital camera and showed her how pictures can be copied into the computer and set as her wallpaper. Slowly I think she is starting to see how these things converge into an information repository. Yesterday I also created her first email account and explained how the internet can be used to send messages to people. In the near future I am going to set up a blog site for her and encourage her to start blogging about her (computing and general life) experiences. I’ll put some google ads on her blog and hopefully she will even start to generate a little income from her digital life. She doesnt have internet access so she will check her email and update her blog when she comes over to visit, writing her articles at home and bringing them across on an old memory stick I have given her. One other thing I haven’t mentioned is that Bongi’s first language is Zulu so she has to learn everything in a second language, making it that much more of a challenge for her.

The coolest part is that she is experiencing everything in her new found digital world as FOSS software. Ok, I know I said that already, but I still find it incredibly cool. I’ll probably post occasional updates on her progress and who knows maybe one day she may be using FOSS GIS software too! Speaking of FOSS GIS, QGIS recently got a Xhose translator (thanks Andiswa Silinga!) and I hope to get it translated into the rest of the 11 official South African languages to make it a little easier on folks when they do get to the point of wanting to learn GIS.

If you would like to write to Bongi to wish her well on her digital journey (she will be thrilled to receive her first emails too I am sure!), you can pop her a note on: speperembe at gmail dot com

I haven’t yet explained to her all the rather more unfathomable aspects of the internet so hopefully she doesnt get inundated with Nigerian get rich quick schemes or offers for viagra!

Oh and one more thing, some of Bongi’s neighbours have found out that she is learning computers and are keen to learn too. I’ve started teaching Thandi (pupil number #2!) but dont have a computer for her. If anyone has old laptops they dont need (they really don’t need to be anything fancy, just enough to run ubuntu or xubuntu etc.) and would like to have it put to good use rather than gathering dust in your cupboard, please contact me and I’ll see that they get put to good use! Laptops are particularly good as they have a built in UPS (power supply is extremely variable especially in the rainy season) and people typically live in single room dwellings without a lot of space.

Do you have similar experiences? I’d love to hear any tips and tricks!