Teaching Open Source Planet is a Planet, a collection of personal blogs by Teaching Open Source community members working to bring the open source way into academia. We write about our inspirations and experiences in learning, teaching, and collaborating within free and open communities. In the spirit of freedom, we share and criticize in order to collectively improve. We hope you enjoy reading our thoughts; if you’re fascinated by what you see, consider adding your voice to the conversation.
This post won’t make much sense if you have not read my last.
By snooping around other peoples apps some more, I came across the puzzle groups JavaScript folder. In there I found what was allowing the puzzle pieces to be moved around. It is done by an extension to the jquery suite and adds support for drag on the iPad through touchPunch. TouchPunch has been added to the slideshow as well as jquery, which I made the decision to move away from earlier… Well now I’m back.
In theory I should just be able to add the “draggable” function to the image element. So far no luck. It maybe conflicts with the other drag function. I hadn’t thought of this until now. The problem is, when to call/allow the draggable function to be called. Each image is contained in a separate div, so when is the appropriate time? Something I’ll have to think about.
The other solution would still be what I talked about before. Updating the drag function as it stands now in MooTools-more and add touchMove events.
And… now that I brought back jquery support, maybe I should change the current swipe ‘tech’ in the app to jquery instead of the current iteration.
A lot to think about.
This is probably the last weekend I’ll be able to work on it. I hope I have big breakthrough. Again, the latest version I’m working on is on the test server.
In an earlier post Mark Johnson responded to recent commentary about unlicensed code on Github. Mark criticised the idea put forward by some pundits that developers not licensing their software project was some kind of movement. Instead Mark sees it as emerging from a lack of education (or, quite possibly, sheer laziness). He also reiterated the point that a lack of licensing clarity discourages community and harms reuse and sustainability of software. Experienced developers won’t touch unlicensed code because they have no legal right to use it.
However, I decided to follow up by seeing if I could start from the other end of the argument and identify some good – or at least acceptable – cases for where you might legitimately make your source code available intentionally without applying a license.
Here’s what I’ve come up with.
Licenses interact with your choice of business model. For example, some licenses are more useful than others when pursuing a dual-licensing strategy; some make more sense for software that provides online services; and each license provides some degree of advantage over others for particular cases (if there wasn’t, there wouldn’t be so many of them!)
However, for some projects its hard to identify early on what the business case is going to be, or even if there is likely to be any point developing one.
Your software experiment may turn into a liberally-licensed library, a copyleft and commercial dual-licensed application, or a service offered under something like the CPAL or AGPL, but maybe its too early to tell. Should you keep it under wraps while you work out where its going, or share it now and risk selecting the wrong license?
Releasing your code with no license while you are still deciding on an appropriate model is one possible option. The downside of this is that no-one will really be able to reuse your code until you do apply a license, and it is also likely to deter potential collaborators.
So even here I’d still recommend choosing a license and revisiting the choice later as the project matures: as the owner of the intellectual property for your software you always have the option of changing your mind, and your license, later on.
Changing licenses for software can be controversial and difficult, but at least you have more chance of developing a user community and partner network to have this argument with by making the initial code available under a recognised license.
Note that its also much easier to change from a more restrictive license to a more permissive one than the other way around.
There is a type of project where releasing code but not licensing it (effectively sharing code with all rights reserved) may make sense. This is where you have no interest in anyone else actually reusing your code, or building on it, or contributing to it!
Why on earth would you want to do that? Well, when the purpose of releasing the code is not to create viable software, but instead to provide transparency and reproducibility.
For example, if you have written software as part of an experiment, and you need reviewers to be able to replicate or inspect your work. In this case, there is no real expectation that anyone will take your code and reuse it for something else, or integrate it into any kind of distribution.
So maybe then you can just distribute the code, but not as open source or free software?
One reason why that may not be a great idea is that no-one else being able to make use of the code is just your perspective; from another perspective, maybe your code has a value you don’t realise? As Scott Hanselman points out, you can think of this kind of these projects as a “Garage Sale” where one developer’s junk is another’s treasure.
You may also be concerned that, by distributing your code under an open source license you may be raising expectations of what the code is for, or inviting a critique of your software development skills; this is a theme that Neil Chue Hong picks up on in a post over on the SSI blog. (Neil even points to a special license, the CRAPL, aimed at this sort of case.)
Even for very specialised academic code aimed at a single objective for a single paper in a specialist journal, the case can be made for releasing the code as Free or Open Source software.
(For another good discussion of this topic, see Randall LeVeque’s post Top ten reasons to not share your code (and why you should anyway)
Sometimes you get to work on a project as part of some sort of funded initiative, which, while not stipulating sharing your code as open source, does expect you to at least make the code “available” in some fashion.
So, like an artist locked into a record contract, when the funding runs out you may be tempted to just make a code dump somewhere in order to meet your obligations, and in a fit of spite not even bother put a license on it either.
However, the “garage sale” metaphor works well here, too. Maybe the project or initiative didn’t exactly set the world on fire, but maybe some of the code written in the process could still be salvaged for something.
You often find code snippets in blog posts or as solutions to questions on StackOverflow. This is very rarely explicitly licensed, but the assumption is that its usually OK to copy and paste without worrying too much about licensing. If you’re conscientious, you can always pop in a comment with a link to where you found it.
However, there are also grey areas, such as Gists, which are a bit more than a few lines of code, but not quite project in their own right.
Even with a small snippet of code, its not always clear whether or not copyright protection applies. For example, a lengthy example of how a standard Java library should be used would probably not be protected as it doesn’t involve much creativity. However, a two-line program that offers a novel solution to a problem could well be considered protected under copyright.
So, in some cases you may be justified in not bothering with a license for a snippet or Gist, but to avoid all uncertainty its still better to put in a license header, or at least make it clear you’re willing to license the code for anyone who wants it that thinks its necessary.
OK, I wouldn’t say this is a great reason, but it could be a reason.
Maybe you really do want to make people uncertain about whether they can use your code because … well, because thats the way you roll.
Maybe you’re happy to license your code, but only with people who ask you nicely first, and you don’t want them to be able to distribute their code as free or open source software for some reason.
Or maybe you are looking to bait the uncautious into copying your software so you can threaten them with lawyers and shake them down for money, because you are actually a Copyright Troll.
From this brief excursion I would conclude that distributing unlicensed code is never a great idea, and rarely even a good one, but I can see there are circumstances where you might consider doing it. In each case, though, there is usually a better option worth taking.
After counting the blog posts, I have only 12, and the course requires 14, so I will write 2 more random, CS-related, but not course-related, ranting posts.
So as titled, I will now describe what my summer plan for this summer is like!
For this summer, I got accepted for the REU program at Depauw University located in the beautiful town of Greencastle, Indiana. The title of the project I applied for is “Problem Solving using Parallel Programming.” here is the link & description http://my.depauw.edu/univ/reu/projects.html
This is a 10-week program. It starts next Wednesday the 29th, and I have to be there on the 28th. They provide up to $600 for traveling expenses. At first I was going to take a plane there, but then I google the town and found out it’s relatively(?) countryside, and no public transportation. Since I will be there for basically 2 1/2 months, I think I’ll need my car so I decided that I will drive there. Google Map says it would take around 15 hours, minus the traffic, to get there. So I will begin my 1-man solitary road trip this coming Sunday. Please wish me luck!
So far, we have not decided on what kind of problem we will try to solve for the summer. But I know that we will be programming in Erlang language. Erlang is a functional programming language that is mostly used for Parallism…or so Google says. Now I have started reading the book on Erlang, just to get a bit of a head start so I won’t be super lost next week, and it is quite different from (what the book calls) “imperative” language like C++, Java, etc. For example, it is highly similar to real mathematical equation in terms of the use of variables, like lets say, x = 5; you cannot say x = 5+1 now, because 5 != 6.
Anyways, then I was researching whether learning this language would make my resume look better and help me get a job after graduation, and the answer is…”depends.”
So Erlang is mostly used for solving problem through parallelism to speed up the computation time exponentially. But most of the time, this only happens in research institutions, not really business corporations. So if I want a research job, or grad school, knowing functional language will help upping my candidacy a bit. Although I guess more and more companies are starting to utilize parallel programming and more functional programming jobs are becoming more available, and the pay is quite good (w/ experience of course). So if it turns out I am able to pick up the language and I like it, I might as well stick with it, since some article said that non-mainstream language programmers hardly ever get laid off….so we’ll see!!
*EDIT: after some more googling around, I found that there are quite a few of jobs available for Erlang with OTP and databases…so yeaa I will see how far I can understand the language after the summer!
I just had to make a couple of changes to the Introduction Page as Tim requested. All I had to do was, moving the navigation (left+right) buttons to the center of the page, and also have it say “next” and “previous.” That is all!
This course has been a very valuable for learning what it is like to work in a real development environment, as well as working in a large group. Working in team is not new to me; at my internship we work in a small team of 3. But working with a team THIS large is quite hectic, and requires much more planning, strategizing, and coordination. Overall, we got the work done, and it is a very rewarding feeling to see our “idea” turning into a real product.
Also, since this is most likely the last change i had to make, and is conclusion of this class. I will probably most likely never blog again. Thank you! 
Last Wednesday Tim decided that instead of the pinch to zoom feature, it might be easier to change it so that if the image is clicked on, it goes full resolution size and the image can just be dragged around.
This is now working fine in a web browser, but like every issue I’ve had so far…. It does NOT work on the iPad. The drag feature is being called upon in the MooTools- more JavaScript file. I believe Touchstart and touchMove events need to be added and somehow get cords from them to enable drag. The drag function can be easily read if anyone wants to take a gander. I can always end up giving them the old version that worked fine, but it will be missing the “better” zoom (hard to call it better when it doesn’t work).
If it was just being run in a web browser it would be done at this point.
I pushed a version to git finally the other day. I don’t think that one was fully working either. This one is better though. I’m worried I’m going to end up overwriting everyone’s work, so I’m trying to stay away from it as much as possible.
Lastly it is on the test server. If you are using filezilla you should be able to get into my directory and download it (I’ve downloaded other peoples work from there). That should be the most updated version unless I’m working/testing things on it if/when you download it.
Sean
One of the hot topics of commentary on open source development at the moment is the licensing situation on GitHub. When code is committed to GitHub, the copyright owner (usually the author or their employer) retains all rights to the code, and anyone wishing to re-use the code (by downloading it, or by “forking” and modifying it) is bound by the terms of the license the code is published under. The point of discussion in this case, is that many (indeed, the majority) of repositories on GitHub contain no license file at all.
There are two troubling points to the commentary on this phenomenon. The first is that some discussions suggest that publishing with no license is “highly permissive”, implicitly allowing anyone to take the code and do with it as they wish.
In fact, it’s usually the case that having no license on your code is equivalent to having an “All Rights Reserved” notice, preventing any re-use of your code at all. Whether it’s the copyright holder’s intention to enforce these rights isn’t being made clear, but it’ll be enough to put off any company who might want to engage with such a project under an open development model.
The second troubling point is that commentators are time and again dressing this up as a wilful movement. James Governor coined the term “Post Open Source Software“, while Matt Asay claims “Open Source Is Old School, Says The GitHub Generation“. These commentaries seem to imply that there’s some sort of “No License Manifesto” being championed (in a similar fashion to the Agile Manifesto, perhaps).
The only movement I’ve seen which would be akin to this is the Unlicense, which encourages authors to wilfully lay aside any claims to their rights, effectively a Public Domain dedication which Glyn Moody has suggested is the way forward for open source.
However, what we’ve seen on GitHub shows no such conscious setting aside of rights, it shows a lack of education. Publishing articles touting release without a license as how all the cool new kids are working encourages behaviour which could prove damaging to the development of a project’s community, and the wider community in turn.
Fortunately there are voices of reason in these discussions. Stephen Walli of the Outercurve Foundation points out that governance == community. If a project seeks to “fuck the license and governance” as James Governor suggests, then they risk doing the same to their community by alienating contributors (particularly those that are part of a larger organisation, rather than individual developers), as these contributors have no predictable structure to work within.
If the project lead might turn around and say “I dont feel like accepting your contributions, and by the way, if you keep using my code I’ll sue you”, you’ve got very little incentive to work with them.
By neglecting your community in this way, you project is at risk of being limited to a few individual contributors who know and trust one another implicitly. I can’t believe that developers seeking to allow permissive use of their code would be happy with this as an outcome.
GitHub haven’t yet made any suggestion that they feel this is a problem they should work to solve. It’s our responsibility as a community to ensure that we educate newcomers to become responsible open source citizens, rather than encouraging them to follow established bad practices.
Licensing and governance analysis form 2 cornerstones of OSS Watch’s openness rating. If you’d like advice on how to improve your projects management of these areas, please get in touch.
I quickly wanted to show the directory structure that we used for this course, and the git branches associated with them. We are using a CentOS 6 machine with apache as the web server. We also installed php for the git scripts which lie in the web root.
> /var/www/html/ – Web Root, No Git Association
> index.html – Show a list for Master / Development / or Users, No Git Association
>> master – The final project ready for deployment, Git Master Branch
>> test – The most complete branch for testing, Git Development Branch
>> development – Used for user directories, No Git Association
As I played a major role naming the directories, I take the full blame for the blunder of naming a directory test and linking it to a development branch, and then proceeding to name a directory development and using it for something else. Sorry about that guys.
CS401, the capstone for WSU Computer Science, is a very useful class as it shows some real world applications. As a member of the server group, I was able to help set up the back-end of the project and integrate the code with a working web page. In order to accomplish this, I was able to practice my scripting, working with apache, improving git abilities, and again, finding the headaches associated with permissions. Some of the most satisfying results of the class were working with others on a large project, trouble shooting with peers, and seeing a full scale development task move from infancy to completion throughout a single course. It was a great semester and very valuable to future success.
Although the overall class was a success, there’s always some things that could have been done better. I wish I would have gone back to fix the git script, it was done so it worked and then it was forgotten about. I wish I went back and maximized the efficiency of this script. The other opportunity I wish I grasped a hold of was working with some of the html, css, and javascript of the other groups, possibly helping to debug or lend a hand when needed because I would have liked to learn a bit more of those languages.
All our code throughout the semester was placed on git and then brought to the server for testing/deployment. Instead of having to log on to the server and pull code every time a change was made, we wanted to update the server every time a change was made.
In order to accomplish this, we looked into GitHub’s web hooks, which work by calling a script every time a pull request goes through. The idea of this seemed simple, but we ran into some problems with permissions. In order to accommodate this, we decided to delete the whole directory and re-clone it into the same place by the following php script:
<?php
date_default_timezone_set(‘America/New_York’);
$gitRoot = “/var/www/html/master”;
// Use in the “Post-Receive URLs” section of your GitHub repo.
if ($file = fopen(“log.txt”, “a”)){
fwrite($file, “Update ” . date(“F j, Y, g:i a”));
}
if ( $_POST['payload'] ) {
$delete = shell_exec(“rm -rf $gitRoot”);
$clone = shell_exec(“git clone -b master https://github.com/CS-Worcester/CS401Spring2013.git $gitRoot”);
fwrite($file, “\n\tPayload Received\n\tClone: $clone\n\n”);
} else{
fwrite($file, “\n\tNo Payload Received\n\n”);
}
?>
The better way to do this would be to pull changes into the directory, which is much quicker because it updates only the changed files. This wasn’t followed up on after the quick fix because the quick fix was needed early in the semester, and other things arose before re-addressing the issue.
After creating the user directories, we had to allow the user a way to put their code in the web directory. There were two main ways to accomplish this that was explained on an as-need basis in class. The two (perhaps three) methods are to modify code locally and use FileZilla to transfer files to the directory, modify code locally and use scp to place the code on the server, or ssh into the server and modify code directly in the test directory.
From working with individuals throughout the course, the majority seems to be using FileZilla, but it’s nice to have the option to work directly in the folder’s code.
When we started working on a web project, we were using git for individual parts of the project but we wanted to see the projects as a web page and updating git to wait for results was a bit more difficult than expected. Because of this, we decided to create user directories on the server hosting the project which would render everything through the web server. This made testing much easier, as any scripts could be tested locally.
The user directories were creating using the following script:
user=
pass=
users=
passwords=
count=0
while [ 1 ]
do
# Prompt and get the username
echo -n “Enter username [Blank to Exit]: “
read user
if [ -z $user ]; then
break
fi
# Check for errand username formats
if [[ ! $user =~ ^[a-z] ]]; then
echo “Invalid username”
continue
fi
# Set up the user and directories
useradd $user -d $BASE_DIR/$user
mkdir $WEB_DIR/$user
chown $user:developer $WEB_DIR/$user
ln -s $WEB_DIR/$user $BASE_DIR/$user/html
chown $user:developer $BASE_DIR/$user/html
users[$count]=$user
count=$(($count + 1))
# Check for more users
echo -n “Another User? (y/N): “
read another
if [ -z $another ]; then
break
fi
if [ $another != 'y' ] && [ $another != 'Y' ] && [ $another != 'yes' ] && [ $another != 'Yes' ]
then
break
fi
done
for (( i = 0; i < $count; i++ ))
do
echo “Username: ${users[$i]}”
echo “${users[$i]}” >> users.csv
done
The script creates a new user given a user name and creates a home folder for that user. Then a directory is created in the development folder of the web directory with the same name as the user name. The permissions is then corrected so the correct user can edit their code. Once this is done a symlink is placed in the user’s home folder to make it a little easier. To place your code in the web directory you just needed to place your code in your own html folder.
To access an individual’s web work, you could go to cstest.worcester.edu/development/ and get a list of the user directories. You could then view the work by clicking on the correct user.
Working with the Worcester Art Museum has been a good experience for working with a client and making sure a project will be complete and thorough. Throughout the course there were both some challenges faced and milestone achievements.
Most of the work I did during the semester was done in the server group so there was not as much direct interaction with Tim and WAM as most of the other groups, although there was some. The server group started by ensuring that the final project would be able to be deployed on the Worcester Art Museum’s iPads and that the project was easy to maintain. After deciding to move to a web page as the main project deployment wasn’t an issue. As it turns out, the museum has a web server where we can deploy the finished product and they can maintain it locally. With all these things established, the server group looked for ways to potentially expand, and that’s where working with a climate can be challenging.
Part of the initiative for the server group was to look into a way we could use a database to improve the features of the project. The major ideas that surfaced were to email coloured images to a provided email, save images for other patrons to view, save high scores for the puzzle, and leave comments about the exhibit. When talking to WAM about these features it was determined that databases weren’t going to be used because it added to the complexity of maintenance. This was a bit of a bummer because as a group we were really looking to contribute a front end feature instead of all back end.
In the end, it all worked out, and every thing went well. At this point we are just finishing up some final polishing and getting ready to deploy the finished project.
All computer science courses up to this point have dealt with individual or small group assignments. In these assignments we began with either a complete instruction set or a template, a starting position, and an end goal. Using these assignments we have been able to learn concepts and basics which can be placed together to form larger projects.
During this capstone course we have moved away from this fairly standard model, going over a semester long project, breaking into groups, and determining different paths to take to get from point A to point B. Unlike most classes where deadlines were weekly, and assignments complete, this course featured a more abstract plan. Although updates on progress were given, the deadlines were defined by the groups and almost anything was acceptable providing the project would be completed on time.
This model is close what I’m expecting in the real world. Tasks, mostly small parts of larger projects will be assigned, and a deadline given. Based on this deadline, we will have to develop a plan, determine what course of action needs to be taken, and meet the deadline. I enjoyed that this class was like that and it has really prepared me for my future career opportunities.
Open Badges started as a modest experiment: build open source badge issuing software for ourselves and others. As momentum around this experiment has grown, it feels like the opportunity is bigger: we could build openness and user empowerment into how learning — and professional identity — work all across the web. With Open Badges 1.0 out there in the world, now is the right time to ask: where next for Mozilla and badges?
When Mozilla and MacArthur Foundation first started work on Open Badges about 18 months ago, the plan was to build a badge interchange standard (like SMTP for skills) and a collection of open source software for issuing and sharing badges (Badge Backpack, Open Badger, etc.). We’ve built all these things. And we’ve put up a reference implementation that Mozilla and others are using. This was really the limit of our original plan: build some basic open tech for badges and put it out there in the world.
The thing is: there has been way more excitement and pick up of badges than we expected. Even though Open Badges only launched officially in March, there are already over 800 unique providers who have issued almost 100,000 badges. We are also starting to see the development of city-wide systems where learners can pick up hundreds of different badges from across dozens of learning orgs and combine them all into a single profile. Chicago is the first city to do this (June 1), but Philadelphia and San Francisco are not far behind. And, this is just the tip of the iceberg: orgs like the Clinton Global Initiative and the National Science Foundation are focusing on badges in a way that is likely to drive even more educators to pick up the Open Badges standard, making their badges interoperable with others.
Of course, the fact that educators and policy makers are interested in badges doesn’t represent a victory in itself. It just shows momentum and buzz. The real opportunity — and the real impact — comes when learners and employers get excited about badges. Mozilla never planned to build offerings for these audiences. Increasingly, it feels like we should.
In the Internet era, people learn things online and out of school all the time. Whether you want to make a web page, knit a sweater or get better at calculus, the internet makes it easy to learn on your own or with a group of friends outside of a school setting. However, there is no good way to get credentials or recognition for this kind of learning. And, even if there was, there is no trusted, verifiable way to plug that recognition into Facebook, About.me and other places that make up your online identity. People have no good way to show ‘what they know’ online.
Similarly, employers are increasingly turning to the internet to find talent. They use sites like LinkedIn that let you search online resumes. Or, increasingly, to sites like Gild and TalentBin that use data mining to find potential hires. The problem: these services do not offer granular or variable skills profiles. And, with some of them, there are significant issues around privacy: people are being offered up as potential hires without even knowing that these sites are collecting data about them.
Mozilla could offer a distributed, open source and privacy-friendly solution to problems like these. We could help learners show their skills in all their online profiles and also help employers search for talent reliably. However, to do so, we’d have to build a Firefox-quality offering for learners and employers on top of Open Badges. While this hasn’t been our focus up til now, I’m thinking more and more that this is something we should consider.
In some ways, there is a parallel to Gecko and Firefox. Gecko provides the underlying platform for shaping standards around our vision of the web. But we need a popular consumer offering like Firefox if we want this vision to actually become relevant in the market. Right now, with Open Badges, we’re mostly just playing at the underlying standards layer. If we really want to shape how learning and professional identity work on the web, we probably need to build our own offerings directly for the people who most want and need badges.
Now is the time to be looking at where the opportunity is in this space. Momentum and demand is amongst educators is growing. More and more start ups are appearing in the badges, portfolio and skills spaces. And likelihood that badges will be important for learners and employers is growing. We need to be asking ourselves: how can Mozilla — and its values — shape this space?
With this in mind, Erin Knight is leading an effort over the next few months to look at different badges product options. She’ll be providing updates on her blog. And I’ll be summarizing here as well. If you have ideas on where Mozilla should go on all of this, we’d love to have you involved as we think this through. Comments here on this post are a good place to start.
Throughout this capstone course, small groups worked together to create an overall project. Because of the format of the class, a method of collaboration was needed and the one that made the most since was git through github. Git allowed the teams to work individually on their parts and then merge changes to the larger effort. This way of collaboration and version control worked well to assure the fluidity of the project. The only setback associated with using git was the fact that it was a new concept to many in the class and the features were being learned throughout the course.
There is currently the initiative to introduce git in the first programming course offered as a way of working with lab partners and submitting assignments. After students learn to use git in one of the introductory courses the idea can be used throughout the college career as a means of collaboration, version control, and centralized organization. Dr. Wurst is in the process of drafting a lab to introduce git and will use it as the way submit assignments.
Version control such as git is valuable for individual development as well as large group projects and learning it early on will be very valuable throughout college and career. Personally, I’m very excited to see how the idea of introducing git early on will change the dynamic of the Computer Science major at Worcester State.
At OSS Watch we periodically review all the resources on our main website to make sure they’re accurate and up to date. Last week it was time to revise our case study on Apache Wookie, which is a project I’ve been involved with for some time.
OSS Watch became involved with Wookie while I was working in an EU project based at the University of Bolton. The project as a whole had done lots of interesting stuff, but as with many large projects the whole was somewhat less than the sum of its parts; the central joined-up platform wasn’t really going to take off after the project finished. However, in the process we had built quite a promising system for adding functionality to the core portal shell using the W3C Widgets specification.
Towards the end of the project I went to an OSS Watch event, and spoke with Ross Gardler about what we were doing. Ross explained the Apache Incubator model to me, and from there on I was hooked.
Fast forward to 2013, and Apache Wookie is out of the incubator and a top-level Apache project, and is now on its seventh official release (the last one was in April). Its not a huge project – the team is still small, though its far more diverse than when we started out.
The tempo of development has also slowed in recent years. However, in part thats due to the maturing of the software to a point where code churn for its own sake has a negative impact on the projects that depend on it. Most recent updates have been fixing bugs affecting deployment in various unusual configurations, driven largely from reports by users. So this isn’t necessarily a bad thing!
Something that has also had a very positive impact on the project is having a very active downstream project – Apache Rave. This has driven a lot of improvements to Wookie to improve integration and deployment.
Two major EU projects have been working with Wookie and Rave over the past two years, and are coming towards their end – one this year, and the other in 2014.
Unlike previous projects they have focussed on working with existing software projects rather than going it alone, and have contributed code, user studies and content. This has been a great experience, and hopefully future projects can learn from this approach.
Wookie stands as an example of how OSS Watch can help take work from within the HE sector and turn it into a sustainable open source software project; and as a beneficiary of this approach I’m keen to offer the same help I received to others.
Do you think your University-based project has the potential to go further? If so, get in touch!
Read the updated case study on Apache Wookie at OSS Watch.
(Photo by Silus Grok, used under CC-BY-SA license)
According to the existing defect in the light box zoom feature that the article page will remain on the same zoom size when user exit from the light box. My original plan is let user to click on the picture and return to the article page with the full size. However, it does not work that way. So I came up with another solution, which unblock the zoom function on the article page. The advantage of doing this is user will being able to zoon back and normally read the article. The disadvantage will be when the user did not close the light box with size, the page will look disorganized until they zoom back in. I have gave a couple people test on the user experience, they feel nature’s zoom in for the picture, and when they close the light box, they will realized the page need to be zoom out, also. I mean, this the not the solution that my original plan was. But this is at least a solution for the problem.
Well this will be the very last post regarding the coloring app for the Worcester Art Museum. I have only made one change since the last post and that was to add a back button. The reason for this was because we have a navigation bar built into our app but on the coloring app page it causes squishing because the positioning is done with percentages. The outcome is the app looks fine if the window is a enlarged but things overlap and become unusable if you make the window to small. The solution; remove the navigation bar from the coloring app completely and add an html back button. I tried a few different codes for this but in the end I settled on onclick = “history.back(-1)”. This way I do not need to worry about traversing the files I just go to the previous page onclick =”".
Till the next Project.
Jason Hintlian
Now, our screensaver part seems to be done. Tim wanted the introPage’s response to the wipe actions to be quicker. We could decrease the time delay for transition effect to have an improvement, but it isn’t a really significant improvement. We believe the reaction speed to the swipe actions depends on the realization of jQuery to the swipe actions/touches.
With the sense of improving, i also made another screensaver as a second choice since i also like a continuous motion pattern (beside fading or popping) for our screensaver. To me, this design makes a sense of showing a collection of all the images related to the Orantes at the first glance with the continuous movement. Here is how it looks like (these images were captured at different moments of the movement).
The background color can be changed flexibly for an attractive look.
I let Tim know and Im waiting for his response on this new pattern.
As part of OSS Watch’s regular review of our website’s content, I’ve taken a look through the publicly editable version of our Open Source Options for Education list and added some new contributions to our website.
The response from the educational community has been overwhelming in helping us find both alternatives to common proprietary software and real-world examples of these alternatives being used. I’d like to extend my thanks to everyone who’s contributed.
I’m particularly pleased this time to include a new category for Management Information System (MIS) software. These tools often represent a significant investment to an institution and requirements for compatibility with these systems which perform a key administrative role can be a strong influence over procurement of related software such as VLEs.
You can find the updated version of the Open Source Options for Education document on the OSS Watch website, and continue to contribute to the public version on Google Docs.
On april 29th 2013, I joined Microsoft’s legendary Developer and Platform Evangelism team, where I will initially focus on the Enterprise market. I will report to Technical Fellow John Shewchuk, joining his new team of top-notch technical evangelists, like Xoogler James Whittaker and Microsoft veteran Eric Schmidt. Mary Jo Foley wrote a nice piece about our team on ZDNet today. I will be based in the Microsoft San Francisco office.
How did it happen?
I spent most of my career competing with Microsoft, at Netscape, Sun, Google and VMware. Competition builds respect, competitors force you to question your assumptions and to constantly evolve. For many of my friends, this move came as a total shock. What made me open to the idea of joining Microsoft is a presentation from Scott Guthrie about Windows Azure at NodeConf 2012 last summer. He presented from a Mac laptop, launched Google Chrome, went to the Cloud9 IDE, edited a Node app pulled from Github, and pushed it to Azure from the cloud IDE: to me this indicated a real change of mentality at Microsoft, and a new openness. Clearly they had listened to what developers ask from a cloud platform. Later on, when my friend Srikanth Satyanarayana pinged me to start conversations with Microsoft, I was open to it. I met with Satya Nadella, and realized that our visions for where the cloud was going were very aligned. Further conversations with Scott Guthrie about Azure, John Shewchuk and Steve Guggenheimer about developer evangelism convinced me this was an adventure I had to take!
Why Microsoft?
Joining Microsoft boils down to 4 reasons: People, Learning, Technology, Impact.
People: in my late 30′s I realized that the people you work with, for and around are as important as what you’re working on. Microsoft has many people I have admired from the outside, like Dare Obasanjo, Eric Meijer, Scott Guthrie, Jon Udell, Scott Hanselman, Jeff Sandquist, Andrew Shuman or Anders Hejlsberg. The team I join has a fantastic roster of A-players with whom I’ll have fun and from whom I will learn.
Learning: I’m a learner at heart. I am curious, I read a lot, and I like to learn from people I work with. I also love to share what I learned with others. My kids loved this book called My Friends, by Taro Gomi, which goes like this: “I learned to walk from my friend the cat, I learned to jump from my friend the dog…”.
In my career it worked the same way: I learned algorithmic from my teacher Christian Vial, I learned internet protocols from my friend Nicolas Pioch, I learned open source from my friend Alejandro Abdelnur, I learned social media from my friend Loic Lemeur, I learned developer relations from my friend Vic Gundotra, I learned platform strategy and storytelling from my friend Charles Fitzgerald… I love doing developer relations, and my two mentors in this area over the past 8 years, Vic and Charles, both came from the Microsoft DPE team. I’m coming to the source for more learning. This team is more than a 1000 people worldwide, and over the past 10 years they defined what tech evangelism is about: they operate at a larger scale and cover a wider scope than any of the teams I worked with. I am very excited to join them.
Technology: Windows Azure is Enterprise ready, more open than people think, and is a complete platform, from infrastructure to services, mobile and Big Data. Azure has matured a lot in the past few years, it covers IaaS, PaaS and Saas, their Paas service is multi-framework and multi-service, with a marketplace of add-ons, it has a mobile backend as a service for Windows Phone, iOS, Android and HTML5, and includes Hadoop and Big Data services. It is in production today, has been battle tested for years as the base for many Microsoft first party apps and services, and is ready for the Enterprise, with a true public/private/hybrid solution: with Windows Server 2013, System Center and Azure you can start building your hybrid cloud today.. The team ships important new features regularly, my favorite being the point to site and software vpn features announced a few weeks ago, which will drastically lower the barrier to create hybrid clouds. Azure is not a Windows/.NET only platform, it is more open than people give it credit for: you can provision Linux VMs, and the PaaS supports .NET, Java, PHP, Node, Python, Ruby, with open source (Apache 2 license) SDKs on Github and an Eclipse plugin, built by the Microsoft Open Technologies team. Scott Guthrie gives a very good overview of Windows Azure in this video from the Windows Azure Conf 3 weeks ago.
Impact: as a kid, I was reading a lot of science fiction, and got my first computer (a TRS-80) when I was 10 years old. As I explain in many of my presentations (like Portrait of the developer as The Artist), my childhood dreams were to change the world through technology, and more specifically computers. My dreams are far from being fulfilled today: it is true that we have more powerful machines and software tools, and technology changed the world in many aspects, but machines are still hard to program, and software engineering needs to evolve to let us work at a higher level of abstraction.
The move to a devices and services world is an important architecture change like we see every 20 years in the software industry. Cloud platforms have the potential to help developers build smarter applications faster, and change entire areas of the human experience. It has started to happen in the consumer applications space, but the next big wave of change is the consumerization of Enterprise IT, where developers and IT professionals can completely transform the way enterprises work, driving business value faster, enabling new capabilities and business models. My goal is to help them in this transformation, and Microsoft is the place where I can have the most impact.
Here’s a quick video to summarize it all: developers, developers, developers, think big and look up at the sky, its color is Azure!
If you have never tried Azure, or have tried it a year ago, sign up for a free trial and give it a go! I hope to see many of you at the Build conference in June in San Francisco.
For this week, there wasn’t much left for me to do.
After I showed Tim the recent version of the Introduction Page, he tested it and told me that the transition between pages is a bit sluggish. So I’ve read up on possible solution to fix this, and it is to change the transition value of the .in, .out in the jquery-mobile css file (default to 350ms). So after I did that, I found that the “transition effect” is faster, but the transition is still “slow.” I think this is due to jquery mobile recognizing the “swipe” motion, so there is really nothing else I can do with my little knowledge of javascript.
And Tim said that if this cannot be fixed then it would be ok if I put the button back and choose the transition effect with the least delay. So I put the left & right navigation button back, with the default transition effect of “fade” for those buttons. However, the “Help” button is still there, and we can still navigate the pages by swiping.
I also wrote up a short document on how to change the contents of the Screensaver and the Introduction Page, and it is very simple so I think Tim should not have a problem understanding it.
I’ve written before how HTML5 is the platform of the future for developing interactive educational apps, and you can even develop (code) in your browser (or chromebook) now. Well, the future is here, and HTML5 is still looking to be the best option, but there are some wrinkles. One is the slow pace of multimedia support in HTML5, in particular audio (a counterexample is 3D, in the form of WebGL, which is coming along faster than I expected). Two other things are actually good, but still challenging problems – 1) the explosion of HTML5 and Javascript frameworks: Meteor.js, AngularJS, Ember, Backbone, CanJS, Knockout, yadda yadda yadda (I’m particularly excited about Meteor, but none of these frameworks seem to have “ease of use” in their vocabulary, and accessibility is usually an afterthought, if considered at all – Dojo being one exception), and 2) the explosion of languages that compile to JavaScript: Coffeescript, Dart, TypeScript, yadda yadda yadda (Dart is one that interests me at the moment).
But one problem in particular has been my biggest hurdle, which I discuss more here: the cost of scalable hosting. With “old-fashioned” desktop apps or single-user applets or web animations or games, you can fire and forget it. Develop your app or site, slap it up on the web, and people download it or visit it and use it. Static web hosting is practically free (like this WordPress blog). However, if you want social features, persistence (database), or other things like that, you need to have a database or other backend at minimum, and it needs to be able to scale. I’ve always had my hopes up for Drupal - it is still my favorite go-to solution for social but non-interactive web applications, and several folks are using Drupal as a backend for HTML5 or mobile apps, but it is not so easy or so cheap to scale up. A lighter weight alternative to Drupal, perhaps built on node.js and MongoDB, has not yet emerged.
The Serverless, Unhosted, No Backend Options
Anyway, so, one hurdle to developing interactive educational HTML5 applications on the web is the cost of scalability. Web hosting is cheap (or even free) at the beginning, but can quickly spiral out of control and sometimes lock you into a proprietary platform (like google appengine). I could get a grant, but what about when the funding runs out? I could beg for money by posting my ugly mug at the top of every page like Jimmy Wales did on Wikipedia, but I’m not a sadist. I’m not a venture capitalist/entrepreneur, and unfortunately, I’m not at a university that supports or provides web application hosting (I used to be able to just run apps off the computer under my desk as an undergrad, grad, and professor, or by running cheap virtual private servers for as little as $15/year when scaling up wasn’t much of a concern).
Here are some sites that describe lower-cost, open source, and scalable cloud hosting solutions, by either letting visitors host their own data (in their browser’s local cache, or on dropbox or google drive or another site), or by using a cheaper backend-as-a-service that your front-end connects to. [Really, none of these (except WebP2P) are completely "serverless", and many do not eliminate the costs, either, but it is progress.] Various terms have been used for some of these concepts: serverless, no backend, unhosted, and there are also new and cheaper cloud hosting services that provide a backend-as-a-service (BAAS) or a platform-as-a-service (PAAS).
For an older article that hinted on this “serverless” trend, see Why The Future Of Software And Apps Is Serverless, and a newer article explores the No Backend movement in more detail: NoBackend: Front-End First Web Development.
My last day at VMware was april 6th 2013: I loved every bit of these 18 months building a worldwide and world class developer relations team of 21 star developer advocates, program managers and community site builders for Spring and Cloud Foundry. We had fun, accomplished and learned a lot.
I strongly believed in the “go big or go home” strategy led by Paul Maritz and Tod Nielsen, going up stack from VMware’s stronghold in Infrastructure as a Service (IaaS) to Platform as a Service (Cloud Foundry), developer tools (Wavemaker) and frameworks (Spring), and Software as a Service (Horizon, Socialcast, Sliderocket, Zimbra).
I am proud of the work we did in VMware developer relations, engaging with developers around the world to help them become more agile, drive business value, and change the world with software, by leveraging cloud platforms and modern development frameworks.
We helped the Spring community grow, brought SpringOne to China and India, and helped create a strong developer and partner community around Cloud Foundry, with 13 Cloud Foundry Open Tour events around the world, and technical presentations at 130 developer conferences in 2012. One aspect that I am particularly proud of, as a manager, is the culture of innovation and getting things done we built in that team in 18 short months.
In December 2012, VMware and EMC announced to Pivotal Initiative, a bold initiative to spin off VMware and EMC’s Cloud and Big Data product portfolios into a new company called Pivotal.
As many of you know, it is an understatement to say that I am an avid reader. In 2012, 3 business books particularly inspired me: “Who Moved My Cheese?” by Spencer Johnson, “The Start-up of You”, by LinkedIn founder Reid Hoffman, and Clayton “Innovator’s Dilemma” Christensen “How Will You Measure Your Life?”. What these 3 books have in common is advocating for an active management of your career based on your own priorities, goals and values, embracing change instead of fighting it, and being open to emergent opportunities.
Pivotal represented a big change, for my team and myself. When planning the organization for Pivotal developer relations, I got pinged by a friend with a super exciting opportunity outside of VMware and decided to do a pivot of my own. I built a plan for Pivotal developer relations, covering Cloud and Big Data, transitioned the team to Adam Fitzgerald, left VMware and, being French, took a month of vacations:-)
Adam is a fantastic developer relations director, and his team is one of the best in the world: the splendid execution of the Pivotal launch last month is a strong testament to their capabilities.
It is always bittersweet to leave a team you love working with, but my new gig is too exciting to look back. Thank you VMware for these excellent 18 months, and good luck with your new adventure Pivotal team! I want to specially thank Charles Fitzgerald, who was my manager, but whom I consider more like a mentor and a friend, for teaching me developer platform strategy and evangelism, Tod Nielsen and Mark Brewer for hiring me at VMware and giving my team the means to tell developers the VMware platform story, Mark Lucovsky, Derek Collison, Vadim Spivak, Ramnivas Laddad and their teams for building Cloud Foundry and Bosh, the Spring team for enabling Java developers to be more productive, Jerry Chen, Killian Murphy and their teams in products, David McJannet, Dekel Tankel and their marketing team, James Watters for building such an impressive ecosystem of partners, and being an awesome voice on Twitter, Alan Ren for his relentless energy building the VMware engineering team in China.
But above all, I want to thank my team: Adam Fitzgerald, Josh Long, Andy Piper, Raja Rao, Chris Richardson, Frank Yu, Eric Bottard, Rajdeep Dua, Toshihiko Ikeda, Alvaro Videla, Monica Wilkinson, Peter Ledbrook, Scott Frederick, Tamao Nakahara, Danny Gamboa, Amy Welch, Christina Jones, Corrine Bai, Giorgio Besso, Dararith Ourk, Chloe Jackson, Loc Nguyen, Magizh Thirunavukkarasu,
you will always have a special place in my heart, and I wish you all success at Pivotal or elsewhere for those who have left the team.
I will post more details about my new job on Monday. In the meantime, I took advantage of this month of spring vacations to shoot some fun videos in different places I visited, as a homage to you, developers I interacted with around the world, in the past 8 years doing developer relations at Google and VMware. They are inspired by Bob Dylan’s Subterranean Homesick Blues video, in the movie Don’t Look Back. I call them Subterranean Developer Blues!
Sorry for not updating you guys last week. It’s been a busy week. We have been working on getting gstreamer to interface with application. For some reason we haven’t been able to get video to show up on the screen.
We have discovered that the reason it’s not working is that the windows for the GUI are not being being realized. Without them being realized, the prepare preview method in gstreamer is never called. It’s something we will have to look into more.
This is the last week we will be working on OVC for my HFOSS class. I plan on continuing work on OpenVideoChat but I will only be able to do it in my free time. I have applied to Google Summer of Code for the Open Video Chat project so if I get accepted to the program I will be working much more on the Open Video Chat program over the summer.
This version has had the following changes done:
Images now take up the entire image viewing portion of the page.
The image no long scroll they just appear, in addition to now having a position for captions.
The scroll triggers have been removed, the focus change is now all touch.
Added links in the footer to acknowledgements and back to the chapter page viewer.
Font size has also been increase.
The images now have a different function to change:
function swapImage(){$(‘#image-display’).css(“background-image”, “url(images/”+article+”/p_”+currentRow+”_thumb.jpg)”);}
I removed all scroll functions and just utilize the p.on(‘vclick’) function. The font size was a simple CSS change of p{ font-size: 2em;}
Here is a screenshot of the current version – note the images have no been submitted to fit the div:
One of the clients tested the article viewing concept and had a few suggestions:
The first suggestion was only having a fixed footer and removing the header as well as the previous and next buttons above the article. This was implemented with relative ease, the only issue was the footer which would disappear whenever a function was called that did animation. I learned that this is a default setting for jQuery mobile when you make the footer fixed.
Here is the code for the footer div so that it didn’t move when an animation or click was executed:
<div data-role=”footer” data-position=”fixed” data-mini=”false” data-tap-toggle=”false” class=”ui-footer ui-bar-a ui-footer-fixed slideup” id=”footer” role=”contentinfo”>
</div>
Then i just added the home button, the previous button and the next button. In place of the old buttons I placed the title of the current chapter in a header tag.
The second suggestion which was a solution to a problem in the design of the scroll to switch focus concepts. If there is no where to scroll the user can’t change focus and therefor can’t view the other images. This suggestion was a touch the paragraph to execute the animation and focus changes. This was a very simple and elegant solution; all I added was an if statement that was essentially if the page is not scrolling implement a click function on the p tag to execute the same focus change functions. However in the else statement I also added a function that would allow the clicking on the p tag but it was implemented by scrolling the page, not directly changing the focus.
In essence: If(no scolling){ p.click -> execute focus change functions} else{ keep scroll functions p.click -> scroll to the proper section}
This worked without any issues and I was a relaly big fan of the touch to change focus solution!
Here is a screen shot of the new setup!
Until next time!
-Joe
The content viewer is referred to the article viewer now, there have been some additions and removals since the last update!
Here is an outline:
A link to the next article or chapter at the top of the paragraphs.
New focus on paragraph div that is behind the paragraphs.
Scroll to change focus on image and paragraph.
Here is a screenshot of the final 0.1 product:
Linking was as simple as creating simple jQuery mobile buttons buttons.
Creating a “focus” on the current div per request of the client was a little more interesting.
So I didn’t want to create a simple function that would change the background color of the current paragraph tag because that isn’t elegant and just didn’t seem appropriate! So I created a stand alone div that would move and change height based on the height of the paragraph it was supposed to be highlighting! I also places this div behind the paragraphs so it wouldn’t interfere with the font settings. All of this was accomplished with the animate function and basic CSS selectors and attribute functions for jQuery. Here is a screenshot showing the function in action!
Here is the function that accomplishes the animation:
function animateActive(){$(‘#active’).stop().animate({‘top’ : $(‘#article-display p:eq(‘+currentRow+’)').position().top+10+’px’,‘height’ : ($(‘#article-display p:eq(‘+currentRow+’)').height()+20)+’px’}, animationTime);}
The #active div is an absolutely positioned element that gets it height and width from the p attributes. it is completely dynamic with regard to sizing and position.
The other interesting part of this version is the trigger for that function; the function is activated by scrolling! the initial proff of concept for this was not a viable option because I created the function to animate based on when the top of the page passed the top of the P tag, this doesn’t work for sections that are a the bottom of the page so I created the following function:
$(window).scroll(function(){if($(window).scrollTop() == $(‘.ui-page’).height()-window.innerHeight){ //potential null value if numRow does not divide nicely into the page height-windowInnerViewcurrentRow = numRow-1;Uncaught ReferenceError: numRow is not defined (repeated 2 times)
animateActive();slideY($(‘#row-wrapper’), -currentRow*imageHeight, animationTime);}else if(currentRow != Math.floor(($(window).scrollTop())/scrollSwap)){currentRow = Math.floor($(window).scrollTop()/scrollSwap);animateActive();slideY($(‘#row-wrapper’), -currentRow*imageHeight, animationTime);}});
This was a pretty cool learning experience; I have seen scrolling impact the page on some portfolios, it was nice to make my own function to do it!
Until next time!
-Joe
There was a minor issue with animation speed which we attempted to remove, the new page viewer also implements 2 new functions for specific pages.
Attempting to improve performance in only kiosk pro’s browser consisted of removing opacity from the animations. This made a very minor difference with regard to sluggish animation. The animation speed works fine in other browsers on the iPad which leads me to believe this is indicative of an issue with kiosk pro. However removing the opacity will remain in the application even with the negligible performance enhancement.
the two new functions added were from the main page and chapter viewing page:
Main Page:
The primary addition here was the combining of the screensaver function with the main page, it is not sure yet if this will make it to release.
Chapter Viewer:
per request of the Worcester Art Museum we implemented a menu for the chapters. This was done using jQuery Mobile’s built in grouped buttons. These buttons now animate the page viewer to the respective preview. Example: if chapter 2 is clicked the application will animate to the chapter 2 instantly for quick access.
Here is a screenshot:
That wraps up the additions and modifications to the page viewer, until next time!
-Joe
So the page view has made it into the final production! The goal with the page viewer is to have it function as the main menu for the user to access the content.
With this acceptance into the final product and detailed requests from the art museum we tailored 0.2 to fit the requirements.
First off the project will consist of a main menu and sub-menus:
The main menu will consist of 3 links to sub-menus:
Story of the Orantes Sub Menu:
1 ARCHAEOLOGY
2 WHAT ARE ORANTES?
3 ORANTES IN THIS EXHIBITION
4 HISTORY OF ORANTES AT THE MUSEUM
5 MATERIALS AND CONSTRUCTION
6 CONSERVATION
7 TECHNICAL AND SCIENTIFIC ANALYSIS OF THE WORCESTER ORANTES
8 WHY IS THE HEAD MISSING?
Photo Gallery is a direct link
Activities sub menu:
1 COLORING
2 PUZZLE
The sub-menu links will go directly to other groups applications.
With the new specifications for the application we removed all dynamic content and buttons for the menus and replaced the with images.
Here is a screenshot of the “main menu”
Until next time!
-Joe
Well, my H/FOSS class is coming to an end. In a few short hours, I’ll finish my last H/FOSS class with a presentation on our work on Sugar (coincidentally it’s also my last college class).
At this point, I’ve realized that Sugar is a fairly disorganized project. It seems like it’s constantly in flux, with multiple wikis, bugtrackers, git repos, etc. It’s very confusing to get started deving on - probably the most difficult project to enter in my experience in FOSS.
That being said, walking away will be hard…well, not that hard since I don’t plan on walking away just yet.
I was assigned some tasks by the team after my initial set of patches, so I’ll make sure to finish those up. Then what? I’ll probably run away and never look back.
While I can appreciate the work the Sugar devs do, it’s not a project that I find particularly compelling, so I plan on leaving it once I’ve submitted my last set of patches.
Almost any software project involves working with dependencies – from single-purpose libraries to complete frameworks. When you’re working on a project it’s tempting to bring in libraries, focus on meeting the user need, and figure out the niceties later. However, a little thought early on can go a long way.
This is because every dependency can bring its own licensing obligations that affect how you are able to distribute your own software. In some cases, in order to release the software under a particular license you may end up having to rewrite substantial amounts of software to remove reliance on a library or framework that is distributed under an incompatible license.
So there is a tradeoff between being agile and productive in the short term, against the risk of needing to do a costly refactoring triggered by a compatibility check before – or even worse, after – a release.
For larger projects, and organisations with multiple projects, this starts to stray into the territory of open source policies and compliance processes, but for this post lets just focus on the basics for small projects.
A good strategy is to build good dependency management practices into your general software development practices – similar to the concept of building in quality or building in security.
In other words, given that the cost of fixing things later can be significant, it’s worth investing in the practices and tools that can ensure potential issues are spotted and fixed earlier.
At its simplest, this can just mean developing a greater awareness as an individual developer of where your code comes from, knowing that what you reuse can limit your choices for how you license and distribute your own code.
So in practical terms, this means being careful about copying and pasting code from the web, and making sure you know the licenses of any dependencies, preferably before working with them, but certainly before building any reliance on them into your code.
It may also make sense to handle any required attribution notices for inclusion in a NOTICE and README as you go along, rather than just rely on a release audit to always pick them up.
There are also tools that can help make things easier. For example, if you use Maven for Java projects, there is a License Validator plugin that can help flag up problems as part of your compile and build process.
Alternatively, Ninka is an Open Source tool for scanning files for licenses and copyrights. While it can’t follow import declarations or dynamically linked libraries, it can be useful to periodically check builds. A similar project is Apache RAT (Release Audit Tool) which was originally created for use within the Apache Software Foundation for reviewing releases made in the Apache Incubator.
For larger projects and organisations there are also complete open source policy compliance solutions like Protek from Black Duck, or Discovery from OpenLogic.
It’s also worth pointing out that, while tools can be a part of the solution – and can be invaluable for large projects – ultimately it’s still your responsibility to make sure you meet the obligations of the software you are reusing.
If a dependency has a compatible licence, thats great. But what about if the project that distributes it doesn’t bother checking their own dependencies?
This is where it’s good to have an idea about the governance and processes of projects you depend on.
There aren’t just licensing risks associated with dependencies – if you rely heavily on a library that has only one or two developers then you also run the risk that it may become a “zombie” project with implications for the rest of your code, for example, if security patches are no longer being applied.
Beware of zombie projects!
The commercial tools mentioned above are also typically backed by a knowledge base that can also flag up other issues with dependencies, such as governance or sustainability problems. However, just having a check for the project on Ohloh is often good enough for most smaller projects to check that a library is still “live”.
If you need to know more about the sustainability of a particular project, OSS Watch can carry out an Openness Review to check its viability using a range of factors – get in touch with us if you want to know more.
Some organisations make use of component registries to keep track of which components they approve on in their software projects. This can save time spent by developers researching the same libraries, but makes most sense when you have a lot of projects that probably need the same kinds of components, in which case focussing on reusing the same set of libraries makes sense.
Another reason for using a registry is where you need to perform more detailed evaluations, for example for security, and so checking a dependency is more involved than just figuring out which license it uses, and that the project isn’t dead.
Some examples of commercial registries are Sonatype Component Lifecycle Management and Black Duck Code Center. Again, for a smaller project or an organisation with a relatively small set of projects this can be overkill, and just having a shared document somewhere where you can keep note of which libraries you’ve used can be effective.
For example, you could share a spreadsheet with colleagues containing some basic information on each library like what version you’re using, what license it’s under and the date and results of any investigations you’ve done into sustainability, security or risk assessment.
Reusing code is good practice and should save you time and expense – so it’s annoying if the administration associated with it starts affecting your productivity.
You can make a judgement call about what level of risk you feel is acceptable; for example, on an internal-only research project the risk of having to undergo a major refactoring should the project be successful may be one worth taking.
However, for a production system, or a component that is itself intended for reuse, you may just have to accept that you have to be a bit more diligent in how you reuse code.
Photo by DieselDemon used under CC-BY-2.0.
This week, people from Worcester Art Museum come to the class and gave each of the content group some suggestions to make our app looks nicer and more usable. Her suggestion for our group is follow:
First, make the interface more simpler, so when the readers scrolling the article, the pictures will not fly everywhere;
Second, add the lightbox feature into the chapter. Although I have set up the feature, but we are not yet to combine.
Third, since they have HD pictures, they want us to make zoom function into the app, which we disable the function at beginning.
This week, with joe’s help, my lightbox function now is working in the app.
My primary work is working on the zoom function. My goal is to having zoom function, while doesnot effect other chapters.
By talking with my classmate, Williams, he told me the way how to disable the zoom function.
<meta name=”viewport” content=”width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no” />
Hello Everyone,
There have been some great things happening here in Sky-Time Land. We had the game set up on some of the FOSS Box computers during imagine RIT, and it was a hit with the kids!
Don’t trust my word, this video of one child's excitement speaks for its self: http://jlk9713.cias.rit.edu/videos/index.gif
Today we had our last class! Everything seems to be mostly done just putting everything together and making sure it runs correctly. The only thing that had to be done today was put licensing in the all the code files. Next week we will meet and each group will give a presentation on how the entire semester went and what exactly it is that we did and how we got to our finished product. It has been a long semester and a lot of hard work but it was an interesting class to take. We finally got to take what we have been learning and use it in a real world project. We got to learn how to deal with a company and take what they imagine there application to look like and actually bring it to life. I think we did a good job with grasping all the pieces they wanted in the puzzle app! I can’t wait to be able to visit the Worcester Art museum and actually use the app that we have been working on all semester and be able to say my classmates and I built this!
Finally i got the access back to my blog. For some reason i have not been able to receive the password-reset email for my WordPress account.
Now, for the screensaver part, we have the code almost ready. According to the design Tim asked us to make on our app, the screensaver part has 2 parts as i mentioned on my previous post: a screensaver and a introduction page.
Here is how they look like:
1st: it is a slideshow of the statues and their pieces.
2nd, when any touch is done to the screen, a instruction box will pop up, and after that is the introduction screen.
By swiping back and forth, we can navigate the slide of the introduction.
3rd, when the “Skip to Home” button is touched, the homepage will pop up.
.
Previously, there was another introduction page we came up with with the design from the website http://www.bttls.com:
But due to the incompatibility of this version on the iPad, the jQuery mobile version above was chosen.
This past week, I just fixed some bugs in my files
1) screensaver links to the wrong document name (easy fix).
2) IntroPage: left & right navigation buttons are (much) slower than swiping fingers, I’ve tried playing with the values in the jquery-mobile.js file to make the transition faster, which it did make it faster, but the transition was still not seamless like when swipe the fingers. So I just decided to get rid of the navigation buttons, and replace it with “Help” button to give user info on how to navigate the pages. Now it looks like this,
and when you click the Help button, the pop-up dialog looks like this,
Now I will work on writing a How-To document to give Tim information on how to change the content of my pages, for future reusability.
In the final week of class I find myself going over what I’ve accomplished and learned from this class. I’ve learned how to read HTML 5, not necessarily code in it however. I’ve learned Javascript and how to manage a real life software development project as well as how to interact with others in an environment where there are multiple coders. And I’ve also been able to boost my troubleshooting abilities with programming.
This semester went by so fast! It is crazy to see how our progress has made over the entire length of the semester from Day 1 to now. I know for my group the puzzle, we have made a lot of progress and learned a lot. Getting a better understanding in HTML5, JavaScript, & CSS has been very helpful. Especially how my job has me doing some work at times with theses languages which make it easier now to understanding the code. The last bit of work left to do is the powerpoint presentation for next’s week final block.
This class has been a fun and a learning experience with new tools that will help us all in our future careers in Computer Science. Working with the Worcester Art Museum was just like working for a company or in my case it felt like I was reporting to my boss. I think the class definitely gave everyone a feel of what the future will be like in our paths and how it will be to meet deadlines for future managers (Tim in our case) to see for approval. Communication is key and this class really got us into that aspect of working as part of a team to complete tasks compared to any other college class.
Over the past few weeks, the ideaLab app for the Worcester Art Museum has received the majority of its finishing touches. A lot of the time has been spent communicating with Tim and his colleagues on the visual aspect of the app as a whole; where things are being placed and what colors and images to use. The core functionality of the project is there and ready, it’s just a matter of getting feedback from the higher powers over at WAM and applying the changes that they desire.
On the puzzle’s side of things, it’s much of the same story. We’ve had the finished idea for a few weeks now, but our group has been communicating back and forth with Tim pertaining to a few things. He sent us a layout of a cover page to be the first page one see’s when they visit the puzzle section. This was just a matter of converting these images to the right size and placing them correctly. There was also editing done to the actual page the puzzle is on; images for the buttons have recently been added and other formatting issues have been taken care of.
Overall, this has been an interesting semester. This class provided a fun, and sometimes frustrating challenge. What I really am taking out of it is more than the actual programming and development – I think the class as a whole gained valuable real world knowledge. The process of dealing with a client and working as a group are skills people in the field of computer science must grow accustom to using, and I think this class provided that.
This post is for others as much as it is for me. I’m using it as a point where I left off today and continue over the next few days.
I’ll start off with the success. Pinch to zoom somewhat works BUT it is very buggy to say the least. If the kiosk is used to disable the pinch to zoom, it should completely disable it and be at the point it was (a usable state). The problem with zoom right now is that it is zooming in the entire web page, but it is only being used when the image is clicked. Other functionalities will be disabled in the zoom sequence. What needs to be altered here is making the background static so it does not move and only the image is zoomed in upon.
Onto the other issue. I’m still trying to work on it, but the carousel is still not swiping. I have it all ready for the code to be put in. The swipe setup is ready and it is acknowledging the swipe at the right time (using alert() I can tell) it’s just implementing it in. It’s tedious to test. Each time I have to upload the changes to the test server and test through my iPad. It’s an issue with variables. It just needs to update what gallery image needs to be centered. Using and array like galleryImage[i + 10] for example is what needs to be done, but a little more involved.
I’m hoping I can get this running up to standard before the semester is over. I would hate to drop it onto someone else.
This post is an odd amalgam of all the different things I have learned, and done during the course of this quarter in the Open Source class. I will also be opening with the status of our project, given that we only have one more week there may not be another blog post to follow.
Before going forward I want to say that this class is one of the best I have ever taken, it involves everything that I have been saying was missing from other classes for two years now. No other class has you work on real projects, is language agnostic, mixes students with non-students on projects, gets you involved with the community, and has you learn version control software. These are all things that exist in the industry, but in almost no classrooms.
Our team chose to work on OpenVideoChat, a Sugar activity that would allow for video communication over a network. When we started the program was not working, and we were warned that it was quite a piece of work.
Our original goal was to read the code and make sure it was fully documented before changing anything, but as we continued to see deprecated code in use we eventually shifted gears to update the code before documenting it, as it was going to need to be changed anyways.
We managed to get it to “start” within the first week by updating some deprecated property names. We tested video successfully, though randomly, using the old code with some minor changes, but making it stable was going to take a lot of work.
I believe our team is exemplary, none of us joined as python experts, we have all undergone a learning process, and each of us has our own area of specialization. One of us specializes in git which has saved our team multiple times over the quarter as we switched work-flows to try and speed up development.
Another team member read about all the deprecated components and started pushing us to move the system to the latest Sugar3/Gtk3 standards.
I am proud to say that as of the end of this week the network stack and interface are 100% modernized using the latest Telepathy channels for message communication, and Gtk3 elements for the interface.
At this stage we have roughly one week left for our course, and our original goal to add documentation and diagrams is not complete. We are also still missing video communication. Whether our project can be considered a success is left to be interpreted, though with a bit of luck maybe we can get video up in the next few days.
The network stack was the latest challenge, and I just finished working through it as of Thursday (May 2nd). The original code used custom connections and tubes, while newer code uses telepathy channels. The tubes may still be required for streaming video, but the old code appears to have used tubes to get the IP Address for video streams.
Using the Chat.activity as a basis to building our modern communications system, I was able to identify what we needed and implement it. After two days of testing I managed to get the connections working.
What really saved me was reading the detailed Telepathy documentation, which explained the components and made sense of why channels and connections were accessible from the sugar presence service.
Not everything went perfectly, I became really confused when I read the constructor code of the Chat.activity, as its setup process either connects to the joined or shared signal, but may also already assume they have joined and call the method after connecting to the joined signal.
In none of my tests has `get_shared()` ever been set on-load even when `shared_activity` is set. Further why connect to the joined signal, shouldn’t that be in the `else:` logic?
So I spent a lot of time trying to understand the natural flow of shared, joined, and other sugar activity specific signal procedures.
Apparently shared is triggered by making an activity public or inviting someone to it. Hence why an activity can be shared privately, by invite. I also found out that you cannot unshare an activity apparently.
In every test I ran joined always fires when you join an activity. Whether you join a public activity or by invitation it always fires. In no case did get_shared() return true either. So in my code I omitted that logic.
However, the Chat.activity also contained some excellent resources I had not seen and which made debugging worlds easier for me which I will discuss next.
The Chat.activity had references to the Logging utility, which I found that I could import and clean up my debug messages from messy print statements to truly useful manageable segments of output.
Once I began using the logging utility with dir() and type() introspection methods everything about debugging became exponentially easier.
I had previously mentioned bpython when I was debugging Gtk3, and the one downfall to using a tool with auto-completion was when it had a dozen dependencies. Without a second system to connect to testing networking is tough, and that is not something I could do with bpython easily. So the ability to print out the methods and properties of an object with dir() is the next best thing.
I guess it is kind of funny that I am only just now figuring out the appropriate debug utilities, but if you want to add logging to your system throw this above your class definition:
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
Then you can print the contents of the activity object in your code like so:
logger.debug(dir(self))
Take note that the setLevel() method allows you to specify the level of messages to display. You can comment out that one line to silence the output for standard users, without having to remove your debug code.
Oddities with the Sugar Builder were a serious challenge.
When we began working on the project there was an empty network file, no code and no references or imports.
However, when we deleted it and tried to build a dist_xo, the sugar builder would complain that the file did not exist.
For about a month we left it there, until I decided to run a check on the builder source code.
As it turns out, the Sugar Builder requires your source code to exist inside a git repository, and will use the git history of the directory contents to build the files. In other words what is in the directory is not used, but what git expects to be in the directory.
The solution was to inform git that we deleted the files, which while testing I generally don’t push changes when I don’t know they will work (or if they throw errors especially not).
So, interesting fact you can now be aware of.
When I setup my development I tried my best to emulate the laptop environments we had. One problem I ran into was that the laptops were without a password. Both the user login, su root and sudo command required no passwords.
While this is certainly a security problem, I figured with snapshots and virtual machines it should hardly be an issue. So here is how I created a passwordless user `olpc`:
passwd -d olpc
usermod -aG sudo olpc
To make sudo work I added this line to sudoers:
%sudo ALL=(ALL:ALL) NOPASSWD:ALL
I found documentation after finishing most of my Gtk3 code that solved one of my problems.
Some Gtk3 widgets do not have a background, so setting the background color wouldn’t work. In the common questions of the Gtk3 documentation it specifically recommends adding things to a Gtk.EventBox and applying a background to that event box.
Am I the only user who thinks this is extra hacky? Why an EventBox exactly? Are we missing a simple paint-container?
I am all about design patterns and abstraction, so during the rebuild I have been giving a lot of attention to how the design and flow of operations and communication between classes is handled.
Previously, everything had ties back to the Activity. This was a very coupled design, so my aim has been to abstract the network stack and GSTStack from the rest of the system, making the Activity and GUI code the primary source for change based on situations. This makes both of the other classes much more reusable. _Still working on how to abstract the `shared_activity` property such that it can be reusable in a non-Sugar environment, but this is not important to the functionality of the current version._
In a number of areas I eliminates the former approach of creating class-level properties to access custom settings, and began using objects and built-in components. For example, since we apply the GUI as the canvas of the activity, I use get_canvas() to get the GUI instead of setting self.gui and using that. Other examples include storing the toolbar of the toolbarbox instead of a custom array of buttons, and using `get_nth_item` to access buttons on the menu in operations.
I did my best to limit passing and storing whole objects such as the activity, which was previously used as a medium of communication between the objects, and now supply the components to the GUI. This makes the most sense as it allows the GUI to be tailored to the code and not the code tailored to the GUI. We can directly connect signals on the network stack and GST Stack to the GUI components as well.
Here are some of the many bugs I have run into during development, most have been resolved:
Sugar documentation (somewhere) says you can use max_participants to apply a limit to the number of users of a shared activity. It specifically says it must be self-enforced. However, there is no details on how to enforce a limit of 2 people on an activity.
Making an activity public manually has proven impossible so far. I tried the share() method, but calling that manually crashes the code. However, I added the button back and that works and I am less worried about this now.
Apparently once an activity is made public it cannot be made private again, or the share button is just broken in my development Sugar systems.
One bug that I have not pin-pointed is that occasionally the save() operation inherent to the Activity object is called while loading, and will fail several times before crashing the activity. Wrapping it in a try-catch did not resolve this, and it only happens once in a while generally after many previous crashes caused by development test-runs.
Apparently the signal for buddy-left occurs erratically, as in my tests only once did I ever get a disconnected message. It could be the use of development environments, and the Chat activity had the same problems. There are work-around I could implement such as sending a disconnect message from can_close, but that feels hacky and really this does not effect the functionality all that greatly.
So, the project has a new face, and new internals, but is still missing video. At this point if we can finish documentation I would be happy, but we still need working Video.
If GSoC approves my application to work on this project some more I would be thrilled, but I may continue to work on it anyways if able, since it has been a wonderful experience in general.
Well there is just one more class Session before the semester ends. Unfortunately we still don’t have a fully working program. There is a possibility that work will need to continue during the summer. Some students who will still be around have volunteered to continue working on it. I as well volunteered for this, although I wouldn’t be much help with the coding side (not having as much experience with it as others) I offered to continue testing and helping with any Kiosk Pro issues that come up.
The good news is that Most of the individual pieces are working well, problems left are minor and mostly just polishing. Once everything is integrated it will need testing to make sure that process didn’t mess anything up.
On Monday the programmed was reviewed, even if in pieces by WAM, I helped to explain some of the program and each group talked and did a demo of their own part of it. I took notes on all the changes that they wanted in case anyone needed a reminder later on. Most of these changes were cosmetic in nature and not to difficult to do according to the teams.
So far as I can tell this week no changes have been made to the code on the server for any section. So I was unable to do any testing. I was able to put together a simple word document instructions for setting up the other iPads. This should make things easier for WAM and also help reset things properly if the settings are ever somehow changed or corrupted.
For Next week will do testing on Tuesday (the last day of classes before Final Exam week). In my blog I will list any remaining problems I have found in my testing as well as any issues from WAM that have not been finished. I will also send that list out by e-mail to the group so that if for whatever reason I am not assisting in the completion of the program, those that are will have the most up to date list of needed fixes.
The Guardian Careers site published an article yesterday discussing which skills you should have on your CV to ensure your application is “at the top of the pile” when applying for IT jobs.
Among the usual traits such as being able to program (they suggest Java, but with a willingness to learn new languages), one of the recommendations is “Open up to open source”.
In a succinct paragraph the article manages to introduce the idea of open source, as well has explaining both its benefits to the public (in terms of having access to zero-cost versions of software) and why IT companies and departments would be looking for it.
Engaging with an open source community provides you with the opportunity to gain practical experience in working on projects with a distributed team from diverse backgrounds. Any skills relevant to the IT industry would be desirable to an open source project – not just programming but also skills like project management and technical writing.
The public nature of open source projects also means that your work will be open for potential employers to examine. Code you’ve written for a previous job may be locked up in a company’s version control system, but by contributing open source code you give a potential employer the opportunity to see evidence of your competence in the field.
Of course, beyond the benefits of the general IT skills you can acquire, specific experience in open source engagement can be of value to IT companies who are increasingly taking advantage of open source software. To get the full value from open source implemented in an organisation, that organisation should be prepared to engage with the community process, allowing them to get bugs fixed, contribute to the project, and possibly influence the project’s direction in their favour. To make this possible, they’ll need people with experience of community engagement.
After a late start, Matt and I have been blazing ahead on development of Sugar. As of this writing, we have 6 (almost 7) patches merged into Sugar upstream.
The biggest hurdle in getting Sugar installed was that I wasn’t running it on a supported OS. I was building and testing on Fedora 19, where it only supports Fedora 18 and Ubuntu whateverthefuck.
As a result, my first 5 patches fixed various problems with the build system, including adding support for Fedora 19. After some vigorous testing and discussion, all 5 patches were merged in.
Afterwards, I found a crash in the journal caused by mousing over the Pippy activity icon. The crash was caused by a call to a deprecated function…a function prevalent across the entirety of Sugar. My 6th and 7th patches are fixing this sweeping problem.
While we haven’t quite fixed the kinds of usability bugs we first set out to fix, we are making a significant impact on Sugar and are helping fix the contribution process.
Success! We will be at Imagine RIT in FOSS Box in the Innovation Center!
The download is not quite ready yet, but should be up shortly!
This week we rethought the interface and user interaction with the keyboard. At Ryan’s suggestion we are now using the shift keys to move the clock hands. This allows the player to use both hands comfortably. We also have some plans for positive reinforcement with animation of clock hands when the student gets an answer correct. (For now we just have an image that pops up)
We have pretty much decided that we’re not going to finish the code side of the project. The reasons are documented extensively on our wiki, but suffice it to say there were a multitude of factors at play.
Also, I’m unpublishing all the blog posts related to TamTam once the quarter’s over. Sorry for the blogspam, folks. It was a requirement for the class.
I have a profound post coming up on what it feels like to be about to graduate from college.
On April 19th the United States Patent and Trademark Office finally rejected an application for the trademark ‘Open Source Hardware’. The grounds for the rejection were that the term was ‘merely descriptive’. Trademarks are intended to identify a specific source of goods or services, protecting that source from confusion in the minds of consumers with other sources. Naturally then, if you try to obtain a trademark which is just a description of a type of product or service, it is proper that you should be refused; it would not be distinctive and it would distort the market by allowing one source to control the generic term. If I market a car for a hamster, I should not be able to get a trademark for the name ‘hamster car’, as that would improperly restrain competitors from bringing their own hamster cars to market. So should we be pleased that the application was rejected? After all there is no trademark ‘open source software’ (although the Open Source Initiative do hold one for their own name and logo which acts as a kind of accreditation mark for their approved licences and projects that use them). In this case it’s a little confusing, because the applicants do not seem to have been actually looking to use the mark to describe what is usually understood by the phrase ‘open source hardware’ at all. In fact they were looking to protect their offering comprising:
Computer services, namely, providing an interactive web site featuring technology that allows users to consolidate and manage social networks, accounts, and connections to existing and emerging application programming interfaces (APIs)
Reading the decision it seems that the services relate to providing and managing services for children on a variety of devices, and that the trademark is supposed to imply the ‘general freedom’ of open source software but applied to one’s hardware devices in a surprising new way:
In support of registration, applicant maintains in Section 1 of its brief that the mark is not merely descriptive because OPEN SOURCE was used initially with the Open Source Software Movement; that applicant’s use of “open source” would associate that term with the provision of software and that “this causes a jarring effect that is overcome by the user’s imagination to the play on words.”… Additionally, applicant argues that joining HARDWARE next to OPEN SOURCE causes consumers to think of “physical artifacts of technology designed and offered in the same manner as free and open source software,” citing to the wikipedia.com definition of “open source hardware.”
So, I would argue, this is really not an application to use the term ‘open source hardware’ on what is normally understood to be open source hardware, so it’s not merely descriptive. This is more like the the Irish company that holds the trademark ‘open source’ for use on dairy products. Indeed, the decision does have a strong dissenting opinion which argues that the trademark ought to be allowed as non-descriptive but then properly obstructed by complaints from the actual ‘open source hardware’ community before its final grant.
What this shows, I think, is a couple of things. Firstly, that bodies like the USPTO have trouble understanding phrases like ‘open source’ where they relate to technology. Secondly, that terms that the community relies on to describe their interests and enthusiasms are not necessarily immune from proprietary seizure. While the decision here seems to contain an error that worked to deny the trademark, it’s possible to imagine a similar error that would allow a troublesome trademark to be granted.
In connection with trademarks and FOSS I was interested to see the establishment of modeltrademarkguidelines.org, a wiki-based site which
…proposes language one might use for trademark guidelines for FLOSS software projects.
It already contains a very useful page listing pre-existent FOSS project trademark policies. I would encourage readers to read the draft version of the guidelines and comment.
Al Biles (GenJamGuy)Alolita Sharma (alolita)Andrea Hickerson - RIT (Andrea_H)Andrew Hagner (AJH89)Andrew Ross (aross)Andrew T. MurrayAnthony HajecAntonio F Mondragon - RIT (afmondra)Aparna Mahadev - Worcester State (aparna)Armen Zambrano Gasparnian (armenzg)Armindo AndradeBeau Bouchard (BeauBouchard)Ben Steele (BenSteele)Benjamin Kerensa (bkerensa)Beto LunaBoniface Kabaso (boniface)Brandon ChabanBrian BartholomewBrian LabbeCaleb Coffie (C_Coffie)Cameron Seay (cseay)Carl GodonCasey DeLormeChad Wade Day, Jr.Cheong Poh YeeChris JacobsChris Tyler (ctyler)Clark Hochgraf (Clark_RIT)Coady LaCroixCody Van De Mark (Cody_RIT)Dan Fuhry (fuhry)Dan Slinky (swissslinky)Dan WangDau NguyenDave Kelly (thedavekelly)David D (Biomech360)David Humphrey (humph)David Shein (DShein)David ThompsonDerek CarlinDevin Houde (dphoude)Dhimitraq JorgjiDillon MurphyDorin Patru (dxpeee)Doug Holton (dug_)Eduart LekdushiElizabeth FerraoEric Likness (elikness)Fardad Soleimanloo (fardad)Frank Hecker (hecker)Gary Kwong (nth10sd)Gary Pollice - WPI (gpollice)Geoffrey Anderson - RIT (ganderson)Grant Hearn (gruntus)Greg Hislop (ghislop)Greg Wilson (gvwilson)Harish Pillay (harishpillay)Heidi Ellis (heidi)Howard FrancisIan FurryIhudiya OgburuJ.C. Cockburn / RIT (engineer)James CelonaJames FitzpatrickJames ForkeyJan Wildeboer (jwildeboer)Jared StroudJaric SngJason HintlianJeff Osier-Mixon (Jefro)Jenn KotlerJoe Corneli / Hyperreal Enterprises, Ltd. (jcorneli)Joe YoungJohn DulaneyJon Meschino (KnightMearh) - RITJose Luis FernandezJoseph GavalKaren BeiterKarl R. Wurst (kwurst)Karlie Robinson (KarlieRobinson)Karsten Wade (quaid)Kathleen LentKennedy KongKent Palmer (ekpalmer)Kerry SabantyKevin Granger (KevinMGranger)Kody Hogg (Waterfox)Kristina Striegnitz - Union College (kris_striegnitz)Kulbir Saini (generalBordeaux)Kyle RobitailleLim Kin ChewLong NguyenLuke Macken (lmacken)Marcos KnightMark StevensMark Surman (surman)Mark Thill(thillm)Mark WambachMatt Critelli - RIT (mcritelli)Matt Jadud (jadudm)Matthew MorrisseyMel Chua (mchua)Michael Adeyeye (micadeyeye)Michael AguirreMichael Gage (Gage)Michael Graaf (michaelgraaf)Michael Kenny (mgrmaverick)Michael Lutz - RIT (mlutz)Michael Riordan - RIT (mprppr)Michael RossettiMichael Yacci (icepop27)Michelle PurcellMihaela Sabin - UNH (mihaela)Nadia ZahidNadimpalli Mahadev - Fitchburg State (mahadev)Nancy Doubleday - RIT (ndoubleday)Nannette Napier (nnapier)Nathan DoeNicholas Whittier (imperialwicket)OSS WatchParitosh Aggarwal (paritosh1010)Patrick ChanezonPierros Papadeas (ppapadeas)Rajeev AgrawalRemy DeCausemaker - FOSS@RITRob Willhoft - Roberts Wesleyan College (willhoft)Roger ChiunRolando Raqueno (rraqueno)Ryan StushRyan WilliamsSarah Wagner - RITSean HortonSean Normoyle (happyjack825)Sequetta Sweet - Monroe Community College (ssweet4)Sompop SuksawatStephen FlynnStephen Jacobs - RIT (itprofjacobs)Steve Kuhaneck -RIT (skuhaneck)Steve Viggiano (Root.at.127.0.0.1)Taylor Rose (trose)Ted Pawlicki (Alkorozim)The Humanitarian FOSS Project (www.hfoss.org) BlogThomas Galica (ikonified)Tirath SinghTrevor HoddeWilliam OrrWooJoong HwangWyatt Winters (wywin)Ye LongZhengjun Li