This release has been a long time coming. There hasn’t been a lot of development on the software, but it hasn’t needed it. I’ve made a few performance tweaks, and there are a few more things I have in mind that should help the app start faster. I’ll probable be posting on those as I get them implemented.

I did have to go through philosophical transition. Grease has always been created to be simple. When I first started writing it, I did so with the specific purpose of not introducing features that I didn’t need and would just create bloat. I think I’ve achieved exactly what I was looking for. A few months ago, though, I received a pull request from someone on github. They had added a number of things, like the ability to change from random to ordered, and had made a few UI tweaks. I accepted the pull request, but when using the app, discovered that it really had lost what I was aiming for. Tonight I removed those additions and returned the project to it’s original aims. In the future, I will probably only be aiming for performance tweaks, especially when dealing with large libraries.

If this kind of app interests you and you find it useful, please let me know! You can reach me on twitter @charlesj.

The problem

I have a confession.  I’ve never used the built in ASP.NET Membership framework.  Early on, it was a pain trying to figure out how to get it integrated with your own database, and later on, I was so used to rolling my own that I didn’t worry about it.  A little more than a year ago, though, I realized this was pretty foolish, so I decided to take another look at it.

Unfortunately, what I found didn’t suite me.  It may work for some applications, but not for what I’m building.  I needed something with some finer control.  Here are a few things I wanted that it didn’t have:

1. Ability to combine webforms and windows authentication (some users from each)
2. Ability to store passwords using the bcrypt hashing algorithm (for future safety).
3. Finely tuned permissions that only give access to a subset of resources in a resource type.

The last one is especially important.  On the basic applications you see in demos, it’s not important at all.  If you have a blog, most people have read access, few people have write access.  For blog demos, users that have read-write access to only a subset of blog posts doesn’t come up very often.  But this is a very common issue in every single web app I’ve ever developed.   Having an “EditBlogEntry” role doesn’t cut it.  That role needs to be able to check to make sure that some user can edit a specific blog entry.

Recently, I’ve set out to tackle that problem.

What I’m working on

It became apparent to me pretty quickly that to get something like this to work, each role would need to be able to execute some unique code to be able to run the logic to insure that a user can access what they’re trying to access.  I would call these “Permissions.”  Permissions would eventually be able to be assigned to both individual users and groups of users, but to begin with, to keep it simple, only users.

Here are some of the requirements:

1. Users (and groups) can have many permissions (many-t0-many in the db)
2. Permissions will have unique  checking code for each one (therefore, each permission is a different class).
3. A filter will be per-controller or per-method (in MVC) and will know which permission that method or controller requires (it will be a string, most likely).
4. The filter will create an instance of the permission, pass in the values needed and then execute some function to find out if the user is authorized.

I started writing some code.  One issue I realized right away: EF expects one table per class.  With each permission being a different class, and wanting an arbitrary number of classes, this would be a problem.  Instead, I would make all permissions inherit from an interface and store only certain information from the class in the database.

Currently, here is the website permission:

When the applications starts up, it reflects over itself to find all classes that implement IWebsitePermission, and it inserts a record into the Permissions Database (if it doesn’t already exist) for that permission. The database stores the Permission Name, Option, Whether it has an option, description, and System.Type.

To give you an idea how this permission is implemented, here is a partial implementation that checks to see if a user can edit a specific webpage:

Okay, there is a lot of bad code in this file. Ini my defense, for now I’m just trying to get this idea to work. Then I’ll work on fixing the rest.  Above all, the entity framework code in the snippet should be outlawed.  And there’s no exception checking!

So far, I’m pleased with how this method is turning out.  It seems like I’m on the right path, but I’ve got some major architectural issues:

1. Where should the permissions be hosted?  In the Models namespace?  In the Website namespace?
2. Is there a better way to pass in the request information and logged in user information?
3. How is the best way to break up permission access?  Does there need to be a permission for add/edit/delete, and every sub modication (e.g. add version to webpage)

I have a long ways to go here, but this idea has been floating in my head for a few years now, so it’s nice to start making some real progress.

This trip is also going to be great because the two people that really got me into this field are going to be there: Constance Steinkuehler and Sean Duncan.  Their 2008 paper “Scientific Habits of Mind in Virtual Worlds” [PDF] was posted to reddit (or somewhere I happened to stumble upon) pre-press and it opened a new world to me.  Since then, I’ve earned my M.Ed., hope to start my Ph.D. soon, and I have no doubt that my career will be focused on this area.

My next major trip will be in July, as I head off to The Amazing Meeting!  I know every year this conference is packed with awesomeness, but I can’t help but feel like this year is the best yet.  Just take a look at their list of speakers.  It’s going to be my first time to Vegas, and I’m kind of skeptical that it’s all that great for someone like me.

I have a few big projects I’m working on this summer.  I’m not ready to talk about Democritus in depth, yet, especially without hearing the criticism I will hear next week, but I am excited about it so far.  My gut tells me that this is something that is really needed and will be huge, but I also realize that I must be skeptical of my gut, as it tends to be wrong.  I will go ahead and offer a short explanation of the project.

Democritus is a next-generation Learning Management System that includes social networking and game mechanics as core features.  On the technical side, it is an HTML 5, with no java / flash / other third party plugins.  I’ve said for years that BlackBoard is crap, so I’m finally doing something about it.

Suppose 30 years from now you receive a paper from one of your students of such quality you suspect they didn’t actually write it.  When confronted, they admit that they had their robot “Curtis” write it for them.  They argue that since it wasn’t another person who wrote it for them, it’s not plagiarism.  Do you accept their paper?  Justify your answer.

As I’m grading, I was noticing a disturbing tendency to agree with the student.  Finally, one of my students’ answered in a way that really demonstrated what their thinking was, and it came down to the way they defined plagiarism.  If they defined it as ‘taking work not your own and claiming that you created it’ they denied the paper.  If they defined plagiarism as ‘taking another person’s work and claiming it as your own’ then they would agree that the student was correct that it’s not plagiarism, but wouldn’t accept the paper.

So in the end, it really hedged on the presence of “person” in the definition.  They don’t imagine robots fitting the description of ‘person’ so it wouldn’t be plagiarism, as long as their definition of plagiarism included the word ‘person’ in it.  I just find that incredibly interesting.

That said, the conference had one major problem this year: it allowed itself to be defined by some criticism that occurred before the conference started by someone who wasn’t even attending.  The criticism was that the conference would have been better named “atheistcon” instead of “Skepticon.”  I really think this criticism is pretty ridiculous, so I’m not going to spend time talking about it here, especially after hearing so many people talk about it at the conference, especially DJ Grothe and Randi.  They both seemed very defensive to me and I didn’t understand it at all.

Phrases like “atheism is skepticism about only one thing” and “I’m an atheist because there is no evidence” were hammered on so much, I just wanted to yell “get on with it.”  I mean, it’s 2010, is this really an issue?  Was this actually unclear to anyone?  Never-the-less there were some really good points made, and it was great to hear Randi in person.

DJ Grothe made a really good point that I had to applaud.  He said that he would rather hang out with someone who is skeptical about everything but god than someone who is skeptical about only god.  Examples given were Bill Maher, who is a prominent atheist, but pushes some really bone-headed ideas, compared to Martin Gardner, who was very skeptical, but believed in a deist god never-the-less.  I couldn’t agree with this sentiment more.  I’ve stopped going to some of the local skeptical meetups because they are populated with people whose only concern is religion and have really strange ideas about other things.

Don’t get me wrong, Religion is an important topic to discuss and be skeptical of, but listening to atheists who believe the crap about vaccines and autism, or push Zeitgeist as a good source for information is not my idea of fun.  I’m not going to accept atheism as ‘good enough.’  The end goal is skepticism.

There were several speakers at the conference I had never heard of before.  The best speaker at the conference was John Corivino, a philosophy professor, gay rights activist and skeptic.  It’s safe to say that I’m now a fan, and I hope to get more opportunities to hear him speak.  His best trait?  The ability to effectively explain and communicate nuance.

David Fitzgerald was someone else who I hadn’t really heard of before.  He gave a talk on the historicity of Jesus which was very good.  He has a book out called “Nailed: Ten Christian Myths that show Jesus never existed at all.”  After hearing his talk, it’s definitely on my wishlist.  The historicity of Jesus is a topic that’s very interesting to me, even though it has a reputation of being somewhat ‘out there.’   In the last decade or so, it looks like the scholarly case for a mythical Jesus has really been put together, though, and can hold up to criticism.  I would go so far as to even call it compelling.

Other new speakers included Debbie Goddard, Amanda Marcotte, and Greta Christina.  These talks were all very good, though I don’t have much to say about them.  Marcotte’s presentation on Skepticism and Feminism was very good to hear.  I haven’t paid much attention to feminism; it just isn’t something that I’ve been interested in, but after hearing her talk, I think it’s something I should be interested in.  It’s important, and I should learn more.

I did have an interesting conversation with a Christian who stopped to witness to me in the hotel.  It was very cordial, even though his accusations of “you never really were a real christian” irked me.  Who is he to say that?  I didn’t go that route, though, and I think we had a pretty good conversation.  I was helped by the fact that he had a background in psychology, so I was able to bring up our cognitive biases when he started talking about ‘evidence’ for god.  He didn’t really have a reply to that, and kept complaining about superficial christians.  I don’t think either mind changed at all, but these are the conversations we need to be having.

Overall, the conference was great.  We had some of Ray Comfort’s people outside handing out copies of their annotated Origin of Species, and there was a gun show right next door.  Other than the expected “you’re going to hell” accusations, everything was very civil.  I can’t wait to attend again next year.

One of the problems with developing against databases is that unless you go out of your way, there it’s difficult to include in your source version control repository.  The “best” way in the .NET world has been generating your sql server creation scripts and go from there.  I didn’t feel like this was a good solution, though, especially since the code that is generated utilizes a lot of SQL that I don’t understand, nor have any desire to learn.  So I set about trying to find a better way.

The first constraints I decided upon were pretty simple:

1. There needs to be a way to include the database schema in a text file that can be versioned with the rest of the code.
2. The text file should be able to be transformed into a database (i.e. executable).
3. I should be able to insert base data into the system.  For example, if I want to populate a Settings table with some default values.
4. It would be able to completely reset the database to a pristine state.

Being a previous Rails developer, active_record migrations jump to mind, but I ran into problems pretty quickly.  As it turns out, active_record doesn’t respect foreign keys, which is what the Entity Framework uses to find relationships.  Active_record was a no go.  I decided to stay in the ruby world, though, and check out what else they had for me.  After some searching, I found Sequel.  So far, it’s worked pretty well.

I decided not to go the migrations route, because that didn’t seem to really fit my development pattern.  Instead, I’m generating the entire database at once.  This may turn out to be the wrong decision.  Currently, here is where I”m at:

There are quite a few problems with this code, but it’s got me on a path I’m feeling pretty good about.  Since it’s all in ruby, this means I can easily integrate it with Albacore build system (for .NET).

Okay, so this is pretty standard stuff in the ruby world.  So how well does this fit in with the Entity Framework?  Pretty well so far.  I can run that script above and then right-click and choose “Update Models” from Visual Studio.  The models are updated, and I’m ready to go.

I’m going to continue working on this, but I am really starting to feel like I’m on the right track here.

As I was thinking about this, I thought about how exactly I use these mp3 players.  Usually, I just pull them up and have them play random songs from my library.

I decided that this is *all* Grease would do.  Embracing the Unix philosophy of “Do one thing well” as inspired by onethingwell I set to work.

After a few hours,  I had something I was able to start using personally, and after some polish, it’s ready for it’s first general release.  I’m calling this somewhere between “Alpha” and “Beta” quality.  There are still some issues, but I thought I would release it to see what the response is.

How to use Grease:

1. Click on the folder to select a folder full of mp3′s.
2. Grease recursively walks through that directory finding any MP3′s (and m4a’s).
3. Click play, and enjoy.

It will remember your directory, so you don’t need to select it every time.  It will load up your music files on startup the next time you open Grease.

I definitely wanted keyboard short cuts, so here they are:

Space-bar: Play toggle
Left arrow: go back a song
Right Arrow: skip to the next song
Down arrow: volume down.
Up arrow: volume up.

That’s all there is to it.  It’s a WPF application, and I’ve only tested it on Windows 7.  If you try it out, please let me know what you think!

It doesn’t require installation.  You can just unzip the binaries and run them.  The source code is on github if you’re interested in that.

Grease: Source Code | Binary Zip

EDIT: I have discovered a bug where keyboard short cuts don’t work after clicking the folder icon.  I’m not sure why this is, but if you restart the application, the shortcuts will once again work.

The Missing Team Fortress 2 Manual

I’m happy to report we’ve seen a great response, which has been almost completely positive.  We’re not launching version 1.0 until after the big engineer update, but I’m very pleased with how it’s turned out so far.

• In less than 24 hours, we had written nearly 8,000 words.
• Today, we’re close 13,000 words.
• More than 50 people have contributed in some way.
• 28 people have contributed substantially.
• Gone through at least two major transitions in the style of writing: from 2nd person to third person, and from the voice being used.
• 4 different websites (3 etherpad clones and crocodoc.com)
• My copy of the manual is 56 pages long, formatted.
• There is now a website: http://tf2manual.net/
• We were flexible enough to neutralize trolls who deleted all our work.

The list can go on.  The message is clear: this has been a massive collaborative work that has produced something amazing in a very short amount of time.  I’ve been involved throughout the whole process, stepping up soon after lolard made the first post.  From this perspective, I’ve learned several things.

1. The future is live collaboration at the level etherpad (and it’s clones) tried to provide.  Wiki’s are last generation technology that only slow things down.
2. None of the etherpad clones were able to fully function at our level of collaboration, including the new Google Documents.  We used ietherpad, openetherpad, sync.in, and I privately tested Google Documents.  All of them experienced difficulties dealing with both the number of collaborators and the size of the document.  Sync.in functioned the best of the bunch.
3. Crocodoc is awesome, but does not scale up to groups of more than 2-3, especially for a 50 page document.  It’s flash driven, and was extremely slow.  It claims to be ‘live’ in the sense of etherpad, but it really isn’t at the levels we were using it.  I had to refresh the page to make sure I was viewing all of the changes.
4. Do not use the time slider on any of the etherpad clones.  This basically made the document useless for everyone over the next 20 minutes as the website did who knows what.  This feature worked great in the original etherpad, so I’m not sure why these clones have trouble with it.  Even sync.in had this trouble.

I can’t emphasize enough how much this changed my view of collaboration.  This has been collaboration how it’s supposed to be done.  While reflecting upon this experience, I’ve identified several reasons I think this went so well.

1. We’re passionate about the subject.  Of course this is important and must appear on the list.
2. We’re passionate about the community.  This is not necessarily an extension of the first point.
3. There was no barrier of entry.  Once the pad was created, we could simply spread the URL around, and once people arrived on that page, they could start editing.  There was no registration, no waiting.  They could immediately jump in and start writing.  This was true for all the etherpad clones as well as crocodoc, and I applaud all of those websites for that.
4. The latest work was immediately available, down to the keystroke.  We could see exactly what others were typing as they were typing it.  Corrections could be done within seconds, and they were not always done by the person who made the mistake.
5. Version control was transparent.  We didn’t have to think about keeping track of a history; the application did it for us.  Hypothetically, we could even playback that entire history as it played out, but that feature was broken on every website we tried.

The biggest theme is that while we were all very good with technology, the technology was completely transparent.  We didn’t have to think about it (except when it broke, like with the time slider).  We just focused on what we were trying to do, and then we did it.

It’s been an amazing experience so far, and while this project is far from over, our parts are winding down.  Soon, we’ll have a nice manual for team fortress 2 users to go with all this valuable experience we’ve gained.

Currently there are a few tablets that are available for use in the classroom.  The problem is “Tablet” is used in a bit of a different sense.  The tablet I have available to me is the Airliner from Smartboard.  This piece of hardware is truly a piece of crap.  Half the time it won’t connect to the computer, and when it does connect, the software fails to function correctly.  There is a better way to handle this type of functionality, and I think I’ve found one.

One issue with using a tablet like this is usability.  You’re controlling the computer through the tablet, but you can’t look at it.  It would be better if you could get a copy of the screen on the tablet itself.  Well, with these new tablet computers, it’s possible to do that.  You just need to setup a VNC server on the computer you want to connect to, and a VNC client on the tablet.

Well, I had the opportunity to borrow one of our faculty member’s iPads and go ahead and try this out.  There’s a lot of idiocy in this institution about network security and such, but I was able to finagle (to use a technical term) the server installation such that I didn’t have to go through IT to enable this functionality.  However, the iPad was having trouble connecting.  So I decided to use another computer in to test the connection.

I didn’t have a VNC client on any of the student machines available, but I did have one on my desktop computer upstairs. So I logged into one of the student machines, and used the Microsoft Remote desktop software to connect to my workstation.  Then I was able to use the VNC client on my workstation to remote into the instructor machine at the front of the classroom.  Everything worked perfectly.

Then I had a thought.  We run a piece of software called iTalc that enables us to view the screen of any of the students computers.  This piece of software is amazing, and I use it constantly while teaching, for diagnosing student problems, letting students demo different things from their computer, and proctoring tests, among other things.

So I opened up iTalc to open up the screen of the student’s computer I was on.

The circle was complete.  I was remoting in a complete circle using three different pieces of technology on three different computers.  I got a nice looking mirror effect on my computer, but I was also able to close it all down easily.  Here’s the final picture:

1. Student Machine -> My Workstation (using RDP)
2. My Workstation -> Instructor Machine (using VNC)
3. Instructor machine -> Student Machine (using iTalc)
4. The student machine was already connected to my Workstation.

Just a bit of fun.  Unfortunate the wireless bandwidth around here is so crappy the iPad was practically useless as a VNC client.  I’m going to have to figure out something else.