Merge pull request #37 from strongloop/mobile_clients

Mobile clients

docs/concepts.md

@@ -31,11 +31,35 @@ notifications, register users, and any other behavior provided by data sources.
 
 ### Mobile Clients
 
-**PLACEHOLDER FOR SDK INTRO**
+LoopBack provides native Client SDKs to give mobile developers access to remote,
+persistent data in a contextually-relevant way. The transport and marshalling of
+the data is taken care of, and mobile developers can leverage all of their
+existing tools (XCode, Eclipse, et al) to model their data on the client,
+persisting it to the server as needed.
 
-In summary, mobile clients work with objects that are connected to LoopBack
+To achieve this, LoopBack supports both "Dynamic", schema-less Models and
-to provide data and perform actions.Those objects are captured as models in
+"Static", schema-driven Models. (See ["Models"](#models) for more specifics and
-LoopBack.
+how-tos around Model creation.)
+
+Dynamic Models require minimal server code up front (just a name!) to set-up,
+with the format of the data specified _completely_ and _flexibly_ by the client
+application. Well-suited for data that _originates on the client_, mobile
+developers can leverage Dynamic Models to persist data both between sessions and
+between _devices_ while obviating the need for outside engineering support.
+(Let's be honest - how many server programmers do you know that are _excited_
+when you ask them to add a field to some schema on the server? None? That's what
+we thought.)
+
+Static Models require more code up front in an extended grammar of JSON we call
+LDL, with the format of the data specified _completely_ in a _structured_ way by
+the server application. Well-suited to both existing data and large, intricate
+datasets, mobile developers can leverage Static Models to provide structure and
+consistency to their data, preventing the multitude of bugs that can result from
+unexpected data in their database. (These pesky bugs _love_ to show up in
+production and ruin everyone's launch day. Stop them before they start!)
+
+Use one strategy, or use both. Leverage them to fit your _use case_, rather than
+fitting your use case to some fixed modelling strategy. The choice is yours.
 
 ### Models
 
@@ -172,7 +196,7 @@ SOAP Web Services, and Storage Services, as data sources.
 LoopBack allows you to connect to many sources of data and services both in the
 cloud and on-premise in your data center. DataSources are accessed through a
 plugin called a Connector in LoopBack.  Plugins are highly customizable and
-extensible.  Unlike other mobile backend, LoopBack can leverage your existing
+extensible.  Unlike other mobile backends, LoopBack can leverage your existing
 data and organize them in the form of models.
 
 Connectors implement the data exchange logic using database drivers or other
@@ -230,9 +254,87 @@ As well as its management sub-components:
 
 - Editor - ***Coming Soon***
 - Admin Console - ***Coming Soon***
-- LoopBack Shell
+- LoopBack Node.js API
 - Repository/Registry
 
 ![loopback_overview](assets/loopback_ov.png "LoopBack Overview")
 
+At first glance, LoopBack looks like just any other API tier.  But
+looks can be deceiving.  Here are some key differentiators that make
+Loopback stand out as an api tier built for mobile:
+
+1. Model APIS are surfaced over REST without writing code
+2. The Datasource Juggler is a modern ORM that supports
+not only traditional RDBMS, but also noSQL and services
+3. As a mobile backend as a service (mBaaS) we help you leverage
+valuable existing data in your mobile app as well dynamically create
+new schema or schema-less data
+
+<h4> Mobile clients </h4>
+We're putting a lot of effort into building flexibility and
+functionality into our mobile client SDKs.  The ultimate goal is to
+preserve what's familiar to the mobile developer in their native
+platform and empower them with seamelss backend functionality.
+
+Mobile clients call into LoopBack APIs surfaced by [strong-remoting](http://docs.strongloop.com/strong-remoting), a pluggable transport
+layer that supports surfacing backend APIs over REST, WebSockets,
+and other transports.
+
+<h4> API Gateway </h4>
+The first line of defense and entry is the API gateway.  This
+sub-component of LoopBack acts as a reverse-proxy to the rest of
+LoopBack.  It provides OAuth2 based security, will mediate between
+multiple data formats and acts as a quality of service layer for your
+API providing instrumentation and other aspect level functionality.
+
+<h4>  API Server </h4>
+The core of LoopBack is the API Server where models are registered
+and hosted during runtime.   Models are automatically exposed through a REST endpoint.
+
+The API server also will run batch processes or scheduled jobs as a
+mobile backend for functions like mass push notifications.
+
+<h4> Enterprise Connectors </h4>
+LoopBack lets you leveratge existing data and services that you need
+in your mobile apps just as you do in your web apps.  LoopBack has a
+layer of abstraction provided by the DataSource Juggler so that all
+you need to worry about is your model.  The Datasource Juggler
+accesses the underlying [datasources](http://docs.strongloop.com/loopback/#data-sources-and-connectors) through Enterprise
+Connectors.
+
+<h4> Editor </h4>
+LoopBack comes with a rich set of [Node.js based APIs](http://docs.strongloop.com/loopback/#nodejs-api).
+The editor is a web based GUI that makes it even easier to define,
+configure and manage your mobile apps and models without having to
+write code.  The editor will also facilitate the process of
+[discovering models](http://docs.strongloop.com/loopback/#datasourcediscovermodeldefinitionsusername-fn) and [schemas](http://docs.strongloop.com/loopback/#datasourcediscoverschemaowner-name-fn)
+from datasources to give you a headstart on building your app.
+
+<h4> Admin Console </h4>
+Each LoopBack development environment is fully self contained.  When
+working in the enterprise, there is a need to distribute work much
+like how distributed source control systems like `git` have risen and
+evolved.  When combining the work output from multiple LoopBack
+development environments into a single enterprise runtime, the Admin
+Console helps with merging and maintaining configuration as well as
+deployment.
+
+
+<h4> Repository </h4>
+All development in LoopBack ends up as metadata that's stored in JSON
+config files.  Config files are distributed, merged and
+consolidated centrally into the Repository.  The Repository is
+centrally maintained by an admin through the [Admin
+Console](http://docs.strongloop.com/loopback#admin-console) where
+policies like security are defined and configured.
+
+
+<h4> LoopBack Node.js API </h4>
+All manipulation of the metadata that constitutes the entire runtime
+of the mobile API is done through an internal Node.js API.  In the
+spirit of truly "eating our own dog food" - the API powers the
+editor and any other tools that are included with LoopBack.
+
+
+
 ---

docs/quickstart.md

@@ -29,7 +29,7 @@ $ slc run app
 
 > Open the app in a browser.
 
-The sample app should now be running at <http://localhost:3000>. The homepage of
+The sample app should now be running at <a href="http://localhost:3000" target="_blank">http://localhost:3000</a>. The homepage of
 the sample app lists several sample requests you can make against the LoopBack
 REST API.