Showing posts with label Android. Show all posts
Showing posts with label Android. Show all posts

Thursday, October 8, 2015

Towards a Concept of Source Code Management - Android - Licensing, Repo, and Repositories

Ed. note: The following article is written with an assumption that a thesis thoughtfully juxtaposing the BSD and GPL licenses is already available, thus that the author's own perspective that the BSD license is "More free" than the GPL -- that this can be assumed to be a concept already familiar to an arbitrary reader.

Ed. note: The following article will not present a juxtaposition of marketing and propaganda.  The philosophical similarity of such concepts may be left for another time.

Ed. note: The following article will not endeavor to address the ZMOT marketing strategy as published of any singularly advertising-oriented commercial agencies.

Google Android -- as a mobile operating system certainly "more open" than iOS, if not measurably "More fun" than QNX, in any arbitrary measure of statistical popularity -- it being an operating system, it has a source code. It being an operating system based on the Linux kernel, of course it's an operating system extending of a GPL licensed work, moreover. Software licensing not being per se a time-locked concept, it may be a relevant concept even when it is not per se a popular concept. Thus, the author proposes to write about the concept, even in writing in a populist Internet media.

Though the GPL license clearly does not limit the popularity of  marketing about the Android platform, but as the GPL's licensing limitations representing a manner of a legal concept, and Google being a gargantuan company, it certainly may not be the veritable poisoned apple in the varnish, if it may be something that Google surely would have addressed, already, to all legal extents, already -- such as would be apparent of Google Android source code distribution and Google Android binary application distribution.

So much as any non-GPL'd applciations may be defined as linking to the Linux Kernel in the Android platform -- that, of course, would not be "On Google," rather "On" the responsibilities of Android application developers. Sure, Google facilitates distribution of non-GPL'd applications for Android, with the Android App Store -- and sure, it may be difficult, if it is not altogether impossible for a software industry to thrive under a toxic licensing strategy such as, to some theories, the GPL represents. So far as estimating any possible risk of Android application development, with non-GPL's applications, "The industry" perhaps seems to "Look away" from analyzing the exact terms of the GPL license and its implications for applications development and public applications distribution on GPL'd platforms. Individual software vendors may not be at such liberty.

A thorough study of licenses applied in the Google Android source code -- such  a study being, no doubt, a non-trivial thing to develop -- may not be immediately forthcoming of this singular article, though proposed of this article, momentarily.

A study about source code management practices applied with regards to the Android operating system -- as a study that should be preceded with a study about software licensing, as in regards to terms and practices of software licensing in regards to software development and software distribution -- a study about source code management, itself as a topic, may need not begin with any manner of a review of marketing propaganda.

Of course, Android is designed to be compiled with GNU LibC and GNU Make [requirements]. There's a certain alignment between Java Development Kit (JDK) versions and Android versions, moreover

Android OS Version(s) JDK Version
"Cupcake" .. "Froyo" JDK Release 5
"Gingerbread" .. "Kitkat" JDK Release 6
"Jellybean" .. JDK Release 7

The Android Open Source Project (AOSP) applies Git as a software change and configuration management tool. Thus, the AOSP source code repositories may be presented as changeset management repositories -- of which, there are no few [android Git repositories]

As though in a manner similar to the Google Chromium project, the Google Android Open Source Project applies -- as extending of the Git changeset model -- a custom development tool, named repo.

... a central managing repository of which is represented in the platform/manifest repository of the Google AOSP.

Repo may provide a manner of a service for coordinating Git changeset branches among individual Git repositories published of the Google AOSP. The platform/manifest repository itself is organized with a number of changeset branches and changeset tags, each representing -- no doubt -- a specific application target for the Android platform, as in regards to platform development and software distribution services. The Android Downloading and Building guide, for instance, recommends a branch named 'android-4.0.1_r1', such that -- certainly -- would represent a version 4.0.1 release of the Android operating system, essentially as upstream to any vendor-specific additions to the operating system.

Clearly, a topic of Changeset Management with the Android platform may seem to become to something of a geometric expansion, as with regards to analysis of software repositories, software sources, software destinations, and provenance as in a manner of software platform analysis. So far as that the Repo tool can be applied for accessing Android source code, there is a guide about it online.

Candidly, so, it may not be all of a trivial process to develop a "match" between any single vendor release of the Android operating system, in matching to any single upstream Android open source release -- or, in a logical inverse of such relation, traversing the Android OS distribution chain from any single Android open source release to any number of individual vendor releases.

Beginning with changeset branch 'android-4.0.1_r1' in the AOSP platform/manifest repository [AOSP] ... after a short 'Git clone', perhaps the contents of the repository would then be readily available for expert perusal.

This author will presently take a short break, while mustering up to understand Android.

Monday, September 28, 2015

Android, FreeBSD, and the Golden Ticket Demistyfied

"We don't support FreeBSD officially, so you'll have to run you custom Android Studio built from source."
— [source]
With regards to applying FreeBSD as a desktop operating system, the author of this article may presently endeavor to "Skip ahead" from recounting an initial installation of FreeBSD onto an HP Pavilion PC's EFI architecture -- with a small configuration in the laptop's EFI boot-time processes, FreeBSD boots, more easily so than on the author's own older MBR/BIOS-style laptop. The author is presently running the Cinnamon desktop, augmented with an installation of Microsoft Windows 7 in VirtualBox. Although the Pavilion PC's hardware isn't completely supported in FreeBSD 10.1, but it's sufficient to maintain a usable desktop with FreeBSD -- no clutter, no advertisements, nothing but plain computing with the FreeBSD brand of UNIX.

It's theoretically possible, certainly, to develop a DITA topic repository as for the interest of presenting documentation to FreeBSD users and FreeBSD developers, in a centrally organized manner. Such a topic repository -- it might much resemble a Wiki, in style, though more centrally managed, such as viz a viz FOLDOC -- it might not be a light feat to undertake, however. Of course, there's already the FreeBSD Wiki, the FreeBSD Handbook, and the FreeBSD manual pages, all available as immediate documentation about components of the FreeBSD kernel, the FreeBSD base system, and ports available in FreeBSD. So much as in assuming that a manner of technical documentation may be of some assistance, in developing FreeBSD, the author of this article wishes to assume furthermore that a topic-oriented manner of documentation -- as may be developed onto a DITA format -- may be of some use for developing unambiguous documentation with regards to applications of FreeBSD. Of course, if there may be some disagreements about exact topical labeling and depth of overall content, maybe it would be only a "Paper project," after all.

So, while the author of this article considers that it may be useful to write more documentation about FreeBSD, but the "Central DITA topic repository" model, as an idea, it may not seem as immediately feasible as much as it may seem immediately ideal to an overview of FreeBSD.  Instead, the short and no doubt in-a-populist-light "Odd" notes at this web log may have to be sufficient, for developing so much as a stub of "New" documentation.

What's to denote, "Newly" about the Android operating system? It's an operating system applying a Linux kernel -- different to other UNIX operating systems, and different to even the Linux desktop operating systems, in some ways. The Android Operating System features some components developed by the Google Android project, some of which components are distributed individually in the Google Play Services package for Android. No doubt, Google is the primary commercial institution developing the Android platform, but there is some development support available from individual vendors and developer institutions, furthermore, such as with Samsung.

The Android operating system may be meaningfully contrasted to any number of other mobile operating systems, such a BlackBerry 10 and its QNX baseline, or iOS mobile. The Android operating system, in itself, is not all of the Google Play Android App Store, but certainly there's to one of the primary incentives to develop with Android -- as towards any possibility of developing an income from software development, moreover in software development applied onto the Android platform. Of course, as with many things, a topic of Android development may not stay forever contained of its own definition -- entailing, naturally, concepts such as of build automation, software distribution, and later issue tracking.

The author of this article would not propose to raise a barn about Android, without first denoting that someone shall have to shovel out the stalls -- as in a metaphor onto Farmville, if not a metaphor to actual farming -- albeit, at some risk of trivializing the interactions with Android users, in the metaphor, perhaps moreover a risk of trivializing any nature of farming. Android users being individual persons, there's certainly much that can be said as to how provide effective customer support in the Android marketplace.

It might seem to be of a different kind of  media than of a typical commercial support counter, but -- in being fully aware of the shovel and the stall, so to speak -- it may remain a  manageable endeavor, to provide customer support even to any very demanding customership in the Android marketplace.

One chooses one's metaphors carefully, when choosing a metaphor with a bit of pith to it.

Could it be, then, a glimmer of the much sought after "Golden ticket," that it is possible to develop an Android application on the FreeBSD platform? It  may not be the entry pass to all of Willy Wonka's own private theme park, but perhaps it may be worth a sincere synopsis at least.


[Article Draft Nr. 1]

Outline for Article Drafts Nr 2+ : Resources
  • Library (Literal)
    • Safari Books Online [www] (fee-based service)
    • Google
  • Baseline Support
    • Java [info]
    • Linux Emulation [info]
    • USB [info]
    • If YouTrack: 
      • HTTP Server - Apache HTTPD, Nginx, or other
      • Java Servlet Engine - Tomcat, Jetty, or other
  • Android Developer Tools
    • ADB [port]
    • Fastboot [info] [port]
    • Simpleperf [port]
    • Android SDK [patch]
      • Bundled with Android Studio
      • Available separately for ADT and other toolchain applications
    • Android NDK [?]
      • May not be needed for all Android development projects
      • Linux emulation (?)
    • Vendor-Specific Developer Support - Android Developers
  • Documentation Tools
    • Emacs
    • DITA Open Toolkit
    • DocBook
  • IDE Integration for Android Development
    • Android Studio
      • See also: Android SDK
    • Android Developer Tools (ADT) and Eclipse IDE
      • See also: Android SDK 
    • Emacs (??????)
  • Android Emulators
  • Build Automation
  • Network DevOps
    • Code Signing and Distribution
    • Continuous Integration
      • Jenkins
      • Travis CI
      • ...
    • Change Management
      • Git
      • SVN

Sunday, September 27, 2015

Concerning Android App Identities as Represented in the Android OS

One of the challenges facing the development of an integrated bibliography system on the Android platform, simply, arrives of the Android OS' app UID/GID model, moreover Android's application of the Linux filesystems permission model – in any ways augmented, as some documentation may denote, augmented with a mandatory access control (MAC) application extending of SE Linux, in light of the albeit not formally adopted POSIX 1003.1e i.e "POSIX 1e" draft, in Android KitKat and other Android release branches. POSIX 1e finds application in Linux, furthermore, with the Linux process capabilities implementation. Analogously, in the FreeBSD operating system, POSIX 1e find application in the FreeBSD MAC implementation and in the Capsicum implementation.

Not as if to abjectly criticize the Google Android project – the app/filesystem permissions model in KitKat being of some notable inconvenience for file storage to SD card media, in Android platforms – there is probably a logic to the changes made with regards to these features, in Android 4 i.e "Kit Kat" and other Android release branches. (Ed note: cf. Android Content Providers [AndrDeveloperST])  Whatever ways in which the MAC model may be involved in the issue, it may seem to center primarily about app UID specification – the issue of the inonvenience for platform users, as with regards to files that must be accessed with multiple Android apps on a single Android appliance – whether or not specifically to access files stored on external SD card media, logically an orthogonal concern, orthogonal to the permissions model of a Google certified Android appliance's own on-device storage meda, there with further orthogonal reference to filesystem types (bibliography on file).

On the Android platform, app UID and GID is computed at time of app installation[AndrDeveloper]. App UID and GID information on the Android platform is not stored in the common text and shadow files under the /etc directory – common insomuch as with regards to UNIX platforms applying a POSIX and X/Open model. Rather, in one regards, UID and GID information is stored – on the Android platform – as with reference to an 'acct/uid' directory[BD2015]. (Ed. note: See also, the GET_ACCOUNTS manifest permission [AndrAPI_Mperm])


From a developer's perspective, there are application settings available for sharing an app's identity with an existing app, inasmuch as with regards to the sharedUserID attribute [AndrDeveloperPerms] of a single app's APK manifest description. The corresponding sharedUserLabel APK manifest field, moreover, allows for human-readable labeling of apps' shared user ID[AndrAPI_R], Albeit, the sharedUserLabel may be applied to an ambiguous situation – as with regards to that a sharedUserLabel may be specified in one app's APK manifest, but would be applied for a UID shared among multiple apps. This article will not further investigate how the Android OS may establish a systematic precedence to shared user labels, as in a conflict of differring sharedUserLabel specifications for a single sharedUserID.

In addition to the sharedUserID APK manifest attribute, the Android API defines a permissionGroup object type [AndrAPI_R], corresonding to a 'permission-group' tag as may be specified in an Android APK manifest file[AndrAPI_RStyleable]

Referring to the reference documentation about these multiply-linked OS features, in Android, it seems there is an Account Service in the Android OS, specifically referencing the GET_ACCOUNTS manifest permission [AndrAPI_Mperm] – perhaps an elusive feature of the Android Operating System, the Android OS Account Service.

There is  inquiry of a topic as with regards to storage of user account information on the Android platform. [OvOp2015]  Probably, the Android OS Account Service may be a topic of a commonly linked reference, as with regards to APK principal peer identity, and UID and GID values computed at time of APK install.
(Ed. Note: Or not. On further study, it seems that the Android Account Service is rather a service for managing a user's web account information, centrally, on any single Android appliance.)

Perhaps this study may be extended of, as with regards to applying Kerberos as a neteork peer authentication service on Android appliances. There is some of an existing work, with regards to implementing Kerberos services on the Android platform (bibliography on file), though perhaps nothing immediately about whether or not a network admin should allow authentication to a network service, e.g SSH, with a Kerberos ticket from a thin client appliance – an orthogonal topic, certainly. For web apps, of course there's OAuth/OAuth2.

 [Article Draft Nr. 2]

Webliography

Friday, May 8, 2015

Notes - Bibliography and Reference - Android Platform

Android Apps - Bibliography Databases

• Eratosthenes
• RefMe
• EasyBib
• Pearson Writer app

Android Apps - Writing - Web Logs - Blogger

• Blogger app
• Blogaway app

Android Apps - Writing - Social Networking

• Tweetcaster Pro
• Google+ app
• Facebook app
• Tapatalk app

Android Apps - Writing - Office Documents

• Documents to Go
• Google Docs
• Hancom Office 2004
• AndrOpenOffice

Android Apps - eBooks - eBook Readers

• Adobe Acrobat app
• MoonReader+
• CoolReader
• Kindle app
• Kindle app for Samsung Mobile
• Kobo app
• Nook app

Android Apps - Academic Resources - Content Portals

• OpenStax CNX
• [No off. Mendeley app]
• [No off. ResearchGate app]
• Archivist app
• ACM Digital Library app

Android Apps - Distributed Learning Networks - School Portals

• DeVry app
• UDemy app
• Coursera app
• APUS app


Tuesday, April 21, 2015

Hardpan Technologies and the Ex Libris Model – Bookshelf Concept and Service Architecture Design – Overview

Corresponding to development of the Hardpan Technologies web log ('blog), I would like to begin making some formal, public notes as with regards to a design not for a patent insomuch as it is a design for a bibliographical content management system. Today, I would wish to extend of that same design with a set of features for support of book sales – and that, without offending the sensitivities of libraries as institutions. So, a capital idea and a wave to the socialized state aside, the thing would focus on JCR and CORBA, firstly for data structures and personal content access, secondly for data services as may be provided on a heterogenous network medium of no too simple authenticity.
So, the initial server component would be implemented in Java, and the first service client toolkit may as well be implemented in Java, also. The server, in this design, would use ModeShape – nothing too specific in the data serialization layer, howrver. The server and the client would both use JacORB, and – ideally – the hosting operating system's Kerberos support, X.509 certificate model, and user interface.
It being implemented in Java, the first client application may not be available on iOS platforms. The intermediary IDL interfaces, however, could as well be implemented in C# for iOS platforms, and OS X platforms, and the desktop. Perhaps there's a port of Cocoatron for Android, too. The author is rather more immediately familiar with Java(r) toolchains, however, and the author does not have access to a normal XCode installation. So, initially, it will be implemented in the Java programming language, for Linux and FreeBSD servers and for Android mobile operating systems.
The author may or may not publish the Android app, at the Android app store. Initially, it will be installable for Android platforms, in application of the Android Studio IDE. "All smiles" for the newest innovations in development of the Gradle DSL for Android Studio applications, and the inevitable (?) Gradle-Ant and Gradle-Maven adapters, if one should wish to search around for such adaptive technology.
There's the architecture of it. It needs a name, too, and I have a name for it: Ex Libris, under the Hardpan label. Unique, huh? In that quality, it extends likewise of a design of a small model for access to, and user-unique creation and annotation of automotive notebooks in a user's own digital data model, in a manner ostensibly extensible for whole automotive crews, in applying CORBA, FreeBSD, Android, OBD-II libs, and the BeagleBone Black platform as a "Shop appliance" with a suitably stylish and functionally sturdy enclosure. No patent pending of this design, here licensed CC BY-SA 3.0.
Ex Libris, in its bookshelf features - no too long nod for BibTeX in Java.
Further design TBD.
Donate Bitcoins

Wednesday, January 28, 2015

Towards LabVIEW and GCC, or not? Introduction to the eSym Project

Considering the availability of LVH LINX -- originally, LIFA -- as an extension module available for programming Arduino and other microcontroller boards from the National Instruments LabVIEW platform, my first thought is to wonder what defines the toolchain in LIFA.

Comparatively, the NI LabVIEW Embedded Module for ARM Microcontrollers extension (footnote: device support) uses the commercially licensed Kiel uVision compiler. Personally, as a student of DeVry University Online, I've received a one year license for uVision, complimentary with the LabVIEW 2010 and LabVIEW for ARM bundle that we're using for some very simple device programming projects, in a few of the courses. That license will expire in roughly one year's time. If I will begin programming for embedded platforms with LabVIEW, I would like to be sure that there would be some longevity to the toolkit I would be using.

I wonder, Does LINX use GCC, alternately?

In a rough summary of procedures with the LabVIEW programming kit for ARM: When a LabVIEW project is compiled with that kit, clearly LabVIEW performs a translation into C code, then compiles that to machine code, then programs the device with the resulting application. Certainly, the similar could be done with GCC and other free/open source software (FOSS) tools.

Concerning the hypothetical GCC-based procedure for application building and device programming, the "FOSS alternative" could simply apply GNU Make, or even  Gradle, all within a conventional FOSS toolchain. The same toolchain could use uClibc as an alternative to GNU LibC, perhaps minimizing the space requirements for applications compiled with the toolchain. Insofar as that much of the toolchain, itself, would be comprised of free/open source software components -- those, all compatible with the Debian Free Software Guidelines (DFSG) -- it might serve to provide something of an available platform for programming with LabVIEW. Of course, LabVIEW itself  is a commercially licensed product.

What would be the incentive for developing a free/open source data flow programming language, alternately? Without making a "too lengthy" dissertation in this article, the hypothetical FOSS data flow programming language could serve to provide a convenient, desktop interface for data-oriented programming -- in that much, perhaps very similar to LabVIEW -- without the commercial overhead of a commercially licensed product such as LabVIEW.

Would it be enough: Simply to climb the mountain because it is there?

What additional features could be provided in a data flow programming language and toolchain licensed as FOSS -- beside any features implicitly available of a software product produced with a FOSS licensing model, such as instant availability and low commercial overhead? Some thoughts, to matters that may be relatively simple to set as goals, at least:
  • If the hypothetical data flow programming toolchain would be developed on a platform supporting ARM microcontrollers as well as Intel microcontrollers, and if that platform would be functionally applicable in a Linux operating system, then -- in short terms -- it could as easily be ported to the Android platform.
  • If a data flow programming language -- as a feature of the hypothetical data flow programming toolchain -- could be implemented with a corresponding metamodel onto the Metaobject Framework (MOF), then a corresponding model transformation framework could be developed. The model transformation framework could implement QVT, as for a purpose of transforming a program model -- such that would be developed in the same data flow programming language -- into a program model in any single language supported with the corresponding QVT transform. 
  • If the data flow programming model would be implemented with a binding onto Common Lisp:
    • A corresponding visual model could be implemented with CLIM, for visual representation of elements in the data flow programming model
    • Insofar as that the data flow programming model may be implemented towards a deterministic timing, for programs as would be produced in any single compiler toolchain, it would serve to provide an opportunity for developing a number of ideal "Use case" scenarios, towards models for deterministic timing in developing Common Lisp software programs for realtime systems.
    • In utilizing the Common Lisp Object System (CLOS), the Common Lisp binding for the data flow programming model could be developed as not only to extend CLIM, but also -- in another facet -- as to extend a hypothetical implementation of MOF in Common Lisp, in implementing the corresponding program metamodel
      • If the data flow programming model would be implemented consistently as an expression of the hypothetical data flow programming metamodel, then any programs developed in that programming model could be easily serialized for storage, using the XMI binding for MOF.
      • If accompanied with a corresponding QVT implementation -- viz a viz QVTo --  any model developed under the programming metamodel, ideally, could be transformed into any single target platform programming language, so long as a QVT transform would be implemented for the latter.
  • With sufficient application of magic beans, it could even become a glorious beanstalk.

Sometime around when the author of this article was first beginning an acquaintance with LabVIEW, the eSym project was created. The main driving intention in the eSym project was to develop a data flow programming model in Common Lisp. 

At this time, the codebase for the eSym project is in no normative state. The project has been stalled around some orthogonal design issues, such as for developing a modal locking model for thread-safe slot value access onto the Common :Lisp Object System --- most likely, as to apply cl-async via green-threads, in an extension onto the Common Lisp Metaobject Protocol (MOP), Furthermore, the author's own attention has been directed towards the possibility of developing a Common Lisp programming framework onto the Android platform -- such that may need a substantial integration between Android Studio and/or the Android Developer Tools (ADT) and any single Common Lisp implementation supported on the ARM platform, viz a viz SBCL and CCL, in Common Lisp implementations compiling to machine code, as well as ABCL, which compiles to Java bytecode and might therefore integrate more easily with the Android programming environment, overall.

The prospective "Common Lisp on Android" project would represent a subsantial divergence, orthogonal to further development of the eSym source tree. 

Sunday, January 11, 2015

In a View of a Software Project as a Tree-Like Structure: Towards Memory Locking and Memory Access Control in Common Lisp Programs

On beginning a study of National Instruments' LabVIEW programming platform, last year -- that, as was contingent on being a student of a sort of vocationally-focused introductory program in computing, networking, and the electrical sciences, a program hosted by a certain online university -- the author if this article has begun studying a broader concept of data flow programming. Contingent with that study -- not as if try to trump-up any competition towards National Instruments (NI) but rather towards a broader academic study of data flow programming -- the author has been developing an expression of a concept of data flow programming, in Common Lisp.

The author would gladly make reference to the source-tree for that item, here, but it may not be in any useful state for applications, presently. The author has been referring to the project as eSym -- as to denote something towards a concept combining of component concept of symbolic logic and a metaphor with regards to electrical current flow.


While developing eSym, the author has discovered a number of complimentary concerns that may be addressed in a Common Lisp program. Those concerns may be addressed before eSym would be any further developed.

The following article presents an outline of those initial concerns, then proceeds to develop some concepts as with regards to a sense of a broader context in development software programs in Common Lisp.

  • An extension may be defined onto the Common Lisp Object System (CLOS) -- at the least, in implementations applying of the Metaobject Protocol (MOP) -- such that the extension would allow for a thread-local modal locking procedure -- and more specifically, a read/write locking procedure -- onto slot values of a Common Lisp standard object.
    • This, in turn, may be implemented onto a portable interface for modal locking, such that may be developed directly onto Bordeaux Threads (BT), in a platform-agnostic model
      • In parallel to developing a modal locking layer onto Bordeaux Threads, an additional portability interface may be developed onto so many implementation-specific timer interfaces
        • ....such that may then be applied in a revised `BT:WITH-LOCK` then allowing a blocking keyword argument -- the behaviors of which would be fully described in the documentation, but in summary of which: 
          • blocking t : block indefinitely to acquire lock
          • blocking nil : do not block. Rather than returning nil, should signal error of type lock-held if lock is held, such that the calling function could then handle appropriately without storing a return-value from the failed lock acquisition request
          • blocking {integer} : block for a duration specified by {integer}, and if timeout, then signal error of type timeout-exceeded
        • ....and that may then also be applied in a new `WITH-MODAL-LOCK` macro, as well as underlying `ACQUIRE-MODAL-LOCK` function
        • Alternate to Bordeaux Threads:
          • Threading in cl-async [github]
            • Extended with a BT-like interface in Green Threads
            • CPS: Continuation Passing Style [multscheme]
            • In operating systems applying a pthreads threading model, this may provide an interface onto an underlying PThread implementations, as via cl-libevent2 and transitively, libevent
            • libevent provides a platform-agnostic model for development of asynchronous programs onto C
            • As far as a portable timers implementation in recent revisions of cl-async : See also  delay / with-delay (?)
  • The data flow programming language, in its abstract graphical representation, could be implemented as an extension of the abstract graphical syntax and the underlying semantics of the Systems Modeling Language (SysML) ... as SysML being implemented with a metamodel extending of the meta-metamodel defined of the Metobject Framework (MOF).
    • Alternately, a SysML view for the data flow programming language's data flow graphs could be added later.
    • This may extend, indirectly, of de.setf.xml -- with de.setf.xml providing an interface for parsing the XMI schema and the XMI schema then serving to present a structured interface for processing and I/O onto metamodels serialized onto the standard MOF/XMI binding , with any number of vendor-specific conventions in the same.
    • An implementation of the Object Constraint Language (OCL) should be developed as part of the same -- such that may apply the ATN parser, such that is applied in de.setf.xml -- the parser implementation in the OCL implementation therefore remaining aligned with the XML implementation
  • This data flow programming model may  of course be implemented with extensions onto McCLIM, for managing interactions with a data flow programming graph, as via a CLIM application frame.
In parallel to the matter of thread-local slot value locking: While I was developing some notes as with regards to a lock ticket caching framework -- and a more generic object buffering framework -- as to address a question of how a program may provide an interface for controlling access to the slots of  buffered object, such that the buffered objectwould be simultaneously accessible in a buffer cache and from there, accessible in any number of threads of a program, as well as being accessible broadly in the data space of the containing process -- I had developed a question as to how and whether it may be possible to control access to a region of memory. In regards to how that may be approached in software programs developed on the Linux kernel, my question -- as such -- was promptly answered, on discovering the shmget(2) and shmctl(2) manual pages, as well as the useful  shm_overview(7) such that provides an overview of an independent SHM interface providing file descriptors for shared memory segments.  I would denote some additional caveats to this matter, as well:
  • The  shmctl(2) manual page, specifically, describes some of the structural qualities of the following structure types in the Linux programming environment:
    • The C structure type shmid_ds 
      • Application: This type appears to be used for providing information about the Kernel's implementation of the SHM interface. For instance, there are some structure slots for recording of times and process IDs (PIDs), within the shmid_ds structure type
      • The shm_perm slot provides further structure, as denote in the following
    • The C structure type ipc_perm
      • This type uses the key value as applied also with shmget(2)
      • This type also provides a record for UID and GID values as well as flags for access permissions defined onto a shared memory segment
    • Consequent to a further study of the shmctl(2) manual page, it may seem that the shmctl() function is defined for purpose of reflection onto system-wide registers with regards to shared memory allocation
    • An orthogonal question: Onto what platforms other than Linux is the Linux SHM interface considered portable?
      • BSD?
      • QNX?
  • It's not the same as mlock(2)
    • Application: Ideally, there may be a compatibility interface defined between values used in  shmget(2) and similar SHM functions, and values used in mlock(2). Such a compatibility interface may or may not exist, presently, within the body of existing work in free/open source software and systems
    • mlock(2) may be applied in at least two manners of usage case
      • To prevent a memory segment from being paged to disk, as to ensure that data in the memory segment will not be recorded in any permanent medium, namely towards applications in data security
      • To ensure that a segment of memory will not be paged to disk, as towards ensuring a deterministic timing within the calling program, for access onto the same segment of memory -- as towards applications in a realtime operating system (RTOS) environment, such as for embedded computing. As a further reference, to that effect: sched_setscheduler(2)

This outline, of course, does not present a full interface onto SHM in Linux, for any single Common Lisp implementation. The previous outline may serve to develop some further knowledge, towards some questions with regards to memory management, within any single Common Lisp implementation, viz a viz:
  • One  "first question", as towards the origins the previous outline -- more broadly, as towards preventing unwanted access to regions in a program's data space -- in that regards, towards a design for data security within Common Lisp programs. 
    • The question, in short: How can an interface be developed for controlling access to memory registers within a program's data space, in a Common Lisp program on any single operating system platform? 
    • Nothing to compete with the Java programming model, certainly, though Java also defines some controls for data access, at least insofar as with regards to definitions of Java fields and Java methods in Java classes. The author is not presently aware of any similar SHM interfaces in Java.
  • A second question, as contingent around the matter of RTOS applications: 
    • The question, in short: How can memory be locked, within a Common Lisp program -- whether permanently or temporarily -- as to not be shifted in the data space, within garbage collection processes?
      • This is orthogonal to the question: How can memory be locked, within a Common Lisp program, as to not be paged out to the system's page area?
    • The "second question" is notably a naive question, it demonstrating some assumptions as to what side effects a garbage collection (GC) process may produce, within a Common Lisp program. Namely, there is an assumption that an object's object address may change within the duration of a Common Lisp program -- assuming that an object in a Common Lisp program may not be left where originally created within a program's data space, after completion of any single GC iteration.
    • Of course there would be some orthogonal concerns, and perhaps some orthogonal design concepts, for instance:
      • Is it possible to define a specific region of memory as being locked with mlock(2), and such that that region of memory may be used for allocating multiple Lisp objects? 
        • May that serve to provide a methodology for implementing a non-paged memory IO region wtihin a Common Lisp program?
        • May it serve to allow for a tunable efficiency in applications, such that mlock(2) may not need to be applied at every time when a new Lisp object is allocated? 
        • If a shared memory control interface would implemented, in parallel to this feature, of course the shared memory control interface may produce some side effects as with regards to this feature's implementation -- for instance, in that an access-controlled region of memory may be effectively contained within the mlock'd memory region.
      • There may be some additional concerns addressed, as with regards to manual memory management in Common Lisp programs, for instance:
        •  That  if there may be an application in which one cannot simply cons and forget and leave the garbage collector to clean up the memory space for unused objects
        • ...then as well as the implicit memory allocation of creating a new Lisp object
        • ...a Lisp program may provide an interface for manual memory deallocation, thus towards both
          • obviating the burdens for the garbage collector and also 
          • allowing for a deterministic procedure chain, insofar as for memory management within a Common Lisp program
        • This can be implemented with requirement for multithreading.
          • An explicit memory deallocation thread may be implemented
            • ...as to be coordinated in scheduling alongisde the garbage collector
            • ...such that it would be accompanied with rigorous definitions of memory deallocation forms, for ensuring that objects created for "one time use" within a single lexical environment will be explicitly marked as to deallocate when control exits from within the same lexical environment.
            • ...though that would require a storage of a separate "to-deallocate table" essentially separate to reference-counted memory -- lazy references? -- and a methodology for iterating across the same table, perhaps alternate to a methodology of scanning Lisp objects recursively for count of object references and recursively deallocating those denoted only as "not referenced".
            • ...and may be applied with an functional interface, parallel to cl:gc, rather such as foo-mem:prune
            • ...such that an application applying the memory prune function may be exist in parallel to applications not doing such explicit memory deallocation.
            • ...and should be accompanied with a conditions model, such as for when   foo-mem:prune would be applied on any object that would contain, as an n-ary  referenced object, any object that would be known as that it cannot be pruned, for instance any definition of a class defined in the cl package
            • ...and must also be accompanied with a lengthy description of how foo-mem:prune would function on individual objects to be pruned
              • Note: Reference vs definition -- for instance, that a reference to a string is not a string object itself
            • Essentially, this may serve to develop a concept: Memory management for objects referenced within only a single lexical environment
            • Ideally, this should be implemented as to not entail any overhead for "Reference counting".
Certainly, a Common Lisp interface on the SHM features of the Linux kernel may be implemented as a layer onto an interface onto mlock(2) -- and so, the development of the mlock(2) interface could effectively precede the development of the SHM memory control interface. Also clearly, such extrnsions would need to be implemented in all of an implementation-specific manner, as onto the memory management features of any single Common Lisp implementation. This, then, would certainly require much of a detailed study onto those same features, and perhaps an application of the C programming language.

Some further notes in documentation should be forthcoming, to that effect, as may be published in this web log, henceforward. The author proposes to limit the study onto two Common Lisp implementations specifically:
...at such future time as when it may be immediately feasible as to address the following procedural outline into an implementation:
  1. To begin such a study of memory management, on those platforms.
    • Ostensibly, to develop a series of SysML models for describing the conventions applied in memory management on those platforms
      • UML class diagrams for illustrating structures and relations of explicit and inferred data types (e.g. VOPs in CMUCL and SBCL)
      • SysML block diagrams for developing a block/port-oriented view of memory and memory management  in the respective Common Lisp implementation
      • Onto CCL, block diagrams illustrating of qualities of the FFI interface
      • State Charts in SysML for describing memory management in terms of finite state automota
  2. To develop an interface for an  mlock(2) locked region of memory in a program's data space
  3. Implicitly: To develop a Common Lisp interface onto an operating system's underlying authentication and authorization (A2) model
    • To furthermore extend that interface onto the A2 procedures of Kerberos 
  4. To develop an interface for an SHM controlled access to memory within a program's data sapce
    • To develop such condition types, deubugger features, and other features unto the Common Lisp semantics, such that may serve to simply the programmer's view of the memory access control forms 
If the reader may wish to inquire as to why those two platforms are specified, in this article:
  • Both of those platforms may be applied on an ARM microprocessor architecture
    • ARM, in turn, is applied within a number of embedded computing platforms, including mobile phones
  • Although there are additional Common Lisp implementations available for the ARM architecture -- including ECL -- it may be feasible to limit the study to, essentially: 
    • One implementation of or deriving from CMUCL, as with SBCL at the original "Point of fork"
      • This should be approached with an observation about signals, interrupts, and foreign threads in SBCL -- as denoted as being problematic for an interface onto a Java Virtual Machine, at the web site for CL+J 
      • This should be approached, also, with an observation as with regards to the newer thruption model in SBCL, and related features defined in recent editions of SBCL
    • One implementation deriving its implementation more broadly from LibC, as with CCL and its own respective foreign functions interface
      • This may be approached with consideration: 
        • That the Linux Kernel is implemented in C
        • That the fundamental interfaces to the Linux Kernel are provided as for C programs
        • That the FFI model developed in CCL may applied in a prototype fork for and towards applying such extended memory management procedures as denoted in the previous outlines in this article
Of course, it would be impractical to assume as if an extension could be addressed instantaneously onto two separate Common Lisp implementations, if only a single developer is developing the same extension. At this point in the article, the author arrives at a point of decision as to which Common Lisp implementation the author would wish to focus on, first, if to develop such an extension. That question, then, may be pushed further down the effective stack, with a couple of corresponding questions:
  • How may a mobile application development model be developed in free/open source software, for supporting development of mobile applications and desktop applications with Common Lisp?
    • How may CLIM be applied within such a model for mobile application development in a free/open source regards?
    • How may that be extended, furthermore, in applications of "new" embedded computing models, such as may apply the BeagleBone Black platform, Gumstix, or any other single-board computing model capable of running a Linux operating system?
  • How easily can CCL or SBCL and McCLIM be installed onto an Android device, for purpose of development testing?
    • How easy would it be to use the CLIM REPL, in such an installation?
    • How many separate concerns may be addressed onto CLIM, as for design of mobile human computer interfaces -- in whatever regards, if as an alternative to conventions developed of popular desktop computing interfaces? 
      • How and how well may CLIM be integrated with an on-screen keyboard, as of a tablet PC or a notebook with touschscreen?
      • Would it not be useful to include a modeline -- even if it would be a 'hidden modeline' of a kind -- onto every single window created, in such an appliation of CLIM? Then how would the 'meta' key be implemented, for key input to such a modeline?
  • How can a commercial interface be developed, onto such work, and it not be limiting towards the free open source nature of the software that would be applied in such work?
    • Sidebar: "Free/open source" does not imply "Insecure"
      • A deterministic model will not be illustrated for that thesis, in this article
    • Sidebar: Incentives?
      • Data-secure computing for small/medium enterprise - referencing strongSwan, Kerberos, and JacORB as providing support for Kerberos and SSL onto CORBA
      • Games programming for mobile platforms, in Common Lisp? 
        • Can we make it look more like Half Life? Should we?
        • What about music?
          • What about folk music?
        • What about educational applications developed albeit with a novel game-like interface but lending towards any actual, fundamental concepts in mathematics, if not also towards the material sciences?
          • What wonders may await, in the literary works of Charles Babbage?
          • What wonders, in a view providing of an implicit sense of gender neutrality, if not a broader sense of cultural neutrality, with regards to mathematics and science? barring any discussions lending immediately to a maturity of nature.
      • Furtherance of concepts in the state of the art?
        • IDE development in the heterogenous systems programming environment
          • Towards implications for the software development environments in applications of virtualizaiton and software-defined networking (SDN)
          • "Because CORBA"
      • Beginnings of discussion with regards to community support, if not for further commercial support for Common Lisp  applications on mobile platforms?
        •  "There's the kicker"
        • Existing services for issue support may include:
        • May entail some platform-specific focus about Linux
          • The following mobile platforms implement Linux:
          • Focusing on the Android platform, specifically, there may be an interface available for bug tracking onto any single Anrdoid app store (TBD)
        • Questions with regards to tools
          • A hypothetical model for capturing results of an application error: Fork, save diagnostic data-optionally save entire Lisp image, and debug on 'Own hardware"
            • Revisions for "Other users" : Do not save session-local data within diagnostics; Do not save Lisp image; ensure full authorization and authentication with upstream issue tracking agency, in network transactions transmitting of diagnostic information
          • Debugger hook : How to apply that usefully on a mobile platform?
            • Usage Case - Developer's mobile platform
              • Context: Prototyping and testing
              • Context: Unexpected situation in program
            • Usage Case - User's mobile platform
              • Context: Regular application procedures
              • Context: Unexpected situation in program
          • Debugger hook   How to apply that  usefully, for server diagnostics?
          • Data models : How to "flag" session-local data values, so as to prevent their printing or storage onto media outside of environment of a running Common Lisp program?
          • Systems models : How to securely and conveniently (?) encrypt a saved Lisp image?
            • Further implications onto design and development of digital platform operating systems?
          • How to integrate developer tools, in a novel manner, with Xen? 
            • cf. Xen Dom0 
              • Emulator as Dom1 instance
              • Xen must be (?) installed directly on platform hardware
              • Orthogonal to: Microkernel design.
            • cf. Amazon Web Services
              • Application of Xen
To this point in the article , the article has diverged from the original topic of developing a data flow programming model in Common Lisp.  Figuratively, the eSym project might represent some figurative icing on the figurative concha otherwise described in this article. The majority of such tasks as would entail an extension of interfaces onto the Linux kernel -- as addressed in this article, albeit superficially -- those might be approached albeit without a cup full of sugared bread, but with a substantial portion of documentation regardless.

This article has described a substantial number of individual concepts and related task items, such that may be addressed into development of an essentially arbitrary number of source trees.

This is developed under the MetaCommunity project, towards a further goal of developing a comprehensive architecture for application development in Common Lisp, and an orthogonal goal of reviving the design of MIT CADR for application onto contemporary microprocessor architectures, denoted as the CIIDR project.

Monday, November 10, 2014

Developing with Android: Platform Selection - A Non-Exhaustive List of Resources


A Short Survey of Resources for Application Development with the Android Platform
  • Software Development Platforms
    • Eclipse IDE
    • Android Development Kit (ADK)
      • Alternatives: 
        • Bundle of SDK Tools and Eclipse IDE
        • Stand-Alone SDK Tools Distribution
    • Intel XDK
      • Provides an IDE supporting development of web-based mobile applications
        • HTML5
        • Cascading Stylesheets
        • jQuery for mobile
        • AJAX, REST, etc
      • Supports distribution to multiple user platforms, including Android and iOS mobile devices, Amazon Kindle and Barnes and Noble Nook eReaders, and desktop platforms including Chrome, Firefox, and FaceBook
      • Provides an effective testing platform for on-device application testing, via Intel®  App Preview
    • Android NDK
      • Supporting application development in C, C++ programming languages, on Linux, OS X, and Microsoft Windows development platforms
      • Example application: Building Qt/Android on Windows
  • Documentation (including)
    • Installation and Configuration
    • Distribution
      • Android. Supporting Different Platform Versions
        • The "top three" Android platform editions as listed at the Dashboards page, presently, are:
          1. "Jelly Bean" (i.e. 4.1.x) est. proportion 51%
          2. "KitKat" (i.e. 4.4) est. proportion 30.2%
          3. "Gingerbread" (i.e. 2.3.3-2.3.7),  est. proportion 9.8%
          4. Not listed: Android platform version 5.0 
      • Android. Supporting Multiple Screens 
        • With reference to: Screen geometry
        • Provides an explanation to terms applied in the Dashboards page as with regards to generalized screen pixel densities (DPI) and generalized screen geometries
        • The "Top three" leading screen geometries, going by the table at the Dashboards page, would be all three at range of resolution [470x320640x480 ) with screen pixel densities in range, from first to third most popular:
          • [240, 320dpi 
          • [320, 480) dpi 
          • [480, 640) dpi
      • Android. Dashboards
        • Page provides a sort of statistical overview about number of Android devices as calculated per each Android edition.
        • Android. Developer Console
          • Topics include:
            • Configuration details for store listing page
            • Procedures for entering an application into an opt-in Alpha testing or Beta testing program, coordinated with Google Groups
            • Some details with regards to pricing and in-app sales for Android applications 
            • Some notes with regards to capabilities targeting, as with regards to specific hardware/software features provided with any functional qualities, in an APK bundled application
  • Hardware (optional)
  • Usage Notes
#YMMV

Saturday, November 1, 2014

Research Note: KDE on Mobile

One evening, when endeavoring to develop an idea of what I might be able to expect if I was to transition from an iPhone to an Android Phone, I had read that the default email application on the Anrdoid OS is lacking some features [Purty2011]. More recently, on reading about the Season of KDE 2014 Student Programs, I found myself inquiring of whether there may be any projects for implementing the KDE PIM suite -- as would be, instead of on a Linux desktop -- on a mobile phone platform, in so many human-computer interface revisions and architecture revisions as might be developed of such a port for the KDE PIM applications.

On researching my own question, I found a few projects. One of those projects, Plasma Activehas implemented Kontact on a mobile platform [PlasmaActive]. Another of those projects, Mer Project, represents an architecture for Qt applications on a mobile platform. [MerProject]

One might observe, candidly, that at this time, neither project project has published a list of vendors implementing their respective platforms. Perhaps, one might think it could seem hopeful, in a sense, regardless.

Insofar as whether the Mer Project may be anyhow forked, perhaps, to be extended and/or revised for implementation onto a baseline Anrdoid operating system -- considering Anrdoid's broad support base, both in vendor implementations and in software development projects, in the consumer market, -- globally so, as that even Rostec's YotaPhone runs Anrdoid [Martin2014] -- perhaps it may be fortuitous, to focus on the Anrdoid platform as it being an existing, by in large open platform for mobile devices. Android, after all, is based on the Linux kernel. [Lynch2013] certainly insofar as would be extended by Google, in development of the baseline Android platform -- but insofar as to fork the Mer Project? If one has only read about the Mer project, this weekend, and one has not a really well-developed object model, in place, for application of C and C++ toolchains, one might wonder if perhaps it may be worth a short note, however, as with regards to KDE on Mobile.

Thus, here's a research note, in such technical regards.


[Purty2011] Purdy, Kevin. K-9 Mail is What Anrdoid's IMAP Email App Should Be. Lifehacker. 2011
[KDECommunity2014] KDE Community. Season of KDE deadlines extended!. Twitter stream object.
[PlasmaActive] Plasma Active. Plasma Active. web site.
[MerProject] Mer Project. Mer Project. web site.
[Martin2014] Martin, Chris. YotaPhone 2 hands-on review: Dual-screen Android smartphone gets better. Tech Advisor. 2014
[Lynch2013] Lynch, Jim. Is Android really a Linux distribution? IT World. 2014