Cloud Computing Overview ..

Cloud computing, also on-demand computing, is a kind of Internet-based computing that provides shared processing resources and data to computers and other devices on demand. It is a model for enabling ubiquitous, on-demand access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications and services), which can be rapidly provisioned and released with minimal management effort.

NIST(National Institute of Standards and Technology) also offers up several characteristics that it sees as essential for a service to be considered “Cloud”. These characteristics include - 

1. On-demand self-service - The ability for an end user to sign up and receive services without the long delays that have characterized traditional IT
2. Broad network access - Ability to access the service via standard platforms (desktop, laptop, mobile etc)
3. Resource pooling - Resources are pooled across multiple customers
4. Rapid elasticity - Capability can scale to cope with demand peaks 
5. Measured Service - Billing is metered and delivered as a utility service

Cloud computing comes in three forms:

• public cloud
• private cloud
• hybrids cloud

A public cloud is basically the internet. Service providers use the internet to make resources, such as applications (also known as Software-as-a-service) and storage, available to the general public, or on a ‘public cloud.  Examples of public clouds include Amazon Elastic Compute Cloud (EC2), IBM’s Blue Cloud, Sun Cloud, Google AppEngine and Windows Azure Services Platform. 

Private clouds are data center architectures owned by a single company that provides flexibility, scalability, provisioning, automation and monitoring. Private clouds are data center architectures owned by a single company that provides flexibility, scalability, provisioning, automation and monitoring. 

Hybrid clouds can maintain control of an internally managed private cloud while relying on the public cloud as needed.  For instance during peak periods individual applications, or portions of applications can be migrated to the Public Cloud.

Service-oriented architecture advocates "everything as a service".
Service models:

• Infrastructure as a service (IaaS)
• Platform as a service (PaaS)
• Software as a service (SaaS)

IaaS is the hardware and software that powers it all – servers, storage, networks, operating systems. SaaS applications are designed for end-users, delivered over the web. PaaS is the set of tools and services designed to make coding and deploying those applications quick and efficient.

Cloud Analytics is a service model in which elements of the data analytics process are provided through a public or private cloud. Cloud Analytics applications and services are typically offered under a subscription-based or utility (pay-per-use) pricing model. 

ref:

Cloud Computing Wiki - https://en.wikipedia.org/wiki/Cloud_computing

Intel Cloud Computing - https://www-ssl.intel.com/content/www/us/en/cloud-computing/intel-cloud-based-solutions.html

IaaS vs PaaS vs SaaS - 

• https://support.rackspace.com/white-paper/understanding-the-cloud-computing-stack-saas-paas-iaas/
• https://www.computenext.com/blog/when-to-use-saas-paas-and-iaas/
• http://www.networkworld.com/article/2182527/virtualization/iaas-vs--paas-vs--saas.html

Data Analytics in Cloud Computing - http://technologyadvice.com/wp-content/uploads/2013/05/Data-Analytics-in-Cloud-Computing_TechnologyAdvice.pdf

Big Data in Cloud - http://www.intel.com/content/dam/www/public/us/en/documents/product-briefs/big-data-cloud-technologies-brief.pdf

Cloud and Big Data Analytics - https://education.emc.com/guest/campaign/Cloud_BigData.aspx

Big Data in Amazon AWS - https://aws.amazon.com/big-data/

BigQuery is Google's fully managed, petabyte scale, low cost analytics data warehouse - https://cloud.google.com/bigquery/

Misc - 

1. http://www.asigra.com/blog/cloud-types-private-public-and-hybrid

Apple Audio Processing .. CoreAudio

Apple Core Audio is the digital audio infrastructure of iOS and OS X. It includes a set of software frameworks designed to handle the audio needs in your applications. Apple CoreAudio API bit different between MacOSX & iOS as these API also consider the processing power of the device(desktop vs mobile).

In OS X, Core Audio expects audio data to be in native-endian, 32-bit floating-point, linear PCM format. You can use Audio Converter Services to translate audio data between different linear PCM variants. You also use these converters to translate between linear PCM and compressed audio formats such as MP3 and Apple Lossless. Core Audio in OS X supplies codecs to translate most common digital audio formats (though it does not supply an encoder for converting to MP3). iOS uses integer and fixed-point audio data. The result is faster calculations and less battery drain when processing audio. iOS provides a Converter audio unit and includes the interfaces from Audio Converter Services. For details on the so-called canonical audio data formats for iOS and OS X, see Canonical Audio Data Formats.

Audio units are software plug-ins that process audio data. In OS X, a single audio unit can be used simultaneously by an unlimited number of channels and applications. iOS provides a set of audio units optimized for efficiency and performance on a mobile platform. You can develop audio units for use in your iOS application. Because you must statically link custom audio unit code into your application, audio units that you develop cannot be used by other applications in iOS.

CoreAudio Frameworks Available in both iOS and OS X =>

AudioToolbox.framework - The Audio Toolbox framework contains the APIs that provide application-level services.

AudioUnit.framework - The Audio Unit framework contains the APIs used for managing plug-ins in Core Audio.

CoreAudio.framework - The Core Audio framework contains data types common to all Core Audio services, as well as lower-level APIs used to interact with hardware. In OS X, this framework contains the interfaces for Hardware Abstraction Layer (HAL) Services.

The frameworks listed in this section are available in iOS only =>

AVFoundation.framework - The AV Foundation framework provides an Objective-C interface for playing back audio with the control needed by most applications. The AV Foundation framework in iOS includes one header file:

AVAudioPlayer.h: Defines an interface for playing audio from a file or from memory.

Frameworks Available in OS X Only

The frameworks listed in this section are available in MAC OS X only =>

CoreAudioKit.framework - The Core Audio Kit framework contains APIs used for creating a Cocoa user interface for an audio unit.

CoreAudioKit.h: Top-level include file for the Core Audio Kit framework.

AUGenericView.h: Defines a generic Cocoa view class for use with audio units. This is the bare-bones user interface that is displayed if an audio unit doesn't create its own custom interface.

AUPannerView.h: Defines and instantiates a generic view for use with audio units.

Open source Mac/iOS Audio Libraries =>

1. Novocaine - https://github.com/alexbw/novocaine
2. EZAudio - https://github.com/syedhali/EZAudio
3. OrigamiEngine - https://github.com/ap4y/OrigamiEngine
4. FreeStreamerMobile - https://github.com/muhku/FreeStreamer/tree/master/FreeStreamerMobile

ref:

1. https://developer.apple.com/library/mac/documentation/MusicAudio/Conceptual/AudioUnitProgrammingGuide/AQuickTouroftheCoreAudioSDK/AQuickTouroftheCoreAudioSDK.html
2. https://developer.apple.com/library/mac/documentation/MusicAudio/Conceptual/CoreAudioOverview/WhatisCoreAudio/WhatisCoreAudio.html
3. https://developer.apple.com/library/mac/documentation/MusicAudio/Conceptual/CoreAudioOverview/CoreAudioFrameworks/CoreAudioFrameworks.html

C/C++ Chrome OS Development ..

Native Client is a sandbox for running compiled C and C++ code in the browser efficiently and securely, independent of the user’s operating system. Portable Native Client extends that technology with architecture independence, letting developers compile their code once to run in any website and on any architecture with ahead-of-time (AOT) translation. In short, Native Client brings the performance and low-level control of native code to modern web browsers, without sacrificing the security and portability of the web.

Native Client comes in two flavors - 

    Portable Native Client (PNaCl): Pronounced ‘pinnacle’, PNaCl runs single, portable (pexe) executables and is available in most implementations of Chrome. A translator built into Chrome translates the pexe into native code for the client hardware. The entire module is translated before any code is executed rather than as the code is executed. PNaCl modules can be hosted from any web server.

    Native Client (NaCl): Traditional or non-portable Native Client, NaCl runs architecture-dependent (nexe) modules, which are packaged into an application. At runtime, the browser decides which nexe to load based on the architecture of the client machine. Apps and Extensions installed via the Chrome Web Store (CWS) can use NaCl modules without additional prompting. NaCl apps can also be installed from chrome://extensions or the command-line during development, however, this is not a recommended distribution mechanism.

Everything you see on Chrome OS is Chrome browser, Login window, all the bells and whistles. With regular Chrome there's "parent" process which manages the browser processes. In the Chrome OS case it's extended a bit and manages the whole OS. The only way to run native code on regular ChromeOS is via (P)NaCl (or JavaScript). NaCl is only allowed to use Pepper API to communicate with the browser. As a Chrome OS application developer, you have access to the Chrome Apps API and the Pepper API. You cannot directly call any operating system libraries, because your (P)NaCl code runs in a sandbox. Also, the resources you have access to with the Pepper API are virtualized containers scoped to your "origin" (roughly, this is the hostname for webpages and the extension id for chrome apps/extensions).

Even Android Apps could run on ChromeOS. These Apps in fact run on top of NaCl and PPAPI(Pepper Plugin API). They have some additional permissions, though (not much, though: currently they could execute native code without NaCl limitations, but still could only call the outside world via PPAPI).

Webports is collection of open source libraries and applications that have been ported to Native Client. 

Brief:

1. If you want your code to run on official release builds of ChromeOS, the only supported solution for C/C++ is to use the native client sandboxing technology. 
2. You can use portable native client (PNaCl) directly just from regular web pages if you don't need access to any of the additional APIs provided to chrome extensions or apps.
3. As a Chrome OS application developer you have access to the Chrome Apps API and the Pepper API and can NOT access underlying OS api directly. If you do need access to those APIs, then you'll need to make an extension or app and have at least a minimal Javascript shim for proxying extensions/apps API request/responses and events to your NaCl/PNaCl code, using messaging. 
4. You can also develop your own OS images based off the Chromium OS source with your C/C++ code natively linked in.

ref:

Chrome User-Groups - native-client-discuss@googlegroups.com, chromium-extensions@chromium.org

Chromium OS Overview - http://dev.chromium.org/chromium-os

Chromium Native Client - https://www.chromium.org/nativeclient

Chromium Native Client development basics - https://www.chromium.org/nativeclient/getting-started/getting-started-background-and-basics

Chrome OS Native Client Development - https://developer.chrome.com/native-client

Chrome Pepper API(C/C++) reference - https://developer.chrome.com/native-client/pepper_dev

Chrome OS C++ Tutorials - 

• https://developer.chrome.com/native-client/devguide/tutorial/tutorial-part1
• https://developer.chrome.com/native-client/devguide/tutorial/tutorial-part2

Chrome OS Developer mode - https://software.intel.com/en-us/blogs/2014/08/18/two-simple-ways-to-get-to-the-chrome-os-shell 

Launching Chrome OS Shell (crosh) - https://software.intel.com/en-us/blogs/2014/08/18/two-simple-ways-to-get-to-the-chrome-os-shell 

Intel Chrome Resources - https://software.intel.com/en-us/chrome

Porting Chrome* Apps to Mobile Using Crosswalk and Apache Cordova - https://software.intel.com/en-us/blogs/2015/06/15/porting-chrome-apps-to-mobile-using-crosswalk-and-apache-cordova

Chrome Extensions - https://developer.chrome.com/extensions

Chrome Apps - https://developer.chrome.com/apps

Building Chrome OS on Linux - http://dev.chromium.org/developers/how-tos/build-instructions-chromeos

Chrome JavaScript to Native Client Messaging System - https://developer.chrome.com/native-client/devguide/coding/message-system

Chrome Native Client SDK download - https://developer.chrome.com/native-client/sdk/download

Chrome OS JavaScript API - https://developer.chrome.com/apps/api_index

Running Android Apps on Chrome OS - https://developer.chrome.com/apps/getstarted_arc

Chrome WebPorts - https://chromium.googlesource.com/webports

Chromium OS Developer Quick Start Guide - https://www.chromium.org/chromium-os/quick-start-guide

Chromium OS Developer Guide - https://www.chromium.org/chromium-os/developer-guide