Asana Blog

Disclaimer: I work at Asana

We have an in house system (LunaDb) which is a little like this. There's a tech talk available about how it works at https://blog.asana.com/2015/10/asana-tech-talk-reactive-queries/ - it's from a few years ago, but the core ideas are there. There's also some details on the caching layer we built for it at https://blog.asana.com/2020/09/worldstore-distributed-caching-reactivity-part-1/

A few properties based on your questions and the observations here:

- We don't attempt to incrementally update query results. Given the number of simultaneous queries the system handles, we've found it much more important to instead by very precise about only re-running exactly the right queries in response to data modification.

- We support joins (although not queries of arbitrary complexity). We avoid a race conditions and cross-table locking issues by using the binlog as our source of changes, which imposes a linearization on the changes matching the state in the db. Correctly determining which queries to update for these requires going back to the database.

- Performance is an interesting problem. It's easy to arrange situations where total load is a function of "rate of data change" * "number of queries over that data", so being overly broad in triggering recalculations gets expensive fast.

We're actively hiring to work on this - if you are interested my contact details are in my hn profile.

Asana (https://asana.com/jobs/eng) | San Francisco, CA . New York, NY | ONSITE
Software Engineers (generalists and specialists: mobile, web, api, infra, security)

We’re a mid-stage startup (~250 people) building a SaaS product that allows teams to track their work and achieve their most ambitious goals. We are looking to grow our team with engineers and managers who want to build enterprise software that delights users while ensuring the highest level of security, availability and performance. We're hiring across all of our teams in SF and NY, each of which has 2-5 engs at a time and is responsible for projects from inception through launch and beyond. We value technical excellence, mindfulness, and maximizing impact, which leads to an engineering culture that focuses on shipping quickly (and sustainably) as well as mentorship.

Our interview process consists of a written test, phone interview, followed by on-site interviews. You can view our interviewing guide at http://asa.na/interview
Here are a few links in case you are interested in learning more:
Engineering Blog: https://blog.asana.com/category/eng/
Asana's vision doc and where we are going: http://asa.na/vision
Our Engineering Values: https://asa.na/14g
Our co-founder Dustin on why work-life balance is so important to us: http://asa.na/live-well
Please email me at hn@asana.com if you're interested in our engineering positions.

The main differentiator and focus of the post is "we're making this run in the browser". But nowhere does it explain why that's better for designers. You don't need it to power collaboration features.

This echoes Asana and a lot of the "HTML native" product efforts. Which have mostly failed as a technical approach and resulted in a return to platform native apps.[1] What's different this time?

Meanwhile this prompts amazed reactions from folks who are technically impressed with how far it pushes the browser. But that was the case with prior HTML native efforts too. It distracts from a critique of the actual product features.

I'd like to see a more head to head comparison with popular tools like Sketch. Maybe the built in team collaboration is better than, say, a companion app like Zeplin. But the implementation details don't really matter to customers.

[1] https://blog.asana.com/2014/07/mobile-plans/

We use the concept of 'topics'. A topic encodes: 'The part of the index a query cares about'.

For example, given a query like "fetch user where id = 1", there could be a topic like "users:id:1" [1]

When a WAL record comes in, we find queries by their topics, and invalidate them. This triggers a refresh.

This is inspired by Figma's LiveGraph [2], which in turn is inspired by Asana's Luna [3]. The essays cover the idea in more detail, but you can also start diving into the code, at invalidator.clj [4]

[1] This is an example. Inside Instant, we encode them as a 'datalog' pattern. Something like `[:ea "1" :users/id]` [2] https://blog.asana.com/2020/09/worldstore-distributed-caching-reactivity-part-2/ [3] https://www.figma.com/blog/livegraph-real-time-data-fetching-at-figma/ [4] https://github.com/instantdb/instant/blob/main/server/src/instant/reactive/invalidator.clj

I'm an engineer at Asana. Trust me, they're full aware that performance is the #1 problem with Asana right now.

The major engineering focus at Asana right now is performance. It has been for a while and they're just starting to roll things out with the new, faster, backend and UI. I think you'll start to see significant improvements soon as the investments they've been making start to roll out. It's already started rolling out to some customers, and the API updates just got turned[1], on for example. Those changes are going to be making it into the UI soon.

If you don't like Asana performance, give it a few months and check back or keep an eye on their blog[2]. Big changes are coming on that front.

[1] https://asana.com/developers/feed/asana-fast-api-open-beta
[2] https://blog.asana.com/

> Javascript is great. But... in saying that it has a few quirks and can work in some unexpected ways.

Typescript has just as many[1] (in fact more, as it's a superset) quirks than Javascript. I like using it (and it makes JS type-safe-ish), but it's not really some kind of paradigm shift.

Not sure how I feel about import maps. They are quite literally the same thing as package.json. In fact, converting between the two takes about 20 lines of code[2]. I'd bet my bottom dollar that everyone's going to use them, which is going to lead to exactly the same types of problems as Node.

[1] https://blog.asana.com/2020/01/typescript-quirks/

[2] https://github.com/WICG/import-maps/issues/60