Programmatic cut and copy to the clipboard It’s now possible to programmatically copy and cut text in response to a user gesture with document.execCommand('copy') and document.execCommand('cut'). Having this ability may eliminate some websites’ last need for the Flash plug-in.
We'll be able to make use of this for direct linking
Very useful brief explanation of the basics of matrix/vector math that is relevant to 3D graphics and explanation of the process of transforming model vertexes into rendered pixel positions on screen.
This is used in the Elm language for the implementation of the Array module.
define and document the interfaces between them
Agreed. Your point here is about the fact that we should document them, not how, but I have some proposals around tools that would help us with this - on the front-end at least.
1. The Hypothesis client library (hypothesis.js)
I would consider the sidebar an application rather than a library - since it is something that is fully usable by an end-user on its own.
Making the client a distinct entity from the web service is an important first step, but given the goals outlined above, I think this is still quite monolithic and we already have use cases (eg. EPUB) which will require dividing this into smaller pieces, with public APIs connecting them. This doesn't have to happen all at once, but we'll need to have it in mind. I think the initial division might look something like this:
h/static/scripts/annotator. This would expose a public API that clients could use in order to display those annotations in a viewer (like our sidebar), attach information about the parent document, persist annotations to/from storage. This raises the question of whether we should use Annotator (2.x?)'s APIs as the public API or whether we should define our own and have Annotator be an implementation detail.I would envision that (1) and (3) would have minimal external dependencies, so that they could be integrated into a variety of environments.
it's about building a platform that will outlast Hypothesis the organisation.
Providing a platform that other people can run is an important part of building something that can outlast the organization, but a big factor is providing a tool and service that proves the potential value of such a layer over the web.
There are a few aspects to this which I think are relevant to the architecture of H:
Enabling Integrations
I think a lot of the potential value of H and annotation tools in general depends on making it convenient to integrate it with other services and web content. Areas of integration include:
(2) and (3) are relevant in terms of how we partition the client into libraries and what public APIs we expose.
Enabling us to provide services on top of the data
When talking about separating the client and web service, I think there has been the implicit assumption that the architecture would be like this:
Hypothesis WS <==> Client <==> Third party identity/annotation providers
Whilst I we will clearly need to support that model, I think we could also satisfy many needs with a model where the client communicates only (or primarily) with our service, and our service then communicates with third parties:
Client <==> Hypothesis Web Service <==> 3rd party providers
The primary advantages of this approach, from my perspective, is more control over the quality and consistency of user experience and the ability to provide services around that third-party data.
It is far too early to be talking about creating new projects and git repositories for most of the components described above.
My instinct at the moment is that I would rather we didn't create a bunch of new projects and Git repositories. I completely agree that we want to restructure the source tree so that it mirrors the overall architecture. However, I think having a single repository (or a very small number) has advantages in terms of reducing the total volume of project config boilerplate, making developers feel freer to engage with any part of the codebase, keeping track of issues and PRs and supporting open source contributions etc.
This library is semantically versioned and released independently, and is deployed as built assets to a CDN.
We could deploy this via npm to make it convenient for 3rd-party consumers. If we split the application as I suggested above then each of the parts with a public API would be its own npm package.
We could potentially leverage cdnjs as the CDN if we did this, although we could obviously quite easily host it ourselves as well.
In particular, we are pursuing two goals which can at times be in direct tension
They can also be mutually very supportive.
In particular, having a clear architecture with well-defined interfaces between the components is something that will help us regardless of what other people do with it.
<!-- flex item: anonymous block box around inline content --> anonymous item 3
In this case, text nodes inside a flex element will automatically be wrapped in a block box, so:
<div style="display:flex">Some text</div>
Is the same as writing
<div style="display:flex"><div>Some text</div></div>
The DROP COLUMN form does not physically remove the column, but simply makes it invisible to SQL operations. Subsequent insert and update operations in the table will store a null value for the column. Thus, dropping a column is quick but it will not immediately reduce the on-disk size of your table, as the space occupied by the dropped column is not reclaimed. The space will be reclaimed over time as existing rows are updated. (These statements do not apply when dropping the system oid column; that is done with an immediate rewrite.)
Very interesting article on how to best utilize capacity for concentration as a programmer.
Overall, there's a strong correlation between job satisfaction and pushing code into production. 65% of developers who never check in code are satisfied at their jobs vs. 77% satisfaction rate among developers who commit code multiple times per day. Developers want to code! (Or maybe happy developers just commit more than everyone else.)
Alexandrian pattern
Apparently also known as an Alexandrian form, this is a format for documenting design patterns in software
Therefore we've built https://github.com/salsita/redux-side-effects which is at least "somehow" trying to simulate the Continuations with Effect handlers approach. The idea is very simple, if reducer was generator then you could simply yield side effects and return mutated app state. So the only condition is to turn all your reducers into function* and use yield* whenever you want to compose them.
This also looks like an interesting and potentially relatively simple take on supporting effects in reducers.
Very interesting thread with a discussion on how to improve handling of effects in Redux and make Redux applications composable ala. the Elm Architecture.
Redux Loop looks like a very interesting take on supporting the Elm arch with the current version of Redux
This is a great article on the principles of a rich text editor in a DOM-like environment.
Good but opinionated article on topics for for interviewing UX engineers. Relatively narrow focus however.
In general, it is important to recognize that any big team will have multiple roles. And HTML templates are more inclusive of real-world workflow that includes designers, testers, and others who aren't deeply familiar with JavaScript, but who can interact with HTML templates directly or through tools.
The question here is whether designers do actually edit Angular component templates or not, or whether something like JSX would actually be a problem for them. I don't have enough experience in such environments to answer this.
The basic argument here is that templates have an advantage because they are constrained compared to allowing component structure to be defined in arbitrary JS is valid.
Summary slide at the end:
This is a useful introduction through recent developments in client-side data management and an overview of the different choices available when building a new application and guidance on what is appropriate for different sizes of app.
generate(ast, null, code);
The code argument here is used for sourcemaps. Each node in the AST has source location information, which is retained as the AST is transformed. This information is then used to generate a sourcemap.
Example of a large open source project using:
<script async src="//genius.codes"></script>
I didn't know .codes existed as a TLD. Very cool Genius devs :)
Let’s instead choose numbers because they fit, because they look good, and because they serve the meaning of the design.
In some ways it’s different from how we already work, but it feels more natural. Going from content out, rather than canvas in, to paraphrase Mark Boulton, is a more web native way of designing
In summary, teams which are "fairer", in two senses, tend to be more effective:
The first parkrun took place in 2004. Paul Sinton-Hewitt, 55, an IT worker who ran for South London Harriers athletics club, decided to set up a different kind of event after tripping and falling during a run while representing his club
Most recently he is a member of Ranelagh Harriers, posting some very impressive times in a mob match against SLH: http://www.southlondonharriers.org/results-archive/results-archive.html?view=result&id=579&tmpl=component
Useful deep-dive into ES2015 arrow functions, with actual references to the specs.
A useful (2015) recent comparison of different JavaScript linting tools.
The TL;DR is that the recommendation is to use ESLint as it is widely used, supports ES6 well and provides a decent combination of configurability and presets.
This is a good short overview of how change detection works in Angular 2.
It fixes the fundamental algorithmic complexity problem that change detection has in Angular 1.x by making it possible to prune parts of the component tree from change detection if the inputs have not changed.
Unfortunately the zone.js implementation involves some horrifying monkey-patching of various DOM APIs.
This is a perfect use-case for @extend. These rulesets are inherently related; their shared traits are shared for a reason, not coincidentally. Further, we aren’t transplanting their selectors hundreds of lines away from their source, so our Specificity Graph stays nice and sane
So a sensible policy might be to use @extend only for related classes in the same source file, where source order is obvious.
Some useful notes on the pros and cons of @extend vs mixins in SCSS.
In a nutshell, he suggests avoiding @extend entirely.
My main bugbear is that it prevents local reasoning about the final set of rules that will apply for an element with a given class.
We’ve learned so far that bindings create a bigger $digest cycle, and it’d be a great idea for directives we create to potentially be statically rendered components that aren’t tied into Angular unless really needed.
This is the critical performance problem with Angular. $interpolate looks interesting.
ES6 performance sucks! Strong mode is a mode for ES6, you cannot use it without using various ES6 features. However, idiomatic ES6 code currently is substantially slower than ES5, across all browsers -- easily by 2x, often by 10x or more. Due to the sheer size of ES6, plus a number of unfortunate design choices, it will likely take years until implementations catch up with ES5 optimisations, and the hundreds of man years that went into those. Until then, strong mode is not going to be an attractive target
Oh dear, "unfortunate design choices" sound ominous.
I'm not sure I like the requirement to use classes but some interesting notes on dependency injection for JS
n the Webpack approach, each Sass file is compiled in isolation. This isn't a new idea, but I think it's a much better way of doing Sass. It just means you need to @import dependencies like variables & mixins wherever you use them
Which is a much better thing to be doing anyway in terms of having clear and explicit dependencies.
but also it is extremely easy to transition from browserify to webpack when needed.
If however, you’re predominantly dependent on the NPM ecosystem and you want a tool with a small and very well designed API and takes minimal configuration, you should go for Browserify
We don't particularly need Node compatibility at the moment, but "small and well designed API" is appealing.
On the other hand, not having to hunt around and collect all the tools together for packaging code for the browser is also appealing.
This is probably the best high level comparison of the approach of Webpack and Browserify that I've seen.
When not setting an explicit domain for a cookie, the default in most browsers is to only send the cookie when the domain matches exactly. However, Internet Explorer violates the RFC, and will send it to all subdomains as well.
Test annotation created on sandbox.wikidot.com
Any browser extensibility is a potential vector for malicious software, and our extensions will be vetted, delivered, and managed through the Windows Store
No details here on whether automated publishing of extensions will be possible using APIs
“Search is the cornerstone of Google,” Corrado said. “Machine learning isn’t just a magic syrup that you pour onto a problem and it makes it better. It took a lot of thought and care in order to build something that we really thought was worth doing.”
API-wise, one issue with React (or JSX) is that the render function often involves a lot of logic, and ends up looking more like a piece of program (which in fact it is) rather than a visual representation of the interface. For some developers this is a bonus, but for designer/developer hybrids like me, having a template makes it much easier to think visually about the design and CSS. JSX mixed with JavaScript logic breaks that visual model I need to map the code to the design. In contrast, Vue.js pays the cost of a lightweight data-binding DSL so that we have a visually scannable template and with logic encapsulated into directives and filters.
I wonder whether JSX has proven problematic in practice for "designer/developer hybrids"?
Good explanation of why flexbox is not always the answer.
The flip side of this is that I’m always being painfully aware that React Hot Loader is a great hack. It’s not how hot reloading should work
The greatest advantage Webpack has over these tools is Hot Module Replacement (HMR). In short, it provides a way to patch the browser state without a full refresh. We'll discuss it in more detail when we go through the React setup
match_main(text, pattern, loc) => location Given a text to search, a pattern to search for and an expected location in the text near which to find the pattern, return the location which matches closest. The function will search for the best match based on both the number of character errors between the pattern and the potential match, as well as the distance between the expected location and the potential match.
This is the core function currently used by the dom-anchor-text-quote library to handle fuzzy anchoring of annotations.
Usually you end up evolving both in parallel. However, I find it quite helpful to have an initial idea of what the state tree should look like in different situations before I start coding.
All kinds of frameworks and architectures have state. In Ember apps and Backbone apps, state is in Models. In Angular apps, state is often in Factories and Services. In most Flux implementations, it is in Stores. How does Redux differ from these?
Useful explanation of how state storage in Redux differs from other frameworks.
Useful tutorial that covers combined usage on the client and server.
This might be useful for achieving consistency after automated translation of CoffeeScript to ES6
Learn the actual underlying technologies, before learning abstractions. Don't learn jQuery, learn the DOM. Don't learn SASS, learn CSS. Don't learn HAML, learn HTML. Don't learn CoffeeScript, learn JavaScript. Don't learn Handlebars, learn JavaScript ES6 templates.
Very true and a useful way to evaluate potential developers.
Some docs on a prototype Hot Reloader for Angular. It relies on new component instances being able to pull data from singleton services, unlike the Redux solution where the store is passed down via context and most components just get the data via props.
Note that this is functionally equivalent to using the HTML5 doctype.
In other words, if you use the preferred <!DOCTYPE html>, you don't need the 'X-UA-Compatible' meta-tag.
Suddenly the cry "The Trial's beginning!" was heard in the distance, and Alice ran along with the others.
A note on Alice in Wonderland
ink it so very much out of the way to hear the Rabbit say to itself, "Oh dear! Oh dear! I shall be too late!" But when the Rabbit actually took a watch out of its waistcoat-pocket and looke
Foo bar
And so it was indeed! She was now only ten inches high, and her face brightened up at the thought that she was now the right size for going through the little door into that lovely garden.
This
Now, as far as I know, this use of the UUID does not cause any major issues with the retailers, and will not lead to your EPUB being rejected. But it does not make sense to identify an EPUB with an ID that is not the ISBN. Future-proofing your content is one of the most important steps you can take as a production specialist.
A summary of best practices for unique identifiers for epubs
Shallow rendering currently throws an error if setState is called. React seems to expect that, if you use setState, the DOM is available. To work around the issue, we use jsdom so React doesn’t throw the exception when the DOM isn’t available. Here’s how to set it up:
The issue may be fixed upstream in React > 0.14.6, there is also a simpler alternative on that thread which doesn't require setting up a pseudo-DOM environment for tests.
Quite a useful article summarizing the state of React and Angular 2 and to be fair, it does make criticisms of both sides.
Composing components in a single compile-time checked file is one of the big reasons JSX is so special.
Not to mention that TypeScript can perform static type checking of JSX with nice IDE integration.
Very useful article on why JSX is better than yet-another-templating-language
You can call store.dispatch(action) from anywhere in your app, including components and XHR callbacks, or even at scheduled intervals.
For an example of dispatch at regular intervals, the SoundRedux media player app dispatches an action every time the play time of the current song, measured in seconds, changes.
Now todoApp just gives it the slice of the state to manage, and todos knows how to update just that slice.
This is great for the simple case where there is no interdependent state. For ideas on what to do when one part of the state tree depends on another, see http://stackoverflow.com/questions/34782948/how-can-i-model-interdependent-data-with-cascading-updates-in-redux/34796163#34796163
If you find yourself often writing such operations, it’s a good idea to use a helper like react-addons-update, updeep, or even a library like Immutable that has native support for deep updates.
Note that the "updeep" library has a dependency on lodash.
More background reading on CIF annotations in EPUB and iBooks.
This is a good resource explaining the how EPUB CFIs are structured.
EPUB CFIs are also a key part of the answer for how to share bookmarks, highlights, annotations and other reader-definable features between reading systems and between readers. By standardizing the referencing mechanism, it ensures that any reading system will be able to correctly dereference the location referenced by these CFIs, avoiding proprietary solutions to the same problem. (But, for true interop, a standard means of structuring the information for sharing is still necessary.)
This is a good argument for why Hypothesis should use CFIs for anchoring in epubs
Substrings in brackets are extensible assertions that improve the robustness of traversing paths and migrating them from one revision of the document to another. These assertions preserve additional information about traversed elements of the document, which makes it possible to recover intended location even after some modifications are made to the EPUB Publication
Our current integration with Hypothesis is nearly two years old now and the interface needs rethinking and updating. Sliding panels coming in from both side aren’t ideal and obscure content. The design too closely mimics a printed book and as a result the paginated rendering hinders being able to make annotations across pages. A scrolling view would allow navigating the book and using the Hypothes.is toolbar at the same time. We’re going to create a new example reader with the controls, navigation and Hypothes.is integrated together with scrolling text.
Are there any mockups of this available?
When you associate a controller with a directive, an instance of the controller gets stored in the data store of the element. The naming convention for the key value is '$' + name of directive + 'Controller'
@seanh - See this section and the 'element.data' part below in the code example
ES6 modules are supposed to be statically analyzable (runtime cannot change the exports/imports) so it can’t be dynamic
Useful set of benchmarks based on the DBMonster demo for a set of different frameworks - looking at various axes such as GC collection, layout and paint times.
There are some notable caveats in the comments though that the subjective feel was not always reflected in the metrics, suggesting that the authors believe they have not found the optimal set of metrics that reflect user-perceived performance.
Very useful overview of the conceptual differences between several modern UI architectures
Hierarchical composition happens only among React components, not with Stores neither with Actions.
Some of the answers for Android app permissions might have relevance to Chrome extensions.
In my experience, the best way to lift weights for runners is to use a heavy weight that is enough to push your limits after 5 repetitions
Agrees with the advice at http://victorsrunningblog.com/2014/04/15/why-distance-runners-should-lift-heavy/ which also has more references and a better explanation.
Recommends "deepFreeze" lib to protect against unexpected mutations to objects and arrays.
This is an interesting opinion piece on the difficulties that newcomers have with the React ecosystem and the problems with the lack of a central guidelines about which pieces to use and how to tie them altogether.
I don't think it applies to just React though - choices around testing frameworks, build tools, languages etc. apply regardless of which framework you are using.
We shouldn't be expected to get things right the first time, but we need a platform that lets us get it wrong first, and then iterate towards perfection.
I highly recommend giving it a read.
Ditto, this is a very well constructed argument in favor of small modules.
Unfortunately however, the current tendency to couple project infrastructure structure (Git repository, issue tracker etc.) to npm project structure doesn't suit this well.
Regarding tight coupling with require, this is a limitation of the framework. I believe Angular 2 is more flexible with interdirective communication from the little I have seen of it.
Need to read up on this
This effectively means that these directives cannot be used outside of annotated-image because Angular will throw an error when it cannot locate the required controller.
In other words, the child components are no longer re-usable and this breaks composability.
The basic principle is that you patch where an object is looked up, which is not necessarily the same place as where it is defined. A couple of examples will help to clarify this.
This caught me out, as it did for a lot of other people apparently, see also this useful post about Python Mock gotchas: http://alexmarandon.com/articles/python_mock_gotchas/
UPDATE: This post has seen a significant change from the first version of the code. It now relies on a much simpler method: a hidden object element that relays its resize event to your listeners.
Unfortunately this involves creating a new Window object for any object whose size we might want to monitor. That sounds expensive to me.
See also: http://stackoverflow.com/questions/3444719/how-to-know-when-an-dom-element-moves-or-is-resized
multiElement
See http://www.michaelbromley.co.uk/blog/260/writing-multi-element-directives-in-angularjs for a guide on how to use this
Useful hints on isolating the environment for templates in Jinja2
A relative reference beginning with a single slash character is termed an absolute-path reference, as defined by <abs_path> in Section 3.
House - Judiciary
Testing an issue reported at https://github.com/hypothesis/h/issues/2768
It is important to note that the path attribute does not protect against unauthorized reading of the cookie from a different path. It can be easily bypassed using the DOM, for example by creating a hidden iframe element with the path of the cookie, then accessing this iframe's contentDocument.cookie property. The only way to protect the cookie is by using a different domain or subdomain, due to the same origin policy.
Useful explanation of the different ways of sharing persistent data between a Docker host and containers.
This will make the directory /data inside the container live outside the Union File System and directly accessible on the host. Any files that the image held inside the /data directory will be copied into the volume. We can find out where the volume lives on the host by using the docker inspect command on the host (open a new terminal and leave the previous container running if you’re following along):
In Docker 1.9 the field name is Mounts rather than Volumes
and a related URL fragment specification will leverage the FindText API to let you share a URL that navigates directly to the selection you shared
Does anyone have a link to said specification?
Firefox and Chrome exhibit different behaviors when trying to style elements that appear inside a <use> block. In Firefox 45, a .use-element-class .sub-element-class selector will style the element as expected. In Chrome it won't because this is trying to cross a DOM boundary (that is, the SVG content and the <use> element are in different DOMs). This article has useful background to this and approaches to use.
Here’s an example with a component directive that uses bindToController. Instead of defining the scope properties on scope, we declaratively define what properties are bound to the component’s controller:
Example of idiomatic integration of controllers into directives in Angular 1.4.x+
The DOM element that is currently being annotated.
ie. The element on which Annotator was originally loaded.
Recruiters are not welcome.
In other words, the sponsor of the event gets exclusive access to the engineers for recruitment purposes.
This extension passes the AMO validator with no signing warnings, meaning it would be automatically signed for distribution. #1 required no modifications to pass validation. #2 and #3 required some l33t hacking in the form of Components.interfaces["nsI" + "p".toUpperCase() + "rocess"] and window['e'.replace() + 'val'](req.responseText) — variations on basic string concatentation.
Good lord Mozilla, this is not how you do security.
This is pretty bad since it looks like you support accessors but you really do not. I hope you are not shipping anything with this any time soon.
Yes, they did ship this in Safari 9 :(
Won't this be fixed now under Bug 49739?
"WebIDL attributes should be implemented as getters and setters on the prototype chain " - As of 24/11/15, assigned but not yet implemented.
Trying to override the getter on the prototype of an element is somewhat pointless as WebKit does not use getters for DOM properties. Technically we could make it do so, but that basically means throwing away performance for no good reason. Comment 2 T. Brains 2010-03-21 14:23:58 PDT That means there's absolutely no way to override or extend the default get or set behavior of any of the built-in DOM properties, which is very limiting, and like I mentioned contradicts the behavior of other browsers.
When this was written, overriding getters for native DOM properties was not possible.
Some useful notes on capturing JavaScript errors during page load with Selenium
In those cases, the best way to get an invariant is to start writing what Steve McConnell calls“smoke tests” against the rest of the system
The free plan of ngrok allows only a single concurrent tunnel to be opened. Even though BroswerStack and Sauce Labs provide their own tunneling solution, we decided to go with ngrok, in order to provide a more generic solution. We happily upgraded to the $25/month business account following our excellent experience with the free account.
Visual regression testing tool that may be worth investigating.
Useful background on ElasticSearch's Percolator functionality. Includes some useful notes on the implementation and factors such as performance impact and memory usage.
Join Darin Fisher, VP of Chrome as he talks the past, present and future of the web.
RAIL - Reaction (<100ms), Animation (<16ms), Idle (<50ms), Load (<1000ms)
Given we put the system in a known state before the user (or external system) starts interacting with the system (in the When steps). Avoid talking about user interaction in givens. When we take key actions the user (or external system) performs. This is the interaction with your system which should (or perhaps should not) cause some state to change. Then we observe outcomes.
This problem is precisely the kind of problem that FSMs are very good at resolving. If you can enumerate the states, and events, then you know the number of paths though the system. So if Given/When/Then statements are truly nothing more than state transitios, all we need to do is enumerate the number of GIVENs and the number of WHENs. The number of scenarios will simply be the product of the two.
Main observation here is that BDD is essentially a syntax for specifying states and transitions in a state machine. If all possible states and events can be enumerated, you can quantify what proportion of paths through the system have been tested
Presentation summarizing an approach to duplicate web page detection that was developed by a researcher whilst at Google in the early 2000s
Compute fingerprint
Which algorithm does 'fingerprint' refer to?
Adding in push notifications with Parse made a big improvement in re-engagement and keeping people coming back at the right time.
Interesting React Native testimonial for a running 'showcase' app.
Most apps had detailed stats to help improve performance. However, to a friend who is not a runner, that info is much less exciting. They would probably much rather see that it was equal to 5 donuts, and give you a thumbs up.
When starting on a new design, I like to list the objectives. Picking the right goals is often more important and harder than making things look good
On October 14, 2003, the Swiss newspaper Tages-Anzeiger published a few articles presenting as a scandal the fact that the Degussa company was involved in the construction of the memorial producing the anti-graffiti substance Protectosil used to cover the stelae, because the company had been involved in various ways in the National-Socialist persecution of the Jews. A subsidiary company of Degussa, Degesch, had even produced the Zyklon B gas used to poison people in the gas chambers.
Dramatic statistics about the negative impact of hiding key navigation options out of the main view in mobile apps.
The onboarding flow can be designed in many other ways that might be more useful to your users. Slack, for instance, uses the first screen to create some context. They simply introduce themselves, focusing on benefits instead of screens and features.
That’s why now all the big players are shifting from hamburger menus towards making the most relevant navigation options always visible.
Interesting example of YouTube switching away from the hamburger menu.
use Hypothesis
Hello MozFest 2015!
If you have any feedback, feel free to add comments here.
You can create a Hypothesis account for yourself, or use one shared for this presentation:
username: mozfest2015
password: mozfest
You’ll now have three Docker containers
On Ubuntu the steps below will work fine because Docker runs the containers on the same IP as the host. On OS X however the containers will run in a VM with a different IP address. The H default configuration expects to find the services on localhost, so make dev fails.
Mailboxes
See https://gist.github.com/mgold/461dbf37d4d34767e5da for a good tutorial on what mailboxes are, why they exist and how to use them
So in both cases we are writing contracts that say “I require input with this shape, and I will give you output with that shape.” This is the essence of ruling out runtime errors in Elm. We always know what kind of values a function needs and what kind it produces, so we can just check that we always follow these rules.
These are the questions asked to the Monday evening panel on future directions for the web platform.
ServiceWorker also enables you to send Push Notifications, just like mobile apps do, and even when the website is running in the background;
Installing the services¶
The current version of these steps will run all of the services under Docker.
If you are on Linux, the services will be available on localhost:<port number>.
If you are on Mac however, the services will usually be available on the IP of the virtual machine which is running the docker containers. If using docker-machine which is the recommended tool, then the IP is given by docker-machine ip default.
If the host is not localhost, you'll need to set environment variables to override the default ports/hosts for services which are defined in conf/development.ini.
eg. Create a file that defines environment variables. Assuming the host of your Docker VM was called "docker" (replace with the actual hostname or IP):
export DATABASE_URL='postgresql://postgres@docker/postgres'
export TEST_DATABASE_URL='postgresql://postgres@docker/h_test'
export ELASTICSEARCH_PORT=
export ELASTICSEARCH_PORT_9200_TCP_ADDR=docker
export ELASTICSEARCH_PORT_9200_TCP_PORT=9200
export NSQD_PORT=
export NSQD_PORT_4150_TCP_ADDR=docker
export NSQD_PORT_4150_TCP_PORT=4150
export NSQD_PORT_4151_TCP_ADDR=docker
export NSQD_PORT_4151_TCP_PORT=4151
export REDIS_PORT=
export REDIS_PORT_6379_TCP_ADDR=docker
export REDIS_PORT_6379_TCP_PORT=6379
And source it with source <filename>
Python dependencies
During this step I ran into the following error under OS X at the very end of dependency installation:
gevent is in an unsupported or invalid wheel
See http://stackoverflow.com/questions/33009545/gevent-is-in-an-unsupported-or-invalid-wheel for a solution
In short, the fix was:
setup.py to loosen the requirement for gevent to `gevent>=1.0.2pip install gevent=1.1b6 where 1.1b6 is the current beta at the time of writing.Once the final 1.1 build is released we should bump the dependency.
Install the following packages:
I think we need to add postgres to this list as well. See https://hypothes.is/a/m4v7zbm1RIiFDxqL594MHw
brew install postgres
PostgreSQL
Later on when installing the python dependencies required to run the H backend, the pg_config executable will be required.
Although you can install postgres via Docker, it appears that the postgres dev tools still need to be installed on the host machine as well.
On OS X this can be done via brew install postgres
Install h’s Python dependencies into the virtual environment, and its Node dependencies into the h/node_modules directory
This has been obsoleted now by making this step happen as part of make dev (see the section below on "Running h")
Download and run the official NSQ image, the official PostgreSQL image, and our custom Elasticsearch with ICU image
On the command line this can be done with:
docker pull nsqio/nsq
docker pull postgres
docker pull nickstenning/elasticsearch-icu
The best explanation I was able to get from them for why they did this was, ``it looked ugly and I didn't understand why it was there.''
First rate commit message material
Useful guide to adding a central logging point for all events in an Angular app that are broadcast via $rootScope
When using $rootScope.$on, we need to unbind those listeners each time the $scope is destroyed. $scope.$on listeners are automatically unbound, but we’ll need to call the above closure manually on the $destroy event:
See also this StackOverflow post: http://stackoverflow.com/questions/24830679/why-do-we-use-rootscope-broadcast-in-angularjs
Some interesting notes on combining Angular 1.x with immutable data structures for better performance.
It’s known that Angular becomes slower with around 2,000 bindings due to the process behind dirty-checking. The less we can add to this limit the better, as bindings can add up without us really noticing it!
From some preliminary testing it looks like we get close to hitting the 2000 watch count on the /stream view - which explains the lag.
Do you have a question or comment that involves "security" and "hashids" in the same sentence? Don't use Hashids. Here are some ways to decode:
The temporary solution we found is to wrap chrome.* api callback with setTimeout() function. In that case errors thrown within chrome.* api call are passed to window.onerror with correct line number. Example:
Wrapping all the chrome.* async API calls such that exceptions in the callback result in an error being logged to a handler that we control looks like the way to go.
In Chrome extensions, errors thrown in callbacks for async APIs do not trigger the global window.onerror handler.
and a slightly less optional name
"slightly less optional"? Is that the same as required?
Replace a two-way '=' binding on the directive configuration with an expression binding '&'
Note the caveats in the comments section at the bottom. '=' is not only a two-way binding but it also handles automatic updates when the input changes. In the absence of React-style 're-render the whole component' when a model value changes, this is needed.
Smart components are connected to services. Though they may have inputs and outputs, they mostly know how to load their own data, and how to persist changes when they occur
Useful categorization of 'smart' and 'dumb' in the context of Angular
We can refactor this component by, first of all, changing its signature so that it gives out the new version of the object when the user is done, instead of just mutating the input object in place:
The section on refactoring components that rely on two-way binding to update the model is useful
Introduce a binding (=binding) for this external reference, and put it in the bindToController section of the component directive.
Needs Angular >= 1.3
I think this can pretty much be our Angular style guide.
minimized JavaScript sourcecode will destroy the grouping in really bad ways. Because of this you should ensure Sentry can access your Source Maps.
Here’s what the team says about preparing code for less migration effort when we get Angular 2.0, which is luckily in-line with the guesses that several others came up with so far.
Some useful notes about writing Angular components in a forwards-compatible way.
Some reading I came across whilst looking into error reporting for AngularJS expressions
In version 1.4, bindToController gets even more powerful. When having an isolated scope with properties to be bound to a controller, we always define those properties on the scope definition and bindToController is set to true. In 1.4 however, we can move all our property binding definitions to bindToController and make it an object literal.
This starts to look a lot like propTypes, except without runtime type checking.
Changes to isolated scope properties from the outside world are not reflected back to the controllers’ this object.
Notable caveat with using controllerAs in Angular 1.2.x
In fact, we don’t even need to request $scope in our controller anymore, since the scope is bound the controller’s this reference when using controllerAs.
So in the context of a directive, when a property is specified on scope in the directive's definition object, it will be available in expressions in the template via vm.<property>, assuming vm is the name assigned to the controller via controllerAs
Intro to the controller as syntax in Angular 1.2.x - main benefit highlighted here is making it more explicit which controller an expression in a template is referring to when directives are nested.
JSX is Not an HTML Template LanguageThough it looks like it, JSX isn’t a template in the sense that Handlebars and EJS are templates. It’s not a simple token replace and `.innerHTML= foo` dump like so many other tools.
This is a great explanation of why JSX is not a templating engine, which it is often mistaken for.
The current version is None. Mock is stable and widely used.
Err.. whoops
Links to a ton of style guides for different sites - possibly a very useful reference for H
Consolidated all our HTML resets into a new module, Reboot. Reboot steps in where Normalize.css stops, giving you more opinionated resets like box-sizing: border-box, margin tweaks, and more all in a single Sass file.
Worth having a look into the Reboot module to see what the reset involves and the rationale.
Note that normalize.css is used as a baseline, with styles from reboot.scss applied on top.
See https://github.com/twbs/bootstrap/blob/v4-dev/scss/_reboot.scss
Documentation on what changed in the Bootstrap 4 Alpha, possibly a useful reference for CSS best practices in 2015.
Note that we currently are using a universal selector reset in reset.scss in H which changes the default box-sizing model.
Best Practice: use controller when you want to expose an API to other directives. Otherwise use link.
The bad news: we now have to contemplate adding authentication to our RSS/Atom feeds.
Since anyone who has the original link can join a group, perhaps just provide a way for group members to generate an RSS link that includes authentication (eg. as a query string parameter)?
You’ll want to make sure that you list all required resources of a specific type in a single directive.
A useful intro to the angular-jwt service that we use in H for auth.
So rather than waiting further we decided to instrument the existing web interface — not a terribly elegant or reliable solution but it works for now.
Sigh, it looks like we'll need to do something similar for H in order to automate the Firefox extension build process unless APIs are ready soon.
Open source components from Twitter using Velocity and React
Useful introduction to how source maps work. The code for Mozilla's source map library is very readable and an easy way to test this in practice.
You can then just use one class in your markup <button class="Button--error"> and get the common & specific styles you want. It’s a really powerful concept, but the implementation has some edge cases & pitfalls that you should be aware of. A great summary of those issues and links to further reading is available here, thanks to Hugo Giraudel.
Some notes worth a read on SASS and @extends
Article introducing CSS modules
Here are a few handy tips on measuring your project’s performance profile:
In particular, see this section on recommendations for setting up tests that reasonably simulate "real world" conditions.
Web performance article from a couple of the Chrome team developers / (developer advocates). Mentioned on Twitter - https://twitter.com/aerotwist/status/649877465079390209
Great article on the state of immutable data structures in JS and using them with React and Redux
Risks for Corbyn over nuclear stance
First version