Welcome to YUI Weekly, the weekly roundup of news and announcements from the YUI team and community. If you have any interesting demos or links you’d like to share, feel free to leave a comment below.

• Today we reach the Sprint 7 Feature Complete milestone, which is just fancy terminology for the last day that new feature pull requests can be merged into the next release of YUI. The next milestone on the current development cycle is the Commit Freeze Pull Request Deadline next Tuesday PM. So if you have anything for inclusion into the June 4th release of YUI, you only have a few days left!

• Yeti v0.2.23 was released this week to increases stability in IE and fix a few bugs. Check out the release announcement for more details. Also, Yogi saw a version bump this week (diff) to lock in version dependencies. Upgrade with npm install -g yeti yogi.

• YUI core team members Reid (@reid), Eric (@ericf), and Tilo (@tilomitra) will be attending JSConf.us and CSSConf next week. So say hi if you are in the area!

• In this week’s Open Roundtable (notes, YouTube) we introduced one of our new summer interns, Patrick Jameson (@patjameson). Welcome Pat! We discussed Contributing.md, SWF deprecation, speaker deadlines for upcoming conferences (JSconf.eu and HTML5DevConf), stale pull requests, and tickets that are up for grabs.

• Discussions this week on the contributor mailing list included a proposal to deprecate SWFs, a clarification on Feature Complete, a proposal for migration of the forums to Google Groups, and more.

• Recent additions to the Gallery include:

  • Affix – Inspired by Bootstrap Affix.
  • ScrollSpy – Inspired by Bootstrap ScrollSpy.
  • Task – A utility for simplifying the use of promises by making them behave as synchronous code.

• Updated modules in this week’s Gallery build include: affix, dd-momentum-plugin, debounce, io-utils, scrollspy, and task.

• Links of the Week (thanks to JavaScript Weekly)

  • GIF.js
  • Writing Testable JavaScript
  • Chrome’s requestAutocomplete()
  • Fluent APIs and Method Chaining
  • … and more

Welcome to the weekly summary.

qx.Desktop on mobile devices

Regular qooxdoo desktop apps increasingly become better suited for touch devices. After the recent diet of the desktop widget set, a blog post during the week had details about another improvement: emulating mouse events internally, based on touch events. This allows desktop widgets to continue to work on touch devices.

Bugfixes

For a complete list of tasks accomplished during the last working week, use this bugzilla query.

Bye.

This overview of the Telerik Control panel showcases the ease of installing, updating, upgrading, removing and activating optional features for Telerik Products.

Some weeks back I lobbed an overly terse “noooooooooo!!!!!” at the W3C Web Application Security Working Group over revisions to the CSP 1.1 API; specifically a proposed reduction of the surface area to include only bits for which they could think of direct use-cases in a face-to-face meeting. At the time I didn’t have the bandwidth to fully justify my objections. Better late than never.

For those who aren’t following the minutiae of the CSP spec, it began life as a Mozilla-driven effort to enable page authors to control the runtime behavior of their documents via an HTTP header. It was brought to the W3C, polished, and shipped last year as CSP 1.0; a much better declarative spec than it started but without much in the way of API. This is a very good way for any spec to get off the ground. Having a high-level declarative form gives implementers something they can ship and prove interop with very quickly. The obvious next step is to add an API.

Late last year I started digging into CSP, both for a personal project to implement a “user CSP” extension for Chrome, and to work with the spec authors to see what state the proposed API was in and how it could be improved. The short form of my analysis of the original CSP proposal was that it was pretty good, but missed a few notes. The new proposal, however, is a reflection of the declarative machinery, not an explanation of that machine.

Not coincidentally, this is also the essential difference between thinking in terms of a welded-shut C++ implementation and a user-serviceable JavaScript design.

For example, the previously proposed API provided methods on a SecurityPolicy class like allowsConnectionTo(url) which outline an API that the browser might plausibly need to enforce a policy at runtime. The new API includes no such methods. As someone working with CSP, you suspect the browser indeed has such a method on just such an object, but the ability to use it yourself to compose new and useful behaviors is now entirely curtailed. This is the extreme version of the previous issues: an API that explains would make an attempt to show how the parser is invoked — presumably as a string argument to a constructor for SecurityPolicy. Similarly, showing how multiple policies combine to form a single effective policy would have lead away from document.securityPolicy as something that appears to be a single de-serialized SecurityPolicy and instead be written in terms of a list of SecurityPolicy instances which might have static methods that are one-liners for the .forEach(...) iteration that yeilds the aggregate answer.

So why should any WG bother with what I just described?

First, because they’ll have to eventually, and by showing only enough skin to claim to have an API in this round, the question will be raised: how does one implement new rules without waiting for the spec to evolve? The Extend The Web Forward idea that flows naturally from p(r)ollyfills has shown real power which this new design puts further from reach…but it won’t keep people from doing it. What about implementing something at runtime using other primitives like a Navigation Controller? Indeed, the spec might get easier to reason about if it considered itself a declarative layer on top of something like the Navigation Controller design for all of the aspects that interact with the network.

There are dozens of things that no over-worked spec author in a face-to-face will think to do with each of the platform primitives we create that are made either easier or harder for the amount of re-invention that’s needed to augment each layer. Consider CSS vs. HTML’s respective parsing and object models: both accept things they don’t understand, but CSS throws that data away. HTML, by contrast, keeps that data around and reflects it in attributes, meaning that it has been possible for more than a decade to write behavioral extensions to HTML that don’t require re-parsing documents, only looking at the results of parsing. CSS has resisted all such attempts at gradual runtime augmentation in part because of the practical difficulties in getting that parser-removed data back and it’s a poorer system for it. CSP can either enable these sorts of rich extensions (with obvious caveats!) or it can assume its committee knows best. This ends predictably: with people on the committee re-implementing large bits of the algorithms over and over and over again for lack of extension points, only to try to play with new variations. This robs CSP and its hoped-for user-base of momentum.

Next, the desire to reflect and not explain has helped the spec avoid reckoning with poor use of JavaScript types. The document.securityPolicy object doesn’t conceptually de-sugar to anything reasonable except a list of policy objects…but that more primitive SecurityPolicy object type doesn’t appear anywhere in the description. This means that if anyone wants to later extend or change the policy in a page, a new mechanism will need to be invented for showing how that happens: meta tags parsed via DOM, not objects created in script and added to a collection. All of which is objectionable on the basis that all that will happen is that some objects will be created and added to the collection that everyone suspects is back there anyway. This is like only having innerHTML and not being able to construct DOM objects any other way, and the right way to be presented with the need to go build idiomatic types for what will eventually be exposed one way or another is to try to design the API as though it was being used to implement the declarative form. JavaScript first gets you both good API and a solid explanation of the lifecycle of the system.

There is, of course, another option: CSP 1.1 could punt on an API entirely. That’s a coherent position that eliminates these frictions, and I’m not sure it’s a bad option given how badly the API has been mangled recently. But it’s not the best solution.

I’ve got huge hope for CSP; I think it’s one of the best things to happen to webappsec ever. What happens about the API will always be overshadowed by the value that it is already delivering. But as a design microcosm, its API is a petri-dish sized version of scenario-solving vs. layering, and a great example of how layering can deliver value over time; particularly to people who aren’t in the room when the design is being considered. An API that explains by showing how declarative layers on top of imperative is one that satisfies use case zero: show your work.

Check out the new stuff we just shipped with the Q2'13 Beta and let us know what we can do better for the official release due in less than a month.

Preview Text:  Mobile apps are threatening to engulf software development at many organisations large and small. Even organisations at the vanguard are struggling to find ways to develop and test their mobile apps, and the rest are either much further behind or yet to dip their toes in the water. Legacy Sponsored:  ...

Last year around this same time, I published a blog post about a technique I developed for creating multiple Twitter Bootstrap popovers.  I came up with the technique while building a page containing several icons that, when hovered over with the mouse, would display different Bootstrap popovers with explanatory text and HTML. Preview Text:  ...

This post comes from Ryan Cates at the AnswerHub Blog. Preview Text:  When approaching the task of creating a new standard theme for AnswerHub we wanted to make sure we got one thing right -- Responsive Design. We wanted to provide a consistent experience for users throughout the platform, regardless of the device they're using. ...

I know, I know. The title sounds like SEO-link-bait, I apologize. I want to talk about something that I'm fairly excited about, and I hope it excites you as well. Preview Text:  I know, I know. The title sounds like SEO-link-bait, I apologize. I want to talk about something that I'm fairly excited about, and I hope it excites you as well. ...

I have created a web application that recognizes hand gestures using WebRTC's getUserMedia API. Here's how it works: when you launch the application the browser will prompt you for the permission to access the camera. Click on 'Accept',and then swipe your hand from right to left and vice versa. You would see that the next image  (or the previous image if you swipe from left to right) in...

…but if it were, there would be time to cover the W3C Advisory Board election. This is truly inside-baseball stuff, as most of the AB’s work happens in member-only areas of the W3C website and most of what they effect is W3C process.

So why care? Because spec licensing matters, sadly.

Let me first outline my view: in an ideal world, specification language for web standards would be in the public domain or dedicated to it. The body of intellectual property that is non-copyright is fought over via an independent process, and to the extent that it accumulates in a standards organization, it should also be possible for the group of members that have contributed to take their ball and start again somewhere else.

Why does this matter? Competition.

Standards bodies should not be insulated from the pressure to try to deliver better results. There are, of course, pathologies around this; some of which are common enough to have names: “pay for play”, “venue shopping”, etc. But in general, to the extent that many bodies can produce substitue goods, it gives them a reason to differentiate. The concrete example here is WHATWG vs. W3C. I don’t think it’s controversial to assert that without the WHATWG, the current W3C would be f’d. Competition makes everyone better, even for products that are “free” for consumers and are the product of community effort.

This, then, is why it’s such a terrible idea for the W3C’s Advisory Committee (the people who have some power) to elect representatives to the Advisory Board (who have even more power) that are willing to take the self-interested side of the W3C against liberal licensing of specs over the competition-enabling position that liberal licensing makes everyone better off (to a first approximation).

If you are an AC rep, the time is now to quiz candidates on this point. If you truly think that the W3C is a unique community, it’s important to realize that what makes it that special is a set of shared values, not a death-grip on legacy intellectual property rights. Fixating on that ownership is the fast-path to making everyone worse off; by the time it truly becomes important, it’s so likely that the organization that cares about it needs competition to right the ship or get out of the way.

Some time ago, we started to think about the usage of qx.Desktop UI elements on mobile devices, especially on tablets. There should be no reason why an application using qx.Desktop couldn’t work on tablets as well. And basically that’s true, even for older qooxdoo releases. But our goal wasn’t just to make it usable, but to make it fun to use. With the recently announced diet of the widget set, we took a step into the right direction. This switch reduced the memory footprint and along with that, improved the performance on mobile devices. With this blog post, we want to introduce another step.

Mouse Emulation
Relying on mouse events, as the whole UI layer of qx.Desktop does, comes with some challenges on mobile devices. The common, webkit-based browsers on mobile devices delay the mouse events for a certain timespan, which leads to a sluggish user experience. So we decided not to listen to the native mouse events, but to create our own mouse events based on the touch events offered by the browser. For more details, check out the manual page, which covers what’s supported and how to use it in your own application. Basically, with a certain config setting your app should now also work on touch devices like a tablet (while it still might not be optimized for such a use case, of course).

If you have a touch device like a tablet at hand, just check out the most recent Widget Browser, which has this new feature turned on. Let us know how well you can interact with the app just using your fingers, and please file reports if you encounter any issues.

Here is the new SilverlightShow content for Thursday, May 23rd, 2013.

• [Windows 8] Provide search suggestions based on local files
• Getting the current system language
• What Yahoo and Acer can teach Windows 8 app developers
• Implementing the ISupportIncrementalLoading interface in a Windows Store app
• Create location aware apps using geolocation and Bing Maps

Subscribe to our Daily News Digest RSS Feed to receive a summary of all SilverlightShow news!

Or follow our news on Twitter - @silverlightshow!

Read original post at Thomas Lebrun's Blog

Windows Store Applications allows developers to provide search suggestions to users, so they can find quickly what they are looking for.

For example, you can provide search suggestions using a Web Services or you can even use local files for that. Here is a “naïve” way to do it [...]

Read original post at Kraig Brockschmidt's Blog

Although swapping out language resources is something that happens
somewhat automatically when the user changes system language, sometimes
you want to know that directly.

There are a number of APIs in WinRT that relate to this (thanks to Erik Fortune for this) [...]

Read original post by Ed Bott at ZDNet

Microsoft has sold plenty of licenses for Windows 8. Six months after its launch, the company announced that 100 million licenses had been sold, with each one representing an upgrade copy or a PC that had rolled off the assembly line and was ready for sale. A rough extrapolation from current usage share figures collected by NetMarketShare and StatCounter suggests that 60-70 million of those PCs are in use today.

But how many people are actually trying out the signature feature of Windows 8, its new apps? And how many are continuing to use those apps on a daily basis?

Read original post at Marco Minerva's Blog

The ISupportIncrementalLoading interface allows to easily create a collection in which data is loaded incrementally, when a user is about to the end of the items available on the user interface. Using it, we can obtain a fast & fluid scrolling while loading an huge set of records.

First of all, we need a class that inherits from ObservableCollection and implements the ISupportIncrementalLoading interface [...]

Read original post by Ross Heise at Windows 8 App Developer Blog

By tying together a user’s location to the business logic of your app, you can easily provide app users with weather, coupons, sporting events, or concert listings for their current location. You can use the geolocation capabilities of Windows 8, along with the Bing Maps SDK, to create great location aware Windows Store apps.

Let’s take a look at how your app can use the location service to provide users location-specific info with either an IP address, WiFi network, or GPS data. Once you have the location, you can use the Bing Maps SDK to show the user where they are.

Since the official Q1 2013 release of RadControls for Silverlight and WPF we introduced a new online resource, the XAML GitHub repository. This blog post will explain the main functionalities of the XAML SDK, what could be found in its content and how to work with the included solutions and project.

I really like the generators feature that's arriving in PHP 5.5, and since we're now into release candidate releases, it's actually not that far away. I've been speaking on this topic and I thought I'd share my trivially simple code example from my slides. Writing a Generator The generators use the yield keyword to feed values out as they are iterated over. In code, they really look a lot like a...