The documentation linked to by the left side navigation bar is non-normative and provides a comprehensive by-example description of OData to make it simple to learn the protocol. The description of OData on this page is divided into a group of documents (Core, Formats, URL Conventions, etc) to reflect the fact OData is designed to be modular such that an OData implementation need only implement as much of an OData specification as required for its target scenario.
To get started learning OData, begin by reading the OData Core document and progress to the other documents as required by your scenario.

Fake is a new browser for Mac OS X that makes web automation simple. Fake allows you to drag discrete browser Actions into a graphical Workflow that can be run again and again without human interaction. The Fake Workflows you create can be saved, reopened, and shared.

Flask is a microframework for Python based on Werkzeug, Jinja 2 and good intentions.

ImageOptim optimizes images — so they take up less disk space and load faster — by finding best compression parameters and by removing unnecessary comments and color profiles. It handles PNG, JPEG and GIF animations.

Great deep dive into the WebKit developer tools: #webinf #web #development #tools #html #css #javascript

"Raw data" vs. APIs.

"In controlled environments, e.g. on a single site, or in a single person's
media library, or within a small coherent community where all the
participants have compatible goals, it is possible to get enough
discipline that metadata is both reliable and useful. And for such
communities we have a raft of extension mechanisms, and clashes can be
avoided easily by simply using names that nobody in the community is
already using.

"But as soon as this kind of thing is applied to people outside the
tightnit community, the metadata becomes an utter mess, misused, wrong,
missing, syntactically incorrect, semantically incorrect, unusable. We
have shown time and time again that when metadata mechanisms face the
wider Web community, they fail. Ignoring this doesn't make it go away."

Ian Hickson's post in which he announces (kind of) the formation of the WHATWG and the break from the "out of touch" W3C.

A starting point to write your own Ruby algorithms to analyse the wealth of information that’s buried in the Common Crawl web archive.

There is lots of information about node.js, but given the rapid pace at which it is developing, it can be difficult for beginners to find good, current information on how to get started. This guide aims to provide exactly that, whilst staying updated with the latest stable version of node.js.

Although it is necessary for a service to be RESTful in order to build a system that exhibits RESTful characteristics, it is not sufficient.    The client needs to behave RESTfully or the coupling that the server tried to avoid will be re-introduced.

The following levels are my initial attempt to classify clients based on how coupled the client is to the service API. 

ROCA is an attempt to define a set of recommendations — independent of any particular framework, programming language, or tooling — that embodies the principles of what we consider to be good web application architecture. Its purpose is to serve as a reference, one that can be implemented as-is or be compared to other approaches to highlight diverging design decisions.

Free open source full-stack framework for rapid development of fast, scalable, secure and portable database-driven web-based applications. Written and programmable in Python.

Web Data Commons will extract all Microformat, Microdata and RDFa data that is contained in the Common Crawl corpus and will provide the extracted data for free download in the form of RDF-quads as well as CSV-tables for common entity types (e.g. product, organization, location, ...).

Instead of going to the library or the archive, we increasingly access history, the past, through the web. But what kind of history or histories, past or pasts are we accessing online? And what does this accessing entail? Following Leong et al., we approach temporality on the web “as a multiplicity of times derived from relations between different elements (2009, 1279)." This project is specifically focused on contentious historical moments, pasts that have had and potentially still have a major emotional impact, and which have been subject of struggle. Moreover, we not interested in sites specifically devoted to history, but in the major platforms on the web.

Confronting the historical events on the various platforms and opening up to a multiplicity of time we immediately realized that the traditional linear conception of time does not work online. First, most platforms do no not work in a chronological fashion, but with a reverse chronology. Second, because the platforms order sources according to ‘relevance’, the chronology of the sources as they are presented to us is radically mixed up. Third, sources do their own trick with time as well. Some focus on the historical event itself, while other rework the event. This reworking happens in a wide variety of ways, for example, by metaphorically invoking the event, by turning it into a historiographic debate, or by incorporating the event in a personal account (reading a history book, visiting a historical site, listening to a song). Crucially, in some of these reworkings, the event is actualized as controversial. These temporal complications directly informed our research, analysis, and visualization.

The above considerations translate in the following research questions:

Source time: Do we primarily find contemporary sources or historical sources in the various spheres? Does this vary across controversies?

Historical time: Do the sources on a platform focus on the historical moment itself, or a contemporary reworking of the moment? Does this vary across controversies?

Heat of the controversy: Is the controversy treated as settled, or is it actualized as still controversial? Does this vary across platforms and controversies?

A static site generator built with Node.js, JSDOM, and Weld.

I'm beginning to see that some parts of the Web we take for granted are not what actually defines it. The Web is not HTML, CSS, and JavaScript. It's not DOM, SVG, WebGL, PNG, or Flash. The Web is really just HTTP over TCP/IP. What gets transported over HTTP does not define the Web.

There is, however, one other characteristic that does define the Web, and that is the humble hyperlink. Links are a feature of HTML, but they are not limited to HTML. Links are the connections that give the Web its name, and links are the biggest thing missing from native platforms.

My definition of the Web then is resources loaded over the Internet using HTTP and then displayed in a hyperlink-capable client.

Microformats, RDFa and microdata all enable consumers to extract data from HTML pages. This data may be embedded within enhanced search engine results, exposed to users through browser extensions, aggregated across websites or used by scripts running within those HTML pages.

This guide aims to help publishers and consumers of HTML data use it well. With several syntaxes and vocabularies to choose from, it provides guidance about how to decide which meets the publisher's or consumer's needs. It discusses when it is necessary to mix syntaxes and vocabularies and how to publish and consume data that uses multiple formats. It describes how to create vocabularies that can be used in multiple syntaxes and general best practices about the publication and consumption of HTML data.

his courses focuses on understanding the Web as an information system, and how to use it for information management for personal and shared information. The Web is an open and constantly evolving system which can make it hard to understand how the different parts of the landscape fit together. This course provides students with an overview of the Web as a whole, and how the individual parts it together. We briefly look at topics such as Web design and Web programming, but this course is not exclusively designed to teach HTML or JavaScript. Instead, we look at the bigger picture and how and when to use these and other technologies. The Web already is and will remain a central part in many information-related activities for a long time to come, and this course provides students with the understanding and skills to better navigate and use the landscape of Web information, Web technologies, Web tools, and common Web patterns.

1 - Find the set of architecture properties of key interest[1]
2 - Formulate an active approach to defining our an architecture that
induces these properties[2]
3 - Then, using the collective knowledge of already existing styles [3]
4 - Develop a style that meets the needs of the identified problem domain

This process is the actual topic of Fielding's dissertation. "REST" is
just his example "step 4" from above.

The primary activity of the TAG is to develop Architectural Recommendations. The TAG findings listed below document fundamental principles that should be adhered to by all Web components. The TAG expects to include these findings in the TAG's Architectural Recommendations, to be published according to the requirements of the W3C Recommendation Track process.

The World Wide Web uses relatively simple technologies with sufficient scalability, efficiency and utility that they have resulted in a remarkable information space of interrelated resources, growing across languages, cultures, and media. In an effort to preserve these properties of the information space as the technologies evolve, this architecture document discusses the core design components of the Web. They are identification of resources, representation of resource state, and the protocols that support the interaction between agents and resources in the space. We relate core design components, constraints, and good practices to the principles and properties they support.

Presentation from Cesare Pautasso and Erik Wilde.

• There are two distinct relationships between names and things. Reference is different from access. The architecture of the Web determines access, but has no direct influence on reference
• Reference can be established by ostention or by description. Description is inherently ambiguous; ostention can be done only to accessible entities.
• Therefore, references to non-accessible entities - the vast majority of references - must be by description, and hence must be ambiguous.
• Reference to accessible entities still differs from access. Establishing reference by ostention requires naming conventions. Access is one form of ostention.

HTTP URIs, in the web architecture, have been used to denote documents -- "web pages" informally, or "information resources" more formally. However, with the growth of the Semantic Web, which uses URIs to denote anything at all, the urge to use and practice of using HTTP URIs for arbitrary things grew steadily. The W3C Technical Architecture group eventually decided to resolve the architectural problem that if an HTTP response code of 200 (a successful retrieval) was given, that indicated that the URI indeed was for an information resource, but with no such response, or with a different code, no such assumption could be made. This compromise resolved the issue, leaving a consistent architecture.

I believe that this solution enables people to name arbitrary
resources using the "http" namespace without any dependence on
fragment vs non-fragment URIs, while at the same time providing
a mechanism whereby information can be supplied via the 303
redirect without leading to ambiguous interpretation of such
information as being a representation of the resource (rather,
the redirection points to a different resource in the same way
as an external link from one resource to the other).

I didn't have this thought out a few years ago. It has only been in actually building a relatively formal system on top of the web infrastructure that I have had to clarify these concepts my own mind. I am forced to conclude that modeling the HTTP part of the web as a web of abstract documents if the only way to go which is practical and, by the philosophical underpinnings of the WWW, tenable.

history has shown that the HTTP protocol is a very flexible protocol and that not all implementations need to follow the example provided by Fielding in order to meet the needs of users. for example, RPC over HTTP works just fine for many cases; esp. those that do not require system stability on the scale of years/decades.

however, the more important it is for the solution to continue to operate (and evolve) over an extended period of time, the more useful are the additional constraints Fielding identified in his example and the more important it is to optimize for run-time stability over ease/speed of initial implementation.

URLs can be used to identify abstract concepts or other things that do not exist directly on the Web.  This is sensible, but it means that the same URL might be used in conjunction with four different (but related) things: a name, a concept, a Web location or a document instance.  Somehow, we need conventions for denoting these four different uses.  Two approaches are available: different names or different context.  The "different names" approach requires new URI schemes or conventions; the "different context" approach requires syntactic conventions for indicating the intended context.

This document analyzes the definition of "resource" in RFC2396 [1] in an attempt to understand it.  It notes ten questions or points of confusion (labeled QUESTION1 - QUESTION10) that I encountered.
 
WARNING: This analysis is painfully detailed, and somewhat rambling (sorry!), reflecting my thought process as I (honestly) attempted to understand the definition.  It is only recommended to those who believe that the definition is clear, and want to see evidence to the contrary.

REST is the architectural style of the Web, and closely related to REST is the concept of a HTTP API. A HTTP API is a programmer-oriented interface to a specific service, and is known by other names such as a RESTful service contract, resource-oriented architecture, or a URI Space.

I say closely related because most HTTP APIs do not comply with the uniform interface constraint in it's strictest sense, which would demand that the interface be "standard" - or in practice: Consistent enough between different services that clients and services can obtain significant network effects. I won't dwell on this!

One thing we know is that these APIs will change, so what can we do at a technical level to deal with these changes as they occur?

RequestBin lets you create a URL that will collect requests made to it, then let you inspect them in a human-friendly way. Use RequestBin to see what your HTTP client is sending or to look at webhook requests.

The subjects covered in this document are large and complex, and there is a risk of growing to become unwieldy. The scope of the document is limited, though: to summarize the design considerations important for creating W3C specifications that enable stable standards for the Web, in a way that the Web standards community can discuss issues and altenatives with a common framework, and the evolution of the Web not hindered by interoperability concerns.

One of the important aspects of the Web that is, unlike many other communication applications, there is a broad community of Web developers: designers, programmers, individuals, software engineers, who create instances or strings intended for use in the languages of the Web. Because of the breadth of users as well as large numbers of implementations, the evolution and standadization of the Web has been different from the evolution of most previous communication standards. The history of the evolution of the web is messy: "browser wars", "best viewed by", widespread misunderstanding, slow standards. If we understand better the way in which the Web evolves, we can facilitate the development of useful standards.

The development and widespread use of Internet technologies and platforms that are grouped under the labels “Web 2.0” and “social media” have led to celebratory accounts of their potential as tools to unleash human creativity. A “creativity consensus” has emerged that describes a vision of creative production via these new platforms as universal, democratic, communal, non-commercial, and revolutionary. The avant-garde of Web 2.0 creativity are said to be young, web-savvy media makers: a new generation that has embraced new technology and is upending old notions of creativity and related cultural practices. This dissertation challenges these views through an ethnographic investigation of deviantART, the self-described “world’s largest online art community.” The dissertation demonstrates how conflicting ideals of art, creativity, and the web, when put into practice, shaped the site as ideological and technical infrastructure for creative practice and the formation of members’ creative identities. In their use of the site, participants in deviantART actively, and at times contentiously, engaged with historical tensions concerning both art and the web. The dissertation explores tensions emerging around three sets of concerns: (1) gaining artistic recognition through visibility, popularity, or quality; (2) demonstrating artistic “seriousness” in relation to ways of improving at art; and (3) controlling and circulating work through the concepts of property, “sharing,” and “theft.” The dissertation argues that rather than upending Romantic conceptions of art and creativity, the web uneasily accommodates multiple conflicting ideologies. Intersecting with tensions in art are tensions around the web and its overlapping corporate, commercial, and communal uses. deviantART brought together a diverse set of art worlds and creative practices via a seemingly conventional set of interfaces, features, and functionality. In turn, participants on the site helped manifest, reproduce, and transform these tensions in art practice and web use. These findings illustrate flaws in conventional accounts of creativity in a world with the web—accounts that fail to recognize the active, contested, and ongoing work underlying the mutual production of creative practice and the web.

Common Crawl Foundation is a California 501(c)3 non-profit founded by Gil Elbaz with the goal of democratizing access to web information by producing and maintaining an open repository of web crawl data that is universally accessible.

Pyramid is a very general open source Python web framework. As a framework, its primary job is to make it easier for a developer to create an arbitrary web application. The type of application being created isn’t really important; it could be a spreadsheet, a corporate intranet, or an “oh-so-Web-2.0” social networking platform. Pyramid is general enough that it can be used in a wide variety of circumstances.

Oui is a kit and framework for building larger websites, in the same fashion as networked and distributed desktop applications.

All code is modern JavaScript -- Node.js for the server and in the browser at the client side.
The user interface is completely handled client-side
Client-server communication is REST-ful and exchange structured data (JSON)
All JavaScript, HTML and CSS is namespaced (derived from file structure)

This document specifies relation types for Web links, and defines a
registry for them. It also defines the use of such links in HTTP
headers with the Link header field.

New media offer an unprecedented opportunity to revise our literary economy. One crucial anxiety is that we be able to find (and to publish) good work of local or specific importance, since much human knowledge is not popular. Small, low-traffic sites are thus of considerable interest to the health of the Web, though individually these sites possess small economic leverage. The challenge these sites face is increased by the noisiness of web traffic; herds, flocks, and cadres of narrative-driven fans can all increase traffic one day and eliminate it another. For large sites, this poses no problem, but for smaller sites this granularity, combined with the zero lower bound, can have catastrophic consequences both for individual publications and for the overall shape of the Web.

the recently published RFC 5988 (Web Linking) specifies relation types for web links more generally, and defines a registry for them. it also defines the use of such links in HTTP headers using the Link header field. this means that from now on, links for RESTful application do not (necessarily) have to be embedded in representations anymore. instead, if they pertain to the requested resource, they can be communicated in a Link header field, which is specifically mentioned to be semantically equivalent to HTML's <link> element and Atom's feed-level <link> element.

the immediate advantage of this approach is that links can now be used for resources where the representation does not define a place to put them, and that resources do not have to be parsed to find links connecting them to other resources. in fact, by using HEAD requests, resources do not even have to be retrieved to find the links that link them to other resources, which means that Link-aware clients can traverse RESTful services in a much more efficient way, as long as all they need are resource-level links.

A drawing to demonstrate the value of REST and the Web for systems integration.

"HTTP has been successfully conflating names and addresses since 1989."

The Unicode Consortium provides four standard normalization forms (see Unicode Normalization Forms [UTR #15]). These forms differ in 1) whether they normalize towards decomposed characters (NFD, NFKD) or precomposed characters (NFC, NFKC) and 2) whether they normalize away compatibility distinctions (NFKD, NFKC) or not (NFD, NFC).

For use on the Web, it is important not to lose the so-called compatibility distinctions, which may be important (see [UXML] Chapter 4 for a discussion). The NFKD and NFKC normalization forms are therefore excluded. Among the remaining two forms, NFC has the advantage that almost all legacy data (if transcoded trivially, one-to-one) as well as data created by current software is already in this form; NFC also has a slight compactness advantage and a better match to user expectations with respect to the character vs. grapheme issue. This document therefore chooses NFC as the base for Web-related text normalization.

NOTE: Roughly speaking, NFC is defined such that each combining character sequence (a base character followed by one or more combining characters) is replaced, as far as possible, by a canonically equivalent precomposed character. Text in a Unicode encoding form is said to be in NFC if it doesn't contain any combining sequence that could be replaced and if any remaining combining sequence is in canonical order.

Spritemapper is an application that merges multiple images into one and generates CSS positioning for the corresponding slices.

Compojure is a small, open source web framework for the Clojure programming language.

Webmachine is an application layer that adds HTTP semantic awareness on top of the excellent bit-pushing and HTTP syntax-management provided by mochiweb, and provides a simple and clean way to connect that to your application's behavior.

The “Chromeless” project experiments with the idea of removing the current browser user interface and replacing it with a flexible platform which allows for the creation of new browser UI using standard web technologies such as HTML, CSS and JavaScript.
 
Instead building a whole new platform, we suggest that the web itself should be the platform. That a developer could design the browser using standard web technologies combined with a minimal set of new APIs to interact with the underlying operating system and control the application's user interface. This new functionality is exposed as lightweight conventions on top of the DOM and javascript modules exposed via the CommonJS packaging standard.

Watir, pronounced water, is an open-source (BSD) family of Ruby libraries for automating web browsers. It allows you to write tests that are easy to read and maintain. It is simple and flexible.

Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. It's a pre-fork worker model ported from Ruby's Unicorn project. The Gunicorn server is broadly compatible with various web frameworks, simply implemented, light on server resources, and fairly speedy.

List of tools for doing research into the "natively digital".

LIVELY, SUBTLE, PERFECTLY LEGIBLE (free) FONTS FOR THE WEB.

We have traditionally analyzed collections of information or things using categories like libraries, museums, archives, content or knowledge management systems, and data repositories. The concept of an organizing system complements this categorical view with a dimensional perspective that sees these categories as sets of design patterns that reflect typical answers to questions about what is being organized, why, when, how much, who is doing the organizing, and how services are provided to interact with the organizing system. These dimensions frame trade-offs and constraints about the content, policies, and implementation of organizing systems. The primary goal of this course is to use these design dimensions to better understand traditional design patterns and their consequences, and to identify useful new ones.

For example, the thingness, uniqueness, persistence, useful lifetime, mashability, and intended uses and users of the content of an organizing system jointly determine how it is implemented and operated. We will examine how these design influences intersect, and consider what alternative designs would look like if some of these content and policy choices were to change. Furthermore, in many domains the Web has become the default implementation of organizing systems interfaces, yet we don't critically examine the implications this should have on the system itself. So we will study how Web Architecture — or the architectures and constraints implied by other metamodels and architectures such as Linked Data or WS-* services — influence decisions about content granularity and structure, how identity and provenance are supported, the kinds of interactions and services the organizing system allows, and so on.

A clean and consistent syntax, optimized for modern use cases including string interpolation and event based programming, and one that generates human readable JavaScript. Couple it with HAML and SASS, and the maintainability of web pages goes way up.

FlexPaper displays documents in your favorite browser using flash. Its way of reusing display containers makes it possible to view large documents and books.

Piwik is a downloadable, open source (GPL licensed) real time web analytics software program. It provides you with detailed reports on your website visitors: the search engines and keywords they used, the language they speak, your popular pages… and so much more.

Piwik aims to be an open source alternative to Google Analytics.

IIPImage is an Open Source light-weight streaming client-server system for the web-based viewing and zooming of ultra high-resolution images.

IIPImage is a light-weight client-server system for fast and efficient online viewing and zooming of ultra high-resolution JPEG2000 and TIFF images.

oEmbed is a format for allowing an embedded representation of a URL on third party sites. The simple API allows a website to display embedded content (such as photos or videos) when a user posts a link to that resource, without having to parse the resource directly.

It must be simple for Web developers to extract and utilize structured information from a Web document. This document details such a mechanism; an RDFa Document Object Model Application Programming Interface (RDFa DOM API) that allows simple extraction and usage of structured information from a Web document.

"Creating a rumor on the Internet is a cost-free form of entertainment.  During the communication process, the truth is often beaten out by the lies.   Rumors often coincide intentionally or unintentionally with certain of emotions.  This is one way in which the bad currency eliminates the good currency on the Internet."

Blueprint is a CSS framework, which aims to cut down on your development time. It gives you a solid foundation to build your project on top of, with an easy-to-use grid, sensible typography, useful plugins, and even a stylesheet for printing.

It Sticks to the Bottom of the Page!

Nicely designed portfolio site.

Typekit is the easiest way to use real fonts on the web. It's a subscription-based service for linking to high-quality Open Type fonts from some of the worlds best type foundries. Our fonts are served from a global network on redundant servers, offering bulletproof service and incredible speed.

If you are running local tests against your application using WebTest, with just a little tweaking you can turn those tests into HTTP tests (i.e., actually connect to a socket).

formencode.htmlfill is a library to fill out forms, both with default values and error messages. It’s like a template library, but more limited, and it can be used with the output from other templates.

Varnish is a state-of-the-art, high-performance HTTP accelerator.

In search of a good general-purpose method of pulling the content out of arbitrary web pages and leaving the boilerplate, advertising, navigation, etc. behind. See also http://bit.ly/4SFOIH

I see signs that the essential freedoms of the web are being undermined by a cadre of companies through the introduction of new technologies and interfaces that, combined, may spell the death of the URL.

Discover a clean alternative to bloated enterprise Java stacks. Play focuses on developer productivity and targets RESTful architectures.

There has been a lot of confusion from a wide varying uses use of this term for various different historical reasons, leading to uses which are sometimes ambiguous and in places inconsistent. This article attempts to shed light on the issue.

“Portable clouds” is a name for the idea that the “cloud” of the Internet is / can be made portable by copying portions of it onto your local networks, desktops and portable devices. Another way to say this is: really great replication and caching of the web.

Citation info for all W3C documents in bibtex format.

Comprehensive comparison of web-based timeline tools.

The mission of the Media Fragments Working Group, part of the Video in the Web Activity, is to address temporal and spatial media fragments in the Web using Uniform Resource Identifiers (URI).

Varnish is a state-of-the-art, high-performance HTTP accelerator. It uses the advanced features in Linux 2.6, FreeBSD 6/7 and Solaris 10 to achieve its high performance.

Short URL auto-discovery is a simple way to link a long URL with a short URL. The following code should be placed in the <head> section of the HTML page: <link rel="shorturl" href="http://short.com/1234" />

Implementing rev=canonical short URLs in Django.