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

Category: Uncategorized

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
Advertisements

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: http://beta.chrisknepper.com/2013/10/xopc-team-proposal/

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: http://docs.python.org/2/library/fractions.html 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: https://github.com/mpn3712/Graphtacular.js

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.

Roc.py meetup 2

As a class we hit up Roc.py. 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 Roc.py 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.

Team Project

Please see Chris Knepper’s blog post: http://beta.chrisknepper.com/2013/10/xopc-team-proposal/

MA and NY Math Curriculum

For our final group project in Humanitarian Open-Source Software Development we will be making an educational game for students. Obviously, in order to produce an effective project you really have to understand your target. In order for the class to get a good grasp on the kind of skills our games should be teaching we were assigned to read the math curriculum for both NY and MA. While reading through these documents it was pretty easy to pick out a lot of connections that math skills have to games. Even though you may not exactly be using math (raw numbers, graphs, etc) you use many of the ideas behind math.

Both curriculum were pretty similar in content. They both recognized the same 3 critical areas:

  1. Developing an understanding and fluency with multi-digit multiplication and developing understanding of dividing to find quotients involving multi-digit dividends
  2. Develop an understanding of fraction equivalence, addition and subtraction of fractions with the denominators and multiplication of fractions by whole numbers
  3. Understanding what geometric figures can be analyzed and classified based on their properties, such as having parallel sides, perpendicular sides, particular angle measures and symmetry.

Some examples of math relating to games that I had come across are:

Gain a familiarity with factors and multiples

  • This is used in a ton of games for score multipliers. One example I thought of was in Grand Theft Auto 5 when you use the gun range to increase your shooting stats. You really have to concentrate on not “spraying and praying” because the real skill is getting multiple shots in a row to activate the score multiplier. It’s basically impossible to get medals in this task if you don’t take advantage of the multipliers.

Generate and analyze patterns

  • There are a ton of examples for this one; however, one good example would be after dying 10 times trying to get past a mission in pretty much any single player shooter. You may start to recognize the patterns of the AI, for example, you may notice the first enemy always comes running out from the right side next to a red barrel and then the next 2 enemies come out from the right side. You’ll probably start to wait until the second enemies come out and then blow up the red barrel.

Solve problems involving measurement and conversion from a large unit to a smaller one

  • Most RPG games include collecting items and using them to upgrade items or craft new items. Maybe you have to collect 15 gems of a certain kind to upgrade to a new blessing on your weapon. The player starts to think of these items almost as a currency. You start to relate everything to a conversion and begin developing an entire game plan around it.

The curriculum was definitely useful in helping me think of some ideas for our game. It should be pretty easy to incorporate these theories and ideas into a game. As stated, one of the biggest challenges of making a game is understanding your target. With these documents, that has become a much easier task.

HFOSS Commarch Report

Myself, along with 3 other students in HFOSS (credit to those guys in the docs below) had to develop a report about Firefox and how their community worked. Firefox being so massive definitely caused a lot of digging around for some of the answers. However, for the most part we were able to find out all the information we needed without too much fuss!

You can find the answers to the commarch questions here:

https://docs.google.com/a/g.rit.edu/document/d/1KFM5AinnzV90NkCtON81VbxofThcHxs3lS4NyI80fYw/edit

Also, you can view our slideshow here:

https://docs.google.com/a/g.rit.edu/presentation/d/1-rmhNcFjDWS1yTzS0_4fugTMMjmA4CLRbs13qHfDP9w/edit#slide=id.p

 

BugFix Homework Reflection

So it’s no doubt this was the most daunting assignment for me thus far for HFOSS. We were tasked with finding an open source project and contributing to it. Now, this is something completely new to me (which is why I’m taking HFOSS!). I wasn’t sure where I should contribute. I’m most comfortable with PHP so I wanted to find a PHP project to contribute to. Unfortunately, I had trouble finding a project that I myself use regularly enough to know of any bugs; furthermore, never really looking at the code of projects much in the past caused me even more trouble because I wasn’t even sure where in the code to start looking for a bug if I had even found one. I did ask on the PHP subreddit for some ideas: http://www.reddit.com/r/PHP/comments/1mu8we/looking_for_a_beginner_open_source_project/

People gave me a lot of options but I was still feeling a bit overwhelmed. I ended up searching through OpenHatch and I noticed a ton of posts about MediaWiki, which is the service that Wikipedia runs on, cool! It was actually a service I had used a ton before; however, I didn’t feel like I was in the position to really contribute to the actual functionality of the project (plus it was my fault I waited so long to get started on this, I’ll know better next time). One users post on the Reddit thread I created mentioned contributing to documentation, so this is sort of the route I went. I decided to take baby steps and found the README file for MediaWiki and noticed the formatting issues as well as a typo. I decided to fix these to get a feel for the whole process of doing something like this. I forked the MediaWiki repo, cloned it and make the changes, this is where the headaches started.

I wrestled with GitHub for about an hour trying to push my changes with no luck. I went to the IRC channel for help; unfortunately, I forgot that when you close the window your chat history dissapears, so I’m unable to provide that. I did get some help from oddshocks, ryansb and kGrange though. I didn’t totally get my questions answered but they did get me on the right track of figuring out what the problem actually was. I was initially cloning the MediaWiki git instead of cloning my forked version of it. This explains why every time I would try to push the changes I’d get a message that I did not have valid credentials. I found this nettuts article about GitHub which helped get me on the write track: http://net.tutsplus.com/tutorials/other/getting-the-hang-of-github/

After setting the correct origin and upstream I was finally able to push to my forked repo and submit a pull request which can be found here:
https://github.com/wikimedia/mediawiki-core/pull/10

I can’t say I had very much fun on this one. I felt like I was thrown in the deep end for most of it; however, I feel pretty comfortable now that I understand the process a bit more. I could definitely contribute to the functionality of a project now. So while it was frustrating, it did help me figure out some things I wasn’t entirely sure about before.

I believe things will go a bit more smoothly in the future.

Roc.py Reflection

Our RIT-HFOSS class took a trip to the University of Rochester for the monthly Roc.py meetup. Roc.py is a group of Python developers in the Rochester area that meet to learn useful Python knowledge from one another as well as nerd out on everything Python.

This was the first tech meetup I’d ever been too. I’ve had the desire to go to one so it was nice to be kind of “forced” (i use that word lightly) into going to one. I really just needed that push to make me see that they can be very beneficial. The experience was mostly what I had expected it to be. The main differences being it was much more lecturey than I was expecting. It really felt like I was in a class learning from a professor. This was mostly an okay way of going about it; however, I think the meetup could benefit a bit more with some more hands-on approaches to the problem. It would be nice if they took place in a lab that had computers set up and ready to go, which would allow us to follow along with what the speaker was talking about and getting the ability to hack away on precisely what they are talking about. This is the best way to really absorb information in my opinion.

Some things I took away from the meetup:

  • The Python community (in Rochester anyway) is really friendly and open to discussion and questions. While I didn’t ask any questions, I feel that I would be comfortable asking questions once I get a better understanding of Python. The concepts made sense to me; however, when you haven’t touched the language before it becomes a bit more abstract
  • Python has no private namespace….weird.
  • There is this weird double underscore thing called a dunder. I’ve never seen it before and I still don’t totally understand the reasoning behind using one.
  • WHERE ARE THE BRACKETS?! To me it makes code quite a bit more difficult to read/code just using indentation. I guess it’s something you’ll get used to but I would really prefer to get some bracket action up in here.
  • turntable.fm seemed pretty cool. I wouldn’t mind using it while just browsing the web or wanting to find some new music to listen to; however, it may be a bit too distracting for me to use while actually working on something.

Overall it was a pretty great experience and I look forward to going back and being able to showcase some of our work. I think the whole low-stakes public speaking would be beneficial for me since public speaking is definitely something I’m looking to improve on.

Open Source Quiz

What are the titles of each Pillar?

  • Open Exchange
  • Participation
  • Rapid Prototyping
  • Meritocracy
  • Community

What are the titles of each General Principle?

  • Make it interesting and make sure it happens
  • Scratch an itch
  • Minimize how many times you have to reinvent the wheel
  • Solve problems through parallel work processing whenever possible
  • Leverage the law of large numbers
  • Document what you do
  • Release early and release often
  • Talk a lot

What are the similarities between Weber’s eight principles, and the five pillars?

  • They both offer best practices for open source development. Also, they both heavily rely on the community aspect of open-source development and utilizing a rapid development process. According to both it’s essential to put out your work often and get feedback from a large number of people. They also both discuss the open exchange of information and working on projects you truly care about; therefore, leading to a strong work ethic and really owning the project.

What are the differences?

  • The five pillars address more of the ideology of open source. The principles address specific use cases and I think apply more to the actual development process. The way I view it, the pillars are more a constitution for the open source community and the principles are the laws. One is a general overview that helps you make the right choices and decisions and also helps settle disputes that may not even exist at this point in time.

Who’s “keen analysis” did Weber “Draw Heavily” upon?

  • Eric Raymond

What was the title of this “keen analysis”?

  • The Cathedral and the Bazaar

Where can this keen analysis be found?

Success of Open Source Software Reflection

Who:
Steven Weber

What:
The Success of Open Source

Where:
http://hfoss-fossrit.rhcloud.com/static/books/Weber-SuccessofOpenSource-Chap3.pdf

When:
2004

The Gist:
The reading addresses many ways that the open source development process is often a better solution than commercial development. It also addresses the shortcomings of open source development and how the community is working to address them. Lastly, it helps paint a picture of how the open source community interacts with one another.

The Good:

  1. I’ve come to realize the process of approving software patches for open source projects. The Github exercises helped reinforce this as well. I’ve always wondered software like Firefox prevented people from tampering with the code; however, now I see there is (sometimes) a very structured hierarchy to prevent tampering from happening.
  2. Open source software allows people to really work on things they enjoy and essentially have a better work ethic. If they really care about the cause of the project then better work is produced and It allows people to utilize their own expertise. Obviously (or not) one person can’t build an OS on their own because it’s impossible to understand every component of an OS. However, many people can contribute their expertise and ultimately make a kick-ass product.
  3. Working on an open source project helps prevent reinventing the wheel. Often developers can find a boiler plate of a project they would like to work on and start from there rather having to plan out every minute detail. As they build their project further then that original boiler plate can evolve even more. It’s easy to relate it to civilization as a whole. We are able to produce these amazing products and build on scientific discoveries because we learn from the success and failure of our history. The same holds true for software development.
  4. One more just because! Open source software takes a lot of the risk out of development. When you don’t have to navigate through corporate leaders you have more freedom to experiment and possibly find solutions you may not have found if you were constricted but others.

The Bad:

  1. It’s very difficult to track contributions to open-source projects. It’s easy to find the large contributors who are writing massive amounts of code but the large chunk of people who write small bug fixes go unnoticed.
  2. Development is very lop-sided. Mostly follows the 80-20 rule. 20% of the people do 80% of the work. May not necessarily be a bad thing but things could be done to better utilize the talents of everyone. Maybe offer incentives for good components or bug fixes would get more people involved.
  3. Open source relies on an evolving architecture. A solution you wrote may stop working if some of the core functionality of the project changes. This goes along with the loose structure that I address in my questions below. Without (semi) strict guidelines you run the risk of messing up a lot of work that others have done

The Questions:

  1. With open source software that may handle sensitive data (like a web browser) it seems like it would make the software less secure. If anyone can look at the code what is preventing them from understanding how the security works and figuring out ways to exploit it? I think this is possibly one of the biggest fallbacks of open source.
  2. Why hasn’t there been more structure introduced in open source projects? The prime example that comes to my mind is how difficult it is to track contributors. I’m sure there is probably more structure than I realize; however, it seems like there are a lot of cases where more structure could help open source projects thrive a bit better.
  3. Several times the reading address the problem with having a lot of hands working on a project. Specifically Brooke’s Law which states “Adding more manpower to a software project that is late (behind schedule) will make the project even later.” Is this law irrelevant with open source software because there aren’t really time restraints when it comes to open source, or does it still hold true? Is it irrelevant because open source developers aren’t forced to sit in a room together and work out a problem and instead are free to explore their own options on their own time?

My Review:
Overall I found the reading really interesting. I’ve always known what open source was and generally what it stood for; however, this reading made it much clearer how the open source movement works under the hood. I would definitely recommend it to anyone looking to get a better understanding of open source. The reading was very concise and written in an appropriate tone and language. It knew who it’s target was and approached them (us) very well.

3/5

Smooth Sailing…mostly

With the FirstFlight assignment I got tasked a few things I haven’t really dealt with before: GitHub and IRC. Having heard of both of these in the past but never really having a hands on opportunity to learn them, I was eager to dive in.

I had little to no trouble setting up the IRC system. The one problem I’m still having is registering my username. I’ve tried the command multiple times but I can never get it to go through apparently. I’ll have to come back to this soon. I’ve poked around the IRC channel a bit and have had some minor discussions. I’m hoping I can contribute a bit more once I learn Python.

As far as GitHub…I have zero experience with GitHub. I’ve heard of it and I had a vague idea of what it did; however, after reading some of the documentation and working through a few examples I have a much better understanding of it. I’m not much of a terminal junkie…so it’s definitely daunting! I’ve been primarily working in the GUI application because I feel much more comfortable with it. I’d definitely like to get a better understanding of the command line though. I was able to fork the repo and commit my changes (adding my .yaml file)…I’m not seeing it on the course homepage though. I assume the professor needs to approve the commit before it shows up.

That’s all for now! Hopefully these posts will be a bit more interesting in the future!