581 research outputs found
The web as a runtime in mobile context
Web-teknologiat kehitettiin alun perin kuvaamaan staattisten web-sivujen sisältöä. Web-selainten suosion vuoksi samoja teknologioita hyödynnetään nykyisin myös sovellusten toteuttamiseen käyttäen web-selainta niiden suorittamiseen vuorovaikutteisesti.
Web-teknologioiden suosiosta huolimatta ne sisältävät useita ongelmia ohjelmistojen toteuttamisen näkökulmasta. Lisäksi mobiililaitteiden rajoitukset tekevät kaikilla laitteilla toimivien sovellusten toteuttamisesta haasteellista. Tämän vuoksi uusia ohjelmistoalustoja on kehitetty ratkaisemaan web-selainten asettamia rajoituksia.
Tässä diplomityössä koostetaan vaatimukset mobiililaitteissa toimiville web-sovelluksille. Tämän lisäksi web-sovelluksille luodaan luokitusjärjestelmä ja tärkeimmät web-sovelluskehitykseen liittyvät web-teknologiat ja ohjelmistoalustat esitellään. Esimerkkisovellus toteutetaan käyttäen web-teknologioita ja hyödyntäen ohjelmistoalustan ominaisuuksia. Lisäksi esimerkkisovellus arvioidaan määritettyä vaatimusmäärittelyä vastaan.
Arviointi paljasti lukuisia haasteita, jotka liittyivät web-teknologioiden puutteelliseen ilmaisuvoimaan, yhteentoimivuuteen ja ohjelmistoalustan toiminnallisuuteen. Tästä huolimatta esimerkkisovellus toteutti sille asetetut vaatimukset työpöytäohjelmistotasoisesta toiminnallisuudesta.Web technologies were initially designed to facilitate the creation of static web pages. However, the ubiquity of the web browser has motivated the use of the same technologies as a basis for desktop-style applications which are executed within the web browser and have their characteristics such as high interactivity.
Despite the popularity of web applications, there exists various problems due to the fact that established web technologies were not specified with applications in mind. In addition, the constraints introduced by mobile devices challenge the ubiquity of such applications. On this account, new platforms have emerged extending the capabilities of web browsers.
In this thesis, the requirements for client-side web applications in mobile context are synthesized. Moreover, a taxonomy for web applications is drawn and client-side web technologies and major software platforms relevant to the client-side web applications are discussed. Furthermore, an application concept implementation developed using web technologies leveraging the capabilities of the major mobile platform is presented and evaluated against the defined requirements.
The evaluation revealed various problems related to limited expressiveness of web technologies, interoperability and platform functionality. Regardless, the implementation provided a level of functionality comparable to that of native applications
Web 2.0: Capabilities, Business Value and Strategic Practice
Web 2.0 is the adoption of open technologies and architectural frameworks to facilitate participative computing. Web 2.0 has the potential to deliver rich peer-to-peer interactions among users, enable collaborative value creation across business partners and create dynamic new services and business models. With the emergence of new information technology it is necessary for organizations to redefine and reassess the new technology and its business value. Extant research does not provide managers guidance on how they can utilize their web 2.0 presence to add value creating activities for the organization. In this research we develop a conceptual foundation for the value propositions enabled by web 2.0 technologies. We provide taxonomy of features, capabilities and organizational value added activities. We develop a model of Web 2.0 capabilities and the nature of value adding services they can provide
This Is the World Calling: The Global Voices and Visions of Internet Radio and Television
Internet radio and TV--tuning into information and feature programs broadcast via the Internet and receivable on a personal computer--piqued interest among educators, librarians, and instructional technologists in the 1990s. Then, connectivity and bandwidth issues affected widespread use. However, interest in Internet broadcasting and podcasting has seen a resurgence in the last few years. Internet radio and TV is more than just a new toy--there's real content online, applicable to the curriculum. Language instruction, music, politics, religion, history, culture, business, science, and more are just a few clicks away. This session will provide background on international Internet radio and TV broadcasting; sources for programs; curricular materials available online; and ideas for application to library and educational services
Pro Web 2.0 Mashups: Remixing Data and Web Services
XXXIII, 603 p. ; 24 cmLibro ElectrónicoEn cub.: Remix the Web to create cutting-edge web applicationsHow many times have you seen a web site and said, “This would be exactly what I wanted—
if only . . .” If only you could combine the statistics here with data from your company’s earnings
projections. If only you could take the addresses for those restaurants and plot them on one
map. How often have you entered the date of a concert into your calendar with a single click
instead of retyping? How often do you wish that you could make all the different parts of your
digital world—your e-mail, your word processor documents, your photos, your search results,
your maps, your presentations—work together more seamlessly? After all, it’s all digital and
malleable information—shouldn’t it all just fit together?
In fact, below the surface, all the data, web sites, and applications you use could fit together.
This book teaches you how to forge those latent connections—to make the Web your own—by
remixing information to create your own mashups. A mashup, in the words of the Wikipedia, is
a web site or web application “that seamlessly combines content from more than one source
into an integrated experience.”1 Learning how to draw content from the Web together into new
integrated interfaces and applications, whether for yourself or for other others, is the central
concern of this book.ÂżCuántas veces ha visto usted a un sitio web y le dijo: "Esto serĂa exactamente lo que querĂa-
si sĂłlo. . . "Si sĂłlo pudiera combinar las estadĂsticas aquĂ con los datos de las ganancias de su empresa
proyecciones. Si tan sĂłlo pudiera tener las direcciones de los restaurantes y colĂłcalas en una
mapa. ¿Cuántas veces has entrado en la fecha de un concierto en su calendario con un solo clic
en lugar de volver a escribir? ÂżCon quĂ© frecuencia desea que usted podrĂa hacer todas las diferentes partes de su
mundo digital, el correo electrĂłnico, los documentos procesador de textos, fotos, resultados de la bĂşsqueda,
sus mapas, sus presentaciones, trabajar juntos con mayor perfección? Después de todo, todo es digital y
maleable que la informaciĂłn shouldn't a sĂłlo encajan entre sĂ?
De hecho, debajo de la superficie, todos los datos, sitios web, y aplicaciones que utiliza podrĂa encajar.
Este libro te enseña a forjar esas conexiones latentes a hacer de la web su propio por
informaciĂłn remezcla para crear su propia mashups. Un mashup, en palabras de la Wikipedia, es
un sitio web o aplicación web "que combina a la perfección el contenido de más de una fuente
en una experiencia integrada. "1 Aprender a dibujar el contenido de la Web junto a nuevos
interfaces integradas y aplicaciones, ya sea para usted o para otros, es el centro de
preocupaciĂłn de este libro.The modern Web is awash with data and services just waiting to be used, but how do you make effective use of all this information? The answer lies in APIs (such as Google Maps, Flickr, and Amazon Web Services) and remixing, or mashups. "Pro Web 2.0 Mashups: Remixing Data and Web Services" teaches you everything you need to create useful, dynamic real-world applications using APIs, web services, Ajax, web standards, and server-side languages. All you need to make full use of this book is basic knowledge of HTML, CSS, and JavaScript, and at least one server-side language (such as PHP or ASP.NET). Highlights include the following: Looks at the overall shape of todays Web from a developers point of view--what are its main features, and what is available for us to use to develop applications? Contains real-world examples of creating mashups using all the major APIs. Contains examples written in multiple server-side languages. What you'll learn Understand how the constituent parts of the modern Web fit together--web standards, Ajax, APIs, libraries, tagging, blogs, wikis, and more. Create different types of mashup, for example mapping mashups, search functionality, calendars, RSS/Atom feeds, social bookmarking, online storage systems, open document formats, and more. Build Web 2.0 applications using HTML, CSS, JavaScript, Ajax, server-side languages, APIs, and libraries Who is this book for? This book is for any web developer who is already comfortable with HTML, CSS, JavaScript, and at least one server-side language and wants to learn how to create Web 2.0 applications. About the Apress Pro Series The Apress Pro series books are practical, professionaltutorials to keep you on and moving up the professional ladder. You have gotten the job, now you need to hone your skills in these tough competitive times. The Apress Pro series expands your skills and expertise in exactly the areas you need. Master the content of a Pro book, and you will always be able to get the job done in a professional development project. Written by experts in their field, Pro series books from Apress give you the hard-won solutions to problems you will face in your professional programming career. Related Titles Beginning Google Maps Applications with PHP and Ajax: From Novice to Professional Beginning Google Maps Applications with Rails and Ajax: From Novice to Professional Building Flickr Applications with PHP Pro DOM Scripting with Ajax, APIs and Libraries Pro Ajax and the .NET 2.0 Platform Pro Ajax and Java Frameworks.About the Author xxi
About the Technical Reviewer xxiii
Acknowledgments xxv
Introduction xxvii
PART 1 Remixing Information
Without Programming
CHAPTER 1 Learning from Specific Mashups 3
Looking for Patterns in Mashups 3
Housingmaps.com5
What Is Being Combined? 5
Why Are the Constituent Elements Being Combined? What’s the
Problem Being Solved? 5
Where Is the Remixing Happening? 6
How Are These Elements Being Combined? 6
Comparable Mashups 7
Google Maps in Flickr 7
What Is Being Combined? 8
Why Are the Constituent Elements Being Combined? What’s the
Problem Being Solved? 8
How Are These Elements Being Combined? 12
Comparable Mashups 13
LibraryLookup Bookmarklet13
Configuring a LibraryLookup Bookmarklet 14
Invoking the LibraryLookup Bookmarklet 15
How Does This Mashup Work? 16
How Can This Mashup Be Extended?17
Comparable Mashups 18
Tracking Other Mashups 18
Summary 18
vii
CHAPTER 2 Uncovering the Mashup Potential of Web Sites 21
What Makes Web Sites and Applications Mashable 22
Ascertaining the Fundamental Entities of the Web Site22
Public APIs and Existing Mashups 23
Use of Ajax 24
Embedded Scriptability 24
Browser Plug-Ins 25
Getting Data In and Out of the Web Site 25
The Community of Users and Developers 25
Mobile and Alternative Interfaces and the Skinnability
of the Web Site 26
Documentation 26
Is the Web Site Run on Open Source? 26
Intellectual Property, Reusability, and Creative Commons 26
Tagging, Feeds, and Weblogging27
URL Languages of Web Sites27
Some Mashups Briefly Revisited 28
Flickr: The Fundamentally Mashup-Friendly Site 29
Resources in Flickr 29
Users and Photos 30
Data Associated with an Individual Photo 33
Tags 34
User’s Archive: Browsing Photos by Date 36
Sets 37
Collections37
Favorites 37
A User’s Popular Photos 38
Contacts 38
Groups 38
Account Management40
Browsing Through Flickr40
Search 41
Geotagged Photos in Flickr 42
The Flickr Organizer 43
Recent Activities44
Mailing Interfaces 44
Interfacing to Weblogs 44
Syndication Feeds: RSS and Atom 45
Mobile Access45
Third-Party Flickr Apps 45
viii CONTENTS
Creative Commons Licensing 46
Cameras 46
The Mashup-by-URL-Templating-and-Embedding Pattern 47
Google Maps 49
URL Language of Google Maps 49
Viewing KML Files in Google Maps51
Connecting Yahoo! Pipes and Google Maps 51
Other Simple Applications of the Google Maps URL Language 52
Amazon 53
Amazon Items53
Lists 55
Tags 55
Subject Headings 55
del.icio.us 56
Screen-Scraping and Bots 58
Summary 60
CHAPTER 3 Understanding Tagging and Folksonomies61
Tagging in Flickr 62
Tags in Flickr 63
How Tags Are Used in Practice 63
Creating Your Own Tags 64
Syntax of Tags in Flickr 64
Potential Weaknesses of Tags 65
Singular and Plural Forms of Tags in Flickr 65
Hacking the Tagging System: Geotagging and Machine Tags 66
Interesting Apps Using Flickr Tags 67
Tagging in del.icio.us 67
Mechanics of Adding Tags in del.icio.us 68
Dealing with Case and Multiword Phrases 68
Getting More Information 69
Gathering Content Through Tags in Technorati71
Searching Technorati with Tags71
How Technorati Finds Tags on the Web 72
Word Inflections and Syntactic Constraints in Technorati Tags 72
Using Tags to Mash Up Flickr and del.icio.us 72
Other Systems That Use Tagging 73
Relationship of Tags to Formal Classification Schemes 73
Summary 75
CONTENTS ix
CHAPTER 4 Working with Feeds, RSS, and Atom77
What Are Feeds, and Why Are They Important? 78
RSS 2.0 78
RSS 1.0 80
Atom 1.0 82
Extensions to RSS 2.0 and Atom 1.0 84
Feeds from Flickr86
Flickr Feed Parameters 86
Examining the Flickr Feeds 87
Exchange Formats Other Than RSS and Atom 90
Feeds from Other Web Sites 92
Finding Feeds and Feed Autodiscovery 93
Feeds from Weblogs 94
Wikipedia Feeds94
Google and Yahoo! News 95
News Aggregators: Showing Flickr Feeds Elsewhere 96
Validating Feeds98
Scraping Feeds Using GUI Tools 98
Remixing Feeds with Feedburner 99
Remixing Feeds with Yahoo! Pipes 100
A Simple First Pipe with Yahoo! News 101
Google News and Refactoring Pipes102
Wikinews and NY Times: Filtering Feeds 103
Pulling the Feeds Together 104
Summary 104
CHAPTER 5 Integrating with Blogs 105
Integration Scenarios for Blogs 105
Sending Flickr Pictures to Blogs 106
Configuring Flickr for Integration with Blogs107
Blogging a Flickr Picture110
How Does the Flickr Blog Integration Work?110
Desktop Blogging Tools 111
Combining Feeds and Blogging to Generate Feedback Flows113
Flock: Bringing Together Blogs and Flickr 114
RSD: Discoverability of Blog APIs 115
Linkbacks 116
Wiki Integration at an Early Stage 116
Summary 117
x CONTENTS
PART 2 Remixing a Single Web Application
Using Its API
CHAPTER 6 Learning Web Services APIs Through Flickr 121
An Introduction to the Flickr API 122
What Does This XML Response Mean? 124
What Can You Do with the XML Response? 126
API Documentation, Community, and Policy 128
Terms of Use for the API 128
Using the Flickr API Explorer and Documentation 129
Calling a Basic Flickr API Method from PHP 132
HTTP Clients 133
A Refresher on HTTP 134
XML Processing 138
Pulling It All Together: Generating Simple HTML
Representations of the Photos 143
Where Does This Leave Us?145
The Flickr API in General 145
Using flickr.reflection Methods 146
Querying the Flickr Reflection Methods with PHP 149
Request and Response Formats 154
Flickr Authorization 156
Why Passing Passwords Around Doesn’t Work Too Well157
Authorization for Web Apps 157
Using Flickr API Kits 165
PEAR::Flickr_API 165
phpFlickr 166
Phlickr 168
Limitations of the Flickr API 169
Summary 170
CHAPTER 7 Exploring Other Web APIs 171
XML-RPC172
What’s Happening on the Wire? 176
Using Wireshark and curl to Analyze and Formulate
HTTP Messages 177
Parsing XML-RPC Traffic178
CONTENTS xi
SOAP 181
The Dream: Plug-and-Go Functionality Through WSDL
and SOAP 181
geocoder.us 182
Amazon ECS 191
The Flickr API via SOAP195
Learning About Specific Web APIs 195
Programmableweb.com 196
YouTube 198
GData and the Blogger API 199
Using the Blogger API As a Uniform Interface Based on
HTTP Methods203
Summary 204
CHAPTER 8 Learning Ajax/JavaScript Widgets and Their APIs 205
What You Need to Know206
What Difference Does Ajax Make? 207
Learning Firebug, DOM Inspector, and JavaScript Shell 208
Using the DOM Inspector 208
Using the Firebug Extension for Firefox 208
Using the JavaScript Shell 210
Working with JavaScript Libraries 210
YUI Widgets211
Using the YUI Calendar 211
Installing YUI on Your Host 212
Learning Google Maps 213
Accessing Flickr via JavaScript217
Using Greasemonkey to Access New York Times Permalinks 220
Learning More About JavaScript and Ajax 223
Summary 223
PART 3 Making Mashups
CHAPTER 9 Moving from APIs and Remixable Elements
to Mashups 227
Getting Oriented to ProgrammableWeb 228
User-Generated Data in ProgrammableWeb 228
Can Any Directory of Mashups Keep Up? 228
Learning About the Overall Mashup Scene 229
xii CONTENTS
Directory of Mashups 230
Using Feeds to Track Mashups 230
Using Tags to Describe Mashups 231
API and Mashup Verticals 233
Looking at a Specific Mashup Profile233
Going from a Specific API to Mashups234
Sample Problems to Solve Using Mashups235
Tracking Interesting Books235
Knowing When to Buy Airplane Tickets 239
Finding That Dream House240
Mapping Breaking News 241
Summary 242
CHAPTER 10 Creating Mashups of Several Services 243
The Design 244
Background: Geotagging in Flickr245
Background: XMLHttpRequest and Containing Libraries 248
Using XMLHttpRequest Directly248
Using the YUI Connection Manager250
Building a Server-Side Proxy253
What Happens with XHR and Direct API Calls?253
Building a Server-Side Script for Geolocated Photos255
Building a Simple Client-Side Frame 257
Reading and Writing Elements257
Handling Simple Events to Connect Form Input and
Display Calculations 260
Hooking the Client-Side Framework to Flickr 261
Writing a URL for Querying flickrgeo.php 262
Using XHR via the YUI Connection Manager to
Read the JSON 262
Converting the JSON to HTML 264
Mashing Up Google Maps API with Flickr 266
Setting Up a Basic Google Map 267
Making the Map Respond to Changes in the
Viewport of the Map268
Bringing Together the Flickr and GMap Code 269
Wiring Up the Bounding Box of the Google Map270
Making the Pictures Show Up in the Map 272
Google Mapplet That Shows Flickr Photos 277
Summary 281
CONTENTS xiii
CHAPTER 11 Using Tools to Create Mashups 283
The Problem Mashup Tools Solve284
What You Are Making in This Chapter 284
Making the Mashup: A Step-by-Step Example286
Familiarizing Yourself with the Google Mashup Editor287
Reading and Displaying a Feed (Simple Template) 288
Introducing a Custom Template289
Using Yahoo! Pipes to Access Flickr 291
Displaying Flickr Photos Using 292
Adding JavaScript to the Mashup 294
How to Persist Feeds and Use Tabs 299
The Final Product: Showing the Saved Entries on a Map 304
Analysis of Trade-Offs in Using GME and Yahoo! Pipes309
Other Mashup Tools 310
Summary 311
CHAPTER 12 Making Your Web Site Mashable313
Why Make Your Web Site Mashable? 314
Using Techniques That Do Not Depend on APIs 314
Use a Consistent and Rich URL Language314
Use W3C Standards to Develop Your Web Site 315
Pay Attention to Web Accessibility315
Consider Allowing Users to Tag Your Content 315
Make Feeds Available 315
Make It Easy to Post Your Content to Blogs and
Other Web Sites 316
Encourage the Sharing of Content with Explicit Licenses317
Develop Extensive Import and Export Options for
User Content 317
Study How Users Remix Your Content and
Make It Easier to Do So 317
Creating a Mashup-Friendly API 317
Learn From and Emulate Other APIs318
Keep in Mind Your Audiences for the API 318
Make Your API Easy to Learn 318
Test the Usability of Your API 319
Build a Granular, Loosely Coupled Architecture So That
Creating an API Serves You As Much As It Does Others319
Embrace REST But Also Support SOAP and XML-RPC
If You Can 320
xiv CONTENTS
Consider Using the Atom Publishing Protocol As a Specific
Instantiation of REST 320
Encourage the Development of API Kits: Third Party or
In-House320
Support Extensive Error Reporting in Your APIs 321
Accept Multiple Formats for Output and Input 321
Support UI Functionality in the API 321
Include a Search API for Your Own Site 321
Version Your API 322
Foster a Community of Developers322
Don’t Try to Be Too Controlling in Your API322
Consider Producing a Service-Level Agreement (SLA) 322
Help API Users Consume Your Resources Wisely 323
Consider Open Sourcing Your Application 323
Easy-to-Understand Data Standards 323
Summary 324
PART 4 Exploring Other Mashup Topics
CHAPTER 13 Remixing Online Maps and 3D Digital Globes327
The Number of Online Maps 328
Examples of Map-Based Mashups329
Making Maps Without Programming 329
Mapbuilder.net 329
Google My Maps 331
A Mashup Opportunity: Mapping Yahoo! Local Collections332
Transforming the Yahoo! Local XML into CSV for
Mapbuilder.net 334
Collection Building in Microsoft’s Live Search Maps 336
Summary of Making Maps Without Programming 338
Data Exchange Formats 338
CSV338
Microformats and Metatags for HTML 338
GeoRSS 339
Yahoo!’s Use of GeoRSS and Yahoo! YMaps Extensions 341
KML 345
Interoperability Among Formats: GeoRSS vsKML346
CONTENTS xv
Creating Maps by API Programming 346
Google Maps API 347
Yahoo! Maps API351
Microsoft’s Live Search Maps/Virtual Earth354
Geocoding356
Yahoo! Maps 356
Geocoder.us 357
Google Geocoder 358
Virtual Earth 361
Geocoding Non-U.SAddresses363
Google Earth and KML 364
Displaying and Handling KML As End Users 364
KML 368
Programming Google Earth via COM and AppleScript374
Mapstraction and OpenLayers 376
An Integrative Example: Showing Flickr Pictures in Google Earth376
KML NetworkLink 379
Generating the KML for the Photos382
The flickrgeo.php Code383
Summary 393
CHAPTER 14 Exploring Social Bookmarking and Bibliographic
Systems 395
The Social Bookmarking Scene 396
Using Programmableweb.com to Examine the
Popularity of APIs 396
del.icio.us 397
Using the del.icio.us API 398
Third-Party Tools for del.icio.us405
Third-Party API Kits 405
Yahoo! Bookmarks and MyWeb407
Connotea408
A Flickr and del.icio.us Mashup 412
Summary 416
CHAPTER 15 Accessing Online Calendars and Event Aggregators 417
Google Calendar 418
Setting Up Google Calendar As an End User 418
Exploring the Feed Formats from Google Calendar 420
xvi CONTENTS
Using the GData-Based Calendar API Directly 426
Using the PHP API Kit for Google Calendar 434
Using the Python API Kit for Google Calendar 437
30boxes.com 438
An End User Tutorial 439
30boxes.com API 439
Event Aggregators 443
Upcoming.yahoo.com 443
Eventful.com452
Programming with iCalendar 458
Python and iCalendar 458
PHP and iCalendar 460
Exporting an Events Calendar to iCalendar and Google Calendar461
The Source: UC Berkeley Event Calendars 462
Creating an iCalendar Feed of Critic’s Choice Using Python462
Writing the Events to Google Calendar464
Summary 471
CHAPTER 16 Using Online Storage Services 473
Introducing Amazon S3 473
Rationale for S3 474
Conceptual Structure of Amazon S3 475
The Firefox S3 Extension Gets You Started with S3476
Using the S3 REST Interface 477
Listing Buckets Using the REST Interface 480
Using the SOAP Interface to S3481
Amazon S3 API Kits 482
PHP 483
Python 484
Summary 486
CHAPTER 17 Mashing Up Desktop and Web-Based Office Suites 487
Mashup Scenarios for Office Suites 487
The World of Document Markup 488
The OpenDocument Format488
Learning Basic ODF Tags 497
Create an ODF Text Document Without Any Styling of
ODF Elements 499
Setting the Paragraph Text to text-body 503
CONTENTS xvii
Formatting Lists to Distinguish Between Ordered and
Unordered Lists504
Getting Bold, Italics, Font Changes, and Color Changes
into Text Spans 505
API Kits for Working with ODF 507
Odfpy 507
OpenDocumentPHP 516
Leveraging OO.o to Generate ODF 518
ECMA Office Open XML (OOXML) 519
Viewers/Validators for OOXML522
Comparing ODF and OOXML 522
Online Office Suites523
Usage Scenarios for Programmable Online Spreadsheets 523
Google Spreadsheets API 524
Python API Kit 524
Mashup: Amazon Wishlist and Google Spreadsheets Mashup528
Zend PHP API Kit for Google Spreadsheets 533
A Final Variation: Amazon Wishlist to Microsoft Excel
via COM 535
Zoho APIs 536
Summary 536
CHAPTER 18 Using Microformats and RDFa As Embeddable Data
Formats537
Using Operator to Learn About Microformats 537
adr (Addresses) 540
hCard (Contacts) 541
hCalendar (Events)542
geo (Locations)543
tag (Tagspaces) 543
Definitions and Design Goals of Microformats 543
Microformats Design Patterns545
rel-design-pattern 545
class-design-pattern 545
abbr-design-pattern 546
include-pattern546
Examples of Microformats 547
rel-license 547
rel-tag 548
xfn548
xviii CONTENTS
xFolk549
geo 549
hCard and adr550
hCalendar 551
Other Microformats 551
Microformats in Practice 552
Programming with Microformats 552
Language-Specific Libraries 552
Writing an Operator Script 553
Studying the Tutorial Script 554
Writing a Geocoding Script556
Resources (RDFa): A Promising Complement to Microformats 557
Reference for Further Study 558
Summary 558
CHAPTER 19 Integrating Search 559
Google Ajax Search 559
Manipulating Search Results 559
Yahoo! Search 561
Yahoo! Images 563
Microsoft Live.com Search 564
OpenSearch 568
Google Desktop HTTP/XML Gateway 570
Summary 571
APPENDIX 573
INDEX 57
Text Mining Infrastructure in R
During the last decade text mining has become a widely used discipline utilizing statistical and machine learning methods. We present the tm package which provides a framework for text mining applications within R. We give a survey on text mining facilities in R and explain how typical application tasks can be carried out using our framework. We present techniques for count-based analysis methods, text clustering, text classification and string kernels.
How To Touch a Running System
The increasing importance of distributed and decentralized software architectures entails more and more attention for adaptive software. Obtaining adaptiveness, however, is a difficult task as the software design needs to foresee and cope with a variety of situations. Using reconfiguration of components facilitates this task, as the adaptivity is conducted on an architecture level instead of directly in the code. This results in a separation of concerns; the appropriate reconfiguration can be devised on a coarse level, while the implementation of the components can remain largely unaware of reconfiguration scenarios.
We study reconfiguration in component frameworks based on formal theory. We first discuss programming with components, exemplified with the development of the cmc model checker. This highly efficient model checker is made of C++ components and serves as an example for component-based software development practice in general, and also provides insights into the principles of adaptivity. However, the component model focuses on high performance and is not geared towards using the structuring principle of components for controlled reconfiguration. We thus complement this highly optimized model by a message passing-based component model which takes reconfigurability to be its central principle.
Supporting reconfiguration in a framework is about alleviating the programmer from caring about the peculiarities as much as possible. We utilize the formal description of the component model to provide an algorithm for reconfiguration that retains as much flexibility as possible, while avoiding most problems that arise due to concurrency. This algorithm is embedded in a general four-stage adaptivity model inspired by physical control loops. The reconfiguration is devised to work with stateful components, retaining their data and unprocessed messages. Reconfiguration plans, which are provided with a formal semantics, form the input of the reconfiguration algorithm. We show that the algorithm achieves perceived atomicity of the reconfiguration process for an important class of plans, i.e., the whole process of reconfiguration is perceived as one atomic step, while minimizing the use of blocking of components. We illustrate the applicability of our approach to reconfiguration by providing several examples like fault-tolerance and automated resource control
MementoMap: A Web Archive Profiling Framework for Efficient Memento Routing
With the proliferation of public web archives, it is becoming more important to better profile their contents, both to understand their immense holdings as well as to support routing of requests in Memento aggregators. A memento is a past version of a web page and a Memento aggregator is a tool or service that aggregates mementos from many different web archives. To save resources, the Memento aggregator should only poll the archives that are likely to have a copy of the requested Uniform Resource Identifier (URI). Using the Crawler Index (CDX), we generate profiles of the archives that summarize their holdings and use them to inform routing of the Memento aggregator’s URI requests. Additionally, we use full text search (when available) or sample URI lookups to build an understanding of an archive’s holdings. Previous work in profiling ranged from using full URIs (no false positives, but with large profiles) to using only top-level domains (TLDs) (smaller profiles, but with many false positives). This work explores strategies in between these two extremes.
For evaluation we used CDX files from Archive-It, UK Web Archive, Stanford Web Archive Portal, and Arquivo.pt. Moreover, we used web server access log files from the Internet Archive’s Wayback Machine, UK Web Archive, Arquivo.pt, LANL’s Memento Proxy, and ODU’s MemGator Server. In addition, we utilized historical dataset of URIs from DMOZ.
In early experiments with various URI-based static profiling policies we successfully identified about 78% of the URIs that were not present in the archive with less than 1% relative cost as compared to the complete knowledge profile and 94% URIs with less than 10% relative cost without any false negatives. In another experiment we found that we can correctly route 80% of the requests while maintaining about 0.9 recall by discovering only 10% of the archive holdings and generating a profile that costs less than 1% of the complete knowledge profile.
We created MementoMap, a framework that allows web archives and third parties to express holdings and/or voids of an archive of any size with varying levels of details to fulfil various application needs. Our archive profiling framework enables tools and services to predict and rank archives where mementos of a requested URI are likely to be present.
In static profiling policies we predefined the maximum depth of host and path segments of URIs for each policy that are used as URI keys. This gave us a good baseline for evaluation, but was not suitable for merging profiles with different policies. Later, we introduced a more flexible means to represent URI keys that uses wildcard characters to indicate whether a URI key was truncated. Moreover, we developed an algorithm to rollup URI keys dynamically at arbitrary depths when sufficient archiving activity is detected under certain URI prefixes. In an experiment with dynamic profiling of archival holdings we found that a MementoMap of less than 1.5% relative cost can correctly identify the presence or absence of 60% of the lookup URIs in the corresponding archive without any false negatives (i.e., 100% recall). In addition, we separately evaluated archival voids based on the most frequently accessed resources in the access log and found that we could have avoided more than 8% of the false positives without introducing any false negatives.
We defined a routing score that can be used for Memento routing. Using a cut-off threshold technique on our routing score we achieved over 96% accuracy if we accept about 89% recall and for a recall of 99% we managed to get about 68% accuracy, which translates to about 72% saving in wasted lookup requests in our Memento aggregator. Moreover, when using top-k archives based on our routing score for routing and choosing only the topmost archive, we missed only about 8% of the sample URIs that are present in at least one archive, but when we selected top-2 archives, we missed less than 2% of these URIs. We also evaluated a machine learning-based routing approach, which resulted in an overall better accuracy, but poorer recall due to low prevalence of the sample lookup URI dataset in different web archives.
We contributed various algorithms, such as a space and time efficient approach to ingest large lists of URIs to generate MementoMaps and a Random Searcher Model to discover samples of holdings of web archives. We contributed numerous tools to support various aspects of web archiving and replay, such as MemGator (a Memento aggregator), Inter- Planetary Wayback (a novel archival replay system), Reconstructive (a client-side request rerouting ServiceWorker), and AccessLog Parser. Moreover, this work yielded a file format specification draft called Unified Key Value Store (UKVS) that we use for serialization and dissemination of MementoMaps. It is a flexible and extensible file format that allows easy interactions with Unix text processing tools. UKVS can be used in many applications beyond MementoMaps
Saving New Sounds
"Over seventy-five million Americans listen to podcasts every month, and the average weekly listener spends over six hours tuning into podcasts from the more than thirty million podcast episodes currently available. Yet despite the excitement over podcasting, the sounds of podcasting’s nascent history are vulnerable and they remain mystifyingly difficult to research and preserve. Podcast feeds end abruptly, cease to be maintained, or become housed in proprietary databases, which are difficult to search with any rigor. Podcasts might seem to be highly available everywhere, but it’s necessary to preserve and analyze these resources now, or scholars will find themselves writing, researching, and thinking about a past they can’t fully see or hear.
This collection gathers the expertise of leading and emerging scholars in podcasting and digital audio in order to take stock of podcasting’s recent history and imagine future directions for the format. Essays trace some of the less amplified histories of the format and offer discussions of some of the hurdles podcasting faces nearly twenty years into its existence. Using their experiences building and using the PodcastRE database—one of the largest publicly accessible databases for searching and researching podcasts—the volume editors and contributors reflect on how they, as media historians and cultural researchers, can best preserve podcasting’s booming audio cultures and the countless voices and perspectives podcasting adds to our collective soundscape.
A series of case studies to enhance the social utility of RSS
RSS (really simple syndication, rich site summary or RDF site summary) is a dialect of
XML that provides a method of syndicating on-line content, where postings consist of
frequently updated news items, blog entries and multimedia. RSS feeds, produced by
organisations or individuals, are often aggregated, and delivered to users for consumption
via readers. The semi-structured format of RSS also allows the delivery/exchange of
machine-readable content between different platforms and systems.
Articles on web pages frequently include icons that represent social media services
which facilitate social data. Amongst these, RSS feeds deliver data which is typically
presented in the journalistic style of headline, story and snapshot(s). Consequently, applications
and academic research have employed RSS on this basis. Therefore, within the
context of social media, the question arises: can the social function, i.e. utility, of RSS be
enhanced by producing from it data which is actionable and effective?
This thesis is based upon the hypothesis that the
fluctuations in the keyword frequencies
present in RSS can be mined to produce actionable and effective data, to enhance
the technology's social utility. To this end, we present a series of laboratory-based case
studies which demonstrate two novel and logically consistent RSS-mining paradigms. Our first paradigm allows users to define mining rules to mine data from feeds. The second
paradigm employs a semi-automated classification of feeds and correlates this with sentiment.
We visualise the outputs produced by the case studies for these paradigms, where
they can benefit users in real-world scenarios, varying from statistics and trend analysis
to mining financial and sporting data.
The contributions of this thesis to web engineering and text mining are the demonstration
of the proof of concept of our paradigms, through the integration of an array of
open-source, third-party products into a coherent and innovative, alpha-version prototype
software implemented in a Java JSP/servlet-based web application architecture
- …