Google Wave was really the spark that inspired me to "build a startup." With that said, it was a mess. It was a schizophrenic product that couldn't decide whether it was a developer platform or replacement for email. It had "everything" in the worst of ways.
It really was a Frankenstein; I distinctly remember threaded conversations that wouldn't collapse, weird and inconsistent results when contributing to the same "wave," and an interface that was honestly pretty awful (not to mention cramped on the screens of yesteryear). There's more: Google wanted to create a protocol but the tech was invite-only (???), it wanted to replace email but no one else adopted it. The whole thing made no sense.
But after watching the Google I/O talk, I was enthralled. I thought to myself "I bet I could build that!" And really, even if Google Wave failed horribly, it did contribute to the "real-time" web we all enjoy today.
The “key mistake” was that all of the technical parts were poorly architected and horribly buggy, and then they tried to scale up the user base using a massive amount of marketing hype before their product or infrastructure could handle the load. As a result all the hyped-up customers were confronted by a terrible user experience, felt burned, and left. Without a completely different technical implementation from top to bottom it was bound to fail irrespective of how their marketing team “positioned” it.
The UI was a GWT app written in Java and compiled to JavaScript which suffered from inexplicable UI hangs and all kinds of weird bugs in every corner case (it would e.g. get stuck in states requiring a page reload to fix).
The “communication protocol” was opaque binary blobs of GWT stuff wrapped up in Jabber/XMPP (XML) but without really using most Jabber features. Basically not a designed protocol at all, just the most ad-hoc thing slapped together overnight, with XMPP used as marketing (because that’s “open”).
The server was some closed source thing only hosted by Google.
The original marketing claim was that this was all “open” and “federated” but it was not possible to run a third-party server, and it was not possible to implement a different front-end since the whole thing was coupled tightly to the GWT front end they had.
The big innovation was supposed to be that some fancy “operational transformation” magic would merge different users’ diffs so that everything could be edited collaboratively in real time without conflicts and with minimal bandwidth, but in practice what that meant was they just sent the full content of every message on every keystroke (where “full content” here includes a massive amount of protocol overhead wrapping the messages) – maybe the fancy diff research stuff was intended for some future update that never made it.
The front end really started falling apart horribly (slowing down to the point of being unusable) under any kind of larger group, because it hadn’t been architected to keep up with the load. From what I remember it mostly worked with about 2–10 people communicating in a group, and became entirely unusable with 50+ in a group.
Disclaimer: I was never a Wave expert, just some guy who tried to read their docs and play with their technology and ended up laughing and sadly shaking my head all the way through, and it’s been a decade now. Some of my recollection could be slightly off.
Maybe the tech was bad, but the marketing was worse. I never even tried Wave, so didn’t experience the bugs and bad UI, because I could never understand what it was or what family of problems it was trying to address.
Agreed. In the modern app world, it's not enough to have great or useful tech, it has to be branded and communicated properly, not exactly Google's strong points.
Even worse, I was super excited about Wave and wanted to use it for a project - but I couldn't secure enough invites for the project team, so my trial never happened.
The operational transforms were integeated into Google Docs later for multi-person editing (the Wave team was merged into Google Docs), and it works quite well.
Positioned is the operative word here. Slack isn't positioned as a replacement for email. It might become that, it might even already be that to some, but nobody is buying a Slack subscription as part of a plan to turn off the Exchange server.
> It was a schizophrenic product that couldn't decide whether it was a developer platform or replacement for email.
In other words, it was Lotus Notes 2.0.
One of these days, someone's gotta make a Lotus Notes 3.0 that actually makes good on the original premise, without screwing it up by adding too much other stuff (like Lotus+IBM did) or by forgetting what the problem being solved is (like Google did.)
The original premise is pretty cool, once you see through to it. Notes did two important things:
1. Notes takes email message bodies and turns them into, essentially, the initial response-bodies of (gradually-enhanced) HTML5 web-applications. Each message body contains a common "program"—which may or may not require any bandwidth to deliver, depending on whether the receiving server already has other copies of it—and then, along with that program, it contains some initialization data customized for the recipient (like the initial response-body HTML in a gradually-enhanced webapp.) Your mail-reader becomes equivalent to a modern web browser (i.e. it's a zero-install application sandbox), except that there are no URLs—instead, you get pushed new pages [or new versions of pages] by other people, and then they stick around in your "cache" (your inbox) until you delete them.
2. Notes then gives those little email applets persistent "cloud" storage, in the form of Firebase-like synchronization to tiny per-applet databases that live on—or next to—the message author's IMAP server. (Notes' applet database server is called Domino, but it was essentially just Firebase's API backed by a bunch of BDB DB files on a disk—usually on the same machine that the IMAP mbox files were held on.)
Together, that meant that you had a federated, vendor-neutral method of composing little applications like straw polls of what to get for lunch, or interactive infographics with live source data. Each applet's program would travel around by regular email; and each applet's data would be canonically on the applet-author's mail-server, but would be synced with anyone any time they opened the applet message. And then, along with that, you also get federated, vendor-neutral, PKI-keypair-based ACLs giving identity to every read or write, enforced by the applet DB server, that applet authoring software could then turn into simple access control settings for each Firebase-like object type.
Wave took the whole distributed infrastructure of Notes and puts it into Google's cloud, but without any of the federated/vendor-neutral/client-synced stuff that was the whole point of the design. You got the same essential architecture (applets live inside messages; applets get shared cloud backend storage; the system syncs the state of "your" applets to local storage), but you no longer got any advantage from it: since you were talking to a cloud that could run arbitrary compute anyway, anyone in an enterprise who wanted to "author an applet" could just write (or rely on authoring software to generate) a little Google App Engine app, which would store its data in Google Cloud Datastore and use GSuite OAuth for login. All the same benefits, but now it's just a web-page. Open it in a tab, bookmark it, whatever. No need to push the app; just email people a link to it.
While the Apache Foundation hosts a lot of great projects, it also looks to me like a place where big projects go to die.
I'm thinking of the whole Apache Open-Office fiasco, among other things. Looking at their list of projects sorted by number of committers[0], event at the top I don't get the idea that most of those have a lot of momentum.
Do I just have a completely wrong impression? I'm curious if there's something to learn from this.
Projects in the wild die all the time, and the process is not necessarily neat and tidy.
At the ASF, projects must be actively retired, and there are a sequence of actions which must be taken to move the project into the "Attic". Retirement gives all stakeholders a defined close of business.
All software projects have a life cycle. What is notable about ASF projects is that the end of the life cycle is comparatively orderly.
I wish the Wave folks well as they move on to whatever's next for them.
You hear more about the ASF retiring projects because the ASF has a whole process around it that's publicized.
You don't hear too much about some one-man project that stops updating its GitHub all of a sudden. You hear about ASF projects dying becuase the ASF wants people to hear about it.
That projects site seems to give a particularly pessimistic view. I looked at the 'traffic server' project[1] (a web cache) and it says the last release was in 2012, but the real project website[2] shows there has been a steady stream of releases, the last one just a few weeks ago.
Yeah, no, your impression is correct. Apache is and always has been a bit of an open source graveyard.
There's counter-examples but even they have me worried. Airflow, originating from AirBNB, is now Apache Airflow: https://github.com/apache/incubator-airflow -- And I've been super hesitant to throw weight at it because of that, even though it looks actively maintained.
Airflow is extremely active — check the mailing list, Gitter chat, or even GitHub contributions. My company, Astronomer, also provides a hosted version of Airflow [1] if SaaS is more you're thing.
That's partially because of the ecosystem it plays in. Plenty of people who won't touch a Hadoop/Big Data ecosystem tool unless it has 'Apache' in front of it.
What you are seeing as "dying" is actually "widespread adoption and maturity", only you've moved on because you're "latest and greatest." Nothing wrong with that, but doesn't mean anything has died. Only your interest has.
That's definitely a good question, and one that I don't think is clearly addressed in the docs (so I might take the opportunity to turn this into a little blog post later). tl;dr - Airflow can support running multiple Python versions.
Here's a three-pronged answer:
1. PythonOperator - Assuming you're running Airflow on 3.6, you can run your 3.6 functions with the normal PythonOperator.
2. PythonVirtualenvOperator - Then, if upgrading your 2.7 code to 3.6 is an option, I would; if that's a hurdle... You can run multiple Python versions mixed using the PythonVirtualenvOperator [1] to run the other tasks in dedicated 2.7 etc virtual environments. That's pretty simple if it satisfies your requirements, but it's not a foolproof solution if your reason for being on 2.7 is complex or some system-level dependency that requires more.
3. DockerOperator - If the setup requires more complex things to be installed, you can use the DockerOperator [2] and build out a simple Python Docker image e.g., [3]. This is the method we use to run other languages like Scala and JavaScript via Airflow.
Feel free to reach out via email if you'd like to discuss more or have questions - taylor [at] astronomer.io. We like to help people get started with our Airflow and have written a bit of content for it.
I will check out the docker operator. I didn't want to drop down into the bash executor to run docker containers because it felt a little dirty.
My dev team is excited to use airflow but, in my estimation, keeping them all in lockstep with a single requirements.txt seems a little far fetched. ;)
Did Wave ever really live, though? I know it had its vocal fans for whatever reason, but most people never understood what it was, even if they had heard of it and tried to use it (like myself).
Wave was a layer that live on top of a modified Jabber/XMPP chat server. It sent extra meta data to your messaging client. Depending on your client and meta data sent your client could download JavaScipt applets you authorized. The applet would render the meta data into something like an iFrame to show a Google Document or a PacMan game. Also you could create a separate messaging thread from a single comment but still have a link to parent thread (ala #Slack now.)
The branching comments, embedded documents, and ability to create mini applets were the big selling points. But the feature were never well explained and internal implementation was a nightmare. As people could still hook in Jabber with client it was also creating issues with spamming and hacking.
The interesting bit of Wave wasn't the product but the underlying framework components they created for it e.g. salmon protocol and the pubsub system.
They made many of the components needed to create an open source federated social networking system where separate implementations could interact with each other. So for example your user on your company's twitter/fb hybrid could have threaded conversations with other users across other organisation's fb clones (obviously with access control).
This could have been exactly the killer functionality to topple centralised proprietary Twitter and Facebook. Google should have thrown everything into it, could have turned out as impactful as hypertext.
I've recently discovered Netbeans and I like it. It's currently the only Java IDE I can get running on aarch64. But I know what you're saying. The contributors that are left sound rather desperate for help.
That has a lot to do with the license. It should be more copyleft. Permissive licenses attract leeches who do nothing but complain to overworked contributors.
"Over the years, I've become convinced that the BSD license is great for code you don't care about" -- Linus Torvalds
People who aren't aware, this was the continuation of Google Wave, the real time collaboration tool that was, for a while, built into gmail, and then taken over by apache. https://en.wikipedia.org/wiki/Apache_Wave
Not just internally. I remember the massive hype around this being the "next email." I excitedly got as many of my friends onto there as I could.
I can't really pinpoint any one thing. There really was a mass of mistakes that all lead to this imploding heavily. I seem to recall that the fate of GWT was intertwined heavily with it. Very heavyweight widgets to support the general idea of massive collaboration in real time.
I suspect the killer is that "real time" portion. People love to talk about that. Few actually want it. (Fewer still need it.)
Pretty sure the biggest mistake was the same as Google Plus': the invite system that artificially hampers growth.
Since these platforms need to capture an entire network of people at the same time if there is something preventing someone from bringing all their friends/collegues in at the same time then it is doomed to fail.
Yeah, this worked fine for Gmail's early years because you can talk to people on other email systems. But Google tried to apply the same system to both Wave and Plus where the exclusivity made them comparatively useless.
I think they've learned the lesson by now at least, since their latest communication systems (Duo and Allo) had open signups. If those two fail it'll be because they were pointless (from a user perspective) entries into a crowded market of established players who already had network effect lock-in working them.
More than just the invite, I think they really soured a larger portion of their market than they thought.
The impression seemed to be that they would kill buzz/reader/wave, and the folks would just naturally turn to what they then offered. The reality seemed as much that many of us were unwilling to try anything else from them until it was clear it was good and going to stick around.
I've said this before, but while I know for a lot of people Reader is the axed Google product they miss most, for me it will always be Wave. I know a lot of people didn't get it, and I can't blame them, but I was part of a six-person software team using Wave for a brief project and, despite its faults, it was the greatest communication tool any of us had ever used, and remains so to this day. Slack/Discord/Teams/Trello/whatever still don't come close.
(Which makes it all the more appropriately ironic that it had a bunch of Firefly references and easter eggs inside. It's like they knew.)
- That communication could be both synchronous (like chat) and asynchronous (like email) and you could use whichever worked best for you at the time. You could even switch in the middle of a thread- maybe it stared out asynchronous, but then both people were online and decided to have a conversation.
- Threads were a better way of breaking up topics than channels
- The ability to post a document and then have people comment on it let you basically incorporate Google Docs-style document revision into your chat application, but like the other comment says, the comments were a first-class citizen of the interface, rather than bubbles that are totally out of context
- I like real-time chats, where you could see the individual characters the other person was typing. This, admittedly, is an aesthetic preference I know not everyone shares.
Some people hated real-time typing, but it made interactions feel even more immediate than Slack.
I also like that comments were a first-class citizen; part of the document. You could have an in-line conversation about a paragraph, then distill the results into the text and delete the conversation. Comments weren't another "mode" like they are in Google Docs; they were just document bubbles nested in a parent document bubble.
I've apparently flip-flopped on this; looking at a post I wrote at the time, I thought it felt wrong to delete comments.
I used Wave along with a group of friends when it first came out often. I also setup WIAB which was almost usable but never was as 'smooth' as the google hosted Wave.
what was smooth you ask? I never had issues, I even played people in some of the games they had to great enjoyment (was never able to get this on my WIAB)
I joined Apache Wave with great excitement when it first was accepted and yet disappointed in my inability to contribute. I am not a software engineer but I tried multiple times with different IDs and the response was (paraphrasing) go check this site and pick something to work on.
as the years went on multiple attempts were made to retire Apache Wave with last minute efforts by multiple people trying to keep it going. I knew this day would come and it is still sad to see.
I am not sure if there was a better 'onboarding' for noobs available if I would have done much but I think many open source projects may fair better if their barrier to entry for them were clearer
Wave was highly ambitious, but under resourced with a horribly botched rollout. It could have killed Twitter, Facebook, and preempted Slack, or better shifted them to a common open source framework which would have allowed a thousand twitters and fbs to bloom and interact. Real shame that OStatus couldn't get traction.
Since they came from there originally, I doubt they'd end up back at Google Cloud. Maybe AWS? I just hope they don't get sent to, well, the bad place.. Azure..
Wave helped sour me to hyped ideas. Reader made me bitter to even attempted google+. To the point that i forget google+ still exists quite commonly. I almost feel guilty that I don't know more about it.
Yes, that's true. But even at the time Google had a reputation for throwing a lot of stuff out there and then pulling the rug out from under them if they did not develop traction fast enough and a thing like Wave did not look like it would be a fast grower. So I told myself I'd really get into it if it lasted 5 years. This 'try to not be first' attitude has definitely cost me some opportunities over the years but it has also saved me betting on horses that ended up as also-rans many times.
I've got different kind of annecdote that I need to share now that the thing got retired.
I missed the entire wave thing. Don't know how or why. But I just missed it. And I never ever miss these kind of things. My job at the time was consulting and advising startups and I just looked silly when "wave" came up in a meeting and I had no idea what it was.
I remember the CEO saying "You didn't see the video of the developers cheering with their laptops above their head?" ... which I did not.
It's one of those things that comes back to haunt me when I can't sleep. You know, one of those awkward social interactions that nobody but yourself remembers.
For the below-25 crowd email is quite dead : they only read it when asked via proper chat or “social” channels, and send one as last resort. For the older gen email is near dead due to spam. In few years it will be new telefax.
People have been claiming that email is dying since the mid-90s. And here we are, with the only messaging protocol that's available to everyone on the internet: email.
I believe you can take space from email like these messenger apps for the mobile phone but to say that's dead or going to die I think it's a mistake to make this type of statement.
Try to enroll in these social media networks without an email, they require you to have an email, try to enrol anywhere they ask you for an email confirmation. Email is not dying it's just changing the purpose.
I don't see that, only if you're talking to a kid maybe. But everyone still has emails, I think WhatsApp and Facebook Messenger did gain space on communications taking space from email in daily usage but email still has its space, ask anyone if they have email.
I remember it for the amount of demos that went wrong. It takes courage or desperation to demonstrate a project in that state.
Also, somewhere in there is a quote by the project lead that I still remember today, something like this: "There aren't many companies that can afford to mess up a demo. [pause] We're not one of them." The last part sounded like a panicked attempt to backpedal on what he just said.
Why don't apache update web interface.
It's just not fun anymore, I get all retrograde feel to it, but in 2018 it's plain annoyingly ugly and hard to understand what's going on on the page.
Google Wave didn't fall, it inspired me and many more for ambitious thinking. Its tech was adopted by other products. It changed something intangible and inherent to tech.
Didn't this start out as EtherPad? I remember that being an eye-catching demo of a way to collaborate on documents over the web. How/where did that go wrong?
My organisation desperately wanted to use this, but since invites were limited and rolled out slowly, we couldn't, since you can't have half of the org using a collaboration tool like this. So the initial buzz about this was killed quickly when no-one could use it for any serious work, then once it was generally available, people had lost interest. Google has a habit of botching roll-outs like this.
Google Docs in its current form has a lot of features that were in Wave, and people seem to like and use that.
It really was a Frankenstein; I distinctly remember threaded conversations that wouldn't collapse, weird and inconsistent results when contributing to the same "wave," and an interface that was honestly pretty awful (not to mention cramped on the screens of yesteryear). There's more: Google wanted to create a protocol but the tech was invite-only (???), it wanted to replace email but no one else adopted it. The whole thing made no sense.
But after watching the Google I/O talk, I was enthralled. I thought to myself "I bet I could build that!" And really, even if Google Wave failed horribly, it did contribute to the "real-time" web we all enjoy today.