Good News! And Startups!

A few weeks back I posted about a couple of hackathons I participated in. The first was the OpenData Guelph hackathon which I participated in with my friend from UW Stratford, Carlos Saavedra. We placed 3rd in the contest. Since then, we also found out that our app in the CODE contest, newRoots made it to the top 15 in Canada. The contest had around 900 participants and we were selected to pitch at the final day. While waiting for pitch day, I tried to get involved in anything I could at the University of Guelph to try to improve my pitch skills. I found a practice pitch day that was being put on by the Entrepreneurial Society at the University of Guelph and tried to be active at the event as much as possible.

banner 10153187_869615509730921_1433170679_n esLogoVerticalLogo

I have another side project I’ve slowly been working on for a couple years called Redtree Robotics. I decided during an interactive session to try to pitch this idea without even thinking about my pitch. It was terrible. But the speaker allowed me to try again and I managed to reduce what Redtree does into a couple of easy to understand sentences. Later we had to form groups and pitch an idea that would help the city of Guelph deal with a projected 40% population growth in the upcoming years. The team I was assigned and I, came up with the idea of an autonomous car service. During this pitch, I learned the importance of numbers. Things like market size, how much of that market you might be able to reasonably obtain, and how much revenue that might mean to the company. Our pitch for autonomous cars came in third. So there were two big take-aways from this day. Keep your pitch simple and understandable, and focus on numbers.

Capture

Hub Pitches

Carlos and I met before the big CODE2014 pitch and tried to apply these ideas to our pitch. On pitch day, Carlos introduced us and spent the first minute or so giving a very simple and easy to understand explanation of our idea and a tiny bit about who we are. We then showed the video, which showed how our app, newRoots worked. Then I followed up with the numbers. Our strategy worked – we ended up winning the contest and $26000.

Following this success, I attended another pitch event put on by the Centre for Business and Social Entrepreneurship at the University of Guelph called “Pitch Envy”. At this event, the guy who started Student Car Share came in and talked more about what a good pitch had in it. Again it was more about numbers, but also an emphasis on a good team. He also talked a bit about how to get investment in a good idea without giving too much of the company away which will likely be useful eventually. I also spoke with a friend, who has a startup named Voltera at UW Velocity about what he thought made up a good pitch. The best advice was to pitch to as many people as possible, one a time and then incorporate their advice into the pitch so it is slowly refined over time.

After two years of part time work on Red Tree Robotics, we decided we would finally try to get some funding. We applied to the Hub, the first incubator program at the University of Guelph. Our team had three members, so the pitch was a challenge. We had to figure out who would say what, and had to get timing down to be under the strict 5 minute deadline. This was the biggest challenge, but once we identified the strengths of each team member, the pitch went really smooth. We ended up winning a spot in the incubator and start May 1st!

 

If you are interested in following the progress of either of the startups:
Red Tree Robotics: www.redtreerobotics.com Twitter: @redtreerobotics
ElectricSheep: www.electricsheep.ca Twitter: @2electricsheep

Technical Reviewing as Grad Student?

As I’ve published more and more, I’ve been invited to become a reviewer for many conferences and journals. Some are by people I’ve met while presenting at conferences, but others come randomly in my inbox from people who have read my papers. There’s something that seems weird about being an “expert reviewer” while still not completed my studies myself – but I’ve always accepted when I’ve had time to do them because I feel like it’s good to volunteer back some time after other people have done the same work to review my papers.

Generally, I stick to accepting review requests for papers which are very closely related to my area of study. In the cases where I’m not sure of something, I ask for advice from other grad students in the areas I am lacking in expertise. I also usually give a comment to the editor letting them know I am just a PhD student, and to take my opinion with less weight than more qualified reviewers. That being said, I think I usually am thorough and give useful feedback to the authors’ of papers I review.

Getting invited to review so often has also made me question the whole review and acceptance process. It would be nice if journals and conferences disclosed how many of the reviewers have PhDs – although I guess it wouldn’t really tell much because I’ve also been handed papers by professors I work with and been told to review them and give them a report which I assume they use to submit the review themselves. In some respects it makes sense to have grad students review papers since they are often very connected to the current research, but I am still not confident about the process if it is possible for papers to be accepted without even being looked at by a real PhD. Maybe I just don’t know enough about how it all works yet to know for sure. After all, there’s always layers of editors and committees and everything else.

In any event, here’s a couple of links about how to review a paper for any other grad students who find themselves in the same boat:
http://www.cs.ucsb.edu/~ebelding/courses/284/papers/ReviewingPapersStudentGuide.html
http://www.raulpacheco.org/2013/06/the-ethics-of-academic-peer-review-some-tips-and-best-practices/

Blog stats

This blog has been running for quite a few years now and I got thinking about the traffic patterns on it today in an earlier post, so I thought I’d put some of the info together into a post 🙂

Here are the visits in the last three years (74,000 hits)

And in just the last year (30,000 hits)

The average time on the site remained about the same when looking back one or three years and in both cases is about two minutes.

Here is a world map showing the countries where most of the traffic comes from. The top three were US, India and Canada. The darkest colour represents almost 6000 hits.

The most popular browser with visitors of my site is Firefox, followed by Chrome, IE and Safari. I was a bit surprised that Safari did more poorly than IE, but I guess it can be expected when you see the next figure with OS’s.

The most popular OS’s for my site: Windows, Linux, Mac. This makes me a little sad that Linux wasn’t the highest proportion, given the content of my site…but it was at least respectable.

Lastly, here is the posting frequency. There have been 83 posts total according to the wordpress admin page.

Including Blogs in Tenure & Promotion

Inspired by this blog post: http://andreweckford.blogspot.ca/2012/10/would-you-include-your-blog-in-your-t.html and the ensuing twitter conversation: https://twitter.com/andreweckford/status/260737094056542210 I decided to write a more in-depth response on my blog.

Compared to the rest of the group in the twitter convo, I am probably the most junior being a grad student still (the others are librarians and professors in various stages). The general consensus seems to be that while a forward facing department may consider a blog in their criteria, there are not clear cut rules to support blogs in the process and most people would not include it.

When I get to that stage in my career, however, I’ll try my best to shoehorn it in somehow. I’m of the opinion that any modern academic department should be considering blogs and even social media accounts in the T&P process. These types of things show how engaged an academic is with the public. We need more engaged professors and research students. The general public pays for our work (for the most part) and we should make them aware of what they are paying for.

As mentioned in the twitter conversation, the benefits of blogging and social media alone in terms of connections and collaborations with other researchers end up showing up on the resume anyways with publications and projects. However, I think there is also value in the quality of a blog itself.

As for the less professional posts, I think these also have some value. As long as they aren’t the type someone should be embarrassed about, I think they also still add value. They humanize the professor for the students and the general public and make the professor more approachable. Sometimes its also nice to read these peoples’ opinions on issues outside of their expertise.

My blog has been going for about three or four years now, and while I think the quality of the posts are not as good as the others in the Twitter conversation, it has some value since it has documented some of the journey through grad school, some of the work I’ve done and some of my thoughts that would otherwise just disappeared into the ether. Clearly this is something people are interested in since I regularly get around 2500 hits per month on the site. These types of statistics may be the type of thing to include in T&P files. The number of hits, followers on twitter, retweets, “klout” – all show the level of engagement of the professor. On the other hand, this could just lead to a race to the bottom of constant meaningless social engagement, but I’d still prefer a prof who tweets too much to one who is alone in their bubble.

OpenGL Console Library for Blackberry Native SDK (Playbook)

Over the break, I decided to try my hand at some Blackberry native SDK programming since I recently got a playbook. I looked around the App World and noticed there weren’t any telnet/ssh tools available for free (that worked the way I wanted) so I thought this would be a good starter project.

However, for the look I wanted, I wanted to maximize the screen space for the console application to show as much text as possible and worked off the hello world example on the SDK webpage. Essentially, the simple “library” (note: library is used very loosely here) initializes the display, shows the keyboard and supports some simple output using putch and puts functions that I implemented. It can also show a blinking cursor and user input at a prompt. In case someone else can use the code I have made it available. Check back soon to see the source for the telnet portion of the app I made as well or look for it on the App World.

Simple Telnet - Example Application
Simple Telnet – Example Application using the conosole library

In order to use the library, you need to make use of the bbutil.c and bbutil.h files that are included in many of the examples provided by RIM. I have provided them here alongside my own code so that it is easier to follow along. I also provide two more files: glconsole.c and glconsole.h. You just need to #include “glconsole.h” in your source in order to use the library. All of the functions available to you are listed in the “glconsole.h” file as well. I will go over the important ones in this article.

First is gl_init(). This function initializes the library, the screen, font etc. This function should be called before using anything else in the library. Similarly, gl_cleanup() is used to free memory and should be called before your app is terminated.

After initialization, you may now use the puts and putch functions to display characters to the screen. gl_putch(char c) takes a single character and displays it onto the screen. It can handle newlines which are represented as ‘\n’ and tabs which are represented as ‘\t’. Backspaces by user input is handled as a ‘\b’ character. This is similar to how people on The osdev.rg website often handle character output in their custom operating systems. I’m not sure how it relates with normal c standards, but I imagine it is similar. Eventually I hope to implement a printf() type of function, but at the moment the putch() and puts() functions serve what I am doing well enough. Note: puts() is the same as putch() but instead takes a (char *) ie) a string. The string should also be null-terminated, or it will just continue until it hits a null character. The characters are automatically scrolled when the bottom of the screen is reached.

The only other really important function is gl_render(). This function is what should be called everytime the screen needs to be refreshed. This is usually in a for loop within your main() function in your app.

It is also possible to resize the screen using the gl_resize() function. By default the screen starts at 80X29 which is the maximum size with no virtualkeyboard showing, at the font size I selected. When the keyboard shows up, it fits 80×14. In some sample code I’ll also show how keyboard input can be handled, how to blink the cursor and how to detect when the keyboard is shown or hidden.

For the rest of this guide, I’ll assume you are using the QNX Momentix IDE available from RIM’s developer website. To start, create a new project by going to File->New Blackberry Tablet OS C/C++ Project. Name it whatever you like, click next. Then choose the C language, and empty Application Project. You can now drag the gl_console.c, glconsole.h, bbutil.c and bbutil.h files into the src folder within the IDE to include them. You will probably want to copy the files and not link them when it asks. Before compiling, there are several libaries which must be linked to the project. You can do this by right clicking your project, going to properties. Then go to C/C++ General->Paths and Symbols->Libraries. Here you can add libraries. Each time you add one, be sure to check “add to all Configurations” so that you don’t need to do this again if you change from a device-debug to device-release build. The following libraries should be included:

  • bps
  • EGL
  • GLESv1_CM
  • freetype
  • png

Now that all this is setup, it is possible to start you main() function and use the library. If you like you can right click on your src folder and click “new file” and create a main.c file or whatever you like to name it. While this isn’t the typical way you would include a library into a project, this way lets you edit the library source to your liking in case you want to further extend it.

The following example shows a skeleton of what is required to get the code to display some text:

#include /* EXIT_FAILURE */
#include /* NULL */
#include /* BPS_SUCCESS */
#include /* screen_event_get_event() */
#include /* NAVIGATOR_EXIT */
#include "glconsole.h"

void handleScreenEvent(bps_event_t *event);

int main(int argc, char * argv[])
{
int exit_application = 0;

if(EXIT_SUCCESS != gl_init())
{
fprintf(stderr, "error init\n");
return 0;
}

gl_puts("Hello gl console world!\n");

for(;;)
{
bps_event_t *event = NULL;
if (bps_get_event(&event, 0) != BPS_SUCCESS)
return EXIT_FAILURE;

if (event)
{
int domain = bps_event_get_domain(event);

if (domain == screen_get_domain())
handleScreenEvent(event);
else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event)))
exit_application = 1;

if (exit_application)
break;
}
gl_render();
}

gl_cleanup();
return 0;
}

void handleScreenEvent(bps_event_t *event)
{
/* do normal event handling here, see other bb examples */
}

The key parts are calling gl_init() which initializes the library. Then within the main loop, the gl_render() function should be called which will actually render the text. Finally gl_cleanup() should be called before termination to properly free memory.

In the near future I plan to add some support to handle ansi encoded text (specifically for my telnet application) so that it can display colours and move the cursor around the screen using this standard.

Here are the files:
glconsole.h
glconsole.c