Proactive User Interface

Introduction

As discussed in the previous post “How to Measure User Interface Efficiency“, I stated that it is easy to create a User Experience Design (UXD) or Interaction Design (IxD) interface that can minimize the cognitive and manipulative load in executing a specific task.  This interface must be usable in the three most used interaction modes: graphical, voice, and text.

Author: Josef Betancourt

CR Categories:  H.5.2 [User Interfaces]: Input devices and strategies — Interaction styles ;

Here is a draft of what I’m thinking about this.

Problem

Let’s review the problem.  A user desires some action X.  To trigger X, there must be one or many sub-steps that supply the information or trigger sub processes so that X can be successful.   X can be anything, an ATM transaction, insurance forms on a website, or sharing a web page.  Let’s use the last example for a concrete discussion.

On my Android phone (Samsung Galaxy Note) when I am viewing a web page, I can share it by:

  1. Click the menu button
  2. View the resulting menu
  3. Find “Share page”
  4. Click “Share page”
  5. Get a menu “Share via”
  6. Find “Messaging”
  7. Can’t find it
  8. Scroll menu down
  9. Find it
  10. Click “Messaging”
  11. Get Message app, ‘Enter recipient’
  12. Click Contact button
  13. Get ‘Select a contact’ app
  14. Click ‘Favorites’ button
  15. Search for who you want to sent to
  16. Scroll
  17. Put check box on contact’s row
  18. Click ‘Done’ button.
  19. Get back to Message app
  20. Click ‘Send’ button

And, that is just a high level view.  Note that, of course, systems can use recently used lists or search to reduce the complexity. If you include the decision making going on, the list is much greater.  Other phones will have similar task steps, hopefully much shorter, that is not the point.  The interaction diagram is shown in figure 1.   TODO: show interaction diagram.

This interaction is very quick and easy.  The fact that is has so many steps is symptomatic of the user interfaces and has many drawbacks.

  • Cognitive load:   Despite all warnings and prohibitions, mobile devices will be used in places they should not be, like cars.  These task manipulations just make things much worse.
  • Effort:   All of these tasks eventually add up to a lot of effort.  Ok, if this is a social effort, but when part of a job not profitable.
  • Accuracy:  The more choices the more possibility of error.  As modern user interfaces are used in more situations this can be a problem.  Does one want to launch a nuke or order lunch?
  • Time:   These tasks add up to much time.
  • Performance:   As we do more multitasking (the good kind), these interactions slow down our performance.  Computer performance is negligible.

Interacting with computer interfaces is just too complex and manipulative.  How can this be made simpler?

Conventional Approaches
In the industry there has been a lot of progress in this area. However, the predominant technique used is the Most Recently Used (MRU) strategy. This is found in task bars, drop down menus, and so forth. Most recently in one Android phone the Share menu item has an image of the last application used to share a resource. The user can click the “share…” and use the subsequent cascading menu or click on the image to reuse that app to share again.

This is an improvement, however, as discussed below, there are further optimizations possible to actually invoking via the selected sharing application.

Solution

Use prior actions to determine current possible actions.  What could be simpler?  In the current scenario, as soon as I select the ‘Share’ option, the system will generate a proposal that is based on historical pass action.  Note this is not just “Most Recently Used” strategy, but also based on context. If I am viewing a web page on cooking and click share, most likely I am targeting a subset of my contacts that I have previously shared “cooking” related pages with.

Now I can just switch to that proposal and with one click accomplish my task.  If the proposal is not quite what I had in mind, I can click on the aspect or detail that is incorrect, or I can continue with my ongoing task selections, and each successive action will enhance the proposal.

The result is that in best case scenario, the task will be completed in two steps versus twenty.  A 90% improvement.  In worse case, the user can continue with the task as usual or modify the proposal.  But, the next time the same task is begun, the generated proposal will be more accurate.

What does a proposal look like?  Dependent on the interaction mode (voice, graphical, gestural, text), the proposal will be presented to the user in the appropriate manner.  Each device or computer will have a different way of doing this which is dependent on the interface/OS.

Let’s look at a textual output.  When I make the first selection, ‘Share’, another panel in the user interface will open, this will present the proposal based on past actions.  If there was no past action with a close enough match, the proposal is presented in stages.  This could be a simplest form:

Proposal example
Figure 2 – simple proposal

Of course, it would look much better and follow the GUI L&F of the host device (Android, iOS, Windows, …). In a responsive design the proposal component would be vertical in a portrait orientation.

The fields on the Proposal will be links to the associated field’s data type: email address, URL, phone, and so forth.  This gives the user a shortcut to invoke the registered application for that data type.  In the above example, if I am not sending to Mary, I just click on her name and enter the contacts application and/or get a list of the most likely person(s) I am sending the web page to (based on web page content, URL, etc.).  Also, if I am not sending an SMS message, when I click something else, like email, the proposal changes accordingly.  When I send email, I am generally sending to a co-worker, for example.

To present an analogy of a similar approach, in Microsoft’s Outlook application one can create rules that control the handling of incoming email.  A rule has many predefined actions in the rule domain specific language (VB code in this case).  See figure 3. Of course, the Outlook rule interface is not proactively driven. You could select the same options a million times and the interface will never change to predict that.

Figure 3 – Outlook rule form

A proposal is an automatically dynamically generated rule whose slots are filled in by probabilities of past action.  That rule is translated into an appropriate Proposal in the current UI mode.  When that rule is triggered, the user agrees with the proposal, the associated apps that perform the desired task are activated.

Implementation

To come up with an idea is easy.  Now how to actually create a Proactive User Interface (PUI)?  One big constraint is size and performance.  On a desktop PC or a laptop this is minor, but on a mobile device this is critical.   Thus, case memory, as in Case-Based Reasoning (CBR), must be small, and the processing should be minimal.   Also, in the case of a web app, how will prior task invocations be stored and accessed by the JavaScript interpreter?

 Proactive Interface

Image created with Dia

Technologies

Potential techniques that could be used are:

  • Machine Learning / AI
  • Behavior Trees (BT)
  • Bayesian Nets (BN)
  • Case-based Reasoning (CBR)
  • Case-base Planning (CBP)
  • Hierarchical Finite State Machines (HFSM)
  • State-Charts
  • Ad-hoc data structure with lookup

History

Predictive interfaces are not a new idea.  A lot of research has gone into its various types and technologies.  Amazingly in popular computing systems, these are no where to be found.

Interestingly, Games are at the forefront of this capability.  To provide the best game play creators have had to use applied Artificial Intelligence techniques and actually make them work, not fodder for academic discussions.

Even Microsoft has had a predictive computing initiative, “Decision Theory & Adaptive Systems Group”, and had efforts like the Lumiere project.  Has anything made it into Windows?  Maybe the ordering of a menu changed based on frequency.

I came up with this idea while using my Samsung Galaxy Note smartphone or “phablet”. Using the same phone I brainstormed the idea. Here is one of the diagrams created using the stylus:

Idea for Proactive User Interface

Similar Posts

Intellectual Properties

There are research and commercial efforts to create and sometimes monetize a Proactive User Interface.

Further Reading

  1. Quick Access in Drive: Using Machine Learning to Save You Time, https://research.googleblog.com/2017/03/quick-access-in-drive-using-machine.html
  2. The Lumiere Project: Bayesian User Modeling for Inferring the Goals and Needs of Software Users“, http://research.microsoft.com/en-us/um/People/horvitz/lumiere.htm
  3. Web based evaluation of proactive user interfaces“, http://atlas.tk.informatik.tu-darmstadt.de/Publications/2008/SchreiberEtAl2008.pdf
  4. Introduction to Behavior Trees“, http://www.altdevblogaday.com/2011/02/24/introduction-to-behavior-trees/
  5. A Comparison between Decision Trees and Markov Models to Support Proactive Interfaces“; Joan De Boeck, Kristof Verpoorten, Kris Luyten, Karin Coninx; Hasselt University, Expertise centre for Digital Media, and transnationale Universiteit Limburg, Wetenschapspark 2, B-3590 Diepenbeek, Belgium; https://lirias.kuleuven.be/bitstream/123456789/339818/1/2007+A+Comparison+between+Decision+Trees+and+
    Markov+Models+to+Support+Proactive+Interfaces+%28MIMIC%29.pdf
  6. Understanding the Second-Generation of Behavior Trees – Game AI“, http://aigamedev.com/insider/tutorial/second-generation-bt/, accessed 10/16/2012.
  7. On-line Case-Based Planning“, http://www.cc.gatech.edu/faculty/ashwin/papers/er-09-08.pdf, Santi Onta˜n´on and Kinshuk Mishra and Neha Sugandh and Ashwin Ram, CCL, Cognitive Computing Lab, Georgia Institute of Technology, Atlanta, GA 30322/0280, USA
  8. Blackboard system, http://en.wikipedia.org/wiki/Blackboard_system
  9. An introduction to Outlook rules“, http://zatz.com/outlookpower/article/an-introduction-to-outlook-rules/
  10. blackboardeventprocessor“, http://code.google.com/p/blackboardeventprocessor/wiki/BlackboardConcepts
  11. Automatically Generating Personalized Adaptive User Interfaces“, http://www.youtube.com/watch?v=ODrE7SodLPs&playnext=1&list=PL7E1AF55BC556E56B&feature=results_video, Krzystof Gajos, Stanford University Human Computer Interaction Seminar (CS547).
  12. Halo Statecharts“, http://gram.cs.mcgill.ca/statecharts/index.php
  13. Decision Making and Knowledge Representation in Halo 3“, http://www.bungie.net/images/Inside/publications/presentations/publicationsdes/engineering/nips07.pdf
  14. Progressive User Interfaces
  15. Eight Principles of Natural User Interfaces

System

  • Dia
  • Phone: Samsung Galaxy Note SGH-I717
  • Android 4.0.4 Ice Cream Sandwich
  • Host: Windows 7 Professional 64bit.
  • PC: AMD quad with 8GB ram.
  • Brain: Belonging to carbon-based life form, Earth, Homo sapiens sapiens.

Dedicating multiprocessors per OS structure

What if instead of multithreading at the application level, we instead dedicate a chip of a multicore processor to a specific OS resource. What kind of OS resource?

A few weeks ago something I’ve been thinking about for a while came back into my thoughts. What if instead of multithreading at the application level, we instead dedicate a chip of a multicore processor to a specific OS resource.

What kind of OS resource? I don’t know. Maybe four processors at ring zero, or at the IO subsystems. We could have application specific cores that are optimized for specific software tasks, just as the new graphic processors are used for APU.

I’m certainly not a system designer and the above is probably pure drivel. Like, how would context switching work and not slow everything down? However, there are possible reasons why perhaps its not.

  • Number of cores will keep growing.
  • GPUs will become more important and powerful.
  • Future applications will be distributed and require advanced resource handling, example, hierarchical robust device systems, like memory handling.
  • Thermal limitations will demand new forms of optimization.
  • AI and robotics applications will reach a tipping point and become ubiquitous, and even more performance will be demanded from computing systems

After thinking about this, I later started seeing articles on internet-on-a-chip, a new way of connecting multicores. Interesting.

Further reading

From Tags To Categories

This is how the internet will wake up. It will create an ontology and it will act. Hopefully, humans are part of a necessary category.

Tags are usually non-hierarchical fine grained descriptors of a resource. They are the opposite of categories which are usually part of a semantic hierarchy. Categories are really old-school, killed by the effectiveness of Search and the expanding mash-up universe.

However, while tags provide rapid access to resources and easier sharing of them, tags do not enrich knowledge. We can see this if we consider knowledge as one of the tiers toward wisdom: data, information, knowledge, wisdom. Tags are data on information, metadata. Categories are information on knowledge.

Since data is used to create information, the data on information, tags, can be harnessed to increase the information on knowledge by the automated creation of categories. We simply create the directed cyclic graphs of tags around resources and detect clusters. The naming of categories come from the resources themselves.

This is how the internet will wake up. It will create an ontology and it will act. Hopefully, humans are part of a necessary category.

Some possible related reading

  1. Ontology on Wikipedia
  2. New Common Tag Format
  3. Semantic Web Use Cases and Case Studies. Case Study: Semantic tags
  4. Ontology is Overrated: Categories, Links, and Tags

State Machine discord as system error detection

It takes three subsystem state machines to create an error adaptive system.

It takes three subsystem state machines to create an error adaptive system.

This morning in the shower I was thinking about my last post on SCXML. What do you use as states in a system? Easy question, but then I thought, sure its internal states of a process, but how does the external “real” come into the picture, via guards? That could get messy in a very complex real world system. So, what if the external system is also modeled as a state machine?

Now we have two state machines, internal system and external system. What is the advantage? Well, each can have a peak into the other or using historical information, compute how the other works. Then if this prediction is not matched, it is an error. That is, if the internal machine is at state x and it knows that the external machine should be at state y at this point, and it is not, it is a system error. What to do?

This is where a third error machine would come into use. The function of this machine is to bring the other two into resonance, reduce the entropy, heat.

Depending on whether the machines are Mealy or Moore based, one would detect errors at particular points, events, transitions, or states.

I remember reading years ago about fault tolerant hardware systems. The minimum components was three; similar.

Hmmm. I don’t know what everything above really means, if anything. 🙂

Tangential subject: State machines, life cycles, etc:

For future thinking …

  • How does a FSM approach differ from a REST architecture.
    Building a RESTful Hypermedia Agent, Part 1
  • On the finite-state machine, a minimal model of mousetraps, ribosomes and the human soul“, Brian Hayes, Scientific American, 1983. Accessed November 6, 2011, at http://bit-player.org/bph-publications/SciAm-1983-12-Hayes-FSA.pdf
  • “Exception Handling Mechanism in Communicating Threads for Java”, Gerald. H. HILDERINK, Communicating Process Architectures 2005;
    Jan Broenink, Herman Roebbers, Johan Sunter, Peter Welch, and David Wood (Eds.), IOS Press, 2005
  • “Self-Healing in Modern Operating Systems”, Michael W. Shapiro, Sun Microsystems, QUEUE December/January 2004-2005.

 


Proactive Agents?

I read a blog post related to the topic I mentioned, “Synergistic Social Agent Network Cloud”. The term Proactive Agents is mentioned by …

I read an interesting blog post related to the topic I previously wrote about: “Synergistic Social Agent Network Cloud“.

The term Proactive Agents is mentioned by Carlos E. Perez, in “Software Development Trends and Predictions for 2011“:

Proactive Agents – For decades people have been forecasting the emergence of digital personal assistants that would actively react to the environment on one’s own behalf. The emergence of always present smart mobile devices and cloud computing shared spaces will be the catalyst for the developing of active agent based computing platforms and frameworks. At present, most computing is merely reactive, that is servicing web requests only on command of a user. Future computing will include a proactive aspect that suggests courses of actions to users. Semantic technologies like Zemanta and OpenCalais provide intelligence to writers by suggesting tags that are relevant to a written document.

Are current social networks, apps, and other mobile devices “proactive” yet?

Further Reading

Java Plain Old Concurrent Object

One possible conclusion is that there is no need for a ‘higher’ level concurrency support in Java or that this should evolve on its own before attempts at standardization are attempted.

Abstract

This blog post reiterates the existing critique of the concurrency support in the Java platform and language: that the low level thread and shared memory features should be improved upon with one or more high-level concurrency frameworks. Some of the competing frameworks are listed, and further references are given.

CR Categories: D1.3 [Concurrent Programming]; D.1.5 [Object-oriented Programming]; D.2.2 [Design Tools and Techniques]: Design Tools and Techniques — Software libraries;D3.2 [Language Classifications]: Concurrent, distributed, and parallel languages;D.3.3 [Language Constructs and Features]: Concurrent programming structures;

Keywords and Phrases: concurrency, Java, Actor Model, threads, Component based software engineering, Concurrent object-oriented programming, Distributed systems, Java CSP, CCS, multiprocessor

This is an excerpt from a document I wrote about three years ago.  The doc was in a Java Specification Request (JSR) format and from time to time I updated the link section as I came upon interesting references.   Maybe someone will find it interesting or it will spark a new idea for a project. In a later post I give some examples of concurrent code using the Groovy language.

Intro

The Java Platform has built-in support for concurrent programming. At the time of Java’s birth this was very big deal. But, is it now time to build upon this by the creation of a requirements document for high-level concurrency support in the Java language? Could this bring Java closer to a Concurrent Object-Oriented Language (COOL)?

Well, since I’m not a concurrency subject matter expert, just a working stiff developer, I will leave that to others, and just put my two cents here. What prompted me even looking into this subject was my experience on a few projects that required concurrency support.

What is needed is a survey or summary of what exactly are the issues, what is available, what their application areas are, and what are the development options. Some of initial tasks I see, in no particular order, are:

  • State the problem and application scope.
  • Provide use-cases.
  • Create project
    • wiki, forums, etc.
    • conference
  • Limit the scope of the effort.
  • Identify solution categories.
  • Identify solution selection criteria.
  • Testing and management requirements.
  • Measures, such as Performance and scalability.
  • Tools.

One possible conclusion is that there is no need for a ‘higher’ level concurrency support in Java or that this should evolve on its own before attempts at standardization are attempted.

Problem

One thing has been left out of the OO frenzy is the concept of a process. There are two manifestations of this: Methodology and Concurrency. In the methodological realm, ‘process’, which was part of data-flow analysis, is practically missing from modern analysis (as typified by OOP/UML derived methods). And even now, modular approaches, are still divorced from concurrency concerns. For example, OSGi fortunately brings back modularity to the Java environment. As stated by Kriens:

“Why is modular important? Well, if there is one consistent lesson in all our technology trends over the past 50 years then it is high cohesion and low coupling. Structured programming advocated this; OO forgot it for some time ….” — Peter Kriens, http://forum.springframework.org/showpost.php?p=138459&postcount=2

Yet, even in OSGi, a module is still at the mercy of unconstrained concurrency effects:

“OSGi … does not provide a thread of execution to each bundle. Events are delivered to bundles through certain interfaces, but no guarantees are made about which thread event delivery occurs on. Generally, event callbacks are required to finish quickly and should not make calls back into the OSGi framework to avoid possible deadlock. It is common, therefore, for bundles to start one or more threads in order to get work done.” — Oliver Goldman, “Multithreading, Java, & OSGi”

Welch calls this “unconstrained OO”:

“In unconstrained OO, threads and objects are orthogonal notions — sometimes dangerously competitive. Threads have no internal structure and can cross object boundaries in spaghetti-like trails that relate objects together in a way that has little correspondence to the original OO design. ” – Peter H. Welch in Javadocs for jcsp.lang.CSProcess of the JCSP library

And, others give similar critiques:

All object methods have to be invoked directly (or indirectly) by an external thread of control – they have to be caller-oriented (a somewhat curious property of so-called object oriented systems). — P.H Welsh (“Process Oriented Design for Java: Concurrency for All”)

“In standard OO, if you hold a reference to friend, and you wish to invoke the borrowMoney() method, then the call friend.borrowMoney() is executed in your own thread of control, not in a separate thread (or in friend’s thread), thus breaking all similarity to the way the real world works.” — (Oprean and Pederson, 2008).

“Although the development of parallel languages began around 1972, it did not stop here. Today we have three major communication paradigms: monitors, remote procedures, and message passing. Any one of them would have been a vast improvement over Java’s insecure variant of shared classes. As it is, Java ignores the last twenty-five years of research in parallel languages.”
— JAVA’S INSECURE PARALLELISM by Per Brinch Hansen (1999)

“However, I think Java needs to change. When it was first released, its number one competitor was C++, and Java walked all over it in terms of support for concurrency. Threads in the standard library! Syntactic support for critical blocks! Implicit locks in every object! Now, Java’s number one competitor is C#, which is increasingly starting to look like a functional language. Also languages like Erlang and Haskell have concurrency primitives that walk all over Java’s (I particularly love Haskell’s composable memory transactions). I hope this is something that is addressed in Java 7, but I fear it won’t be…” — Neil Bartlett

A higher level concurrency support in Java will allow a more approachable use of concurrent development. Though the concurrency implementation in Java is a vast improvment over what was available in a popular language at the time, we are now seeing more interests in other approaches as shown in Scala, Erlang, Kilim, Akka, GPars, Haskell, and others.

A standard would then allow, within reason, the sharing of development expertise and common patterns and idioms among the different languages and frameworks. For example, could an Actor in Scala be behaviorially the same as an Actor in plain old Java?

We are also seeing multiple processor cores being used to continue the improvment in thruput since thermal and process limititions have reduced growth. These will also allow true parallism. A high-end actual product, Sparc T3, the Sun Microelectronics version of the chip multi-threaded (CMT) processor, will be capable of forming a quad core SOC (System on Chip) that offers 512 hardware threads. Even on personal desktop systems, we already have quad cores and soon hexacores will be commonplace in the high end, such as the Intel Nehalem-EX. (Note that concurrency and parallelism are not the same thing).

Update: This was written a while back. In the interim, Oracle bought Sun and in the process canceled the Rock high-end CMT based processor design. Yet, Oracle said they will continue to support the upcoming SPARC CMT versions. Interesting discussion is found here. Intel and AMD have not stood still. AMD, for example, is promising a 16 core “Interlagos” chip soon. On the mobile side, ARM and others are also producing multicore systems.

Plain Old Concurrent Component

Instead of just reusing existing terms, I can call this new concurrency support a Concurrent Component. A component is more similar to an OS process, whereas internally it may incorporate light weight threads.

A possible conceptual view of a Component or Plain Old Concurrent Object (POCO) is shown in figure 1 below . Note that this is intentionally reminiscent of a Programmable Logic Device (PLD) block diagram. Each block is an optional ‘concern’ that crosscuts each object that is part of the component. The nested objects can share state and optionally will execute within a fine-grain concurrency kernel. The external control communication is via interfaces that expose the Component API, whereas the actual messaging embeds the application API that the component instantiation provides. This is somewhat of the flavor of Cox’s Software IC concept (ref?). This is also similar to various old Microsoft COM models. In future, it’s even conceivable that each POCO could have its own core assigned in an dynamically created application specific multicore processor implemented in nanoprocessor FPGA.

And, yes the diagram is just my brain’s core dump on the subject. Would require more work to explore this further, and determine what would really make sense.

POCO
Concurrent Component

Why isn’t this need met by existing specifications?

Currently, developers can use the concurrency control constructs that are provided in the Java language itself. Many experts consider these too low level for some applications and for use by the average developer (in terms of development effort, correctness, and failure potentials):

Use Erlang-Style Concurrency. The Java concurrency primitives like locks and synchronized have been proven to be too low level and often to hard to use. There are better ways to write concurrent code. Erlang Style concurrency is one of them – in Java there are many ways to achive this in Java – I’ve written about them here. Newer ones are Akka and Actorom. You can also use Join/Fork or the myriad of data structures in java.util.concurrent. —- Stephan Schmidt in Go Ahead: Next Generation Java Programming Style

In Java 5 and above one uses the new java.util.concurrent utilities. These offer a powerful and relatively accessible API such as the Executor and the Fork/Join frameworks. However, though the latter were a significant improvement, their use still require advanced skills and really only offer the means to create application specific or JVM language based concurrency frameworks.

Even with concurrency updates in Java 6 and Java 7, the Java language doesn’t make parallel programming particularly easy. Java threads, synchronized blocks, wait/ notify, and the java.util.concurrent package all have their place, but Java developers pressed to meet the capacity of multi-core systems are turning to techniques pioneered in other languages.

— “A Java actor library for parallel execution

Some languages or libraries, such as Scala (?) and JCSP even use the underlying concurrency support in Java to create the respective ‘active’ object concurrency extensions. See for instance this presentation by Doug Lea, “Engineering Fine-Grained Parallelism Support for Java 7”.

Note that introducing a higher level of abstraction will not necessarily reduce the need for skilled engineering. In fact, it may increase that need until the patterns, methodologies, measurement, and tool sets catch up and support the new framework. Of course, many other concerns are important, such as performance.

Underlying technology or technologies:

There is a rich history in both industrial and academic research into the theory and practices of concurrency. In the fifty plus years of this, surely there must be more that can be used in Java then Monitors, semaphores and other low level tools.

Some examples are Communicating Sequential Processes (CSP), Calculus of communicating systems (CCS), and all the ‘proven’ concurrent support already found in other languages, among them, Occam, Go, Erlang, Haskell, Esterel, Scala, and many others in the academic research community. There is even one observation that the current Monitor implementation in Java itself could more fully embrace the original theoretical Monitor concept.

Of course, as in anything else, there is hype and fashion in software too. Thus, some approaches are touted as fixing deadlocks and other problems, when they don’t.

Related Projects:

· Disruptor – Concurrent Programming Framework
· LMAX: “The LMAX Architecture“, Fowler, M., http://martinfowler.com/articles/lmax.html
· CQRS: CQRS, Fowler, M., http://martinfowler.com/bliki/CQRS.html
· Akka: http://akkasource.org/
· Multiverse: http://multiverse.codehaus.org/overview.html
· REAL TIME OPERATING SYSTEM BASED ON ACTIVE OBJECT
· ESTEREL: http://www-sop.inria.fr/meije/esterel/esterel-eng.html
· Staged event-driven architecture (SEDA)
· CSP: http://www.usingcsp.com/cspbook.pdf
· Kilim: http://www.malhar.net/sriram/kilim/index.html
· JCSP: http://www.cs.ukc.ac.uk/projects/ofa/jcsp
· JVSTM: http://web.ist.utl.pt/joao.cachopo/jvstm/
· Clojure: http://clojure.org/concurrent_programming
· “Gpars: http://gpars.codehaus.org/
· Groovy Parallel: http://www.dcs.napier.ac.uk/~cs10/GroovyParallel/
· Scala: http://www.scala-lang.org/
· Triveni: http://webpages.cs.luc.edu/~laufer/triveni/
· ActorFoundry project, http://osl.cs.uiuc.edu/af/
· “Jetlang, Message based concurrency for Java” http://code.google.com/p/jetlang/
· Jsasb, adds event-driven programming paradigm to Java, https://jsasb.dev.java.net/
· Node.js: http://nodejs.org/
. Er.js: Er.js: Erlang-in-JavaScript
· MPJ: Java for High Performance Computing, http://mpj-express.org/
· FunctionalJava, accessed on 3/2/2009 at http://functionaljava.org/
· JAVACT : a Java middleware for mobile adaptive agents, accessed on 3/2/2009 on 3/2/2009 at http://www.irit.fr/PERSONNEL/SMAC/arcangeli/JavAct.html
· Threading in COM, accessed on 3/2/2009 at http://en.wikipedia.org/wiki/Component_Object_Model#Threading_in_COM
· http://www.transterpreter.org/
· http://supertech.csail.mit.edu/cilk/
· TBB: http://www.threadingbuildingblocks.org/
· JConch: http://code.google.com/p/jconch/
· JAC: http://www.inf.fu-berlin.de/inst/ag-ss/jac/
· X10: http://docs.codehaus.org/display/XTENLANG
· COSA: http://www.rebelscience.org/Cosas/COSA.htm
· BAM: http://caucho.com/resin/doc/bam.xtp
· Concurrent Programming Research Group, http://mypages.iit.edu/~concur/
· JCarder, http://www.jcarder.org/
· Go, http://golang.org/doc/go_lang_faq.html#concurrency
· Panini: http://www.cs.iastate.edu/~design/projects/panini/
·

Further Reading

Below are a few easily obtainable links found on-line. (To do: use standard style guide like IEEE Standard and Chicago).
· Concurrency in Elixir

· Coarse-grained locks and Transactional Synchronization explained

· Concepts compared

· “Joe Duffy on the Future of Concurrency and Parallelism

· Dr. Dobb’s Report: Real-Time Ready Java

· Actors Make Better Observers

· Talking about Akka, Scala and life with Jonas Bonér

· Miller, Alex; Comparing concurrent frameworks

· Lea, Doug; “Engineering Fine-Grained Parallelism Support for Java 7”, http://www.dzone.com/links/r/engineering_finegrained_parallelism_in_java.html

· Milewsk, Bartosz; “Beyond Locks and Messages: The Future of Concurrent Programming”, http://bartoszmilewski.wordpress.com/2010/08/02/beyond-locks-and-messages-the-future-of-concurrent-programming/

· Wiger, Ulf; “Death by Accidental Complexity”, http://lambda-the-ultimate.org/node/1630

· “Erlang concurrency: why asynchronious messages?”, http://lambda-the-ultimate.org/node/1630″>http://lambda-the-ultimate.org/node/1630

· Merritt, Eric;”A Brief Overview of Concurrency.”, http://erlware.blogspot.com/2010/07/brief-overview-of-concurrency.html

· Kuppusamy, Rmsundar; “Is concurrency such a complex thing in real world applications?”, http://www.dzone.com/links/r/is_concurrency_such_a_complex_thing_in_real_world.html; Comments on the article are very informative.

· Kabutz, Heinz; “Deadlocks through Cyclic Dependencies”, http://www.javaspecialists.eu/archive/Issue184.html

· Jackson, Joab, “Microsoft Windows architect says ditch the kernel”, http://news.techworld.com/operating-systems/3217766/microsoft-windows-architect-says-ditch-the-kernel/?olo=rss

· Breshears, Clay, “Across the wide Concurrency”, http://software.intel.com/en-us/blogs/2010/05/17/across-the-wide-concurrency/

· Dibyendu Roy, “Rethinking Multi-Threaded Design Principles”, [Weblog entry.] Java.net. 3 Mar 2010. (http://today.java.net/article/2010/03/03/rethinking-multi-threaded-design-priniciples). 5 Mar 2010.

· Mordani, Rajiv; “Asynchronous Support in Servlet 3.0”, http://blogs.sun.com/enterprisetechtips/entry/asynchronous_support_in_servlet_3

· Michele Simionato, “Threads, processes and concurrency in Python: some thoughts”, [weblog entry.] The Explorer. 26 Jul 2010. (http://www.artima.com/weblogs/viewpost.jsp?thread=299551). 26 Jul 2010.

· Orlic, Bojan; “SystemCSP : a graphical language for designing concurrent component-based embedded control systems”. (2007) thesis. http://doc.utwente.nl/58009/

· Jonas Bonér, “Introducing Akka – Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors”. 4 Jan 2010. (http://jonasboner.com/2010/01/04/introducing-akka.html). 14 Mar 2010.

· Stephan Schmidt, “Actor Myths”, [Weblog entry.] Code Monkeying. Jul 21, 2010. (http://codemonkeyism.com/actor-myths/)

· James Iry. “Erlang Style Actors Are All About Shared State”, [Weblog entry.] One Div Zero. 6 Apr, 2009. (http://james-iry.blogspot.com/2009/04/erlang-style-actors-are-all-about.html) . 23 Jul 2010.

· Paul Chiusano, “Actors are not a good concurrency model”, [Weblog entry.] Prettt-tty, pretty, pretty good!. 15 Jan 2010. (http://concurrency.tumblr.com/post/420147030/actors-are-not-a-good-concurrency-model). 2. Mar 2010.

· Welch, P.H.; “Process Oriented Design for Java: Concurrency for All”, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.102.9787

· Dimitris Andreou, “Thoughts on Actors”, [Weblog entry.] Code-o-matic. 8 Jan 2010. (http://code-o-matic.blogspot.com/2010/01/thoughts-on-actors.html). 23 July 2010.

· McDonald, Carol; “Some Java Concurrency Tips”, http://weblogs.java.net/blog/caroljmcdonald/archive/2009/09/17/some-java-concurrency-tips

· Oprean, George and Pedersen, Jan B., “Asynchronous Active Objects in Java”, Communicating Process Architectures, 2008., http://wotug.org/paperdb/show_proc.php?f=4&num=26

· sutter, Herb; “Prefer Using Active Objects Instead of Naked Threads”, http://www.drdobbs.com/high-performance-computing/225700095;jsessionid=OCHVVY5DWODL3QE1GHRSKHWATMY32JVN

· Alex Tkachman, “Groovy concurrency in action: asynchronious resource pools with Groovy++”, http://groovy.dzone.com/articles/groovy-concurrency-action-0

· Alex Tkachman, “Fast immutable persistent functional queues for concurrency with Groovy”, JavaLobby, http://java.dzone.com/articles/fast-immutable-persistent

· Schumacher, Dale, “Composing Actors”, “blog It’s Actors All The Way Down”, http://www.dalnefre.com/wp/2010/05/composing-actors/

· “Objects as Actors?”, Debasish Ghosh, http://java.dzone.com/news/objects-actors

· “Gartner Says as the Number of Processors Swells Inside Servers, Organizations May Not Be Able to Use All Processors Thrust on Them”, http://www.gartner.com/it/page.jsp?id=867112

· “Tilera vs. Godzilla”, Louis Savain, http://rebelscience.blogspot.com/2007/08/tilera-vs-godzilla.html

· “Convergence in Language Design: A Case of Lightning Striking Four Times in the Same Place”, Peter Van Roy, http://www.info.ucl.ac.be/~pvr/flopsPVRarticle.pdf

· “The Problem with Threads”, Edward A. Lee, http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.pdf

· “A Component-Oriented Language for Pointer-Free Parallel Programming”, Luc BlÄaser, Computer Systems Institute, ETH ZÄurich, Switzerland. Accessed on 3/10/2009 at http://www.isp.uni-luebeck.de/kps07/files/papers/blaeser.pdf

· Mauricio Arango, “Coordination in parallel event-based systems”, http://blogs.sun.com/arango/entry/coordination_in_parallel_event_based

· Irfan Pyarali, Tim Harrison, and Douglas C. Schmidt Thomas D. Jordan; “Proactor: “An Object Behavioral Pattern for Demultiplexing and Dispatching Handlers for Asynchronous Events”, http://www.cs.wustl.edu/~schmidt/PDF/proactor.pdf

· “A Component-Oriented Model for the Design of Safe Multi-threaded Applications”, Reimer Behrends, R. E. K. Stirewalt and L. K. Dillon Dept. of Computer Science and Engineering Michigan State University, accessed on 3/10/2009 at http://www.cse.msu.edu/~stire/Papers/cbse05.pdf

· “2028: Concurrent processing–from revolution to legacy”, http://www.embedded.com/design/212000158

· “Join Patterns for Visual Basic”, accessed on 3/10/2009 at http://research.microsoft.com/en-us/um/people/crusso/papers/cb.pdf

· “ActorsModel”, at http://c2.com/cgi/wiki?ActorsModel

· “Sharing Is the Root of All Contention”,Herb Sutter, http://www.ddj.com/go-parallel/article/showArticle.jhtml?articleID=214100002

· Bryan Cantrill. “OpenSolaris Sewer Tour”. [weblog entry.] The Observation Deck. 14 Jun 05. (http://blogs.sun.com/bmc/entry/opensolaris_sewer_tour). 26 Jul 10.

· “Concurrent computing”, http://en.wikipedia.org/wiki/Concurrent_computing

Walsh, Matt; “SEDA: An Architecture for Highly Concurrent Server Applications”, Harvard University,
http://www.eecs.harvard.edu/~mdw/proj/seda/

· “Multicore programming: Easy or difficult?”, http://www.edn.com/article/CA6646279.html?nid=2551

· “The universe model: An approach for improving the modularity and reliability of concurrent programs, Reimer Behrends”, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.15.8983

· Mitchell Pronschinske, “Concurrent Programming in Groovy”, JavaLobby, http://java.dzone.com/articles/dont-be-afraid-try-gpars

· “Actors in Groovy”, Alex Miller, http://tech.puredanger.com/2009/01/16/actors-in-groovy/

· “Scala Actors vs Plain Old Java”, Duke Banerjee, http://shorugoru.blogspot.com/2009/09/scala-actors-vs-plain-old-java.html

· Event-based actors in Groovy, Václav Pech, accessed on 3/4/09 at http://www.jroller.com/vaclav/entry/event_based_actors_in_groovy

· Pech, Václav; “Flowing with the data”, http://www.jroller.com/vaclav/entry/flowing_with_the_data

· “We haven’t forgotten about other models – honest!”, posted to Maestro blog, accessed on 3/02/2009 at http://blogs.msdn.com/maestroteam/archive/2009/02/27/we-haven-t-forgotten-about-other-models-honest.aspx

· ” Infrastructure for the Synchronization and Coordination of Concurrent Java Component Programs”, Sandeep Mitra, Sudhir Aggarwal, accessed on 2/28/09 at http://csdl.computer.org/comp/proceedings/hicss/2000/0493/08/04938052.pdf

· Parallel Computing Developer Center, http://msdn.microsoft.com/en-us/concurrency/default.aspx

· Search on CiteSeer for STM: http://citeseerx.ist.psu.edu/search;jsessionid=832BC25C661FF28D18EDAE10E725B301?q=software+transactional+memory&submit=Search&sort=rel

· “Synchronization and Time”, Duffy, Joe; http://www.bluebytesoftware.com/books/winconc/ConcurrentProgramming032143482X_ch02.pdf

· “Concurrency’s Shysters”, http://blogs.sun.com/bmc/entry/concurrency_s_shysters

· “More thoughts on transactional memory”, Duffy, Joe; http://www.bluebytesoftware.com/blog/PermaLink,guid,94778838-3e27-4788-a935-006ae9c8ef94.aspx

· “And now some Hardware Transactional Memory comments…”,Cliff Click Jr., http://blogs.azulsystems.com/cliff/2009/02/and-now-some-hardware-transactional-memory-comments.html

· “Communicating Java Threads” (1997),,Gerald Hilderink, Jan Broenink, Wiek Vervoort, Andre Bakkers, http://www.ce.utwente.nl/javapp/cjt/CJT-paper.PDF

· “Actors That Unify Threads and Events”,Philipp Haller and Martin Odersky, http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf

· Discussion at Lambda the Ultimate: http://lambda-the-ultimate.org/node/2048

· “The Next Mainstream Programming Language”, http://www.cs.princeton.edu/~dpw/popl/06/Tim-POPL.ppt

· “Actor Foundry”,”Rajesh Karmani, et al.”,http://osl.cs.uiuc.edu/~rkumar8/ActorFoundry.ppt

· “Implementing the π-Calculus in Java”,Liwu Li, http://www.jot.fm/issues/issue_2005_03/article5.pdf

· “Tackling Concurrency Language or Library?”,http://www.scala-lang.org/sites/default/files/odersky/intel06.pdf

· “Programming in the Age of Concurrency: Software Transactional Memory”,http://channel9.msdn.com/shows/Going+Deep/Programming-in-the-Age-of-Concurrency-Software-Transactional-Memory/

· “Communicating Process Architectures 2008”, Editors: Frederick R. M. Barnes, Jan F. Broenink, Alistair A. McEwan, Adam Sampson, G. S. Stiles, Peter H. Welch; IOS Press, Amsterdam, 978-1-58603-90. http://wotug.org/paperdb/show_proc.php?f=4&num=26 Accessed 26 Jul 10.

· “CSP for Java programmers, Part 1“,Abhijit Belapurkar, http://www-128.ibm.com/developerworks/java/library/j-csp1.html

· “CSP for Java programmers, Part 2“,Abhijit Belapurkar, http://www.ibm.com/developerworks/java/library/j-csp2/

· “CSP for Java programmers, Part 3“,Abhijit Belapurkar, http://www.ibm.com/developerworks/java/library/j-csp3.html

· More Java Actor Frameworks Compared, http://sujitpal.blogspot.com/2009/01/more-java-actor-frameworks-compared.html, Sun Jan 04 2009 09:24:04 GMT-0500 (Eastern Standard Time)

· Concurrency, Actors and Kilim, http://sujitpal.blogspot.com/2008/12/concurrency-actors-and-kilim.html, Sun Jan 04 2009 09:24:54 GMT-0500 (Eastern Standard Time)

· Event-Based Programming without Inversion of Control,
Philipp Haller and Martin Odersky, Proc. JMLC 2006, and. Accessed 2007 at http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf

· Actors that Unify Threads and Events,
Philipp Haller and Martin Odersky, Proc. COORDINATION 2007. Accessed 2007 at http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf

· “Integrating and Extending JCSP”, Peter WELCHa, Neil BROWNa, James MOORES b, Kevin CHALMERS c and Bernhard SPUTH. Communicating Process Architectures 2007. Accessed 2007 at xxxx.

· “Message Passing–Sync or Async?”, Bartosz milewski, http://bartoszmilewski.wordpress.com/2009/02/10/message-passing-sync-or-async/

· A message thread about Erlang related questions, http://www.erlang.org/pipermail/erlang-questions/2008-January/032224.html

· “Are Concurrent Programs That Are Easier to Write Also Easier to Check?”, Kedar S. Namjoshi, accessed 20081228 at http://www.cs.utah.edu/ec2/papers/ec2-pp7.pdf

· Goldman, Oliver. “Multithreading, Java, & OSGi.” http://www.ddj.com/java/191601642.

· Vogel, Lars. “Java Concurrency / Multithreading – Tutorial”, http://www.vogella.de/articles/JavaConcurrency/article.html

· “Thread-safety in OSGi”, Neil Bartlett, accessed at http://neilbartlett.name/blog/2007/03/05/thread-safety-in-osgi/

· Ernst, Dan.”Parallelism Exposure – It’s Not That Hard!“,

· “Kilim: Isolation-typed actors for Java”, Sriram Srinivasan, http://www.malhar.net/sriram/talks/kilim-google.pdf

· “Wot, no chickens?”, http://wotug.org/parallel/groups/wotug/java/discussion/3.html

· “Java for High Performance Computing”, http://mpj-express.org/

· “4.5 Active Objects”, http://gee.cs.oswego.edu/dl/cpj/s4.5.html

· “Rock (processor)”, http://en.wikipedia.org/wiki/Rock_processor

· “Early Experience with a Commercial Hardware Transactional Memory Implementation”,Dave Dice, Yossi Lev, Mark Moir, and Dan Nussbaum, http://blogs.sun.com/dave/resource/asplos09-Rock-Final2.pdf

· “Concurrency JSR-166 Interest Site”, http://gee.cs.oswego.edu/dl/concurrency-interest/index.html

· “Actors Guild”, http://actorsguildframework.org/

· Synchronous Active Objects Home Page, http://ltiwww.epfl.ch/sJava/index.html

· “What after Java? From objects to actors”,Carlos A. Varela and Gul A. Agha, http://www7.scu.edu.au/1890/com1890.htm

· “Programming Java threads in the real world, Part 9”, Allen Holub, JavaWorld.com, 06/01/99, http://www.javaworld.com/javaworld/jw-06-1999/jw-06-toolbox.html

· Actors Foundations for Open System: http://www.erights.org/history/actors.html

· “Power Combination: SCA,, OSGi and Spring”, OSOA Collaboration, http://www.osoa.org/download/attachments/250/Power_Combination_SCA_Spring_OSGi.pdf

· There Is a Silver Bullet, Brad J. Cox, http://www.ddj.com/184407534

· Concurrency and Coordination Runtime, http://en.wikipedia.org/wiki/Concurrency_and_Coordination_Runtime

· Yuri Gurevich, Wolfram Schulte, and Charles Wallace, “Investigating Java Concurrency using Abstract State Machines”. In Y. Gurevich, P. Kutter, M. Odersky, and L. Thiele, eds., Abstract State Machines: Theory and Applications, Springer LNCS 1912, 2000, 151-176.

· Understanding actor concurrency, Part 1: Actors in Erlang A new way to think about structuring concurrent applications By Alex Miller, JavaWorld.com, 02/24/09, http://www.javaworld.com//javaworld/jw-02-2009/jw-02-actor-concurrency1.html

· “Understanding actor concurrency, Part 2: Actors on the JVM”, http://www.javaworld.com/javaworld/jw-03-2009/jw-03-actor-concurrency2.html

· Byrne, Dennis; “Memory Barriers and JVM Concurrency”, InfoQ, http://www.infoq.com/articles/memory_barriers_jvm_concurrency

· Thread Safe Programming Language, Stefan Forster, http://threadsafeprogramming.blogspot.com/2009/03/threadsafeprogramminglanguage.html

· Maestro: A Special-Purpose Language for Parallel Programming, Jonathan Erickson, http://www.ddj.com/go-parallel/article/showArticle.jhtml?articleID=214502187

· Message Passing Interface (MPI), http://en.wikipedia.org/wiki/Message_Passing_Interface

· “Best programming approach/methodology to assure thread safety”, http://stackoverflow.com/questions/256517/best-programming-approach-methodology-to-assure-thread-safety/256684

· “RPC and its Offspring: Convenient, Yet Fundamentally Flawed”, Steve Vinoski”, http://qconlondon.com/london-2009/file?path=/qcon-london-2009/slides/SteveVinoski_RPCAndItsOffspringConvenientYetFundamentallyFlawed.pdf

· “Bigraphs: a model for mobile agents”, Robin Milner, Accessed on 3/3/2009 at http://www.cl.cam.ac.uk/~rm135/Bigraphs-Lectures.pdf

· “Fine-grain concurrency”, Tony Hoare, accessed on 3/3/2009 at http://se.inf.ethz.ch/laser/2007/slides/guildford.Fine-grain%20concurrency.pdf

· P. Brinch Hansen, A keynote address on concurrent programming. Keynote address for the IEEE Computer Software & Applications Conference, Chicago, IL, November 1978. Computer 12, 5 (May 1979), 50{56. Copyright °c 1979, Institute of Electrical and Electronics Engineers, Inc., accessed on 3/3/09 at http://brinch-hansen.net/papers/1978c.pdf

· “Concurrency: The Next Generation”, Damian Dimmich, Christian Jacobsen and Matthew Jadud, Computing Laboratory University of Kent Canterbury, CT2 7NZ, accessed on 3/3/09 at http://www.cs.kent.ac.uk/pubs/2006/2522/content.pdf

· “Concurrency and Erlang” LCA2007 Andre Pang, http://www.scribd.com/doc/415195/Concurrency-and-Erlang-LCA2007-Andrep

· “Concurrency in Erlang & Scala: The Actor Model”, Ruben Vermeersch, http://ruben.savanne.be/articles/concurrency-in-erlang-scala

· Erlang for Concurrent Programming, Jim Larson, http://queue.acm.org/detail.cfm?id=1454463

· How OSGi Changed My Life, Peter Kriens, http://queue.acm.org/detail.cfm?id=1348594

· “New parallel programming language design: a bridge between brain models and multi-core/many-core computers?”, http://arxiv.org/PS_cache/arxiv/pdf/0812/0812.2926v1.pdf

· Component-based software engineering, http://en.wikipedia.org/wiki/Software_componentry

· “Component-based approach for embedded systems”, Ivica Crnkovic Mälardalen University, Department of Computer Science and Engineering, http://research.microsoft.com/en-us/um/people/cszypers/events/wcop2004/18-crnkovic.pdf

· Super Actors for Real Time (2001), G. Fortino, L. Nigro, F. Pupo, D. Spezzano, Proc. of the 6 th IEEE Workshop on Object-oriented Real-time Dependable Systems (WORDS’01 http://si.deis.unical.it/~fortino/research/publications/conferences/pdf/words01.pdf

· “Fundamentals of Concurrent Programming for .NET” (2005), Charteris White Paper, Greg Beech, http://www.charteris.com/publications/white_papers/downloads/White Papers – Fundamentals of Concurrent Programming for dotNET (Greg Beech) March 2005.pdf

· “A type safe state abstraction for coordination in Java-like languages”,Ferruccio Damiani, Elena Giachino, Paola Giannini, and Sophia Drossopoulou,Acta Informatica, Volume 45, Numbers 7-8 / December, 2008, http://www.springerlink.com/content/2168q630k2355563/

Books

· The Art of Concurrency: A thread Monkey’s Guide to Writing Parallel Applications, Clay Breshears, O’Reilly Media, May 2009. 978-0-596-52153-0. http://oreilly.com/catalog/9780596521547

· Concurrency: State Models & Java Programs, Jeff Magee and Jeff Kramer

· Java Concurrency in Practice, Brian Goetz

· Concurrent Programming in Java, Doug Lea,

· Java Thread Programming, Paul Hyde,

· Java Threads, Oaks & Wong,

· Multithreaded Programming with Windows NT, Thuan Q. Pham and Pankaj K. Garg

· From “Industry Education Recommended Reading List”, http://www.intel.com/technology/rr/

o C# Threading Handbook, Tobin Titus, Sandra Gopikrishna, Tejaswi

o Redkar, Srinivasa Sivakumar, Wrox Press 1861008295

o Computer Architecture: A Quantitative Approach 4th Edition John L. Hennessy and David Patterson Morgan Kaufmann 0123704901

o Multi-Core Programming Shameem Akhter, Jason Roberts Intel Press 0976483246

o Multithreading Applications in Win32: The Complete Guide to Threads Jim Beveridge, Robert Wiener Addison-Wesley Professional 0201442345

o Parallel Programming in C with MPI and OpenMP Michael J. Quinn McGraw-Hill Professional 0072822562

o Parallel Programming in OpenMP Rohit Chandra, Ramesh Menon, Leo Dagum, Dave Kohr, Dror Maydan, and Jeff McDonald Morgan Kaufmann 1558606718

o Using OpenMP: Portable Shared Memory Parallel Programming Barbara Chapman, Gabriele Jost, Ruud van der Pas, David J. Kuck MIT Press 0262533022

o Parallel Programming with MPI Peter Pacheco Morgan Kaufmann 1558603395

o Patterns for Parallel Programming Timothy G. Mattson, Beverly A. Sanders, Berna L. Massingill Addison-Wesley Professional 0321228111

o The Art of Concurrency Clay Breshears O’Reilly 9780596521530

o Programming with Hyper-Threading Technology Andrew Binstock, Richard Gerber Intel Press 0971786143

o Programming with POSIX® Threads David R. Butenhof Addison-Wesley Professional 0201633922

o The Software Optimization Cookbook, Second Edition Richard Gerber, Aart J.C. Bik, Kevin Smith, Xinmin Tian Intel Press 0976483211

o Optimizing Applications for Multi-Core Processors Stewart Taylor Intel Press 1934053015

o Intel Threading Building Blocks: Outfitting C++ for Multi-Core Processor Parallelism James Reinders O’Reilly 0596514808

o Threads Primer: A Guide to Multithreaded Programming Bil Lewis, Daniel J. Berg Prentice Hall 0134436989


Modular Continuously Shippable Applications

This was not just a test-driven development (TDD) approach, I said. For example, we could use a Command Line Interface until we have the Rich Internet Application framework ready, we could use flat-files until we knew what the data model should be, etc. The “product” was in flux based on potential customer feedback. So, it was really to do the simplest thing that will get the application doing real work as soon as possible.

Long ago in 2000 at a job I suggested to the development teams that an approach we could use is to start on day one with a shippable product.  That is, using Stubs, Mocks, and fake data, we could create the complete app that is testable and shippable from day one.  Since the first customers are the investors and potential partners, they would get to see what we really intended to create up front, in working code, not fancy PowerPoint presentations.  The working code would have served as the presentation and the base on which to build the eventual product to ship to external customers.

This was not just a test-driven development (TDD) approach, I said. For example, we could use a Command Line Interface until we have the Rich Internet Application framework ready, we could use flat-files until we knew what the data model should be, etc.  The “product” was in flux based on potential customer feedback.  So, it was really to do the simplest thing that will get the application doing real work as soon as possible.

The advantages I thought could have been:

  • Faster to market
  • Better API (no fluff)
  • System always testable
  • Infrastructure for testing and QA
  • Usable for presentation
  • Modular

What was the response?  Nothing.  Oh well.  It would have been great to see what could have been accomplished.

I was reminded of the above as I stumbled upon “Architecture Review: Mock-Driven Three-Layer Architecture“ on James Shore’s The Art of Agile blog.

Now there has been much more creative work and new agile languages that would have made my idea more doable.  In fact, many of today’s successful frameworks are responses to the excess complexity that I had to deal with then.

Updates

Links

“Potentially Shippable product – A Myth or Reality?”: http://agileworld.blogspot.com/2009/11/potentially-shippable-product-myth-or.html

Continuous Integration:  http://en.wikipedia.org/wiki/Continuous_integration

“Learn how to Pivot — or you’re toast”: http://bit.ly/aa80CL

Mock Object: http://en.wikipedia.org/wiki/Mock_object

Mock-Driven Three-Layer Architecture”, http://jamesshore.com/Blog/Architecture-Review-Mock-Driven-Three-Layer-Architecture.html

“Mocks Aren’t Stubs”, http://martinfowler.com/articles/mocksArentStubs.html

“Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))”, http://www.amazon.com/exec/obidos/ASIN/0321601912

Grails:  http://grails.org/

How to improve web search

During the following days I thought about this, then while driving the solution popped into my head (very dangerous!). Use the results of searching to present possible terms to the user to augment the search. One technique I thought of using was Tag Clouds. In Bing, Yahoo, or Google, one would just do a normal search, but new panels would then show with different type of Tag Clouds. The user could click on a term and that would be added to the search string. That would solve the problem of not knowing what to add to the terms to narrow the search, but also whether the search terms are helping get closer to the “real” topic.

I originally wrote this on January 21, 2010.  A few weeks ago I was helping a family member with some research.  I searched the web on the topic.  It was very bad.  No matter what I used as a query the results were bad.  Not only were the results not relevant,  duplicates and noise were overshadowing everything.  I tried using different search engines, Google, Bing, Yahoo, and others.

This is not new, of course.  Though search services are very good, there is just a lot of noise out there.  Worse, there is an adversarial relationship between search targets and the search services.   To see an example of this see this blog post The Anatomy Of A Bad Search Result

During the following days I thought about this, then while driving  the solution popped into my head (very dangerous!).  Use the results of searching to present possible terms to the user to augment the search.  One technique I thought of using was Tag Clouds.  In Bing, Yahoo, or Google, one would just do a normal search, but new panels would then show with different type of Tag Clouds: terms, news, location, entertainment, etc.  The user could click on a term and that would be added to the search string.   That would solve the problem of not knowing what to add to the terms to narrow the search, but also whether the search terms are helping get closer to the “real” topic.  Subsequent searches would allow refinement, adding and removing terms, and new tag clouds would form.

Well, I get an idea and know how to embellish it and make it powerful, its fun to do this.   So, I also saw how to extend this to do much more such as using Semantic tools, RDFa, TopicMaps, and graphical visualizations.  As I’m doing research to see if I can write this up, I stumble upon DeeperWeb.  Wow, they use the TagCloud technology to do just what I wrote about above.   Not only did they implement this, they also started to use some Semantic Web technologies like Topic Maps, which I was also thinking about.   Oh well, at least I found something that hopefully will improve search.

Unfortunately, DeeperWeb plugin has not improved my search results.  In fact, it has not been useful at all.  Occasionally the phrases panel was useful.   Puzzling.  I think this is not possible with a plug-in.  Instead, the search services themselves must provide the “deep web” results.  For example, Google has an ginormous database that can create a tag cloud or other type of  search augmentation.  I know there were some lab experiments like a mindmap like visual explorer (which was lame).

In the meantime, just for fun, I’ll look into the other ideas I had.  Tag Clouds were just an interim means, much more can be done.   There is a rich storehouse of more information that can be correlated and presented to assist the user in search.   Even location based filtering.  Social network based topic discovery, cultural cues, and even search augmented by crowd sourcing.  Let say you are search for xyz, this search can be broadcast to subscribers of a search service who then can augment the search terms to provide better results.  They would ask pertinent questions of course, and privacy is paramount.

As a Google employee stated, most of search has been solved, its the last part that will take the most effort, the usual 80/20 rule.

I’ve had this blog post in draft so long now I lost the momentum.  Oh well.

Why use an AOP language when other languages can now do Aspects?

Interesting research, JOT: Journal of Object Technology – How AspectJ is Used: An Analysis of Eleven AspectJ Programs: Sven Apel, on how an AOP language, specifically AspectJ, is used in a few sample projects. Was it useful, required? The jury is out.

Interesting research,  JOT: Journal of Object Technology – How AspectJ is Used: An Analysis of Eleven AspectJ Programs: Sven Apel, on how an AOP language, specifically AspectJ, is used in a few sample projects.  Was it useful, required?  The jury is out.

Interestingly the author correctly mentions that some languages now have rudimentary support for handling of basic crosscutting concerns.   And, since the analyzed projects did not really need advanced AOP techniques,

“numbers indicate that languages that provide only basic crosscutting mechanisms are appropriate to implement a large extent of the analyzed programs.”  

Note that the study does not apply to container based AOP as used in frameworks such as JBossAOP and SpringAOP.  Several Dynamic Languages use a Metaobject Protocol.

I used AspectJ for some utility and diagnostic help.  The language is fine and the concepts are approachable.  It’s the configuration, tools, and environment hassles that put a damper on things.   That’s why frameworks and tool support like that found in Eclipse are critical.

Updates
9/11/2010:
Adding Logging around all of the Methods of a Class with Groovy“, Ted Naleid. http://naleid.com/blog/2010/09/11/adding-logging-around-all-of-the-methods-of-a-class-with-groovy/

Further Reading

JOT: Journal of Object Technology – How AspectJ is Used: An Analysis of Eleven AspectJ Programs, Sven Apel

McClean, John, “Painless AOP with Groovy“, http://www.infoq.com/articles/aop-with-groovy

Meta-object Protocol, http://en.wikipedia.org/wiki/Meta-object_protocol

Dynamic Programming Language, http://en.wikipedia.org/wiki/Dynamic_language

AspectJ, http://www.eclipse.org/aspectj/

AJDT, http://www.eclipse.org/ajdt/

Fixing sound on OpenSolaris in VirtualBox

On my new system I installed OpenSolaris 2009.16 in a VirtualBox instance.  Nice!  OpenSolaris is very advanced Unix system but presents a user interface that is also found on popular Linux distributions, Gnome.  A lot of new stuff is in the latest release.

VirtualBox running OpenSolaris
VirtualBox running OpenSolaris

But, sound was not working.  I found two blog posts that show how to get it going:   The Observatory and Constantin’s Bloog.  As usual, the steps did not work.  And as usual, a bunch of mucking about was successful.  Unfortunately, the exact sequence was not captured.  I followed the advice in both posts.  I do remember that you have to run ossdetect, and then precede (or follow) it with pkexec /usr/sbin/soundoff, then pkexec /usr/sbin/soundon

Still not reliable; I just rebooted and the sound is off and I had to redetect and soundoff soundon.  Hmmm.

Would I run OpenSolaris or Solaris?  Sure for servers.  It has a lot of system features such as ZFS, Crossbow, Virtualization, and so forth.  But, as a desktop app?  I don’t know; maybe if I were getting paid to do so.  Like Linux, its going to have its share of device issues and incompatibilities.  For example, Google Toolbar is not available for FireFox on OpenSolaris.  Not a biggie, unless your used to having it.