Lance Laughlin

I'm a graduating New Media Interactive Development student from the Rochester Institute of Technology. I blog about open source software and web development

It’s the final countdown!


So, the end of my college career is slowly approaching! WOOOHOO! Anyway, for our last assignment in Advanced FOSS we are to open 10 issues and close at least 5 of them by next week. We can either chose to update the course website or add to our existing projects…I’m doing a hybrid. Here are the 10 issues I plan on working with:


In-glass – CLOSED – CLOSED

Course Website – CLOSED – CLOSED

RocWiki/Wikipedia – CLOSED


Now for a recap!

It’s been a fun and enlightening year for me. My experience in free and open source software began last semester and I feel I’ve really come a long way since September. This post is technically supposed to cover the Advanced FOSS class; however, I think it’s important for me to cover the entire year since it was so important to me. At the beginning of the year I knew the basics of open source but had never done any actual open source development or contributed to any open source projects. The desire was always there…I just needed a little push in order to actually accomplish my goals. Luckily, the FOSS courses were there to inspire me to learn as much about the open source movement as possible.

My journey and really the thing that threw me into it all was Github. Initially I saw Github as a way of sharing my code with employers. Github was actually super beneficial for me in my job hunt. I was approached by recruiters who saw my Github account and was impressed by my code. SCORE! Pretty much every interview I got asked me to go through some projects on Github and talk about my reasoning behind my code. This was super helpful for me because it forced me to go back through my projects and make my code more efficient since I knew so many people would be looking at it and potentially forking my code.

Another great step for me was learning IRC. It’s really a great resource, especially when you have a great channel like RIT-FOSS. It was really nice because it allowed me to integrate myself into the open source community in both the digital realm and in real life! I now use a number of IRC channels to ask specific questions…super helpful!

I can safely say that I’ve become a much better programmer and person from learning about open source. I’m now much more eager to share my ideas and code with other. In the past I would be more hesitant doing so because I felt that all the work I had put into something would be wasted if I just gave it away. However, now I open source everything I do. This is mostly due to how much I’ve utilized others hard work. I feel like I owe it to all of those people who have helped me. Who knows, maybe someone will find my code at 4 in the morning after a long night of frustration and it will solve their problem for you.

Open source has changed my philosophical views on many things too (though I think the act of growing up has too). Again, I used to be a big proponent of private property (both physical and intellectual). I felt everyone deserved the right to keep their ideas locked in a tight box, after all, they are the ones who worked so hard to accomplish their goals. I still feel that this is an important right to have; however, I also realize that having the right to share your information freely is just as important, if not more. With Github and the FOSS movement thriving, it allows innovation to happen.

Thanks for everything FOSS!



Community Contribution 3

Coming soon…I promise.

RocPy live from PyCon

This month at RocPy was a bit different than usual. Generally, we have lecture like sessions where one of the members will give an overview of some Python goodness. However, this time around we were lucky enough to have our Advanced FOSS professor, Remy, video chat into the meetup live from PyCon. PyCon is basically the Mecca of the Python world. As far as my knowledge goes, it the most highly attended Python even that exists. Many of the FOSS students at RIT also tagged along for the trip.

PyCon consisted of Remy interviewing a number of folks in the Python community and we were able to do some Q+A with them which was pretty rad. It’s difficult to remember the names of everyone (Most I hadn’t known the person but I knew some of the projects they talked about). One that stands out to me is a man who worked at Mozilla, he was part of the Firefox OS team which I thought was pretty awesome (I’d love to check it out). One person worked on creating open data sets (something that I currently have in the works myself) which I found interesting. The rest of the guests were general Python enthusiasts who made a variety of tools and utilities.

I really enjoyed this RocPy! It was a nice change of pace from the usual meetings and was very informative!

Community Contribution 2

For the second Community Contribution I made some edits on the RocWiki. My current apartment building was recently bought by a new company and the information about the building was out of date on the RocWiki. I added who the who owner of the building was and updated the web address. You can see my edit here:

This was the first time I had ever updated RocWiki and I think I’ll continue to do so as I have noticed some out of date information on a few entries.

Hack #2

Hack #2 is basically done! We have changed the class syllabus to allow us to continue to polish our projects from this semester so once this phase is done, WE ARE DONE! The project came out really well in my opinion and I think people will dig it. My teammate Chris Knepper did a great job creating the initial UI and base functionality. My role was mostly filled by cleaning up the UI, adding some local storage functionality and making the design more responsive. I think our project really shines due to it’s simplistic functionality. It does exactly what it should and it does it well. It doesn’t bombard you with unnecessary UI elements or settings…it just works. Overall, it was a good learning experience for me. I got to mess around with FLASK which I’ve been meaning to do for a while now. It’s actually really simple and does help streamline your workflow a bit…I’m not sure if I’ll totally switch over to using it; however, I can definitely see it’s merit and will continue to learn more about it.


Title of Hack


Short Description of Hack

Web-based temperature monitoring using Python, JavaScript, some computer running Linux (i.e. Raspberry Pi) and a USB thermometer.

Software Libraries Needed

Flask, libtemperd

Upstream Distribution Repository

PyPI, GitHub

Open Hardware Needed

Temper USB Thermometer

Team Members

Dustin Raimondi
Lance Laughlin
Chris Knepper

All team members will be contributing to development, design, and documentation.

Project Milestones

Milestone 1: Skeleton Flask app that outputs dummy temperature value

Milestone 2: Reading temperature from device and displaying with basic history on web page

Milestone 3: Store temperature history on back-end and customize display on front-end

Stretch: Handle multiple devices connected to the same computer.

Other Details

Mentor: threebean (What a cool dude!)

Hack #1

So we have finished up hack #1, Entropy. Check out our repo here:

Entropy was a lot of fun to work on. It was my first experience creating a command line tool and it was much easier than I had expected it to be. I also feel that the tool we made is pretty nifty and I’d love to see it continue to grow and become more elaborate. Our current system for rating is pretty elementary and could definitely be polished and expanded on. Overall I thought it was a great success!

Community Contriubtion #1

For Advanced FOSS we were tasked with doing a community contribution in some form. I decided that I would update a couple Wikipedia pages since it wasn’t something I’ve done before and I was interested in how everything worked. I’ve come to learn that editing a Wikipedia page is very easy…perhaps too easy. My first Wiki edit was for the upcoming PS4 exclusive: Infamous: Second Son’s. It was officially revealed today that the game would be 24GB for the digital download of the game. There was some discussion about it on the PS4 subreddit and it apparently was some news released a couple weeks ago; however, a large debate that has happened between early PS4 buyers (like myself) is the amount of space these next-gen games are taking up. When early games like Killzone, Battlefield 4 and NBK 2k14 came out and were packing a beefy 40GB data size many people began talking about whether the 500GB HDD was big enough. This isn’t only an issue for those who are digital buys because when you first insert a new game into the system all of the disk contents are automatically downloaded to your HDD. So I thought it could be benefitial to add that to the wiki article for the game. I know that often when I want to know some info about something I’ll google “whatever wiki” in order to get a full overview of the thing. Here is a revision history for the edit:

The second article I updated was for a widget that is used across all pages related to the Miami Dolphins (my favorite football team). It was big news today that the Dolphins had resigned their star corner back (one of the guys that guards the wide receivers), Brent Grimes. I originally checked Brent Grimes wiki page to see if someone had added it. Things move fast on the internet so I loss my shot; however, I did notice at the bottom of his page there was a Dolphins roster widget which still had him listed as a free agent. Woohoo! So I went ahead and changed that so it listed him under the active roster:

Overall this was a pretty easy task. I was surprised how easy it was to edit a Wiki page. I’d always heard about it being easy but I didn’t expect it to be SO EASY for anyone to edit a wiki article, heck you don’t even need to log in (though your IP is logged). This has definitely made me more weary to trust everything I read on Wikipedia and I’ll probably make it a habit to check the source. I use Wikipedia multiple times a day to look up generally random facts; however, I also consult it for homeworky type things; therefore, it’s really important that I’m not reading something fictional.

I will probably continue to update Wiki articles as I see fit in the future. It’s definitely a cool idea that so many people can contribute to common knowledge; however, I think it would better if there was a better process in place for editing: like forcing a login and perhaps a reputation system.

Entropy Status Update

This blog post is a reference to a team project I’m working on for Advanced FOSS:

So the first week of development has officially ended! Over the next week we’ll need to finish up the rest of our functionality and start preparing for testing and packaging.

So far we have a command line tool that is successfully reading in an image and spits out some basic info about it; including, the screen resolution and format. This week I worked on and completed the functionality to allow the user to analyze an image that is hosted on the web and accessible by a URL. I was actually quite surprised by how easy it was to get this functionality working. We are already using Pillow to pull some data about the image; therefore, all I really needed to handle was actually pulling in the image from a URL and the code we have already worked flawlessly on it.

Here is a quick code rundown of what I needed to do:

import urllib
import cStringIO

First off, we need to import urllib and cStringIO. urllib allows us easily open up an url and pull data from whatever it serves us. cStringIO is a helper class that allows us to use strings a bit better…I’m not 100% of all the functionality but it’s definitely helpful in this situation.

In our initializer function is where most of the magic happens.

def __init__(self, source): #Pass in the argument image location
self.source = source
if 'http' in self.source:
print 'reading from url'
file = cStringIO.StringIO(urllib.urlopen(self.source).read())
self.image =
self.image =
except IOError:
print "Cannot load image. Be sure to include http:// if loading from a website"

Here we are basically checking if the value the user passed in is a web url. There may be a better way of doing this than checking if the string has http but it works for now. If it is a url we can simply load that image into our program with a single line and then instantiate it as an Image object.

We later go on to print some data about the image using the Image method, which is a part of the Pillow library:

def output(self): #Probably only print this in verbose mode in the future
print "We're processing the image: " + self.source
        print "This " + self.image.mode + " image is in the " + self.image.format + " format"
        print self.image.size

We hopefully will finish off the rest of the required functionality this week. More to come!

Rochester Civic App Challenge

In lieu of our Advanced FOSS class we went to the Rochester Civic App Challenge press conference held at The MAGIC Center. If you’re not sure what the RCAC is check this out: Essentially, it’s a 60 day challenge in which members of the Rochester community hack on apps that are civic in nature. The challenge requirements in general are pretty vague and for a good reason: rules hinder creativity.

The press conference went pretty well and had a decent showing. A large portion of the audience were students from the Advanced FOSS class which isn’t necessarily a bad thing. Many of these students will be participants in the challenge so their presence helps give the organizers a good idea of the type of people who will be competing. I want to use the word competing lightly here. Yes, this is a competition; however, like most things FOSS I truly believe that most of the participants are very pumped to see what their “competitors” come up with..though the prize money certainly adds a touch of competitiveness to the equation.

Unfortunately, I’m not sure if I’ll be competing in the challenge myself due to the massive amount of work I have going on at the moment. This includes both my school work, my on-campus job for Just Press Play, freelance work and preparing for the career fair and entering the real world in a few short months. I’ll likely take advantage of the 24-hour hackathon kick-off though to work on some of my school work and try to lend a hand to anyone that may need it. I’m really looking forward to seeing the type of project ideas people come up with and the data sets that are used. It will be interesting to see how people tackle problems that we face in both government and as Rochester citizens.

First meetup for Advanced FOSS

Now I’m not a nooby when it comes to We went as a class every month for our HFOSS (Humanitarian Free & Open Source Software) class last semester. This semester we are rollin’ deep with both this semester’s HFOSS class as well as our Adv FOSS class, totaling about 20 people. This month was pretty beneficial for the HFOSS class as the first hour was about data structures and basic programming logic in Python. I feel like this would have been super helpful for our HFOSS class last semester because about 85% of the class had zero Python knowledge going in. Our class did manage to pick up Python over the course of the semester; however, I really feel like we could have done so much more with our projects had we had a mini-seminar like this. We did get a pretty awesome guest lecture from Threebean though which personally helped clear up a few things for me.

Aside from the intro to Python we had an hour at the end to give lightening talks to the group. Most of the Advanced FOSS students gave lightening talks about our first project for the class. I’m working on a group project with Chris Knepper and Dustin Raimondi which will help people decide whether a wallpaper is suitable for their machine. You can check out our project proposal here: I thought our lightening talk went okay; unfortunately, we only have a proposal at the moment so we couldn’t talk about too much. I felt like the presentation was sort of boring because it was 3 people talking about something very basic and likely would have went better with a bit more content or with less people presenting: live and learn. Check out our presentation here:

Of the other lightening talks for Advanced FOSS projects I must say that I really really like Lindsey Ellis (Fangy) and Joe Prezioso (ArcticSphynx) project. It’s a dog tracker that emails people when their dog(s) are being noisy. I like this idea because it’s very practical and really perfect for the Raspberry Pi. This has inspired me to do something more Pi-centric for the next project rather than something that is simply written in Python and ran on the Pi.

Project 1 Proposal

Title of Hack:

Short Description of Hack:
Rates wallpapers based on a variety of criteria

Software Libraries Needed (e.g. python packages, npm, ruby gems, etc…):

  1. PIL – load local images and manipulate pixels
  2. requests – load images from URL
  3. xlib – get screen information via x session

Upstream Distribution Repository (e.g.
PyPI, GitHub

Open Hardware Needed:

Team Members (if Applicable. With Roles):

  1. Dustin Raimondi (Developer)
  2. Lance Laughlin (Developer)
  3. Chris Knepper (Developer)

Project Milestones (REMEMBER You only have 2 weeks of development!):

  1. load an image from a local source

  2. pull metadata from image

    1. resolution

    2. filetype

  3. pull various pixel data from image

    1. fill in gaps in metadata

    2. overall color temperature

  4. algorithmically calculate image score

  5. load an image from the web

  6. verbose mode

  7. process a folder of images


threebean (pending approval)

Mmmm. Pi.

We took a mini field trip to the MAGIC Center today to a get a bit of a treat; A Raspberry Pi Ultimate Starter Kit:

I’ve been eye-balling a Pi for quite some time. I debated buying one while on break but decided to hold off to get one provided by RIT. We all arrived and received our Pis pretty quickly and began digging in. We mostly went over all the components to make sure everything that was supposed to be in the kit actually was in the kit.

Now this is the first time I’ve even seen a Raspberry Pi in person, let alone code on one. Upon doing a bit more research about the Raspberry Pi I’ve began to understand how everything works together. For my New Media Team Project my group is likely going to use an Arduino to do some physical computing which lead me to this pretty good overview article for a beginner:
Turns out that the Raspberry Pi is a mini-computer whereas the Arduino is a micro-computer. In essence, the Pi is basically a very tiny PC while the Arduino simply aids in electronic projects. Understanding that difference has helped me quite a bit.

I’m exciting to finally get mine booted up; Unfortunately I need to get my hands on an HDMI monitor and a keyboard. This is the first time in my college career that not having a desktop environment has been an inconvenience. Regardless, it will be fun to get started!

First Advanced FOSS post

The spring semester is underway! This blog will become a blog mostly related to that class and the Raspberry Pi’s.

Fractionauts Play Test

So this week some members of my team went to the Allendale Columbia School to play test our game: Fractionauts. Allendale Columbia is a pretty nifty private school in Rochester that focuses on preparing students for college at a very young age. I was unfortunately not able to go to the play testing sessions due to having classes; however, my team filled me in on how the play tests went.

Overall, we got some pretty positive feedback from the kids but they obviously had some criticisms as well (which is awesome! That’s what we needed). Some of the criticism we received was:

  • More on-screen directions, make it very clear
    – This is definitely some good feedback and we already planned to add more directions to the game. This is actually one of the deliverable I’ll be adding to the game before we release it.
  • Give feedback when the answer is wrong (it’s only given when the answer is right)
    – This was a planned feature as well. Should be fairly easy to implement since we already have the correct answer screen. We will need to decide how we want to handle incorrect answers. Likely they will just be given unlimited shots at getting the correct answer
  • Beating the game should increase difficulty, or difficulty should increase as you progress through levels (right now it’s kind of random)
    – This is definitely needed. Currently our levels are just pulled in for jSON. I’ve been working on a questions class that will randomly generate a new questions for the player. We will need to implement a way of gradually increasing the difficulty of the questions.
  • Kids suggest putting buttons in top-right
    – This can be done…will need to see what the rest of the group thinks about this. Mostly a trivial issue.
  • Kids suggest a “hint” button
    – I think this could be beneficial especially if the child is having trouble with a question. Ideally I would like to make this work in a way that they are given the choice for a hint after failing 3 times or something similar in order to deter kids just from grabbing a hint without really trying to solve the problem

It’s beginning to look a lot like quarters

….everywhere you go. Aren’t we supposed to be done with classes now? This time last year we would be starting new classes with a clean slate. So far this semester things have felt a bit…slow. You have longer to work on projects and you cover more things in class; however, there is a lot of uncertainty felt by both students and professors (I think anyway). Unfortunately for me, I got caught up in the slow semester system and now I’m being faced with a large chunk of work and short amount of time to complete it. It looks like my last 2 weeks or so will look and feel a lot like quarters did.

Before the end of the semester I have: A PHP movie-based project (which is currently on hold because Rotten Tomatoes has yet to activate my API key…it’s been 3 weeks.), a portfolio redesign, our HFOSS team project – Fractionauts, a data visualization project that will map crime data in Rochester as well as a final paper for my Civil War America class and 4 journal entries also for Civil War America. I’m starting to feel a bit overwhelmed; however, I know I can get it done.

Our HFOSS project is slowly moving along. We are mostly on schedule and once we finish the first level implementing the remaining levels shouldn’t be too much trouble. Everyone in the group has been pretty good with contributing to the project, I think having Thanksgiving break and all of us being pretty swamped with work has definitely made things a bit more difficult. We will probably have to sprint to get everything wrapped up that we had planned. I am confident we’ll be able to pull it off though.

I forsee a few all-nighters in my future. Let’s do this.


Lit Review #2

Coming soon…

HFOSS Team Project Update

So we are now a few weeks into our team projects (I think?) For those of you how don’t know about the project check this link out:

We spent the first couple of weeks mostly planning, this involved our artists creating some sketch mockups as well as planning out our development cycle, including creating tickets on our Github repo. The first week or two was probably the most challenging thus far. We all had different visions for what the project should look like and it took a little bit for us all to get behind one idea but we finally landed on Fractionauts.

So far I’ve been tasked with creating a questions class for the game. This is basically a class which will be instantiated and will result in a question object that holds, the goal fraction for the player, all the possible choices, as well as a reference to the correct choices. I wanted to incorporate some randomness into the game so I did so here by creating a random goal based on a subset of the possible answers.

Overall, this process went fairly smoothly. I was initially having trouble finding a way to randomly generate some decimals without going over 1.0 total. Mike Nolan (Nolski) and I brainstormed a bit and he had a really good idea of breaking 1 down into groups based on how many correct answers there would be. So if there were going to be 4 correct answers I would break 1 into 4 pieces of .25 and then generate a random decimal between 0 and .25 for each section; therefore, preventing it from ever exceeding 1.0 total.

I’m mostly done with this class so far. I still need to implement the other operations besides addition. Subtraction should be pretty straight forward aswell as multiplication. May run into a bit of trouble with division but we’ll see about that tonight when I try to tackle it.

Another issue I was having is converting the decimals into fractions. Python has this pretty cool Fractions module that you can import: while it does return a fraction when you pass it a decimal, it’s not reduced. So we will need to find a solution for that before too long. Most of the math under the hood will probably use decimals anyway…so it’s mostly for presentation.

We are moving along nicely and I think we should be good hitting our first milestone.

Happy coding!

Rochester Barcamp Fall 2013

This past Saturday was the the Rochester Barcamp unconference. It’s an event that takes place at RIT in which a number of people (we had about 135 people this year) come together and share ideas with each other through 20-minute talks and lightening talks. I was on the student team involved in the planning and running of Barcamp. I arrived bright and early at 8:30am and began setting up tables, putting out signs and creating the grid which help the schedule of talks. At 10:30am we had the opening talk by Chris Horn and then everyone started signing up for events.

My classmate Mike Nolan (Nolski) and I planned on giving a lightening talk on the HTML5 Canvas Javascript library we’ve been working on:

Unfortunately, I spent a lot of time doing working type stuff, primarily checking people in and selling t-shirts. So I only had a chance to catch a few talks: 10 steps in improving your UX, Homemade weapons (it was as awesome as it sounds), and one about setting up a motherboard or something that went completely over my head. I also saw all of the lightening talks as well as gave ours.

My favorite 20-minute talk I went to was the homemade weapons one. It was a couple of young kids, I’m guessing around 12 or 13 years old that showed us how to create a mini-crossbow with Popsicle sticks, clothes pins and rubber bands. They brought all the materials for people to use (their parents were very encouraging, great job on their part).

Nolski and I gave our lightening talk toward the end of the event. It went pretty smoothly, especially for not having much time to put a presentation together. A lot of people had cleared out before we gave our talk so we only presented to probably about 30 people…which made me a bit less nervous since I’m not a great public speaker for the most part.

I’m definitely looking forward to the next Barcamp and I’m hoping I can catch some more talks next time out. meetup 2

As a class we hit up It’s a local Python enthusiasts group that meets at U of R. This is the second time we’ve gone to this meetup, the first time being last month. Every group in the class were to present their proposed final projects. We were actually the first group to present at the event. Our project name is forthcoming (RIP Math Blasternauts).

The one great thing about having to present at was that we got to start meeting with our groups for the first time. It was definitely beneficial to get together and hash out most of the details and have everything in an organized manner. However, it think it would have been better to present at a later time. Each group only had a very general overview of their projects. Though, due to timing issues (pff. semesters) things don’t always go as planned. It would have been nice to show some actual code and maybe working prototypes. Aside from that it went pretty well.

We are one of the few teams working on a completely brand new game. While this is a daunting task I think we have a pretty solid and well rounded team. Now that we have the XOs and we’ve started to get everything set up (still pending a bit on my end) we can really start to dig into the actual production. While I’m not a huge fan of game development, being primarily a web developer, I am definitely looking forward to learning python. It seems like a pretty cool language with a great community.