Back at the end of February, IBM announced an upcoming beta version of MobileFirst Platform Foundation version 8.0. Well, guess what? … As of last week, it is now available!
What is IBM MobileFirst Platform Foundation?
For those stumbling upon this and wondering “What is IBM MobileFirst Platform Foundation?”:
IBM MobileFirst Platform Foundation is an open, comprehensive platform to develop, test, secure, and manage mobile apps.
MobileFirst Platform Foundation provides a middleware solution and SDK that makes exposing data to mobile apps easier, improves security through encryption, authentication and handshaking to guarantee app authenticity, provides facilities to easily manage multiple versions of an app, notify and engage users, and, on top of everything else, provides operational analytics so that you can monitor the health of your overall system at any point in time.
As a mobile developer catering to the enterprise, it makes your life significantly easier, and it supports any mobile development paradigm that you might want to target: Native platforms, hybrid Xamarin using C#, and hybrid Cordova platforms (HTML/JS).
What’s new in the IBM MobileFirst Platform Foundation 8.0 Beta?
The recently opened beta has some great new features, AND it’s now available as a service on Bluemix (IBM’s Cloud platform). The beta program is intended to deliver the next generation of an open, integrated and comprehensive mobile app development platform redesigned for cloud agility, speed, and productivity, that enables enterprises to accelerate delivery of their mobile strategy.
Those new features include (but not limited to):
Use of NPM on Cordova apps
CocoaPods support for iOS apps
Gradle and NuGet support for native apps
Maven support for backend logic
Faster plug-in speed – faster MFPF performance for new and existing apps
New, better, sample code, documentation, and guides
Automation support and self-service features for faster ramp-up and tear-down of environments for testing and iterations
Ability to make changes to app runtime settings without redeployment
Middleware redesigned for DevOps efficiency
Custom notifications in MobileFirst Operations Analytics
New crash analysis tools
Getting involved in the Beta
This is a great opportunity to to explore new features, and drive business value. We also want your feedback to make sure the MobileFirst Platform has what you need.
I recently gave a presentation at IBM Insight on Cognitive Computing in mobile apps. I showed two apps: one that uses Watson natural language processing to perform search queries, and another that uses Watson translation and speech to text services to take text in one language, translate it to another language, then even have the app play back the spoken audio in the translated language. It’s this second app that I want to highlight today.
In fact, it gets much cooler than that. I had an idea: “What if we hook up an OCR (optical character recognition) engine to the translation services?” That way, you can take a picture of something, extract the text, and translate it. It turns out, it’s not that hard, and I was able to put together this sample app in just under two days. Check out the video below to see it in action.
To be clear, I ended up using a version of the open source Tesseract OCR engine targeting iOS. This is not based on any of the work IBM research is doing with OCR or natural scene OCR, and should not be confused with any IBM OCR work. This is basic OCR and works best with dark text on a light background.
The Tesseract engine lets you pass in an image, then handles the OCR operations, returning you a collection of words that it is able to extract from that image. Once you have the text, you can do whatever you want from it.
So, here’s where Watson Developer Cloud Services come into play. First, I used the Watson Language Translation Service to perform the translation. When using this service, I make a request to my Node.js app running on IBM Bluemix (IBM’s cloud platform). The Node.js app acts as a facade and delegates to the Watson service for the actual translation.
You can check out a sample on the web here:
On the mobile client, you just make a request to your service and do something with the response. The example below uses the IMFResourceRequest API to make a request to the server (this can be done in either Objective C or Swift). IMFResourceRequest is the MobileFirst wrapper for networking requests that enables the MobileFirst/Mobile Client Access service to capture operational analytics for every request made by the app.
Once you receive the result from the server, then you can update the UI, make a request to the speech to text service, or pretty much anything else.
To generate audio using the Watson Text To Speech service, you can either use the Watson Speech SDK, or you can use the Node.js facade again to broker requests to the Watson Speech To Text Service. In this sample I used the Node.js facade to generate Flac audio, which I played in the native iOS app using the open source Origami Engine library that supports Flac audio formats.
You can preview audio generated using the Watson Text To Speech service using the embedded audio below. Note: In this sample I’m using the OGG file format; it will only work in browsers that support OGG.
English: Hello and welcome! Please share this article with your friends!
Hola y bienvenido! Comparta este artículo con sus amigos!
On the native iOS client, I download the audio file and play it using the Origami Engine player. This could also be done with the Watson iOS SDK (much easier), but I wrote this sample before the SDK was available.
//download the contents of the audio file
NSData *audioData = [NSData dataWithContentsOfURL:flacURL];
NSString *docDirPath = NSTemporaryDirectory() ;
NSString *filePath = [NSString stringWithFormat:@"%@transcript.flac", docDirPath ];
[audioData writeToFile:filePath atomically:YES];
//pass the file url the the origami player and play the audio
NSURL* fileUrl = [NSURL fileURLWithPath:filePath];
Cognitive computing is all about augmenting the experience of the user, and enabling the users to perform their duties more efficiently and more effectively. The Watson language services enable any app to greater facilitate communication and broaden the reach of content across diverse user bases. You should definitely check them out to see how Watson services can benefit you.
So, I mentioned that this app uses IBM MobileFirst offerings on Bluemix. In particular I am using the Mobile Client Access service to collect logs and operational analytics from the app. This lets you capture logs and usage metrics for apps that are live “out in the wild”, providing insight into what people are using, how they’re using it, and the health of the system at any point in time.
You can access the sample iOS client and Node.js code at https://github.com/triceam/Watson-Translator. Setup instructions are available in the readme document. I intend on updating this app with some more translation use cases in the future, so be sure to check back!
Last week I attended IBM Insight in Las Vegas. It was a great event, with tons of great information for attendees. I had a few sessions on mobile applications. In particular, my dev@Insight session on Wearables powered by IBM MobileFirst was recorded. You can check it out here:
Wearables are the most personal computing devices ever. Your users can use them to be notified of information, search/consume data, or even collect environmental data for reporting or actionable analysis.
Regardless of whether developing for a peripheral device like the Apple Watch or Microsoft Band, or a standalone device like Android Wear, you are developing an app that runs in an environment that mirrors that of a a native app. So, the fundamental development principles are exactly the same. You write native code, that uses standard protocols and common conventions to interact with the back-end.
Caveat to #1: You user interface is much smaller. You should design the user interface and services to acomodate for the reduced amount of information that can be displayed.
You can share code across both the phone/tablet and watch/wearable experience (depending on the target device).
Using IBM MobileFirst you can easily expose data, add authentication, and capture analytics for both the mobile and wearable solutions.
You may have heard a lot of buzz coming out of IBM lately about Cognitive Computing, and you might have also wondered “what the heck are they talking about?” You may have heard of services for data and predictive analytics, services for natural language text processing, services for sentiment analysis, services understand speech and translate languages, but it’s sometimes hard to see the forest through the trees.
I highly recommend taking a moment to watch this video that introduces Cognitive Computing from IBM:
Cognitive computing systems learn and interact naturally with people to extend what either humans or machine could do on their own.
They help human experts make better decisions by penetrating the complexity of Big Data.
Cognitive systems are often based upon massive sets of data and powerful analytics algorithms that detect patterns and concepts that can be turned into actionable information for the end users. It’s not “artificial intelligence” in the sense that the services/machines act upon their own; rather a system that provides the user tools or information that enables them to make better decisions.
The benefits of cognitive systems in a nutshell:
They augment the user’s experience
They provide the ability to process information faster
They make complex information easier to understand
They enable you to do things you might not otherwise be able to do
Curious where this will lead? Now take a moment and watch this video talking about the industry-transforming opportunities that Cognitive Computing is already beginning to bring to life”
So, why is the “mobile guy” talking about Cognitive Computing?
First, it’s because Cognitive Computing is big… I mean, really, really big. Cognitive systems are literally transforming industries and providing powerful analytics and insight into the hands of both experts and “normal people”. When I say “into the hands”, I again mean this literally; much of this cognitive ability is being delivered to those end users through their mobile devices.
Last, and this is purely just personal opinion, I see the mobile MobileFirst offerings themselves as providing somewhat of cognitive service for developing mobile apps. If you look at it from the operational analytics perspective, you have an immediate insight and a snapshot into the health of your system that you would never have seen otherwise. You can know what types of devices are hitting your system, what services are being used, how long things are taking, and detect issues, all without any additional development efforts on your end. It’s not predictive analytics, but sure is helpful and gets us moving in the right direction.
Even though the acquisition is still “hot off of the presses”, you can start using these tools together today:
If you haven’t heard about StrongLoop’s LoopBack framework, it enables you to easily connect and expose your data as REST services. It provides the ability to visually create data models in a graphical (or command line) interface, which are used to automatically generate REST APIs – thus generating CRUD operations for your REST services tier, without having to write any code.
Why is this important?
It makes API development easier and drastically reduces time from concept to implementation. If you haven’t yet looked at the LoopBack framework, you should definitely check it out. You can build API layers for your apps literally in minutes. Check out the video below for a quick introduction:
Again, be sure to check out these posts that detail the integration steps so you can start using these tools together today: