To begin the conference I attended the half day “Ontology 101” presented by Elisa Kendall and Deborah McGuinness.  They indicated that this presentation has been given at each semantic technology conference and the interest is still strong.  The implication being that new people continue to want to understand this art.

Their material was very useful and if you are someone looking to get a grounding in ontologies (what are they?  how do you go about creating them?) I recommend attending this session the next time it is offered.  Both leaders clearly have deep experience and expertise in this field.  Also, the discussion was not tied to a technology (e.g. RDF) so it was applicable regardless of underlying implementation details.

I wrapped up the first day with Richard Ordowich who discussed the process of reverse engineering semantics (meaning) from legacy data.  The goal of such projects being to achieve a data harmonization of information across the enterprise.

A point he stressed was that a business really needs to be ready to start such a journey.  This type of work is very hard and very time consuming.  It requires an enterprise wide discipline.  He suggests that before working with a company on such an initiative one should ask for examples of prior enterprise program success (e.g. something like BPM, SDLC).

Fundamentally, a project that seeks to harmonize the meaning of data across an enterprise requires organization readiness to go beyond project execution.  The enterprise must put effective governance in place to operate and maintain the resulting ontologies, taxonomies and metadata.

The full conference kicked off the following day.  One aspect that jumped out for me was that a lot of the presentations dealt with government-related projects.  This could have been a side-effect of the conference being held in Washington, DC but I think it is more indicative that spending in this technology is more heavily weighted to public rather than private industry.

Being government-centric I found any claims of “value” suspect.  A project can be valuable, or show value, without being cost effective.  Commercial businesses have gone bankrupt even though they delivered value to their customers.  More exposure of positive-ROI commercial projects will be important to help accelerate the adoption of these technologies.

Other than the financial aspect, the presentations were incredibly valuable in terms of presenting lessons learned, best practices and in-depth tool discussions.  I’ll highlight a few of the sessions and key thoughts that I believe will assist as we continue to apply semantic technology to business system challenges.

Marcel Jemio from the Department of the Treasury discussed a massive project seeking to apply semantics to their siloed transactional data.  His focus was to present his lessons learned as well as a possible blue print for similar projects.  He did a great job on both fronts.  A focus he suggested was that such projects should not be concerned with classifying data; rather they should seek to classify knowledge.  It is knowledge that is actionable and provides meaning and relevance.

Some other important points he made included the need for business data governance, standardized data (vocabulary, semantics) and a shared information repository.  Beyond his excellent sharing of experiences, his slides included recommendations for how to present information to business stakeholders so as to inform and educate.

Richard Green’s presentation looked at how to go about creating a practical ontology for an enterprise.  He dove into detail, showing some of the structured approaches that he uses to gather the requirements that feed an ontology design.  A key point for Richard was that ontologies must be practical (delivering value, being easy to use), define an ontology (describing what exists and their relationships) and work for a specific enterprise or constituent.

I thought his approach was very logical and included useful guidance for thinking through the process.  Sharing his documentation templates helped to clarify how the approach works and specifically how his “5 w’s” are applied to different situations.  I intend to integrate some of his approach into my practices.

Another presentation that contained specific guidance was Janet Millenson’s ROI of RDF discussion.  She outlined some of the key drivers that would lead an organization to apply RDF-based technology as a more efficient way to approach a business challenge.  She went beyond simple ROI and also discussed the underlying business driver such as reducing costs and supporting their mission.

Her approach to making the business case was standard procedure for introducing large scale change to an organization’s leadership.  Like Marcel, she cautioned against the use of technology terms in these types of discussions.  The technology is irrelevant to business leadership, the results are what matter.  Based on her experience she shared the importance of setting realistic expectations and creating the right team in order to succeed.

When discussing actual project planning and execution she gave a good overview of some major aspects that must be thought-through and managed in order to succeed.  These include people with their skills as well as technologies leveraged and the business domain being addressed.  Considering technology issues (data quality, governance), organizational concerns (build/buy, vendor relationships) and market risk (vendor consolidation, standards evolution) are vital in order to create the most effective result.

Her bottom line was that a successful project will address a specific problem in the organization (not boil the ocean), understand and work within constraints, start with realistic expectations and plan flexibility into the result to deal with technology and business changes.

David Booth (presenting on behalf of Jurgen Angele) walked through 2 healthcare industry case studies where semantic technology was used to effectively advance the effectiveness and safety of care while reducing costs.  The initial case was from the Cleveland Clinic.

The usual starting point of having multiple stovepipe systems that contained related data was presented.  The total data set, if combined in a meaningful way, would create a much more useful information source for doctors and researchers. Since semantic technology simplifies the integration of separate data sources, it was an obvious choice for this project.

David described the high-level process that was used to bring the data together.  The basic subsumption capability of inferencing is a simple yet powerful way to quickly combine data.  He quoted Jim Hendler, “A little inferencing goes a long way.”  The presentation described the pipeline process that was applied and which makes a lot of sense as a standard approach to dealing with such integration projects.

The second case study revolved around PanGenX, which seeks to use human genome information to understand which drugs will work for which individuals.  The overall data integration process was very similar to the first case study.  One point that was made, which resonated with me, was the statement that SPARQL is a convenient rule language.  This comment was in the context of simple rules, obviously not inferencing.  However if simple rules are being created, having them in the same syntax as the queries simplifies the process.

Neil Raden’s presentation, albeit abbreviated, was thought provoking.  Neil’s direct manner, devoid of pretense, allowed him to actually cover a lot of information in a very short time.  His take on the overhyped and overly complex processes that represent current BI practices, such as large MDM projects and monolithic data warehouses, was that these are not where businesses should be spending their BI dollars.

He dropped a lot of information in one-liners.  Some of which weren’t related to semantics as much as data in general.  I found his presentation a call to action to leverage semantic technology in support of a new data paradigm, not a new way to implement existing paradigms.  I don’t know if that was a point he intended to make but it seemed like a logical extension of what he was saying.

The conference wrapped up with a panel discussion between David Booth, Elisa Kendall, David McComb and Dennis Wisnosky.  They discussed some of the changes they have seen with semantic technology including the fact that project implementation seems to be getting easier as tools mature and the semantic technology ecosystem gets fleshed out.  They are also seeing people focusing on more pragmatic and meaningful projects, going beyond simply playing with the technology.

There was some discussion about the continuing hype associated with this area and the need to not fall prey to that.  The work that has been done represents hard work and collegiate sharing.  The solutions are neither turnkey nor ready to simply buy and install.

There continues to be a focus on unstructured data which is good since so much corporate information is sitting idle in documents rather than databases.

Some specific guidance for getting started with semantic technology: prove it to yourself with a POC.  You can’t discuss it more broadly if you don’t believe in it.  Choose an initiative and give it a name so that people recognize it.  Plan to deliver value on a regular (no less than every 6 months) basis.  Start small and grow from there.

Controlling scope, as in all projects, is central to working with new technology in order to get to a success point and begin acquiring lessons learned, which will allow for future success.  The guidance from “The Mythical Man Month” is still relevant: you always throw the first one away.

A theme that was heard in several sessions and repeated in the panel discussion was that use cases must be leveraged when beginning a semantic technology project.  In reality that has nothing to do with semantics.  I leverage use cases (or user stories) in every business system project.  The fact that they are required for semantic technology projects simply points out that these projects are still focused on business success and must be driven by business needs.

On the technology side there were several vendors present demonstrating their tools and providing sessions that explored their case studies.   The capabilities of these tools continue to advance quickly.  I saw several that I will be trying out including ontology editors, inference engines and integration tools.

It is great to see the tool landscape continuing to grow in breadth and depth.  It is also nice to see a mix of commercial and open source alternatives, allowing a company to start a small POC without a large capital investment and then having commercial alternatives based on needs.

Overall the conference presented useful experiential information through case studies and lessons learned.  More commercial experience needs to be shared.  Also, a way needs to be found to make the output and advancement that the working groups are driving more visible and understandable.

In my case I am not looking to build a triple store or an OWL interpreter, those types of standards are not interesting to me.  I need more basic information.  Some of this exists but may not be as visible as it could be.  There was discussion around the importance of raising the visibility of things like CIO-level information and developer (of semantic technology-based applications, not the semantic technology itself) documentation.

I continue to be convinced that semantic technology will fundamentally change the way we work with data and system integrations.  It is simply a matter of time to get there.  Practitioners and thought leaders have an important role to play in order to get this vision out into the mainstream and keep it in the forefront of enterprise system conversations.

As always, if you have thoughts you’d like to share about a topic on my blog, feel free to add a comment.

On the Android platform it is actually quite easy to execute SPARQL against remote SPARQL endpoints, RDF data and local models.  The heavy lifting is handled by Androjena’s ARQoid, an Android-centric port of HP’s Jena ARQ engine.

Both engines (the original and the port) do a great job of simplifying the execution of SPARQL queries and consumption of the resulting data.  In this post I’ll go through a simple example of using ARQoid.  Note that all the code being shown here is available for download.  This post is based specifically on the queryRemoteSparqlEndpoint() method in the com.monead.androjena.demo.arqoid.SparqlExamples class.

Setup

To begin, some environment setup needs to be done in order to have a properly configured Android project ready to use ARQoid.

First, obtain the ARQoid JAR and its dependencies.  This is easily accomplished using the download page on the ARQoid Wiki and obtaining the latest ARQoid ZIP file.  Unzip the downloaded archive.   Since I’m discussing an Android application I’d expect that you would have created an Android project and that it contains a libs directory where the JAR files should be placed.

Second, add the JAR files to the classpath for your Android project.  I use the ADT plugin for Eclipse to do Android development.  So to add the JARs to my project I choose the Project menu item, select Properties, choose Build Path, select the Libraries tab, click the Add JARs… button, navigate to the libs directory, select the JAR files and click OK on the open dialogs.

Third, setup a minimal Android project.  The default layout, with a small change to its definition will work fine.

Overview

Now we are ready to write the code that uses ARQoid to access some data.  For this first blog entry I’ll focus on a trivial query against a SPARQL endpoint.  There would be some small differences if we wanted to query a local model or a remote data set.  Those will be covered in follow-on entries.

Here is a list of the ARQoid classes we will be using for this initial example:

• com.hp.hpl.jena.query.Query – represents the query being executed
• com.hp.hpl.jena.query.Syntax – represents the query syntaxes supported by ARQoid
• com.hp.hpl.jena.query.QueryFactory – creates a Query instance based on supplied parameters such as the query string and syntax definition
• com.hp.hpl.jena.query.QueryExecution – provides the service to  execute the query
• com.hp.hpl.jena.query.QueryExecutionFactory – creates a QueryExecution instance based on supplied parameters such as a Query instance and SPARQL endpoint URI
• com.hp.hpl.jena.query.ResultSet – represents the returned data and metadata associated with the executed query
• com.hp.hpl.jena.query.QuerySolution – represents one row of data within the ResultSet.

We’ll use these classes to execute a simple SPARQL query that retrieves some data associated with space exploration.  Talis provides an endpoint that we can use to access some interesting space exploration data.  The endpoint is located at http://api.talis.com/stores/space/services/sparql.
The query we will execute is:

SELECT ?dataType ?data
WHERE {
  <http://nasa.dataincubator.org/launch/1961-012> ?dataType ?data.
}

This query will give us a little information about Vostok 1 launched by the USSR in 1961.

Create the Query instance

We begin by creating the Query instance using the QueryFactory.

// Create a Query instance
Query query = QueryFactory.create(queryString, Syntax.syntaxARQ);

This code assumes that the query given earlier has been assigned to the String  variable queryString

Create the QueryExecution instance

We next create a QueryExecution using the QueryExecutionFactory.

// This query uses an external SPARQL endpoint for processing
// This is the syntax for that type of query
QueryExecution qe = QueryExecutionFactory.sparqlService(sparqlEndpointUri, query);

This code assumes that the Talis endpoint mentioned above has been assigned to the String variable sparqlEndpointUri.

Execute the query and obtain the ResultSet instance

We are now ready to actually execute the query and obtain the ResultSet instance.

// Execute the query and obtain results
ResultSet resultSet = qe.execSelect();

The resultSet variable now provides us access to the query results.

Retrieve the column names

A useful piece of metadata in the ResultSet instance is the list of column names.  These will be based on the information requested in the SELECT clause.  ARQoid can return them as a List<String>.

// Get the column names (the aliases supplied in the SELECT clause)
List<String> columnNames = resultSet.getResultVars();

The columnNames List will contain the aliases given in the SELECT clause.

Iterate through the resulting rows

We can now iterate through the resulting rows, asking for each row’s data which is represented as a QuerySolution instance.

// Iterate through all resulting rows
while (resultSet.hasNext()) {
  // Get the next result row
  QuerySolution solution = resultSet.next();

The solution variable will contain the current result row’s data.

Obtain the data for a row and column

To actually access the data you can request a specific column name from the QuerySolution instance.  However, you need to know whether the data is null, a literal value or a URI.  The following code performs the necessary tests and then prints the data to the standard output (in the downloadable code it will be presented on the Android device’s screen).

// Data value will be null if optional and not present
if (solution.get(var) == null) {
  System.out.println("{null}");
// Test whether the returned value is a literal value
} else if (solution.get(var).isLiteral()) {
  System.out.println (solution.getLiteral(var).toString());
// Otherwise the returned value is a URI
} else {
  System.out.println(solution.getResource(var).getURI());
}

From the code, above, you can see that in order to access the basic data value you use the get(String) method which expects the column name to be passed.  This will return null if there is no data associated with this row and column.  If there is a value, the method isLiteral() may be called to test whether the data is a literal.  If it is not than it will likely be a URI.  The URI can be accessed by calling the getResource(String) method, passing the column name, and calling the getURI() method on that value.

Close the QueryExecution instance

The last step is important.  The QueryExecution instance should be cleaned up by calling its close() method.

// Important - free up resources used running the query
qe.close();

These are the basic steps you need to carry out in order to execute a SPARQL query against a SPARQL endpoint using ARQoid.  Here is a screen shot of the Android emulator executing the example just covered.

Notes

A few other items for completeness.  First, remember to add the INTERNET permission to your Android manifest (<uses-permission android:name=”android.permission.INTERNET”/>).  Failure to do so will lead to an ARQoid failure when it tries to access the remote endpoint.  The stack trace will indicate a failure to access the URI – it won’t mention that there is a permission issue.

Also, depending on your query, you may be trying to access a lot of data which could be time consuming and also could cause issues with small memory devices.  You may limit the number of rows returned and set a starting row for the results.  This allows you to create a sliding window in your application by only pulling a few results and then allowing the user to ask for more.  These values are set on the Query instance.  Once you have the Query from the QueryFactory you can use these methods.

// Limit the number of results returned
// Setting the limit is optional - default is unlimited
query.setLimit(10);

// Set the starting record for results returned
// Setting the limit is optional - default is 1 (and it is 1-based)
query.setOffset(11);

The limit and offset given above would cause ARQoid to return 10 records, starting with the 11th one found. If there were fewer than 11 results then no records would be returned.

Conclusion

Hopefully if you are trying to use ARQoid this will give you a quick template to leverage the basic features of the engine.  In the future I’ll expand on this by adding other data sources as well as using the URIs returned by the query to create a richer result for the user.

Remember that you may download the sample code if you want to see the working Android demonstration application described here.  Also, you can install Sparql Droid which contains a variety of sample SPARQL queries that use the local model, SPARQL endpoints, RDF data sources as well as demonstrating federated queries.

If you have questions or comments about this topic please add them to this post or send them to me via my contact page.

Business rules, decision engines, BPM, complex event processing (CEP), these all invoke images of computers making speedy decisions to the benefit of our businesses.  The infrastructure, technologies and software that provide these solutions (SOA, XML schemas, rule engines, workflow engines, etc.) support the decision automation process.  However, they don’t know what decisions to make.

The BPM-related components we acquire provide the how of decision making (send an email, route a claim, suggest an offer).  Learning, supported by data analytics, provides a powerful path to the what and why of automated decisions (send this email to that person because they are at risk of defecting, route this claim to that underwriter because it looks suspicious, suggest this product to that customer because they appear to be buying these types of items).

I’ll start by outlining the high level journey from data to rules and the cyclic nature of that journey.  Data leads to rules, rules beget responses, responses manifest as more data, new data leads to new rules, and so on.  Therefore, the journey does not end with the definition of a set of processes and rules.  This link between updated data and the determination of new processes and rules is the essence of any learning process, providing a key function for the cognitive corporation.

The following image depicts the overall process of using data analytics to take corporate information and derive new business processes and rules, hence learning.  I will refer to the numbered items throughout this post.

Data Analytics is a general term and there are many subtleties within such a broad field.  In this case I’m focused on the machine (computer) learning aspect of analytics.  I’m skipping past the need to identify key data sources, create canonical definitions, and normalize information.  Overused, yet accurate, the phrase, “Garbage In, Garbage Out” applies to data analytics as much as any other aspect of computing.  The relevant data must be effectively organized before proceeding (in the diagram this is depicted as items 1, 2 and 3).

What is machine learning?  It is a way that computers can be used to look at data and find patterns that we don’t realize exist.  There are a variety of algorithms that allow computers to be used for this purpose.  Some are very difficult to understand and some are quite simple.  They each have strengths and weaknesses.  Not all work well for a given type of data or analytics.

Therefore, the first step for leveraging data analytics (on clean data, of course) is to understand the computer’s perception of that data at a high-level.  This is known as data preprocessing and contains within it tasks that are necessary in order to find actionable information within the data (diagram item 4).  The tasks can be outlined as: Aggregation, Sampling, Dimensionality Reduction, Feature Subset Selection, Feature Creation, Discretization, and Feature Transformation.  I will explore each of these tasks in future postings.

Once the data is understood and we know how to structure it for automated analytics (diagram items 5 and 6), we need to run it through machine learning algorithms (diagram item 7).  These are the secret sauce of many data analytics tools.  The algorithms involve a variety of mathematical approaches to identifying relationships within the data.  What isn’t always easy to understand is why the analytics are identifying certain relationships.  Some algorithms make this harder than others to discern.  As with data preprocessing’s steps, I’ll delve into these algorithms in future posts.

Fundamentally, the output from this type of tool is a predictive model (diagram item 8) that can take new data and predict the outcomes.  Assuming we have focused on something pertinent to our operations, retaining customers perhaps, then we want the computer to find a way to predict which customers are likely to defect.  If such a model is tested and found to provide accurate results then we are confident that within its black box it “knows” something about our defecting clients that we might be able to use in order to improve retention.

It is the next step, being able to use the model to derive a business rule change, which requires human intervention.  The task is to root out the underlying cause(s), which the computer has found, in a way that we are able to understand (diagram item 9) and, more importantly, that we may may act upon (diagram item 10).  This is the crux of leveraging data analytics to improve business operations.

To successfully leverage the data analytics findings (items 9 and 10) a business needs three things.  First, it must have a formal understanding of the processes used within the analytic environment.  Experts must be able to translate the predictive model back to the actual source data that is pertinent to the predictions.

Second, there must be an open and collaborative environment that accepts unanticipated data relationships, working to define them in business terms – not looking to dispute or discredit them. Often, people who “know the business” cannot accept what the data analytics results are showing.  The findings, often by definition, are at odds with commonly accepted “truths.”  This is part of the power of using these tools, they aren’t beholden to our mental baggage and, by design, they think outside of our business-knowledge-based box.

Third, the business must have an agile environment that can make changes to the underlying processes and rules culled from the model.  This permits the patterns and causes found by the data analytics tool to manifest as timely action within the business’ operation.  Therefore, there must be business leaders empowered to change business processes and rules, as well as an IT infrastructure that supports implementing rapid rule and process changes (diagram step 11).

The faster an organization can take data analytics results and update business operations (rules and processes), the better its ability to respond to changing business environments.  Such a capability provides a key differentiator for any business.  More and more companies are finding themselves competing in ever more commoditized markets.  It is an organization’s unique ability to use automation as a way to quickly personalize and flex to specific situations that allows it to be more productive, more responsive and ultimately more successful.

This process is not simple nor is it completely automatic.  It consistently requires manual effort and tuning.  Machines don’t do the thinking, they simply provide leaders with actionable information by which conclusions may be drawn and decisions may be made.

Some business use cases for data analytics tools are easier to implement than others.  For instance, predictive models around actuarial data lead to scoring rules in a business rule environment fairly directly.  The relationships between buying patterns and social media and their impact on business processes and rules are not as straightforward to map.  The rewards, however, are meaningful and worthwhile as long as the correct data is being used to drive the correct decisions.

If you are exploring data analytics as an input to business rule and process improvements I’d be interested in hearing about your experiences and thoughts.  Also, as I mentioned at the beginning, this post is meant to introduce the high-level concepts.  Future postings will dive deeper into the individual processes, tools and techniques that were touched upon.

I understand the desire to rely on unit testing and its ability to find issues and prevent regressions.  For TDD, I’ll need to write separately.  Fundamentally I’m a believer in white box testing.   Black box approaches, like TDD, seem to be of relatively little value to the overall quality and reliability of the code.  Meaning, I’d want to invest more effort in white box testing than in black box testing.

I’m somewhat jaded, being concerned with the code’s security, which to me is strongly correlated with its reliability.  That said, I believe that unit testing is much more constrained as compared to formal reviews.  I’m not suggesting that unit tests be skipped, rather that we understand that unit tests can catch certain types of flaws and that those types are narrow as compared to what formal reviews can identify.

Here is how I view the constraints around unit testing:

First, unit tests are normally implemented by the same developer who created (or will create) the code.  This is a huge constraint on the brain power (BP) being applied to the quality of the code.  In this case BP=1.  If the unit tests are created by a separate individual then BP>1 and, I argue, BP<2 because the tester is focused on the micro level (the unit level of code).

Second, unit testing is often used to only check that the code does what it is supposed to do.  This means unit tests don’t often check whether code does things it isn’t supposed to.

Third, unit tests don’t consider maintainability of the code, or really any macro-level concerns.  Passing unit test doesn’t mean that the code is easy to understand or logically organized.  I agree that single-purpose methods and well written code are easier to test, but bad code can be tested and even meet high coverage requirements.

The reason I believe that the study’s results (discussed in the previous post) are probably still accurate is that many software fundamentals are no different now than in 1986.  We used unit testing frameworks (sometimes called scaffolds) and leveraged unit tests to prevent regressions.  In some ways we had to be more concerned with the completeness of our test scenarios in 1986 due to the overhead of modifying an application.  Developers today can be somewhat cavalier with code changes since our system environments tend make distribution of updates easier.

I agree that new languages, paradigms and environments have not reduced the need for unit testing, quite the contrary.  We have more options and threats to deal with.  However, we can more quickly make and distribute an updated application than we could in 1986.

Considering the breadth of what can be identified, formal design and code reviews go beyond simply checking that for some inputs a valid output is calculated.  Instead, formal reviews apply BP=T(RE%) where T is the team size and RE% is the review effort percentage the team invests.

These reviews catch maintenance issues, identify best practices violations (beyond what a style checker would do), find opportunities for refactoring (reducing code, reducing complexity, etc.) and serve as a way for the team to increase its overall expertise through interactions and discussion.  Clearly, this represents a much broader value set than that provided by unit testing.

As I said in the original posting, this thinking isn’t a defense to skip unit testing in favor of formal reviews.  (I clamor for unit tests and high coverage metrics.)  Instead, my message is a call to understand that you need both (and other types of testing and inspections), realizing that the formal reviews catch a more comprehensive set of issues than unit testing.  Time and again I have seen organizations leveraging unit testing but not formal reviews.  This means that their RE% is zero.  For me this is a poor investment choice.

Perhaps it would be worth doing a small scale study to see if our shop has a similar experience?  It might be quite informative for the whole team.

At one point we were reviewing some code that had several error handling blocks that were not being covered in the unit tests.  These blocks were, arguably, unlikely or impossible to reach (such as a Java StringReader throwing an IOException).  There was some discussion by the team about the necessity of mocking enough functionality to cover these blocks.

Although we agreed that some of the more esoteric error conditions weren’t worth the programmer’s time to mock-up, it occurred to me later that we were missing an important point.  What mattered was that we were holding a formal code review and looking at those blocks of code.

Let me take a step back.  In 1986, Capers Jones published a book entitled Programming Productivity.  Although dated, the book contains many excellent points that cause you think about how to create software in an efficient way.  Here efficiency is not about lines of code per unit of time, but more importantly, lines of correct code per unit of time.  This means taking into account rework due to errors and omissions.

One if the studies presented in the book relates to identifying defects in code.  It is a study whose results seem obvious when we think about them.  However, we don’t always align our software development practices to leverage the study’s lessons and maximize our development efficiency.  Perhaps we believe that the statistics have changed due to language construct, experience, tooling and so forth.  We’d need similar studies to the ones presented by Capers Jones in order to prove that, though.

Below are a few of the actions from the book’s study of defect detection approaches.  I’ve skipped the low end and high-end numbers that Caper’s includes, simply giving the modes (averages) which are a good basis for comparison:

Based on this data, we see that formal reviews of the design and code are much more effective at finding defects than unit testing.  In this case, unit testing is focused on branch coverage.  Obviously, changing the testing expectations, such as applying domain testing concepts, might change the effectiveness. My guess is that such a change would not bring unit testing on par with formal code reviews but would improve its performance, at a cost of productivity – since domain testing takes more rigor to apply.

As Capers points out, these percentages can’t be added together.  In other words, there is an intersection of the defects found by these methods.  In his studies these methods found some of the same and some unique defects.  Therefore, this data does not provide a defense to skip unit testing.  Instead, each defect detection method should be used in a complementary fashion.  The statistical data does inform us regarding level-of-effort decisions.  Also, we can use this information to help define where to cut corners, if necessary.

If we have to reduce the time we spend in the testing phase, we would do better to give up some unit testing in favor of keeping more formal code reviews.  This isn’t always the way we approach such situations.  It is easy to skip the formal reviews, believing that the time would be better spent by developers creating more tests for their code.  Apparently this is not the case.

I think it is valuable to periodically remind ourselves about studies like these as a way to make sure we aren’t falling into bad habits or being misled by incorrect assumptions.  Also, as teams bring on new members, it is good to review our practices, understand the relevant literature and actively discuss why we do what we do (and whether it needs to change).

A parting thought about statistics like the ones quoted here.  They are an average from a very broad array of problem types and development shops.  As Boris Beizer has pointed out, each shop has a “bug fingerprint”.  The bug fingerprint is impacted by things like the technologies being used, types of applications being developed and the experience of the team members.

Further, different types of bugs are better identified through different detection methods (branch tests, domain tests, code inspections, etc.).  Therefore, the optimal set of testing approaches for a given group of developers will differ somewhat from the average.  I’ll discuss this in a future post.

What does your team do in regards to testing and inspections?  Are there other techniques you find useful for identifying software defects?  I welcome your comments and feedback.

As I’ve placed these separate projects into a common context of my own, I’ve concluded that the long term goal of leveraging information technology must be for it to support cognitive processes.  I don’t mean that the computers will think for us, rather that IT solutions must work together to allow a business to learn, corporately.

The individual tools that we utilize each play a part.  However, we tend to utilize them in a manner that focuses on isolated and directed operation rather than incorporating them into an overall learning loop.  In other words, we install tools that we direct without asking them to help us find better directions to give.

Let me start with a definition: similar to thinking beings, a cognitive corporation™ leverages a feedback loop of information and experiences to inform future processes and rules.  Fundamentally, learning is a process and it involves taking known facts and experiences and combining them to create new hypothesis which are tested in order to derive new facts, processes and rules.  Unfortunately, we don’t often leverage our enterprise applications in this way.

We have many tools available to us in the enterprise IT realm.  These include database management systems, business process management environments, rule engines, reporting tools, content management applications, data analytics tools, complex event processing environments, enterprise service buses, and ETL tools.  Individually, these components are used to solve specific, predefined issues with the operation of a business.  However, this is not an optimal way to leverage them.

If we consider that these tools mimic aspects of an intelligent being, then we need to leverage them in a fashion that manifests the cognitive capability in preference to simply deploying a point-solution.  This involves thinking about the tools somewhat differently.

As I consider the vision of empowering a learning corporation, I break enterprise tools into 6 general areas.  These areas provide a portion of what is required in order to survive and grow in an environment.  These 6 areas are: Think, Communicate, Act, Know, Sense and Learn.  They are in no particular order since the absence of any will prevent meaningful growth from occurring.

I’ll be expanding on this concept over time, drilling into each area and the solutions we often use to meet that need.  Depicted below is a very high-level diagram of these areas with the categories of products or functions I place in each.  The categories are broad and I’ve chosen key terms to represent a lot of different tools and techniques.

This framework provides an infrastructure, similar to how a person is made up of a set of systems.  However, it is the information that is shared between systems that becomes the key to actually supporting the idea of a thinking and learning system.  There are assumptions we make as we design enterprise systems that will limit our ability to empower a cognitive corporation™.

For instance, we may limit our definition of valuable data to the information collected by our on-line systems.  A broader interpretation begins to consider the process steps followed and the rules executed for a given interaction as data.  There are many places where such assumptions and limitations will interfere with gaining a true advantage from our enterprise solutions.

We must change our view of the way that a business benefits through the use of IT.  The focus on feature sets for a specific type of problem must be replaced with a focus on the whole set of systems and how they interrelate and may be leveraged to benefit business growth – in multiple dimensions.  This will allow us to make an order-of-magnitude jump in the value derived from IT investments.

Therefore, an enterprise architecture goes beyond the role that systems will play, it must define how the systems will interact within the entire enterprise.  We are then in a position to leverage these powerful tools to create a cognitive corporation™.

I had two questions I wanted to answer: 1) did I achieve the vehicle’s advertised MPG; and is the gas savings significant versus owning a non-hybrid.

To answer the second question I needed to choose an alternate vehicle to represent the non-hybrid.  I thought a good non-hybrid to compare would be the 2007 Civic EX since the features are similar to my car, other than the hybrid engine.

Some caveats, I am not including service visits, new tires or the time value of money in my TCO calculations.

First some basic statistics.  I have driven my car a little over 105,500 miles at this point.  I have used about 2,508 gallons of gas costing me $7,466 over the last four years.  I have had to fill up the car about 290 times.  My mileage over the lifetime of the car has averaged 42 MPG which matches the expected MPG from the original sticker.  Question 1 answered – advertised MPG achieved.

To explore question 2, I needed an average MPG for the EX.  Since traditional cars have different city and highway MPG I had to choose a value that made sense based on my driving, yet be conservative enough to give me a meaningful result.  The 2007 Civic EX had an advertised MPG of 30 city and 38 highway.  I do significantly more highway than city driving, but thought I’d be really conservative and choose 32 MPG for my comparison.

With that assumption in place, I can calculate the gas consumption I would have experienced with the EX.  Over the 105,500 miles I would have used about 3,306 gallons of gas costing about $9,903.

What this means is that if I had purchased the EX in 2007 instead of the Hybrid I would have used about 798 more gallons of gas costing me an additional $2,437 over that time period.  That is good to know, both in terms of my reduced carbon footprint and fuel cost savings.

However, there is a cost difference between the two vehicle purchase prices.  The Hybrid MSRP was $22,600 while the EX was $18,710.  The Hybrid cost me $3,890 more to purchase.

Gas Consumption (Hybrid versus Postulated EX)

So over the four years I’ve owned the car, I’m actually currently behind by $1,453 over purchasing the EX (again not considering the time value of money, which would make it worse).  I will need to keep the car for several more years to break even, and in reality it may not be possible to ever break even if I start including the time value factor.   Question 2 answered and it isn’t such good news.

My conclusion is that purchasing a hybrid is not a financially smart choice.  I also wonder if it is even an environmentally sound one given the chemicals involved in manufacturing the battery.  Maybe the environment comes out ahead or maybe not.  I think it is unfortunate that the equation for the consumer doesn’t even hit break even when trying to do the right thing.

With my main questions answered I did spend a little time playing with the data.  After all, exploring data is fun.  For the moment I’ll stick with the more mundane reporting.  I’ve loaded the data into Rapid Miner and Weka to do some mining, which I’ll write about later.

Miles Driven and MPG by Season

I split the data in seasons, since I’ve noted an obvious pattern in MPG changing through the year.  I then reported on miles driven and MPG in each season.  To keep the reporting balanced I only used the three complete years of data that I have (it’ll be another 7 months to fill out another complete set of seasons).

  


Looking at the charts it is interesting to see the differences in total driving distance by season.  I wasn’t expected to see that, or if anything differed, I expected winter to involve fewer miles driven than other seasons.  As I’d observed informally, the average MPG clearly changes during winter.  I think increased Ethanol added by fuel companies during cold months is the likely culprit.  Interesting that gas prices don’t reflect that lowered efficiency during the winter.

All told, even though I do 25% of my driving in the winter, I use 27% of the gas I purchase.  Not a huge difference, but certainly not optimal.  I should drive less in the winter to maximize my annual savings.

As I begin considering the purchase of a new car, I am less sure that a hybrid will be my top choice, especially since many small cars get good mileage, easily within 6 MPG (highway) of a lot of hybrids.

If others out there have had a significantly different experience with their hybrid I would be interested in hearing about it.

I’ll start on the development side.  I use Eclipse and the android development plugin is very helpful. It greatly streamlines the development process.  Principally, it automates the generation of the resources from the source files.  These resources, such as screen layouts and menus, require a conversion step after being edited.  The automation, though, comes at a price.

Taking a step back, Android doesn’t use an Oracle-compliant JVM.  Instead it uses the Dalvik VM.  This difference creates two major ramifications: 1) not all the standard packages are available; and 2) any compiled Java code has to go through a step to “align” it for Dalvik. This alignment process is required for class files you create and for any third-party classes (such as those found in external JAR files).  Going back to item 1, if an external JAR file you use needs a package that isn’t part of Dalvik, you’ll need to recreate it.

The alignment process works pretty fast for small projects.  My first application was a game that used no external libraries.  The time required to compile and align was indistinguishable from typical compile time.  However, with Sparql Droid, which uses several large third-party libraries, the alignment time is significant – on the order of a full minute.

That delay doesn’t sound so bad, unless you consider the Build Automatically feature in Eclipse.  This is a feature that you want to turn off when doing Android development that includes third-party libraries of any significance. Turning off that feature simply adds an extra step to the editing process, a manual build, and slightly reduces the convenience of the environment.

With my first Android project, I was able to edit a resource file and immediately jump back to my Java code and have the resource be recognized.   Now I have to manually do a build (waiting a minute or so) after editing a resource file before it is recognized on the code side.  Hopefully the plug-in will be improved to cache the aligned libraries, saving that time when the libraries aren’t being changed.

Another lesson learned for me relates to GUI interaction, specifically updating the GUI.  In Sparql Droid I am using threads so that processing of ontologies or execution of SPARQL queries does not interfere with UI interaction.  I immediately hit the Android design principle that only the thread that created a view can update the view.

Attempting to interact with a UI component from another context (thread) leads to a CalledFromWrongThreadException being thrown.  The correct way to have an asynchronous update to the UI is using a Handler instance that is created as part of the view and therefore runs under that view’s thread. Once I setup a handler and used events to communicate updates, I was able to create threads and manage asynchronous GUI updates without any issues.

A major frustration point for me was an Ant 1.7 compatibility issue. I hadn’t bothered upgrading to Ant 1.8 and for my first Android application I had no issues with the release target that the Android environment provides.  However, the reason it worked was that I was not using any third-party JAR files.

There is an incompatibility with the Android development environment’s dynamic inclusion of JARs in the default libs folder.  The real issue is that the Android setup doesn’t complain about Ant 1.7.  According to this bug report that shortcoming will be resolved in the next Android development tools release (perhaps it has already).

Unfortunately the build failure is silent (since the build classpath includes the JARs, only the Dalvik alignment process doesn’t) and the symptom is, obviously, a ClassNotFoundException when you run the released application. Focusing on that error led me down the wrong path for a while since I though the issue might be an incompatibility with a class being aligned – even though it was working in the emulator.  I eventually unzipped the APK file and saw that the JARs were not there. Given that fact, Google quickly led me to a report about the Ant 1.7 and Android tools problem.

Of course a major constraint when programming for the phone is memory. When I programmed for my Vic 20 (with a whopping 3.5 K of user memory) I prided myself on what I could squeeze into the system.  I’m back to pursuing that line of design.

For me, the most interesting aspect of dealing with constrained memory is reacting to OutOfMemoryException situations. I’m experimenting with detecting these and changing the operation of the program.  In many cases the out of memory condition isn’t fatal and can be handled (at least with the functionality I’m working with currently).

For example, a common place for me to exhaust memory is when resizing images that have been downloaded.  In my initial design, I downloaded the image and held onto the original, returning a resized copy to my view.  My first memory-sensitive fix was to resize the image and only keep the smaller version.

However, depending on the number of images being downloaded this can still overwhelm the available heap.  I have been experimenting with catching the out of memory condition and abandoning the image.  This seems to work fine in the emulator.  Next I’ll be trying to save the image to local storage as a last ditch effort to not losing it.

I have also been learning a bit about image manipulation. There are API calls that seem to imply they will support resizing an image in a general fashion but they don’t seem to actually alter the image.  Specifically, I tried creating a Canvas with my desired dimensions and calling the Image class’ draw() method, keeping the returned Image instance.  However that image had the same dimensions as the original.

To actually resize an image, I ended up having to create a Bitmap instance from the Image and use the createBitmap() method, passing in the desired dimensions.  It isn’t clear to me from the API documentation why my original approach doesn’t work.

One other design consideration that I’m still fussing with is laying out sets of query results. When pulling data that is best represented in groups we often use tables.  Each row is a member of the group and each column is one attribute of the group.  However, on the small UI of a phone that design almost always guarantees horizontal scrolling.  Also, if the columns require varying amounts of vertical space then the table looks odd when the taller columns aren’t visible.

When I first released Sparql Droid I had the SPARQL results reported in a table.  I didn’t mind the horizontal scrolling and for simple result sets the tables weren’t too wide and my columns had similar amounts of data in them so no rows were taller than others.  Once I opened up my queries to a broader set of endpoints and added images that all changed.

Using the HorizontalLayout becomes problematic; it implies an infinitely wide canvas. The side effect I encountered was that large text fields simply ended up as one long line rather than wrapping.  Add to that the fact that images occupy varying vertical space, and the table ended up looking very odd.

I removed the use of a horizontal layout and instead now group results with a horizontal divider label row.  I like this visualization better for most situations.  Though I think for small sets of attributes that have short values, a horizontal layout makes more sense.  This is another place, like dealing with memory constraints, where I’ll probably want the program to make a dynamic decision.  In this case, deciding on a horizontal or vertical record layout.

All told, these are the Android programming events that have been of the most interest, and in some cases frustration, for me over the past few weeks.  I’m looking forward to adding more features to Sparql Droid while learning more about the Android environment.

I’d appreciate your feedback whether about programming in general, semantic technology or the Sparql Droid application.

I am a strong advocate of leveraging semantic technology.  I believe that this new paradigms provide a more flexible basis for our journey to create meaningful, efficient and effective business automation solutions. However, one challenge that differentiates leveraging semantic technology from more common technology (such as relational databases) is the lack of mature tools supporting a business system infrastructure.

It will take a while for solid solutions to appear.  Support for mainstream capabilities such as reporting, BI, workflow, application design and development that all leverage semantic technology are missing or weak at best.  Again, this is an opportunity and a challenge.  For those who enjoy creating computer software it presents a new world of possibilities.  For those looking to leverage mature solutions in order to advance their business vision it will take investment and patience.

In parallel with the semantic paradigm we have an ever increasing focus on mobile-based solutions. Smart phones and tablet devices, focused on network connectivity as the enabler of value, rather than on-board storage and compute power, are becoming the standard tool for human-system interaction.  As we design new solutions we must keep the mobile-accessible mantra in mind.

As part of my exploration of these two technologies, I’ve started working on a semantic technology mobile application called Sparql Droid. Built for the Android platform, my goal is a tool for exploring and mashing semantic data sources.  As a small first-step I’ve leveraged the Androjena port of the Jena framework and created an application with some basic capabilities.

Sparql Droid allows the user to enter an ontology, run the Androjena OWL reasoned and then use SPARQL to query the resulting triples.  This functionality provided a way to prove to myself that the pieces would work, as well as to get a feel for the performance and scalability of the Androjena libraries running on a smartphone.  I also wanted to see how a multi-threaded application would perform on the Android.

The application works and I have placed it in the Android Market for those that are willing to experiment with it.  The real goal of the application is to become a point-and-click tool for exploring and mashing semantic data. However, having a semantic reasoner available in order to do some experimentation seems like a feature one would want in a semantic toolbox so I believe this functionality will remain useful.

I’ll be writing a bit in an upcoming blog post about my development journey.  I have learned a bit about Android programming in the process of building this application and perhaps others will be able to benefit from my experiences.

In the meantime, if you are willing to test the application and provide feedback on its operation as well as collaborate on fleshing this out I would appreciate hearing from you.

OpenOffice provides five key office-type software packages.  Writer for word processing, Calc for spreadsheets, Impress for presentations, Base for database work and Draw for diagrams.  There is a sixth tool, Math for creating scientific formulas and equations, which is similar to the equation editor available with MS Word.

As one of my coworkers suggests when providing positive and negative feedback, I’ll use the sandwich approach.  If you’ve not heard of this approach, the idea is to start with some good points, then go through the issues and wrap up with a positive item or two.

On a positive note, the OpenOffice suite is production worthy.  For the two tools that seem to be most commonly used in office settings, word processing and spreadsheets, the Writer and Calc tools have all the features that I was used to using with the Microsoft Office (MS Office) tools.  In fact for the most part I was unaware that I was using a different word processor or spreadsheet. From a usability perspective there is little or no learning curve for an experienced MS Office user to effectively use these OpenOffice tools.

Of key importance to me was the ability to work with others who were using MS Office.  The ability for OpenOffice to open the corresponding MS Office documents worked well at first but then cracks began to show.

OpenOffice Writer was able to work with MS Office documents in both the classic Word “doc” format and the newer Word 2007 and later “docx” format.  However, Writer cannot save to the “docx” format.  If you open a “docx” then the only MS Office format that can be used to save the document is the “doc” format.  At first this was a small annoyance but obviously meant that if a “docx” feature was used it would be lost on the export to “doc”.

Another aggravating issue was confusion when using the “Record Changes” feature, which is analogous to the “Track Changes” features in MS Word.  Although the updates made using MS Word could be seen in Writer, notes created in Word were inconsistently presented in Writer.  The tracked changes were also somewhat difficult to understand when multiple iterations of edits had occurred.  At work we often use track changes as we collaborate on documentation so this feature needs to work well for our team.

I eventually ran into two complete show-stoppers.  In the first case, OpenOffice was unable to display certain images embedded in an MS Word document.  Although some images had previously been somewhat distorted, it turned out that certain types of embedded images wouldn’t display at all.  The second issue involved the Impress (presentation) tool.

I’ve mentioned that Writer and Calc are very mature and robust.  The Impress tool doesn’t seem to be as solid.  As I began working with a team member on a presentation we were delivering in February I discovered that there appears to be little compatibility between MS PowerPoint and Impress. I was unable to work with the PowerPoint presentation using Impress.  The images, animations and text were all completely wrong when opened in Impress.

To be fair, I have created standalone presentations using Impress and the tool has a good feature set and works reliably.  I’ve used it to create and deliver presentations with no issues.  OpenOffice even seems to provide a nicer set of boilerplate presentation templates than the ones that come with MS PowerPoint.

My conclusion after working with OpenOffice now for about 3 months is that it is a completely viable solution if used as the document suite for a company. However, it is not possible to succeed with these tools in a heterogeneous environment where documents must be shared with MS Office users.

I will probably continue to use OpenOffice for personal work.  I’ll also continue to upgrade and try using it with MS Office documents from time to time.  Perhaps someday it will be possible to leverage this suite effectively in a multi-platform situation. Certainly from an ROI perspective it becomes harder and harder to justify the cost of the MS Office suite when such a capable and well-designed open source alternative exists.

Have you tried using alternatives to MS Office in a heterogeneous office tool environment?  Have you had better success than I have?  Any pointers on being able to succeed with such an approach?  Is such an approach even reasonable?  Please feel free to share your thoughts.