AllJoyn and the Internet of Things

Much of our group’s research involves applications that span a number of computers, input-output devices, and other electronics. Over the years we have connected the various pieces using sockets, web servers, Bonjour, OSC, and other technologies, weighing the tradeoffs for each application. Programming network connections can be time-consuming and error prone, or may use libraries or technologies that are — let’s say uneven — across platforms. Connectivity tends to consume a disproportionate amount of development time, leaving less to spend on interaction and functionality (i.e., the focus of our research).

Hence, we have been understandably interested in following the growth of the AllSeen Alliance, and the AllJoyn framework. AllJoyn was originally developed by the Qualcomm Innovation Center, and was contributed to the Alliance to serve as the foundation of an aspirational network of frameworks and applications to enable the “Internet of Everything.” With the addition of Microsoft to the alliance this year, AllJoyn has to be considered a viable competitor to Apple’s HomeKit and Samsung+Google’s Thread Group. To date, AllJoyn focuses on local connections between a number of device types, abstracting away the various transport mechanisms and OS layers that are supported. In theory, it sounds like a near-perfect solution to a set of challenges facing a growing number of developers. In reality, the framework seems to be suffering some growing pains, and the market impacts of some design decisions are still unknown.

I have been exploring the AllJoyn framework for the last week or so, and have only scratched the surface. Some of what I have seen is very appealing, while other aspects have impressed me less favorably.  The transition from Qualcomm to the AllSeen Alliance has created a bit of a mess of discontinuity between source code, SDK binaries, and documentation. I assume much of this will be straightened out in coming months, but I plan to document here some of what I learn in my efforts, for the benefit of anyone who is currently trying to walk the same path I have been on. Also, because I forget things.

Obtaining the AllJoyn Framework

The first challenge can be understanding where to get the current framework. One gets the impression that the system is in fairly rapid flux, and there are a number of sources for code and binaries. I would recommend avoiding the AllJoyn.org website unless you have a specific reason to be there. Most everything I have found useful is on the AllSeen Alliance site.

There are two pages on the AllSeen site that will be most useful. The first is the Download page, where you can obtain AllJoyn binaries for individual platforms, as well as a source tarball of the current release (14.06 at this writing) and a link to the git source code repository. Note that this is a repository on the AllSeen site. There is an AllJoyn repository on GitHub, but it is not active. Compiling any or all of the source is not for the faint of heart (or anyone on a deadline), so work from the binaries if you can. Having said that, there are resources in the source that are not in the binary packages (and vice-versa), so I prefer to have both available to me in most cases. So far, the git repository has been a better source for source than the source tarball, with one or two exceptions. I will try to be specific if it matters. I will try to cover specific cases as we go along. The Download page also contains a link to the AllSeen Wiki. I haven’t found too much there that was useful to me, but there were one or two helpful bits, so it’s worth mentioning.

The second important resource is the Developer Resources page. This is where much of the documentation for the framework is available. I would suggest starting with the Framework Tutorial to get an idea of the concepts, and then start working on a specific language and platform. For me, this generally involves downloading the binary and source and beginning to work through the documentation. I would like to say you could compile and run the BasicService and BasicClient samples for each platform — and in some cases you can — but in other cases you is probably simpler to build a Hello AllJoyn of your own.

I will post specifics on platforms and languages as I work through them, unless I grow tired of the whole thing.

Summer Research Experience for Undergraduates

CCT recently completed our summer research program. In addition to two different undergraduate programs managed by the Center, we had several high school students and a few high school teachers participating in personal research. The National Science Foundation funds these experiences, allowing students to spend two months working full time with a faculty mentor on a single project.

The summer programs are almost always more work than anticipated for the mentors (or their graduate students, for those who have them), but can be extremely satisfying. I have participated in some capacity for the past four summers, usually choosing a student whose career path I think might be significantly changed by the experience. It’s somewhat of a high risk strategy, and not all of the students will end up in Ph.D. programs, but I wouldn’t trade the students I have mentored for future Turing award winners. Probably.

This year was a bit of a departure, in that my student was a young lady who likely is destined for high achievement. She is intelligent, ambitious, and seems equally comfortable in the technical and more artistic aspects of system design. Not insignificantly, she also seems interested in the well being and success of her cohort, and of society at large. Our project was generally well received. Given the high level of talent that was present this summer, I am quite proud of the effort and dedication she exhibited.

CCT REU group picture

CCT and LA-SIGMA summer researchers and mentors

It was great to get to know all of the students, and I enjoyed spending time with the other mentors, many of whom I don’t interact with directly all that often. Congratulations to all on an enjoyable and productive summer!

Finding your passion

This is commencement week at LSU. Young people around campus are busy planning their graduation blowouts, and realizing that they should have been looking for a job already.

The last time I cared about who was speaking at commencement was my own graduation, but I am sure whoever it is this year will exhort the new graduates to “follow your passion.”  I remember a news story published last year that centered around this universal commencement advice. One new graduate, concerned that he had not yet found his one true calling, sought advice from an economist about what to do. As our young protagonist pointed out, some people find their passion early in life, while others search for decades, or forever. (Spoiler alert: this is another area where economists were sure they could provide an answer, but in the end were as clueless as the rest of us.)

Working with first rate researchers, I am quite familiar with people who found their calling at an early age. Most of my colleagues were firmly on their current career path before they graduated high school. I was a member of that other group. I drifted in and out of institutions of higher learning and through several careers, trying to find my one true calling, the thing that would motivate me to realize the high potential I had always been told that I possessed.  Each attempt eventually ended with me bored and disillusioned, and I grew increasingly pessimistic that I would ever find my intended vocation.

It was a series of personal setbacks that finally turned things around for me. Unemployed and back in school, I found myself too busy trying to survive to worry about my passion. I focused my efforts on accomplishing each my new objective, and solving problems new and old. I had no time for self-absorption.  I was content with the satisfaction that came with learning something new, acquiring a new skill, or making a new friend. I learned to enjoy my own company, and to appreciate the days as they passed.

Along the way, I fell in love with computer science. I realized that my passion had always been learning new things, understanding how the world works, and thinking hard, and CS is a perfect fit. Twenty-five years later, I am still excited to come to work every day. I don’t wish to imply that I would not have cared for computer science if had not struggled, but I think that focusing on what I have and enjoying who I am, rather than what I wish I had or who I would rather be, has helped me to stay committed and content with my chosen path. Corny, I know, but no worse than “follow your passion.”

The Future is Friday

 

Baton Rouge’s Red Stick Festival is getting a makeover. This year will be about listening to the community about which elements should be the focus in future years.

It’s free and open to the public. And a great chance to see our new Digital Media Center.

redstick_8.5x11

Using Git in computer science classes

Coming to academia from industry, I am a strong proponent of teaching useful career skills to undergraduates, especially when it can be done in a way that enhances or reinforces core CS concepts. Using a source control system for managing assignments has always been near the top of my wish list in this regard. A few of my like-minded colleagues have used externally hosted websites and Subversion (SVN) for managing classes with some success. I wanted to experiment with a system that would integrate with what our department’s current workflow and technology.

This semester our administrator and I collaborated to create a set of Git repositories for my senior level Interface Design and Technology class. The repositories replaced a set of script files on a department Unix server that have been used for several years to help automate paperless submission of homework and programming assignments. We set up a separate repository for each student in the class, and one for each of the project groups. The directory containing each repository was owned by a  Unix group that consisted of the student (or students, in the case of project group repositories) and myself. Each repository was created “bare” — no working directory — and “shared” to act as an integration point for the student’s work. Each student cloned the  repo for themselves and their group, and I cloned all of them to my workstation.

Students would push each assignment to the shared repo. I would pull the repo, grade the assignment, commit the changes, and push the grades back to the repo.

Despite inevitable problems with permissions, branches, and conflicted merges, I consider the experiment a success. I was able to create simple scripts to automate much of the pulling and pushing, though there are several more I will make next time to support some of the grading tasks.  There are a few important things I learned.

First, notification is important for this environment. We had not set up e-mail notifications, and I ended up sending group messages to the class when grading was complete. It was also not always clear to the students when they had successfully pushed their work to the correct branch in the shared repo.

Using ssh keys for authentication is virtually a necessity for this setup. I typed my password more times than I care to remember over the course of the semester. My dream for our CS program would be to spend the first day of the intro class for majors setting up ssh keys and an individual Git repo. There is an open question whether each class would be better represented by a separate repository or a branch in the student’s master repo, but either way a graduating senior could take all of their school work when they leave, with a complete history of its creation.

As an aside, one of our groups became so interested in some of these issues that they created an application to help beginners master the system and support the functions necessary for our workflow. For their penultimate project, they added automated integration using Buildbot with results (success or failure) integrated into the system.  This is one step toward my long term goal of using test cases to serve as both specification and instant grader for assignments, but that is a discussion for another day.

Congratulations Class of 2013

Graduation was — well, a few weeks ago now. We see them come and go three times a year, and often forget what a landmark it is for those participating. This Spring, one of the students in our lab was chosen as the student commencement speaker for the College of Engineering. A video of this speech is here.

Congratulations, Andre. And the rest of the Class of 2013!