OpenWrt Overview ..

OpenWrt is an embedded operating system based on Linux, primarily used on embedded devices to route network traffic. It can run on various types of devices, including CPE routers, residential gateways, smartphones, pocket computers (e.g. Ben NanoNote), and laptops. It is also possible to run OpenWrt on personal computers, which are most commonly based on the x86 architecture.

 Instead of trying to create a single, static firmware, OpenWrt provides a fully writable filesystem with package management. This frees you from the application selection and configuration provided by the vendor and allows you to customize the device through the use of packages to suit any application. For developer, OpenWrt is the framework to build an application without having to build a complete firmware around it; for users this means the ability for full customization, to use the device in ways never envisioned.

 OpenWrt Commands:

 1. Kernel version => uname -a
2. OS version => cat /etc/banner
3. Show contents of syslog => logread
4. Install OpenWRT packages => https://downloads.openwrt.org/snapshots/trunk/ar71xx/generic/packages/packages/
opkg install kmod-bluetooth bluez-utils
opkg install libusb

 OpenWRT BlueZ packages =>

 bluelog-live_1.1.2-1_ar71xx.ipk 32868 18-Jun-2016 17:57
bluelog_1.1.2-1_ar71xx.ipk 10945 18-Jun-2016 17:57
bluez-daemon_5.38-1_ar71xx.ipk 488028 18-Jun-2016 17:52
bluez-examples_5.38-1_ar71xx.ipk 29941 18-Jun-2016 17:51
bluez-libs_5.38-1_ar71xx.ipk 48830 18-Jun-2016 17:51
bluez-utils_5.38-1_ar71xx.ipk 861936 18-Jun-2016 17:52

 ref:

 Official - https://openwrt.org/https://openwrt.org/

 Wiki - https://en.wikipedia.org/wiki/OpenWrt

 OpenWrt github - https://github.com/openwrt

 Getting started with OpenWRT - http://www.cambus.net/getting-started-with-openwrt/

 OpenWRT Build System - https://wiki.openwrt.org/doc/howto/build

OpenWrt BlueZ - https://forum.openwrt.org/viewtopic.php?id=1650

 OpenWrt on x86 PC - https://forum.openwrt.org/viewtopic.php?id=20478, https://we.riseup.net/lackof/openwrt-on-x86-64

 OpenWrt on VirtualBox - https://wiki.openwrt.org/doc/howto/virtualbox

 Generic Basic Howtos for OpenWrt - https://wiki.openwrt.org/doc/howto/generic.overview



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 - 
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/

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 - 


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

Microservices Architecture ..

Microservices architecture as a service-oriented architecture composed of loosely coupled elements that have bounded contexts. It is a software architecture style in which complex applications are composed of small, independent processes communicating with each other using language-agnostic APIs. These services are small, highly decoupled and focus on doing a small task, facilitating a modular approach to system-building.

 Microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.

 Microservices, in some ways, make for a better developer experience too, which allows you to grow your business more rapidly. More and more people are flocking to try the microservices architecture because its modularity of small, focused, quasi-independent services allow businesses to deploy and scale services more easily. This segmentation also allows smaller teams that create smaller code bases. Microservices also lend themselves to agile, scrum and continuous delivery software development processes with shorter lifecycles. This architecture distinguishes itself from service-oriented architecture (SOA) because each microservice only belongs to one application, not multiple.

ref:


Microservices Architecture Pattern - http://microservices.io/patterns/microservices.html

Microsoft Azure Service Fabric and the Microservices Architecture - https://msdn.microsoft.com/en-us/magazine/mt595752.aspx


Adopting Microservices at Netflix: Lessons for Architectural Design - https://www.nginx.com/blog/microservices-at-netflix-architectural-best-practices/



Misc -