To be fair, I’ve been intrigued by this topic for a long time, although probably with a much less academic interest than the one many people in the digital humanities community often have. In short, I’d say I care more about designing applications that can change the way people read online, rather than taking on biblical text-encoding enterprises that at the end of the day result in just another, more complicated, html page.

So I was happy to see that there’s lots going on in this area outside academia; in this post (which is a work-in-progress) I’ll start collecting a few examples of this kind of digital tools.

Findings

Findings is a “groundbreaking tool for collecting, sharing and discussing clips you find on your Amazon Kindle and from any website on the internet. Just import your Amazon Kindle Highlights with Findings and you can start sharing and discussing them with others instantly”.

The key idea here seems to be that since a lot of the reading we do nowadays is online (or on digital devices) we may as well start sharing the ‘highlights’ we create by using a social network architecture (e.g. share, vote, comment on etc.). The idea definitely makes sense, and, quite interestingly, it reminds us of what used to be common practice in a time when the book (as we know it nowadays) wasn’t yet an established form of writing (check out Robert Darnton: “early modern Englishmen … broke texts into fragments and assembled them into new patterns by transcribing them in different sections of their notebooks“)

Small Demons:

Small Demons. The blurb is catchy: “suppose someone took every meaningful detail from all the books you love. Every song mentioned, every person, every food or place or movie title. And what if they did that for all the books everyone else loves, too. The ones you’ve never heard of. Suddenly you’ve got a whole world of seemingly random people, places and things, all gathered in one place. Together they create something vast, wonderful and entirely new. A Storyverse. A place where details touch, overlap and lead you further. To new music to listen to. New movies to watch. Places to visit. People to know. And of course, new books to read. Getting started is simple. Just choose a book. See where it takes you.”

Here there seems to be some level of semantic annotation of the texts, which produces a thick layer of metadata that can be used to create unusual and interesting interconnections among the materials published. Definitely worth keeping an eye on – in particular I wonder how ‘deep’ is the semantic annotation process, and on which scale!

Readmill

Readmill is a “curious community of readers, sharing and highlighting the books they love. Highlight your favorite passages and share them with your reading community. Follow people you like and find out what your friends are reading. Explore a world of reading and keep a list of books you want to read. Read with Readmill for iPad, and sync highlights from Amazon Kindle with the Readmill Bookmarklet.”

The read-highlight-share idea is the same as in Findings (above); the main difference, at first sight, is that this Berlin-based startup is also producing mobile apps (e.g. iPhone, android) that will make the ‘Readmill experience’ much more integrated and, supposedly, powerful. We”ll see!

Quote.fm

Quote.fm is presented as “the best way to discover, read and share great texts that have the power to convey ideas, provoke emotions or change your entire life. It’s all about texts truly worth reading.”

This is another German company that in the spirit of Findings (above) has put up a service for saving and sharing quotations taken from online resources. The site look is quite appealing, there’s no support for Kindle yet by it appears from the Timeline that soon we’ll see a whole bunch of new features on this site..

Read and Note

Readandnote.com system “has the ability to annotate digital versions of books and many types of different assets, add any asset and the capability of linking references through the annotation process. The e-publication suddenly becomes more than a ‘read-only’ document”.

This technology seems very promising; the website talks about supporting iPad and mobile devices too, which is always a plus. Unfortunately there isn’t any demo or screencast available at the moment, but we’ll keep an eye on this (you can sign up to receive news from them if you like).

UPDATE 1/6/12: a video of the software is now available online.

Tailored Texts

Tailored Texts is a “project which allows lovers of language and literature to collaborate in the reading and annotation of original-language texts that are in the public domain”.

The software is very usable and it offers several fairly advanced features, such as categorised annotations (‘definitions’, ‘grammar’, ‘analysis’ etc.), wikis and integrated discussion boards. It may be tailored especially to language students, teachers and translators who need to study a text and/or annotate it collaboratively, but it seems as if it could be used in a number of other contexts too.

That’s all for now..

Which of the ones above will succeed? I’ll try to keep adding pointers to this list as I run into them in the next weeks, so come back for more.

Tip: the recently finished ifBookThen conference had a lot of interesting talks (also, you can read an overview of it on Storify)

The book (which is available online here )is simple and well organized; it spends quite a bit of time on both introductory topics and more advanced ones, so it’ll probably fit both the beginner and the more experienced programmer.

Here’s a list of the chapters available:

CHAPTER 1: GETTING STARTED WITH PATHS AND TEXT
Introduction
Drawing a line
Drawing an arc
Drawing a Quadratic curve
Drawing a Bezier curve
Drawing a zigzag
Drawing a spiral
Working with text
Drawing 3D text with shadows
Unlocking the power of fractals: Drawing a haunted tree

CHAPTER 2: SHAPE DRAWING AND COMPOSITES
Introduction
Drawing a rectangle
Drawing a circle
Working with custom shapes and fill styles
Fun with Bezier curves: drawing a cloud
Drawing transparent shapes
Working with the context state stack to save and restore styles
Working with composite operations
Creating patterns with loops: drawing a gear
Randomizing shape properties: drawing a field of flowers
Creating custom shape functions: playing card suits
Putting it all together: drawing a jet

CHAPTER 3: WORKING WITH IMAGES AND VIDEOS
Introduction
Drawing an image
Cropping an image
Copying and pasting sections of the canvas
Working with video
Getting image data
Introduction to pixel manipulation: inverting image colors
Inverting video colors
Converting image colors to grayscale
Converting a canvas drawing into a data URL
Saving a canvas drawing as an image
Loading the canvas with a data URL
Creating a pixelated image focus

CHAPTER 4: MASTERING TRANSFORMATIONS
Introduction
Translating the canvas context
Rotating the canvas context
Scaling the canvas context
Creating a mirror transform
Creating a custom transform
Shearing the canvas context
Handling multiple transforms with the state stack
Transforming a circle into an oval
Rotating an image
Drawing a simple logo and randomizing its position, rotation, and scale

CHAPTER 5: BRINGING THE CANVAS TO LIFE WITH ANIMATION
Introduction
Creating an Animation class
Creating a linear motion
Creating acceleration
Creating oscillation
Oscillating a bubble
Swinging a pendulum
Animating mechanical gears
Animating a clock
Simulating particle physics
Creating microscopic life forms
Stressing the canvas and displaying the FPS

CHAPTER 6: INTERACTING WITH THE CANVAS: ATTACHING EVENT LISTENERS TO SHAPES AND REGIONS 
Introduction
Creating an Events Class
Working With Canvas Mouse Coordinates
Attaching Mouse Event Listeners to Regions
Attaching Touch Event Listeners to Regions on a Mobile Device
Attaching Event Listeners to Images
Dragging-And-Dropping Shapes
Dragging-And-Dropping Images
Creating an Image Magnifier
Creating a Drawing Application

CHAPTER 7: CREATING GRAPHS AND CHARTS
Introduction
Creating a pie chart
Creating a bar chart
Graphing equations
Plotting data points with a line chart

CHAPTER 8: SAVING THE WORLD WITH GAME DEVELOPMENT
Introduction
Creating sprite sheets for the heroes and enemies
Creating level images and boundary maps
Creating an Actor class for the hero and enemies
Creating a Level class
Creating a Health Bar class
Creating a Controller class
Creating a Model class
Creating a View class
Setting up the HTML document and starting the game

CHAPTER 9: INTRODUCING WEBGL
Introduction
Creating a WebGL wrapper to simplify the WebGL API
Creating a triangular plane
Rotating a triangular plane in 3D space
Creating a rotating cube
Adding textures and lighting
Creating a 3D world that you can explore

The last chapters about animations and game developments are probably the most interesting ones, especially they all include detailed walk-through of the techniques discussed. Here’s for example an example from Chapter 5, ‘Oscillating a bubble’:

[inline]

[script type=”text/javascript”]

var Animation = function(canvasId){
this.canvas = document.getElementById(canvasId);
this.context = this.canvas.getContext(“2d”);
this.t = 0;
this.timeInterval = 0;
this.startTime = 0;
this.lastTime = 0;
this.frame = 0;
this.animating = false;

// provided by Paul Irish
window.requestAnimFrame = (function(callback){
return window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
window.oRequestAnimationFrame ||
window.msRequestAnimationFrame ||
function(callback){
window.setTimeout(callback, 1000 / 60);
};
})();
};

Animation.prototype.getContext = function(){
return this.context;
};

Animation.prototype.getCanvas = function(){
return this.canvas;
};

Animation.prototype.clear = function(){
this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
};

Animation.prototype.setDrawStage = function(func){
this.drawStage = func;
};

Animation.prototype.isAnimating = function(){
return this.animating;
};

Animation.prototype.getFrame = function(){
return this.frame;
};

Animation.prototype.start = function(){
this.animating = true;
var date = new Date();
this.startTime = date.getTime();
this.lastTime = this.startTime;

if (this.drawStage !== undefined) {
this.drawStage();
}

this.animationLoop();
};

Animation.prototype.stop = function(){
this.animating = false;
};
Animation.prototype.getTimeInterval = function(){
return this.timeInterval;
};

Animation.prototype.getTime = function(){
return this.t;
};

Animation.prototype.getFps = function(){
return this.timeInterval > 0 ? 1000 / this.timeInterval : 0;
};

Animation.prototype.animationLoop = function(){
var that = this;

this.frame++;
var date = new Date();
var thisTime = date.getTime();
this.timeInterval = thisTime – this.lastTime;
this.t += this.timeInterval;
this.lastTime = thisTime;

if (this.drawStage !== undefined) {
this.drawStage();
}

if (this.animating) {
requestAnimFrame(function(){
that.animationLoop();
});
}
};

window.onload = function(){
// instantiate new animation object
var anim = new Animation(“myCanvas”);
var context = anim.getContext();
var canvas = anim.getCanvas();

anim.setDrawStage(function(){
// update
var widthScale = Math.sin(this.getTime() / 200) * 0.1 + 0.9;
var heightScale = -1 * Math.sin(this.getTime() / 200) * 0.1 + 0.9;

// clear
this.clear();

//draw
context.beginPath();
context.save();
context.translate(canvas.width / 2, canvas.height / 2);
context.scale(widthScale, heightScale);
context.arc(0, 0, 65, 0, 2 * Math.PI, false);
context.restore();
context.fillStyle = “#8ED6FF”;
context.fill();
context.lineWidth = 2;
context.strokeStyle = “#555”;
context.stroke();

context.beginPath();
context.save();
context.translate(canvas.width / 2, canvas.height / 2);
context.scale(widthScale, heightScale);
context.arc(-30, -30, 15, 0, 2 * Math.PI, false);
context.restore();
context.fillStyle = “white”;
context.fill();
});

anim.start();
};

[/script]

[/inline]

In a nutshell, this is what is going on (note that the ‘animation’ library is discussed in a previous chapter of the book):

<script src="animation.js"></script>
<script>
    window.onload = function(){
        // instantiate new animation object
        var anim = new Animation("myCanvas");
        var context = anim.getContext();
        var canvas = anim.getCanvas();
        
        anim.setDrawStage(function(){
            // update
            var widthScale = Math.sin(this.getTime() / 200) * 0.1 + 0.9;
            var heightScale = -1 * Math.sin(this.getTime() / 200) * 0.1 + 0.9;

            // clear
            this.clear();
            
            //draw
            context.beginPath();
            context.save();
            context.translate(canvas.width / 2, canvas.height / 2);
            context.scale(widthScale, heightScale);
            context.arc(0, 0, 65, 0, 2 * Math.PI, false);
            context.restore();
            context.fillStyle = "#8ED6FF";
            context.fill();
            context.lineWidth = 2;
            context.strokeStyle = "#555";
            context.stroke();
            
            context.beginPath();
            context.save();
            context.translate(canvas.width / 2, canvas.height / 2);
            context.scale(widthScale, heightScale);
            context.arc(-30, -30, 15, 0, 2 * Math.PI, false);
            context.restore();
            context.fillStyle = "white";
            context.fill();
        });
        
        anim.start();
    };
</script>

All in all, a book definitely worth reading!

The first excerpt is about the ‘ever-changing meaning of ontology’. The second one instead is a graph depicting the role of ontologies in semantic systems.

And the good news is: you can get a pdf pre-print for free!

Abstract
Several technologies are emerging that provide new ways to capture, store, present and use knowledge. This book is the first to provide a comprehensive introduction to five of the most important of these technologies: Knowledge Engineering, Knowledge Based Engineering, Knowledge Webs, Ontologies and Semantic Webs. For each of these, answers are given to a number of key questions (What is it? How does it operate? How is a system developed? What can it be used for? What tools are available? What are the main issues?). The book is aimed at students, researchers and practitioners interested in Knowledge Management, Artificial Intelligence, Design Engineering and Web Technologies.

During the 1990s, Nick worked at the University of Nottingham on the application of AI techniques to knowledge management and on various knowledge acquisition projects to develop expert systems for military applications. In 1999, he joined Epistemics where he worked on numerous knowledge projects and helped establish knowledge management programmes at large organisations in the engineering, technology and legal sectors. He is author of the book “Knowledge Acquisition in Practice”, which describes a step-by-step procedure for acquiring and implementing expertise. He maintains strong links with leading research organisations working on knowledge technologies, such as knowledge-based engineering, ontologies and semantic technologies.