Subscribe: Microformats
http://microformats.org/feed/atom
Added By: Feedage Forager Feedage Grade B rated
Language: German
Tags:
classnames  community  microformats org  microformats parsing  microformats  org  parsing  publishing  simpler  time  web  year  years 
Rate this Feed
Rate this feedRate this feedRate this feedRate this feedRate this feed
Rate this feed 1 starRate this feed 2 starRate this feed 3 starRate this feed 4 starRate this feed 5 star

Comments (0)

Feed Details and Statistics Feed Statistics
Preview: Microformats

Microformats



building blocks for data-rich web pages



Updated: 2017-06-22T17:13:53Z

 



Improving the php-mf2 parser

2017-06-22T17:13:53Z

During the past year, the popular php-mf2 microformats parser has received quite a few improvements. My site runs ProcessWire and one of the plugins for it uses php-mf2, so I have been spending some time on it. My own experience with microformats started when I discovered the hCard microformat. I was impressed with the novelty [...]

During the past year, the popular php-mf2 microformats parser has received quite a few improvements. My site runs ProcessWire and one of the plugins for it uses php-mf2, so I have been spending some time on it.

My own experience with microformats started when I discovered the hCard microformat. I was impressed with the novelty of adding some simple HTML classes around contact information and having a browser extension parse it into an address book. Years later, when I started to get involved in the IndieWeb community, I learned a lot more about microformats2 and they became a key building block of my personal site.

php-mf2 is now much better at backwards-compatible parsing of microformats1. This is important because software should be able to consistently consume content whether it’s marked up with microformats1, microformats2, or a combination. An experimental feature for parsing language attributes has also been added. Finally, it’s now using the microformats test suite. Several other parsers use this test suite as well. This will make it easier to catch bugs and improve all of the different parsers.

php-mf2 is a stable library that’s ready to be installed in your software to start consuming microformats. It is currently used in Known, WordPress plugins, and ProcessWire plugins for richer social interactions. It’s also used in tools like XRay and microformats.io. I’m looking forward to more improvements to php-mf2 in the coming year as well as more software using it!

Original published at: https://gregorlove.com/2017/06/improving-the-php-mf2-parser/




Evolving for 12 Years

2017-06-20T15:09:08Z

For the 12th birthday of microformats.org (congratulations!) Tantek asked the community if any of us would like to highlight whatever we liked in a guest post. I am taking this opportunity to talk about my favourite feature of microformats: its constant evolvement. Sometimes it feels like a standard is done. Sometimes it feels like a [...]

For the 12th birthday of microformats.org (congratulations!) Tantek asked the community if any of us would like to highlight whatever we liked in a guest post. I am taking this opportunity to talk about my favourite feature of microformats: its constant evolvement.

Sometimes it feels like a standard is done. Sometimes it feels like a standard is abandoned before its time. In a few special cases a standard keeps evolving. I think we can agree that microformats goes in the latter category. This is hugely thanks to the fact that anyone can help it grow.

As you read this, work is being done to upgrade h-event from a Draft to a full Specification. This prompted a few of us to have a look at what people are doing with the format. As it turns out: it has departed from the Draft!

The IndieWeb community is putting events in their feeds, interleaving them with other items (like blog posts) that use h-entry. To make the events fit within this context properties are being copied over from h-entry, properties completely new to h-event. Somehow these separate implementations introduced the same properties, showing how h-event is evolving quicker than its Draft Specification without splintering it in lots of different versions. Naturally evolving the format forwards!

Then there are the small, fringe changes. Work on pronouns in h-cards has been mostly dormant since 2015. I spent time with it during IndieWebCamp Nuremberg and came to a completely different conclusion on how to mark-up my pronouns. The beauty there is that anyone can do the same! All it takes is to put something on your site, like the IndieWeb community did with h-event, and tell the world about this piece of extra information they now have access to.

Here is to one more year of constantly tinkering with our HTML and giving more meaning to the information we publish 🥂




microformats.org at 11

2016-06-22T15:20:49Z

Thanks to Julie Anne Noying for the meme birthday card. In this day and age of web frameworks that rise and fall like seasonal fashion displays, bait-and-break APIs, and sudden site-deaths, it’s nothing short of incredible that we’ve been able to continue evolving, improving, and growing microformats use for 11 years. All that incremental work [...] Thanks to Julie Anne Noying for the meme birthday card. In this day and age of web frameworks that rise and fall like seasonal fashion displays, bait-and-break APIs, and sudden site-deaths, it’s nothing short of incredible that we’ve been able to continue evolving, improving, and growing microformats use for 11 years. All that incremental work has produced quite a lot since a year ago. Most recently, we’ve made great progress with iterating, publishing, and deploying microformats2 support. I believe microformats.org has surived as a community, and microformats as a technology, by continuing to focus on solving smaller, simpler problems first, and then iterating only as needed with real world use-cases. It’s an approach I think works as a good starting point for nearly any project. -Tantek 10,000s of microformats2 sites and now 10 microformats2 parsers The past year saw a huge leap in the number of sites publishing microformats2, from 1000s to now 10s of thousands of sites, primarily by adoption in the IndieWebCamp community, and especially the excellent Known publishing system and continually improving WordPress plugins & themes. New modern microformats2 parsers continue to be developed in various languages, and this past year, four new parsing libraries (in three different languages) were added, almost doubling our previous set of six (in five different languages) that brought our year 11 total to 10 microformats2 parsing libraries available in 8 different programming languages. microformats2 parsing spec updates The microformats2 parsing specification has made significant progress in the past year, all of it incremental iteration based on real world publishing and parsing experience, each improvement discussed openly, and tested with real world implementations. The microformats2 parsing spec is the core of what has enabled even simpler publishing and processing of microformats. The specification has reached a level of stability and interoperability where fewer issues are being filed, and those that are being filed are in general more and more minor, although once in a while we find some more interesting opportunities for improvement. We reached a milestone two weeks ago of resolving all outstanding microformats2 parsing issues thanks to Will Norris leading the charge with a developer spec hacking session at the recent IndieWeb Summit where he gathered parser implementers and myself (as editor) and walked us through issue by issue discussions and consensus resolutions. Some of those still require minor edits to the specification, which we expect to complete in the next few days. One of the meta-lessons we learned in that process is that the wiki really is less suitable for collaborative issue filing and resolving, and as of today are switching to using a GitHub repo for filing any new microformats2 parsing issues. more microformats2 parsers The number of microformats2 parsers in different languages continues to grow, most of them with deployed live-input textareas so you can try them on the web without touching a line of parsing code or a command line! All of these are open source (repos linked from their sections), unless otherwise noted. These are the new ones: Elixir – created by ckruse. Haskell – created by myfreeweb Java (2) The Java parsers are a particularly interesting development as one is part of the upgrade to Apache Any23 to support microformats2 (thanks to Lewis John McGibbney). Any23 is a library used for analysis of various web crawl samples to measure representative use of various forms of semantic markup. The other Java parser is mf2j, an early-stage[...]



microformats.org turns 9 — upgrade to microformats2 and more

2014-06-21T01:33:01Z

Nine years ago we launched microformats.org with a basic premise: that it is possible to express meaning on the web in HTML in a simple way—far simpler than the complex alternatives (XML) being promoted by mature companies and standards organizations alike. Today microformats.org continues to be a gathering place for those seeking simpler ways to [...] Nine years ago we launched microformats.org with a basic premise: that it is possible to express meaning on the web in HTML in a simple way—far simpler than the complex alternatives (XML) being promoted by mature companies and standards organizations alike. Today microformats.org continues to be a gathering place for those seeking simpler ways to express meaning in web pages, most recently the growing IndieWeb movement. Looking back nine years ago, none of the other alternatives promoted in the 2000s (even by big companies like Google and Yahoo) survive to this day in any meaningful way: Google Base Google Data Yahoo’s CommonTag.org too many XML approaches to count From this experience, we conclude that what large companies support (or claim to prefer) is often a trailing indicator (at best). Large companies tend to promote more complex solutions, perhaps because they can afford the staff, time, and other resources to develop and support complex solutions. Such approaches fundamentally lack empathy for independent developers and designers, who don’t have time to keep up with all the complexity. If there’s one value that’s at the heart of microformats’ focus and continued evolution of simplicity, it is that empathy for independent developers and designers, for small consulting shops, for curious hobbyists who are most enabled and empowered by the simplest possible solutions to problems. We now know that no amount of large company marketing and evangelism can make up for a focus on ever simpler solutions which take less time to learn, use, and reliably maintain. As long as we focus on that, we will create better solutions. Community Changes Speaking of taking less time, we’ve learned some community lessons about that too. Perhaps the most important is that as a community we are far more efficiently productive using just IRC and the wiki, than any amount of use of email. In fact, the microformats drafts that were developed wtih the most email (e.g. hAudio) turned out to be the hardest to follow and discuss (too many long emails), and sadly ended up lacking the simplicity that real world publishers wanted (e.g. last.fm). Email tends to bias design and discussions towards those who have more time to read and write long emails, and (apparently) enjoy that for its own sake, than those who want to quickly research & brainstorm, and get to actually creating, building, and deploying things with microformats. Thus we’re making these changes effective today: IRC for all microformats discussions, whether research, questions, or brainstorming email only for occasional announcements and to direct people to IRC. wiki for capturing questions, brainstorming, conclusions, and different points of view We’re going to update the site to direct all discussion (e.g links) to the IRC channel accordingly. Hope to see you there: #microformats on irc.freenode.net Upgrading to microformats2 Over the past few years microformats2 has proven itself in practice, with numerous sites both publishing and consuming, several open source parsing libraries, and a growing test suite. All the lessons learned from the evolution from original microformats, from RDFa, and from microdata have been incorporated into microformats2 which is now the simplest to both publish and parse. It’s time to throw the switch and upgrade everything to microformats2. This means three things: Upgrading microformats.org First, we’re starting by upgrading the links on the microformats.org home page to point to the microformats2 drafts, which are ready for[...]



Getting Started With microformats2

2014-03-06T10:53:40Z

Classic microformats have been serving the web community’s need to extend HTML’s expressive power since 2004. Through an evolutionary, open, rigorous community process and human-first design principles, structured use of the class and rel attributes have paved the cowpaths of publishing data about people, places, events, reviews, products and more. Microformats2 is the next big [...]Classic microformats have been serving the web community’s need to extend HTML’s expressive power since 2004. Through an evolutionary, open, rigorous community process and human-first design principles, structured use of the class and rel attributes have paved the cowpaths of publishing data about people, places, events, reviews, products and more. Microformats2 is the next big effort by the community to improve how microformats are authored, parsed and defined. Version two has multiple working open source implementations which independents are using in production and is easier to publish and consume than ever. In this series of guides I’ll show you how to be the next site publishing and consuming microformats. You can see how a microformats parser sees your markup by pasting any of the code samples below into this php-mf2 sandbox. Go ahead and experiment with adding more properties and see what happens! Incremental Steps In order to demonstrate some of the differences between microformats 2 and Classic Microformats/other competing technologies, I’ll use the process of content-out markup — going from plain text to HTML and finally adding a sprinkling of microformats. Let’s start with my favourite example: mentioning a person. As plain text: Barnaby Walters With HTML: Barnaby Walters With classic microformats: Barnaby Walters That’s 37 extra characters and a whole extra nested element just to say “This link is to a person”, not to mention the strangely named root classname (vcard? I thought this was an hcard?) and multiple cryptic fn n classnames. Competing technologies are typically even longer and messier. With microformats 2 this all becomes much simpler: Barnaby Walters Weighing in at only 15 characters, this is quicker to type, easier on the eyes and easier to remember. There are two fundamental changes in microformats 2 which make this helium-esque lightness possible: Implied Properties and prefixed classnames. Implied Properties When you give class=h-card to an element, you’re saying “This element represents a person”. In many cases the element will be simple; just a name, perhaps with a link or photo. Why should you add extra elements and classnames just to tell a dumb computer which bit is the name, URL or photo URL when that information is already expressed by the markup? Implied properties save you from this tedium. When you specify an element as an h-card without explicitly defining which parts are the name, url or photo url, the parser will figure out what you meant. And it’s not just for h-cards either — thanks to the new generic parsing in microformats 2, this shorthand works for any microformat. Prefixed Classnames Classic microformats used plain classnames which looked like any other (e.g. vcard, n or note). There were a few problems with this — classnames would clash, cause false positives or be thrown away by developers who weren’t microformats-aware (“these classnames aren’t doing anything!”). This also meant parsers were tricky to write, as each one had to maintain a long list of classnames used by each microformats, resulting in many parsers quickly going out of date. Prefixing classnames solves both of these problems: semantic microformats2 classnames are set apart from styling hooks, and parsers can figure out which classnames to look for, cutting down o[...]