[TriZPUG] Shining Panda?

[Tom Bryan]

On Saturday 18 September 2010 17:17:23 bob gailer wrote:
>   On 9/18/2010 3:15 PM, Tom Roche wrote:
> > Anybody using this?
> >
> > http://www.shiningpanda.com/
> 
> I visited the website. I for one could use a tutorial, as I can't begin
> to guess how I'd use it. Or perhaps I am in the category "if you have to
> ask you don't need to know".

I just glanced at it, but the words "continuous integration" tell me most of 
what I need to know.  http://c2.com/xp/ContinuousIntegration.html

History: Especially on large systems, it was (and still often is) common for 
people or entire teams to own large parts of a system.  They would work in 
some isolation so that they didn't have to keep rebuilding the system.  (If 
you have a monolithic C application that takes hours to build and link, it's a 
very practical concern.)  So, people would work on their own sub-system or 
even on their own module within a sub-system.  Then, periodically, all of the 
recent changes from everyone's private branches would be merged and 
"integrated" together. 

Back to your question: Continuous integration is a process that tries to move 
away from the approach described above.  In a language like Python (or Java, 
Smalltalk, etc.), you don't have long build and link times.  Some people still 
preferred isolated development with periodic integration of all of the modules 
of the system.  Continuous integration is a combination of multiple ideas, but 
it starts with the belief that developers should see each other's changes as 
soon as possible.  With an SCM system like Subversion or CVS, that normally 
means that everyone is working on the same branch, and everyone commits often, 
and everyone updates his local sandbox often.

The danger is that someone will check in code that breaks things, and everyone 
is suddenly impacted.  If you update, and someone changed a signature in a 
library without changing all callers, your sandbox code may suddenly not run 
(or not compile).  If you have a dozen people on your team who suddenly can't 
run and test code in their sandbox, it's a problem.  

To avoid that problem, a "continuous integration server" is normally used to 
monitor the SCM system.  When someone commits code, if the server isn't 
already busy, it checks out a new local sandbox from scratch, builds the 
entire system (kind of a non-issue for Python), and runs all of the unit 
tests.  It may do other things like run analysis tools like PyChecker or 
deploy successful builds to a staging server for further automated testing 
using something like Selenium (for a web application).

When most people talk about continuous integration, they're thinking of the CI 
server.  You check in code, it checks out the latest code, builds, and tests.  
That way, if someone checks in code that breaks the build or unit tests, 
you'll know right away (often within minutes, depending on how long your tests 
take to run).   That way, everyone knows not to update his sandbox, and the 
developer who broke the build stops what he's doing and fixes the build.  

In a small team, it's maybe not essential.  It's really useful once you have 
10 or so people all working on different parts of the same code base.  It's 
already a big time saver once you have 20 people on a project.  It also gets 
you away from the "works for me" excuse.  If it's not working on the CI 
server, it's not working.  :)

To make all of this work, development with CI uses some ideas from agile / 
extreme programming methodology.  For example, each commit is some complete 
piece of functionality.  Basically, whatever is on the HEAD of the main 
development branch builds and works.  A feature may not be done, but all of 
the parts of the code that's checked in work and work with the rest of the 
system.  To avoid potential of widespread build breakage, developers normally 
try to commit often, developing a feature incrementally.  

So the real answer to your question: It looks like Shining Panda is a CI 
system that monitors your project's commits, if you're using one of the hosted 
development platforms like github.  On a successful build and test, it looks 
like it can deploy the "snapshot" build to various systems, like PyPI.  

---Tom