This is the third in our series on Asterisk. This article will cover enabling asterisk to record calls. You may want this to interview people over the phone, podcast, or some other purpose. Read on.

read more

In the past, we've been given feedback that as an organization supporting open source and open standards we should not use certain technologies. Adobe flash, and Adobe Air have been two notable examples of this. For some, this issue is black or white... if you want to reach people on the web, flash is a big part of doing so. Conversely, those advocating open standards note the risks and damage caused by using technologies encumbered by patents and royalties and thus push strongly for free alternatives. It is thus interesting to see what Adobe has to say on the matter. Read on.

read more

I have seen people, most especially academics, ask me the following questions.
1) Why can’t I implement session mobility using Mobile IP or Media Independent Handover (MIH)?
2) Who needs session mobility?
3) Why did you choose to use SIP?

Having done an extensive literature review and got a number of papers (in a journal and conf. proceedings), I can now say that my answers to the questions have always been right. Once again, these are my answers:

1) My work is an “application layer solution” for HTTP/Web session mobility. I don’t work at the lower layer(s) of the OSI layers. Mobile IP and MIH have been used to achieve terminal mobility at the lower OSI layers. My work involves moving web sessions between PCs, but not moving terminals (mobile nodes) between access points. That is what Mobile IP and MIH can help you achieve, and it’s called terminal mobility.

2) The work offers solutions to problems faced by the regular Internet users. I explained what the problems are using two use case scenarios here. Most of us (the regular Internet users) often do one of these things: 1) send a URL to a friend in an e-mail or through the Instant Messaging (IM) service when we want him/her to take a look at what we are viewing online; 2) save a URL in our e-mail/diary with the intention of continuing with what we are doing somewhere else. Interestingly, many software companies, such as Mozilla and Google, are introducing new products/services to address the problems. Examples are the Mozilla Weave and the outdated/de-supported Google Browser Sync. What I have done in my work is to make a person send a URL from one browser (or PC) to the other without using a third-party service like IM or e-mail.

3) It’s obvious that HTTP without being extended can’t deliver the services desired in this present day. That’s why it’s been patched to provide the services. Mozilla Weave was once using WEBDAV (an extension to HTTP). In another sense, cool tools like AJAX, Restful APIs have been introduced in order to provide those new services – Rich Internet Applications. HTTP User Agent (UA) can either be a client or a server, but not both. Hence, it had to been extended to do both. The case is different in SIP in which its UA is both a client and a server. Software firms are now relying on protocols like SIP and XMPP to offer some appealing services. An example is the Google Wave, which uses XMPP (Draft Protocol Specs here). I also chose to use SIP in my project in order to gain the instant messaging and presence capabilities in SIP.

I am happy to answer other related questions or provide more information on the work.

CAS stands for Converged Application Server. It is the controller for the TransferHTTP extension, and I blogged on it sometime ago here. The controller, also known as the proxy, is called CAS  because it provides two endpoints (a SIP endpoint for the signalling and services and an HTTP endpoint for the services administration). Below is the User Interface (UI) for setting policies in the work. The policies include web session mobility blocking and forwarding policies. In web session mobility blocking policies, users could add SIP URI they would not want to accept a session transfer from; while in web session forwarding policies, users could forward (i.e. redirect) a session transfer request to any of their PCs.

User's Policies Interface

Below the user’s policies (in the above figure) are registered SIP URIs of the user. Those are the URIs at which the user could be contacted.  The log in credentials (SIP URI and password) will be required to connect to the server. Here is the client interface – http://transferhttp.mozdev.org/screenshots.html – where the user will enter the credentials.

I already have a number of things under future work. These include extending CAS to support buddy list with presence and extending the TransferHTTP extension to support an address book.

I finished up some work today on the Processing.js automated test tools.  Previously I wrote a test harness to allow JavaScript based unit tests, as well as parser tests.  However, after watching some of my students struggle through bugs during the lead up to their 0.5 release, I decided we needed a way to also be able to write them in Processing.  Right now I see a lot of tests being drawn into sketches, and then manually comparing results.  It’s sub-optimal to say the least.

Having written the unit test functions already, I decided to simply load them into Processing via a library.  Processing.js, like Processing, has the capability to load “native” libraries.  In Processing.js, such libraries are JavaScript functions written like so:

(function() {
  Processing.lib.Foo = function() {
    this.something = function() {...};
    ...
  }
})();

Then, in your Processing.js sketch code, you initialize the library by calling its constructor (e.g., Foo();), and then any function (e.g., something();) will be available to your code.

Using this technique I added the same set of _check* functions already available to JavaScript unit tests, such that I’m now able to write small unit tests in Processing like this:

// Tests for Processing str() function - http://processingjs.org/reference/str%28%29
boolean b = false;
byte y = -28;
char c = 'R';
float f = -32.6;
int i = 1024;

_checkEqual('false', str(b));
_checkEqual('-28', str(y));
_checkEqual('R', str(c));
_checkEqual('-32.6', str(f));
_checkEqual('1024', str(i));

I’ve fully documented the setup and use of the new automated testing features. All Processing.js developers (especially my students), should read through this. Beginning with the 0.6 code, we’ll start using this by default for all regression and API testing.

The announcement about Symbian going open source made me watch an introduction video flagged by my colleague Rowan, who has written about open source in mobile devices.

What I heard, among others, was that developers are encouraged to contribute to the open source platform, and in the final section (3′45″) that Symbian’s governance model allows virtually anyone to be part of the working groups and councils and have a say about their future direction. This looks good, I thought, let’s check further.

There is a wealth of information on Symbian’s developer site, including another video suggesting how users and developers can get involved.

The contribution process includes both general issues about contributing source code and more specific ones, such as how to contribute a fix, an enhancement, an extension, or how to start a new Symbian-related project.

In a nice piece on the wiki I also found things very much in the spirit of how we talk about open development and the process of building open source communities:

“Contributors are also users (which is one reason why they are motivated to meet the needs of the users) but contributors want a say in the roadmap so that they have a chance of influencing it in directions that benefit them and they want to be able to get their contributions accepted into the project. Contributors may provide code for bugfixes and new features (the most obvious form of contribution) but they can also contribute support services, translations, documentation etc.”

Community-wise this looks like a nice step to open source for Symbian. Let’s wait and see.

For those in academia: I’m wondering whether this might be the kind of mini research problem (or even non-mini research problem) that university students might be excited about picking up.

From Matt Domsch’s post to the Fedora advisory board list:

I’ve spent quite a bit of time over the last week fixing up the scripts that generate Fedora’s worldwide user maps including the worldwide map for all Fedora versions currently in use as determined by yum requests for mirrorlists… we currently have no way to know, within even a 2-4x margin of error, how many current installs of Fedora there are. But this number, and it’s growth (positive, or negative), would be interesting to know, if only it were more accurate.

Now… it seems to me that this is an interesting technology-related problem requiring technical fluency, development of keen analysis skills, and with immediate potential real-world (i.e. would-actually-affect-the-work-of-thousands-of-people) implications. And it also seems to me like it would fit nicely into the format of an independent study or a small thesis – actually, my first reaction (before starting to think about potential solutions) was “huh, this is something I could work on, write a paper about, and turn in for school, if I were still in school.”

Thoughts? Would these sorts of “huh, we wonder how we’re doing on this front?” introspective semi-research-ish questions coming from open source communities make good material for student projects (independent research, class projects, whatever format it would fit in)? If so, how could we help students get started on them? If not, why not – and what sorts of problems would be better?

JGrass, present and future by Andrea Antonello, Silvia Franceschi

read more

This story is very interesting given it's significance from both an open and closed source perspective given the high performance and disruptive potential involved.

read more

Amid all the excitement about moving education online, we shouldn’t forget that so far, doing so seems to hurt those who need help the most. As Mark Guzdial says in his recent blog post:

Universities already widen the gap between rich and poor, by flunking out or not admitting the poor. On-line courses tend to flunk out even more students, and mostly at the lower-knowledge and poor levels…  I think it’s possible for on-line education to be even better than existing University education, in terms of improving learning and engaging a broader range of students… [but] the work has to happen first. If [universities] disappear in favor of [online education], before we make [online education] better, [it] will lead to worse education for society, especially for weaker students.

We just finished a big last-minute sprint in the #teachingopensource IRC channel to push our OSCON track proposal through.

Here are the five I’m listed for:

1. 5 FOSS in Edu projects that changed the world (Karsten Wade, Mel Chua)
2. Junior Jobs and Bite-sized bugs: Entry points for new contributors to open source (Mel Chua, Asheesh Laroia)
3. Teaching FOSS to Undergraduates (Ralph Morelli, Luis Ibanez, Carlos Jensen, Mel Chua, Timothy Budd, Leslie Hawthorn)
4. Teaching Open Source Has A POSSE (Professors Open Source Summer Experience) (Mel Chua)
5. The Open Source Way: Leveraging Communities (Sebastian Dziallas, Mel Chua)

As a first-time proposer, I was amazed to see how quickly things came together, snowballing right up until the very end. A few minutes before the deadline, proposals were still being written – for the one I was in, Asheesh was filling in the outline Karsten had set down while Jeff caught typos and I copy-pasted the finished bits into the OSCON proposal submission page. We got it in right under the deadline. (In other news, etherpad kicks some serious butt.)

I’m hopeful that our track (and at least some of our talks) will be accepted – I definitely want to see… oh, pretty much all the talks listed. July should be a fun month for travel this summer.

In other news, the road trip back to Boston (from Raleigh) continues. I’ve made it to New York, staying with Sumana and Leonard. Many thanks to Paul and his family for putting me up last night (complete with affectionate dog resulting in my pants still having dog hair on them – but I’m happy about this, since my opportunities to get covered in dog hair are far less frequent than I would like them to be).

It is nearly 4am, which means unconsciousness shall claim me shortly. Farewell to the waking world for a few hours.

The Globe picked up a Canadian Press article today, whose title echos the favourite refrain of big media and other institutional onlookers of so called social media: “Students failing because of Twitter, texting.”  In it the author cites some “solid evidence” for the demise of writing skills at the post secondary level:

Ontario’s Waterloo University is one of the few post-secondary institutions in Canada to require the students they accept to pass an exam testing their English language skills.

Almost a third of those students are failing.

…

“What has happened in high school that they cannot pass our simple test of written English, at a minimum?” she asks.

Even those with good marks out of Grade 12, so-called elite students, “still can’t pass our simple test,” she says.

Poor grammar is the major reason students fail, says Barrett.

“If a student has problems with articles, prepositions, verb tenses, that’s a problem.”

We’ve heard all this before.  Poor writing?  Increased use of social media?  Let’s connect the dots.  A little further into the article, we find some other interesting bits; let’s start with grammar:

Some students in public schools are no longer being taught grammar, she believes.

…

“When I went to high school in the ’70s I was never taught grammar in English. I learned grammar from Latin classes.”

…

“We haven’t taught grammar for 30-40 years…(and it) hasn’t worked.”

“It’s not that hard to teach basic grammar,” he says.

I learned grammar studying classical Greek through four years of university.  I was never properly taught grammar in high school, because that final statement above is false: it is hard to teach grammar, or perhaps it is hard to teach it well.  Grammar, as an abstract system, is very difficult to grasp when you only know one language.  Without being able to step outside English and examine it from the vantage point of Greek, I don’t think I would have ever understood it.  But in the context of learning a second language, especially its literature, one is forced to map grammatical structures back and forth.  You can be a very good speaker or writer of English and not know the names for the constructions you use.  You can’t learn to read another language without them.  In other words, the need for grammar has to be real if one is to learn and then retain it.  I think many of the high school students who failed these tests did in fact learn grammar; they just didn’t retain it beyond the final exam.

Another issue discussed at length is spelling, contractions, and other short forms:

Emoticons, happy faces, sad faces, cuz, are just some of the writing horrors being handed in, say professors and administrators at Simon Fraser.

…

“Instead of ‘because’, it’s ‘cuz’.

…

“The words ‘a lot’ have become one word, for everyone, as far as I can tell. ‘Definitely’ is always spelled with an ‘a’ -’definitely’. I don’t know why,” says Paul Budra, an English professor and associate dean of arts and science at Simon Fraser.

I find the last example particularly funny.  The use of alot vs. a lot frustrates me, I’ll be honest.  I have a friend who uses ‘alot’ exclusively, and one day I decided to send him a private note telling him of his mistake.  He replied politely that he knew, and had made a conscious decision to change the spelling as a way of normalizing ‘alot.’  I was blown away at first, but later, upon reflection, had some respect for his decision.  Spelling reforms have happened throughout history, whether through decree or by means of popular usage shifts.  If ‘definitely’ is always spelled ‘definately,’ it soon will be.  Is it E-Mail, E-mail, e-mail, or email?  Spelling is very much influenced by usage, just as meaning.

Students haven’t learned grammar.  Students haven’t learned to spell.  Ergo:

Cellphone texting and social networking on Internet sites are degrading writing skills, say even experts in the field.

“even experts” notwithstanding, how do we make the leap from an obvious lack of focused study on particular areas of language learning, and the increased use of cellphones, social networking, and the web?  Furthermore, how is it that these are degrading writing skills?

I have spent the past decade teaching software engineering to third and fourth year undergraduate students.  I teach in what is often thought to be an illiterate discipline (in addition to English and Greek philology, I also studied Computer Science, so I can speak from experience).  What does programming have to do with writing?  A lot (or should I say, Alot).

In my courses I expect students to do a great deal of writing and reflecting.  Students are asked to keep a blog, use Twitter, collaborate on wikis, and communicate in real time using irc.  My experience in doing this over the years is that students have a lot to say, are thinking in ways that help move the class forward when shared, and most of all, that they have much to teach the other students and myself.

Do I see them make mistakes in terms of punctuation, grammar, and style?  I do.  Do they see me do the same thing?  Most certainly they do.  But we’re all writing.  Can students write?  Yes, if you let them.  Yes, if you model writing, and reading for them.  One of my students asked me a few weeks ago if I’d ever done a word count on my blog.  I hadn’t but decided to try.  It turns out I’ve written the equivalent of 3 good sized novels since 2006.  I haven’t written a novel, though, and don’t expect I ever will.  Instead, blogging, Twitter, social networking, and the web have insured that I exist in a literate age, where writing every day is the new normal.  I would argue that if students were allowed to use the web more, they’d be in even better shape.  As David Eaves notes of his blog, “if writing is a muscle, this is my gym.”

I’m less skeptical of students’ ability to write than I am of the intentions of educators decrying the demise of writing.  When all we have of writing is a “simple test,” education is reduced to a set of questions you can use in order to substitute real reading and ideas for a bell curve.  We’ve seen “simple tests” before, and they often have very little to do with real writing.  Writing, like many worthy pursuits, is easily stifled by pedants, who confuse the rules of writing for writing itself.

This term’s UCOSP projects all seem to be going well so far: most teams are writing and committing code, and several teams have adopted code review as a standard practice. I’m really hoping that at least a few UCOSP students will make a bid for places in the VeloCity entrepreneur bootcamp this summer—it’d be great to see them take their ideas to the next level.

Elsewhere, though, things are not so rosy. The students in my CSC302 software engineering course had to hand in their first assignment last week. One team brought it in two days early (earning themselves two days of grace to use in future assignments), four of the others came in on time, and one team was a day late. That’s about what I expect; what I didn’t expect, and was disappointed by, was that two teams were tossing files back and forth by email, rather than using the version control repositories we had set up for them. This is triply frustrating because (a) they’ve all had to use version control in previous courses, and (b) the only way they can submit their work for grading is to commit it to their repo. Many of these same students are in their final term, and will be entering the workforce in just over three months; somehow, we just haven’t gotten through to them.

Coincidentally, my wife was up from midnight Saturday until 10:00 am Sunday babysitting a software deployment that ultimately had to be rolled back. She works for one of the largest IT consulting firms in Canada, and her team has updated the software in question several times in the past. It still took them seven hours to get to the point where they could tell that a few key things just weren’t going to work, despite all the pre-testing they and other teams had done, and another three hours to re-set to a working state. Michael Nygard talked at length in Release It! about how to not get into this situation, and I’ve thought more than once about creating an undergrad course to teach the necessary concepts, but realistically, if our senior students still think that version control is something you use once at the end of the project, and only because the prof says you have to, it’s clear there are higher priorities.

The concurrency.cc logo

I am excited to announce the release of Plumbing, software and documentation to support artists and makers in the programming of low-cost, open-hardware
platforms like the Arduino. The Plumbing libraries are a collection of parallel components written in occam-pi , a small language with a long history.

Last summer, we decided that it was time to bring six years of work regarding runtimes for parallel languages to the Arduino, a popular open platform for exploring the of art, electronics, and computing. In doing so, we decided that documentation would be critical in this effort. Documentation became a focus because we decided as a team that users matter. In designing and documenting Plumbing, we kept our focus on the students, artists, and makers who might do something amazing with our tools.

I think we’ve taken some substantial risks. Many people have contributed many thousands of hours of development time in our software (to say nothing of the years invested in occam-pi), and we will soon be releasing hardware as part of this effort as well. For me, the most substantial is the commitment to publishing our book, Plumbing for the Arduino, under a Creative Commons BY-SA license. That means that anyone can modify, distribute, and sell our work, as long as you give us credit.

Giving our book away is substantial because publishing is part of how academics are evaluated and keep their jobs. By giving away our book, we must now convince our respective institutions that publishing under the Creative Commons will force us to produce a better product (on an ongoing basis) than editorial review would, as well as reach more readers than if we found a publisher (who would then claim copyright over our creation). Or, we must find a publisher who is interested in helping develop and market our text while allowing it to continue to be available under a free and open license. (If you know one, please have them drop me a note to me at matt at concurrency dot cc.)

concurrency.cc and the materials made available from that site have been in development for years. I’m glad to finally see everything settling in place so people can easily download and explore the tools we have spent so many years working on. If you do, let me know how things go. (We’ll have mailing lists up soon, I promise… but for now my job as a professor calls, and it’s going to be a busy few days…)

Thanks to Dave Humphrey, GDK, and the rest of the POSSE crew. For months the encouragement to just release! has been kicking around my head. That message helped keep us on track as we reworked build systems, wrote text, built websites, and generally did all that stuff that no one thinks about when bringing a project together.

And we’ll get a Fedora RPM done as soon as we can. (In the meantime, you can build from source like the rest of us.)

Today I finished-up my work writing automated tests for the Processing.js parser and a full unit test infrastructure.  It has been an interesting bit of work, and resulted in a lot of good info.  Today I imported Ben and Casey’s sample code from their Processing books, and it was interesting to watch things pass and fail.

Of the 855 Processing files I tested today, 623 were parsed correctly (72%).  This leaves 232 that fail for one or more reasons.  It’s actually not as bad as it sounds, since there are six main errors I see over and over, for which I’ve filed bugs, and a bunch of other failures that are likely related to my python/js scripts.

I’m pumped to have some new students about to start writing tests and doing more investigations into these bugs.  At the same time, we’ve got a new project coming online to do an antlr-based rewrite of the parser.

If you’ve got Processing code that you want to make sure works on the web, let us know so we can add it to our automated test suite.

After a long, really long wait, AMD has released the next version 10.1 of its ATI Catalyst display drivers (fglrx) for Linux. The drivers can be download from ATI Catalyst™ 10.1 Proprietary Linux x86 Display Driver Page. As previous version turned out to be a big turn off for Fedora community and AMD took a long time for releasing this, I hope they have fixed issues regarding new Xorg version. Fedora folks will really want this version to work, otherwise there will be *blood* You have got AMD graphics card? What are you waiting for? Download the drivers immediately and test the damn thing! And please let everyone know whether it works for you with details of your graphics card. You know where the howto for installation is How To: Install ATI Catalyst (fglrx) Drivers.

I really hope that things turn out well and you don’t really get to this point. But if these drivers don’t work for you, proceed to the post Fedora 12 ATI Catalyst Drivers and checkout mesa-dri-drivers-experimental.

From the release notes for version 10.1,

Resolved Issues

• [ATI CatalystTM Control Center] Display Manager Properties tab now properly shows a single mode instead of multiple modes when big desktop mode is enabled.
• The operating system will no longer fail when switching between virtual desktops.
• [RHEL 5.4 32-bit] [ATI CatalystTM Control Center] System now functions properly after selecting “Detect Displays” button and hot-plugging a HDMI display.
• [Ubunut 9.10] X no longer fails after executing multiple Xserver generations with Xinerama enabled.
• Hotplugging a HDMI monitor or toggling between LCD and HDMI no longer causes the system to stop responding.

Know Issues

• [RHEL4-U8 32-bit] Corruption may be observed while starting Xserver on some ASICs.
• Corruption may be observed after 90, 180 or 270 degree desktop rotation on some ASICs.
• System may stop responding after switching to DC (battery) mode with CrossFireTM enabled and full-screen applications running.
• System may become unresponsive after executing specific combinations of XRandR reflections and rotations.
• The output log file may report the Engine Clock or Memory Clock values as 0 MHz on some systems.
• [RHEL 5.4][ ATI CatalystTM Control Center] Applying customized TV modes might not work properly, pop up message requesting restart will not appear and customized format will not apply.
• [Ubuntu 9.04 x86 64-bit] Some systems may become unresponsive during video playback with certain Dual Head configurations.
• [ATI CatalystTM Control Center] Specific customized modes under the HDTV page may fail to apply on some systems.
• [Ubuntu 9.04] With one DP monitor and one DVI monitor connected in clone mode, unplugging and re-plugging the DVI monitor may cause the system to deadlock.
• Xserver may fail to launch after enabling CrossFireTM and restarting on some ASICs.
• [ATI CatalystTM Control Center] Super Anti-Aliasing (16x) mode may not be available on some display adapters with CrossFireTM is enabled.
• Display rotation may fail to apply from ATI CatalystTM Control Center with desktop effects enabled.
• [RHEL] Enabling Xinerama may cause input devices (keyboard and mouse) to become inaccessible after restarting Xserver.
• System may fail to return to console mode after enabling all adapters and exiting Xserver for multi GPU configuration on some ASICs.
• ATI CatalystTM Control Center may report error when two displays of different maximum resolutions are set in clone mode.
• [SUSE 11.1 64-bit] Enabling CrossFireTM might fail with some ASICs
• Scaling setting changes may fail to retain after mode change, reboot or restarting Xserver.
• [SUSE 11.2 x86] CrossFireTM might not be functional under specific configurations
• [Ubuntu 9.10] CAL test “completemodulelist.txt” might not execute and throws segmentation fault.
• [ATI CatalystTM Control Center] Some systems may intermittently stop responding when changing the scaling options.
• [ATI CatalystTM Control Center] Applying “Size and Position” adjustments for Analog Monitors might not work properly.
• [Ubuntu 9.04] Some video cards may stop video output signals when monitor has been powered off.
• [ATI CatalystTM Control Center] Disabled display will become enabled after Xserver restart.
• Flickering corruption might be visible while running OpenGL applications with CrossFireTM enabled on specific ASICs.

Related Posts

• News: Will ATI Catalyst Drivers 9.12 work with Fedora 12?
• News: ATI Catalyst Display Drivers 9.9 Released
• How To: Install ATI Catalyst (fglrx) Drivers
• Info: ATI Drivers 9.8 Doesnt Work with Fedora 11 (2.6.29+)
• Info: ATI Drivers 9.7 does not work in Fedora 11 (2.6.29+)

Fedora Tutorials and Videocache by Kulbir Saini.

This event is the monthly open source business breakfast for the Ottawa area. The intention is to bring industry, government, academia, and community together once a month for an enjoyable breakfast of networking, good food, and a couple of short presentations. This event runs Monthly.

read more

Chamindra has organized a Quality Assurance team of volunteers to help with the testing of the Sahana-PY, the Python version of Sahana.  He’s posted a helpful overview of the bug-tracking process that pulls together all the information needed to get started. Here’s another view with a nice block diagram showing the flow of Sahana’s bug tracking process.

I’ve put together a summary page for students in our CPSC 110 class, who will participating in the testing activity as a class project.

Well, OpenSource is more or less about software source code and technology specific but OpenSource.Com scales beyond software and technology and provides a platform to discuss/learn/get involved/share.

From the website,

What problems can we solve? How would it affect the way we learn? Work? Run our governments?

We want to shine a light on the places where the open source way is multiplying ideas and effort, even beyond technology. We believe that opensource.com will be a gathering place for many of the open source stories we’d like to share–through articles, audio, web presentations, video, or open discussion.

Currently website has following five channels,

• Business
• Education
• Government
• Law
• Life

For more information, visit following links

• What is opensource.com?
• What should opensource.com be?
• What is the open source way?

If you want to participate, please visit How to participate?

Related Posts

• How To: Install PHP 5.3 on CentOS 5.1 or RHEL 5.1

Fedora Tutorials and Videocache by Kulbir Saini.

At OSS Watch, we actively promote that there is more to open source software than just a licence. Open source projects should use not just an OSI-approved licence but practice the open development method and if they want to become sustainable they should be building a community around their project. Once in a while, we come across a nice example of how the power of the community can be beneficial, and recently one of these examples occurred.

It started with an application that has been built by Nick Burch at the Apache Software Foundation to facilitate the search of geographically ‘nearby people’. He made this little Django application available via a Subversion repository with an Apache licence.

Linking people and projects is also one of the aims of the project registry framework Simal that OSS Watch is involved in. On Simal’s public demo site there is a collection of projects and people working on these projects. Besides doing development work on the Simal application OSS Watch is starting to use the registry more often in our daily work. Unfortunately, we recently failed to find out about a project that was run at our institution, Oxford University, even though it was present in our public registry.

When I realised Simal was lacking functionality that had been useful for OSS Watch, i.e. to find nearby projects based on location, I created issue 263 for Simal, dumping my thoughts about possible solutions, among which the ASF application on nearby people.

A key problem in adding this functionality was to have the geo-location data of the institutions that are in involved in the projects. This prompted Ross to reach out to his wider community to see whether anyone had tackled this issue.

The first and very useful suggestion on this matter was from Paul Stainthorp who pointed to a list of UK universities and their geo-location, which is maintained at Wolverhampton university.

The second one was from Sam Easterby-Smith who pointed to a list on Wikipedia. That was a good one, as Wikipedia is quite complete and geo-tagged, so we would have the data from that source if only we had a convenient way of extracting it.

The solution to that problem is to use DBpedia and it was suggested both by James, who added a comment to the issue in the tracker, and by Wilbert Kraan on Twitter. DBpedia is a community effort to extract structured information from Wikipedia and it provides a public SPARQL endpoint for querying Wikipedia data. We can conveniently query that endpoint for a list of the geo locations of al UK universities and add that data to our Simal repository.

So within one working day we have a solution to the main problem, getting the geo-location data. But Ross’s discussion with someone already doing this revealed that they are manually creating the data, so they can potentially benefit from our search and automate it, if they want to. Furthermore, someone on Twitter noticed our search and he indicated that he would be interested in the solution, so potentially more people and/or projects can benefit. Furthermore, since everything happened completely in the open, even more people have the opportunity to find our solution and use it in their own problem space.

To me, this is a perfect illustration of the power of community. There is just so much that we all collectively know and by having your project run out in the open, freely accessible by everyone, enables you to tap into the collective knowledge of many experts. If this is not a reason to use the open development method, I don’t know what is.

This is the story of my favourite kind of programming.  The kind of programming where you have a handful of existing tools, a bunch of data, and you need to make it all fit together somehow.  There’s no neat-shrink-wrapped-sofware-download-it-from-the-web way to do it (none of this stuff was meant to go together), so you start hacking your tools, abusing data formats, work in multiple languages, and otherwise get round pegs to slide smoothly into square holes.

Today’s fun comes as a result of the need for a test harness to drive automated tests for the Processing.js parser.  I tell it in large part to help my students see how one leverages open technologies and formats on the way to solving otherwise unsolvable problems.  There’s no button in Visual Studio for what we’re about to do here.

The story is set within the Processing for the Web project, which is making a JavaScript version of Processing.  The past few days we’ve been trying to track down some bugs related to the parser.  Right now, there is a clever hack in place to take Processing code, and using a series of regular expressions, turn it into pure JavaScript.  It’s a nice bit of code, and works pretty well turning the Java-style syntax into something the browser can understand.  It’s also very brittle.

What we really need here, and what Processing itself uses, is an antlr based grammar to build our parser on top of JS.  Processing basically subclasses the Java antlr grammar, and we could do the same thing, only use the JavaScript target.  Probably doing this in parallel to a parser-lite version in the browser, so that you could choose to create your pure JS Processing code once, and then include that in your web pages.  I’ve filed a bug, and some unsuspecting student is going to get the chance to work on it soon…

But!  before you can go reimplementing a parser, and before you can properly fix regressions in the current one, you need a proper test suite.  We really need a simple way to take valid Processing code, and make sure our parser produces valid JavaScript.  And we need it now, so we don’t break more code while we fix these bugs.  I debated making it a student project for this term, but Al convinced me that we needed it for the next release.  So today I wrote a test harness.

The problem is actually pretty simple, but automating it required some thinking.  I have a parser written in JS that is meant to be run in a web page, and I need to take lots of Processing code and run it through, some of which I want to pass, some of which I want to fail, etc.  In order to automate this, I really want to decouple this from the browser, and do it from the command-line.

A lot of these problems are already solved in the Mozilla context.  With Firefox we have a whole slew of testing frameworks and tools to drive our various automated tests.  To run a lot of these, we don’t need a full browser, just a JS shell that can execute our JS code and report to stdout.  I spoke with Ted today about our issues, and he recommended modeling it on how xpcshell tests work (i.e., js + python + makefile).

The first step was to take a directory of Processing files and turn them into something I could feed into a test harness running in the jsshell.  The jsshell can run the Processing.js parser, since it’s just JS, and as long as I can feed the Processing code in, I’m good.  There’s even a handy load() function I can use to get files into the jsshell.  However, what it loads has to be valid JS and Processing code is anything but.  I needed a way to trick the jsshell into loading the Processing code in so I could get it into the parser and tested.

I chose to use python, and decided to write it such that it would scan the test dir for all the files, and turn them into JSON strings, which I could pass on the command-line to the jsshell executable (i.e, ./js -e ‘{code: “x =7;\ny=5;\n…}’), along with my test harness scripts.  I then wrote my test harness in JS, which also loads the Processing.js code (i.e., the parser), and then I basically do this:

try {
  eval(Processing(canvas, processing-code));
  _pass()
} catch (e) {
  _fail()
}

The Processing function takes a canvas element (where the graphics will get drawn), and the Processing code, and tries to parse it.  What it gives back is pure JS, so we can use eval() to try and execute it.  If that works, the generated JS is good, so our test passes; if not, we fail.  But there’s another problem: the Processing code assumes there’s a canvas element and a DOM–basically, it assumes it’s running in a web browser as part of a page.  But we’re nowhere near a web browser when this runs, so we have to fake it.

The nice thing about JS is that you can create and modify objects, data, functions, whatever on the fly.  In my case, I needed to fool the Processing.js parser into thinking that it had access to various DOM functions and objects (e.g., document, setInterval, etc.).  My solution was to create dummy functions and object literals that could stand-in for the real thing.  The parser doesn’t actually need to call this code; it just needs to be there and non-null.  Here’s my setInterval implementation:

var setInterval = function() {};

Using this trick I was able to slowly write all the bits of the fake DOM I needed to get the parser running.  As I’ve tried running a few other larger tests, I’ve noticed other bits of the DOM I need to implement, but it’s pretty trivial to add them as I go.

I’ve filed a bug and am waiting for some feedback before a I fix a few more things and get it checked-in.  Once I do, I plan to find some other students to write a ton of tests to try and break the parser even more, and then file bugs so we can fix them.  Writing tests may not be the most fun you can have, but honestly, writing a test harness is pretty close.

The Sahana community has been furiously active in response to the devastating earthquake in Haiti. Their Haiti WIKI describes their activities and provides a summary of volunteer help that is needed. You can follow their activities online on the freenode #sahana IRC (Internet Relay Chat) channel, which is accessible  through the web on http://www.sahana.lk/chat.

Sahana is deploying both a PHP/MySQL version of their system (the one which includes the VM module developed by students in the HFOSS project) and a newer Python version.  They have called for volunteers to help with all aspects of the project, from coding to testing to data entry.  Details on the data entry and bug tracking work can be found here.

This project contains code for a video capture utility capable of capturing presentations. It captures vga output and audio and mixes them together to produce a video thus enabling you to capture great presentations, demos, or training material easily.

This software has been used to record great open source events including hundreds of talks at great conferences like OSGeo's FOSS4G, FSOSS, and more.

Features:

read more

Running an open source project without a governance model is like building a house without plans: a recipe for disaster. A governance model describes how a project is managed and how third parties can interact with that project. In particular, it describes how decisions are made within the project, the ground rules for participation in the project and the processes for communicating and sharing within the project team and the community.

The community is the lifeblood of the project and as such should be protected and nurtured. One of the most important aspects of this is the licensing of the project. There are several types of open source licence available; the choice will depend on the future plans for the software.

Contrary to the traditional concept of a licence, open source licences are designed to increase rather than restrict the freedom of the licensee, to encourage contributions to its functionality by modifying the source code. The GPL, for example, is a copyleft licence designed to ensure that the code it covers remains free and open source by dictating that derivative works, should they be distributed, inherit the same licence as their parent project and cannot be incorporated into non-FOSS products. At the other end of the spectrum is the permissive licence, such as the Apache Software License. Unlike copyleft licences, it allows the inclusion of FOSS in non-FOSS projects and the licensing of derivative works in any way the distributor pleases.

What implications does the choice of licence have on community development? Copyleft licences may restrict the uptake of the code, and therefore the size of the community, because of their ‘viral’ nature: they are seen to ‘infect’ all derivative software with the same restrictions, thus limiting the business models available to projects building on that code. Since copyright holders have additional rights over licences, centralised ownership of copyleft-licensed materials can add additional community concerns because of the scope for ‘abuse’ of that community. Witness the case of Oracle’s planned buyout of Sun, which would make Oracle the exclusive holder of the open source MySQL copyright and trademark. This could have potentially damaging consequences for the project’s future, and possibly result in higher prices for database software.

Permissive licences, on the other hand, encourage greater uptake of the software and wider participation from outside the project because they don’t dictate terms under which derivatives can be distributed. Thus, relinquishing control over what can be done with the code fosters community development, which in turn increases the opportunities for innovation. Permissive licences allow almost any business model except dual licensing and are therefore more appealing to commercial developers.

The contrast between copyleft and permissive licences is illustrated by SpringSource’s recent decision to move from the GPL to the Eclipse Public License (EPL) for its OSGi application server. The company originally chose the GPL because, in the words of CEO Rod Johnson, ‘there’s a lot of technical innovation under the hood [and] if we’re giving that technology away in open source, we wanted others who build on it to also give away results in open source’. The move to the EPL suggests that the company recognises the value of a wider adoption of their technology through more permissive licensing and collaborative community development.

However, permissive licences don’t ensure the ongoing freedom advocated by Richard Stallman, which underpins the FOSS philosophy. Significantly, though, Stallman is himself beginning to accept that they are sometimes necessary, as evidenced in a recent article in which he admits to having mixed feelings on selling licence exceptions. Could this shift in Stallman’s thinking be evidence of a fundamental change in the broader licensing landscape?

There’s a great post over at Mashable by San Francisco mayor, Gavin Newsom, on the city’s new open source policy.  In it he discusses the democratic, fiscal, and technical advantages of open source.  He writes:

One of the greatest technology changes of our times is the rise of open source software…Open source software is created by the people for the people and as such is ideal for government. To that goal, I am extremely proud to announce today the nation’s first open source software policy for city government.

San Francisco’s new policy requires city departments to consider open source software equally with commercial products when purchasing new software. The opportunities with open source are tremendous: lower costs, greater agility, better reliability, improved security, and increased innovation.

Under the leadership of our City CIO, Chris Vein, and the Department of Technology, we have witnessed the benefits of open source with shorter implementation times and lower costs. We have seen this with my web site, DataSF.org, RecoverySF.org and our 311 integration with Twitter.

This week I’ve been introducing our students to open source, and a lot of our discussions have focused on how open source isn’t a fringe movement anymore–individuals use it, big companies use it, and governments use it.  As government budgets continue to shrink, and fiscal responsibility becomes front page news again, open source is being discussed by an ever increasing number of people.  Developers in San Francisco have long understood the value of open source on a technical level, but it’s another thing when the mayor’s office gets in the game, too.

If you’re interested to watch this same phenomenon happening in Canada, keep one eye on David Eaves.  Hey Mayor Miller, where’s our open source policy?

My talk at CUSEC starts in 15 minutes; to calm my nerves, I’m catching up on my blog :-). Here are where students are from:

Some time ago I posted “Does it take a disaster to understand the power of open development?” Unfortunately it is now time to revisit that post with a call for software developers to help Haiti.

The Sahana Software Foundation are looking for additional developers to help with Sahana, a disaster management tool. They need to continue to build an information portal that is seeing increased interest and usage to assist organisations responding to events in Haiti. Information on the work underway can be found on the Sahana Haiti response Overview page.

The skills they are primarily looking for are (you don’t need them all, any will do):

•  Python - the main development for SahanaPy is Python (we’re not using PHP for this instance)
•  web2py - Sahana uses the web2py enterprise framework for SahanaPy (I’m told it is fairly easy to learn if you’re used to Django)
•  OpenLayers
•  jQuery

To find out more and offer your help please jump onto #sahana on freenode. Please give as much or as little as you want.Some of the core devs have been working really long hours the past 5-6 days, and any additional resource would assist us greatly, particularly as the effort is really starting to get some interest, traction and coverage, which leads to more and more feature requests.

Thanks for reading this far - please consider giving a few hours of your time to help out, if you can.

Challenges and opportunities related to serving GIS via Mobile phones: Review from a developing Nation's perspective by Nimialika Fernado

read more

I’m working with an ever growing group of web and Mozilla developers, along with some talented audiophiles, on a project to expose audio spectrum data to JavaScript from Firefox’s audio and video elements. Today we bring out the demo reel.

Last time I wrote about our success getting the browser to make dynamically generated sound.  Since then we’ve continued our work to expose and use raw audio data, and it has produced some delicious demos.  Today I finally got setup to record some of them and show a bit of what’s possible.  NOTE: I’ll provide links for all of these, but you need a patched Firefox to see things happen.

The first demo is a visualization of audio spectrum data using the C++ FFT code (the one Corban did before was done with JavaScript).  This particular song is perfect for demonstrating beat synchronization, wave changes, etc.  Al MacDonald wrote both the code and music (click here to watch video):

The second demo shows how the <video> element can be used in the same way as <audio>.  In this video of whales singing to one another, Al once again visualizes the spectrum data, but this time in 3D, and overlays it on the <video> element using <canvas> (click here to watch the video):

The third demo shows both visualization and dynamic generation of audio using JavaScript. In this demo an oscillator module generates a signal which is sent through a Low Pass filter and ADSR Envelope and then written to an <audio> element. The demo was created by Corban Brook, who also wrote the PJSAudio library especially for the task (click here to see the video):

For my part I’ve been busy thinking about how to rewrite my browser implementation so it is done properly.  In the third demo you’ll hear some static, since I’m not doing any buffering, which we need in order to deal with latency in generating the audio frames.  I’ve got a number of email threads going with people who can help me figure out the API and implementation directions.

In addition to working on code, we’ve also been chatting about the other things we might do with audio in the browser.  Here are some of the ideas that have come-up:

Audio Data and Experiencing 3D

As WebGL gets closer to being released, I’ve been thinking about accessibility within 3D scenes.  Reading this inspiring article about a blind architect, it made me think about sound in a new way.  I’ve got students right now working on light and cameras in 3D web environments, but what about sending sound in too?  What if you dynamically sent sound into a 3D scene and had it echo back to you, such that you could judge depth, objects in front of you, different materials, etc.  Doing this well requires dynamic transformations of the sound, which is exactly what this work is making possible (Corban’s demo shows the first steps).

Audio Data and Seeing Sound

Still on the subject of accessibility, I’ve been thinking about sound data, and especially the visualization of sound, for those who can’t hear it well, or at all.  One of my colleagues first got me thinking in this direction.  She can’t hear a lot of the sound her computer makes, and is often unaware that web pages are even making sound.  In cases like this, it would be great to have even simple indications that there is sound, how loud it is, etc..  Taking this further, one can imagine exploring ways to make the browser more like the Emoti-Chair or other similar devices, which bring the experience of sound to those who can’t hear it.

Audio Data and Programmatic Approaches to Music

Then there’s the possibility of making music specifically for this medium.  We (I’m thinking of people like me who can’t play instruments) tend to think of music as a consumable end-product vs. something you build or assemble.  Music is something you buy, something you download, something you play.  That’s what text used to be, too.  But putting text on the web, and specifically, assembling text using code, changed that forever.  Just as we mix text from different sources, dynamically overlay it, transform it, translate it, etc., what if you could listen to music being mixed and altered live in your browser?  What if music was one part drum loops and one part repeating sample and both were written in JavaScript?  What if those got layered over audio being played from an .ogg file, or got mixed into something happening in a video?  What if the music was changed in response to what you were doing in the page?  When music becomes algorithmic, scriptable, and composable, any number of new things will happen.

This portion of our experiments has really been about imagining what you might do with something new.  The browser hasn’t traditionally been the place where sound gets made.  But what if it was?  How would music adapt to its new surroundings?  What would we expect of it?

I’ll leave you with a quotation from a recent interview with Brian Eno, as he talks about the synthesizer, and innovation in music and sound.  When he says ’synthesiser’, replace it with ‘browser’ in your mind, and think about it for a moment:

One of the important things about the synthesiser was that it came without any baggage. A piano comes with a whole history of music. There are all sorts of cultural conventions built into traditional instruments that tell you where and when that instrument comes from. When you play an instrument that does not have any such historical background you are designing sound basically. You’re designing a new instrument. That’s what a synthesiser is essentially. It’s a constantly unfinished instrument. You finish it when you tweak it, and play around with it, and decide how to use it. You can combine a number of cultural references into one new thing.

I meant to post this earlier but was hit with a nasty cold bug that clobbered me - the good news was my hair wasn't infected. The bad news was nearly everything else was.

This is a brief retrospective of what FOSSLC did in 2009, and a look forward to 2010.

Our original goals for 2009 were:

read more

Like many of you who will take the time to read this, I have spent the last decade or so using great software from open source projects. I chuckle when I think of the weekends I lost in the early days fighting to get my XF86Config file tweaked just so, get my new network card working with bleeding edge code, or squeeze out that last drop of performance from my creaky old computer. Along the way I found I was drawn to learn from experiences building and nurturing community. I enjoyed writings and talks from people like Linus Torvalds, Mike Milinkovich, and many others since. I have learned a lot from them and developed a very healthy respect for what they do. They are the masters who make a complicated job of community/ecosystem building look easy. I wanted to share some lessons learned thus far from my own modest efforts, or at the very least, a few thoughts I consider important stated in my own words.

read more

On 7 December 2009 OSS Watch hosted a mini conference in Oxford, at the University Club. There were two workshops running concurrently, one on Open Source, Open Development and Open Innovation, which we wrote about last month, and the other on Building an Engaged Community, which is the subject of this article. During the workshops we ran a live blog for remote attendees; you can see a transcript here. Amir Nettler of OSS Watch covered the morning sessions and I picked up the reins for the afternoon.

The workshop was introduced by Steve Lee, who gave a high-level overview of the topic, focussing on the open development model and what a strong community looks like, as distinct from the open source code that they may be working on. The need for a wide and diverse community of contributors was stressed: not just programmers but contributors with all skills are important, including artwork, marketing, testing, documentation, etc. A good community should be able to sustain itself and cope with people leaving and new people joining. The key to this has to be transparency: all the history and previous decisions should be open for new contributors to review, which will prevent settled issues from being re-raised by people who missed the original discussion.

The licensing and legal considerations of an open project are very important for the community. Contributors need to be sure they have the legal right to give their contributions to the project and if necessary modify the terms of non-disclosure agreements or contracts of employment that could otherwise cause problems down the line. Some projects have contributor license agreements to protect the provenance of contributions; this is something a new project should seriously consider. To provide more information on this OSS Watch has produced a briefing paper on contributor licence agreements.

There is a wide range of free and open source tools for managing a distributed community-based open development project. Most community projects have some kind of shared communication system such as a mailing list or forum; critical to this is the history or mailing list archive being publicly available to new contributors. If the code is open but the communications are closed, the community will struggle to grow. A version control system should be used right from the start of a project to track who contributed which bits of code. A structured system distinct from the project communication system is used for tracking bugs.

Sebastian Brännström of Symbian treated us to a beautifully designed set of slides for his presentation, on how Symbian is moving from a very closed platform to an open development model. Sebastian has written open source software to run on Symbian and now works in delivery management for the Symbian foundation. In terms of governance, the foundation is set up as an independent not-for-profit organisation, which facilitates development but doesn’t actually do development as part of its activities. The foundation started with 12 member organisations, which has now risen to about 180, and has 90 employees. In order to give structure to the governance of such a large project it created four councils to control different aspects of the platform: features and roadmap; user interface; architecture; release management. An interesting aspect was the deliberate selection of structures that make it easy for anyone to influence the direction of the project, not just the larger members such as handset manufacturers.

Sander van der Waal told us about his work with the Apache Felix project. Apache Felix is an implementation of a standard framework called OSGi which defines a modular system for Java applications which amongst other things allows parts of a system to be updated whilst it is running, a powerful feature for highly reliable applications. When Sander got involved in Apache Felix it was in the Apache Incubator, which is a part of the Apache project where young projects are guided through the community building process. His project team started by reading and following the mailing lists for some time before joining in. They found it important to keep all communication on the list. This included communication between colleagues, even where a direct communication option was available, as it was better to keep it to the list so that the information could be shared and archived. Sander went on to explain how the integration of an issue tracker and revision control system is used in conjunction with a mailing list, allowing visibility of who contributed each line of code and which issue each change addresses.

Mark Johnson of Taunton’s College gave a talk on getting started in joining a community from a development perspective. Mark started contributing bug fixes to the Moodle virtual learning environment and took us on an introspective tour of the sequence of events as he progressed from using and administering a Moodle installation to being a part of the community that produces it. Collaboration is an important aspect of open dev, and Mark thinks, if done properly, a collaborative development process produces the best results. As well as raising his personal profile, Mark has benefited from the quality checking and motivation that working with others provides. Mark went on to warn of the dangers of over-collaboration: soliciting opinions from too many people leads to confusion, and bad design. He suggested limiting how widely you consult in discussion phase, produce a prototype/proposal and then have that critiqued; the existence of a tangible contribution limits how widely people’s suggestions can range. You don’t need to please everyone all the time, the objective is writing great software and some healthy disagreement and debate is a part of this.

Steve Lee then kicked off a session on evaluating the openness and sustainability of open source projects using an online form developed by OSS Watch.

This was an audience participation activity, which gave me a bit of a break from the live blogging and a chance to take a quick photo of the audience as they gathered in clusters around an assortment of laptops. I counted three Macbooks, four running some kind of Linux, and three on Windows. Everything points to a more diverse computing landscape over the next few years, with different devices talking to each other using open standard protocols and formats.

I found the results of the activity very interesting in that the audience had no problems choosing projects they were working on or in their own specialist area of interest. Nobody attempted to evaluate the projects with the broadest appeal, such as Firefox and OpenOffice.org. I think this, and the range of resulting scores, points to the evaluation having good practical value for the OSS Watch sector.

The event closed with a panel session in each room, I will pick out a few topics that were covered; there is more in the transcript. The first questions were “Should a project accept all contributions” and “does it matter if a contribution is ignored?” All the panel members stressed the importance of managing contributions and responding to contributors; if a contribution is not used it is critical to provide feedback so that the next contribution meets the required standards for acceptance. Sebastian Brännström said that taking contributions seriously was critical to keeping users and the community happy.

The discussion moved on to the issues faced by smaller projects with a team of core contributors. In order to increase the number of active contributors projects should focus first on increasing the number of non-contributing users and lower the barriers to new contributors, helping users progress to being contributors.

The final question was “What pub are we going to?” the answer to which turned out to be the “Far From the Madding Crowd” where discussions continued into the evening.

Are you interested in widget development and do you want to learn how to build widgets that use the new open W3C widget standard? OSS Watch is organising an Apache Wookie (Incubating) training day in Oxford, UK on 11 February 2010 for developers who would like to get hands-on experience with building widgets using Wookie.

Wookie provides an implementation of the W3C widget standard and allows you to write, deploy and manage W3C compliant widgets easily. The project is also working on implementing extra modules, such as a Google Wave Gadgets API. To increase cross-platform interoperability, several plugins have been written to integrate with other systems, such as Moodle and Wordpress.

This event is free of charge and invitation only. However, we have three open places left for interested developers. General development skills are required, but you don’t need to have specific experience in building widgets. If you are interested we welcome you to contact us on info@oss-watch.ac.uk and let us know why you should to be there. If you would like to know more, details about this all day event can be found on the event page.

One of the reasons we hold this event is in preparation for the dev8D developer days. During that event we will be doing more widget development in a Wookie hackathon and we want to gather some more skilled widget developers for that hackathon. Therefore we expect people who come to the Wookie training day to also attend the dev8D days. However, don’t hesitate to contact us for the Wookie training day if you can’t make it to dev8D.

The recent launch of the new JISC TechDis toolbar sees the introduction of an accessibility tool for students and others when accessing the web. This replacement for the previous TechDis toolbar increases the accessibility of almost any web site by running directly in popular web browsers, and provides features like text to speech of page content.

One important feature that may not be obvious from using the toolbar, is that the Accessibility Team at the University of Southampton Learning Societies Labs, developed the toolbar for TechDis while also making it an open source project.

By supporting this TechDis have increased the opportunity for sustainability by allowing the project to continue to evolve while attracting contributions from others, whether they are users submitting bugs and feature requests, or development teams interesting in using it in new applications. OSS Watch’s advise on open development practices has enabled EA Draffan to include these in her management of the project. In addition Seb Skuse, the lead developer, has used established open practices in his daily work on the project.

Seb attended one of the OSS Watch workshops on engaging with open source and found what he discovered useful in ensuring barriers to contribution are been minimised. The Accessibility Team have been heard to say that they enjoy working on an open source project and I am impressed with their eagerness to understand and apply the principles.

Working with them has been a very positive experience. They are undoubtedly a group to watch as they steadily increase their portfolio of open accessibility projects with wide application. Tools that demonstrate open innovation in provision for users of accessibility in education and beyond, by turning new ideas and research into solutions which provide practical benefits.

Download and try the Toolbar and let the team know what you think. You will find the team most welcoming of your ideas or other contributions.

GeoShield: server side user permissions management for OGC services by Cannata Massimiliano and Antonovic Milan

read more

Shortest path search for real road networks by Anton Patrushev

read more

I’m working with a group of web and Mozilla developers, along with some talented audiophiles, on a project to expose audio spectrum data to JavaScript from Firefox’s audio and video elements. Today we teach the browser how to sing.

Our experiments to expose audio data to JavaScript have really started to get exciting.  Since I last posted, a number of new features and demos have been created, and our group of developers has continued to expand.  This was greatly helped by the fact that the story was picked up by Ajaxian, Hacker News, and Reddit.  If you’d like to help us experiment more, please get in touch.

Previously I linked to a video of a demo made by Corban Brook, in which he uses JavaScript to calculate an FFT, and then visualizes the resulting spectrum data.  After this test we wanted to see how expensive these calculations were in script, so I ported his code to C++ and stuck it into the audio element’s decode loop.  A number of people have expressed concern over the idea of doing this in JavaScript and the cost in terms of speed and time you could spend on other work (e.g., complex real-time graphics).  Therefore, I wanted to have a good way to compare speeds.  I’ve already received feedback in the bug that native FFT calculations probably aren’t warranted, and we should optimize the JavaScript case.  I anticipated this, and having been involved with as much 3D in the browser as we have, I know that JavaScript is up to the challenge of doing very fast calculations.  As soon as I convert over to the faster WebGL arrays I’ll do some tests comparing JS-FFT and Native-FFT so we have better numbers.  In the mean time, the C++ FFT is working really well, and a number of new visualizations have been done with it, including this one by Thomas Saunders.

Another thing we’ve got working is generating and writing audio directly from JavaScript.  So far in these experiments, I’ve been focused on creating a real-time event with raw audio data.  I did this in response to the various Flash and other audio developers who have all told me they need some way to get data as it’s being played.  Now that this is working well, I decided to turn my attention to what Vlad suggested in the bug, namely doing a get/set style method.

I’ve been stumped on the right way to do this for a while.  Actually adding the method is pretty easy.  What I’ve been trying to think through is how you deal with the linearity of audio, and the fact that unlike a canvas (which also lets you do a get/set) the audio data isn’t necessarily there to get (e.g., it is yet to be downloaded/decoded).  I’m sure there are good solutions to these problems, but they’ve eluded me thus far.

I ended-up chatting about it with Rob Campbell and Ted Mielczarek, and together we hatched a plan: what if, for the sake of experimenting, you just added a “write” method, and let JavaScript dump raw audio?  Imagine an <audio> element with no source, totally controlled by JavaScript.  Since I already have an event that gives data as it’s decoded, it would then be possible to have one audio element decode, get the data and transform it somehow in script, then dump it into a second audio.  Is this the right way?  Probably not (the implementation is completely wrong no matter what).  But it was simple enough to do a Friday-afternoon-evil-hack and write a patch.  So I did.

I added two new methods to audio/video:

• mozSetup(channels, rate, volume) // called to create the audio stream
• mozWriteAudio(buffer[], bufferCount) // called to write buffer to the stream

Ted then wrote a simple Tone Generator, and Al MacDonald took that and wrote what I believe to be the first ever HTML document that can play scales using nothing but JavaScript (seriously, check out the source for yourself)!  Here’s a video of it in action:

Next time I hope to show some other demos that my colleagues have created or are creating now.  It is ridiculously fun to iterate on this stuff.  That’s partly due to the fact that I’ve got such a talented group of people working with me.  But it’s also due to how “hackable” this code is to begin with.  The fact that we can go from a back-of-the-napkin idea and then turn that into a working (if somewhat evil) patch in a couple of hours speaks to how well this stuff was written in the first place.  There’s a good discussion going right now about View Source, and how important it is.  What we’re doing in these experiments is View Source all the way down: we work in terms of HTML5 and the Open Web, but underneath is this amazing browser and platform, and underneath that the audio lib, etc.  The only thing that enables this kind of experimentation and collaboration is the existence of View Source, and the kinds of communities that can form around it.

GeoServer application schema support: complex features for the masses by Ben Caradoc-Davies

read more

Along with the cross-country capstone projects I’m coordinating this term, I’m also setting up six projects for the students in my CSC302 software engineering course (the first four of which I mentioned in an earlier post):

1. Adding pivot tables to Gnumeric.
2. Upgrading PyLint.
3. Converting the Selenium IDE to a plugin architecture.
4. Improving the SpatiaLite GIS extensions for SQLite.
5. Porting Django to Python 3.
6. Helping with ILUTE (the Integrated Land Use and Transportation Engineering tool).

10-11 students will be working on each; it promises to be an exciting term.

For the past month I’ve been working with some audiophile friends on a project to try and expose audio spectrum data to JavaScript from Firefox’s audio element.  Today I finally have something more than raw numbers to show off.

When I last wrote about our experiments with the <audio> element in part V, I had successfully written a patch to add a new DOM event (onAudioWritten), which is dispatched every time a frame of audio is decoded (this works for <audio> and <video>).  I make this raw data available via a list type object called MozAudioData, which exposes .length and .item() for accessing the data in script (I’m hoping to move to the new WebGL arrays as soon as Vlad lands them).  As I finished up for holidays, I made a very crude but promising demo that proved things were working:

Now it was clear that the data could be had, but we wondered whether it was possible to consume it fast enough in js.  Corban Brook decided to try, and wrote a Cooley-Tukey FFT algorithm in JavaScript to work with the raw data in real time.  He then wrote a very cool visualization in Processing.js, and the end product is nothing short of amazing (you have to see this video demo of it running on Vimeo to get the full effect):

I want to do some more work to see what moving the FFT into C++ would mean in terms of performance.  Having the ability to do even more complex analysis or visualization (imagine real time speech-to-text coming out of <video>) in script is our goal.  I’m also starting to wonder about how best to add write capabilities to go with this read-only version.  Imagine being able to do equalizing, filtering, etc. on the audio from script.  I have no idea how to tackle this yet.

It’s been fun working with these guys who know so much about audio.  I know almost nothing about the data I’m extracting, and it’s humbling to learn from them.  We’re approaching the point where input on API design would be useful, as I get this patch in better shape for review.  If you’d like to get involved or try it out yourself, drop into irc.mozilla.org/processing.js, where we are working, and join the discussion in the bug.  I’ll continue to blog this series about our work, and I know the others are working on posts and more demos, too.

For quite some time OSS Watch have been trying to put together an article examining Microsofts approach to open source. Today we welcomed the new year with the publication of “Microsoft: an end to open hostilities?“

This has been a very hard piece to write. We felt we needed to talk to as many people as possible, we needed to sift through  significant amounts of Fear Uncertainty and Doubt along with unnecessarily emotional responses.

Things weren’t made any easier by the fact that every time we felt ready to publish something else heppened that seemed to change the story somewhat and we had to return to our sources for more observations.

During our research for this article OSS Watch have been accused, by an OSI board observer and ASF Member, of being “surrogates” for Microsoft, whilst Tony Hey (Corporate Vice President of External Research, Microsoft) privately expressed concern that OSS Watch was “encouraging academics to use the GPL.” Simultaneously, various free software representatives have pointed out how “naive” they believed us to be by even considering the idea that Microsoft may have genuine intentions with respect to engaging with the free and open source community.

As a non-advocacy advisory service we tend to think that if all sides in a debate believe we are in the wrong, yet all are still talking to us, we are probably doing something right. Certainly none of them can claim us as their own.

Given all this input what did we conclude?

Well, as you would expect, the conclusion is far from clear. On the one side we have the Stallman’s (Free Software Foundation) view that “these free programs are meant specifically to prevent the world from freeing itself from non-free software”. On the other side we have Erenkrantz’s (The Apache Software Foundation) view that “every positive and constructive engagement Microsoft has with the open source community (and vice versa) … will continue to chip away at the old perceptions”.

Furthermore, whilst Microsoft may be making concessions to open source and are happy to play with open source when it suits their needs they are also willing to use other methods where it best suits their business. For example, on patents Darren Strange (Head of Open Source Engagement, Microsoft UK) says “Patents drive innovation and they drive openness actually.”

Our own conclusion is that “Microsoft is not simply an unchanging monolith.” The article demonstrates that things within Microsoft are changing. Naturally they are changing in ways that benefit Microsoft as a business, but the good news is that some of these changes also benefit the world of free and open source software.

Over the years I have often quoted Ghandi when looking at Microsoft and their relationship with Free and Open Source Software: “First they ignore you, then they ridicule you, then they fight you, then you win”. FOSS has not “won” yet, but the frontline is moving and it is open source software that is winning.

The field is becoming increasingly crowded: the second edition of Al Sweigart’s Invent Your Own Computer Games With Python is now available.  It’s aimed at kids and teens, but doesn’t condescend — I’m looking forward to going through it.

A lot of work has been done to implement the proxy for the proposed hybrid-based architectural scheme for HTTP Session Mobility. I blogged about the proxy some weeks ago. Here are the blog posts on the proxy [1, 2]. I referred to the services the proxy offers as control services. The services include Web forwarding and Web blocking. Today, I am pleased to introduce the proxy User Interface (UI). Below is a screenshot of the proxy UI.

The TransferHTTP Proxy Interface

The TransferHTTP proxy interface shows the SIP URIs of two Web browsers interacting with each other. In addition, It indicates the SIP Method in use, the time of the interaction, the status or action taken by the proxy and the referred URL.The interaction refers to a content sharing or session handoff between any two Web browsers. It could also be a multimedia session between the two Web browsers. The referred URL is the Web address the initiator of the content sharing or session handoff wants the other person to visit. The status or action taken by the proxy could be forbidden(i.e. blocked) or proxied (i.e. sent). When the status is “proxied,” it means that a message is sent to the intended destination as specified by the initiator or a message is forwarded to another Personal Computer (PC) as specified by the intended recipient.

Currently, the proxy blocks requests from sip:blocked-sender@127.0.0.1 and sip:blocked-sender@testdomain.com. On the other hand, it forwards requests meant for sip:receiver@127.0.0.1/sip:receiver@testdomain.com to sip:forward-receiver@127.0.0.1/sip:forward-receiver@testdomain.com. All other requests are proxied to their intended destinations. Requests, here, refer to SIP MESSAGE and SIP INVITE methods from a Web browser that has the TransferHTTP extension installed.While content sharing and session handoff in the extension use the SIP MESSAGE method to transfer session, make a call in the extension uses the SIP INVITE method to set up a multimedia session.

The Web address of the proxy is http://137.158.125.245:8080/session-blocking-app/. I am currently working on the Web session pick-up feature.With the pick-up feature, a registered user would be able to view all interactions and could reload URL(s) on his PC. The feature comes handy when a user wants to reload a URL that was sent to him in the past. In addition, the feature will be useful when a request is sent to a PC, but the PC is off at that time. With the proxy being able to report all delivery errors, a user would be able to pick-up a session transfer request from a number of requests when he switches on his PC and logs in to the proxy.

#!/bin/sh
chcon -t textrel_shlib_t '/usr/lib/chromium-browser/libmedia.so' 
chcon -t textrel_shlib_t '/usr/lib/chromium-browser/libnacl.so' 
chcon -t textrel_shlib_t '/usr/lib/chromium-browser/libsandbox.so'
#to make the change permanent 
semanage fcontext -a -t textrel_shlib_t '/usr/lib/chromium-browser/libmedia.so' 
semanage fcontext -a -t textrel_shlib_t '/usr/lib/chromium-browser/libnacl.so' 
semanage fcontext -a -t textrel_shlib_t '/usr/lib/chromium-browser/libsandbox.so'
#

[chromium]
name=Chromium Test Packages
baseurl=http://spot.fedorapeople.org/chromium/F$releasever/
enabled=1
gpgcheck=0

Greg Wilson recently posted about student learning, specifically with respect to studying from their own lecture notes. He received some advice from Brock MacDonald at the Writing Centre at Woodsworth College. Brock gave Greg some very bad advice about qualitative research, based on what Greg passed on in his blog (emphasis mine). Here’s some of Brock’s advice:

Empirical evidence for the value of students writing their own assignment specs is harder to come by, because it’s less amenable to direct testing (like most aspects of teaching writing)–the support is more qualitative than quantitative, hence more open to question.

…

both Elbow and Bean refer to quite a bit of supporting research, though as I said it’s mainly qualitative.

Let me set the record straight here: qualitative methods are excellent research tools. They can be applied correctly or incorrectly in any given situation, and the analysis of a qualitative study can be carried out poorly or it can be performed with skill. Qualitative methods give us access to the why of social settings things in a way that statistical methods are hard pressed to do with any rigor whatsoever. Put simply, qualitative and quantitative methods both have a place in research, and we should no more dismiss one than the other.

For Brock to say that a piece of research is “open to question” simply because of the methodology used demonstrates a lack of understanding of the methods involved. We do not evaluate research simply based on the methods used, unless the method employed is inappropriate to the question being asked. We do not consider either qualitative or quantitative research to be flawed unless the method was inappropriately applied or analyzed. And that is not what Brock said in his note to Greg. He just implied (strongly) that the research was questionable simply because it employed qualitative methods.

Peer reviewed qualitative research is not “open to question” as a general rule. (Or, it is always to be challenged… but that is ideally a challenge issued by experts through another research study.) Qualitative research has rigor, and clearly addresses the questions asked in the context they were asked. Unless you’re going to develop expertise enough to evaluate the research in question, accept it as having been executed by people with expertise, undergone peer review by experts, and see for yourself what the research says to you about your specific educational context.

The last two times I’ve taught a regular classroom course on software engineering, I’ve had students make up the lecture notes and assignments. Instead of creating PowerPoint slides and posting them on the web, I’ve lectured with chalk and a blackboard. In each lecture, a group of 3-4 students have been responsible for turning what I say into a wiki page, which then counts toward the 5% “writing requirement” of their course grade. I’ve done the same thing with assignment: after the whole class spends classroom time discussing what should and shouldn’t be in scope, a team of students writes it up and posts it for comment and clarification.

I’ve been pleased with the results, but unfortunately managed to misplace my links to the papers that gave me the idea of trying this. I’m therefore grateful to Brock MacDonald, of the Academic Writing Centre at Woodsworth College, for sending the following:

The most thorough empirical studies of student note-taking were published in a series of papers in the 80s and early 90s by K. A. Kiewra, alone and with various collaborators. They found that students who made and studied their own lecture notes achieved consistently better test results than students who studied from notes they were given. An interesting wrinkle is that students were found to do best of all when they were given a lecture topic outline or matrix of some kind to fill in with their own detailed notes—in other words, student note-taking that’s framed or guided by limited input from the instructor leads to better results than either a) students making notes completely on their own (though this gives the 2nd best results) or b) students being given the lecture notes and not making notes of their own at all (which gives the poorest results).

Empirical evidence for the value of students writing their own assignment specs is harder to come by, because it’s less amenable to direct testing (like most aspects of teaching writing)–the support is more qualitative than quantitative, hence more open to question. The idea most often comes up as part of discussions of critical-thinking- and active-learning-oriented writing pedagogy, e.g., in Peter Elbow (his book Writing Without Teachers and many articles) and John Bean (his book Engaging Ideas); both Elbow and Bean refer to quite a bit of supporting research, though as I said it’s mainly qualitative. The value of students developing the skill of formulating good questions in general (i.e. not only in the context of devising assignments) is also supported in some of the literature on learning objectives and outcomes, e.g., in several articles by Mike Carter, some of which present case studies that show the benefits of building this skill into entire course and program curricula.

We have updated the site to the latest version of drupal and latest patches including for contributed models. We tested the site and everything seems ok. If you notice anything amiss, please contact us through commenting here. Thank you.

After all was said and done, about 15-20 people from all over the country and here at RIT participated in a nationwide event focusing on the leading priorities of the Public Information Economy; Access, Openness and Transparency. This Hackathon was so in mode with initiatives from the highest governmental levels of the Transparency Movement.

• Somebody to implement a “mw status” command in mw so I don’t have to think about it
• Somebody to fix this dastardly python-mwlib bug once and for all
• Somebody to try and reproduce this lordsawar bug
• (oh, and a pony :) )

Edit: I did the first one myself :)

Taught this system in about 15 minutes to my cousin Melanie (high school freshman working on her first Big Paper for history; it’s something about People with Swords in Ancient China, so I’m totally reading it when she’s done) this afternoon and realized I’d never written it down, so here goes: this is how I’ve taken reading notes and written papers since I was in high school. I’m also writing this in part to prove that the terminal is useful for things other than writing code, because I did not know how to code when I started doing this.

My system is largely predicated on the assumption that I am a Lazy Bum, and basically involves 4 tools: cat, grep, | (pipes), and flat text files. These are standard Unix tools, and I’ve never seen a Linux distro without them; Melanie and I already run Fedora, so we were all set.

I grab the text of books when possible (mm, Project Gutenberg) and take advantage of the fact that my computer can read faster than I can. For instance, for history my Junior year of high school, I had to write some paper about the Judeo-Christian belief system. I forget the exact topic now, but let’s imagine wanted to grab out some nice quotes about the symbolic use of… say, swords. I like swords. So I download bible.txt, and…

cat king-james-bible.txt| grep -C 1 sword | less

In English, this means “send (concatenate) the text of the bible through a filter (global regular expression print) that looks for the word ’sword’ and shows the -Context of 1 line before and after it, then let me scroll through the results (less).” The results look something like this.

01:003:024 So he drove out the man; and he placed at the east of the
garden of Eden Cherubims, and a flaming sword which turned
every way, to keep the way of the tree of life.
–

01:027:040 And by thy sword shalt thou live, and shalt serve thy brother;
and it shall come to pass when thou shalt have the dominion,
–
stolen away unawares to me, and carried away my daughters, as
captives taken with the sword?

–
that two of the sons of Jacob, Simeon and Levi, Dinah’s
brethren, took each man his sword, and came upon the city
boldly, and slew all the males.

And so on. Instant sworditude, much faster than actually reading the whole darn book (or Book, in this case).

For those looking for a more powerful alternative to grep, try ack. (The website URL is pretty accurate.) I was introduced to ack at TOPP and have never looked back; the main advantage is how easy it is to deploy ack on huge trees of folders swarming with text (or code) files, meaning that you could, instead of just looking in the King James Bible, deploy the above search for swords in every note you’ve ever taken on every book you’ve ever read. Assuming those notes are textfiles dumped somewhere underneath the folder you’re searching in, I mean. It’s made fascinating connections between long-ago reads I never would have thought of on my own, and my papers in college were much improved by it.

I also take my reading notes in flat text files as I go through books. Those textfiles look something like this:

Arnold, Bennett. How to Live on 24 Hours a Day. New York: Shambling Gate, 2000. Print.

P: (5) Lay out things for tea at night so you can make tea in the morning as a nice wake-up call.
Q: (5) [breakfast] The proper, wise balancing of one’s whole life may depend upon the feasibility of a cup of tea at an unusual hour.
N: Hilarious writing style. Read this book whenever the need for British wit strikes.
?: (7) Was this before or after Taylorism?
N: (7-8) This program would only work in a highly literate population. Which I suppose the reader belongs to, as they’re reading the book. But still.

Note a couple things.

1. Full bibliography at the top so I never have to figure out the formatting for it again.
2. Each note gets a new line, and begins with a letter code for the type of note it is: P for paraphrasing (summary), Q for quote, ? for a question I have, N for a note (my own thoughts), and some not shown here, like R for “reference to some other material I should look up later” (such as when one book cites another that I figure I should read).
3. Optionally, page numbers appear in (parentheses) immediately after the note type.
4. Super-optionally, tags appear in [brackets] after the page numbers, mostly when I want to be able to associate a quote with a word that’s not in the quote, for ease of searching later.

Then I can make queries like “what were all the questions I had about this book?”

cat how-to-live-on-24-hours-a-day.txt | grep ?:

Or “what interesting stuff was on page 7?”

cat how-to-live-on-24-hours-a-day.txt | grep (7

And so forth.

Confession: I’ve fallen off the wagon and haven’t taken notes like this since I left school. I’m trying to climb back on it again, as this sort of database is gloriously helpful to build. Particularly if one plans on doing lots of reading and writing of papers. Like, say, if one were to consider grad school.

I’m sure this system could be improved; I once had dreams of writing a GUI for it, but found this worksforme enough that I just never made one. There are probably better tools out there for it, there’s probably a lot of regexp-fu I could pick up to do more powerful queries (in fact, this is one of the reasons why I know regular expressions at all), there’s… well, you know what I’m about to say.

Patches welcome!

A lot of people (especially working people with mobile devices like notebook/netbooks) need to use different proxy servers at home and office. There are several Firefox extensions available to achieve the required functionality but IMHO Multiproxy Switch(Mozilla Addon Page) is the best because

1. Its simple and easy to use. It does what it should. No fancy/extra terrestrial stuff. Just switch proxies
2. Easy and Firefox like interface to specify different proxies. Many extensions add their own fancy interfaces for specifying proxies which eventually suck big time.
3. I am a fan of this one. The No-Proxy list. I could never understand those regular expression based no-proxy lists in FoxyProxy. Multiproxy Switch has Firefox like No-Proxy list which rocks and understandable

If you happen to come across a better proxy switcher for Firefox, do let us know

Recommended Posts

• How To: Install ATI Catalyst (fglrx) Drivers
• Fedora 12 ATI Catalyst Drivers
• How To: Configure Squid Proxy Server
• News: Will ATI Catalyst Drivers 9.12 work with Fedora 12?
• News : ATI Catalyst Graphics Drivers 9.11 Released

Fedora Tutorials and Videocache by Kulbir Saini.

I’m working on a project to try and expose audio spectrum data from Firefox’s audio element.  Today I ponder arrays and fix some things.

Today is my last day of work before the Christmas break begins, and I just submitted my final grades.  This gave me a little bit of time to rewrite some of my code in order to fix a few things.  Here’s my latest demo:

After talking with some more people who work with audio, I realized that I’d be better off giving floats vs. integers for the data.  In this demo you can see both my code, which uses event.mozAudioData, and the output in Firebug.  I’m pretty happy with our progress to date.  Twelve days isn’t bad to go from clueless to slightly-less clueless and with a working patch.  I want to draw attention to this, because a large part of why I’m doing this is to inspire my students and others to take risks and work on things that scare them.  You hold yourself back if you don’t.  I don’t know what I’m doing most of the time, I just keep at it until I do.  There’s no reason you can’t, too.

Anyway, this is looking good, but I’m far from done.  What I spent the most time on with this iteration was getting my arrays working properly.  I’ve been doing a lot of reading in our code, looking for ways to expose pure arrays in content (e.g., in the DOM).  In the comments of my last blog post, a few suggestions where given, and in the bug another was mentioned.  Here are the ways I’ve come-up with (there might be others):

1. Create a DOM class that wraps your array and provides getter/length semantics (that’s what I’ve done for now).  See nsIDOMClientRectList.
2. Use an nsIVariant type, and let XPConnect coerce the type for you.  See nsAnnotationService::GetPageAnnotationNames.
3. Go around IDL altogether and grab raw JS values.  See nsCanvasRenderingContext2D::GetImageData.
4. Use the (currently not landed) WebGL Array (Vlad recommends I move to this, so I’ll explore that in subsequent work).

Now that I have it running, I’m starting to think about performance vs. just getting it to work.  A lot of questions I am getting relate to doing Fourier Transform in JS vs. navtive code.  I’ve been around Mozilla long enough to know that the first answer to questions like this isn’t to drop into C/C++.  Maybe it won’t be possible in JS; but I need to have that proven before I’ll make that conclusion.  I’m also concerned that my time-based events for exposing the data are going to be problematic.  I really wonder about keeping up with the timing of the audio as it’s played.  A lot of people I talk to are excited about doing precise visualizations that are timed to music.  I know my current code can improve a lot here, so it’s too early to assess whether this will be possible.

I’m not sure when I’ll post my next part of this series.  I am going to celebrate this success with some much needed holiday time.  Rest assured, though, that I’ll be back at it again soon.