I haven’t posted much here lately, but I have been writing. I recently finished my first semester as a doctoral student in Columbia's school of journalism and one of the papers I completed draws directly on my experiences in the Plone Community.  A few years ago I remember being struck at how different open source development was from what I (and presumably others) imagined it to be. I kept pitching human interest stories to journalists, ones that might emphasize the playfulness, the sprinting, and the organizational experimentation, but got very few nibbles. So, I finally wrote some of this up myself before it all fades from memory:

 

Fabricating Freedom: Free Software Developers at Work and Play

 

The paper was for a wonderful class this semester at the New School taught by Paolo Carpignano (The Political Economy of Media - here is the syllabus). The class was all about the shifting relations between fabrication and communication, or more colloquially, work and play. We opened with Marx and Hannah Arendt and closed with Yochai Benkler and danah boyd. The piece I wrote is personal and anecdotal, but reflects on all that our community has taught me about free software, free culture, organizing, consensus building and the day to day politics of software development.

enjoy.

 

 

This is a fun post recognizing the role of open source software and breaking routines in learning new programming patterns and paradigms.

 

7 Reasons I switched back to PHP after 2 years on Rails

 

Rails was an amazing teacher. I loved it’s “do exactly as I say” paint-by-numbers framework that taught me some great guidelines. I love Ruby for making me really understand OOP. God, Ruby is so beautiful. I love you, Ruby. But the main reason that any programmer learning any new language thinks the new language is SO much better than the old one is because he’s a better programmer now!

 

This story articulated an idea that I have been thinking about for a while - the ways in which developers working on open source software enter into an educational relationship with the software and the community (sometimes indirectly, mediated through the code).

I have often appreciated all that Plone has taught me about the domain of content management, component architectures, extensible software design, internationalization, test driven development, responsible release management, etc etc. I know that it has taught me well since when I walk up to new pieces of complex software like Sakai or Drupal the concepts are familiar and often isomorphic. I can vouch that exposure to Plone has helped designers I know with stretch their CSS skills, improve the accessibility of their sites, and more cleanly separate presentation from logic.

I have also made the case that for an organization to work on software in isolation is bit like having a conversation with yourself. At first you might arrive at some new insights, but its really hard to learn anything new in a hermetically-sealed vacuum chamber. The software world transforms so quickly that it is a Sisyphean task for any one person or organization to track. Joining a community, even if it is through the indirect, intermediary object of code, is a great way to continue learning and stay on top of emerging trends. The notion that learning happens through dialog is an old one; the notion that working with open source software is a form a dialog with the authors is a bit less obvious.

My main critique of Derek's post is that he doesn't explicitly acknowledge the fact that Rails is open source, which is precisely what enabled him to learn so much from the framework. This isn't just a matter of attribution, it has practical implications for being able to continue learning new tricks over time.  If he had realized that Rails-the-software embodied the knowledge of the Rails-the-community, he might not have been so quick to venture off and write his very own framework. I am not arguing that he should have steered clear of php, but he does not explain why he decided to roll his own framework as opposed to joining forces with Cake or another existing php framework, or at least using an existing php templating system. With a more explicit understanding of the origins of the knowledge that Rails-the-software captures, he may have appreciated the potential future gains of remaining part of some community.

While it is possible to learn something from proprietary frameworks, "learning" is fundamentally about the open exchange of knowledge and meaning, which are values intrinsic to F/OSS. While you can learn something from a .NET api, you can't step through the entire stack of software in the debugger. Perhaps more importantly, the cultural tendencies on an open project support constructionist poking and prodding (dare I say, hacking?).

For those craving a bit more of a hands on update than my earlier background post on making Plone play well with Salesforce.com provided, hopefully this takes a step in the right direction. I'm going to be demoing the display of Salesforce.com content within the portlet of a Plone site. Credit to Jesse for helping me realize how dirt simple this is. Writing the code to do this took less than 10 minutes and that included asking a colleague a few questions about how exactly Salesforce.com works :)

The Use Case

Recently, the Executive Director of ONE/Northwest, Gideon, sent an email to staff emphasizing the use of quotes as a way to increase our credibility by allowing partners to tell our story in new potential partner circles. Being a nonprofit, think of a trusted grants manager quoted in a proposal to a new foundation or a donor quoted in our annual report. This also includes a quote about a completed web project appearing in our technology solutions section or a scope of work.

Even though we've had a Quote content type in our oft-internally-used, but not widely publicized Pigeonhole product, I thought I'd try an alternate implementation, which I see as very much complimentary, rather than competitive. For us, it makes sense to have our quotes coupled with Salesforce.com contacts. In other cases the ease and speed of doing Plone catalog lookups for related Quotes based on keywords is superior, especially as implemented in Pigeonhole as a lightweight content relation engine.

So, my colleague Steve had done some behind the scenes Salesforce.com fiddling allowing for the addition of a quote that's tied to a contact. I just added a new quote to my own contact record. See image below:

But, how would we display this and other quotes in a portlet on a local copy of onenw.org...

Beatbox Setup

If you're reading this post, I'm assuming you've got a working Plone 2.5.x instance lying around, which means you've got Python 2.4 as well. You may even have EasyInstall. If not, start here. Once you've met the basic requirements, you can install beatbox from the CheeseShop with:

easy_install-2.4 beatbox

Just to prove this is working, fire up the interactive Python used by your Plone instance and type:

>>> import beatbox

Salesforce Base Connector Setup

Next you need to get salesforcebaseconnector from the Plone Collective (hopefully we'll have a 1.0 alpha 1 release in the Plone Software Center soon). Execute the following from your Zope instance's Products folder:

svn co https://svn.plone.org/svn/collective/salesforcebaseconnector/trunk/ ./salesforcebaseconnector

Upon restarting Zope, head to the ZMI and the Plone site where you'd like to talk to the Salesforce.com API.

Add a Salesforce Base Connector:

Select the radio button and hit "Add"

Click on your newly added portal_salesforcebaseconnector



Enter information for a valid Salesforce.com account. This could be a free developer account.

The Code

I chose to do this in a Zope 3 view within the DIYPloneStyle-generated product, ONENWSkin, we use at onenw.org, but as mentioned in the previous post, an explicit goal for salesforcebaseconnector was to enable integrators to easily do the same in ZPT or a Python skin script that's not necessarily filesystem-based.

After the obligatory ZCML wiring, I created a file, browser.py, at the root of my product. The following import statements and the "RandomQuotePortletView" class were all that was necessary:

from Products import Five
from Products.CMFCore import utils as cmf_utils
import random

class RandomQuotePortletView(Five.BrowserView):
    """Find recent job listings for portlet display
    """
    def __init__(self, context, request):
        Five.BrowserView.__init__(self, context, request)
        self.sfbase = cmf_utils.getToolByName(self.context, 'portal_salesforcebaseconnector')
    
    def getRandomQuote(self):
        """Returns a random quote from Salesforce.com in a dictionary
        """
        res = self.sfbase.query(['Name','Quote_Text__c'],'Quote__c',"Usage_Guidelines__c!='Need to get permission'")
        
        # res looks like a dictionary with a 'records' key
        return random.choice(res['records'])

Of note, is the "query" method on our "portal_salesforcebaseconnector" object created at the site root in the setup above. We pass the query method a list of which fields ('Name' and 'Quote_Text__c' -- The '__c' convention signifies a custom field/object) we'd like to retrieve. The second parameter is our desired SObject, the custom Quote object, and finally we have an additional where clause which is based on our internal business rules of never showing any quotes where we don't yet have permission.

That's it! It's basically 2 lines of code (that could be collapsed into 1) within the contents of the "getRandomQuote" method and we're able to retrieve any and everything we might ever want from our Salesforce.com account.

Finally, we setup the following portlet, which defines the view, calls "getRandomQuote" on the view, and then displays the quote text for our randomly collected quote:

<html xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      i18n:domain="plone">
<body>
<div metal:define-macro="portlet"
     tal:define="view context/@@random_quote_portlet;
                 qDict view/getRandomQuote">

    <dl class="portlet" id="portlet-quote">

        <dt class="portletHeader">
            <span class="portletTopLeft"></span>
            Random Quote
            <span class="portletTopRight"></span>
        </dt>

        <dd class="portletItem odd">
            <span tal:replace="qDict/Quote_Text__c" />
        </dd>

        <dd class="portletFooter">
            <a href=""
               tal:attributes="href string:$portal_url/all-quotes"
               >
              More quotes&hellip;
            </a>
            <span class="portletBottomLeft"></span>
            <span class="portletBottomRight"></span>
        </dd>
    </dl>

</div>
</body>
</html>

And after a few page reloads, to bypass the other quotes in our Salesforce.com instance, we see the following:

Conclusion

While I only demoed the use of the "query" call to the Salesforce.com API, you can skim the methods of the SalesforceBaseConnector class or read up on the API via Salesforce.com's APEX developer wiki for a better picture of what's possible. Note: Beatbox currently talks to the 7.0 version of the Salesforce.com API (several major version behind), so everything described in the docs may not be supported.

For my money, this piece of the Plone and Salesforce.com integration landscape is probably the most ready for prime-time right now, due to the relative feature-completeness of Salesforce Base Connector. That is, if you ignore the lack of an official release :)

In the next few days, I plan to show off some work done to make PloneFormGen post directly to a Salesforce.com instance.

I recently encountered O'Reilly's asymmetrical competition meme and think its a good jumping off point to discuss the differences between Plone's perceived and actual competition.

First, let's catch up to where we are today:

Web 2.0 ... The Machine is Us/ing Us

The opensource CMS horserace has seemingly settled on a few players, and without provoking any religious wars, I continue to be impressed with the richness and maturity of all of these projects.

But here in the educational sector there are rumblings which I think will spread beyond our corner. In our world 'C' stands for Course, not 'Content', and the big players are Blackboard (which swallowed WebCT), Sakai and Moodle. Here too, competition may come from surprising corners, as the game itself changes beneath us.

"Collaboration via the net does not necessarily require monolithic, expensive tool suites that aim to do everything under one umbrella. We will share and demonstrate the use of readily available, mostly free, discrete sets of "small" and "loosely joined" technologies - weblogs, wikis, instant messaging, audio/video chat. The loose joining means that how they are connected are not necessarily in the programming of the software, but the ways people can use them in a social context that is an environment of dynamic, changing relationships and connections, rather than the rigid, limited ones defined by computer code."

from Social software: E-learning beyond learning management systems.

This argument is elaborated on, with many examples of applications that might work this way in this paper:

EMERGING TECHNOLOGIES Tag Clouds in the Blogosphere: Electronic Literacy and Social Networking

So what does this mean for the other sectors where Plone operates? I have been hanging out in Drupal land lately, and for a variety of reasons I don't consider that platform to be a serious threat to Plone, in the long term (more on that in another post).

On the other hand, and this might raise some eyebrows, folks maybe should take a peek at Gallery 2.2 . Yeah, its in php, and they don't have enough unit tests, but it does a really nice job of solving the "bucket" problem - that is, easily publishing a repository of digital assets on the web. Their next version will handle audio and video files, and the software is popular enough that people have built desktop clients for iPhoto and Picassa. They have a good story for multi-site installations, upgrades, and even a web based mechanism for upgrading plugins. Just imagine mashing up this backend store with a social-networking tool like elgg. Maybe you could create complex and elaborate views of your data with widgets coming out of the simile project (exhibit and timeline, in particular). You might even be able to use a visual programming tool, like Yahoo's pipes or IBM's QEDWiki to assemble this application.

The real threat here isn't Gallery. Its the loosely-joined, disconnected applications that are becoming connected through the component architecture of HTTP itself (plus a few decent patterns and standards). No one wants to be trapped in a silo, not even if its decked out with hardwood floors, leather furniture, and a marble mantle.

Plone can be a major provider in this hub of communications, maybe even sometimes at the center. But we do need to try to anticipate the future role of the CMS in the face of asymmetric competition.

As Laura Trippi once put it, Content Management Systems like Plone, are turning content produces into coders, and vice versa. We're creating monsters, and they might soon be outgrowing the tools they were weaned on.

(thanks to Biella for the video reference and the critical commentary).