The Service Business
PaaS, BaaS, IaaS have been a growing, and I dare say welcome, industry over the past 5 years. There is a lot of *aaS options out there with specific offerings.
While there are many varing opinions as to when to choose one or many or none of these types of services, this article is an overview of the latest comer to the service space, and in the this humble developers opinion, the best out there: FatFractal
First let’s define which each of the different types of services are:
Platform as a Service
PaaS provides all the infrastructure needed to run applications over the Internet. It is delivered in the same way as a utility like electricity or water. Users simply “tap in” and take what they need without worrying about the complexity behind the scenes. And like a utility, PaaS is based on a metering or subscription model so users only pay for what they use.
With PaaS, ISVs and corporate IT departments can focus on innovation instead of complex infrastructure. By leveraging the PaaS, organizations can redirect a significant portion of their budgets from “keeping the lights on” to creating applications that provide real business value.
This model is driving a new era of mass innovation. For the first time, developers around the world can access unlimited computing power. Now, anyone with an Internet connection can build powerful applications and easily deploy them to users wherever they’re located.
Source: SalesForce
Infrastructure as a Service
Infrastructure as a service (IaaS) means delivering a virtual server, desktop computer or remote storage from the cloud. In other words, a hosting provider such as Dell gives you a remote data center — where it manages the infrastructure, servers and virtualization — and you access your virtual computers and storage from the internet through a secure virtual private network (VPN) connection.
An IaaS approach to infrastructure can offer:
Faster responses to changing business conditions or internal customer needs, enabled by rapid system provisioning and rapid scalability, both up and down, without the long-term lock-in of hardware purchases
Productivity increases resulting from access to your applications and data from anywhere and the reliability that comes from a distributed computing model.
Reduced capital outlay for hardware acquisition, maintenance, data center real estate, and power and cooling, when using a pay-for-use (public cloud) model
Source: Dell
Backend as a Service
BaaS, as we shall call it for the sake of brevity, has carved its own little niche nestled neatly between Platform as a Service (PaaS) and Software as a Service (SaaS). Unsurprisingly, it does exactly what it says on the tin – that is – it provides a near complete server side stack including persistence, user management, data retrieval and querying, file storage and a few other things at the flick of a switch.
Source: Cloudspring
Who Is Out There
I’m sure I am not covering then all, but these are the platforms and back ends that I have used myself.
Parse
Stackmob
Applicassa
Kinvey
They all offer varying takes on the following list of features:
PUSH notifications
iOS, JS, Android SDKs
REST Service
Twitter, Facebook integration
Server Extension (Stackmob and Kinvey only)
Location Services
File storage
Payments (In-app Purchasing)
From Code to Cloud
When I was first invited to FatFractal’s private beta I was expecting more of the same. That isn’t to imply that the above services are bad, just more of the same with their own flavor. You know that expression, “You don’t know what you’ve got until it is gone.”. With FatFractal I never knew what I didn’t have until I experienced it.
As I stated above all of these services offer the same features in some shape form or fashion, however they fail to implement the basic of features in the a correct manner.
What developers want and need is a platform that has benefits of Google App Engine in regards to scalability, language support, and schedule tasks, but an abstracted data store (BaaS) that gives developers complete control over their models. Enter FatFractal. A true abstract data store and abstract engine that is language agnostic. You have all these features above but without endless endpoint creation, spaghetti client code and a new and refreshing approach to data-modeling.
The four main areas FatFractal excels above all the others are:
local development
modeling
object graphs
server-side functionality
Local Development
Since the genesis of BaaS there has been an assumption that developers want to manage the life cycle of their app data in the cloud. Incorrect. We want to be able to have a light-weight local environment that is an exact replica of what we deploy into the cloud. The only current option is GAE, but the trade-off is that you lose the benefits of what BaaS providers offer out of the box. Not with FatFractal.
The FatFractal platform was built on an engine model. We believe that during application development it is imperative to have the local runtime environment be a carbon copy of what’s up on the cloud. When you set up for local development, you install a fully-featured FatFractal Engine on your desktop. This is not a crippleware version, not a simulation.
Source: Lovin’ Localhost
Deploying is literally one line (local): ffef deploylocal (cloud) ffef deployFFFabric
Modeling
I like to create models as subclasses of NSObject. `` I know it seems like a far out idea, but it is a far to common practice to force developers to interact with models that are only hashmaps or dictionaries or having to create a map between my objects and backend. The specifics of how models are defined and created go beyond just defining properties. It could involve conforming to a protocol like NSCoding or using KVO. The reverse is also true. There are many use cases when I just want clean objects. I don’t want extra overhead that is unknown to me.
Functionality like this should not have to be written.
Object Graphs
Six degrees of separation refers to the idea that everyone is on average approximately six steps away, by way of introduction, from any other person on Earth, so that a chain of “a friend of a friend” statements can be made, on average, to connect any two people in six steps or fewer. When we talk about object relationships we are usually discussing these relationships based some sort of defined structure. Whether that is a join table, circle references or foreign keys. The truth is relationships aren’t always explicitedly defined. Most BaaS will provide a standard, one-to-many or many-to-many, but you still run into the “noSQL join” obstacle. Data relationshiops are like human relationships. What makes objects/data useful are these relations but where is the flexibility to define these complex relationships in a simple and meaningful way. John Doe and Jane Smith are friends but their friendship graph is:
John’s mother' second cousin’s nephew’s best friend’s ex-wife’s bridesmaid is also Jane. With the FatFractal’s grabbag and back reference this is trival to define and return.
Most models start clean but the moment you start defining relationships other services start to fall down:
Pivot tables
guids
duplicate data
When defining a grabbag as part of object definition the values aren’t loaded by default with the instance. It is kept as datastore reference and populated via API. Long story short it doesn’t pollute object graph with each instance request.
Essentially FatFractal has solved the NoSQL join problem.
Creating and managing relationships, no matter who complex, is finally straight forward without compromising data integrity or performance. One to many, many to many, many to infinity…it doesn’t matter to FatFractal, but it does to competitors.
Server-side Functionality
A major deciding factor when choosing any sort of “automated” service to replace something that you could hand roll yourself is how easy or difficult is it to extend functionality. This mentality is always at the fore-front of a developers mind. It is our nature. Why…because it is the very being of object-oriented programming. You extend classes, and inherit parent functionality. You implement interfaces to enforce signature. The same funcitonality should exist with BaaS providers. Stackmob does provide extension capability, but you are restricted to Java and there isn’t a way to ensure that your local development will run the same as when you deploy into your dev or production API (see local dev enviornment above). FatFractal is language agnostic. You want to write your extension in Python, no problem, JS, go for it…hey I’m one of those cool ruby kids what about me?…they have you covered too.
In addition to extentending the server you can also event handlers.
Event handlers execute when an event occurs on your app’s backend and are one of the most powerful and unique aspects of the FatFractal Platform. Every CRUD action automatically generates an event, with no coding required by your application, that may trigger an event handler.
In the examples given from other services I see way too much server side code being performed on the client. Whether that is list filtering, validation or post processing…the reason being is that they ability to perform most of these server tasks doesn’t exist. They do with FatFractal.
For example, if I have an app that “checks-in” a user I would probably also want to update a user property “myEvents” (list of all events I have attended) and “currentEvent” (instance of Event) and add myself to the events group of attendees which will provide me certain resource permissions. Having to do this on a mobile app is horrible design. The mobile app should post to “checkin” resource, essentially validating an access code or something and then continue on. The server-side should be able to have an event handler which takes a successful checkin and update the object instance and any other related objects. As side from StackMob, and it is difficult to setup and has to be Java, this isn’t possible.
Using It
Over the past 9 months I have used all of the mentioned BaaS with production apps and hand rolled my own webservices using RDBMS, as well as NoSQL…not just ‘hello world’ tutorials. Each one has their niche in the market, but when making the decision of which service I would use for developing WhoNote (still in development), and any future applications, FatFractal is the clear choice. I am able to keep clean, native objects, define, with simplicity, a complex object-graph, implement proper server-client design with extensions, event handlers, scheduled tasks and last, but not least, have configurable implicit and explict permissions with an exact duplicate local development environment.
Summary
FatFractal is the next evolution of app development platforms.
*Note: I am not employeed by FatFractal and was not paid, bribed or coerced into writing this article. I wrote it because their approach to PaaS/BaaS provides the level of out of the box features and customization that I have seen in different pieces all over the interwebs, but haven’t found in one solution.
Permalink
| Leave a comment »