Code snipplet sharing
This post is a "fork" from the original post by Danielle, posted here. Here's what it reads:
Rouben, this could work really well with my idea for a university code repository - if users wanted to upload code snippets (with metadata tagging), along with descriptions of the projects that they're working on, not only could other users see what kind of work is going on in the university, but they could also search through the solutions to various programming issues. This would be more complicated than a "dating" application, of course, but the two could certainly be integrated.
As for giving users incentive to use the application and keep it updated... no bright ideas yet, but I'll have a think on it. Do GeekPoints lead to some kind of carrot? Maybe there could be prizes associated with levels achieved: 300 GeekPoints = some form of U of T paraphernalia, like a mug. 3000 GeekPoints = Bob Cook bakes you a cake. ;)
I'd like to brainstorm a bit on code sharing. My initial reaction was to use something like pastebin.com, but probably with a heavier social networking component built into it. Another possibility is something like github.com. The latter is a bit of a stretch, but I really like how it just works, and in my opinion, it's a really progressive way to collaborate on programming projects. Distributed version control (git) with a tad of twitter (hub) sprinkled in. I could go on trying to explain how it all works, but I think seeing a demo is the best thing really, especially done by a developer: http://www.fosslc.org/drupal/node/421
to elaborate...
Let me fill in a few blanks about my idea:
1) This application would allow coders to upload any bit of code that they think might be useful to others, or that they just think is cool.
2) Uploads could be tagged for search purposes, and also would require a description so that users know what they're looking at.
3) Any submission would default to anonymous. I've found that even the most experienced developers balk at the idea of putting their name to code for fear that it will be seen as inelegant. If anyone feels like showing off, however, they can always autograph it.
4) Some kind of voting system would be in place, so that anyone who found the solution useful (or not) can say as much.
Rouben made a few suggestions as far as code storage/sharing for tracking versions and comments (thanks R!). If anyone else has thoughts or suggestions - bring it.
Awesome Idea...some points to consider
Interesting idea Danielle,
In theory if such a system existed it would be nice if not only bits of code could be referenced, but also if the system could include current projects (which would be applicable for the geek point system of course) that are currently underway in a kind of subversion-like repository for the U of T community - perhaps even to the public, although that is tricky one since the code must not reveal anything that could potentially be exploited in a security sense. In addition, the code must also not make light of business processes that are considered to be confidential.
I believe a sort of sourceforge-like system would work here that has a project wiki-like portal that that can be used to post information about how to utilize the code for example. Using a wiki-like page would provide a good vehicle for creators to update their documentation in a more streamlined fashion. Also, people could contribute modified versions of the code they downloaded and/or used, where it could be (if the creator chooses of course) later merged into the original code base (evolving the code into something even cooler).
A chink in the armor that must be noted is that the code uploaded would in many cases be originating from a project would have to be approved by the owners of that project before it can be made available to the masses. The problem lies in fact that the code is actually the intellectual property of the stakeholders (and not the developer) for whom the code has been written for and in most cases not the developer. This may not be a problem (of course) if it is owned by the institution, or the developer (if not produced through University resources), but it could potentially become an issue if the code was developed as part of a faculty research project, or for another third party.
Just some things that may needed to be considered if we decided to go that route...It's an amazing idea and I too have thought about how we could accomplish something like this...but it is something that requires a bit of discussion and possibly some examination of current policies before we can continue.
Security, obscurity and intellectual property
Theoretically speaking code should be secure, even if it is completely open and visible and plastered all over the Internet. Of course obvious things like hard-coding database access credentials into one's code should be avoided... but that's a different topic. The best way to write secure (and just plain sane) code is to think about the problem, not shovel it under the carpet. :) That carpet shoveling model has been consistently demonstrated as suboptimal if not flawed.
In terms of politics surrounding contributions, I absolutely and mirror your concerns. Whose intellectual property is the code if it's developers on "free time" and not on university's resources? Theoretically it becomes the author's, not university's IP (please feel free to correct me if I'm wrong). Open source licenses solve that dilemma nicely by making it everyone's intellectual property, quite literally (including that homeless man by the Tim Horton's in front of OISE who probably has no clue what we're talking about or that this web site exists).
Politics bring me back to the issue of support... and by support I don't just mean monetary resources... the biggest obstacle that the "open" crowd at U of T will face is the cultural inertia. Unfortunately historically (as far as IT goes) U of T never encouraged collaboration. Things were always siloed (they still kinda are), probably, as Mark mentioned during Bob's Q&A period, partly due to the funding model. Another big reason for the siloing is simply U of T culture. Nothing wrong with that, it's just the way people are used to thinking and operating here. There are other reasons, of course, but in my opinion those are the two major ones. So the big question is, how do we change this culture?
Hello Guys Idea with code
Hello Guys
Idea with code sharing sounds great and create application as FB is amazing! Will be happy to help with coding if you guys do not mind :)
So I guess Ruben you idea to create a open source community is starting to happening :p
code review
I don't know how many coders in UofT. My biggest problem with UofT software development is: lacking of QA. While there may not be a funding for a QA position in one dept, P2P code reviewing could be possible.
FYI, while I am not a fan of Java, one may have a look on this: http://sonar.codehaus.org/
Shift of Focus
I like the repository idea, but let me put a spin on this discussion: instead of focusing on building yet another code bin, let's focus where the action is: developers... people. Based on my limited experience, the best results occur when a group of talented individuals gather around a common goal and make it happen. Let's face it - any of us could smack up a code library this weekend, apologize for it Monday and then get on with using it. Come to think of it, that's where this site came from (less the apology). :)
I think the best way to get this ball rolling would be to put together a core group devoted to the initiative (like the people in this thread), front it with some strong leadership (which looks a lot Rouben to me), pick a fantastic project and make it happen. If you've really got game, you'll make the project multi-phased and massively hackable (in the Mark Surman sense) so the success of Phase 1 will pull in the broader community.
This doesn't necessarily need to sit inside the walls of the university. We could always reach out to existing communities and come in as a team. For example, I hack on Drupal (poorly) and I see code sprints organized all the time, with teams from various corners bringing concentrated talent to the table. DrupalCamp Toronto is happening at MaRS in August. Wouldn't it be cool to show up with a pile of php freaks as Team UofT and a funky new module? This is just one of many possibilities but the point is this: the best way to get things moving is to pick a direction and start walking (not to sound too pointy-haired manager or anything).
I agree with Greg the first
I agree with Greg the first you need to think what you want to create, I think this is the hardest thing.
And then keep this idea alive during all the way of developing.
And coding is not the hardest part, so many open project is out there...
Sweet...lets start the process to make something cool
I have been talking to Rouben for the last few weeks brainstorming about cool things that we could do (and I agree with you Greg - Rouben's got a good head on his shoulders for this type of thing and I strongly believe he should be one of the leads on this). We could create a community open source team initiative forum on this site and hit it out to come up with some cool ideas (including the cool ideas already mentioned so far) for those interested with the passion (and some extra time) to do something potentially cool that could benefit the university and community...what do you say - shall we rally the troops?
If you build it they will come... as long as they're interested
I'd love to get to a point where we can actually show off our stuff at an event like DrupalCamp! That will take some time and effort, though.
While code sharing dynamics are crucial, I agree with everyone that this shouldn't necessarily be our primary focus at the moment. We shouldn't be mothballing this topic, just "zoom out" a tad. I also agree that collaboration should be driving the code library "spec", and not the other way around. Trying to predict one's needs (even your own) is very difficult and usually doesn't work all that well. We should start small and work our way up, keeping an eye out on the "big boys" (eg. github and SourceForge); learning from their mistakes and successes. Code dynamics (sharing, review, quality control, etc) will become a critical part of collaboration, just not at this point.
Scott's thread on AV represents a good example of a brainstorm topic of finding a common enough "itch" to scratch; something (almost) everyone at U of T could use. AV apps is certainly something that almost everyone at U of T can identify with. Another idea I can think of is mailing lists and targeted communications in general. ListServ and MailMan are good, but they have their drawbacks and they're certainly not for everyone... How about marrying PHPList to a UTORrole prototype as a potential "one size fits all" solution? Just brainstorming...
The best part is, the diversity of potential users at U of T is staggering! :) Diversity breeds innovation and makes one think outside the box! Let's hear some ideas! Let's create some threads!!!
It really depends on what you want to accomplish ...
Both ideas have their own terrific merit, I think.
I definitely agree that there is certainly a good point to providing a good resource for active developers within the institution. It's certainly needed.
There are a lot of other 'developers' that this model wouldn't help. I'll come clean here,
I admit to having had a similar epiphany to Danielle - there are a lot of academic users / developers and users out there that could use something more akin to a 'cookbook' reference rather than a development center. In my mind, there are a lot of people who aren't exactly doing programming (SQL queries, R/Stata/SAS/S+/Matlab/, simple shell scripting, etc etc etc) that a recipe book would be useful for.
I don't see these ideas as being mutually exclusive at any rate, and both are needed. Will follow up with Danielle.
Cheers! -- p
Pastebin + tags?
What do you think?
Possibly...
Simple = good
but
Meta-data = important
Putting together a pastebin or cookbook is a fine idea, so long as sufficient description can be attached to the source or linked to the entry so that others can find it. Some means of grouping sets of recipes within a topic (eg. R), or across topics (OLS Regression in R, S+, STATA, etc).
Tags!
See, I'm curious how people feel towards tagging. Dirt simple, and with a smart enough tagging mechanism (I like how drupal does it, looks tags up on the fly with AJAX and suggests similar tags, so you don't end up creating a new one; helps avoid "apple" vs. "apples").
Categorizing is always a pain, because most people tend to overcategorize (see topic on forum topic categorization... somewhere on here).
Tagging good part of solution, but only part of solution
Tagging various snippets makes a great deal of sense - for the reasons you indicate and then some - and I would definitely want to see that a part of any snippet library. The issue I would have is that there would need to be some context, some explanation to make sure that the information is readily found and intelligible. In my mind, the goal is to build this snippet library not for programmers necessarily, bur rather for ordinary users.
Besides, if Drupal can talk DocBook as I'm led to understand, this should make it theoretically possible to dump the current state of the cookbook to PDF, PS, DTF, you name it. Insert evil laugh here, or something...
Definition of library
Indeed, we need to determine what the underlying purpose of such a library/cookbook entails... My vision was for something very simple, quick and dirty. Simply a "hey send me your code over MSN or e-mail" replacement. Pastebin.com offers lots of little nice things like syntax highlighting, visual diffs between revisions of each code snipplet as well as the capacity to highlight specific lines that you want the recipient(s) to focus on. With basic tagging (like utorauth vs. webdav, i.e. not very specific like "pam stack config file for xyz server") I think we can take the pastebin idea further. Throw in a tag cloud, and some good techie samaritans and hopefully you'll get useful input and criticism on what you're trying to accomplish.
Issues raised with such an app are as follows (credits where due to all who brought these up):
Comments? Ideas? Counter/(-counter)+/ arguments?
Bring these projects all together...
Just as an aside to this, I thought to mention that (in general) rather than having one-off applications perhaps sprouting up we should think about engineering these systems so that they are part of an existing portal (i.e. plugin modules for drupal) application and represent it as a U of T (underground?) suite. In this way we will be able to leverage existing frameworks (without reinventing the wheel) share data and build upon each one of the modules as the project evolves i.e. combining wikis/trac+pastebin functionality+new IT redbook. This can be done slowly of course, but as long as our foundation is sound we should be okay.
Just my 2 Euros ;)
Architecture
Oh, no worries, if we actually get around to implementing this, I'll let you sink your teeth into the architecture... :)
Re: Architecture
And I do have big teeth ;)
Joking aside (well, not really I actually do have big teeth), this would really be a good opportunity for all those developers, and other tech-aficionados out there so if we do get around to do something I am sure it will be awesome.