There had been other projects which had been kept under wraps successfully. Chrome and V8 were demoed in Seville long before anyone on the outside heard about it. They said keep it quiet, and we did. Google TV had been knowable for ages before it went anywhere externally. There was no reason to think someone would leak Wave.
Instead, they started playing the "we're special and you are not" card, and that started a sense of resentment growing. Not even the infrastructure teams which were going to provide services to them were let in on what was really going to happen in there.
Then after far too long, demo day of Wave arrived. I only stayed long enough to see them hit backspace and have it echo out to everyone else who was connected. I remember my exact comment at the time: "packets". As in, lots and lots and lots of packets flying around to generate RPCs for all of those deltas. Then those turn into XML or whatever going out to web browser clients, and ... yeah. SO many packets. That right there worried me greatly.
So then I see this thing about it not scaling properly and choking JVMs and suddenly it all makes sense.
Oh well. All of the secret code depots and restricted access areas must have been practice for what is now happening with Plus. Entire floors of buildings you can't open as a full-time employee? Yep. More code depots being locked down? Yep.
DepotS ? So I assume Google finally gave up on making their one Perforce server scale, then?
(Unless Google is crazy enough to actually do multiple depots on a single p4d instance...)
Along those lines, I doubt there's one of anything in there any more. It's just too big.
Why is that "crazy"? AFAIK, depots are just an organizing mechanism, they don't have any effect on scalability.
Hence, I feel that having multiple depots on one Perforce server simply eats up client names and causes confusion among those who haven't learned the distinction between "depot" and "server".
I say this simply as someone who was, at the time, outside looking in. I know little more than that but it had all the hallmarks of what happens when engineers are running the asylum. Here's this communication medium in which basically all other communication media can be implemented (Email, IM, forum posts, Twitter, etc). It's the kind of general solution that engineers come up with it.
I read a post from someone else (can't find it now but I think it was on Quora) who was familiar with the matter and they were saying the risk-reward thing (which this poster mentions in passing) was all messed up. Basically the incentive structure rewarded mediocrity.
I can't speak with any knowledge of those matters but I can believe it. After all, in a startup what happens if the startup fails? You find a new job. There is a strong incentive to make your runway last and get to your next funding round (or, Heaven forbid, profitability). Inside somewhere as cashed up as Google, those incentives (IMHO) disappear.
If the "startup" fails, what happens? You just move to another part of Google. What do you think the odds were that with Wave going away, any extra Wave incentives became worthless (as would happen in a startup)? Basically zero (IMHO).
I have heard that for all the values of X. Here are the most common:
- It was too hard to use / I didn't know what to do with it
- It didn't integrate with email / didn't have email notifications
- It didn't support IE
- I started using it, but none of my friends were using it, so I stopped
- It was too slow
Too late, the team spent a bunch of time talking to actual users and finding out how they were using the product and what their real pain points were. People use wave to communicate in small teams. IIRC the biggest pain point our users cited was that wave didn't support printing. The people who did get over the adoption hurdle ended up using wave a lot. (I still wonder if maybe wave might have survived if we had charged for it.)
Wave died because we were too slow to make it good. The code base consists of around 1M lines of java. With 1M lines of code, you need a giant team to get anything done, and a giant team working hard on features tends to add even more code. The wave team burned too much money too fast. And we were still working too slowly to get explosive user growth. It made lots of people sad, but Google was right to kill wave.
If I could go back in time and give advice to the team, I would say:
- Don't use Java
- Don't scale past a few engineers. You will have a much longer runway that way, and you'll need it if you want to replace email.
- The network effect will kill you unless you integrate with email from day 1.
- You don't know what you're building, so talk to users early. Like, today.
- Don't optimise for scalability until you know what the product is supposed to be
- Don't try and reinvent the scrollbar, you idiots. (So much stabbing.)
The problems we face with communication today are not ones of distribution, speed, or longevity. Currently there are some very popular forms of communication which have fundamental issues with one or many of those aspects, but ultimately those are problems which are amenable to very direct and relatively inexpensive solutions.
The real problems we face are ones of organization, discovery, workflow, meaningful semantics, and overwhelmingly managing information overload. I don't believe that Wave significantly addressed any of those issues. But only by addressing those issues can you create the sort of value for users that will drive significant adoption of your tools.
Quoting Zawinski's Law of Software Envelopment
"Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can."
In a team of about 6 remote workers we used it to create collaborate documents - starting with something that looked like a chat and then giong back and editing the chat into a finished document.
You may well be right that Google was correct to kill Wave, but thanks nonetheless.
Feels like two high-end devs could implement the 80% of it that people actually used in a couple weeks and 10-50k LOC.
Maybe I am missing something, but it sounds like Large Company culture doomed it.
[Blatant plug: http://sharejs.org/ ]
I loved Wave despite its warts and managed to run several extremely successful small team document writing collaborations through it, completely replacing IM, email, groups and lots of early document drafting in Docs/Word. There was nothing that anybody on the team had experience with that came close to that. We went from hundreds of emails a day and hours of IM'ing to absolutely zero of each within a week of moving to Wave.
My only real complaints were that the web client was dog slow and going from a Wave of draft-edits to a final document was kind of painful.
Never did find a use for lots of the other bells and whistles (embedded widgets things, channel bots, etc.), perhaps that's where a lot of the extra LOC went to...
The entire Wave story would make an amazing case study if Google would ever let the entire story out.
I think we should have spent more time keeping the code clean; but thats always a tough call when you have features to ship. Its easy to point to lots of things and say they were mistakes. But I worry that, had the project been successful, we might point to the very same things and talk about how clever we were.
A huge effort was put into making the client more responsive in the few months just before wave got cancelled. I'm not sure if its still the case, but at one point wave was loading faster than gmail. We were a month or so away from shipping server-side rendering of waves with progressive enhancement for editing. That made waves load in a snap. (The guys finished that piece of work and put it in the opensource wave in a box project.)
You weren't alone in getting a lot of value out of wave. We used it internally for everything. When we had meetings, we shared the agenda in a wave. People edited the wave with meeting items, and during the meeting people collaboratively annotated the agenda with what was decided, turning into the minutes. It was a thing of beauty. I still think there's a need for something like wave - it solves real problems.
When wave was cancelled, there was a series of honest retrospectives internally on different aspects of the project. I hope they get eventually get published eventually too. A lot of people were quite career-sensitive after wave. Most blog posts you see by wave developers are written by people who have left google anyway.
Looking at the app I'm building (alone) with these tools, I could say that it's on par with Wave on the realtime UI and complexity, but the development experience is a really pleasurable one. These tools are crafted for exactly what I'm doing and it seems like they know what I want to do before I want it.
But then again, back then you didn't have these tools so I guess you had no choice but to go the 'academic' Java way.
But anyway, congratulations on this incredible achievement and also for the many lessons learned and shared with the world.
Also, those technologies probably don't scale at all to 1000s of servers, something a Google project has to do from day 1.
(I'm not sure they'd even be fast enough on a single server. As a rule of thumb, the more technologies you put in the mix, the more abstractions there are, the harder it is to minimize the work done.)
The earlier you launch, the sooner you need to do that scaling work. But the later you launch the more development you do in a vacuum, without real customer validation.
CoffeeScript and Backbone.js have nothing to do with scale, as they are used on the front end.
The author talked about how horrible it was to have the UI written in Java (having to wait 3 minutes for a recompile after a CSS change).
Could you recommend a good alternative?
Also, could you elaborate a bit as to why not?
Java works fine in enterprise software written against a strong spec. But wave never had a strong spec - It was an experiment. Inevitably, we spent a lot of time making the wrong thing.
We needed to be able to change wildly based on user feedback. We needed a light, nimbler language which would let us pivot easily and throw away code. ... And you optimise for a changing spec with a small team and a terse codebase.
Today I would recommend Coffeescript, Rails or Scala. Maybe even Go. A few years ago, Ruby, python or C++. Erlang, clojure or haskell would probably work too, depending on the team.
I'm just really surprised about one suggestion: C++. Even if I used it extensively and with great satisfaction back in the day, and even if I personally don't like Java, I'd like to know what would have made C++ a better choice than Java for terseness etc.
I don't think the use of Java would necessarily lead to a project's downfall, I mean how are you going to scale something like this in Python if its already slow in Java?
Stackless might work, it would be great for a prototype. Too bad there isn't a Python on Lua or a Python to Lua translator. The Lua runtime is soo much better and less resource intensive.
I would say it should really be don't use GWT? Blaming entire java for a framework that is developed originally at Google doesn't seem right to me (particularly when Google Employee does that).
"Part of the deal initially was that Wave would be compensated much like a startup, base salaries were supposed to be low but with heavy performance linked bonuses which would have made the Wave team rich upon Wave's success.
During the course of negotiations and building the Wave product, the "heavily reward for success" part of the equation remained but the "punish upon failure" got gradually watered down into irrelevance, making the entire project a win-win bigger proposition."
The problem wasn't that it didn't serve a purpose. The real-time collaboration has moved to google documents, and fills a real need. That said, your analysis for the failure is pretty accurate. It was a focus on engineering over user experience that sealed Wave's fate as a case study on how to not build a product.
I liked the whole article, but this paragraph really stood out to me. It's something I've never thought to put into words, but is so true. Going for days and weeks and not seeing any success in what you're doing is horribly demoralizing. It's happened to me only once, and that was enough to reconsider my appreciation of programming entirely.
It's because the real appeal of programming is, like he said, the incremental gains, the constant moving forward, the iterative process. It's why small side projects are so much fun, because there's nothing getting in the way of your next small accomplishment. It's what draws people (like myself) to programming in the first place. And in its lack, it's the slow killer of large projects.
Thanks for the article.
>And in its lack, it's the slow killer of large projects.
It's interesting that one reason for large project failure may be failure to stimulate dopamine release in its programmers.
I wonder how much of the failure was this sort of thing vs just having a product that people didn't understand. (I definitely agree that if the UI had been simple and snappy it would have been better)
On the bright side, I feel pretty confident that some real startup will take the open sourced Wave technology and do something good...
So _that's_ where the Dart team came from?
I don't share your confidence. Making even trivial changes to the 350k lines of opensourced java takes a lot of time and a lot of skill. There are only ~5 part time developers working on it. I doubt that it will be useful anytime soon.
[Disclaimer: Some of that code is mine]
Then in the client only expose a subset of features until they are really good, then another, then another. Keeping the client codebase small as well.
The client-server protocol uses protobufs encoded over JSON, and the federation protocol uses protobufs encoded over XML, via an XMPP extension. As others have said, there weren't accepted standards for this stuff just a few years ago. Today, you could build whip something together reasonably easily using JSON and socket.io or something.
These days we have plenty business bullies that sing the song "Win big or go home in shame" or "Second place is the first place loser"...
Not only does Apple not shunt n00bs at the UI, it actively hires extremely brilliant people to do UI invention/R&D.
E.g., consider the CV of the (obviously brilliant, IMO) "Up and Down the Ladders of Abstraction" guy, Bret Victor (1).
That's about two lightyears removed from "UI is boring and easy; make the junior programmers work on it while we do the algorithmically hard stuff on the backend."
(As an aside, Holy Shit is BV impressive and refreshing -- incredible tech chops combined with awesome aesthetic/design sensibilities, all wrapped up in a humanistic focus on usability...just, damn.)
(1) http://news.ycombinator.com/item?id=3099595, http://worrydream.com/#!/cv/bret_victor_resume.pdf, and http://worrydream.com/Bio/
hear hear. ui is harder than back-end stuff in my opinion.
Backend is hard in the way that building a skyscraper is hard. You need a solid design and framework, but you also have to make sure every wire runs in the right place. Managing complexity is really the problem there.
Which is harder? I don't think they're very comparable, in the way that I don't know if creating beautiful art or building a skyscraper is harder.
So this is why UI is hard: its art and its engineering. And nobody thinks about the engineering part. And when they do, they have to find an engineer who can talk to the designer without scaring him/her (very often "her").
> Backend is hard in the way that building a skyscraper is hard ... Managing complexity is really the problem there.
UI is hard exactly for this same reason: managing complexity.
There are a lot of great great tools and abstractions for back-end work, but UI has too long suffered with same old OO-oriented approaches that GUI frameworks dictate. They are quite bad for managing the complexity.
It's also noteworthy that UX designers who rely on other developers to actually implement their designs get much more frustrated with such developers...
Long story short, trying to shoehorn 'back-end' developers into UI jobs is a recipe for a crappy user experience.
UI is hard
UI sometime is "boring/tedious" work
UI sometime is "just that, if it breaks, so what..."
Meanwhile back-end stuff usually gets the hype: BigTable, MapReduce, billions load!
Yet at the end of the day... if the user finds it hard...
There are many difficulties with UI, but the most relevant one here is that UI is a bike shed. Everyone's a critic. If you work in a big company you'll learn to dread the UI projects because you're going to have to sit in a room with fifteen people, at least fourteen of whom will dislike something about your approach and all of whom will offer suggestions. There will be 23 revisions and lots of compromises and turf battles and possibly blood, and usually the result will be the legendary horse that was designed by committee.
This is why the author's primary complaint is the team was too big, not we didn't have the best UI people. Without mindful management the big team will squash your UI people no matter how good they are.
Esoteric technical problems don't suffer from as much bikeshedding. Just as in the original parable of the bike shed, nobody wants to suggest changes to the nuclear reactor shielding. If you're the expert on reactor shielding you can basically run your part of the show.
So the author's argument is: build a giant team that is prone to endless meetings, and you will select for traits that help people avoid endless meetings. People will retire into shells. They become narrow technical experts whom nobody wants to gainsay. They will focus on problems that your company already understands well, to take advantage of the cultural consensus which precludes endless argument. And only the young and naive will step forward to do something like UI, where every move is weighted down by bureaucracy and politics.
The article seems to be more about making sure you have experience on the GUI.
All this said, i shouldn't complain about the title - rather i should just be happy the author shared hills lessons.
The argument is that you are going to be better off doing that and picking the best one at the end, than you are running the project with 100 engineers in the first place.
The OP reads totally true to me.
But you are right, it isn't really the primary point he is making.
I'd be curious to know if Google revokes that policy for focus teams like the ones that worked on Wave and Google+.
" If the land mechanism as a whole is good, then every part is good, whether we understand it or not. If the biota, in the course of aeons, has built something we like but do not understand, then who but a fool would discard seemingly useless parts? To keep every cog and wheel is the first precaution of intelligent tinkering. " - Aldo Leopold
At the end we were close to 60 engineers
Some people, when confronted with a problem, think "I know, I'll hire more engineers." Now they have two problems.
Early versions of wave ran on IE7. The problem wasn't HTML feature support, it was a lack of engineering time. In the leadup to the IO announcement, the client team dropped IE support in order to get wave ready for the demo. Dropping IE support was supposed to be temporary, but everybody was too busy to fix it. "Just tell people to install Chrome frame" was the regular excuse.
It was being worked on when wave was finally cancelled.
I think it's more the opposite: Do not use Java when you haven't achieved product/market fit yet. Because it will cost you, dearly, in iteration velocity. Go write your initial version in Python or Ruby or Lisp or something that lets you quickly try out new ideas, and once it starts creaking under load, then you rewrite it in Java or C++.
You've proven the GP's point -- don't use Java because the only people who know how to "use it" are 1% of programming experts that you probably don't have working for you.
I'll just leave this here (Dart - the new language from Google). http://webreflection.blogspot.com/2011/10/what-is-wrong-abou...
I think you're a little too trusting that every single Google programmer knows what they're doing.
Billions of successful projects run on Java.
I will give you billion dollars if you can prove that.
My personal guess (using my personal metrics) is that there are 10^3 to 10^4 successful Java projects and 10^9 failed ones.
Successful ones mean "You can succeed using this".
The failed ones mean "This failed, could have been for a ton of reasons".
This is a human nature. It's very hard to admit you just waisted your time.