Apollo raises $22M to simplify app development

https://blog.apollographql.com/apollo-raises-22-million-to-simplify-app-development-ee30502c81b3

by mostafah • 7 years ago

113 73 7 years ago

blog.apollographql.com

djmashko2• 7 years ago

(disclaimer: I worked at Meteor/Apollo for about 5 years)

I love the callout to how this is continuing the vision for improving application development started with Meteor -- it really does feel that way to me. Apollo, supported by GraphQL is IMO really delivering on the vision of making a lot of aspects of client-rendered app development much more straightforward than they have been in the past.

ben_jones2• 7 years ago

Honest question, what about GraphQL is straight forward? As a web developer I've been curious about its hype for a long time but every time I look at its implementation I balk.

I have a lot of experience with JSON-REST APIs and RPC systems like gRPC and they both seem clearly superior (especially in tandem with code generators) where as GraphQL seems like a ton of extra work on the client and server side for little gain. When asked most developers say its because you can limit which fields you query, and I have to politely explain to them the existence of an SQL SELECT query...

apazzolini2• 7 years ago

The main value prop for me with GraphQL is that it makes data a composable, declarative dependency of a view.

mmckelvy• 7 years ago

Completely agree. I think web development is a lot simpler and faster without GraphQL.

brad0• 7 years ago

It’s understandable that the benefits don’t immediately seem obvious. We have all been working with REST for such a long time that we forgot what didn’t make sense when we were learning REST.

A good way to think about GraphQL is it’s data centric as opposed to operation centric. The unit you work with is the object instead of the operation.

Object level querying instead of operation level querying

Object level auth instead of operation level auth

g_delgado14• 7 years ago

I haven't ever used GraphQL (so take what I say with a grain of salt b/c i could be incorrect), but what gets me intrigued by it is that it helps your engineering organization scale by decoupling the back end and the front end.

Say, for example, that you have a new UI on your app that requires some data stored on your db.

Without graphql, you:

A) Re-use existing REST endpoints and compose data that you need on the front end (but remember that browsers have a hard limit on the number of concurrent api requests. Not to mention that some requests can't be sent until others have arrived back with resource id's). So depending on what endpoints you currently have, this may not be a good option given the latency cost of composing many HTTP requests to get all the required data.

B) You tell your back end devs to create a brand new route that meets the data requirements of the new UI.

With GraphQL, my understanding is that there is zero back end work. You just tell the GraphQL engine what data you need and it magically arrives into your browser.

a_wild_dandan• 7 years ago

On the front-end, with GraphQL you simply specify exactly the data you want on the client, e.g:

`GET localhost/graphql`, with body

dogs {

  name

  location {

    city

  }

  isAGoodBoy

}

...and I get back:

dogs: [

  {

    Fido,

    location: {

      Boston

    },

    true
  },
  {

    Spot,

    location: {

      Los Angeles

    },

    true

  },
  ...

]

No extra fields. My clients page doesn't care about the dog's UUID, weight, etc. No routes. Everything goes to `localhost/graphql`.

It makes writing clients an absolute joy, and it works gloriously with React. Tell the server exactly what you want, and get exactly that.

On the back-end, every field (name, isAGoodBoy) is a resolver. Maybe it's a simple database call to retrieve that field. Maybe it's some service that pulls crap from an S3 bucket. GraphQL doesn't care. So the level of difficulty of implementing a GQL server is dependent on your back-end. For most folks, you'll just be making calls to a database.

seanalltogether2• 7 years ago

When asked most developers say its because you can limit which fields you query

For me this is one of the biggest headaches I have with a new app I've been assigned to. By allowing all fields to be optional depending on the graphql query, there's no consistency in the objects floating around in your apps data store. When I reference a Person object in my view that I'm using, will phone number be there or not, who knows.

Maybe its better when every single page has to request it's own data, but when the model objects are cached to a data store in an app and shared between views, things get really dicey.

adamkl• 7 years ago

One thing to keep in mind is that GraphQL really supports a different use case than something like gRPC or REST.

One of the places where it really shines is providing a queryable API entry point to a graph of interconnected data. This makes it ideal for generally reusable APIs for consumption by a variety of clients (e.g. GitHub's GraphQL API).

gRPC interfaces are typically use-case specific, and performance oriented (though GraphQL doesn't specify any sort of transport protocol, so you could always serialize GraphQL request/responses with protobufs to gain some performance over the wire), making them well suited for server-to-server communication, but not generally reusable.

REST is resource (i.e. nodes in a graph) based, but doesn't necessarily do a good job of making the relationships explicit and easy to traverse (I'm sure there are good HATOAES implementations out there that address this, but I haven't seen one).

Both REST and gRPC have their place, but I think GraphQL is a clear winner when you want to build a single API to service a large number of distinct clients. It really does offer a clear, easy-to-use API abstraction over where ever you might get your data from.

Also, since you call out code generation specifically; GraphQL provides a strongly-typed schema that can be introspected against, and the tooling to parse queries/schemas into abstract syntax trees. A large number of tools have been built with these capabilities including a number of different code generators. I've even used a GraphQL schema to generate a matching XSD (ugh) for import into an internal business rules engine. Made integration a breeze.

diveanon2• 7 years ago

Please don't take this as a personal attack, but I was severely dissapointed with Meteor after being a strong proponent for it for several years.

I advocated for its use on several projects and was bitten by major performance bottlenecks and its over reliance on MongoDB. GraphQL implementation is great, but does it support relational dB's yet?

I am happy to hear that it is still doing well, and I may end up using it for some personal projects.

I believe that the problem it is trying to solve is worthwhile. However I became very frustrated when the push for monetization started while the framework itself still seemed like it was in the prototype phase.

Please correct me if I am wrong, but Meteor has a place in my memory similar to an ex that I really cared about but hurt me once more than I could stomach.

NickBusey• 7 years ago

As someone who also jumped on the Meteor bandwagon, and is now stuck maintaining a project created with it, run away and do not look back.

It is not being maintained by anyone as far as I can tell, more and more packages are breaking by the week it seems like, and the basic 'features' listed 'on the box' of Meteor have never worked.

Save yourself some headache and pick a stack with an active community.

JMTQp8lwXL6• 7 years ago

Externally, my observation was the monetization of the platform was competing with development. When Galaxy came out, feature work on Meteor slowed down. Hungry VCs wanting their return and rapid growth, I suppose. It would've benefitted more from growing organically longer, before going for monetization.

cultofmetatron• 7 years ago

I'm currently using absinthe which enables a graphql backend on the elixir stack with apollo on the frontend. its been working fantasticly well for me so far. Its backed by postgresql and the hardest part so far has been making sure to batch sql queries for complicated graphql queries.

I haven't used apollo-server but I wrote nodejs code for 8 years and I wouldn't trust it to scale without a lot of effort being put into your DevOps story.

flippyhead• 7 years ago

We love Meteor too, but have been very disappointed by how MDG has seemingly abandoned it. We had so many expectations for things it would be doing by now that never materialized because MDG moved onto other shinier things.

kabes3• 7 years ago

If you don't needed the reactivity, I can see how you could solve your performance problems easier without Meteor. However, if you actually need the reactivity, what other tools/frameworks give you a similar convenient reactivity system with better performance? And there are some solutions within the Meteor community: https://github.com/cult-of-coders/redis-oplog (with some trade-offs)

marknadal• 7 years ago

This is awesome, congrats!

Does this mean Meteor is dead?

Also, the end paragraph mentions some cloud-based graph management system. Is there any chance they could do a decentralized graph management system (something like https://github.com/brysgo/graphql-gun ) instead of some centralized solution?

I don't want my GraphQL data getting locked in to some vendor. Any reason why I shouldn't worry about this? Thanks!

JMTQp8lwXL6• 7 years ago

Meteor, as a framework, was solid for its time. I don't think they could've envisioned how much the JavaScript ecosystem would change after its launch. It tried to solve a great deal of problems that ultimately were solved in smaller, more focused libraries.

bnjmn2• 7 years ago

Thanks, this is a good take.

I would add: now it's everyone else's job to make those smaller, more focused libraries work together. The time wasted is unfathomable, but the blame for misconfiguration now falls on individual developers, rather than monolithic frameworks. Progress?

bnjmn2• 7 years ago

Does this mean Meteor is dead?

Absolutely not! We depend on it internally (engine.apollographql.com is a Meteor app), and Galaxy hosting revenue is THE reason we didn't have to raise money until we felt like it, which is why we got to pick our investors in this round.

Behind the scenes, as the lead developer for both Apollo Client and Meteor, I am constantly borrowing technologies from one to benefit the other. Meteor may move more slowly these days, but that's because it's relatively mature. Apollo has to move more quickly because we're still making (and remaking) fundamental decisions.

Even as community enthusiasm for Meteor has slowed, Galaxy revenue has not, and it's honestly not the worst thing for an open-source project if people who came for the hype either (a) find real reasons to stay, or (b) take their hype-thirst elsewhere.

I have some ideas for increasing Meteor contributor engagement that I'll be giving a talk about at the next Meteor Night (tentatively July 9th in SF).

pasharayan• 7 years ago

(Re: Meteor) Our company is scaling up and we're worried that Galaxy won't be able to handle growing demand - do you have any thoughts on making the meteor system more scalable and affordable as companies get larger?

I love meteor, and don't really want to move our stack off it but it's becoming a more real thing that we have to face in the near future as it's hard to see how it can grow with us!

I can only imagine the reason galaxy revenue is increasing is that the companies started off Meteor 2-3 years ago are now becoming real. I know a few companies in our YC batch that use Meteor.

RoboTeddy• 7 years ago

I like GraphQL a lot — but found that writing mutations involved a ton of boilerplate. For example, I'd have to keep writing the same key names over and over again. Anyone else experience this?

KenanSulayman• 7 years ago

You could use input types and reduce the boilerplate to a single parameter, which you then send as an object in the request variables?

fernandotakai• 7 years ago

yeah that's what i did. inputs also help a bit with code reuse, imho.

crucialfelix• 7 years ago

Yes, Mutations are still annoying to write. Especially with all the optimisticResponses and pushing things into collections.

mattbillenstein• 7 years ago

I like graphql as technology - I find it just a better way than REST for building services, and I like that it's just json - simple easy to debug text responses. I like that there are companies investing in this technology.

But, I don't see how you build a VC funded business out of this - countless examples of infra companies trying to build a business out of OSS technology and they always struggle to get paid because they provide so much value for free.

Docker Inc's struggles come to mind here...

727374• 7 years ago

As a customer, I see a lot of value from Apollo's SAAS, which helps in "productionizing" graphQL. GraphQL has more sophisticated instrumentation and access control needs than simpler APIs like REST/RPC and there are few if any open source projects that can do this. It was a pretty easy buy vs build decision for my team. Granted open source alternatives may pop up at some point.

hwillson4• 7 years ago

Our approach (at Apollo) for building a VC funded business out of this is:

1. Build the best GraphQL developer tools we can, focusing on making developers happy. Make sure those tools are open source, and involve the GraphQL community as much as possible when building them, to make sure we're building tools developers actually want to use. With those tools available, make sure any developer who wants to use them can, for free.

2. At the same time, build more advanced tooling and sophisticated GraphQL infrastructure components (that would be costly for an individual organization to build and maintain themselves), that provide a way for businesses and organizations to effectively, efficiently, and securely manage their GraphQL based infrastructure. Give anyone the chance to use these more advanced tools/components for free up to a certain threshold, to see if they're a good fit and if they're worth the money. If all signs point to yes, we then start charging.

Our approach is fairly simple, and has been followed successfully by many companies before us (a simple plan is a good plan). We've been following this approach for a while (before this funding came into place), and things have been going extremely well.

oblib2• 7 years ago

How does this compare to using CouchDB/PouchDB?

(maybe it doesn't, but at first glance it looks similar in a lot of ways to me)

mrgordon• 7 years ago

CouchDB is a document store style database. GraphQL is more focused on the API layer (how do I query any underlying data sources for exactly the data I need) instead of tying you into one particular database. So, in theory, some of your GraphQL objects might live in CouchDB but others might live in PostgreSQL or a file store.

oblib2• 7 years ago

Ok, that's pretty cool

Thank you for the insight!

cryptica2• 7 years ago

Part of me thinks that if Apollo was a good company, they wouldn't need to keep raising this kind of funding by now. There are plenty of alternatives which burned a fraction of what Meteor/Apollo has burned to build this. They're taking funding and attention away from other more deserving projects.

JMTQp8lwXL6• 7 years ago

The danger with external funding is forced growth before the platform is ready to be monetized.

hwillson4• 7 years ago

Actually, this isn't a worry for Apollo. We've been growing and monetizing for a while, and our partners are an amazing group of people who get what we do. They aren't forcing us to do anything.

hwillson4• 7 years ago

Just to clear this up a bit; Apollo doesn't "need to keep raising this kind of funding". Both Meteor and Apollo have been making money. What's really happening here is that both Apollo and its amazing supporters/investors have witnessed first hand the impact that data graph based technology can have on the lives of developers and the productivity (and bottom line) of companies. To help take all of this further, we've decided now is the time to bring more people on board, so we're substantially growing our team (hence the extra dollars).

They're taking funding and attention away from other more deserving projects.

I've gotta say, I completely disagree with this statement. Meteor and Apollo have both helped thousands of developers do amazing things, for free. Yes, I work for Apollo, but I'll detach for a sec; I can't think of any open source software company on the planet that deserves this more than they do. I can tell you first hand that Apollo cares deeply about open source software (OSS culture is ingrained into the company right from the top), and goes to great lengths to make developers happy and provide ways for developers to use a large portion of the things it builds for free - no strings attached. When I encounter other companies that act like this, I instantly think they should get anything they need to help themselves flourish and thrive - Apollo is no different.

JMTQp8lwXL6• 7 years ago

[W]itnessed first hand the impact that data graph based technology can have on the lives of developers and the productivity (and bottom line) of companies

Have you quantified this? I'd be curious to see how much productive companies are using GraphQL when compared to creating, e.g., generic REST API's.

cryptica2• 7 years ago

> What's really happening here is that both Apollo and its amazing supporters/investors have witnessed first hand the impact that data graph based technology can have on the lives of developers and the productivity (and bottom line) of companies

It's just a bunch of wealthy people using their money to force their opinions about software development onto as many developers as possible...

I can guarantee that there exists simpler solutions outside of the GraphQL bubble that far exceed what can be achieved with Apollo in terms of both flexibility and productivity. I could share some links if you are genuinely interested.

SirensOfTitan• 7 years ago

We really love Apollo and use its open-source software in our GraphQL stack.

With that being said, I really hope Apollo will provide their iOS library some much needed love soon, or clearly imply they're not developing it anymore. They've mentioned they're hiring an iOS engineer maybe a year ago? but largely the repo has gone neglected. I've made some modest improvements for our sake, but PRs generally go unreviewed forever, so it doesn't seem worth writing the tests to get my work in a landable state.

peggyrayzis• 7 years ago

Hi from the Apollo team! We hired a mobile engineer who is starting within a few weeks. Keep your eyes out for lots of exciting improvements to Apollo iOS soon!

tonyjstark• 7 years ago

As a user of GraphQL with Apollo since a year, I still don’t see how it simplifies app development. Actually, having such a huge dependency in the code feels more like a liability.

Most apps are simple, don’t need to send much data around if you don’t put 3-10 user tracker in, and Rest is just really, really simple for most parts.

In every project I worked so far that used GraphQL, developers tend to not care about backwards compatibility of APIs because having tons of optional properties in query responses doesn’t feel nice.

As always, there are exceptions and if it makes sense, sure, go ahead. But be aware of the dependencies and the magic you get into your project. Oh, and don’t use it for file upload, that’s just painful.

TheKidCoder• 7 years ago

Couldn't agree more. Apollo has shipped multiple broken releases over the past year related to having a massive dependency tree - we're migrating away from their apollo-server system soon.

baybal2• 7 years ago

I found that despite the name, making something like a graph crawler is kinda hard in graph ql because you have to write "a new schema for discovery of schema" (all is made kinda hard to query the schema itself)

neya2• 7 years ago

I was a huge proponent of GraphQL and used it for many clients. For me, it solved a specific need - I can write an API backend that is scalable across clients (Web, iOS, Android). However, having said that, I have made the mistake of using GraphQL for projects that only have web interfaces with somewhat complex querying (but with vague ideas of expanding to apps later). It wasted so much of my time that I ditched the project halfway and re-wrote everything using normal CRUD interfaces. I use Phoenix + LiveView now, and it's truly a god send to write code without having to touch any Javascript. Not only are my interfaces way lighter, but they also feel very natural and I get server rendered error messages out of the box without having to parse them on my frontend.

GraphQL is a rabbit hole. Don't use it unless absolutely necessary or you have a small to mid-sized team for large scale projects. Atleast on Phoenix/Elixir side of things, it's just not worth the effort - you need to write resolvers apart from your schema/models, handle changeset errors in the frontend (which there is no way to deal with directly as of this comment) and if you're working with VueJS, then good luck. My package.json is so bloated that I am starting to feel it's all just a pack of cards. I can't stress enough how much valuable developer time I wasted getting all these bits and pieces working together. Usually, you can't use one because the other one is outdated, or has some weird Github issue you now need to address. And then that causes another probelm..and another one..[the rabbit hole goes deep]

    "@babel/core": "^7.0.0",
    "@babel/plugin-syntax-dynamic-import": "^7.2.0",
    "@babel/preset-env": "^7.0.0",
    "apollo-absinthe-upload-link": "^1.5.0",
    "apollo-cache-inmemory": "^1.6.1",
    "apollo-client": "^2.6.1",
    "apollo-link": "^1.2.11",
    "apollo-link-context": "^1.0.17",
    "babel-loader": "^8.0.0",
    "babel-preset-env": "^1.7.0",
    "coffee-loader": "^0.9.0",
    "copy-webpack-plugin": "^4.5.0",
    "css-loader": "^2.1.1",
    "file-loader": "^3.0.1",
    "graphql": "^14.3.1",
    "graphql-tag": "^2.10.1",
    "mini-css-extract-plugin": "^0.4.0",
    "node-sass": "^4.12.0",
    "optimize-css-assets-webpack-plugin": "^5.0.1",
    "resolve-url-loader": "^3.1.0",
    "sass-loader": "^7.1.0",
    "script-loader": "^0.7.2",
    "style-loader": "^0.23.1",
    "uglifyjs-webpack-plugin": "^1.2.4",
    "vue-apollo": "^3.0.0-beta.30",
    "vue-loader": "^15.7.0",
    "vue-template-compiler": "^2.6.10",

When DHH ranted about these, I never believed him and I always thought he was not upto par with JS frameworks. But turns out, everything he said was true. Turns out, you don't need GraphQL at all for most use cases when you can simply get away with something like Tubrolinks or LiveView.

theonething• 7 years ago

A thousand times yes. I wish my team lead/members would read this and believe it.

rozenmd• 7 years ago

Not gonna lie, that's a pretty lean package.json file...

neya2• 7 years ago

I extracted out just the GraphQL related bits

ronanyeah• 7 years ago

Just want to give a shout out to Hasura (https://hasura.io/) here which removed a lot of these problems for me.

tkainrad• 7 years ago

Interesting article. However, I disagree with the premise. Data management is certainly not the hardest problem in app development.

Everybody knows there are exactly three hard problems in software development:

1. Naming Conventions

2. Off-by-one-Errors

gregkerzhner2• 7 years ago

I think GraphQL is pretty cool, but my experience with Apollo is mostly negative. The query and mutation components for example - on the surface, they seem pretty useful, however, in reality, its a bad idea to have your view layer directly making API calls - those should be in some other module thats lower level, away from the view and easier to test. But instead, people use these query components everywhere, and all of the sudden, all the app's logic is weaved into the view and very hard to unit test.

Apollo's local state tools are bad in my opinion as well. It might work OK if you just want to keep a few global flags, but anything more, and it gets really verbose. Especially if you want to update state based on current state, you have to first manually fetch the current state, then update it, then save that object back, every time. On top of this, its often necessary to write mutations just to update local state, which are written as GraphQL strings - one mistake in this syntax and you can be stuck trying to debug it for a while. How any of that is easier than just having Redux I still don't understand.

Overall, Apollo feels like a worse version of Angular.js - an app framework thats trying to do way too much. If your app just made basic GET requests and had no other logic, I could see how Apollo could be useful (but why have a framework at all in this case?) However, if you have complex logic or local state, Apollo quickly becomes and opinionated, unwieldy piece of junk

hwillson4• 7 years ago

Thanks for the feedback, and sorry to hear about these issues! I'll try to address them below:

in reality, its a bad idea to have your view layer directly making API calls - those should be in some other module thats lower level, away from the view and easier to test.

Apollo doesn't force you to cram everything into your view layer. If you want full control over how your interact with your GraphQL backend, you can wrap "Apollo Client" in whatever layer you want. If you're using a view layer integration like "React Apollo", we try to help reduce some of the extra layer boilerplate that can come up, when integrating your view layer with other controller, model, business, etc. layers. Again though, none of this is mandatory, and it's important to understand that components in "React Apollo" aren't directly making API calls. Query, Mutation and Subscription components are just React components, that communicate with Apollo Client behind the scenes. Here, "Apollo Client" is the lower level module that you're referring to, that then takes care of API calls. As for testing, you can (and should if possible) test all parts of your application, be it view layer or lower level API integration points. We provide tools to help unit test React Apollo components with mock/fake data (that can be integrated with any popular React testing library), and there are lots of great ways to unit/integration test Apollo Client (and its associated libraries).

But instead, people use these query components everywhere, and all of the sudden, the view balloons with logic like parameter validation, error handling, etc... Everything is weaved into the view and very hard to unit test.

React gives you a toolset to work with and manage components. Can you build an application that gets out of control using React? Absolutely. Apollo gives you a toolset that can be used to work with data. Can you build an application that gets out of control with Apollo? Most definitely. Just like the React team, we've taken a lot of steps to help developers avoid these application design pitfalls. We spend a lot of time working on our docs, routinely blog about best practices, and help developers whenever/wherever we can, through various social channels, meetups, conferences, etc. That being said, we've worked side by side with hundreds of developers who are using Apollo happily and productively, and if anything, have found that Apollo's view layer integration has helped them get their countless view layer data integration points under control (and made things easier to test).

Apollo's local state tools are bad in my opinion as well. To update any state, you have to constantly fetch the current state and then make a modification.

This isn't accurate. Actually, in most cases saving and updating local state is as easy as just running a query/mutation - everything happens for you seamlessly. Apollo Client's local state capabilities have changed quite a bit as of version 2.5, so give a newer version a try (and see the updated docs) to see if that helps.

This feels a lot more cumbersome than just having redux and reducers.

Redux can definitely come in handy, but it has its strengths and weaknesses (like all tech). One of the core tenants of Apollo Client's local state handling is that it knows how to work with GraphQL out of the box. This means AC's local state handling can be used to do all sorts of great things, that would require more work to accomplish with something like Redux. Things like working with a specialized cache that normalizes GraphQL query responses to speed up cache reading/writing, know how to merge local state with results returned from remote queries so applications get everything they need from local and remote after running a single query, replicate remote GraphQL resolver functionality locally to inject advanced data management techniques on the client side, etc.

Overall, Apollo feels like a worse version of Angular.js - an app framework thats trying to do way too much. If your app just made basic GET requests and had no other logic, I could see how Apollo could be useful. But anything more complex, and the code becomes a weaving, untestable mess.

Some of the biggest companies on the planet (with amazingly complex applications and systems) are using Apollo and loving it. That being said, we're always striving to do better and welcome constructive feedback like yours. Please consider opening issues in any of our Github repos with your problems and suggestions regarding how we can help make things better.

gregkerzhner2• 7 years ago

"This isn't accurate. Actually, in most cases saving and updating local state is as easy as just running a query/mutation - everything happens for you seamlessly. Apollo Client's local state capabilities have changed quite a bit as of version 2.5, so give a newer version a try (and see the updated docs) to see if that helps."

You are glossing over the fact that there is a 3rd part, writing a reducer! This part is the most cumbersome in my opinion.

Lets say you wanted to keep a counter and increment it in your app. With Redux, you add it to your state, write an "increaseCounter" action, and then write a reducer. This reducer is just a plain function without any dependencies. A unit test for this reducer would just test that the count was updated.

However, with local state management with Apollo, you would either need to 1. write an incrementCounter mutation and an incrementCounter reducer. Inside that reducer, you would have to fetch the current count from the cache, update that count, and then write the results from the cache. 2. Just use `cache.writeQuery` or `cache.writeData`, but in either case, you need to fetch the current state of the cache, modify it, and then write the object back.

The problem with this is that any time you want to modify state, you need to always fetch the current state, and then write the state back. This is bad because

1. its super repetitive 2. it tightly binds the code of "how the state changes" to "how the state is queried and saved"

Overall, this whole approach of having to write a mutation and a reducer for every state change is annoying and verbose. Redux is just overall a better, more convenient pattern to incrementally update a piece of state.

We actually thought about adding a Redux layer on top of Apollo, so that we would just have a single "Redux" mutation that fetches the current state, passes it to a reducer, and then saves the transformed state in the cache to avoid all this fetching and saving, but then were afraid of potential performance issues of homerolling our own Redux, and went with actual Redux instead.

thatguyagain• 7 years ago

I work a little bit with a graphql backend API and apollo in the front, and I still have no idea why this is better than a rest API and regular fetches in the front. I feel like we are moving backwards. Way more code to type out which fields you want back, and the same in the back + the actual resolvers/mutations. I really don’t get any of this..

Apollo raises $22M to simplify app development

Related Stories