The RDF Web Applications Working Group has published new Working Drafts.
April 20, 2011
RDFa API and RDFa 1.1 Primer Drafts Updated
Comments Off on RDFa API and RDFa 1.1 Primer Drafts Updated
Winning the Keyword Research Game
Winning the Keyword Research Game
Webinar – Tuesday, April 26, 2011
From the website:
Learn key strategies for leveraging keyword research to spend smarter, gain competitive advantage and ultimately drive more leads!
In this webinar, WordStream founder Larry Kim shares his exclusive tips and techniques for winning the keyword research game. You’ll learn the three-step process he follows when conducting keyword research for SEO and PPC, including tips for:
- How to dominate a search category for your brand
- Why keyword niches are more important than single keywords
- How to apply your keyword research in on-page SEO
Topic maps can facilitate discovery of information by different means of identifying the same subject, but only if you have recorded those different means in your topic map.
Quite often that will mean several different keywords for any given subject.
I will try to attend and report back.
Comments Off on Winning the Keyword Research Game
April 19, 2011
The Lisp Curse
The Lisp Curse by Rudolf Winestock begins:
This essay is yet another attempt to reconcile the power of the Lisp programming language with the inability of the Lisp community to reproduce their pre-AI Winter achievements. Without doubt, Lisp has been an influential source of ideas even during its time of retreat. That fact, plus the brilliance of the different Lisp Machine architectures, and the current Lisp renaissance after more than a decade in the wilderness demonstrate that Lisp partisans must have some justification for their smugness. Nevertheless, they have not been able to translate the power of Lisp into a movement with overpowering momentum.
In this essay, I argue that Lisp’s expressive power is actually a cause of its lack of momentum.
Read the essay, then come back here. I’ll wait.
… … … …
OK, good read, yes?
At first blush, I thought about HyTime and its expressiveness. Or of topic maps. Could there be a parallel?
But non-Lisp software projects proliferate.
Let’s use http://sourceforge.net for examples.
Total projects for the database category – 906.
How many were written using Lisp?
| Lisp | 1 |
Compared to:
| Java | 282 | |
| C++ | 106 | |
| PHP | 298 | |
| Total: | 686 | |
That may not be fair.
Databases may not attract AI/Lisp programmers.
What about artificial intelligence?
| Lisp | 8 |
| Schema | 3 |
| Total: | 11 |
Compared to:
| Java | 115 |
| C++ | 111 |
| C | 42 |
| Total: | 268 |
Does that mean that Java, C++ and C are too expressive?
Or that their expressiveness has retarded their progress in some way?
Or is some other factor is responsible for proliferation of projects?
And a proliferation of semantics.
*****
Correction: I corrected sourceforge.org -> sourceforge.net and made it a hyperlink. Fortunately sourceforge silently redirects my mistake in entering the domain name in a browser.
Comments Off on The Lisp Curse
TMQL4J 3.1 Released
From the release notes:
- new behavior of roles axis
- forward navigation return the roles of an association
- backward navigation returns the association acts as parent of a role
- new behavior of players axis
- forward navigation return the players of a role or all roles of the association
- backward navigation returns the roles played by the topic
- new roletypes axis
- forward navigation results in the role types of an association
- backward navigation results in the associations having a role with this type
- new datatype axis
- new update operator ‘REMOVE’ to update clause
- avaible for: names, occurrences, characteristics, locators, indicators, item, scope, topics, types, supertypes, subtypes, instances
- characteristics added as alias for names and occurrences modification
- add variants anchor as update context
- new method @IResultSet
- toTopicMap: If the result set supports this operation, it will return a topic map copy containing only the topics and association contained in
- toCTM: If the result set supports this operation, it will return a CTM string or stream containing only the topics and association contained in
- toXTM: If the result set supports this operation, it will return an XTM string or stream containing only the topics and association contained in
- toJTMQR: If the result set supports this operation, it will return a JTMQR string or stream containing only the topics and association contained in
- CTMResult
- rename method resultsAsMergedCTM to toCTM
- rename method resultsAsTopicMap to toTopicMap
- XMLResult
- rename method resultsAsMergedXML to toXML
- add stream variant of method toXML
- the arguments on update roles are modified argument before operator is the role type, the value after is the player
- update-clause allow any value-expression in front of the operator
- moving some classes
- new function fn:max expecting two arguments
- context of count and counts
- e.g.: fn:max ( // tm:subject , fn:count ( . / tm:name )) to get the maximum number of names a topic instance contains
- new function fn:min expecting two arguments
- context of count and counts
- e.g.: fn:min ( // tm:subject , fn:count ( . / tm:name )) to get the minimum number of names a topic instance contains
- value-expression supports boolean-expression to return true or false
- the update handler checks the value of occ and variants according to the datatype (validate the value for the given datatype)
- a pragma was added to disable this functionality datatype-validation
- the update of variants and occurrences will reuse the datatype instead of setting string automatically, like TMAPI do
- a pragma was added to disable this functionality datatype-binding
- allow prepared argument add new positions:
- as optional axis argument
- as part of update value
More usefully, you could install a copy of TMQL4J 3.1 and take a look at: TMQL4J Documentation and Tutorials.
Comments Off on TMQL4J 3.1 Released
Functional Scala – Mario Gleichmann
Functional Scala – Mario Gleichmann
I ran across this delightful series of posts by Mario on Functional Scala.
To facilitate finding posts of interest, I have created this listing:
- Functional Scala: Introduction
- Functional Scala: Functions
- Functional Scala: Functions as Objects as Functions
- Functional Scala: Closures
- Functional Scala: Comprehending Comprehensions
- Functional Scala: High, Higher, Higher Order Functions
- Functional Scala: Lambdas and other shortcuts
- Functional Scala: Turning Methods into Functions (or WTF is eta expansion?)
- Functional Scala: Polymorphic Functions ?!?
- Functional Scala: Algebraic Datatypes – Enumerated Types
- Functional Scala: Algebraic Datatypes – Sum and Product Types
- Functional Scala: Algebraic Datatypes – ‘Sum of Products’ Types
- Functional Scala: Pattern Matching – the basics
- Functional Scala: Combinatoric Pattern Matching
- Functional Scala: Pattern Matching on product types
- Functional Scala: a little expression language with algebraic datatypes and pattern matching
- Functional Scala: Expressions, Extensions and Extractors
- Functional Scala: Tinkerbell, Frogs and Lists
- Functional Scala: List sugarization
- Functional Scala: Essential list functions
- Functional Scala: Quiz with Lists – common list functions, handcraftet
I will be updating this list as new posts appear.
A couple of general Scala you may find of interest:
Comments Off on Functional Scala – Mario Gleichmann
Map / Reduce – A Visual Explanation
Map / Reduce – A Visual Explanation
Interesting visualization of Map / Reduce in the context of processing a calculation of comments on blog entries.
Comments Off on Map / Reduce – A Visual Explanation
Detexify2 – LaTeX symbol classifier
Detexify2 – LaTeX symbol classifier
Clever interface that enables the search for a LaTeX symbol by drawing the symbol in a provided box.
Aside from its usefulness to the TeX/LaTeX community, I mention this because it illustrates that not all searches (or subject identities) are text based.
Comments Off on Detexify2 – LaTeX symbol classifier
Aranuka – 1.1.0 release
Project Description:
The project provides a set of annotations to map a domain model to a topic map schema. With connectors it is possible to persist instances of the model to a topic map.
It’s like Hibernate only for Topic maps.
If you are unfamiliar with Hibernate, see: www.hibernate.org, for resources and materials.
From the release notes:
- add autogenerate flag to Id annotation -> identifiers which are null will be generated if true
- implemented TMQL query for session
- added “addPackage” for classregistration
- using proxies for topic retrieval which enables lazy loading of attributes
- implementes count method of session
You may also find the Aranuka Handbook useful.
Comments Off on Aranuka – 1.1.0 release
April 18, 2011
Perception and Action: An Introduction to Clojure’s Time Model
Perception and Action: An Introduction to Clojure’s Time Model
Summary:
Stuart Halloway discusses how we use a total control time model, proposing a different one that represents the world more accurately helping to solve some of the concurrency and parallelism problem.
To tempt you into watching this video, consider the following slide:
identity
- continuity over time
- built by minds
- sameness across a series of perceptions
- not a name, but can be named
- can be composite
I will be posting other material from this presentation (as well as watching the video more than once).
(BTW, I saw the reference to this presentation in a tweet from Alex Popescu, myNoSQL.)
Comments Off on Perception and Action: An Introduction to Clojure’s Time Model
Sage Bionetworks Commons Congress – 2011
Sage Bionetworks Commons Congress – 2011
Presentations and videos.
If you are at all concerned with semantic integration in healthcare contexts, this is a must see resource.
It is going to take a while to work through all the individual presentations.
Comments Off on Sage Bionetworks Commons Congress – 2011
Classify content with XQuery
Classify content with XQuery by James R. Fuller (jim.fuller@webcomposite.com), Technical Director, Webcomposite.
Summary: With the expanding growth of semi-structured and unstructured data (XML) comes the need to categorize and classify content to make querying easier, faster, and more relevant. In this article, try several techniques using XQuery to automatically tag XML documents with content categorization based on the analysis of their content and structure.
Good article on the use of XQuery for basic text analysis and how to invoke web services while using XQuery for more sophisticated text analysis.
Comments Off on Classify content with XQuery
Mashups using IBM Mashup Center 3.0
Tutorial: Introduction to creating mashups using IBM Mashup Center 3.0
Since I am attending the One Mashup to Rule Them All webinar this week (20th of April, 2011), I thought I would look at some other mashup solutions.
The tutorial appears to be complete and a good introduction to the IBM Mashup Center 3.0 tool.
I am particularly interested in Module H: Publishing and sharing your mashup.
In the lesson you:
In the Tags field, type customer, tutorial, and sales. Tagging helps ensure that others will be able to find your mashup when using these keywords in searches.
Correction: The last sentence should read:
In the Tags field, type customer, tutorial, and sales. Tagging helps ensure that others will be able to find your mashup when using only these keywords in searches.
That’s the mashup problem in nutshell isn’t it?
You are limited to the imagination of the mashup author in creating keywords for finding the mashup.
I may happen to use the same keywords but we all know that is a hit or miss proposition.
IBM should use its experience with Watson to supplement keyword lists to insert likely alternatives.
And the conditions when those alternatives are likely to be seen. (Dare we say properties of a subject?)
Comments Off on Mashups using IBM Mashup Center 3.0
Biomedical Machine Learning Classifiers
A Software Framework for Building Biomedical Machine Learning Classifiers through Grid Computing Resources by Raul Pollán, Miguel Angel Guevara Lopez and Eugénio da Costa Oliveira.
Abstract:
This paper describes the BiomedTK software framework, created to perform massive explorations of machine learning classifiers configurations for biomedical data analysis over distributed Grid computing resources. BiomedTK integrates ROC analysis throughout the complete classifier construction process and enables explorations of large parameter sweeps for training third party classifiers such as artificial neural networks and support vector machines, offering the capability to harness the vast amount of computing power serviced by Grid infrastructures. In addition, it includes classifiers modified by the authors for ROC optimization and functionality to build ensemble classifiers and manipulate datasets (import/export, extract and transform data, etc.). BiomedTK was experimentally validated by training thousands of classifier configurations for representative biomedical UCI datasets reaching in little time classification levels comparable to those reported in existing literature. The comprehensive method herewith presented represents an improvement to biomedical data analysis in both methodology and potential reach of machine learning based experimentation.
I recommend a close reading of the article but the concluding lines caught my eye:
…tuning classifier parameters is mostly a heuristic task, not existing rules providing knowledge about what parameters to choose when training a classifier. Through BiomedTK we are gathering data about performance of many classifiers, trained each one with different parameters, ANNs, SVM, etc. This by itself constitutes a dataset that can be data mined to understand what set of parameters yield better classifiers for given situations or even generally. Therefore, we intend to use BiomedTK on this bulk of classifier data to gain insight on classifier parameter tuning.
The dataset about training classifiers may be as important if not more so than use of the framework in harnessing Grid computing resources for biomedical analysis. Looking forward to reports on that dataset.
Comments Off on Biomedical Machine Learning Classifiers
Watson and Healthcare
From the webpage:
IBM Watson’s stellar performance in the Jeopardy! show captured the world’s imagination. The first real world application for Watson involves healthcare. How does Watson address issues that previous generations of tools have not been able to address? What are the technical approaches Watson takes to set it apart from other systems? This article answers how Watson takes on those questions and gives you a sneak peek of the technology behind Watson based on scientific papers, specifications, articles published by the IBM team, and interviews with university collaborators.
One of the things I find the most interesting about the Watson project is that Apache UIMA (Unstructured Information Management Architecture) lies at its very core.
In part because I don’t think a significant part of all data is ever going to appear in structured format, whether that be Linked Data, some fuller/lesser form of RDF, Topic Maps or some other structured format. That being the case, we are going to have to deal with data as it presents itself and not the soft pitch form of say Linked Data.
That will include “merging” based on assumptions we impose on or derive from data and later verify or revise.
How skillful we are at building evolving systems with “memories” of past choices will determine how useful our systems are to users.
The article has a number of resources and pointers.
Comments Off on Watson and Healthcare
April 17, 2011
Thrust Graph Library
From the website:
Thrust Graph Library provides graph container, algorithm, and other concepts like a Boost Graph Library. This Library based on the thrust, which is a CUDA library of parallel algorithms with an interface resembling the C++ Standard Template Library (STL).
Comments Off on Thrust Graph Library
Programming in Scala, First Edition
Programming in Scala, First Edition
by Martin Odersky, Lex Spoon, and Bill Venners.
Entire text of the first edition (2008).
Concludes with writing a spreadsheet application in Scala.
I can’t imagine even Scala making spreadsheets interesting but we’ll see. 😉
A good starting point for an introduction to Scala.
Good Relationships: The Spring Data Graph Guide Book
Good Relationships: The Spring Data Graph Guide Book (1.0.0-BUILD-SNAPSHOT)
From About this book:
Welcome to the Spring Data Graph Guide Book. Thank you for taking the time to get an in depth look into Spring Data Graph. This project is part of the Spring Data project, which brings the convenient programming model of the Spring Framework to modern NOSQL databases. Spring Data Graph, as the name alludes to, aims to provide support for graph databases. It currently supports Neo4j.
It was written by developers for developers. Hopefully we’ve created a document that is well received by our peers.
If you have any feedback on Spring Data Graph or this book, please provide it via the SpringSource JIRA, the SpringSource NOSQL Forum, github comments or issues, or the Neo4j mailing list.
This book is presented as a duplex book, a term coined by Martin Fowler. A duplex book consists of at least two parts. The first part is an easily accessible tutorial that gives the reader an overview of the topics contained in the book. It contains lots of examples and discussion topics. This part of the book is highly suited for cover-to-cover reading.
We chose a tutorial describing the creation of a web application that allows movie enthusiasts to find their favorite movies, rate them, connect with fellow movie geeks, and enjoy social features such as recommendations. The application is running on Neo4j using Spring Data Graph and the well-known Spring Web Stack.
The Elements of Statistical Learning: Data Mining, Inference, and Prediction. Second Edition
The Elements of Statistical Learning: Data Mining, Inference, and Prediction. Second Edition
by Trevor Hastie, Robert Tibshirani and Jerome Friedman.
The full pdf of the latest printing is available at this site.
Strongly recommend that if you find the text useful, that you ask your library to order the print version.
From the website:
During the past decade has been an explosion in computation and information technology. With it has come vast amounts of data in a variety of fields such as medicine, biology, finance, and marketing. The challenge of understanding these data has led to the development of new tools in the field of statistics, and spawned new areas such as data mining, machine learning, and bioinformatics. Many of these tools have common underpinnings but are often expressed with different terminology. This book descibes the important ideas in these areas in a common conceptual framework. While the approach is statistical, the emphasis is on concepts rather than mathematics. Many examples are given, with a liberal use of color graphics. It should be a valuable resource for statisticians and anyone interested in data mining in science or industry. The book’s coverage is broad, from supervised learning (prediction) to unsupervised learning. The many topics include neural networks, support vector machines, classification trees and boosting–the first comprehensive treatment of this topic in any book.
This major new edition features many topics not covered in the original, including graphical models, random forests, ensemble methods, least angle regression & path algorithms for the lasso, non-negative matrix factorization and spectral clustering. There is also a chapter on methods for “wide” data (italics p bigger than n), including multiple testing and false discovery rates.
Trevor Hastie, Robert Tibshirani, and Jerome Friedman are professors of statistics at Stanford University. They are prominent researchers in this area: Hastie and Tibshirani developed generalized additive models and wrote a popular book of that title. Hastie wrote much of the statistical modeling software in S-PLUS and invented principal curves and surfaces. Tibshirani proposed the Lasso and is co-author of the very successful {italics An Introduct ion to the Bootstrap}. Friedman is the co-inventor of many data-mining tools including CART, MARS, and projection pursuit.
Comments Off on The Elements of Statistical Learning: Data Mining, Inference, and Prediction. Second Edition
April 16, 2011
MERGE Ahead
Merge Ahead: Introducing the DB2 for i SQL MERGE statement
Karl Hanson of IBM writes:
As any shade tree mechanic or home improvement handyman knows, you can never have too many tools. Sure, you can sometimes get by with inadequate tools on hand, but the right tools can help complete a job in a simpler, safer, and quicker way. The same is true in programming. New in DB2 for i 7.1, the MERGE statement is a handy tool to synchronize data in two tables. But as you will learn later, it can also do more. You might think of MERGE as doing the same thing you could do by writing a program, but with less work and with simpler notation.
Don’t panic, it isn’t merge in the topic map sense but it does show there are market opportunities for what is a trivial task for a topic map.
That implies to me there are also opportunities for more complex tasks, suitable only for topic maps.
Comments Off on MERGE Ahead
The Path-o-Logical Gremlin
Slides from Marko Rodriguez presented at: The 2nd International Workshop on Graph Data Management (GDM’11) Hannover, Germany April 16, 2011.
State of Gremlin 0.9.
Very good introduction to Gremlin.
MaJorToM v. 1.2.0 Released
From the release notes:
Today we have released a the new version 1.2.0 of our Topic Maps engine MaJorToM. Besides some bug fixing the new version provides paging for the topic maps access.
Comments Off on MaJorToM v. 1.2.0 Released
flare: data visualization for the web
flare: data visualization for the web
From the website:
Flare is an ActionScript library for creating visualizations that run in the Adobe Flash Player. From basic charts and graphs to complex interactive graphics, the toolkit supports data management, visual encoding, animation, and interaction techniques. Even better, flare features a modular design that lets developers create customized visualization techniques without having to reinvent the wheel.
Comments Off on flare: data visualization for the web
April 15, 2011
TMQL Canonizer
This is a new service from the Topic Maps Lab but absent any documentation, it is hard to say what to expect from it.
For example, I took a query from the rather excellent TMQL tutorials by Sven Krosse (also of the Topic Maps Lab):
%prefix o http://psi.ontopia.net/music/
FOR $topic IN // tm:subject
RETURN
IF $topic ISA o:composer
THEN $topic >> indicators
ELSE $topic / tm:name [0]
Fed it to the canonizer and got this result:
QueryExpression([%prefix, o, http://psi.ontopia.net/music/, FOR, $topic, IN, //, tm:subject, RETURN, IF, $topic, ISA, o:composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–EnvironmentClause([%prefix, o, http://psi.ontopia.net/music/])
| |–PrefixDirective([%prefix, o, http://psi.ontopia.net/music/])
|–FlwrExpression([FOR, $topic, IN, //, tm:subject, RETURN, IF, $topic, ISA, o:composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–ForClause([FOR, $topic, IN, //, tm:subject])
| |–BindingSet([$topic, IN, //, tm:subject])
| |–VariableAssignment([$topic, IN, //, tm:subject])
| |–Variable([$topic])
| |–Content([//, tm:subject])
| |–QueryExpression([//, tm:subject])
| |–PathExpression([//, tm:subject])
| |–PostfixedExpression([//, tm:subject])
| |–SimpleContent([//, tm:subject])
| |–Anchor([tm:subject])
| |–Navigation([<<, types]) | |--StepDefinition([<<, types]) | |--Step([<<, types]) |--ReturnClause([RETURN, IF, $topic, ISA, o:composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–Content([IF, $topic, ISA, o:composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–PathExpression([$topic, ISA, o:composer])
| |–ISAExpression([$topic, ISA, o:composer])
| |–SimpleContent([$topic])
| | |–Anchor([$topic])
| |–SimpleContent([o:composer])
| |–Anchor([o:composer])
|–Content([$topic, >>, indicators])
| |–QueryExpression([$topic, >>, indicators])
| |–PathExpression([$topic, >>, indicators])
| |–PostfixedExpression([$topic, >>, indicators])
| |–SimpleContent([$topic, >>, indicators])
| |–Anchor([$topic])
| |–Navigation([>>, indicators])
| |–StepDefinition([>>, indicators])
| |–Step([>>, indicators])
|–Content([$topic, /, tm:name, [, 0, ]])
|–QueryExpression([$topic, /, tm:name, [, 0, ]])
|–PathExpression([$topic, /, tm:name, [, 0, ]])
|–PostfixedExpression([$topic, /, tm:name, [, 0, ]])
|–SimpleContent([$topic, /, tm:name, [, 0, ]])
|–Anchor([$topic])
|–Navigation([/, tm:name, [, 0, ]])
|–StepDefinition([>>, characteristics, tm:name])
| |–Step([>>, characteristics, tm:name])
| |–Anchor([tm:name])
|–StepDefinition([>>, atomify, [, 0, ]])
|–Step([>>, atomify])
|–FilterPostfix([[, 0, ]])
|–Anchor([0])
OK, so I omitted the prefix on composer for the following query:
%prefix o http://psi.ontopia.net/music/
FOR $topic IN // tm:subject
RETURN
IF $topic ISA composer
THEN $topic >> indicators
ELSE $topic / tm:name [0]
Then I get:
QueryExpression([%prefix, o, http://psi.ontopia.net/music/, FOR, $topic, IN, //, tm:subject, RETURN, IF, $topic, ISA, composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–EnvironmentClause([%prefix, o, http://psi.ontopia.net/music/])
| |–PrefixDirective([%prefix, o, http://psi.ontopia.net/music/])
|–FlwrExpression([FOR, $topic, IN, //, tm:subject, RETURN, IF, $topic, ISA, composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–ForClause([FOR, $topic, IN, //, tm:subject])
| |–BindingSet([$topic, IN, //, tm:subject])
| |–VariableAssignment([$topic, IN, //, tm:subject])
| |–Variable([$topic])
| |–Content([//, tm:subject])
| |–QueryExpression([//, tm:subject])
| |–PathExpression([//, tm:subject])
| |–PostfixedExpression([//, tm:subject])
| |–SimpleContent([//, tm:subject])
| |–Anchor([tm:subject])
| |–Navigation([<<, types]) | |--StepDefinition([<<, types]) | |--Step([<<, types]) |--ReturnClause([RETURN, IF, $topic, ISA, composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–Content([IF, $topic, ISA, composer, THEN, $topic, >>, indicators, ELSE, $topic, /, tm:name, [, 0, ]])
|–PathExpression([$topic, ISA, composer])
| |–ISAExpression([$topic, ISA, composer])
| |–SimpleContent([$topic])
| | |–Anchor([$topic])
| |–SimpleContent([composer])
| |–Anchor([composer])
|–Content([$topic, >>, indicators])
| |–QueryExpression([$topic, >>, indicators])
| |–PathExpression([$topic, >>, indicators])
| |–PostfixedExpression([$topic, >>, indicators])
| |–SimpleContent([$topic, >>, indicators])
| |–Anchor([$topic])
| |–Navigation([>>, indicators])
| |–StepDefinition([>>, indicators])
| |–Step([>>, indicators])
|–Content([$topic, /, tm:name, [, 0, ]])
|–QueryExpression([$topic, /, tm:name, [, 0, ]])
|–PathExpression([$topic, /, tm:name, [, 0, ]])
|–PostfixedExpression([$topic, /, tm:name, [, 0, ]])
|–SimpleContent([$topic, /, tm:name, [, 0, ]])
|–Anchor([$topic])
|–Navigation([/, tm:name, [, 0, ]])
|–StepDefinition([>>, characteristics, tm:name])
| |–Step([>>, characteristics, tm:name])
| |–Anchor([tm:name])
|–StepDefinition([>>, atomify, [, 0, ]])
|–Step([>>, atomify])
|–FilterPostfix([[, 0, ]])
|–Anchor([0])
So then I enter a query that omits the “$” from the second instance of topic:
%prefix o http://psi.ontopia.net/music/
FOR $topic IN // tm:subject
RETURN
IF topic ISA o:composer
THEN $topic >> indicators
ELSE $topic / tm:name [0]
You can enter that one for yourself. No substantive change in result.
By omitting the “$” from all instances of topic I was finally able to get “an invalid expression” result.
Do note that the following is treated as a valid expression:
%prefix o http://psi.ontopia.net/music/
FOR $topic IN // tm:subject
RETURN
IF topic ISA o:composer
THEN topic >> indicators
ELSE topic / tm:name [0]
A bit more attention to documentation would go a long way to making this a useful project.
*****
PS: From the 2008 TMQL draft:
Examples for invalid variables are x (sigil missing),
Interaction Models for Faceted Search
Interaction Models for Faceted Search
Tony Russell-Rose on models for faceted search:
Faceted search offers tremendous potential for transforming search experiences. It provides a flexible framework by which users can satisfy a wide variety of information needs, ranging from simple lookup and fact retrieval to complex exploratory search and discovery scenarios. In recognition of this, UX designers are now starting to embrace its potential and have published many excellent articles on a variety of design issues, covering topics such as facet structure, layout & display, selection paradigm, and many more.
The purpose of this article is to explore one aspect that has received somewhat less attention than most: the interactive behaviour of the facets themselves, i.e. how they should respond and update when selected. Surprisingly, the design choices at this level of detail can make a remarkable difference to the overall user experience: the wrong choices can make an application feel disjointed and obstructive, and (in some cases) increase the likelihood of returning zero results. In this post, we’ll examine the key design options and provide some recommendations.
Highly recommended.
That your topic map has the right answer somewhere isn’t going to help a user who can’t find it.
Comments Off on Interaction Models for Faceted Search
Sorting algorithms demonstrated with Hungarian folk dance
Courtesy of FlowingData: Sorting algorithms demonstrated with Hungarian folk dance
OK, its not Dancing with the Stars but it is a way to visualize sorting algorithms.
And we don’t know what visualization will appeal to some user and “click” for them.
Thoughts about how to illustrate topic map operations using dance?
Comments Off on Sorting algorithms demonstrated with Hungarian folk dance
Fifth International AAAI Conference on Weblogs and Social Media (ICWSM) – Papers
Fifth International AAAI Conference on Weblogs and Social Media (ICWSM) – Papers
Matthew Hurst has gathered up links for the accepted papers for ICSWM 2011.
Thanks Matthew!
Comments Off on Fifth International AAAI Conference on Weblogs and Social Media (ICWSM) – Papers
Visualizing Directed Edges in Graphs : Don’t Use Arrows
Visualizing Directed Edges in Graphs : Don’t Use Arrows
From Matthew Hurst:
I just came across A User Study on Visualizing Directed Edges in Graphs by Danny Holten and Jarke J. van Wijk. The problem they look at in this paper is how to represented directed edges in visualization of graphs, e.g. to represent A is a part of B or A likes B, etc.
Interestingly, their results indicate that what I suspect might be the most commonly used approach (placing an arrow head at the end of the graph) is not the best. Rather, they suggest, using the tapered elements illustrated below is better.
Comments Off on Visualizing Directed Edges in Graphs : Don’t Use Arrows
Lucene Revolution
May 23 – 24, 2011 Training
May 25 – 26, 2011 Conference
San Francisco Airport Hyatt Regency
From the website:
Lucene Revolution 2011 is the largest conference dedicated to open source search. The Lucene Revolution 2011 brings together developers, thought leaders, and market makers who understand that the search technology they’ve been looking has arrived.This is an event that should not be missed by anyone that is using, or considering, Apache Lucene/Solr or LucidWorks Enterprise for their search applications.
You will get a chance to hear from a wide range of speakers, from the foremost experts on open source search technology to a broad cross-section of users that have implemented Lucene, Solr, or LucidWorks Enterprise to improve search application performance, scalability, flexibility, and relevance, while lowering their costs. The two-day conference agenda is packed with technical sessions, developer content, user case studies, panels, and networking opportunities. You will learn new ways to develop, deploy, and enhance search applications using Lucene/Solr — and LucidWorks Enterprise.
Preceding the conference there are two days of intensive hands-on training on Solr, Lucene, and LucidWorks Enterprise on May 23 and 24. Whether you are new to Lucene/Solr, want to brush up on your skills, or want to get new insights, tips & tricks, you will get the knowledge you need to be successful.
This could be very cool.
Comments Off on Lucene Revolution
Boost Graph Library (BGL)
Boost Graph Library (BGL)
From the website:
Graphs are mathematical abstractions that are useful for solving many types of problems in computer science. Consequently, these abstractions must also be represented in computer programs. A standardized generic interface for traversing graphs is of utmost importance to encourage reuse of graph algorithms and data structures. Part of the Boost Graph Library is a generic interface that allows access to a graph’s structure, but hides the details of the implementation. This is an “open” interface in the sense that any graph library that implements this interface will be interoperable with the BGL generic algorithms and with other algorithms that also use this interface. The BGL provides some general purpose graph classes that conform to this interface, but they are not meant to be the “only” graph classes; there certainly will be other graph classes that are better for certain situations. We believe that the main contribution of the The BGL is the formulation of this interface.
The BGL graph interface and graph components are generic, in the same sense as the Standard Template Library (STL) [2]. In the following sections, we review the role that generic programming plays in the STL and compare that to how we applied generic programming in the context of graphs.
See also: The Parallel Boost Graph Library
Comments Off on Boost Graph Library (BGL)