Wednesday, January 16, 2013

List of technologies we're watching in 2013

From cloud computing to Javascript, from micro services to repeatable environments, from Android and HTML 5 to Big Data and concurrent programming, Chariot's engineers are keeping watch.

The Internet of Things

The “Internet of Things” is all around us.. or, well, we’d like it to be. From “Just in Time” delivery of bus or train schedules as you leave your house, to sensors tracking air quality in the city, from phones to smart clothing, the Internet of Things is about integrating ourselves with this data available all around us. Free of ‘apps’ and ‘services,’ the Internet of Things will make data available ‘just in time’ wherever and whenever you need it. Whether you get the data from WiFi, RFID or QR codes it’s out there, and we think that’s exciting!

Cloud Host Almost Everything!

If you're a savvy IT person, it's may have been a while since you provisioned your own Linux host on a Virtual Private Server or hosting plan. Cloud hosting isn't emerging, it's emerged and taking over. You're likely to use a cloud-based service such as Heroku, Amazon EC2, SliceHost, or even Microsoft's Windows Azure. There are private cloud partitioning services to protect your data from theft in co-location.  Companies such as CloudBees have been shifting so many services to the cloud that now they even provide development and QA platforms that provide your SVN or Git repositories, run Hudson or Jenkins, and provide Continuous Integration services.

Read the rest of this article, subscribe to our TechCast podcast or view all of our Philly Emerging Tech 2012 sessions at our emerging technology resources site, emergingtech.chariotsolutions.com.

Thursday, January 10, 2013

Science of Big Data - sessions coming online

If you didn't attend last month's "Science of Big Data" event in downtown Philadelphia, not to worry. We're beginning to post screencasts of the sessions now:  The Science of Big Data - Screencast Sessions.

Currently we have two - Basho's Tom Santero discusses "Eventual Consistency" and outlines the challenge of keeping data highly available and consistent enough without impacting performance.

The second screencast is the combination of Chariot's Andrew Oswald and Comcast's Josh Angotti's talks. Andy reviews the work that our team did for Comcast using Hadoop in analyzing set-top box users' click selections, and reducing the timeframe of finding answers from days to hours or minutes. Josh Angotti tells the story from Comcast's perspective.

More screencasts are expected soon - we had some video syncing difficulties and audio challenges so it'll take a bit to get them all online. Check the page soon for talks by Cliff Moon of Boundary, Stuart Sierra of Relevance, and Mark J. Headd, the Philadelphia Chief Data Officer.



Wednesday, December 5, 2012

The "Pivotal Initiative" - VMware and EMC spin off a new organization to focus on big data in the coud


Disclaimer - I am a Chariot Solutions employee, however this analysis is my own and should not be interpreted as the policy or official stance of Chariot Solutions. I direct our VMware Authorized Training Center, and provide training in Spring, tc Server and other technologies. Chariot is a VMware solutions partner as well.

On December 12th, EMC and VMware announced a spin-off that will merge units from both VMware and their parent company into a single, focused organization named the Pivotal Initiative.

The main focus of this operation, which will involve more than 1,400 employees from both companies, will be cloud-based big-data software. The merger brings together the vFabric and SpringSource teams (including Cloud Foundry, projects such as GemFire, Hyperic and tc Server), recently acquired Pivotal Labs, and data warehousing and data science teams from Greenplum, as well as recently acquired Cetas.


Thursday, November 15, 2012

Installing PhoneGap Plugins with pluginstall

Phonegap applications can be extended with plugins to add additional functionality. Historically, installing plugins meant copying a bunch of files into the correct places in your project.

Andrew Lunny wrote the Cordova Plugin Specification and pluginstall. Pluginstall is a tool that automates the installation of plugins which conform to the plugin specification.

In addition to demonstrating pluginstall, we’ll also use the PhoneGap create script to make a new project. The cordova build scripts will be used for compiling and installing the binary. Using these tools it’s possible to develop PhoneGap apps with a text editor, instead of an IDE.

Prerequisites

I’ll assume that you have Phonegap 2.2.0 and the Android SDK installed.

Pluginstall requires node.js and is installed through npm. If you’re on a mac and use homebrew, install node and npm with brew install node.

Setup

Install pluginstall

$ npm install -g pluginstall

Create a new Android project using the PhoneGap create script. Create takes the new project path, package name and activity name as arguments.

$ cd /usr/local/phonegap-2.2.0/lib/android
$ ./bin/create ~/foo com.example.foo Foo

The create script built a new PhoneGap project in directory ~/foo. Inside the project there is a cordova directory with some command line tools.

Let’s ensure the generated project works before we modify anything. Start the emulator.

$ cd ~/foo
$ corodova/emulate

Patiently wait for the emulator to start. Unlock the screen and keep the emulator running. Compile, build, install, and launch your app.

$ cordova/BOOM

The application should launch and say “Device is ready”.

Install the plugin

Get a local copy of the Child Browser Plugin.

$ cd /tmp
$ git clone git://github.com/alunny/ChildBrowser.git

Install the plugin using pluginstall. Pluginstall takes the platform, project directory and plugin directory as arguments.

$ pluginstall android ~/foo /tmp/ChildBrowser

The Child Browser plugin is now installed. Pluginstall used to the information in the plugin.xml manifest to update the project. It added an Activity to the Android manifest, listed the plugin in config.xml, added java source code, and added javascript code and images to our project.

Write some code to use the plugin

Edit ~/foo/assets/www/index.html

Include the javascript after cordova.js

<script type="text/javascript" src="cordova-2.2.0.js"></script>
<script type="text/javascript" src="childbrowser.js"></script>
<script type="text/javascript" src="js/index.js"></script>

Edit ~/foo/assets/www/js/index.js

In onDeviceReady, add a call that will open a web page in the Child Browser after 3 seconds

onDeviceReady: function() {
    app.receivedEvent('deviceready');
    setTimeout( function() {
        window.plugins.childBrowser.showWebPage(
            'http://phonegap.com', { showLocationBar: true }
        );
    }, 3000 );        
},

Compile, build, install, and launch your app into the running emulator.

$ cordova/BOOM

The sample application should run and open http://phonegap.com in the Child Browser Plugin.

Monday, October 22, 2012

Top Questions To Ask When Choosing an Android Development Firm or Developer

Now that we understand the implications and challenges of embarking on an Android project, let's discuss how to find the right firm or developer for the job!

You are ultimately responsible for the application - even if you go the outsourcing route. Things happen, disagreements happen, and turn over happens. The likelihood is high that you will need to maintain the application at some point in its lifecycle. The better the code, the easier the maintenance will be.

There is a wide range of abilities, experience, and knowledge out there. These questions are designed to help you make the best choice about how to invest your Android budget. You need to ensure that anybody you onboard to build the application will advance your organization's goals and not cause unnecessary rework.

Interview Questions

  1. What applications have you published in the market? Do you have references we can contact? Describe application features and your role in each application.
  2. Do they speak positively of their clients and applications? What do their references have to say? How high are the app ratings? Take note of positive and negative comments. If possible, download and try the application(s). This will give you some insight into the quality of the implementation and design.

    Do they use similar platform features to what you plan to use? For example, have they only written map applications when you want to create a music streaming application? Keep in mind there is a plethora of platform features, so unfamiliarity with a particular feature isn't a deal breaker. Great engineers can pick up any new feature very quickly. If something is business critical and you are uncomfortable with them learning this for your application, you may want to look for someone with experience with these features.

  3. How do fragments fit into your development process?
  4. Any firm or developer you hire should be knowledgeable of fragments and should be using them. Otherwise, they are writing obsolete code. This technology is nearing two years old and is the way to write Android apps going forward. Frankly, if they haven't taken the time to learn them by now, how can you trust that they will help you innovate in your application?

    If they don't use them, you will need to completely renovate the application when you expand to the Android tablet market. On the other hand, if they write it with fragments from the start it will be much easier to transition to tablets.

    There is a large base of Android developers who remain resistant to learning this new and more flexible way to build applications. I've gone on a conference crusade this year to help businesses and developers see the benefits of switching to fragments before it's too late.

  5. What strategies do you use to ensure the user interface will scale to the multitude of Android devices?
  6. There are many strategies and best practices for making interfaces that scale. Some of the things you’ll want to hear from the developer or firm are:
    • Using fragments
    • Using dimensions, styles, and qualifiers
    • Using 9-patches
    • Using images in different densities
    • Wrapping elements and using relative layouts
    • Not using fixed pixels

  7. How do you minimize battery life drain and bandwidth usage?
  8. If they don't have ideas around this, beware. This is one of user’s main complaints! There is typically a cap on data plans, so users want to limit bandwidth so they don’t get hit with overages. Battery is also a major concern for users. A major factor in battery life is the amount of data downloaded and processed on the device.

    Some techniques are using services to complete background work, using alarms to kick of background tasks, detecting when on WiFi and downloading large amounts of data, designing APIs that give incremental data, or detecting when plugged into the wall to do a large amount of processing.

  9. Do you unit test your applications? Do you write integration or other automated tests?
  10. Test coverage is an important judge of quality for the end product. Although it seems like it's just more code to write, the investment up front will reduce bugs and rework. It may or may not speed time to market, but it will definitely increase the quality of your application.

    Developers that don't use unit testing spend a lot of time building to devices or emulators. This uses significant amounts of time that could be use for writing tests to verify behavior. Plus they won't be able to find all the bugs by poking around in the application.

    Although many Android developers eschew using testing frameworks like Robolectric, setting up new projects with Robolectric, IntelliJ, and maven (or maven + Eclipse) avoids the headaches that come from integrating later on in the project. There are many things you could test, but there are limits and tradeoffs. Check out my article about best practices for testing with Robolectric to help you structure your testing strategy.

    Although unit testing in great, there are other types of testing. The more types of tests that are written, the bigger safety net you have when the architecture needs to change. It will help ensure that large changes don't break existing functionality and find subtle bugs before they get into the wild.

  11. How often will we discuss and decide priorities?
  12. Priorities change - often quickly and without warning. You will encounter challenges even with the best thought out designs. Business requirements will change and it's essential to keep in close contact with your developers to make sure critical features are implemented according to the latest specifications.

  13. How will I access the code base?
  14. It's always a good idea to have access to the code. A good practice is to create an organization on github and invite the developer(s) to join your team. They create a repository for your application and save any changes in the cloud. This gives you access to the most updated code as well as the commit history. You can browse code commits to see what they are working on and get an idea of where the project stands.

    Although we always embark on new contracts with good will on both sides, disputes with an external firm or developer can happen. Make sure that you have access to and retain the rights of your application's code. You can't develop or maintain what you don't have!

  15. Will I get regular builds of the application?
  16. It's also possible to get frequent builds of the app - either manually or as part of an automatic process. Giving stakeholders access to regular builds is a good idea so that the business can ensure that the developers are creating the features as expected.
What has your experience been with hiring Android developers or firms? How did you determine their skill level? We'd love to hear about it in the comments.

Friday, September 28, 2012

iPhone 5 Quick Tip: How to add letterboxing back to your iOS 6 app

So you've removed letterboxing from your iPhone 5 app by adding a Default-568h@2x.png launch image. And there was much rejoicing.

Except now all of your layouts are messed up, and you're supposed to push an app update through to the store tomorrow. So you delete the Default-568h@2x.png launch image and...nothing. Your app still seems to be running in full-screen mode. What's the deal?

It seems to be a bug, but there is a workaround. Here are the steps that I went through to re-enable letterboxing in XCode:
  1. Remove the Default-568h@2x.png launch image
  2. Run a "Clean Build Folder" (⌥⇧⌘K)
  3. Uninstall the app from your device/simulator
  4. Build and run the app
It's not immediately clear to me why you have to jump through so many hoops -- it might be that XCode is caching an intermediate version of the image resource in the build folder, and the device/simulator is simultaneously caching a version of this image in memory or on disk.

I'll update if I get more information.

Wednesday, September 26, 2012

So You Want To Build An Android App?

If you’re reading this, you likely have an iPhone/iPad (iOS) application and are interested in expanding to the Android platform. You've probably already asked the hard questions to define what you want, why you want it, and how it fits into your roadmap. This article will help your business understand the impact of the Android effort.

Android ≠ iOS

This should be obvious, but too often business think "I have an iOS app, how different can it be?" The challenges on each platform are not the same and some factors make Android applications a bit trickier to develop and maintain.

It is unrealistic to think that the exact time (or less) taken to build your iOS application can yield an Android app. The underlying assumption is that all the mobile problems were solved with the iOS effort and perfect conditions are now in place to start a new application. This thinking doesn't leave room to reevaluate infrastructure decisions that could impact the device or scale to new demands. It assumes that there are no developer or institutional knowledge gaps. Finally, it doesn't leave room evaluate the current set of features and how the design translates to the new platform.

Development & Testing

Android does not have a small subset of form factors and OS versions like the iOS ecosphere. There are a multitude of devices that officially (and unofficially) run the Android OS. The OS version distribution impacts both hardware and software features that you can leverage in your application. Also, there are many legacy phones still in use.

This increases complexity of creating an application that looks great on all devices. However, the Android platform has many ways to mitigate these challenges. It's critical to hire engineers and designers that have a good grasp of the platform so that you can reach a wide audience while preserving your brand.

Your organization should define a strategy around which devices to support (preferably when an Android expert is in the room). Different approaches come into play here, but a common one is to pick a representative sampling of devices and make sure the application works well on them. Whichever way you go, the decision will impact the level of testing and development effort.

This may seem daunting, but your application will have a much further reach - on everything from phones to televisions!

Design

There is tremendous value in making your users happy by giving them an intuitive and optimal user experience. This drives adoption and makes your users much more likely to continue to engage with your app over time.

You can’t simply take your current application’s look and feel and shoehorn it into an Android device. This is disrespectful to your users and makes it clear that you view Android as an afterthought. Navigation, user interactions, and widget standards are very different and should be respected on each platform.

It’s critical to evaluate your current features and determine how they will translate to the Android platform. The upside to this fresh perspective is that you will discover ways to leverage platform features that are unique to Android (e.g. rich notifications and widgets).
--
Bottom line: The design will be different, the code base will be different, and the challenges will be different. Make your users happy and follow Android design standards.

Are you building a team or an app?

Once an application is in the market, it will need care and feeding. There will be bug fixes and a growing list of new features to implement. The goal is to find an approach that fits into your mobile strategy and creates a sustainable process around the application. The main trade off is creating an organization in-house or using external firms. Let's look at both approaches in detail.

External team

Outsourcing could provide many advantages for your organization. Although consulting has a higher up front cost, you won't be paying to train and maintain a team. You pay-as-you-go and build only business critical features. The downside is that you’ll continue to pay the firm for maintenance, bug fixes, and feature growth.

Although it's tempting to think about this as something you can just hand off to another firm, you should be involved at all stages. Communication is key to making this approach successful because any external party won't understand your business as well as you do. Being involved in the design and feature prioritization process will ensure that the application created is what you envisioned. You don't want your app built in a vacuum and end up surprised by the end product!

There are several options, including hiring a contracting firm, a boutique firm, an independent contractor, or an overseas team. Contracting firms typically have several contractors that either create apps from scratch or embed with existing teams. Boutique shops have extensive experience with a particular platform and know how to best leverage its features. Independent contractors are typically self employed and work on several applications at once. Finally, you can hire an overseas team for cheaper than what you'd pay a local contractor.

Experience varies widely in the Android development realm. Make sure to ask the right technical questions (covered in detail in the next blog in the series) to ensure you are getting a high quality software product. Aggressively check references and contact past clients to gauge how happy they are with the end product. Install their published applications and check ratings and comments in the Google Play market. Finally, determine how maintainable and easy to extend the app will be (just in case you or someone else needs to update it).

In-house team

Creating a team internally makes sense for many businesses. It allows you to leverage your existing developers and have complete control over the roadmap. You won’t need to pay outside firms each time you want a new feature. Finally, you won’t have to manage the risk of having external developers create your app.

The drawback of this approach is creating and maintaining a team. It's a massive commitment and fiscal investment to support this team. You need to recruit, train, and have enough work for developers to do over the long haul. Depending on the scope of your application and your business objectives, creating your own team can be overkill.

Do you have the right knowledge to select developers to help you with this effort? There is no shortage of developers interested in switching to mobile development because it's an exciting corner of technology. However, it can be challenging to find the talent with the right experience. One strategy is to recruit internal developers and retrain them as mobile developers. Skills like Java and front-end development translate well to Android because it's written in a mixture of XML and Java. This technique is especially effective when combined with hiring an architect to help build the team.

Organizations tend to face the same challenges when beginning a team and an experienced architect can help you avoid these pitfalls. Team augmentation, which is hiring one or more experts to mentor new developers and increase the team Android knowledge, is one way to make this an easier process. Hiring this expert can help you get the right architecture in place, recruit new members, implement best practices, set up continuous integration, mentor team members, and inform the organization about the challenges and constraints of mobile development. Team augmentation can help you make a sustainable team much earlier. Plus there is an endpoint - you decide when to remove the training wheels.
--
Stay tuned for more articles in the series that will focus on choosing the best developers, designers, and testers for your Android project.