Sorry for the limp post; I’m testing some CSS trickery.

This should be red. (even though direct colorization is a no-no)

This part is offset: Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.

This is a quote: At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.

At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.

hermes root # tcpdump -nnvXSs 1514 -c2 icmp
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 1514
bytes 23:11:10.370321 IP (tos 0x20, ttl  48, id 34859, offset 0, flags
[none], length: 84) 69.254.213.43 > 72.21.34.42: icmp 64: echo request seq 0

lsof -i :25

find /var/localhost/www/htdocs -type d -prin0 | grep -0 xargs chmod 755 

I’ve alluded to a major project a few times in recent months. Well, I’m now ready to talk about what it is. I apologize for the disjoined presentation; I’m a bit excited and will clean up as needed later.

Background

One of the most annoying problems that faces computer users is contact management. Most don’t have a truly organized digital address book, and even those that do suffer from contact-rot. This is where each passing day means one more mailing address has changed, someone got a new mobile number, and another person got married and has a new last name. In other words, time deteriorates the quality of your information about other people.

Many services have come and gone that tried (or are trying) to solve this problem. Most notable of these is Plaxo. Plaxo, as well as most of the other services like it, have essentially been services where you kept your updated information. The idea being that when you changed your info, Plaxo could notify the people in your address book that you had done so. At that point they could take some steps to update their information. The problem is that it’s required too much involvement with the third party service. Plaxo is, after all, a for-profit company, so it makes sense that they would want you to interact with them.

Identity Management + Semantic Web

My idea is simple: provide a free and open infrastructure upon which people can build identity-based services ranging from contact management to social interaction functionality. Focus on transparency and open standards, meaning that the exchange of informaton should be as simple as possible and should allow for infinite potential for securely sharing and manipulating the data.

Here are the two primary components:

1. Central, Server-Side Representation of People using XML I’m currently working on RDF for the main definition.
2. Open, RSS-based Client The client piece, while completely open to various implementations, will have two components. 1) Subscriptions to contacts via RSS, and 2) translation of the server’s XML to their own address book format.

Functionality

• Maintain constantly updated contact information by subscribing to your friends’ information on a central server. You stay updated because your information is not static. The information you see when you open your address book is what was last pulled from your contact’s RSS feed.
• Your contact list is constantly maintained in a neatly defined, XML-based format on the server (OPML?). To get your contacts onto any new system (including mobile devices), install any client (there will be many) that speaks both the server-side XML protocol and the local address book format.
• Link the elements within a given definition to other namespaces that carry weight within the semantic world. In other words, allow favorite bands, favorite foods, and a multitude of other attributes to be defined in such a way that associated information can be referenced (and mashed) semantically.

The Architecture

The server resides at kitmee.com (currently living in a VMware machine in San Fransisco that’s powered off) and hosts the various identity files (RDF, etc.). As an example, we’ll say we have two accounts — myself (Daniel Miessler), and my friend (Seth Kline).

We respectively live at kitmee.com/dmiessler and kitmee.com/skline. Within whatever client we’re using for the system (again, this will be any one of many available) I’ll subscribe to Seth’s address within my client that’s installed on my local system. The client works by maintaining two types of information: who you are, and who your subscriptions are (your contacts).

More On Client Functionality

The most basic client monitors the local address book for changes to my own contact information, and upon sensing changes translates the changed result into the server’s XML format and uploads it. This updates my information on the server and updates the associated RSS feed that represents me as a person.

Since people who have me in their “contact list” are actually just subscribed to my RSS feed, their respective clients (web clients, desktop clients, mobile clients) will be notified the next time they check in that I have updated my information. Their client will then update my information in their contact list (server-side) and make the associated change to the local address book on the system they are using (mobile phone, work computer, etc.).

So what we end up with is an infrastructure in which I can update my information using my own local address book, and that information will transparently be propogated (via RSS pull) to anyone who is subscribed to me using the system.

Once I have a client installed it disappears into the background. From that point on I interact only with my regular contact management application, and changes I make are propogated to my subscribers, and their changes are propogated to me.

The end result is that when I open my address book entry for Seth two years from now and dial his mobile number, I could very well be dialing a number that I never entered. He’ll still answer the phone on the other end, however, because at some point he updated HIS local address book, which updated the server, which updated MY local address book.

No extra steps. No extra hassle.

Considerations

Security is handled on the server by managing who can and cannot access your information. Obviously we don’t want just anyone to be able to pull your entire personal definition (essentially what’s now a vcard) by simply visiting a given URI. I also intend for the various elements/fields in the definition to be granularly controllable, e.g. work associates can see only your home number, while friends can see everything, etc.

Clients are the key; without them we don’t have the transparency that’s required to make the infrastructure useful. Specifically, we need the client to be able to translate between the server’s XML format and the local address book format. In later client iterations, however, I anticipate moving towards address book integration, i.e. being able to add kitmee subscriptions right into the native address book.

Final Thoughts

So that’s the project. I’m currently working with one other developer on the server side, and have not even started considering the client piece. Our development environment currently consists of a fairly stout Gentoo Linux server running in VMware. The application platform is RoR, and we’re using Subversion for version control.

I am very much interested in any feedback you may have. And if you’re interested in contributing — either via conceptual input or actual development effort — I’d love to hear from you. I will be following the comments in this thread and am also available via email.

howstufworks.com

We all hear the term “web 2.0″ being used hundreds of times a week. It’s all over the Internet and it pervades modern technical conversation to the point of being cliché. But what does “2.0″ really mean? What came before it? And what’s coming next? Here are some basics.

Web 1.0 This is the first iteration. It wasn’t actually called web 1.0, of course; it was just “the web”, or “the Internet”. You don’t call something version 1 when you aren’t anticipating a second version. This version was (and still is)…

A system of interlinked, hypertext documents accessed via the Internet. With a Web browser, a user views Web pages that may contain text, images, and other multimedia and navigates between them using hyperlinks.

Web 2.0 Interestingly enough, Web 2.0 doesn’t truly correspond to a change in technology. While AJAX is commonly associated with Web 2.0 functionality, the difference is actually in how web 2.0 applications are used, not in how they are implemented. Web 2.0 is…

A perceived second generation of web-based communities and hosted services — such as social-networking sites, wikis and folksonomies — which facilitate collaboration and sharing between users.

Web 3.0 This is the current holy grail — the semantic web. The semantic web represents a shift from documents to data, meaning that data will be presented to humans and computers alike that can be manipulated in various ways. Most importantly, however, there will be meaningful links connecting these various sets of data.

The semantic web is an evolving extension of the World Wide Web in which web content can be expressed not only in natural language, but also in a form that can be read and used by software agents, thus permitting them to find, share and integrate information more easily.^[1] It derives from W3C director Sir Tim Berners-Lee’s vision of the Web as a universal medium for data, information, and knowledge exchange.

In other words, the semantic web links information together in a way that is both useful and automatic rather than manual and disjointed. It’s a collection of data resources that are interconnected and speak the same language.

Using the semantic web will be similar to asking a personal assistant to help you accomplish something. You might say, “Find me all bilingual Porsche dealers within 200 miles that are open on Sunday, and add their sales staff contact information to my address book. Also, let me know if any of their employees have published contacts within 2 degrees of separation from me.”

This will be possible because all that information (business type, language proficiencies, location, contact information, etc.) will be available through the company’s Internet presence. And most importantly, this information will be easily processed and manipulated by any semantically-aware software agent. That’s web 3.0..:

– Quoted text is from Wikipedia

No technology interests me more than the semantic web. I have no doubt that I will spend many years working on projects related to this vision — starting now. The concept captures my ‘grep understanding knowledge‘ theme beautifully, which is probably why it draws me so. From Wikipedia:

The semantic web is an evolving extension of the World Wide Web in which web content can be expressed not only in natural language, but also in a form that can be understood, interpreted and used by software agents, thus permitting them to find, share and integrate information more easily. It derives from W3C director Tim Berners-Lee’s vision of the Web as a universal medium for data, information, and knowledge exchange.

And since ideas ride protocols, the protocol of interest here looks to be RDF. Here’s the W3C description of RDF:

The Resource Description Framework (RDF) integrates a variety of applications from library catalogs and world-wide directories to syndication and aggregation of news, software, and content to personal collections of music, photos, and events using XML as an interchange syntax. The RDF specifications provide a lightweight ontology system to support the exchange of knowledge on the Web.

Based on the knowledge that I have so far (which admittedly isn’t much), I’m quite convinced that this — the semantic web riding on top of RDF or a similar XML-based protocol — is going to change the way we use the Internet. Not like YouTube or Facebook “changed” things, but more like going from BBSs to the Internet.

Here’s an example from W3C:

The word semantic stands for the meaning of. The semantic of something is the meaning of something. The Semantic Web is a web that is able to describe things in a way that computers can understand.

• The Beatles was a popular band from Liverpool.
• John Lennon was a member of the Beatles.
• The record “Hey Jude” was recorded by the Beatles.

Sentences like these can be understood by people. But how can they be understood and processed by computers?

This is what the Semantic Web is all about. Describing things in a way that computers applications can understand. The Semantic Web is not about links between web pages.

The Semantic Web describes the relationships between things (like A is a part of B and Y is a member of Z) and the properties of things (like size, weight, age, and price).

My specific area of focus, however, is going to be looking at how to leverage this technology with people.

That’s all I’m saying for now for two reasons. First, I need to research more to make sure the technology can do what I’m thinking it can. Secondly, it’s cooler if I don’t talk about it. Let me know out of band if you are interested in discussing and/or working on the project with me.:

Hint: Think “semantic personal information exchange using RDF”.