Rants & Raves

Musings on software, programming, design, and business.

Recently I was working on a piece of functionality that needed to be embeded on many websites out of my control. I was using the technique where a simple inline script appends a JS script tag the head of the document. The script that is loaded then targets a specific div and loads markup via ajax as well as any required UI functionality to that markup. It somewhat looked like this -

This would load require.js, which would in turn load main.js … main.js looked something like this -

OK – so it was a bit more complicated than that, but you get the idea. I was going to use require to handle dependencies and async modules in this “widget” that was getting handed out to all these sites, that I had no control over. There were some issues early on in terms of loading multiple versions of jQuery, underscore etc. Also I didn’t want some other site’s jQuery messing with my bits either. This was getting a bit messy. I eventually hacked my way out of that jam by storing my version of jQuery in it’s own special namespace like this :

So what this does is wipe the global namespace of my version of jQuery and stores the reference in window.$182. I then use that namespace with my js with something like this -

You get the idea. This approach was working for the most part, but then came something that I could not account for. By injecting require.js into the head of sites that were not my own I as introducing the require global variable. In doing so any library modern enough to be aware of require would assume AMD was the pattern and then not attach itself to the window. That being the case if any of these sites were expecting those libraries to be on the window, I would have inadvertently broken the world.

This is where I found browserify. I had heard of it before, but wasn’t exactly sure what it did, and where I could use it. What it will do, and you can go ahead and check it out for yourself here http://browserify.org/ - is handle commonJS require syntax and wrap that all up in a self executing block. I knows how to traverse that require tree of common, and so it can be used to create a bundle of node modules as well.

Say you had main.js looking like this…

And then you run

This gives you a single file to look for that has all your modules and what not, all nicely encapsulated. Browserify might not have been designed for this specific scenario, but it saved me, and is also making me reconsider using requireJS with r.js at all. I’m not going to get into what this means for bower and npm … but you can imagine it has implications.

The languages of the browser, HTML, CSS, and JavaScript are berated, harped on, abused, misused, and contorted to do all sorts of things they weren’t designed to do.  HTML in it’s core is a semantic language intended to organize documents and the relationship between them.  CSS is simple, straightforward, but hardly dynamic.  Even with Less and Sass, the resulting output is a flat static stylesheet that was never meant to power rich interfaces.  JavaScript was designed in 10 days and as we all know is the most misunderstood language – thank you Papa Crockford. As someone who writes JavaScript day-in and day-out, I am fully aware of all the issues with it. However, the community is massive and the toolsets are plentiful. What was originally used to perform superfluous tasks is now a great option for a unified language application. Javascript is the only viable way – today – that we have to express a dynamic interface in a browser.

HTML5 has been a big step forward, but it does not really deliver in terms of fluid interfaces, particularly for mobile.  Older methods of DOM access and manipulation are flawed, and ripe with performance issues. Dealing with these issues is complex. Everyday development cycles should be abstracted from having to deal with limitations like these. Famo.us does this for us, and from what I’ve seen so far – it does it well.

Browsers have gotten really good.  Our desktop machines are crazy powerful.  Most of the time folks aren’t cognizant of any performance issues with the sites they browse on their desktop machines.  All of this often masks the limitations of HTML/CSS/JS, or poor implementation by the developer.  On mobile devices however, the cracks in HTML5 start to show.  Although smartphones and tablets today are indeed amazingly powerful for their size, the mobile browsers they tote are a far cry from their desktop cousins.  This is where it becomes quickly apparent that HTML5 is not as magical as we think it is – or have been told it is.  When Zuckerberg – of Facebook –  said “The biggest mistake we made as a company was betting too much on HTML5 as opposed to native” it was a huge blow to the perception of HTML5 in the mobile space.  Recently there have been rumblings of a Front End framework that is solely focused on providing a toolset to use HTML5 in a performant way.  This framework is Famo.us, and it wants badly for the web to win.

Famo.us is alot of things; a 3D layout tool, a physics engine, a native wrapper (yet to be seen), a MVC (yet to be seen), but more importantly it’s an attempt to solve the biggest rendering performance issues of HTML5.  Stabs to crack this nut in the past have fallen short in my opinion.  Sencha Touch is a very mature JS MVC with a rich UI kit, however it is beholden to a heavily nested DOM which will grind your app to a halt if you try to get too fancy.  Ionic framework is a more modern attempt to create a UI kit for mobile, and leverage AngularJS as the app convention.  Although the DOM is much lighter, it doesn’t address a fundamental issue of nested elements, reflows, repaints etc.

Famo.us recently entered a controlled beta – adding a few hundred accounts a day, and allowing access to early guides and documentation.  I am excited to be attending HTML5 Dev Conf for hands on Famo.us training and hackathon, and to be a part of this beta release.  What I have seen so far is very promising.  There are a few things that Famo.us is doing that will give a speed boost to the DOM by addressing how we structure and think about modern web apps.

The Flat DOM

Famo.us uses the concept of surfaces and modifiers for layout. Surfaces are what they sound like, a flat surface – In the DOM represented by a div node.  Surfaces are dumb, they don’t know where they are, they don’t know what size they are.  Modifiers are objects that hold, and can modify the state of a surface.  This can be opacity, x/y/z position, and a host of other properties. A surface’s associated modifiers control its properties, as well as any other surfaces that follow.  This abstraction between surface and modifier allows the developer to chain modifiers and surfaces together, which creates a representational render tree such that a modifier can affect many surfaces below it on the tree.  This concept is central to how one architects the layout.  The association of surfaces is held in the JavaScript code instead of in the markup.  This allows greater flexibility and expressiveness in the tree.   The result is a DOM of surfaces that are siblings, and we avoid the pesky nested DOM tree of yore.


There is a great article on HTML5 Rocks – A resource for open web HTML5 developers about CSS3 and hardware acceleration.  What is not mentioned in that article the the transform matrix3D – which allows a 16 digit matrix of values to describe a point in space in a 3D perspective along with rotation, skew, and scale.  Famo.us wraps this property up and uses it as the main driver of it’s layout engine – flipping brilliant if you ask me.  This allows them to run operations against multiple matrices of modifiers for super performant, complex transitions.  Deeper under the hood Famo.us leverages the JS method “requestAnimationFrame” to know when to update the matrix – ensuring users perveice the UI at 60fps.

Sticky DOM

Nothing really groundbreaking here I would say.  Caching reference dom objects is one of the first things listed in any best practices guide for DOM speed.   Many frameworks have optimized themselves around reducing DOM touches.  They all have their own special flavor on how they get that done, but the concept is straightforward.  I like to think of JS and the DOM as being on opposite sides of a river.  There is a bridge and, as with all bridges, there is a bridge troll.  Everytime the bridge is crossed in order for JS to talk to the DOM, the troll blocks your path and charges a speed tax.  Famo.us’s modifier / surface separation allows the developer to care less about accessing the surface, since the modifier is where all the slick transitioning is handled.

The performance problems that Famo.us is attempting to address, along with the rich catalog of physics, animations, and other features included make it a framework to definitely keep an eye on moving forward. Bootsoft is committed to the open web, and are looking to leverage any piece technology that helps us move that goal forward.  When Famo.us is ready for prime time, we will happily find the right project to unleash it on.

I had the pleasure of attending An Event Apart in Boston back in April. Self-described as, “The design conference for people who make websites”, it was definitely a huge inspiration and learning experience for someone who does, indeed, make websites. The conference consisted of twelve speakers from all walks of the web world. Over the course of two full and informative days, I learned so much about the future of web design and technology. There were a wide range of topics that were touched upon, but I want to focus on what I felt were three underlying themes: responsive design, screen sizes, and user experience. Now, these may not come as a surprise from a web conference, but of course there are new and interesting ways to discuss and think about these topics.As much as I’d like to separate these three topics into sections, I can’t! Due to the fact that they are so relevant each other, I must discuss them through the ideas and guiding principals expressed at an An Event Apart.

One of the big focuses was creativity. There is so much that can be done with the web, and people shouldn’t feel restricted to standards. Don’t be afraid to push forward new ideas just because they’re different from what everyone else does. We have gotten very wrapped up in the PC paradigm where everything is organized by pages, but in reality, the current orientation of various devices has rendered the page fold moot. Jeremy Keith provided an example of the password field, and how the standard is to hide the text and show those all too familiar bullets or asterisks. This was developed as a standard because people has this idea that someone might be standing behind you watching you as you type. Future has shown this to not really be the case. Now, in a world of decreasing screen sizes, keyboards are less tactile and much smaller, so the ability to see what you are typing is pretty integral. It can get very frustrating trying to type a long, complicated password (which is the requirement from many sites nowadays) where you cannot read what you’re typing. A trend that is catching on is having the option to show or hide the password.

Screen Shot 2014-05-30 at 3.17.57 PMScreen Shot 2014-05-30 at 3.18.07 PM

Instead of deciding for the user, give them the option. Just because everyone has been doing the same thing for years, does not mean it’s the perfect solution, especially when we live in a world of ever changing technology.
There are also so great ways to embrace new technology even if it isn’t supported. The beauty of the browser is that it will ignore code it doesn’t understand, so there is no reason to not implement new things and be ahead of the curb instead of playing catch-up when the trend is already established. Some cool ideas that I found particularly interesting were from Luke Wroblewski and Lea Verou. Luke discusses the already familiar media queries and how to use them in more innovative ways, for example, using a vertical media query. Why not consider the fact that people are using so many different screens and that maybe certain screen orientations should consider where the call to action buttons are, or how large the font is. Consider the user and how they are interacting with their screen. Lea Verou talks about color for the web and how to make it more usable for the programmer. From hex codes to rgb, there hasn’t really been an intuitive way of coding color. If someone gets familiar with the convoluted formula, sure they would easily be able to identify a color by hex or rgb., but why should it have to be learned? If someone has any semblance of constructed color, be it from painting or just choosing color schemes, they should be able to figure out how to code color without having to use multiple programs to identify a scheme and figure out hex or rgb. Lea introduces the HSL variant. Using hue, saturation and lightness to determine a color. This form of color thinking is so much more intuitive and logical. I’m glad that this idea has been taken into consideration and pushed forward. Programmers are users too, and there is no reason we shouldn’t be given the opportunity for a good user experience within code.

Screen Shot 2014-05-30 at 3.13.30 PM
© Luke Wroblewski 2014

Screen Shot 2014-05-30 at 3.11.53 PM
© Lea Verou 2014

Another way to really respect and focus on the user is using research. Investigate the types of people coming to your website, or your competitors’. There are plenty of resources for this kind of research to be done easily. (Chartbeat, etc) the beauty of this method is that there is no longer an excuse for uninformed decisions. The idea that opinions are left up to taste and personal preference becomes irrelevant, and good design and functionality can shine through with research supporting it.

In 2011, a study done by equation research found that 71% of people expect their phones to load almost as fast, if not faster on their phone than their desktop (Source). For many who work in the web, this just seems absurd because it’s a pretty standard fact that of course things load slower on a phone. The truth is, people who are not keeping up with technology in the way that we are, are bound to expect different things. People expect because its smaller it should move faster, or because its a more intimate interaction that it would be faster. The beauty of user research is that we are able to find out users’ beliefs, things that we may not have realized because we forget how involved and informed we are about technology. Another study shows that 90% of user are finishing tasks across multiple devices and screens (Source). This is a really interesting and important fact to know! This makes the understanding and focus on multiple screen experiences so integral to design and development.

We can get very wrapped up in the massive amount of screens that are now on the market, and worrying about how to accommodate all of them. We need to keep focus on the fact that the user is who we are designing for. Continuing to focus on the user will help us move away from us relying on devices, to the devices using us. Think of the actual physicality of using a device; it doesn’t get much more intimate than interacting with your hands. It has always seemed natural to move from using buttons to everything being done on touch screens. If we consider the posture of the user, if they may be laying down or sitting, or standing while using a device, it can really educate us on how to properly design the functionality. Creating accessibility across all devices can include the support for both touch and mouse/stylus across devices. You shouldn’t automatically assume that a certain sized screen is going to be using touch. There are some more features to media queries as well – level 4 includes the ability to identify device orientation, the device’s aspect-ratio, the resolution of the screen you’re viewing, what kind of input is being used (touch or click), and my personal favorite… the light-level. I can see light-level being really neat to work with for color schemes, font sizes and other things. It will use the sensor on your phone (that will automagically change the screen brightness depending on how bright or dim the light is where you are) and you can then change various components depending on the level, whether its normal, dim or washed.

Media Queries Level 4 (Source)

@media (orientation:portrait) { … }

@media (device-aspect-ratio: 16/9) { … }
@media (device-aspect-ratio: 32/18) { … }
@media (device-aspect-ratio: 1280/720) { … }
@media (device-aspect-ratio: 2560/1440) { … }

@media (resolution >= 2dppx)
@media print and (min-resolution: 300dpi)

@media (pointer:coarse)
@media (hover)

@media (light-level: normal)
@media (light-level: dim)
@media (light-level: washed)

All of these considerations of the user can really help drive forward good design and development. Instead of focusing just on the devices and how to accommodate for them, we need to make sure the user is the priority. Another way to ensure a great experience is to allocate time to make sure your page load speed is up to par. Just comparing yourself versus competitors and sites that are well made is a great way to gauge how much work needs to be done. There are some great tools you can use such as ChartBeat (Link), WebPageTest.org (Link), and Page Speed Insights by Google Developers (Link). One way or another these sites can really help you find valuable information about your users and how easily they are able to interact with your site.

I think one way I can sum up my learning experience is a pretty obvious statement, but I believe it’s worth repeating:


They are the bread and butter of why we make websites… and don’t forget, YOU are a user too!

After attending An Event Apart, I can certainly say I walked out of there with a ton of knowledge in my head and a skip in my step, ready to get to work on making more innovative and beautiful websites.
Thanks for reading!

The face of front-end development is in a constant state of flux. Web applications are becoming increasingly front-end driven, and the concept of a single page web-app powered entirely by REST-ful web services is the new norm. While libraries like jQuery have dominated the landscape for many years, they no longer provide all of the necessary tools for today’s client-side development world. The result is a major push from the front-end community for more robust tools and frameworks that make up for these deficiencies, one of the most popular of these is AngularJS.  Where jQuery is a toolbelt, Angular is framing, plumbing, and electrical.

Angular isn’t the only solution. Backbone is another popular framework that creates separation in the MVC pattern. It is, in my opinion, the most “bare metal” javascript MVC available in the open-source world. Although it provides some syntactic sugar for wiring events to elements with the scope of a view, it does not offer “two-way” data binding in the way that Angular does.  That is, if you assign a model to a views configuration, the frameworks leaves the work of listening to the model to update the view when data is changed. Building dynamic web applications takes a lot of code, and developers are forced to work with low level tools for DOM manipulation. Starting any new project involves writing a lot of boilerplate code to listen for user input, and then linking all of these listeners to some functionality.

Angular addresses boilerplate bloat code with a more graceful document life-cycle, then allows you to access this functionality through additional HTML attributes/tags/class known as directives. All of the functionality you would have to add using Backbone is moved behind the scenes. The philosophy behind Angular is that web applications are living documents that should update in real time. Creating dynamic client-side applications should not be such a messy endeavor.

The big win with Angular is two-way data binding. In a traditional web app, when a page renders it takes data, merges it with a templating system and then displays that data to the user.  At that point the rendered page is essentially static. Developers have to manually wire events for clicks, hovers, keystrokes etc, that update a data model or collection of models based on those events. The page then has to re-render the page using the template and updated data model.

In Angular, the View and the Model are connected by two-way data binding. Changes that happen in the View immediately affect the Model, and changes in the Model instantaneously change the View. More importantly, Angular sets up all of this functionality under the hood, so coding can be as simple as change a few HTML attributes and calling the template without writing a single line of JavaScript.

Two way binding is a huge timesaver, and also helps the developer think more in terms of the state of the app – which leads to a more consistent experience for the user.  Angular is massively robust and contains many other tools that allow for rapid development.  Dependency injection, custom directives, services, factories, and host of other nuts and bolts place Angular squarely in contention for the go-to JS framework.  I should also note that Angular is a product of our friends at Google, and so we may have a relatively high level of confidence in it’s progression and ongoing maintenance.

Agile is everywhere. In the 13 years since the publication of the Agile Manifesto, the term has slowly become a common part of the tech vernacular – and that’s a good thing. For years, the majority of us in the development community have pretended that if we just sat still long enough, thought hard enough, made swank models, had a lot of meetings to collect requirements, and incorporated feedback from peer reviews on our designs and specifications that we would create the best product possible. I have a lot of swank diagrams, data models, and technical specifications that I’m pretty proud of, but when the rubber meets the road, ‘stuff happens’ and there is always the regret that we did not have more time for development or find that super key thing that was missed.

Collectively speaking, we have always made up for those mishaps with a lot of coffee, all nighters, a few stressed out PMs and a lot of refactoring. Riding down the waterfall in the best constructed barrel has certainly served us well, but I have always felt like something was fundamentally wrong. Agile taught me that I was not crazy for thinking there was a better way, or that our efforts were misplaced.

Agile Process

Helping lead the way in the Agilification of Bootsoft has been one of the more rewarding professional experiences I have had. There is a greater sense of ownership across the board and quite frankly it just makes sense. Working with clients to shape a product from start to finish is very satisfying. When involved in these type of projects, most team members feel like they have a say in the direction of the product as it develops. They’re not just handed a massive tech spec and told “Go.” At the same time clients can see, touch, and feel the product as it goes through development, which obviously helps build our mutual understand and confidence along the way.

That’s not to say Agile is always the right choice. Tackling an Agile project requires a close-knit team of highly motivated individuals. It requires discipline; albeit a more creative kind of discipline, but discipline none the less. It requires more training. The Agile methodology has only recently hit universities and most of us have waterfalling ingrained in our DNA. Unraveling traditional methods and educating clients and colleagues is no small task.

You’ve also got to take the time upfront to reap the rewards. People are resistant to to long retrospectives, planning, and estimation sessions because most of us are simply so scared from a seemingly relentless line of unproductive meetings. We all have a tendency to  fall back on old habits and comfortable ways of working. You need a few ah-ha moments to keep the shift in style and tactics in place. It is not as easy as enacting a new policy and insisting everyone follow. It requires coaching and determination. I guess this is why they invented the scrum master – to keep everyone honest about the process and priorities.

Despite this, I am a convert. There is a better way, and Agile is it. Agile will lead you to a better product faster. In other words – you can believe the hype.

Early last year, Bootsoft introduced the Bootsoft Learns Together program (BLT). The big goal being to continue to grow and learn new and interesting things. One cool thing about the program is that the topic is not limited in scope to what we do here at Bootsoft — or maybe it is, since we’ve been known to dabble in everything from music, to puzzling, to art, and of course software! Another cool benefit is that Bootsoft donates BLT hours for all employees, so you can actually do this while at work!

The development group decided that we would learn Scala. A small group of us signed up for a functional programming course via the popular learning site, Coursera and chugged on for several weeks. The class itself was comprised of lectures, quizzes, and homework. The lectures were about 5 to 15 minutes long per session, with an embedded quiz. Homework assignments were due weekly and got fairly involved, especially towards the end. All in all, it was a great learning experience. The group got together once a week to talk about the class and share ideas on the material itself, including applying our new-found knowledge to future project work.

Riding our Scala-high, we immediately got together to talk about our next learning adventure. That talk resulted in us deciding to attend and iOS class. The class we signed up for was an ongoing series offered by Stanford University. These were real full classroom lectures that were recorded and published. The format was therefore very different than what we were used to from the Scala class. In fact, most of us agreed that we were bored with the delivery of the material (mostly due to the length of each lecture). As a result, we decided to try using the class material as reference to aid in building some real iOS projects in-house. This effort resulted in three projects, two of which were dropped. The final of the three is still on-going and will be released to the public later this year.

We learned from the iOS class that it was next to impossible to keep up with Apple’s lightening pace of iOS version releases without sacrificing real project work and deadlines. We also learned that it was much easier to stick with the class to the end if the format was more suited to a heavy multi-tasking environment. That is, bite-sized chunks over long drawn-out sessions.

Generally, though we got something started and now it is once again in full effect, as a couple of team members have picked up Mongo DB for developers, another online course that is formatted very much like the Scala course and shows great promise for usage in future projects at Bootsoft.

On a regular basis, Bootsoft developers face complex and mind boggling software development challenges. The kind of problems that were solved in high school by the Mathletes because they were too bold and too dangerous for the classroom. Sometimes a single developer can find the solution right away. Sometimes it takes a whole team. Sometimes the team get stumped. Befuddled. Fatigued. When that happens, we bring in Mark. Mark is our clincher. Our relief pitcher. The Resolver.

What makes Mark such an ideal clincher? Experience, for one. Mark has been with Bootsoft for over a decade and has worked on multiple projects across multiple technology stacks and with multiple clients. Second, consistency. A project manager’s dream. I can even tell you what Mark is going to have for lunch tomorrow. Third, his cool and calm demeanor. It is exactly what is needed in an emergency situation and is the trait of a true leader.

In addition to Mark’s keen ability to hone directly in on the problem at hand, he is also a talented software architect and tech lead who is able to see the big picture.

Congrats Mark, you nailed it!

Bootsoft is always trying to find ways to contribute to the community, and one of our favorite ways is using our skills to give back! Over the weekend of November 1st-3rd, we had another GiveBack NY event (formerly named Create-a-thon). Since our last event in April 2013, we’ve partnered up with GiveBack DC, rebranded, and made another website for another well-deserving non-profit.

The group we worked with this time was Sports2Success. They use sports as a platform to empower today’s youth to help them pursue employment and become contributing members to the workforce. Through Sports Leadership Training and Apprenticeship programs, they build up kids with the confidence to excel in life, and through a career.

Working with Jamaal King, the Founder of Sports2Success, we were able to gather all the information and content for the website to get going. By creating wireframes prior to the event, it helps us plan a swift course of action for designing, coding and testing over the weekend. One of the challenges we faced, was the fact that there weren’t any photos of the group yet, so, Jamaal had an idea of creating a dynamic animation for the home page to help show what the organization is about. He sent us an idea for what it could be based on, and our designer Seung-Yun took it and ran with it! She was able to create the impressive animation that is on the home page using solely CSS and HTML. (You can view the site >>here<<)

The look-n-feel was created by myself, Kate B (the event coordinator for GBNY). I was inspired by S2S’s original logo, which was updated and simplified on the new site, and a theme of orange and dark grey/black used on their previous site. I wanted to add another accent color to the layout that wasn’t as bright as the orange color, and I felt that a pleasant teal-blue color complimented the orange and blended with the black and greys. I wanted the site to be engaging but simple, so a user could go to the site and quickly know where to go depending on what they wanted to do. I also wanted the site to have a fun and youthful look to it, seeing that it is a program for kids, but because the target audience is volunteers and supporters, I still wanted it to have a professional and organized feeling, as well.

Once I had the overall design ready to go, the developers were ready to jump in! We worked away all day on Saturday and got a ton of work done, to come in on Sunday to finish off the project and do some testing. For this project we used WordPress as a framework with Foundation and SASS. Everything went pretty smoothly, and we are so happy with the finished product!

Thank you to everyone who participated in this incredibly successful weekend, and can’t wait to begin planning our next event. If you or someone you know are involved with a non-profit in need of a website revamp – please apply at www.givebackny.org

It’s not every day when one of our longtime clients comes to us and says “We want you to build something cool.” Of course all of our projects are cool, but this was slightly different. Coldwell Banker wanted us to build a piece of software to wow their prospective franchisees. After some discussion about what this might look like, the video wall project was born.

Video Wall – Main Screen

The Video Wall is basically a giant interactive map of the United States displayed on a television screen. All over the map are tweets from real estate agents in different cities and states capable of being filtered by specific hashtags. Users control the map using their hands via the Microsoft Kinect, a motion sensor unit we attached to the television.

Coldwell Banker gave us a lot of flexibility on this project. We had an overarching goal for the project, but we knew some of the finer details would be discovered over time. This made it a perfect Agile project. Agile is a method that  involves incremental development broken down into phases called sprints. Instead of all of the functionality being defined at the beginning of the project, functionality is discovered over time with input from the client. At the end of each sprint, a functioning piece of software is delivered to the client for feedback and the goals of the next sprint are laid out. In this way we were free to try a bunch of new things and find the perfect solution for our client.

Getting Started with Kinect: Microsoft vs the Rest

My role in the project was development using the Kinect. The first challenge was selecting what technology to use. Microsoft provides a software development kit (SDK) for the Kinect using Microsoft Visual Studio and C#, which has several built in functions to recognize gestures and movements. There are also several third party SDKs, which I tried over the course of a month in addition to Microsoft’s Kinect SDK. In the end I decided on Microsoft’s.

The third party options are mostly low-level C++ implementations that largely come out of research projects and minor experimentation by various entities. Although some seem very useful (and certainly flexible), the revisiting of writing C++ code would be a big contributor towards avoiding these APIs. Additionally, the availability of support wildly varied by project and relied mostly on how active (in the project) and responsive the developers are. The issue of course is always time.

Windowed App or Not?

Having decided on using Microsoft’s SDK, we came to another intersection that required choosing between creating a GUI Windowed application vs a console-driven application. The goal was to show a web page in a window and we know that web browsers specialize at this. On the other hand, the Kinect SDK has tons of goodies that make developing a Windowed application much easier than the alternative. After a bit of playing around, it was clear that using the web browser to deliver the “wall” was the way to go due to the flexibility and freedom offered in creating Javascript-rich applications and the ease at which updates could be made available.

Kinect Console Lessons

One of the biggest challenges was implementing gestures. Some gestures the Microsoft SDK provided functions for, such as dragging the map by closing your hand. More complicated functions like zooming in or zooming out I had to code from scratch.

To zoom in or out on the map, the user first has to hold both hands up in front of the screen. Then, the user has to close their hands and either pull their firsts apart to zoom in or push their fists together to zoom out. These functions were not provided in the SDK. That meant I had to write a lot of low level code to recognize these gestures. This turned out to be a little more tedious than I anticipated.

Overall it was a quite a fun project. The Kinect also has the capability for facial gesture recognition and voice recognition, so we only really scratched the surface of the full range of functionality. It was great to get to learn some new technology. Thanks CB!

This month Ian Ainley nailed it.

Working with someone is a huge commitment.  You spend hundreds of hours collaborating, debating, struggling, and eventually succeeding alongside your peers.  Trust is an inherent part of any relationship, and getting into the virtual trenches with someone requires a great deal of it.  My working relationship with Ian has spanned multiple companies and countless projects.  There is no developer I would rather have at the keys than Ian Ainley.  He is a superb programmer, but more importantly is dependable, and trustworthy.  There is calmness to his swagger that helps to right the boat when things get rough, and I have never seen a task or impasse get the best of him.

Ian’s work is uniformly accurate and timely.  On a project that was particularly complex – Ian built the front end for something called “Blue Wall”.  This ‘wall’ integrated a live twitter stream using web sockets to display tweets on a full screen map.  The user then interacted with the map using motion captured by an X-Box Connect.  Ian hand rolled a custom event dispatch system in CoffeeScript to handle the incoming tweets and motion events into what is truly fun and exciting user experience.

Most recently we have been working on a mobile app using the Sencha Touch framework, and Phonegap(Cordova).  This is an area of JavaScript development that has become an increasingly popular option for clients who wish to have their “app” deployed to multiple platforms’ App Stores but don’t want the overhead of developing and maintaining a codebase for each platform.  There are many benefits to going the way of the HTML5/JS/CSS3 to native deployment.  In this solution there are of course hurdles and roadblocks that developers must face to achieve the same level of immersion and integration that a native app can provide.  In my experience as a Web Developer this has been one of the more challenging problems faced.  Thankfully Bootsoft is lucky enough to have Ian Ainley tackling these issues and managing the find the right balance between art and code.

These are only a couple of the projects Mr Ainley has been working on, and there is no question that he has Nailed It.