Owner Blogs

One Letter Repository Status for Git, Mercurial and Subversion

Tue, 09 Apr 2013 07:53 GMT

These days we’re using a variety of version control systems and switching between them regularly.

My most used command is checking my working directory status, so I’ve distilled it down to a one-letter shortcut that determines which type of repository I’m in, then does an appropriate status for that system.

I just setup an alias like this:

s='~/s/s.sh'

So just type s and don’t worry about which version control you’re in.

Here’s the code on gist.github.com

Testing JavaScript Code Running Google Closure Library using Mocha and PhantomJS (or Jasmine)

Wed, 24 Oct 2012 11:24 GMT

Here are several options for setting up JavaScript unit testing for code built with the Google Closure Library, albeit these options are helpful for testing a wide variety of JavaScript projects.

Google Closure Library is self-described as a “broad, well-tested, modular, and cross-browser JavaScript library.”

We’re using the LimeJS HTML5 game framework, which is built on this library.

Our Contestants

1. Headless testing with Jasmine 1.2

Jasmine works well. There are two approaches you can use: an HTML runner with jasmine.js, or the Ruby-based runner. Originally we were hoping to take the same approach as the Ruby-runner (with all batteries included, including easy headless testing) but using Mocha and Node.js instead to be on a full JavaScript stack. Though we ended up having to go to an HTML runner + mocha.js to get the DOM testing to work, in scenario 3 below.

In hindsight, by ending up with the HTML + JS approach in scenario 3, Jasmine and Mocha + PhantomJS are very similar approaches.

2. Mocha testing on Node.js

Mocha testing on Node.js works well (easy setup, no html test runner required), but I wasn’t able to get headless DOM working. If your tests don’t require DOM, this is a good way to go. One issue: It takes more effort to debug tests with breakpoints because the code is running on node.js. In the other scenarios, you can just add a debugger line and debug the tests in the browser.

3. Headless testing with Mocha and PhantomJS

Our winner: Headless testing with Mocha and PhantomJS via mocha-phantomjs allows us to use JavaScript tooling, headless DOM testing and a nice Jasmine BDD style for writing tests.

4. Testing with the Google Closure Library testing framework

You can use the Google Closure Library testing framework, which is more of a traditional JUnit style framework and not a BDD-style framework like Jasmine or Mocha. Please check out the Closure documentation for more info.

Let’s Get Testing

Here’s how each can be setup.

Assume you keep your tests in a my-project/spec folder and your code is under a peer my-project/scripts folder. Assume all test-related files discussed below are in the ./spec folder and that tests are kicked off via a script in that folder.

1. Jasmine

This is a personal favorite. It has all batteries included and doesn’t need a separate HTML runner for DOM testing if using the Ruby Gem. We liked this approach, and tried to do it with Mocha + node.js (to get the same features as the Ruby Gem, but on a JavaScript stack) though ultimately went with Scenario 3 below.

For general setup of headless Jasmine testing, see my jasmine-headless-boilerplate repository.

Once setup, to tailor for Google Closure Library, in javascripts/support/jasmine.yml (setup by default with jasmine init) add your project’s base.js and generated deps.js file to ./spec.

src_files:
    - scripts/libs/closure/closure/goog/base.js
    - scripts/deps.js

You can then just create a standard Jasmine test file with goog.require() statements at the top to bring in the module dependencies:

goog.require('the.module.I.am.testing');
goog.require('a.dependency');

describe("the.module.I.am.testing", function () {

});

2. Mocha Testing on Node.js

After setting up node.js and npm, you can create a package.json file to make it easy to setup all the dependencies by just running npm install in your ./spec folder.

If you have a script that kicks off the tests, you can optionally add that to the “scripts > tests” key like seen below so that you can just run npm test.

Also, you’ll need to use the nclosure library to allow node.js to bring in dependencies via goog.require().

In ./spec create 3 files:

closure.json to tell nclosure library where your files are
package.json to setup all your node.js dependencies
a run script

Here are examples:

closure.json

{
  additionalDeps:['../scripts/deps.js'],
  closureBasePath:'/this/has/to/be/an/absolute/path/in/my/experience/scripts/libs/closure/'
}

It took some time to figure out the right file paths. Basically:

“additionalDeps” should be a relative path from where you’re running the script that runs the tests. If you’re running tests from a ./spec folder, and the code lives in a peer (to ./spec) ../scripts folder, use the example above.
However the closureBasePath only worked as an absolute path, plus you leave off the trailing /closure/goog (since often closure is in a lib/closure/closure/goog directory structure).

I assume this could be fixed with either a patch to nclosure or maybe I wasn’t doing something correctly. I also tried setting this as a parameter to the actual require('nclosure').nclosure(); call at the top of the tests, but no difference. This would need to be solved to make it easy for a team to run tests locally.

package.json

{
  "name": "our-test-framework",
  "version": "0.0.0",
  "description": "## Unit Tests",
  "main": "index.js",
  "scripts": {
    "test": "sh runtests.sh"
  },
  "repository": "",
  "author": "",
  "license": "BSD",
  "dependencies": {
      "chai":"~1.3",
      "sinon": "~1.5",
      "nclosure": "~0.4",
      "mocha": "~1.6"
    }
}

runtests.sh

#!/bin/sh
./node_modules/.bin/mocha --recursive --timeout 10000 --reporter spec your/folder/to/your/specs

Here’s an example test file:

require('nclosure').nclosure();

goog.require('my.module.goes.here');
goog.require('one.of.your.dependencies');

describe("my.module.goes.here test", function () {

});

3. Mocha Testing on PhantomJS (node.js not required)

This is the current winner for our specific needs. It’s mainly JavaScript based, runs headless DOM tests, and supports a nice BDD syntax.

This has some additional dependencies beyond the setup above:

Install PhantomJS, which on OSX is as easy as brew install phantomjs via Homebrew.
Bring down mocha-phantomjs.coffee and the mocha-phantomjs folder from mocha-phantomjs and put those in your ./spec folder.
Bring in dependencies mocha.js and mocha.css from root of mocha repository
Bring in third-party libraries like expect.js and sinon.js used by test runner HTML below. (We started with Chai’s “expect” assertion framework, but the assertion code didn’t nicely pass linting, so went with the very similar expect.js)

Instead of using the ./mocha test runner, your run-script can call each test like so:

phantomjs mocha-phantomjs.coffee javascripts/mycontroller_spec.html

In addition to your test js file, you need an html file test runner to setup DOM for your tests.

Here’s an example of mycontroller_spec.html:


  
    Unit Tests

The mycontroller_spec.js test file doesn’t require any special code, just using the normal goog.require():

goog.require('my.module.goes.here');
goog.require('one.of.your.dependencies');

describe("my.module.goes.here test", function () {

});

Other thoughts and ideas

For tests requiring DOM: Is it possible to substitute zombie.js instead of phantomjs? The main reason is that then the whole stack could be in node.js and has fewer dependencies (since it wouldn’t require phantomjs and mocha-phantomjs).
Selenium is another option for testing code against DOM on real browsers.

References To Bookmark

Favorite Tuesday Talks at 360iDev 2012

Wed, 12 Sep 2012 10:46 GMT

Here were four talks I enjoyed, plus Game Jam.

Poking a Hole in the Sandbox, using URLs on iOS

By Greg Pierce, @agiletortoise, Slides

Lightweight local messaging between apps.
A way to test if certain apps are installed, great for cross promotion too.
A protocol for iOS interapp communication http://x-callback-url.com

It’s All in the Tools

By Nathan Eror, @neror, Slides

How to wield Xcode with keyboard shortcuts (Jump bar: ^[1-6], learn keys from top menu items View and Navigation), Behaviors, breakpoints (logging, sounds, shell scripts, llvm allows breakpoints without restarting app), and powerful lldb debugging (formatters, summarizers, python integration, .lldbinit).
Uses make to automating (things like removing sqlite databases), supports autocompletion. See his blog entry on this.
Mountain Lion has Python bindings for Cocoa – see a nice Quartz example in his slides. This was news to me, and after Googling around didn’t find much into about this.

Creating Container View Controllers

By Bob McCune, @bobmccune

These are now easier to create in iOS 5+. A subtle API for adding/removing child controllers, get children, new callbacks. Only use this API within your container. Avoid common mistakes: Outside callers (since invalidates containers view of the world), disobedient children, meddling parents (let children be children)
Demo code is here: https://github.com/tapharmonic

Galcon

By Phil Hassey, @philhassey

Phil following his gaming development passions with Galcon and other games, including his new Dynamite Jack.

Game Jam (7pm to 7am)

Phil Hassey’s Galcon talk motivated me to give Game Jam a try.
I enjoyed this for several hours before drinking and socializing set in.
Had fun with cocos2d and box2d.

Favorite Monday Talks at 360iDev 2012

Mon, 10 Sep 2012 16:24 GMT

My favorite talks are the developer-heavy ones. Here were three I enjoyed today.

Advanced Debugging Code (on Sunday)

By Kendall Helmstetter Gelner, @kendalldevdiary, Slides (pdf) and Sample Project on Github

This talk was chalk full of debugging goodness: logging, instruments, LLDB, breakpoints, ARC (less code == less to debug), Pony Debugger, Charles, Core Data.

Developing for Reuse

By Andria Jensen, @andriajensen, slides: http://bit.ly/U3RA4V

Andria had a great presentation and her slides are very useful for best practices in modularizing code for Objective-C and Xcode.
This very topic was resonating with me last night (iOS Automated Testing: Refactored), and although she didn’t cover the unit testing pieces, she went way beyond the first step of git submodule modularization and went into Xcode workspaces, static libraries, bundles, and categories.

PhoneGap

By Andrew Trice, @andytrice

Andrew is a great resource and has some interesting projects on Github such as app-UI, Lil-Doodle, Fresh-Food-Finder.
“What’s the difference between PhoneGap and Cordova?” They’re the same code base right now. Cordova is the open source project, and PhoneGap is Adobe’s distribution, and they own the PhoneGap name.
Some libraries he uses are Backbone.js, and Leaflet (“An Open-Source JavaScript Library for Mobile-Friendly Interactive Maps by CloudMade”)
He showed some good plugins, like second screen support (native PhoneGap code to support multiple screens). PhoneGap Plugins are nice since they give JavaScript access to anything you can do in the native layer, and there are many plugins that have already been developed.
Presentation Suggestion I have: Many of the PhoneGap examples are business apps (Apple Store, LinkedIn, BBC Olympics, Zombie Jombie, Wikipedia, Untappd, Bit Timer, US Census Browser) though there are JavaScript libraries out there (such as lime.js) that make PhoneGap a nice platform for gaming too.

“Stop it! That Hurts!” Common iOS Anti-Patterns

By Carl Brown, @carlbrwn, slides: http://t.co/JRWPcd1B

His whole talk is great. Topics include Error handling, Asynchronous, Date, Security, Caching, View tagging, Core Data results, don’t mix read-only and read-write data.
He’s in Austin, home of SXSW Interactive where it “Looks like any idiot can make an App”, sees a lot of (bad) code

Suggestions

Read good code – and NOT these from Github Objective-C “Most Watched”: three20, asi-http-request, AFNetworking, facebook-ios-sdk, Restkit.
His “Rocket Engine” for Responsive Code (to make sure you’re not doing much on main thread): NSAssert(![NSThread isMainThread], @"BOOM");
Uses NMVC pattern (“N” for Network), essentially networking happens at the data layer and not throughout code.
Carl had some criticisms with RestKit, so I asked him more details after the talk. The criticism is more that Restkit tries to abstract what’s local and what’s remote, and it’s not always clear what’s happening. He turned me onto a nice recommendation: MagicalRecord which is a Category for Core Data that handles fetching of remote data and adding to Core Data.

Summary

Program sober and rested, if possible
Leave other language’s patterns at the door
Program idiomatically (“The specific grammatical, syntactic, and structural character of a given language.”)
Don’t fight the frameworks

iOS Automated Testing: Refactored

Sun, 09 Sep 2012 14:53 GMT

My mobile projects lately include various combinations of JavaScript and Objective-C. Usually either 100% native iOS, or JavaScript running on a native iOS (or Android) layer.

I also like to dabble with various projects, and am tired of the heavy weight of setting up new Xcode projects when I just want to experiment with some concepts. The JavaScript side is already much lighter.

I consider it heavy because:

I have various snippets strewn across projects, and
getting Xcode tests up and running sucks the life out of me when I just want to jump into some code. True, new Xcode projects do create boilerplate tests, but still requires setup for including other 3rd-party libraries like OCMock.

An example scenario:

Today I’m dabbling with geofencing in an app, but tomorrow I may want to use that code in a hybrid Cordova/PhoneGap app, Thursday I might want to refactor geofencing into something else.

I’m very happy with Jasmine for testing JavaScript, since it’s easy to setup and use. I created a jasmine-headless-boilerplate project that is a starting place for those wanting to setup and run Jasmine JavaScript tests with their projects, and also be able to run it headless on their CI server or on Travis CI.

The New Plan

So for my Objective-C code, I have formulated a plan to deal with both of these at once:

Modularization: I’m going to focus on moving code out of specific apps and into a personal library. I’ll then include that as a git submodule in any new project I begin, whether native or hybrid. I’ve been doing some of this modularization already by avoiding the impulse to add too much code directly into UIViewControllers, but rather putting code into custom classes that are then used by the UIViewController.
Testing: The personal library will also be housed in a bare bones Xcode project, which will only have unit tests and 3rd-party testing libraries (like OCMock), so that I can ensure that code is tested before it gets used in my projects.

When I’m done, I’ll have a versatile and well-tested library that I can quickly add to any project or experiment.

Here’s a Starter Project to play with: Enjoyable iOS Testing

Other Xcode Testing Starter Projects and Resources

I’m now looking around for bare bones Xcode starter projects to use:

Xcode-Templates looks interesting
Cedar looks even more interesting since it’s closely related to Jasmine and looks like it will blend well with my JavaScript work.

With Great JavaScript Comes Great Inspiration

Wed, 04 Apr 2012 08:15 GMT

I’d say the theme of Day Two at JSConf 2012 was inspiration, and was another great day of talks:

I think my favorite talk (best presentation, very pragmatic) was Jake Archibald’s “Application Cache” – why it’s useful and the potholes you’ll encounter while using it. You’ll want to watch this video.
The best demo for me was the presentation prior, Thomas Valletta’s “The Web Game Console”, where he talked about his experience developing his mobile game with HTML and JS. He wrote a Web Bowling game using HTML/JS on iOS as the controller, and a Node.js websocket server for displaying the bowling alley. The source is on Github (so you can setup your own server if you want) and if multiple people play at the same time it turns into “battle bowling” with multiple balls at the same time.
Project Bikeshed was a great demo too. Not only did its authors put on a great daily video series, but Bikeshed allows you to do many useful things such as importing Flash SWF files, automatically turning those into JavaScript and then allowing you to show, combine, manipulate, animate any of those elements and use them in your JavaScript projects. He demo’d an iPad JavaScript game that was powered by Bikeshed. You can also run Bikeshed on Node.js and send that to devices. With a one-line change, he showed running both scenarios.
Ok, another great demo was on Open Data in the B-Track by Daniel Beauchamp & Edward Ocampo-Gooding. They actually packed about 7 small presentations into one and described their process of organizing a city hack-a-thon around Open Data and building a lot of apps for free for the benefit of your city and your community. Very inspired.
The Node.js talk from Brian Ford inspired us with some interesting readings to check out (such as the “Thinking Fast and Slow” book) and the importance of leveraging communities outside of JavaScript, such as the experiences of the Ruby community. He then had many concerns about Node.js repeating concurrency mistakes that Ruby had made. Though I think I mainly left there with only some good book suggestions – it felt like it ended abruptly since there was no time for questions (since presentation went long) and no specific next steps on how to avoid said concerns.
One of the most inspirational talks was 19-year-old James Whelton’s “Changing the world one CoderDojo at a time”. CoderDojo is “a movement of free coding clubs for young people”. Check out their site for a lot of inspiration and how to start a club yourself. Also turns out that JavaScript has been a very accessible language to use – it requires no setup, is available everywhere, fun to work with, and can even land you a job down the road.
Jacob Thornton’s “Brûlons les musées” talk was also very entertaining, and you’ll need to see the video. He led up to the power of the JavaScript community getting together more specifically around creating specs/tests (versus primarily getting together around an implementation), which then offer flexibility and healthy competition when implementing libraries that meet those specs. His example was creating Hogan.js, which is some ways was a rewrite of Mustache.js. The improvements were possible by leveraging the Mustache tests. Then Mustache was able to make improvements. By using the specs, separate projects were able to code and optimize independently.
The final talk of the day was Rick Falkvinge’s talk about politics, the Pirate Party and inspiration on how to change the world. He told his story of how the Pirate Party has been able to make in-roads into mainstream politics, and what’s possible.

Green for Dinner

After the JSConf family photo, nine of us then went to a local vegetarian restaurant called Green which was amazing. The place was packed the whole time while the atmosphere was very easy going. They had a great variety of original and tasty foods.

Boot2Gecko Phone

In the evening, I finally had a chance to play with Mozilla’s Boot2Gecko phone and built a simple app. In Accelo the JSConf logo floats around the screen and moves as you tilt the phone.

Development was fairly smooth and I was able to install my app as part of the Gaia update/install process, but didn’t have luck yet setting it up to install as a stand-alone app.

Albeit since the app is solely HTML/CSS/JS it works just fine by visiting the site http://accelo.evolvingbits.com/accelo/ on the Boot2Gecko phone (or even works on my Macbook Pro which apparently sends accelerometer events). However when viewing on iOS, the accelerometer events seem to be reversed, so not sure which implementation is off.

Thank you

Thanks JSConf for another great year of new friends, bull-riding, great talks, tasty food and inspiration. I will miss the sunshine and the playtime, but excited to jump into the all new tech-wonders that I can use for my web and mobile projects back in Seattle. The Firesky Resort in Scottsdale was a perfect conference location, and I was also very happy with my stay next door at Chaparral Suites.

Also a big thank you to my company Saltbox.com who have sponsored me to attend JSConf this year! We’re developers of an online communication and learning application that allows Sales organizations to keep a pulse on what happening with their products, their customers and their competitors.

JSConf 2012: Play

Tue, 03 Apr 2012 06:50 GMT

On my flight to JSConf, the Southwest Airlines magazine kicked off the topic of Play in Its called Play

This theme continued throughout JSConf 2012’s Day One.

Just a few things to play with:

Registration included getting an NFC Poken, taking pictures with guns and cowboy gear, and a bag of sponsor loot.
All attendees were given the first public Boot2Gecko phones from Mozilla with a challenge to hack it and build apps by conference end.
Stephan Herhut showed us the possibilities with true parallel programming and JavaScript using Intel RiverTail.
Paul Irish showed us the latest in JavaScript tooling. His presentation.
Max Shawabkeh walked us through repl.it which runs 17 languages natively in JavaScript, including Python and Ruby. This is a great environment for new students to programming (since the only dependency is a web browser), or people wanting to play with compiler technology.
Remy Sharp talked about using JavaScript to “Build Anything” and gave a list of things he’s like to see browsers do, such as real-time notifications, strong desktop integration, direct access to hardware, ability to local install a JavaScript app, “go naked” (no browser chrome visible). He also talked about things we should be using today, such as web storage instead of cookies, using HTML5 tags for web form validation (i.e. instead of a crazy client-side email regular expression, use ), History API, AppCache manifest for performance (since just relying on browser cache may mean your files disappear after cache fills up), EventSource particularly for mainly server-to-client pushes (in addition to websockets), Drag and Drop.
David Nolen talked directly about the importance of Play and how ClosureScript was that playground for him. He was also inspired by the book ”The Reasoned Schemer”.
Dan Ingalls, “principal architect, designer and implementor of five generations of Smalltalk environments” took us through Lively Kernel which you need to see in action. It “provides a complete platform for web applications, including dynamic graphics, network access, and development tools” all in the browser.
Attendees left Day One with new cowboy hats, and many rode the bull later that night at Saddle Ranch.

Thanks NotConf for a Great JSConf 2012 Pre-conference

Mon, 02 Apr 2012 06:36 GMT

Arriving PHX was flawless, the Twilio-sponsored shuttle was there to pick me up from the airport.

After checking-in, it was sunny and mid-70s as a few of us awaited for a friendly volunteer-sponsored shuttle to whisk us over to NotConf in fine style.

This one day event went off without a hitch and was a lot of fun.

We arrived to free food, free local beer, t-shirts, sunshine, friendly faces – and of course JavaScript. 30-min talks leap frogged 30 min demos.

Best talk

I was only there the last half of the day, so my favorite talk was Pamela Fox’s (she also won best costume) “Why ternary operators make me want to kick someone in the nuts: AKA code readability.” She highlighted that most JavaScript developers are users of other people (library) code, and had many good points about what to do to make users lives much easier by making the code more approachable:

Documentation – but not too much (such as having two sets of docs that makes it unclear which are the definitive ones) and using doc generation tools to make docs part of the process and not manual
Make debugging headache free (by being clear, using less “elite” code, no crazy ternary operators) since at some point users will need to debug in there. Use tools like jshint to keep your code consistent. Also, although you can write javascript without semi-colons, this is not what most users expect and can lead to pain for potential contributors and users.
Make it easy to contribute to the (library) project. A lot of dependencies for running tests could be one barrier.

Favorite Demo

My favorite demo was deployd.com who had wired up an iRobot and a maze, and attendees could create a program that navigated the robot through it, complete with leaderboard. This demonstrated their cool “instant backend” for software developers and tinkerers to easily create a RESTful backend with no code – which in this case was then downloaded to a robot. Their business card says it all with “Join the Backend Liberation Movement”.

Thank you

The closing event was of course outside, where we all wound down with beer, nice conversations, and a local musician who was playing for us in the courtyard. My pale Seattle skin even gained some color and was happy to absorb all that natural Vitamin D.

Thanks to the organizers of NotConf.com – it was an impressive one-day conference and a great start to JSConf 2012.

Moved to Octopress

Sat, 31 Mar 2012 11:43 GMT

I’m excited to announce I finally made the plunge to Octopress for my JavaScript and iOS developer blog.

Please update your RSS reader to point to this new feed.

I’ll be migrating content off my previous Wordpress blog over time.

Sharpening the Mobile and JavaScript Swords

Wed, 12 Jan 2011 04:48 GMT

In the last couple of years, JavaScript has really become hot for the next breed of web and mobile applications.

JavaScript runs on a majority of mobile and desktop browsers.
… it runs on the server.
… it is used for developing desktop widgets and browser extensions.
… it is being used inside desktop applications. eg scripting for Kod editor
… it naturally works well with the web – easily handling JSON, HTTP and REST.
… works well for new real-time communication techniques (eg websockets).
… as a language it works well for asynchronous-style services.
There’s also a lot of innovation happening in the JavaScript space because it attracts both front-end and back-end developers.

Over the past year I’ve been working in the mobile application space primarily with native iOS and mobile-optimized websites.

This year I plan to expand my mobile and JavaScript skills in the following areas:

Create applications (and web services) using server-side JavaScript with node.js and learn the ecosystem that has grown up around it.
Practice new ”mobile first” and ”responsive web design” web-development techniques where new websites are designed for mobile first, and then progressive enhanced so that the same site works well for larger screens and desktop browsers too. Mobile can no longer be thought of as a bolt-on feature, but needs to become central to web design and development efforts.
Attend JSConf 2011 and NodeConf 2011 which are both in early May in Portland, OR.
Play with more data stores. CouchDB (for example) is a native JSON store that speaks HTTP. Mixed with client-side or server-side JavaScript (that easily works with JSON and naturally speaks HTTP) makes an interesting combination. A recent talk on node.js + CouchDB
Continue to work with the various approaches to building mobile applications to find the right tools for the job, whether native, web-based, or a mix.
Continue to practice test-driven development in JavaScript.

Highlights from DjangoCon 2010 (and videos to watch)

Tue, 14 Sep 2010 14:33 GMT

Here were some DjangoCon 2010 highlights for me, along with talk titles so you can find the full presentations online at http://djangocon.blip.tv/posts?view=archive

“Creating better apps”

Both Eric Florenzano (“Why Django Sucks, and How We Can Fix It”) and Alex Gaynor (“Rethinking the Reusable Application Paradigm”) had many useful things to say about creating better and more reusable apps. The videos are worth watching, here are some highlights:

Narrower abstractions would make apps suck less – such as not directly exposing models (create an API) so you can swap out model or implementation. This was also a big part of Alex’s talk.
Class-based views are a nice way of creating an API and allow implementations to change over time. There are various ways of doing class-based views and there isn’t an official blessed way, but class-based views would be an improvement (and offer more flexibility) than current function-based views in Django.

“Databases other than SQL”

With the growth in non-relational databases out there, I enjoyed starting to play with MongoDB (pyMongo and django-nonrel). After hearing experiences from the “NoSQL and Django Panel” it’s obvious that these are new technologies (relative to SQL) and that they are quite varied in what they support and the problems they solve. There are also pros and cons with schemaless databases.

Andrew Godwin (“Step Away From That Database”) also presented a nice range of databases – Document databases (MongoDB, CouchDB), Key-value stores (Cassandra, Redis), Message Queues (AMQP, Celery), Graph databases – and reminds us that filesystems are also key-value stores, and that version-control systems can provide a versioned storage.

“Data Migration”

Brian Luft’s talk (“Data Herding: How to Shepherd Your Flock Through Valleys of Darkness”) will resonate with anyone looking for better methods of moving from a legacy system to Django. He also highlights the opportunity and flexibility that Django framework provides for clients in moving them off of their desktop and legacy systems.

“Website Security”

Adam Baldwin (“Pony Pwning”) gave a great talk on website security and things to be thinking about while building Django sites.

Cross-Site Scripting (“xss”) vulnerability are alive and well. Though Django offers protections, these can be turned off or it’s easy to make a mistake in the template layer and open yourself up. You can learn more and play with xss vulnerabilities: http://owasp-esapi-python-swingset.appspot.com/xss/django

Adam suggests considering OWASP ESAPI, auditing templates, auditing reusable snippets, and educating designers.

For REST services, good to consider django-piston rather than writing your own.

Other things include checking upload extensions to avoid running arbitrary code, e.g. Django ImageField doesn’t check extensions and could possibly run embedded code. Apache “mod_security” as a nice monitoring tool that can let you know what’s happening, as well as prevent some issues.

“Exclusionary Establishment”

Eric Florenzano hit on some issues on the social engineering side of Django. Examples were presented that send messages of “your contributions aren’t important” out to the larger Django community – enhancements that went through all the steps but didn’t make it into core (eg truncatechars), key contributors not given committer rights (eg Alex Gaynor), no non-core developer code accepted into django.contrib.

James Bennett’s (“Topics of Interest”) reflected some of this too in the fact that there are very few core committers (14) and even fewer than understand the ORM and that they’re having a hard time growing core-committers. Eric’s mention of Guido van Rossum’s quote (creator of Python) “give out more commit privileges sooner”.

Participation could be easier and more inviting if more core devs are added and there is also less concern about breaking trunk.

Something I’ll add to this is that there were many talks submitted for DjangoCon so some were turned away, yet some presenters had 3 slots. Many of the talks were very good, but I think it would be healthy to have some opportunities for new faces to present, and not the same ones each year. (transparency note: our talk was one that wasn’t accepted)

“Become a Django Core Developer”

Given the concern about lack of core committers, Russell Keith-Magee (“So you want to be a core developer?”) was timely. In addition to going through the process of contributing code, he also mentioned that contributing to the Django community in the form of help (django-user list, stack overflow, etc) and writing new docs (tutorials, howtos, elaborating on existing docs) is key.

“Interesting Apps and Projects”

The lightning talks and Eric Holscher’s talk (“Large Problems in Django, Mostly Solved”) were a good source of Django apps to try if you’re not already using them.

Eric also shares his measure of what makes a solid reusable app – needs to have an easy setup, a good upgrade path, good documentation and well-tested.

Apps he mentioned were Haystack (search), Sphinx (documentation), South (db migration), Celery (delayed execution), Fabric (deployment), gunicorn.org (async server), pip and virtualenv (packaging), TastyPie and Piston (RESTful), Taggit (tagging), Hudson (continuous integration tool), django-filter (django admin filtering), djangopackages.com (for finding new apps).

Some interesting things from the lightning talks:

http://djangopackages.com (a Django Dash project)
http://readthedocs.org (a Django Dash project)
logbook - http://github.com/mitsuhiko/logbook

“Performance”

Frank Wiles’ talk (“Alice in Performanceland – Down the Rabbit Hole”) was full of a lot of tasty morsels to help you “do less” and “remove pressure on your server” that ultimately increases the performance and responsiveness of your site.

“Code Quality”

Human code review is best says Peter Baumgartner in his talk (“Monitoring Code Quality in Your Django Project”). There are also many great code quality tools out there that many of us use: test suites, code coverage, link/pep8, profiling, code complexity metrics, value – and pulling this together via Hudson. Also, creating a build in one step is offers new developers a fast way to get started on a project.

“Managed Django Hosting”

I missed Nate Aune’s lightning talk on his DjangoZoom.com cloud deployment solution, but looks interesting. http://djangozoom.com/ponyexpress/

One of the lightning talks discussed the django-servee project: http://www.servee.com/features/ http://github.com/servee/servee

“Seeing some New Faces”

It was nice meeting new people who are using Django in Washington State outside of Seattle, such as in Richland and Spokane, and reconnecting with friends from the Plone and greater Python communities.

Here were some DjangoCon 2010 highlights for me, along with talk titles so you can find the full presentation videos online.

Creating better apps

Narrower abstractions would make apps suck less – such as not directly exposing models (create an API) so you can swap out model or implementation. This was also a big part of Alex’s talk.
Class-based views are a nice way of creating an API and allow implementations to change over time. There are various ways of doing class-based views and there isn’t an official blessed way, but class-based views would be an improvement (and offer more flexibility) than current function-based views in Django.

Databases other than SQL

With the growth in non-relational databases out there, I enjoyed starting to play with djangon-nonrel with MongoDB. This project also supports Google App Engine.

After hearing experiences from the “NoSQL and Django Panel” it’s obvious that these are new technologies (relative to SQL) and that they are quite varied in what they support and the problems they solve. There are also pros and cons with schemaless databases that you should be aware of when picking your solution.

Data Migration to Django

Website Security

Adam Baldwin (“Pony Pwning”) gave a great talk on website security and things to be thinking about while building Django sites.

Adam suggests considering OWASP ESAPI, auditing templates, auditing reusable snippets, and educating designers.

For REST services, good to consider django-piston rather than writing your own.

An Exclusionary Establishment?

Eric Florenzano hit on some issues on the social engineering side of Django. He provided examples of situations that can send the messages of “your contributions aren’t important” out to the larger Django community – enhancements that went through all the steps but didn’t make it into core (eg truncatechars), key contributors not given committer rights (eg Alex Gaynor), no non-core developer code accepted into django.contrib.

Participation could be easier and more inviting if more core devs are added and there is also less concern about breaking trunk.

Something I’ll add: My understanding is that too many talks were submitted for DjangoCon so of course some were turned away, yet some presenters had more than 1 slot. Many of the talks were very good, but I think it would be healthy to open up more opportunities for community members to present.

Improving Django and Becoming Core Developer

Interesting Apps and Projects

The lightning talks and Eric Holscher’s talk (“Large Problems in Django, Mostly Solved”) were a good source of Django apps to try if you’re not already using them.

Eric also shares his measure of what makes a solid reusable app – needs to have an easy setup, a good upgrade path, good documentation and well-tested.

Some interesting things from the lightning talks:

http://djangopackages.com (reusable apps, sites, tools – a Django Dash project. Nice work Daniel Greenfeld!)
http://readthedocs.org (hosted help documents – a Django Dash project)
logbook - an easier way to add logging to Django

Performance

Improving your Code Quality

Managed Django Hosting

I missed Nate Aune’s lightning talk on his DjangoZoom.com cloud deployment solution, but looks interesting. http://djangozoom.com/ponyexpress/

One of the lightning talks discussed the django-servee project: http://www.servee.com/

Thanks DjangoCon!

It was nice meeting new people using Django in Seattle and in other areas of Washington State, such as in Richland, Wenatchee and Spokane – and reconnecting with friends from the Plone and greater Python communities.

Thank you to the organizers, presenters and supporters for another great DjangoCon!

TAF's TechStart Expo 2010

Sat, 19 Jun 2010 23:55 GMT

Brian Gershon headed down to White Center to see the final event of the season for TAF’s TechStart program.

“TechStart is TAF’s free, yearlong after-school program for students in kindergarten through 8th grade. The focus of TechStart is providing science, technology, engineering, and math (STEM) enrichment to underserved children of color through project-based learning and advanced technology tools.”

There were three event themes in Robotics (using Lego Mindstorms), including:

The Hand Crank Race where students had to build a robot, and power it by crank, and get to the finish line.
The Wind Turbine Event, where students had studied alternative wind energy and created a turbine connected to a robot. The robot would calculate the speed to determine which turbines had the best design.
And the Archery Event, where students are given the distance to the archery target when they show up to the event, and then they need to program their robots to try to stop perfectly on the center of the bullseye.

Here are photos from the event.

Also, here is some video from the Archery Event:

TAF Academy's Final Projects in JavaScript

Sat, 19 Jun 2010 23:41 GMT

Alex Tokar, Yonas Seifu and Brian Gershon went down to check out the final projects at Technology Access Foundation’s Academy class in Federal Way.

This was the first class there to teach JavaScript, taught by Seth Nelson and Susan Evans.

We saw Tic-Tac-Toe, a yo-yo animation, a Magic Eight Ball game, “guess that image”, and even a slot machine.

The students did a fine job, and it was impressive to see what 10th grade students were able to learn and accomplish in a limited amount of time.

[caption id=”attachment_188” align=”alignright” width=”300” caption=”Tic Tac Toe in JavaScript”][/caption]

SURF iPhone and Android Incubator: Upcoming events and a strong initial Meetup

Sun, 17 Jan 2010 13:38 GMT

There was a nice turnout of around 40 people at the SURF Incubator on Wednesday Jan 13th.

There were really three events being held at the same time:

SURF Open House
SURF iPhone Coding Night Meetup
and a last minute merge of the “iPhone App Developers” Meetup

The merging of events ultimately created a room full of interesting and engaged people who were networking and discussing mobile app development.

I would say that most were there to network, and some were there to play with code.

The networkers were a nice mix of entrepreneurs and people looking for iPhone developers. The coders were mainly new developers (and some graphic designers) that were getting into iPhone or Android development. The coding part of the session ended up very light because the event took on more of a networking feel.

The Open House event was an active Q&A session for those interested in the incubator, upcoming plans, and how to get involved.

[caption id=”attachment_185” align=”alignright” width=”400” caption=”Jeff Yochim, Brian Gershon, Dan Dosen. Photo by Seaton Gras.”][/caption]

I personally made some new connections, reconnected with other iPhone developers and designers, and met people who I hadn’t run across yet at other iPhone events. The feeling was that there was pent up demand for iPhone networking and coding.

More about SURF Incubator

The SURF space is available as a location for people to collaborate and work on code together – open every weekday during January. The space is also available for other iPhone / Android events. There are desks for people to pair up or meet in groups as well. The plan is to ultimately host many events and activities, and there is also permanent space for developers and those building businesses. This month is the Open House so people can start to explore and use the space. http://surfincubator.com

The recent events have been geared toward iPhone, but the SURF Incubator will also host Android events. This would open up opportunities to create synergies between the two platforms.

Have feedback?

There is also a new IdeaScale portal for people to post feedback to at http://surfincubator.ideascale.com

Upcoming Meetup Events at SURF

The “Seattle iPhone & Android Incubator” Meetup is an umbrella for upcoming workshops and coding sessions at SURF.
- The plan it to have host regular coding sessions/workshops around specific themes and experience levels.
- Please join this Meetup for a calendar of upcoming events.
- On Monday, there will be a Beginner iPhone SDK Xcode - Q & A Discussion Meetup.
- These events would also complement the existing NSCoder group by adding an additional location for those that can’t make it to the University Village Zoka event.
The “iPhone App Developers” Meetup hosted by Andrew will be located at SURF Incubator. I haven’t attended this Meetup, but it looks to be a nice opportunity for networking.

More iPhone-related events

We’re fortunate to have many opportunities to meet and code in Seattle.

XCoders – which offer a presentation, post-meeting networking at Luau, and an active email list. There are two meetings per month: One in Seattle and one on the east side. http://www.seattlexcoders.org/
NSCoder Night – meets each Tuesdays at University Village Zoka in Seattle. http://nscodernight.com/?cat=28

Open Tagging on OSX: A Powerful Way to Organize

Fri, 25 Sep 2009 21:23 GMT

For each project I work on, I have a multitude of files, folders, applications, and web pages.

My goal is to have shortcuts in one place, organized by project, as the ultimate launcher.

Here were some good initial attempts:

Firefox bookmarks might be a nice way to go, but doesn’t make it easy to link to local files, so that solution was quickly dismissed.
Butler did this well – a quick click in the menu bar pulls up a hierarchical list of projects and shortcuts to resources for each project. You could easily drag and drop URLs as well as local file shortcuts to Butler as well. This approach basically created a nice external bookmark manager not tied to any one browser and able to link to files of all types.
Recently I noticed that Snow Leopard’s improved Grid (in the Dock) now allows for navigating down a hierarchy of folders quickly, so though about putting my shortcuts there. The only problem is that the dock is “way down there” (irregardless of where you put the dock) and takes time to mouse around.

Each tool took their own approach, and I had to pick one since I couldn’t easily use multiple ones. Also, graphical solutions still take precious time to drag your mouse and navigate through the hierarchy.

Then a better idea.

Spotlight is quick and fast for searching so is ideal (just press apple-spacebar) though typing in search phrases still brings up lots of extra information I don’t want.

So how do I universally “tag” resources and bring them up quickly?

First, the cool 2006 (and still usable) metadata solution mentioned on LifeHacker: Apple-I on files you want to tag, then add a custom tag into the comment box. Prefix with & so it’s quick to find without bringing up a lot of other crap. For my common Web Collective company shortcuts, I used &wc. Now, when I jump to Spotlight and type &wc, I instantly see all my shortcuts.

This was great, but then I found tagging nirvana on OSX.

An ecosystem of tagging tools has popped up around a free and open source OpenMeta Tag standard.

OpenMeta means that you can now tag files, folders, emails, web pages, etc, with an assortment of tools, and then search for them with an assortment of tools. No need for custom tagging in the file “comment” field, and no need to use a proprietary tagging system that locks you into one tool. (Btw, for web pages, I drag a shortcut from the browser to my file system, then tag the resulting .webloc file)

The simplest workflow consists of tagging files by dragging/dropping them onto Tagger, then pulling them up quickly in Spotlight. To pull up all my shortcuts tagged with “wc” you just type “tag:wc”. This is a free solution and works well.

Next in the evolution are tools such as Tags or Punakea or Leap – which make it easy to tag, while also having nice integrated search features. Tags makes it easy to tag email (in addition to files and folders), Leap (the creator of OpenMeta) is interesting because it has a very fast and flexible searching mechanism and basically does all the work of the Finder with the powerful addition of tagging and rating. These are all paid applications – well worth it if they help you to better organize.

I’m still playing around to find the right combination of tools for my own workflow. See http://code.google.com/p/openmeta/wiki/OpenMetaApplications for a nice list.

Tagger and Spotlight are working well for quick shortcuts – Tags, Punakea and Leap start to show what a world would be like when relying less on hierarchy and more on tags.

Hmmm, TagFolders looks pretty interesting too…

DjangoCon 2009 Recap

Mon, 14 Sep 2009 16:21 GMT

After catching the great videos from last year’s first DjangoCon I looked forward to attending this year. I’m glad I went.

We’ll be discussing “What did we learn at DjangoCon?” at this Thursday’s Django Seattle. See http://www.djangoseattle.org for more details.

In the meantime, here are some high-level take-aways:

Should JavaScript and RESTful services be part of the Django core? JS is even more useful/powerful with the latest fast JS engines in Chrome, Firefox and Safari/Webkit. Competitor Rails builds in RESTful features - some promising ones for Django include django-piston and django-roa. I liked how Ted Leung talked about “science experiments” and posed many ideas on what we may want to experiment with to get right before approaching Django core.
Git - Though this doesn’t directly relate to Django, DVCS systems like Git and Mercurial are in wide use. SVN is a given, but now feel I need to know Git and Mercurial well - since popular projects are using these. I also wanted to pick a “pet” DVCS to use as my default too. I’ve chosen Git (mainly because of git-svn and GitHub), but will be using Mercurial as well.
Django Tips and Tricks - Many to pick from, but I liked Query.as_sql() method to show the SQL the Django ORM generates on your behalf, the flexibility of using “signals” to loosely couple functionality (see django-signals-ahoy on bithub), reusing other Python WSGI middleware (such as repoze.bitblt, repoze.squeeze, repoze.profile), pylint/djangolint, class-based views, db schema migrations with South, much faster test speeds in Django 1.1, various test utilities floating around, talks on performance, etc.
Django jobs are growing, and Django also a popular platform for Start-ups.
Check out the DjangoCon2009 Wiki for slides and presentations.

Snow Leopard Smooth Except Python 32/64 Cocktail

Wed, 02 Sep 2009 20:11 GMT

UPDATE: Thanks to the helpful commenters, I found success getting an older Zope instance running on Python 2.4 on Snow Leopard using buildout.

NOTE: This post is for installing Python 2.4 on a brand new Snow Leopard Instance. If upgrading on top of Leopard, you may have to update easy_install, macports, etc. More Googling around may be required.

Though I had to create two buildouts to get this to work – is there a way to get this into one buildout?

I first tried to create one buildout by combining Florian Schulze’s buildout recipe with a standard Zope recipe – but since initial bootstrap was run by Python 2.5, I couldn’t get the Zope instance to use the new Python 2.4. So I first ran a buildout to build Python 2.4 (using OSX-installed Python 2.5), then used that new Python 2.4 to run bootstrap.py on the Zope 2.8.x buildout.

Here’s the recipe I used to just build Python 2.4 (requires Florian’s buildout, see Alexander Limi’s comment below for where to find this):

[buildout]
#extends = src/snowleopard.cfg     # no longer required as Joe mentions below
python-buildout-root = ${buildout:directory}/src
parts -=
   ${buildout:python25-parts}
   ${buildout:python26-parts}

[install-links]
prefix = /opt/local

Then I ran a simple Zope 2.8 buildout to see if it would compile (using new Python 2.4 to bootstrap), and it did!

[buildout]
parts =
   zope2
   instance

[zope2]
recipe = plone.recipe.zope2install
url = http://www.zope.org/Products/Zope/2.8.9.1/Zope-2.8.9.1-final.tgz

[instance]
recipe = plone.recipe.zope2instance
zope2-location = ${zope2:location}
user = admin:admin
http-address = 8080
debug-mode = on
verbose-security = on

Here is my initial post:

I have to say – most everything I’ve installed on a fresh Snow Leopard install has worked flawlessly and swiftly – except for (the minor inconvenience of) iStat not working. UPDATE: iStat 2.0 is available for Snow Leopard now. There’s a new beta of MenuMeters too for Snow Leopard.

There are also nice subtle improvements, see Mac Life’s 100 Top Snow Leopard Tips, Trick and Features for improvements to Preview, Expose, Stacks, etc. I’ve very happy with the upgrade.

Now for the bad news for those like myself who depend on Python 2.4 for Plone, since many versions of Zope require Python 2.4. I also use Python for Django, though that should run fine on Python that shipped with Snow Leopard.

You can read many of the initial details around the web, but here’s what I’ve experienced and have been able to put together:

Note that these details are for a fresh Snow Leopard install - there are a different set of issues if you’re upgrading over your existing Leopard. NEW: “Clark’s Tech Blog” has a nice write-up about upgrading Python after upgrading Leopard to Snow Leopard.
Snow Leopard ships with Python 2.5.4, and this runs as a 32-bit application.
I also need 2.4 branches of Python too, so I tried rolling my own (as usual) and it didn’t compile. I then followed that thread for awhile.
I then thought I pulled a fast one when I compiled from MacPorts and everything ran great!
… but then I compiled Zope, and attempted to run an instance. I saw a mysterious “No such file or directory” error. Hmmm, I can navigate to that file, but running the script with my new Python interpretor was causing this error.
After digging around with Activity Monitor, I discovered that the Python I built from scratch was running as a 64-bit app – while the Python that comes with Snow Leopard was only running 32-bit – which is telling, since most everything else on Snow Leopard is running 64-bit.
Guessing that the the mysterious “No such file or directory” (when the file and directory did indeed exist) was due to a weird cocktail of 32-bit pieces living with 64-bit pieces.
My latest theory was that I needed to figure out how to build Python as 32-bit. I played with Macports and various architecture settings to hardwire this, but long-story-short – the architecture override isn’t used everywhere – so parts still compile natively as 64-bit on Snow Leopard.
The best thread on the topic (that’s steadily growing) is here: http://bugs.python.org/issue6802 with msg92153 left today, which basically offers some additional settings for compiling Python as a 32-bit app (for Python 2.6). Also mentions that Snow Leopard did some magic to get Python 2.5 working as a 32-bit app.
My hope is that once “32-bit” Python 2.4 happens, the rest of the Zope install, etc, will be back to the good ol’ days in Leopard.

Plan B’s:

Otherwise, to save some headache, I’m wondering about installing a small Linux distro on VMWare as a local mini web-server where I can easily install Python and Zope – though that’s a bit of a pain too.

Luckily I also have my old Leopard in a separate partition (see my Extra life for my MacBook Pro with Snow Leopard and inexpensive hardware blog entry) and can boot that if necessary to work on various Zope/Plone sites (that required Python 2.4) while this is all being sorted out.

Now time to see if I can get 32-bit Python 2.4.6 compiled and installed, while waiting for more patches and information to appear…

Extra life for my MacBook Pro with Snow Leopard and inexpensive hardware

Sat, 29 Aug 2009 13:32 GMT

I’m using the Snow Leopard upgrade as a chance to add some extra life to my (older) MacBook Pro (2,2).

My goals:

Max out memory to 3GB (up from 2 GB) – $29
Upgrade hard-drive to 500GB (up from 120GB) - $129 for a 2.5” Seagate Momentus SATA 7200 RPM. My current drive is 5400 RPM, so this will be a speed improvement too.
I also want to install the OS from scratch as a chance to clean things out.
Hey, I can then even upgrade my wife’s laptop with my 120GB drive!

The steps have been pretty easy:

Backup whole drive using SuperDuper! to a bootable external drive. If I didn’t want to install Snow Leopard from scratch, you could then just transfer your previous OS back to the new hard-drive and be done.
Upgrade memory, piece of cake
Upgrade hard-drive. I like to do this sort of thing myself, albeit Apple is the official place to have this done. This takes a Torx 6 screwdriver, and some patience, but was fairly easy to do thanks to http://www.ifixit.com
Start Installing Leopard. Note that you do not need to install Leopard first for a brand new install. I just put in Snow Leopard, and booted holding down “C” and the installer popped up.
Since the drive is large, I decided to take an extra step of partitioning my drive into 2. You can run Disk Utility right before starting the install to create these. One partition as my main one for Snow Leopard, and the other as a complete bootable Leopard exactly the way my laptop was before the upgrade – just in case I forgot something – and I can easily pull files over while doing the big reinstall-everything-from-scratch step. SuperDuper! makes this easy – both to backup your drive, and restore it on a new partition.
Frolic in all my new hard-drive space and anticipated speed improvements – more memory, faster hard-drive and faster OS.

Django Seattle's Website Barn Raising Sprint: A Recap

Sun, 26 Jul 2009 23:00 GMT

New Django Seattle Website

Thanks to 14 Sprinters who came together on July 25, we now have a Django Seattle Website at http://www.djangoseattle.org

[caption id=”attachment_60” align=”alignright” width=”640” caption=”Some of our Django Seattle Sprinters”][/caption]

There was a lot of infrastructure work done at the sprint which is still in development and didn’t make it to the live site yet – but the experience of getting to know each other, and learning/sharing Django knowledge was another fine Sprint accomplishment.

Here’s a brief summary of what people worked on:

Integrated in Blogging, Profile and Calendar functionality from django-basic-apps. Initially Pinax was explored, but had a lot of dependencies and seemed better for creating specific sites genres, but was challenging to incorporate into our existing site.
Created a Twitter portlet that shows live #djangoseattle Tweets.
Setup Flatpages for core content, and creating a database-driven menu
Created a logo and initial site design and templates
Setup Django on live server
Used the Django Debug Toolbar while developing the site
Some were playing with Django for the first time
Some floated around to help diagnose problems and help those new to Django

[caption id=”attachment_59” align=”alignright” width=”640” caption=”Functionality brainstorm”][/caption]

Thank you Sprinters

Our sprinters (in alphabetical order) were: Andrew Beyer, Jon Callahan, Jesse Franceschini, Doug, Brian Gershon, Johann Heller, Paul Pham, Micah Ransdell, Leo Shklovskii, Trevor Smith, Jesse Snyder, Alex Tokar, Ragan Webber, Ben Wilber

Thank you Sponsors

Also a Big Thank You to our sponsors, hosts and organizers.

Jon Callahan at Mazama Science treated all 14 of us to a tasty PCC Natural Markets lunch, coffee, drinks and snacks.
Michael Kim at Grapevyn brought in Top Pot Doughnuts.
Paul Pham hosted us at his coworking space Office Nomads which was a great place to have a sprint.
Leo Shklovskii at Evoworx and Brian Gershon at Web Collective had a great time organizing the sprint.

We look forward to our next sprint!

Idealware compares Drupal, Plone, Wordpress and Joomla

Fri, 03 Apr 2009 16:55 GMT

Nonprofit software info source Idealware has published what might be the best objective review of the top open source CMS solutions available today. Having read the report and having worked extensively with all four systems for many years I can definitely recommend it for anyone considering the content management software options.The report reinforces many of the messages I use to differenciate