“Use long, descriptive class names over short names that don’t document themselves.”

In Yandex we usually separate styles per block, its modifiers, its elements and for their modifiers. But in reality it is very hard to support all these separations. That’s why in pet projects I and ex-Yandexers support a one-file-per-block structure

This is the main reason we end up with bloated code bases, full of legacy and unknown CSS that we daren't touch. We lack the confidence to be able to work with and modify existing styles because we fear the consequences of CSS' globally operating and leaky nature. Almost all problems with CSS at scale boil down to confidence (or lack thereof): People don't know what things do any more. People daren't make changes because they don't know how far reaching the effects will be.

Spotlight search has always been a handy tool in iOS, helping you find things very quickly on your iOS device: a friend’s phone number, directions to a restaurant, or that important email that is somewhere in your inbox

I'm invited to toggle the dropdown (which implies filtering) to Public. Do so. What does that mean in this context? Nothing.

If your timeline graph is dominated with the color green after recording

there does not seem to be a general rule for how many workers to spawn. Some developers claim that 8 is a good number, but use an online calculator and suit yourself

After some research, I found karma-ng-html2js-preprocessor, a npm package that does the above, all from the karma configuration

By compiling the element like we did in directive template testing, we can access the scope and start testing the publicly accessible methods right away.

First of all, you could simply register a controller on your module, and then use that as you normally would

Now, the problem is that the usual approach to controller testing is to instantiate the controller using $controller, but this fails since we do not have a named controller registered on our module

UPDATE 4/19/2015: The most current and detailed Angular Style Guide is the community-driven effort led by John Papa and Todd Motto, which you can find at https://github.com/johnpapa/angular-styleguide. Please use this instead of the one mentioned below.

While the example above is simple, it will not scale to large applications. Instead we recommend that you break your application to multiple modules like this:

The $scope that each Controller receives will have access to properties and methods defined by Controllers higher up the hierarchy.

The $digest loop keeps iterating until the model stabilizes

Dirty checking the scope for property changes is a common operation in Angular and for this reason the dirty checking function must be efficient. Care should be taken that the dirty checking function does not do any DOM access, as DOM access is orders of magnitude slower than property access on JavaScript object.

The debugger allows you to access the currently selected element in the console as $0 variable.

currency:c

In Angular, the only place where an application should access the DOM is within directives. This is important because artifacts that access the DOM are hard to test

progarm

the the

(Note: you need typescript nightly for this at the moment).

bar = <any>foo; // Okay!

When should I use an attribute versus an element? Use an element when you are creating a component that is in control of the template. The common case for this is when you are creating a Domain-Specific Language for parts of your template. Use an attribute when you are decorating an existing element with new functionality.

To create a mixin you use the @mixin directive and give it a name. We've named our mixin border-radius. We're also using the variable $radius inside the parentheses so we can pass in a radius of whatever we want. After you create your mixin, you can then use it as a CSS declaration starting with @include followed by the name of the mixin. When your CSS is generated it'll look like this

Our toy and demo apps currently group files functionally (all views together, all css together, etc...) rather than structurally (all elements of a view together, all common elements together, etc...) When used in a real larger scale app (e.g. Doubleclick For Advertisers), readability is improved by making the directory and app structure consistent with the architectural design of the app

Second, you will often not even want the data copied directly into your data objects until the data has been sent to the server (typically using a remove create or update service), and the server has responded that the data was accepted.

In my opinion the argument is based on a false premise. The premise that if a designer knows the HTML syntax then they can all of a sudden perform programming tasks, given an HTML-like templating system. While this is theoretically true, the premise mistakes syntax for semantics.

Therefore, when you try to use a declarative language to mimic imperative mechanisms it may work for simple cases, but as the cases get more advanced the code tend to become clumsy

While this allowed imperative control logic to be mixed with the declarative HTML, developers soon realized that mixing Java directly into the HTML resulted in really messy code when the HTML pages got more advanced. The syntaxes of Java and HTML just didn't complement each other very well.

If the value returned by the value function is different than the value it returned the last time it was called

The value function should return the value which is being watched. AngularJS can then check the value returned against the value the watch function returned the last time

The $event variable contains the original browser event object

The orderBy filter can also take a second $scope variable as parameter. In this example that variable is named reverse. The value of this variable determines if the data objects are to be sorted in their natural order, or the reverse order of that. In this case the reverse variable is set to true, meaning the data objects will be sorted in reverse order.

ng-switch Directive

Error: filter:notarray

You will also have to tell AngularJS what part of the directive's HTML template that is to contain the transcluded HTML

This processing is called "transclusion"

In case that HTML template grows big, it is gets hard to write and maintain the HTML inside a JavaScript string.

Both accessibility and performance are invisible aspects of an experience and should be considered even if they aren’t explicit goals of the project.

So to sum up: It should be an active design choice whether you want to enable users to change the font size independently to parts of or all layout and graphics. If so, pixels will probably not be your friend. If not, I’d say it’s mainly a matter of personal taste and/or project.

In version 7 of internet explorer that was released in October 2006 there was a very prominent zoom icon on the bottom right of the browser window. And guess what… The zoom function was just modifying the CSS reference pixel in the browsers CSS rendering engine!

This is not true nowadays. Pressing Ctrl+ and Ctrl- in any modern browser will scale the pixel values as well. It has been like this for a while now.

This will not render properly, unless we do some scope magic.

This will not render properly, unless we do some scope magic.

But ngRepeat has a dilemma. It needs to be able to clone new <li> elements for every action in user.actions. This initially seems trivial, but it becomes more complicated when you consider that user.actions might have items added to it later. This means that it needs to save a clean copy of the <li> element for cloning purposes. As new actions are inserted, the template <li> element needs to be cloned and inserted into ul. But cloning the <li> element is not enough. It also needs to compile the <li> so that its directives, like {{action.description}}, evaluate against the right scope. A naive approach to solving this problem would be to simply insert a copy of the <li> element and then compile it. The problem with this approach is that compiling on every <li> element that we clone would duplicate a lot of the work. Specifically, we'd be traversing <li> each time before cloning it to find the directives. This would cause the compilation process to be slower, in turn making applications less responsive when inserting new nodes. The solution is to break the compilation process into two phases: the compile phase where all of the directives are identified and sorted by priority, and a linking phase where any work which "links" a specific instance of the scope and the specific instance of an <li> is performed.

IcoMoon was also the first to solve a big problem with icon fonts: Compatibility with screen readers. By using the Private Use Area of Unicode, this problem was solved and almost every other icon font started to use the same encoding.

The configuration file itself can be treated as an extension if it contains a setup() function.

@private global variables and functions are only accessible to code in the same file.

The project also adheres closely to the Google Python Style Guide.

We use a combination of [JSHint](http://jshint.com) and [JSCS](http://jscs.info) for helping confirm code style conformance.

Generally, no semi-colons are used. This may change.

Please stick to strict, 80-column line limits except for small exceptions that would still be readable if they were truncated. Eliminate trailing whitespace wherever possible.

The full range of possibilities here is still in need of documentation and we would appreciate any help to improve that.

Copy your extension’s ID from the chrome://extensions page. Chrome generates this ID the first time you install the extension and will reuse it each time your rebuild or reinstall the extension

Add a node symlink. This is needed because the node binary from Ubuntu is called nodejs but many packages will try to run it as node:

Please consult the administration documentation for more information on accessing the admin dashboard.

Once installed, running nsqd in its default configuration should suffice for integration with h in a development environment

The h project uses ElasticSearch (v1.0 or later) as its principal data store for annotation data, and requires the ElasticSearch ICU Analysis plugin to be installed

Using the bookmarklet or otherwise embedding the application may not be possible on sites accessed via HTTPS due to browser policy restricting the inclusion of non-SSL content.

If you don’t have your h/node_modules/.bin directory on your PATH then you’ll get errors because the Node modules you’ve installed can’t be found (for example: Program file not found: uglifyjs). To add the Node modules to your PATH:

If you want to annotate a site that’s served over https then you’ll need to serve h over https as well, otherwise the browser will refuse to launch h and give a mixed-content warning.

Given an LSH familyH, the LSH scheme amplifiesthe gap between the high probabilityP1and the lowprobabilityP2by concatenating several functions

We used the following publicly available real datasets in the experiment

Implementation of the mix-blend-mode property is more complex than background-blend-mode so it is taking a bit more time, but don’t let that get you down. Blend modes will be here soon

This model states that showing more ads resultsin ads blindness, i.e., a decrease in users' propensity to clickon ads.

We discuss two examples where, byprioritizing user satisfaction as measured by ads blindnessor sightedness, we have changed the auction ranking func-tion [10] and drastically reduced the ad load on the mobileinterface. Reducing the mobile ad load strongly improvedthe user experience but was a substantially short-term rev-enue negative chang

If your head boiled from reading the above section, imagine what it was like to write it.

This approach is called change data capture, which I wrote about recently (and implemented on PostgreSQL). As long as you’re only writing to a single database (not doing dual writes), and getting the log of writes from the database (in the order in which they were committed to the DB), then this approach works just as well as making your writes to the log directly.

So instead we introduced the loading spinner on each widget. Nothing is actually any faster, but the whole experience feels more responsive

Simply reducing some CSS transition times from 500ms to 250ms, and cutting others out entirely, made the whole dashboard feel snappier and more responsive.

This means content is served from the nearest possible geographic location to the user, cutting down request latency from as high as 2500ms (in places such as Singapore) to tens of milliseconds

We eventually came up with a compromise solution based on Addy Osmani’s basket.js, using a combination of server-side script concatenation and localStorage for caching. In a nutshell, the page includes a lightweight loader script, which figures out which JS and CSS it has already cached and which needs to be fetched. The loader then requests all the resources it needs from the server in one request, and saves all the resources into localStorage under individual keys. This gives us a great compromise between cutting down the number of HTTP requests while still being able to maintain cacheability, and not re-downloading code unnecessarily when it hasn’t changed. Addtionally, after running a few benchmarks, we found that localStorage is (sometimes) actually faster than the native HTTP cache, especially on mobile browsers.

Stdlib support for a global Trace trait that everyone derives would be awesome.

This section defines three signature algorithms based on the RSA encryption process described in Sections 8 and 9. The intended use of the signature algorithms is in signing X.509/PEM certificates and certificate-revocation lists, PKCS #6 extended certificates, and other objects employing digital signatures such as X.401 message tokens. The algorithms are not intended for use in constructing digital signatures in PKCS #7. The first signature algorithm (informally, "MD2 with RSA") combines the MD2 message-digest algorithm with RSA, the second (informally, "MD4 with RSA") combines the MD4 message-digest algorithm with RSA, and the third (informally, "MD5 with RSA") combines the MD5 message-digest algorithm with RSA.

Accessing a Webpage

In Share extensions (on both platforms) and Action extensions (iOS only), you can give users access to web content by asking Safari to run a JavaScript file and return the results to the extension.

On both platforms, your custom JavaScript class can define a run() function that Safari invokes as soon as it loads the JavaScript file. In the run() function, Safari provides an argument named completionFunction, with which you can pass results to your app extension in the form of a key-value object. In iOS, you can also define a finalize() function that Safari invokes when your app extension calls completeRequestReturningItems:completion: at the end of its task. A finalize() function can use items your extension passes in completeRequestReturningItems:completion: to change the webpage as desired.

Create a JavaScript file that includes a global object named ExtensionPreprocessingJS. Assign a new instance of your custom JavaScript class to this object.

Quick recap — what authors should do now

But if a URL link is for a quotation the problem disappears. Readers follow the link to the top of the sources, copy a few words of the quoted passage into the Control+F search box, and go directly to the passage cited.

However, if an open access version of a text is available, this must always be treated as the primary text. Here the commercial version of the text becomes the secondary version and it should always be cited second and in a manner that makes this completely clear. For instance, after the primary reference to the full text, you could write: ‘Also available as: ….’

Using URL referencing of the kind I employ in this blog, or other innovative methods, readers should be able to go directly (in a single click and in real time) to the specific part of the full text of source that is being cited

@interfaceFunction is interface (no new)

To do that I just typed “label:techgroup -is:starred” without quotes in the search bar and clicked on Search. It displayed all the emails from that label which isn’t starred.

Writing a program is an error-prone exercise in translation. Even math, from which our programming languages are born, has to be translated into something like this:

Many of the Forerunner models have the ability to easily delete anything older than 30 days (Menu > History > Run > Delete > Keep 30 days > ok) For the Forerunner 110/210, Garmin says do this:Press and hold page/menu button until menu appears Select OK on History Press up or down button to locate activity to be deleted Press start/stop and lap/reset simultaneously Release on buttons once Delete Activity message appears Press OK on Yes A message Delete all activities? will appear* If wanting to delete all activities, select Yes

Angular 2 embraces web platform standards, so it puts the view of the component in the Shadow DOM of the element where it has been created. If your browser does not support Shadow Dom, Angular will emulate it on a par with native shadow DOM.

When we first set out to identify malicious extensionsour expectation was to find banking trojans and pass-word stealers that duplicated the strategies pioneered byZeus and SpyEye. In practice, the abusive extensionecosystem is drastically different from malicious bina-ries. Monetization hinges on direct or indirect relation-ships with syndicated search partners and ad injection af-filiate programs, some of which earn millions of dollarsfrom infected users [37]. Miscreants derive wealth fromtrafficanduser targetingrather than the computing re-sources or privileged access mediated via the browser. Itmay simply be that the authors of malicious binaries havelittle incentive (or external pressure) to change, leavingextensions to a distinct set of actors. This uncertainty isa strong motivation for exploring the extension ecosys-tem further.

Link to a webpage listing your publications (eg your professional/university profile, ResearcherId, Google Scholar, Research Gate…

RCTActionSheetManager.h

Setting the tabindex of the focused element to "0" ensures that if the user tabs away from the widget and then returns, the selected item within the group retains focus. Note that updating the tabindex to "0" requires also updating the previously selected item to tabindex="-1". This technique involves programmatically moving focus in response to key events and updating the tabindex to reflect the currently focused item. To do this:

If you start a program in the foreground (with no ampersand), you can suspend that program’s execution and return to the xonsh prompt by pressing Control-Z. This will give control of the terminal back to xonsh, and will keep the program paused in the background.

I have had an annoying problem with git and vi. I like to use vim to edit my commit messages, but I’ve been hit with this annoying message every time I write the message and quit vim.

At various times, such as when a tab is added, Safari will ask you to validate the command. If there is any possibility that the command could be invalid, you should add a listener function for the "validate" event.

Firefox 42: Release and Beta versions of Firefox will not allow unsigned extensions to be installed, with no override.

Only Safari Extensions installed from the Safari Extensions Gallery can be updated automatically. Add the following two lines to each extension's dictionary entry within your Update Manifest to allow existing users to update automatically to the latest version.

We’ve seen some annoying bugs as a result of events being fired twice, or in a circular event chain.

For example, we currently have two components, search and compose, which use Twitter’s typeahead search. Our typeahead data module sends out events like this:

Event namesI’m not sure we’ve got our event-naming nailed as yet. In fact, our naming conventions seem to be widely disagreed upon within our small team. Despite that, we seem to be managing pretty well.

let’s implement the logClass decorator..

function log(constructor: any) {
    let wrappedConstructor = (...args: any[]) => {
        console.log('creating a new ' + constructor.name, 'with args', JSON.stringify(args));
        let instance: any = Object.create(constructor.prototype);
        constructor.apply(instance, args);
        return instance;
    };
    wrappedConstructor.prototype = constructor.prototype;
    return wrappedConstructor as any;
}

Each of our partners will engage in specific trials. AGU will investigate post-publication peer review in the new open access journal, Earth’s Future. ArXiv will permit selected groups of readers to make and view annotations on arXiv articles, or the formally published versions of the same articles, and support new authentication mechanisms, potentially involving ORCID, that would permit overlay journals to integrate select conversations on arXiv. eLife will implement annotation supporting pre-publication peer-review. This will be incorporated into a new and more flexible revision system that will be created to streamline the editorial review process.

To read opinions about a web page

Pre-installed on browsers

Firefox procedure is a little bit more complex as you need to use the SDK including cfx which can wrap your extension into an .xpi file.

I hope I can help you realize its ambitions

personal projects

C++

London React

TypeScript

learning much about usability in the process

TypeScript

offline sync functionality

The line breaking algorithm can also be used to correct the line breaks made by the browser. The easiest way to do is to split a text up into lines and adjust the CSS word-spacing property. Unfortunately, Webkit based browsers do not support sub-pixel word-spacing. Alternatively, we can absolute position each word or split the line into segmants with integer word spacing. You can see the latter approach in action on the Flatland line breaking example.

Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP) , pages 1654–1664, October 25-29, 2014, Doha, Qatar. c 2014 Association for Computational Linguistics Refining Word Segmentation Using a Manually Aligned Corpus for Statistical Machine Translation