Exceptions (2003) - <AUTHOR> http://www.joelonsoftware.com/items/2003/10/13.html

<comment><USER3> Everyone here seems to agree that "exceptions are for exceptional conditions". The problem is that when you get down to details, there is disagreement about what exactly is an "exceptional condition".

e.g. - you are trying to open a file for reading. The file does not exist. Is this exceptional? That depends on context, but the function that opens the file, being in an independent library, is usually designed without this context.

If it does throw an exception, some people complain that "of course it'e expected that file won't be there sometimes! that's not exceptional".

If it doesn't throw an exception, some people complain that "we tried to open a file, but didn't succeed, of course that's an exception". But if you want to avoid an exception in this case, you'll need to check for existence before opening (LBYL "look-before-you-leap"), and get into a race condition (TOCTOU "time-of-check,time-of-use"), which is really bad.

So it very often happens that you are forced by your ecosystem to use exceptions for normal control flow. Claims that you can only use it for "exceptional / unexpected" tend to be incompatible with a project in which you do not develop/control all of the library you use to your strict standard of exceptionalness.

<comment><USER4> Vague value judgments ("only for exceptional conditions") are the inevitable result of a failure to reason.

The semantic function of exceptions is just a way for summing additional values onto the return type of a function because it has results that are not contained within the primary type. In this way, they are a more general and better typed version of NULL (which has it's places - contrary to the modern dogma, these sort of features are needed due to inherent complexity). The standard ways of attempting to avoid this are to either use sentinel values that exist in your standard return type like fd == -1 for an error (thereby making your program less typed), or to create a top-level sum type for every aggregated function return type (cluttering your program with nominal types). Multiple values make the most sense, but those are ad-hoc _product_ types, so you're eschewing the type system in favor of informal invariants.

The syntactic function of exceptions is to avoid constantly repeating (check for error, return error), which often leads to the poor practices of ignoring errors or calling a global exit(). One goal of programming languages is to automate, so it makes sense to capture this oft-repeated pattern. But problems arise when people end up forgetting that every function can have a possible return immediately following it.

It seems some syntactic middleground is needed to signal the complete return type of a function definition, and the possibility that a given function call may quick-return. Honestly (and I hate to say it), but Java probably started down the right track with checked exceptions, but being a B&D language it ended up being waaaay too verbose. And lacking a way to aggregate types along anything but the baked-in hierarchy, people fell into using generic and uninformative 'throws Exception'. And open types make it so there's little point trying to enumerate exhaustive causes. But that doesn't mean that one can't start with the idea of non-silent but syntactically lightweight exceptions and come up with something that avoids a lot of the pitfalls.

<comment><USER5> I'm really fond of the idea of Nullable types (where you have to unwrap them by checking if they're null or errors to get the value). I don't think any non-functional language other than Rust has attempted to work this into the way they work yet, but it strikes me as a powerful mechanism that could also allow for deferring error handling to the site most capable of dealing with it.

<comment><USER6> Scala has the Try [0] and Either [1] types that can be used to achieve this. However, I believe Scala also allows any type to be NULL. In Rust there is no NULL so you don't have to worry if a value is ever NULL unless it is explicitly wrapped in an option instance.

[0] [http://www.scala- lang.org/api/current/index.html#scala.util....](http://www.scala- lang.org/api/current/index.html#scala.util.Try) [1] [http://www.scala- lang.org/api/current/index.html#scala.util....](http://www.scala- lang.org/api/current/index.html#scala.util.Either)

</comment></comment></comment></comment><comment><USER7> I think Common Lisp has a good approach with its restarts system. I try to write something to a file but there is not a enough disk space? How about telling the user, then invoking a restart when the user says, "There is more space available!" and continuing execution as if nothing went wrong? The problem with exceptions is that there is no way to recover from them in most languages, because the exception handler is found by unwinding the stack.

What I do not like about the "check return values" approach is:

1\. It means that client code must understand how to handle error conditions. No disk space? Well whoever called the top-level function that invoked _write_ needs to figure out what to do if there is any chance of recovery. It is a maintenance headache that can quickly accumulate bugs.

2\. In both Java and C++ there are functions that cannot return values: constructors, and in C++ destructors. No, it is not acceptable for a program to crash just because a constructor call failed. No, it is not any better to have every class have a special variable that indicates that the constructor failed. No, having empty constructors is not the answer, and it is certainly not going to help with destructor calls (the C++ standard library actually requires some destructors to silently fail because of the issues with error reporting).

<comment><USER8> Restarts are perfect! This bothered me greatly when I read Code Complete. It doesn't discuss error handlers (which restarts are a form of) in error handling chapter at all.

I really wish more people knew about this option. Maybe it would even get into mainstream languages.

</comment></comment><comment><USER9> Exactly fits the philosophy of Google Go - [http://blog.golang.org/error- handling-and-go](http://blog.golang.org/error-handling-and-go)

I think his point of there being easy syntax for multiple returns is critically important to make this sort of error handling non annoying - <USER2> Go does remarkably well.

I think this factor has a lot to contribute to the fact that you get the warm fuzzy feeling after your code compiles. You feel confident that you have already handled all the error cases (that you care about) in your code.

EDIT - Obligatory nitpick accepted. ;)

<comment><USER10> <nitpick type="obligatory">The name of the language is Go, not "Google Golang"</nitpick>

That said, this was, for me, the single weirdest thing to get used to when starting to program in Go, coming from a mostly Python/Java exception-style background. (I imagine it's easier if you're a C programmer).

However, once I got into the swing of it, I realized I really, really like Go's error handling, and I can't imagine going back to Python's exceptions voluntarily. Returning errors makes code much more readable, and it also reduces the risk of code suddenly failing because of an exception that got thrown somewhere that you can't even find easily.

Go also gets a more subtle point correct: errors are _interfaces_ , not types, which means that you can use any type as an error, as long as it supports the "Error() string" method. This is irrelevant 99% of the time, but I've seen a few pieces of code which utilize this feature very effectively.

<comment><USER11> I have to say, I much prefer people referring to it as Golang, otherwise it is impossible to search for.

<comment><USER12> this is honestly the most annoying thing about go for me. Really hard to do a quick google search for an answer to something!

<comment><USER13> Try "Django" with that new "Django Unchained" movie ;-)

<comment><USER14> For all these language issues, I generally preface the query with the language name. "Python3 Django", "Haskell Quickcheck", "C++ Boost", etc. It makes things so much easier for the search engine to give me Good Results (tm) when it has that extra bit of context.

</comment></comment></comment></comment></comment></comment><comment><USER15> The discussion around that time was interesting (though distributed around the blogosphere); Ned Batchelder had recently argued the opposite (and updated the argument specifically to take Joel's article into account)[0][1]. It was at about that same time that Damien Katz was becoming firmly convinced that Erlang and crash-only behaviour would be the way to go in designing CouchDB[2][3]. (Both Damien and Ned were at Iris/Lotus working on Notes and Domino, and I was a Domino dev at the time.)

[0] [http://nedbatchelder.com/blog/200310/joel_on_exceptions.html](http://nedbatchelder.com/blog/200310/joel_on_exceptions.html) [1] [http://nedbatchelder.com/text/exceptions-vs- status.html](http://nedbatchelder.com/text/exceptions-vs-status.html) [2] [http://damienkatz.net/2004/08/crash-only- software.html](http://damienkatz.net/2004/08/crash-only-software.html) [3] [http://damienkatz.net/2004/09/crash-only-software- revisited....](http://damienkatz.net/2004/09/crash-only-software- revisited.html)

</comment><comment><USER16> If you're catching exceptions all over the place, or worse using them for flow control as part of normal operations, you're doing it wrong. Exceptions should indicate a major error that you can't easily recover from and as such should be caught and logged at the top of the stack, i.e. the main thread run method or request handler.

When used that way, they give you very useful information as to what went wrong and where, while making your program more robust and resilient to errors. We've found this to be the case time after time at [https://starthq.com](https://starthq.com), which runs on Node but uses fibers via [https://github.com/olegp/common-node](https://github.com/olegp/common- node).

<comment><USER7> "Exceptions should indicate a major error that you can't easily recover from"

Maybe in Java and C++, but in Common Lisp we have _restarts_ that allow you to recover from an exception. I like to use the example of attempting to write to a file when the disk is full, because:

1\. It is possible to recover from the exception (e.g. ask the user to delete some files)

2\. It makes no sense for the I/O library to do _all_ the things needed to recover

3\. It is a maintenance headache for client code to do _all_ the things needed to recover

With restarts things would look like this: the I/O library would set up a restart for _write_ that would retry the operation, the client code would catch the exception, prompt the user to free some space, and when the user indicates the space is free the restart is invoked. The I/O library knows the right way to restart the operation, and client code knows whether or not that should happen, and you get code that does not just quit over a disk being full.

</comment></comment><comment><USER17> I am not a huge fan of exceptions per se, but it's important to understand that they are a heuristic for minimizing 'worry' about things that are unlikely. I am not saying it's a good thing, I am saying it's the way people naturally work.

Let's say there is a function that's 20 lines long, and if you did a thorough analysis of possible error conditions, regardless of likelihood, you might come up with 50 or more.

We are not going to write code to address all 50 possibilities from the start. Instead, we are going _de facto_ to wait and see what fails in the real world, and address them as we discover them, because we value our time. We make an economic distinction between a 1-in-1,000 problem, and a 1-in-1,000,000,000 problem.

Is this un-robust? Yes. Are we allowing exceptions to be a control-flow catch- all? Yes. Would a Go-like approach of simply returning error conditions reduce bugs? Probably. But it's important to recognize programmers' 'revealed preference' for exceptions.

<comment><USER18> 50 error conditions in a 20-line function doesn't really sound even remotely realistic. Probably only 5 of the 20 lines are actually calling functions that might return errors, and in most cases, we don't care what _type_ of error is being returned.

So if we're talking about 5 error-checks in 20 lines, then yes, we _absolutely should write code to address them from the start_.

I mean, I can understand not dealing with errors from memory allocation failing, or even possibly failure to write bytes to disk, depending on the situation (e.g., if those fail, you've got bigger problems to worry about than your error handling -- and it's not like exceptions are probably helping you to recover anyways).

But for stuff like network communication, writing to databases, etc., you had definitely better be addressing all error possibilities from the start, because these things fail _all the time_.

<comment><USER19> Nonsense.

Is the network up?

Is the connection to SQL up?

Did someone just turn off the SQL machine half way through the query?

Can we find the server?

Are there any rows?

Did the SQL compile?

Do I have rights on this table?

Have you just terminated me as a result of a deadlock?

Did you return a Null when I was expecting a value?

Did you return a float when I was expecting an int?

Did my value just overflow?

Did you just return 0 and I tried to use it in division?

Did I just try to access the session but some other idiot clear it?

Did I just try to call a method on an object that is in fact null?

And that's all possible in a three liner off the top of my head. I'm sure there's plenty more than that that are possible! I didn't even start on the file ones...

<comment><USER20> Functions should be scoped appropriately so that they only deal with one thing at a time. A function that checks for network connectivity isn't going to be checking for missing rows. Those are different problems, and should be handled by different functions.

Using your example, we have a function that queries a database. It will be given a valid database connection, and return the result of the query.

There is no "valid database connection" logic, since that is handled elsewhere. There is no result validation logic, since that is handled upstream. This function only cares about A) querying and B) returning a value (possibly null). The only exceptions that is handles is when something specific to it's domain goes wrong - for example, unauthorized access to a table. That is an error that is above networking (the connection worked fine) but clearly not a data validation problem (no data), so we handle the exception here.

If you find yourself throwing exceptions "across problem domains", that's a good indicator that your functions are doing too much.

<comment><USER21> You can't just assume that a valid database connection will remain valid the entire time you're using it. The network or server is free to go down at any time. In practice, this rarely happens, it's an exceptional condition. Exceptions are the best way to model these kind of errors.

<comment><USER20> Sure, but the query goes through the layer of functions that actually deals with the database connection. If an error occurs, that layer is responsible and the "higher" layers simply pass on the exception that is thrown.

Point is: the function that deals with database response should never be responsible for dealing with database connection errors.

</comment></comment></comment></comment></comment></comment><comment><USER22> This is a problem of architecture. Should you mix error handling with application logic? You have to handle errors somewhere, but they pollute the otherwise clean problem-solving code. One solution is to just let the exceptions bubble up and the other is to handle them immediately. If you let them bubble up, you can have a separate module that can do the right thing, notify the user, restart the app or something else. This way, the error handling is somewhat cleanly separated into its own thing. Sometimes you want to handle errors immediately, because only the code where the exception happens, knows how to deal with it. This is where return codes might be better. A lot of it depends on the desired behaviour. Sometimes you want the software to immediately exit or restart if there is a critical exception, sometimes you can safely ignore errors if real-time experience is more important. Sometimes all you want is to log the exception and/or notify the user. Does anyone have experience with aspect-oriented programming and does it help solve any of these problems?

</comment><comment><USER23> "Monday, October 13, 2003" \- more like "the old new GOTO"; but apart from the out-of-the-blue rant about PHP (version 4, I guess?) at the bottom, this still seems applicable.

<comment><USER24> His argument is really against using exceptions as part of normal operation, which I agree with. I've noticed when writing plugins to big monolithic programs like 3DS Max and game engines that these tend to throw and catch exceptions as a matter of course, which is a pain when you're trying to debug your own plugin code.

An exception _should_ mean "normal operation cannot continue", and should signify a bug in your code. As such, it is an exceptionally good software development tool.

<comment><USER25> I got a question. Do you think it's okay use exceptions to end what would be otherwise an infinite loop? Python example:

      data = ""
      socket.settimeout(1.5)
      while 1:
        try:
          data += socket.recv(1024)
        except Exception,e:
          store_data(data)
          break

If this is not okay, what would you change?

(And yes, I know there are edge'ish cases were I'd miss some data here)

<comment><USER26> This is NOT OK. You're swallowing all exceptions and assuming that they are your special case.

The fix is to have a specific nonambiguous name for your exception, so that other error conditions still work properly. As examples consider the StopIteration and GeneratorExit exceptions from Python's standard library. (See [http://docs.python.org/2/library/exceptions.html](http://docs.python.org/2/library/exceptions.html) for a list of built-in exceptions.)

</comment></comment></comment></comment><comment><USER27> I think there is reasonable consensus about some software engineering best practices:

1\. Avoid action-at-a-distance and side-effects that are hard to reason about.

2\. Use immutable objects and values rather than references and pointers.

3\. Avoid intricate control flow with many branches.

4\. Greater isolation of processes/threads (actor model).

5\. Use systems and platforms with simple and strong guarantees (e.g. ACID) that are easy to reason about. Special cases and nuances to the underlying platform should be avoided.

6\. Use tools with good support for static analysis (e.g. a good type system with a compiler that can understand it).

Exceptions seem to violate #1, #3, and #6.

These rules only apply to software engineering; that is, the reliability, robustness, long-term maintainability, and total project development cost (including maintenance and support).

Of course, there are other considerations, such as: performance, the time to achieve the minimum viable product, how much developers like the tools, how "hackable" it is, or utility for research purposes. These other concerns may be a good reason to violate the above rules.

</comment><comment><USER28> Sure, exceptions are bad most of the time. But sometimes they are really useful, like in heavily recursive code, i.e. recursive parsers. Catching exceptions in a single top level function and throwing in every other one makes code much cleaner, since you don't have to propagate and handle errors on every function call and you have single exit point on top level function anyway.

</comment><comment><USER29> I don't use exceptions for normal flow. I use them for errors.

While it is true that exceptions create innumerable code paths through a function, RAII makes that manageable. If you're not taking advantage of RAII in your C++ code, you might as well be writing C code.

</comment><comment><USER30> The advantage of exceptions is the ability to pass back the error and make mandatory dealing it (even if ignoring).

Exist a way to have both styles, cleanly?

I have thinking in how could look a language where objects, like in UNIX pipes, have stdout & stderr, and if stderr is consumed (returning codes) the exception is handled, but if stderr is not consumed, then raise it?

</comment><comment><USER31> _> [as an alternative to exceptions] "It is true that what should be a simple 3 line program often blossoms to 48 lines when you put in good error checking, but that's life _

Was he being serious? I'd rather not wade through all that error checking cruft to see normal flow. Exceptions (or goto) don't create buggy hard to read programs, people do.

<comment><USER18> Except that error handling _is_ part of normal flow.

Wishing it wasn't, or just laziness, leads to bugs. It's not cruft, it's integral. That's the whole point.

<comment><USER31> I disagree. Building an error checking scaffolding around every possible and unlikely error obscures the expected flow of control. If I checked for every possible error condition before I started the engine of my car in the morning it would take me an hour to get out of the driveway. I'd much rather have the car tell me when something was wrong and not start. If the system you are using already throws exceptions, you might as well use them too.

</comment></comment></comment><comment><USER32> Some Haskellers treat exceptions as something that you only use if the program has entered an unrecoverable condition and needs to crash.

<comment><USER33> I don't find this true at all. Haskell exceptions don't look like exceptions in other languages, so it's easy to get hung up on the fact that _error_ is generally used only for unrecoverable errors. But that's why it's called _error_ , not _exception_. In Haskell, Either and Maybe are used where I would normally use try/except in Python.

The only exception to this that I've found is that error is something you may need to deal with in the IO monad, where in Python it would still be handled via exceptions.

<comment><USER32> Well, I didn't think of Maybe and Either as exceptions, but rather considered undefined/error. The exceptions from Control.Exception are probably the closest to exceptions in other languages, and I think those are built on error.

</comment></comment></comment><comment><USER34> Most of the discussion about exceptions tries to think about it in abstract terms, which doesn't work. The point of exceptions is a very concrete one: often the code that runs into an error and the code that handles it are separated by ten levels of function calls. Without exceptions, the logic for detecting and passing on the error has to be duplicated in every function in every one of those levels.

Exceptions are arguably the one feature of C++ that isn't just syntax sugar over C, the one feature that makes the language fundamentally more expressive: they reduce a certain kind of code complexity from O(N) to O(1).

</comment><comment><USER35> Forcing a function call to handle an exceptional condition when it doesn't know how doesn't really add anything but bloat to your source code (violating DRY). It's interesting the author mentions goto, because without exceptions goto is often the most reasonable but more error prone way to handle cleanup. C++ solves this using RAII, if you need something to run before the end of the scope, stick it in a destructor. This is very easy and far more composable.

</comment><comment><USER36> While I'm not familiar with the Erlang paradigm that inspires it, the dire[1] library in Clojure is designed to decomplect error handling from code that may generate an error. I like this approach a lot.

[1]: [https://github.com/MichaelDrogalis/dire](https://github.com/MichaelDrogalis/dire)

</comment><comment><USER37> > This is ugly and annoying but it's better than getting magic unexpected > gotos sprinkled throughout your code at unpredictable places.

The proper analogy would be not GOTO, but COMEFROM, no? A catch block is basically a COMEFROM. :)

</comment><comment><USER38> [http://nodejsreactions.tumblr.com/post/59877403633](http://nodejsreactions.tumblr.com/post/59877403633)

</comment><comment><USER39> As a side note, at least in Objective C, blocks are a great way to return multiple values (including errors) and deal with them immedately.

</comment><comment><USER40> You can make methods easily return multiple values in C# with Tuples. They are very handy.

<comment><USER41> For extremely low values of "easily". C#'s lack of pattern matching and tuple syntax makes dealing with tuples in C# a complete pain in the ass. It's ugly, annoying, code, in general.

P.S. You can do this in pretty much any language. Just define pair, triplet, etc.

</comment></comment><comment><USER42> This old gem, huh?</comment>


AH: Did applications ruin Facebook? - <AUTHOR>

Here is my take: I used to really enjoy FB.  It was a fantastic way to connect with friends - simple and easy.  Once they began to introduce applications, everything got much more complex and cluttered.  I am not some luddite - this is Hacker News after all.
I think connect is a solid step in the right direction, but the applications have to go.
Your thoughts? <comment><USER2> I liked apps when I could put them anywhere on my front page and have fine- grained control over their access to my information.

When apps were demoted to a 2nd tab, and access control became "all or nothing", I basically stopped using them.

</comment><comment><USER3> You're absolutely right, the original apps implementation totally blew up in their faces.

Through regular redesigns, they've slowly been clawing their way back to decency. The twitterification' that has banished apps from your wall page was a nice step, but the further emphasis on the news feed (which I don't use, but others seem to intensely) makes the quiz bullshit prominent.

From their actions, the people in charge at Facebook seem to know how much apps have shit all over them. I think they'll continue to recover from it.

</comment><comment><USER4> I detest seeing friends' quiz notifications in my Facebook feed, so I block each quiz as I see it, have had to unfriend one friend who seemed to post nothing else, and continually post links to all my friends about how nefarious Facebook quizzes are. That helps all my smarter friends learn to spread the word to their friend networks about how uncool it is to take Facebook quizzes.

The latest concern is all those nasty ads on Facebook.

<http://www.allfacebook.com/2009/07/facebook-ad-endorsements/>

<comment><USER5> I hate the notifications, too, so I've set my feed to show status updates only by default. Occasionally, I'll switch to the links or notes view to see what's trickling around, since I usually miss these in news feed mode anyway.

</comment></comment><comment><USER6> i think chatting is complicated on face book caus even though my friends are on line and both of us try to chat togther but its imposibble and my laptop isent crap i have tried it on many coputers my friend to</comment>


Barnes & Noble Challenges eBook Price-Fixing Settlement - <AUTHOR> http://arstechnica.com/tech-policy/2012/06/barnes-noble-claims-price-fixing-settlement-will-raise-e-book-prices/

<comment><AUTHOR> There are two major flaws in Barnes & Noble's complaint.

First, they ignore the existence of Kobo (now owned by Rakuten, the "Amazon of Japan" who also owns buy.com) and other significant competition for Amazon besides themselves and Apple.

Second, at the time of Amazon's supposed monopoly, Amazon's only long-run competition was Sony. Nook had just launched and the other major players (Kobo, Google, Apple) were in the process of launching. With the exception of Apple their decision to launch was unrelated to the agency model.</comment>


The first real algebra game - <AUTHOR> http://dragonboxapp.com/

<comment><USER2> Funny, will test it with my nephew!</comment>


Coolest jobs in tech (literally): running a South Pole data center - <AUTHOR> http://arstechnica.com/business/coolest-jobs-in-tech/2012/04/coolest-jobs-in-tech-literally-running-a-south-pole-data-center.ars <comment><USER2> I think we'll see a lot of remote supercomputers in the future. For applications where bandwidth or latency aren't critical this makes a lot of sense.

Iceland is another great example of this. I recently visited there and they have a huge surplus of energy. They have heated sidewalks, everyone heats their houses 24/7 and they're still only using some tiny fraction of their natural geothermal energy (I think around 2%).

If I had to build a supercomputer for long-running computations, I'd build it there.

</comment><comment><USER3> With the contract switching from Raytheon to Lockheed, the general NSF support contract should have a bunch of IT positions opening up next research season, I'd think.

</comment><comment><USER4> I wonder if there is any need for software engineers down there to support the scientific teams?

I'm not a sys admin but I wouldn't mind doing a tour just for the experience.

<comment><USER5> I worked down there with IceCube. We had a few programmers in the project, but it was very competitive to get a slot at the Pole. Most of the people sent down were for physical drilling operations. I went down to do data acquisition software. IceCube is done with construction, so they don't need to send people any more. If you don't go with a science project, the other option is Raytheon Polar Services. Raytheon, however, pays their workers almost nothing because they know that people want to travel there. There were bus drivers with Ph.D.'s. The cook was a gourmet chef.

</comment></comment><comment><USER6> A friend of mine works there since 2006. They don't get enough press in my opinion, but the topic is not suitable for mass media.

</comment><comment><USER7> Anyone know of some other remote locations looking for computer engineers / sys admins that might be a little warmer?

</comment><comment><USER8> I worked for Steve Barnet while at SSEC (<http://www.ssec.wisc.edu>). Working for him is about as awesome as working at the South Pole.

</comment><comment><USER9> <http://aq.indeed.com/>

[http://aq.indeed.com/jobs?q=%3C%3E&l=Antarctica](http://aq.indeed.com/jobs?q=%3C%3E&l=Antarctica) \- 136 jobs in Antarctica!</comment>


100 prisoners problem - <AUTHOR> https://en.wikipedia.org/wiki/100_prisoners_problem <comment><USER2> Since wikipedia doesn't explain why it works (or maybe I just didn't understand it), I found this explanation much better: [http://datagenetics.com/blog/december42014/index.html](http://datagenetics.com/blog/december42014/index.html)

<comment><USER3> This is a great explanation.

Is this problem useful for anything? I've seen multiple variations of these prisoner problems now, and I can never remember any being useful in other contexts.

<comment><USER4> Well, first of all it's a puzzle so it's useful as something fun to think about. Math is kinda like science though, you never know exactly how or if a particular discovery will be useful. In this case maybe you could find some graph traversal scenario where this would be applicable. In the Wikipedia article under variants they mention

> If the number of team members and the fraction of boxes which are opened is > fixed, the winning probability stays strictly larger than zero when more > empty boxes are added

Replace boxes with nodes and now you have some math to determine graph traversals. Maybe a bit more math and you can expand it for multiple paths. I don't know though, I'm not a mathematician and I don't normally have to do more than DFS and BFS in coding interviews, but sure I can see some way that this might be useful.

</comment></comment></comment><comment><USER5> Right, so picking a box at random and following the chain would be bad because you could get back to where you started having not found your number. Starting with your own numbered box is your defense against this because to go back to where you started you would have to have found your number.

<comment><USER6> This was my aha moment.

I was thinking, the solution presented seemed not only invalid but ill- defined, as you could hit a cycle and still have picks left. With this, it totally makes sense why it works: _if_ there are disjoint cycles, this strategy guarantees that _each prisoner is on its own cycle_. And I guess the math works out that in unidirected graphs of 100 nodes, 30% of them contain only disjoint cycles of 50 or fewer nodes.

<comment><USER7> Because of the way that the problem is set up (each of the 100 numbers is in one of the 100 lockers), it can _always_ be written as a list of disjoint cycles (mathematically: every permutation can be written as a product of disjoint cycles).

So, by starting in your own locker, you will eventually end up finding your own number. The only constraint is that everyone has to do it in 50 tries or less, i.e. there's no cycle of length >50.

</comment></comment></comment><comment><USER8> I'm confused...

"Before the first prisoner enters the room, the prisoners may discuss strategy—but may not communicate once the first prisoner enters to look in the drawers."

And, in the example given, "That prisoners 5 to 8 will also find their numbers can also be derived from the information gained by the first three prisoners."

There's never any explanation of what happens when a prisoner opens a drawer and finds it empty. In the first example given, what happens when prisoner 5 goes in and there's nothing in drawer 5? The algorithm doesn't seem to account for this.

It seems like there's some sort of assumption that the later prisoners are gathering information from the earlier prisoners, but the problem set-up seems to preclude this? They're going into a room so they can't watch each other, the drawers are closed afterwards so they can't derive information from which drawers are open/closed, and they're not allowed to communicate.

Am I not following something?

<comment><USER8> Two things:

1) You don't take your number when you find it. I guess my brain assumed "find" meant "find and take with you to prove you found it." Perhaps a better term might be "encounter."

2) Here's a much better explanation (thanks micaeked): [http://datagenetics.com/blog/december42014/index.html](http://datagenetics.com/blog/december42014/index.html). Essentially, the algorithm works because following numbers to drawers will eventually create a loop (e.g., drawer 2 points to 4 points to 6 points to 2). By starting with the drawer with your number, you're guaranteed to be in a loop with your number. The only question is whether your loop is less than 50 drawers long...

Furthermore, this confirms that there IS no transfer of information from previous prisoners in any way.

<comment><USER9> Can you explain to me why it is guaranteed you will be in a loop with your number?

<comment><USER10> To try a simpler explanation:

1) You will be in _a_ loop (by a property of how permutations and hashing work).

2) Using the algorithm in the solution, you always go to the box indicated by the number in the drawer you open.

So if you start with "your" number's drawer, that it is "pointed to" by the drawer with your number in it. So your number is part of that loop.

<comment><USER6> * Thus you will never be in some other loop. Loops are disjoint. Disjoint circles, not train tracks that interconnect. Just loops. Think about that and realize it.

* This strategy guarantees you'll be in _your_ loop. ("Unfortunately" you'll be at the _end_ of that loop: the box that points to your number. But still, in the loop, which is the point).

* Thus if there are multiple loops, all of length 50 or less, you'll get your number before your number is up.

* And math shows that if there are 100 nodes in a randomly unidirected graph, 30% of them contain no loops greater than length 50.

So if everyone follows this strategy, 30% chance they'll win.

</comment></comment></comment></comment></comment><comment><USER11> My favorite version of this is the one that shows one prisoner to make a single swap of two drawers' contents in order to improve their chances. Surprisingly, this allows for a 100% success rate.

<comment><USER12> Doe the "hacker" get to see all the contents? Or only 50 (half?)

If the hacker needs to break the longest permutation in half (consider the simple permutation x->(x+1), they could ... swap box 0 with box 50, so box 0 points to 51 (->52 .. -> 99 -> 0) and box 50 points to box 1. That makes 2 cycles of size 50, but requires inspecting 50+1 boxes

<comment><USER13> That's an interesting follow up question. What is the minimum number of boxes the hacker/spy/secret agent needs to see to guarantee success?

</comment></comment></comment><comment><USER14> What does the prisoner do if she gets to, for example, box 40 and there is a 40 in the box?

[edit] I reread the explanation and get it now. Only 1 prisoner (40) will actually get to open box 40. I was trying to think of this from the point of view of implementing it in code. I guess the cycle stops when a prisoner finds their own number or reaches 50 attempts.

<comment><USER15> Why would they have gone to box 40 in the first place had they not gotten a number 40 from elsewhere?

</comment></comment><comment><USER16> I still doubt the Monty Hall problem (mentioned in the wiki-article). I understand the reasoning, summing the probability tree, but there are two ways to build the probability tree, with the step of reveal or without. Since the player doesn't know that step, why would it be part of the tree? Because we know the setup a priori, in a way.

I'm assuming the bigger tree is still incomplete. More levels can be inserted, reflecting the reasoning of the a priori knowledge. I assume the supposed advantage would thus prove to be imaginary. Or in simpler terms:

Normally the tree would have the sequence in the following order: box distribution, choose a box, reveal one empty box, switch choice or don't.

However, if you are predetermined to switch, then the order would be changed to switch before the reveal. Thereby, the reveal is irrelevant to the result of switching and the probabilities are equal again.

<comment><USER17> You make your initial guess. What's the probability you're right on your initial guess? 1/3\. What's the probability you're wrong? 2/3.

So now, you're presented with your second decision. Do you stick or switch? Well, if you stick, that's going to lead to success if and only if you were _right_ on your first guess. And if you switch, that's going to lead to success if and only if you were _wrong_ on your first guess.

We all agree that you were more likely to be wrong on your first guess. So you should bet on the fact that you were initially wrong. I.e. switch.

</comment></comment><comment><USER18> At some intuitive level this problem reminded me of other very different puzzles like [1] and prompted me to wonder if as a general rule the best tactic when one is faced by a riddle that appears impossible, is to try to think of solutions that involve self reference. It also makes me wonder if the brain at a basal unconscious level uses something analogous to the linked list like solution described here to quickly explore permutation space.

1 [https://en.m.wikipedia.org/wiki/Knights_and_Knaves](https://en.m.wikipedia.org/wiki/Knights_and_Knaves)

</comment><comment><USER19> If I understand this correctly, this basically uses the drawer's perceived number as an out-of-band signalling mechanism for the algorithm they agreed to follow. Each actor must adhere to the same scheme to address drawers. This means that the drawers must either be uniquely named ("labelled" ahead of time), or have some sort of natural ordering that's algorithmically deterministic (e.g. lexicographic, array index, 2D-position using a previously agreed algorithm like right-then-down).

What are some practical uses for this? Distributed hash table traversal using one's own address [1]?

[1] [http://www.bittorrent.org/beps/bep_0005.html](http://www.bittorrent.org/beps/bep_0005.html)

<comment><USER20> This "look at it as a permutation problem and follow the disjoint cycles" idea is loosely what rainbow tables are based on (although I think in that case because of the possibility of hash collisions they aren't guaranteed to be disjoint cycles, which requires extra work to solve).

</comment></comment><comment><USER17> Many mathematical-minded people look at this problem and conclude that the maximum probability of freedom is close to (1/2)^50.

But that's absurdly wrong. They're out by a factor of 10^14 !!! So, are there any important problems in computer science / software engineering contexts that have this form? If so, they may have speed-ups of several orders of magnitude that mathematically and algorithmically-minded people might completely miss?

</comment><comment><USER21> I wrote up a Python framework to play around with a different 100 prisoners problem here: [https://github.com/CydeWeys/hundred_prisoners/tree/master/pr...](https://github.com/CydeWeys/hundred_prisoners/tree/master/prisoners)

People might find it interesting to play around with implementing the solution in code.

</comment><comment><USER22> One key thing about the result is that it doesn't mean that the probability of survival is 30%. The prison director can choose an arrangement such that the strategy is guaranteed to fail. If the prison director is intelligent and after your life, you are infinitely more likely to survive by opening boxes randomly.

<comment><USER23> The prisoners in the game can collude before the game begins, so they can create their own ordering on the fly. This cannot be overcome by the warden.

</comment></comment><comment><USER24> HN post from 2010 : [https://news.ycombinator.com/item?id=1891212](https://news.ycombinator.com/item?id=1891212)

</comment><comment><USER25> Well, this led me on a bit of a rabbit trail. I made a python script that illustrates the solution to this problem in action. [https://gist.github.com/travismay1/8d80fe345786b1d0e93fee812...](https://gist.github.com/travismay1/8d80fe345786b1d0e93fee8127df53b5)

</comment><comment><USER26> The third variant of the problem (where one prisoner is allowed to make one change, which can guarantee that every prisoner survives) is the one I heard first; I like that problem because it seems even more counter-intuitive, but also makes it easier to understand why it works.

</comment><comment><USER27> Let's make the game harder by not letting the prisoners see what's inside the opened drawers.

Is it hopeless now?

<comment><USER28> That's just a game of chance. The point of a skill game, even one that involves randomness, is that information you get can influence your actions. If you cannot look inside the drawers, you do not gain any information about the particular setup and thus cannot execute anything that would resemble a strategy.

<comment><USER29> They can still do slightly better than chance by ensuring their guesses have the right amount of overlaps. For example, if there were only two prisoners, the right strategy would be for one to pick box 1 and the other one to pick box 2, improving their odds of survival from 25% to 50%.

I suspect the chances are still negligible for 100 prisoners though.

<comment><USER30> > I suspect the chances are still negligible for 100 prisoners though.

I think from a probabilistic standpoint, they're equivalent as n increases. Think of it as the inverse; what's the probability each box is checked by its owner?

Pb = Nb / N, or number of people that checked that box divided by number of people total.

If there is perfect, premeditated overlap, then Nb / N is exactly 50/100, so we get the "(1/2) ^ 100" that was already cited in the article.

If prisoners choose randomly though, the expected value of Nb is still 50 though. You've maximized Nb in practice, but not really in theory.

<comment><USER29> > If prisoners choose randomly though, the expected value of Nb is still 50 > though.

The expected value of Nb would still be 50 if all the prisoners checked the same subset of boxes, but the chance of the prisoners surviving would clearly be 0.

I think it's correct that if the prisoners don't get the see the contents of the boxes, then any arrangement where each box is opened by 50 prisoners is equally good and optimal - but I can't quite see a proof.

<comment><USER30> > The expected value of Nb would still be 50 if all the prisoners checked the > same subset of boxes, but the chance of the prisoners surviving would > clearly be 0.

Yes I should have expanded. The probability of escape is

∏ (i = 1..N) Ni / N

So if some Ni is 0, the whole thing is 0. My point was that if you're choosing randomly, then as N goes to infinity, "Ni / N" already converges to 0.5 . So your strategy is ensuring optimality, but you'd get there if you took it to the limit anyway.

As a quick test I did 1000 trials. The minimum overlap in those 1000 trials was 26. 95% of the time it was above 35. For N = 1000, 95% of the time it was above 440.

</comment></comment></comment></comment></comment></comment><comment><USER31> Do the prisoners remove their number from the drawer if they find it? It's not clear from the problem statement.

<comment><USER32> If they did, you essentially go back to random choice because of all the broken chains created. "Find" is meant to imply literally "discovering the location of data that correlates to their prisoner number".

Real world context implied that prisoners would also take the tickets, but that is not specifically stated.

</comment></comment><comment><USER33> Say you have 10 players in a row. You number each player by its position in the row: 1, 2, 3, .., 10. You then write the players' names on 10 pieces of paper, and you randomly place the papers in 10 boxes. You place exactly one paper in each of the boxes. The boxes are also numbered from 1 to 10.

You allow each player to look into half of the boxes. Each player can choose which boxes to look into. The player "wins" if they find a paper with their number written on it. But they can't tell anyone if they won or lost, what they saw in the boxes, or which boxes they picked.

The problem then, is the following: Which boxes should each player look into, such that the chance of all of them "winning" at the same time is as high as possible.

For example, one way to put the 10 numbers in the 10 boxes is:

Box 1: 10

Box 2: 9

Box 3: 8

Box 4: 4

Box 5: 6

Box 6: 5

Box 7: 7

Box 8: 3

Box 9: 2

Box 10: 1

The ordering of the numbers in the boxes is a permutation of the 10 numbers. We know that there are 10! possible ways to place the numbers in the boxes.

Now, consider the following strategy that player X can use to open his 5 boxes. He first opens the box numbered X. If he sees his number in it, then he wins. Otherwise, he saw a different number Y. He then opens the box numbered Y. If he finds his number, he wins. Otherwise, he continues until he has opened the 5 boxes he is allowed to open.

If the player was allowed to open as many boxes as he likes, they he would always win. That is because he would either find his number in a box, or continue opening boxes he hasn't opened before. Why is this true ? Well, let's say it isn't, and that he opens boxes 3 -> 2 -> 5 -> 7 -> 5\. But that cannot happen: The first time he opened box 5 was because he saw the number 5 in box 2. And if he had to see box 5 again, this means that box 7 also had the number 5 in it. In fact, the only way player X could go back to a box he has seen, is when he finds his number (X) that will lead him back to the first box he opened.

Now, we know that a player "wins" if he finds his number before opening more than 5 boxes. Or, put it differently, if the loop he follows has length at most 5\. In the example above, player 2 would open box 2, which would lead him to box 9, which contains number 2, forming a loop of length 2.

So, when do all players "win" at the same time ? When there does not exist a loop that has length 6 or more. Or more specifically, there is no loop of length 6, or 7, or 8, or 9, or 10. So: P_win = 1 - P_loop(6) - P_loop(7) - P_loop(8) - P_loop(9) - P_loop(10).

We can show [1] that P_loop(k) = 1/k, when k > 5\. We need the loop to be larger than 5 because in this case, there can only be one such loop on the permutation.

But then P_win would be 1 - 1/6 - 1/7 - 1/8 - 1/9 - 1/10 or ~35.4%. In general, if we have N players and N boxes then P_win would be: P_win = 1 - Sum[k=n/2+1 .. n]P_loop(k) or P_win = 1 - ( Sum[k=1 .. N]P_loop(k) - Sum[k=1 .. N/2]P_loop(k) ) or P_win ~= 1 - ( ln(N) - ln(N/2) ) > ~30%

(each sum is a harmonic series sum.)

[1] Why is P_loop(k) = 1/k when k > N/2 though ?

Let's say you have numbers 1, 2, .., k. All permutations of them are k!. How many of those k! permutations form a loop ? Well, at the first position, you can place any number other than '1', so you have (k-1) choices. Say you placed number Z at position 1. Then at position Z, you can't place '1' and you can't place 'Z', so you are left with (k-2) choices. In the last position, you have to place number '1' to close the loop, so you have no choice. So, you have (k-1)(k-2)(k-3)...1 ways to form a loop, or (k-1)!.

Therefore, with a little bit of squinting, we can see that the probability that a random permutation has a loop on it of length exactly k is (k-1)!/k!, or 1/k.

We can formalize this argument as follows: There are (N choose k) ways to pick the k places on the permutation where there exists a cycle. There are (k-1)! valid ways to form a cycle on these k places. There are (N-k)! ways to arrange the remaining elements on the permutation. There are N! permutations, Therefore, P_loop(k, N) = (N choose k) _(N-k)!_ (k-1)! / N! = N! / k! / (N-k)! * (N-k)! * (k-1)! / N! = 1/k</comment>


Lynda.com Inspiring Story - <AUTHOR> http://leansparks.com/lynda-com-inspiring-story/

<comment><USER2> I like Linda.com and find it very useful. Everytime I mention it to my co workers they make fun of it. What they don't know, well What only my previous lead dev knows is that I'm a college drop out who learn mostly on my own through Linda and many others, and I am on a program where I receive a raise every 3 months for the past 2 years I am working at this company. If my co workers only knew .

Thank you lynda.</comment>


My Story About the Long(est) Way to Build a Job Board - <AUTHOR> http://blog.talentopoly.com/2012/07/24/my-story-about-the-longest-way-to-build-a-job-board/

<comment><USER2> "The ads were working. I realized that I shouldn't have avoided ads for so many years. I wasn't ever going to reach enough people without advertising."

I'd be curious to hear more about the process of getting into advertising. How'd you decide where to advertise? Did you start with small investments to test different channels? Was there a resource (book? site?) that helped you get into it?

</comment><comment><USER3> I've been a huge fan of Talentopoly for a couple years now. Even as a low- level still-learning developer, it's been invaluable. The Job Boards idea in a more 'intimate' setting seems pretty brilliant too. Trusted people sharing trusted job opportunities (to a degree). Good stuff Jared.

<comment><USER4> Why are you a huge fan of Talentopoly? What does it have that other sites (and there are many similar ones) don't?

</comment></comment><comment><USER5> Interesting story. Makes me want to pickup an old project of mine too.

</comment><comment><USER6> This is a good story that any website worth while goes through. Definitively a good read.

<comment><AUTHOR> Thanks, glad you liked it</comment></comment>


A newsletter to upgrade your IQ on stuff - <AUTHOR> https://outsideplatoscave.substack.com/p/outside-platos-cave-3?r=5xuid&utm_campaign=post&utm_medium=web&utm_source=hackernews <comment><USER2> This is the #4 time you posted this. You can post your stuff here, but if you repost too much the users will get unhappy and start to flag your post and then the mods may ban your site.

There is no hard rule, but I'd recomend not to post more than once a day if you are only posting your newsletter.</comment>


S&P 500 erases its loss for the year as stocks rally on reopening optimism - <AUTHOR> https://www.cnbc.com/2020/06/07/stock-market-futures-open-to-close-news.html <comment><USER2> This has been a very effective way to transfer huge amounts of public money from the Fed to the one percent. Not sure it helps the bottom 50 percent in any way.

<comment><USER3> If you look at the job market, all of a sudden some hiring freezes have been lifted. I noticed the job posting volume drastically increase as the markets have rallied. Some industries obviously are still bad, restaurants etc. but others are starting to reopen and rehire based on market optimism.</comment></comment>


RIBs: Uber's cross-platform mobile architecture - <AUTHOR> https://github.com/uber/RIBs <comment><USER2> This looks cool, but "Cross-platform" is a misleading adjective to use here.

By that standard, you can put "cross-platform" on anything. Like MVC is a "cross platform" architecture. And so is CRUD.

<comment><AUTHOR> I try to avoid editing titles, but I agree that "pattern" would be a better word here.</comment></comment>


Popularity in high school yields a 10% wage premium 40 years later - <AUTHOR> http://privatewww.essex.ac.uk/~agaleo/wp_files/NewStuff/Popularity_final_15July2012.pdf <comment><USER2> Surely it's not that popularity in high school gets you higher wages later, but that charisma gets you both of these things?

<comment><USER3> Nope. It's clearly the popularity in high school. It's amazing what sort of effects your early years, and especially those people around you in your middle years can have. What happens is, basically, everyone in your high school class calls up your future employer and says either "raise his wage" or "lower his wage". The future employer uses their consensus to decide your salary. It's really fascinating.

In other news, ice cream truck drivers now on trial as accessories to murder during summer time.

[edit: So it doesn't come off as otherwise, I'm not snarking you. From a preliminary glance, it certainly looks like they might be doing that whole "correlation == causation" bug that can happen very frequently. Your analysis seems reasonable to me]

<comment><USER4> Trying too hard

</comment></comment></comment><comment><USER5> The scribd link is down for me, but there's a free version available here: [http://privatewww.essex.ac.uk/~agaleo/wp_files/NewStuff/Popu...](http://privatewww.essex.ac.uk/~agaleo/wp_files/NewStuff/Popularity_final_15July2012.pdf)

If you don't want to read the whole paper, the interesting sections are, Table 2, sections 3.2 and 3.2 (including Table 3), and, of course, the intro and conclusion.

Frankly, I'm surprised the wage premium for popularity is so low. The wage premium for managers (and execs) is high, and folks who have good people skills are much more likely to become managers. So, why isn't the wage premium higher?

</comment><comment><USER6> I feel like this is much more about the results of high school popularity (confidence, self-assuredness, dare I say getting laid?) than the actual implementation of popularity itself</comment>


Ask HN: Productive after-hours? How do you collaborate and work during the day? - <AUTHOR> I am a software developer and I get insanely productive / focused just as everyone is knocking off, around 4-5pm and can work until the wee hours of the morning.<p>Even though I work remotely and have daily standups in the afternoon, I actually get work done when everyone else is finished. This sometimes affects me at that I have to work during the day so I can collaborate but it will be a bit difficult as I won't be at my peak. How does this affect collaboration for you and is this something you have communicated with co-workers? I am curious to know how people have managed this kind of work routine. <comment><USER2> If you can't convince your manager that it's in their interest for you to have a custom schedule just stick to the mandatory schedule and call it a day. If they don't care about your productivity certainly you shouldn't care either (that's obviously different if you're self employed)

Tech workers are the new factory workers, don't make it more complex than it already is, do your job, go home, enjoy life.

</comment><comment><USER3> There are two kinds of "Productive".

There's my personal productivity, and there's the team/company productivity.

When working on a team, you have to figure out what produces the best output for the team as a whole, not yourself.

I function best when I get up at about 8am in the morning, and get to work at about 10am.

Doing that, when others leave in the evening I get several hours of high productivity.

My personal productivity soars when following this.

However, it means I'm much less available for the team, and depending on the project my being available has more impact on the team output than my direct personal productivity.</comment>


Review my HTML5 game Orbium - <AUTHOR> http://bni.github.com/orbium/

<comment><AUTHOR> Source code and some more info at github: <https://github.com/bni/orbium>

</comment><comment><USER2> TOO MUCH CAPS CANT HANDLE IT

After that, what the hack am I supposed to do?

</comment><comment><USER3> It crashed after a while (Google Chrome).

</comment><comment><USER4> Instructions?

<comment><AUTHOR> Sorry about the lack of instructions...

Collect 4 marbles of the same color in each rotating device to explode the device. Explode all the devices to proceed to the next level. There is a time limit.</comment></comment>


Ask HN: Anyone else find the new Gmail interface sluggish? - <AUTHOR> For me it's so unresponsive that I'm at a loss for words how google put this into production. I have a modern, new computer and modern, urban internet good enough for streaming 1080p on Twitch without interruption, but I can't delete or archive an email anymore without waiting 4-6 seconds for it to complete the action.
What has your experience been like with it?
edit: Guess I'm not alone. I can only hope someone working at Google sees this post or cares. Maybe too much to hope for. <comment><USER4> Am a googler (hence throwaway account) & I can easily tell you why this shit keeps happening!

Google featureless ZERO penalties for fucking shit up! Zero! Do you know what the people who wasted two years on Allo got after it was canned? Nothing! Some of them actually got promoted!

Google GREATLY encourages "launches" \- releasing something publicly. And keep in mind - no penalties if the shit is half baked, not working, only works on chrome, or some such nonsense! This is the norm!

Why? Promotion. You cannot get promoted beyond a certain level in this place unless you "launch" something big.

So what do you get when you add of all these perverse incentives? Nine thousand, eight hundred, and eighty-three chat apps, and a never-ending chain of redesigns and relaunches so some people can get promoted.

Do you know how many bugs you need to fix to get promoted? Infinity. No matter how many you fix, it will never get you enough "impact" for promotion. Never.

How many useless redesigns do you need to launch to get promoted? ONE!

Extra fun: people internally usually warn about this shit, complain about it, file bugs about shitty performance, etc. It is _ALL_ ignored. Most people who've been here for over a few years have given up filing bugs even. Because the reply is always the same: "you're not the target audience"!

And we all know it! We all do! Some quit when they realize it, others just begin optimizing for promotion as opposed to optimizing for what is good for the user or the company. And this is how you get new gmail, for example.

EDIT: replaced underscores with proper profanity as had been requested

<comment><USER5> Classic: You get what you measure.

But years ago the same thing happened to me at Apple. I was fixing bugs in every part of a major framework to help SnowLeopard ship only to get passed over for a minor promotion because I wasn't "critical on any one project".

I thought it was especially ironic since SnowLeopard was supposed to be a stability/performance release only to get massively delayed by people "shipping" things like the Objective-C garbage collection that made XCode unusable for months. The same stability/performance release that had a day-1 point release.

<comment><USER6> Maintenance is thankless work - it's that way in just about every industry around, short of total disaster no one is going to congratulate you for making something work the way it was supposed to work.

<comment><USER7> Personally I've had good reception of performance and security bug fixes at my current job. Even got a private bonus from CTO for one. (Small-Medium company)

But I can see how that'd be the exception.

</comment></comment></comment></comment><comment><USER8> A week or two after reverting back to the usable gmail, Google notified me they would switch my Google apps mail to the new gmail in a popup on the corner.

It presented me with two options: Now, Delay One Week.

Instead of choosing one, I adblocked the notification. Two weeks later I'm still on the old gmail that responds to clicks. Hoping it never changes.

<comment><USER9> As soon as I got the update notification and couldn't say no, I quit Gmail.

The redesign is absolutely horrible, and just like OP, I find it unusably slow (on a beasty Gaming PC).

I got Fastmail, and redirect my Gmail which will now only be used as a spam address. Exactly the same as when I went Hotmail to Gmail and Hotmail because my spam address.

The tech cycle continues.

<comment><USER8> My Google mail is already a personal domain I just manage through Google apps. To be honest the main reason I keep it on Google apps is the six-ish people I talk to exclusively through hangouts (and momentum).

If I do get forced to the new gmail web version I'll likely switch to a desktop client or write my own client if I can't find a tolerable one.

<comment><USER10> OK, here is the real shocker. I had to create an outlook account and get a Office 365 sub for various reasons. I actually found the Outlook + Skype + OneDrive combo more usable than their Google counterparts. If you had told me this five years ago, I would have had you sectioned under the mental health act

<comment><USER8> I don't discount that possibility, but I use hangouts to talk to specific people who don't use any other PC-based chat. That's the downside of tying your email address to your chat I suppose.

I've taken to using Windows Mail for my gmail usage half the time anyway now, even though I'm still on the old web client.

</comment></comment></comment></comment></comment><comment><USER11> Yes. I was complaining into the air on twitter, and their support responded by asking me to clear the cache and cookie.

I told them: no man, it's not cache and cookies. You're loading too much stuff on initialization. It takes about 45 seconds for page load, and it's not until 1m37s that I can compose an email. You're making about 285 requests (19MB) before I can compose. That's the size of a long pop song on iTunes!

I've now bookmarked the old "html gmail" just so I can compose emails in a jiffy. I think they assume I leave a browser tab open for email. Not when it's so heavy weight.

<comment><USER12> > about 285 requests (19MB) before I can compose.

This is insane. So I went to test it. 358 requests, 6.3MB, 20 seconds till full load.

Compared to the standard, really old view ([https://support.google.com/mail/answer/15049?hl=en](https://support.google.com/mail/answer/15049?hl=en)): 14 requests, 25.3KB, 2 seconds.

Edit: fans were spinning hard, so I opened the task manager: after CPU went down from ~90% tab is using 600-700MB, stable, with the dev console open, 400-500MB closed. 400MB to check my email.

<comment><USER13> ... what the hell is gmail doing to suck up that much memory? It shouldn't take more than 1KB per message to store all potentially-relevant message headers, and even the textual content [i.e., no attachments] is unlikely to consume more than a few KB. That takes 100,000s of messages to reach 400MB, which is roughly on the order of "save every message you have ever received for several years."

<comment><USER14> They have to track your every mouse move, what you type, when you type, where you hover your cursor, how long you took to type an email, who knows what else. Extreme surveillance takes extreme resources.

</comment></comment></comment></comment><comment><USER15> I hope it was the result of plenty of well-intentioned individual business decisions, such as Gmail now working offline in a first-class way, and relying on (presumably more complex and slower) web technologies to make that happen. I mean, the new Gmail is supporting a _lot_ more features (including ones brought from Inbox), so a total architecture rewrite was probably necessary.

BUT -- at the same time it's super-sad, because Google (search) felt like it was one of the biggest forces pushing for faster page loads, publicly saying it would downrank sites that loaded slowly, and pushing things like SPDY -- and think of what Chrome did for JavaScript performance. And the old Gmail was _so_ fast, so _blazingly_ fast, loading instantly and keyboard shortcuts felt akin to using a terminal.

So the new, slow-as-molasses Gmail feels like the end of an era, a couple years after the same thing happened to Maps. Gmail is no longer about clever code that executes lightning fast in the browser, now it feels just like another piece of bloated enterprise software. :( They probably had the right business reasons to make Gmail more enterprise-friendly... but it still feels so sad as a programmer and as a user.

RIP fast Gmail.

<comment><USER16> _and think of what Chrome did for JavaScript performance_

I think that's partly what contributed _to_ this slowdown --- faster JS execution to a browser is basically like faster hardware to a native app, thus reducing the impetus to optimise the JS code itself. Imagine if hardware wasn't getting any faster (we're close to that already) and browsers still used regular intepretive JS execution like IE6 instead of JIT'ing. If browsers don't execute JS any faster, then web app developers would have to do a lot more optimising to get even acceptable performance, and perhaps we'd see some more interesting tricks and knowledge develop.

<comment><USER17> That's correct. On the other hand, I see many people sheepishly accepting slow page loads and overall unresponsiveness of today's web apps because - <USER2> from a few slim ones - the majority seems to be equally sluggish, loading tons of JS, webfonts (before the page gets loaded!) and what have you. Many people somehow got convinced that it has to be that way.

</comment></comment></comment><comment><USER18> It seems like almost everything Google related is sluggish. The new Google AdSense, the new Google Analytics, the new Google DoubleClick for Publishers, and to a lesser extent, the new Google Maps. These are all products I use that perform worse now (on modern hardware) compared to a decade ago. I really don't understand how this happens. Does no one at Google notice some of these services literally taking 10 seconds to load simple pages?

<comment><USER19> They have invested so many billions in their pipeline and committed so much head space that it's incredibly difficult to change their tech stack to improve performance. Users suffer because of poor performance but at least management can brag about compliance, code reuse, being able to quickly push out production code, etc.

<comment><USER16> _Users suffer because of poor performance but at least management can brag about compliance, code reuse, being able to quickly push out production code, etc._

I've seen this type of behaviour become more prevalent especially within the last 5 years or so, and it's just as irritating to me --- especially when resolving user-complaints take a backseat to improving whatever useless metric-of-the-week the management have thought of.

It doesn't have to be "the customer is always right", but I've found that companies are increasingly becoming more deliberately ignorant of user's concerns and instead focusing on furthering their own agenda.

<comment><USER17> > I've seen this type of behaviour become more prevalent especially within the > last 5 years or so

It's much older, but previously you'd see it more in the desktop space.

As for the server, an interesting thing happened: the proprietary software used to follow similar trend (I'm talking to you, big fat database vendors), with some open-source projects behaving the same. But people are not stupid: you realize you win by serving your clients fast and that very often speed is more important than functionality. Hence the success of projects like Nginx or Redis.

</comment></comment></comment></comment><comment><USER20> Welcome to 2018, friend, where we have several orders of magnitude more computing power and somehow everything is less responsive. It's all accomplished through an advanced process called "Software Engineering".

<comment><USER21> More specifically, sluggish websites seem to result from the popularity of "responsive design".

<comment><USER22> Responsive design isn't to blame at all. The "Javascript all the things" approach is to blame.

<comment><USER14> If it was only JavaScript, we'd be fine. But it's a JavaScript framework, built on some other JavaScript frameworks with tons of dependencies, then an entire new dependency plugin for every little thing you need to do like check if something "is an array".

</comment></comment></comment></comment><comment><USER16> Not directly related, but I reckon the mentality of some web developers I've complained to about their "appsites" being sluggish is similar here --- "it works perfectly fine for me, how about you upgrade your hardware?"

I've heard that you can use [http://mail.google.com/mail/h/](http://mail.google.com/mail/h/) to get a basic HTML version.

<comment><USER23> Expecting people to revert to a 25 year old text version, and repeatedly demanding users to upgrade their Chrome version from a 6 month old one shouldn't be necessary either.

<comment><USER24> I can understand asking people to update their browser, for security considerations.

<comment><USER23> My security, my choice. If i say no ('X') then they shouldn't keep nagging me.

<comment><USER23> Getting downvoted, so i'll add that i'm using a Chrome-based Chinese browser (UC) so have no control over the Chrome version.

</comment></comment></comment></comment></comment><comment><USER25> It's incredibly slow and to top it all the new redesign is maddeningly bad. I have to zoom out to 90%-80% just to make it bearable. There is clearly no separation between various sections in the fifty shades of grey that's become their MO. This should never have passed the first line of review let alone be in production. With all their new decisions with the Pixel 3, Chrome and now Gmail, it's clear Google's list its edge.

</comment><comment><USER26> On Firefox it's unusable for quick work (open, quickly manage emails, close). The interface is noticeably slower than the classic UI. It's maddening.

Not sure what I'm going to do when it switches over for our Google Apps account. Any alternatives people like?

<comment><USER27> This exactly. On Firefox Nightly, time to first interaction for me is 30 seconds.

I've found myself going to gmail.com, searching for something, and then waiting 30 seconds for "Loading..."to transform to "Something's not right". I've just started doing all reading on the Android app.

It's still easier for me to write at my laptop than on my phone, so this miserable experience happens to me multiple times a week. I've started to deeply despise the webapp.

<comment><USER28> Use an IMAP client.

<comment><USER27> That is a solution to my problem. Thanks for the tip.

</comment></comment></comment></comment><comment><USER29> I don't use Gmail, but Google Maps seems to be getting slower and slower all the time for me on some of my older boxes.

I imagine that it's just the classic case of developers having good machines, and the market share factor meaning they just don't really have to care.

I develop on a 12 core processor. If I make something user facing, I have to go out of my way to ensure that it's performant on other hardware; it's not part of the standard build/tweak loop.

<comment><USER30> >I imagine that it's just the classic case of developers having good machines.

But, like, that's ridiculous! Developers should be testing the performance of their stuff, either by looking at system resources or by keeping some "crappy" testing machines around. Preferably both.

I wonder what the environmental impact is of users upgrading their hardware in order to run completely unoptimized stuff like this?

<comment><USER31> > or by keeping some "crappy" testing machines around.

We used to do that at ${BIGCORP} until the CTO moved us to an equipment leasing policy in place of buy-and-depreciate. Instead of being able to retain the old machines for testing they went back to the lessor every three or five years.

It used to be that most devs had a couple of old PCs under their desks for hacking around on stuff, but that was no longer tolerated. The policy seemed like a minor financial tweak to the C-suits but was actually quite destructive to innovation.

</comment></comment></comment><comment><USER32> Plenty of previous discussion at [https://news.ycombinator.com/item?id=18305366](https://news.ycombinator.com/item?id=18305366) — you're not alone

</comment><comment><USER33> I get drastically different performance using Google's services between Firefox and Chrome.

I had instant responses in Chrome for Gmail, Chat/Hangouts, Calendar, etc.

In Firefox? 4-6 second wait for _every_ interaction.

And I don't think the fault is with Firefox here...

<comment><USER34> There was a post recently about how YouTube uses depreciated web APIs and then polyfills them to every browser that isn't chrome so YouTube loads slow on non chrome browsers.

<comment><USER35> That's insane. Google's products have taken a nosedive in the past 5 years.

</comment></comment></comment><comment><USER36> I find it pretty sluggish. On Saturday I had to login to outlook for the first time in maybe 2/3 years. Wow the outlook ui from MS is awesome now. For me it was supe... ok ok ok. The login experience from MS still sucks donkey cock. I don't know if they will ever fix that. But if you get past the terrible login experience. Man outlook is Super quick and clean. I switched back to gmail and i doesn't look as good and it's slow. Click things and wait.... gmail experience gone down hill.

<comment><USER37> As an outlook.com and gmail user, I have to say it's going through the same crap as gmail. More features getting tacked on. I stopped using outlook.com's web interface once they started throwing Skype in my face at every chance.

<comment><USER36> There's skype on there too? My experience was.

\- Ah stupid MS login

\- Oh that loaded fast

\- _clicks email_ loads instantly on right hand side and can still see my list.

\- Oh this is clean and fast!

I've been debating loading gmail into a desktop client now that the UI is so sluggish for me. (for the first time since gmail came about) but as of saturday, i'm wondering if I should try using my outlook email more.

</comment></comment></comment><comment><USER38> Yes I have had equal experiences. It has directly lead me to begin switching to Fastmail on my own domain because I'm tired of this nonsense (along with their constant nagging to switch to the new version or chrome).

<comment><USER39> Already switched to Fastmail, which has been excellent. It's nice to have successfully moved something off Google.

<comment><USER40> I did a small inventory of my online accounts the other day and got surprised by how little I depend on Google. A few years ago I figured Google was just a necessity of living (online) these days.

I first migrated to Fastmail a couple years ago, mainly to just have more control and use my own domain etc. Contacts and calendar shortly followed.

I switched to iPhone last year, not because Android is bad or anything, it's just what I had had for a long time and I wanted to try something else. No regrets there.

I switched to Chrome many years ago because it just worked better than other browsers, but recently I went back to try Firefox and it's really good now.

I never really used cloud storage.. (Photos/Drive)

Google is still the vastly better choice for Search, hands down. But just for the hell of it I decided to stick with DuckDuckGo and it's good enough for most things. Only occasionally do I head over to Google to get better results. It's not optimal, but I can live with that.

Google also has very good store/location info etc in Maps, and the photos to go with it. Apple's maps is far from the joke it used to be, but when you just want to get info on a store or something and you get redirected to TripAdvisor, that's a huge bummer.

Finally Youtube, there's just no competition out there.

All in all, of course Google has a presence in my online activity, but it's not the end-all be-all internet hub I thought it was.

</comment></comment></comment><comment><USER41> One setting I found that has made the new interface slightly more bearable is turning off "Hover actions" under the General tab. It gets rid of that awful box-shadow that makes scanning down the list difficult.

<comment><USER42> This made a surprising difference in the performance for me. Thanks for the suggestion!

</comment></comment><comment><USER43> I can't stand the new gmail to the point where I check my email only once a day. Every time I open that interface I get enraged. I am a UX designer and the new UI is a total clusterfuck - something you'd expect to fire someone over. Big G really messed this one up and I suspect many feel this way. If they have any sense left at all they'll add the old view option back or revert completely.

<comment><USER44> Agreed! I vote for this.

It's not just an issue of speed. The new gmail design is very hard to read/understand. Red-on-pink is not the best contrast choice. The icons feel fuzzy without the button borders, are hard to decode, and are too tight together.

Strangely, while the icons are all packed tightly, the email list wastes extra space vertically, and requires extra scrolling. Not the best design choice.

The high-contrast theme brings gmail close to the classic design, but it does not work well enough to make the icons more recognizable and recover the wasted space in the email list.

<comment><USER45> You can make the email list more compact, (and in fact it tells you as much the first time you open the app).

</comment></comment></comment><comment><USER46> Isn't that how modern web design works? Take away features, move stuff around randomly and make things slower?

Google has got really far away from their initial versions of GMail and Maps. They used to be lean and right on and now they are just a bloated mess.

</comment><comment><USER47> I get pretty frustrated with it. I work almost exclusively with shortcuts, and after a while the interface decides to forget to respond to my commands.

Example - /,"is:unread to:me",Enter. Should search for unread mails to me.

On a regular basis if I move through five items rapidly and head into this search, it just shows a blank screen inside the area where the mails should be. Even hitting f5 won't resolve the issue at times. Ive actually stopped browsing through mails on some other threads because of this issue because it would take up too much time to keep debugging Gmail.

</comment><comment><USER48> I just checked uMatrix how many scripts are running. After blocking hangouts, plus, play, notifications and whatever "ogs" stands for it got a bit snappier, and it still works.

<comment><USER49> Can you provide a bit of detail on how you block them?

<comment><USER48> Uhm, well, its just the basic way one would use uMatrix so nothing special. It's an add-on that works by whitelisting instead of blacklisting, similar to NoScript.

In this case I had it set up to allow all subdomains of google, so I opened the panel and clicked to blacklist the subdomain that I didn't want.

EDIT: The only downside of this is that if I want to use Google Hangouts in the same browser, it is now blocked, so I have to manually unblock it. But I use Firefox as my main browser, yet reserve hangouts to Chromium anyway.

[https://github.com/gorhill/uMatrix/wiki](https://github.com/gorhill/uMatrix/wiki)

</comment></comment></comment><comment><USER50> Wouldn't it be crazy if email were built on protocols so users could choose their interface?

</comment><comment><USER51> I was trying out GSuite last week and used the Google Admin console and had the exact same experience.

You click on options then you wait 2-5 seconds for the menu to load or the option to expand.

Coupled with the poor UX I'm surprised more people aren't complaining about the time they spend managing these systems, it's as bad as Office365 but it's damn close now.

</comment><comment><USER52> I think what surprises a lot of people is that Google would take a premier product like Gmail and make it slower and less user-friendly.

Even when you try to use the "basic HTML", they decided to not provide a lot of simple features such as basic view customizations (e.g. standard, compact, relaxed). I'm guessing that was done to make sure people use the new UI - <USER3> it's use the slow UI or too bad for you.

Not sure much will change in terms of the new UI since people are more wedded to their email addresses than say their choice of search engine or maps.

When I worked with them back in the day, there was a certain "take it or leave it" attitude at times from some senior people about some decisions in products.

This was not all the people and I'm not speaking about the present leadership who I don't know, just that it was the case because back in the mid/late 2000s with my experiences and people I knew via working relationships.

</comment><comment><USER53> Not only sluggish but I couldn't stand the custom font, it makes reading paragraphs of text a headache.

<comment><USER54> Ah yes, I hate it!

</comment></comment><comment><USER55> Set Gmail to default to basic HTML. You'll be happy you did.

[https://smallbusiness.chron.com/make-gmail-display-mail- basi...](https://smallbusiness.chron.com/make-gmail-display-mail-basic- html-44852.html)

<comment><USER56> Yes, I've switched to the HTML version permanently, and I hope others do the same. Maybe if Google sees enough people switching to HTML, they'll get an idea of how popular their new version is.

<comment><AUTHOR> that will never happen. gmail has over a billion users. we are really the 0.001% who would do something like that.

</comment></comment></comment><comment><USER57> I use gmail over IMAP, performance on IMAP hasnt changed a bit.

<comment><USER40> I'm surprised they still support IMAP.

<comment> Const-me Probably because in some places, iOS is more than 50% of mobile users.

And globally, mobile devices have already overtaken PCs/laptops, years ago.

</comment></comment></comment><comment><USER58> I haven't come across better mail UI than Inbox.

Inbox got demoted, new Gmail got promoted.

If what I was told is true, then at Google, data beats opinions, that is, they have data to back up those decisions.

Now, why am I not convinced this is the case over here?

<comment><USER59> I've been trying to give them the benefit of the doubt for the same reason, but I too am unconvinced.

As one example/anecdotal aside: replacing a link to all mail from/to a contact on mouseover of their name with....links to Google Keep, Hangouts, etc. There's no way the use case data led to a change like this. I mean, how could it?

</comment></comment><comment><USER60> It actually works great for me. Firefox Nightly on 2016 MacBook pro. Curious why experiences differ so much - I wonder if it's the difference between folks (like me) who leave the browser open always with Gmail in a pinned tab vs people who load Gmail only as needed. Although that can't be it entirely, because I restart Firefox roughly daily to apply nightly updates. Maybe some plugin interference? I run ublock but that's about it.

</comment><comment><USER61> I genuinely hate the gmail interface - mobile especially. Completely unintuitive icons much of the time. Seems to do conversation threads poorly too.

</comment><comment><USER62> Yup, noticeably much much slower than the old interface, while seemingly also not changing functionality or layout at all. What was the point?

<comment><USER63> Technological/intellectual masturbation?

</comment></comment><comment><USER64> Old version is available in the gear if you're using corporate gmail

</comment><comment><USER65> Hell yes. I've been a gmail user for 15 years and I can't use gmail in my browser anymore.

For work, we migrated from Google apps to Fastmail.

But I still have 15 years of personal @gmail.com email and it's been my address forever. I currently use my phone for personal email (even when I don't want to) because the website no longer responds to input.

</comment><comment><USER66> I prefer using email clients than using the Gmail on web because of this particular reason. Their web app is painfully slow.

</comment><comment><USER23> Sent feedback during the test phase that it was unusable (hangs while "loading...") on slower connections and average laptops. Still forced it on us.

Killing G+. Google Search "mini games" annoying eyesore (Winter Olympic ones crashed browser so switched to DuckDuckGo) Censorship in China. 20k Googlers protesting. WTF?!!

</comment><comment><USER67> I dislike Google's preference for making their experiences optimal on chrome. Gmail and youtube both seem to run faster on Chrome. It feels very monopolistic that their services run best with each other and poorly on the competition. It's probably not intentional, but very frustrating.

<comment><USER68> This is entirely intentional. Google has no incentive to make their services run optimally on anything other than Chrome, for that would slow Chrome adoption.

</comment></comment><comment><USER69> I've written about how bad it is, and I've given feedback, and I try to use Gmail basic whenever possible now. That's how bad it is.

But Gmail basic doesn't support changing sender's address... and attachments is a bit backwards, so I still have to stick with this monstrosity.

</comment><comment><USER70> You're not alone. I was blaming on my internet connection for awhile, until I found this post: [https://news.ycombinator.com/item?id=18095579](https://news.ycombinator.com/item?id=18095579)

Moved to ProtonMail for important conversations.

</comment><comment><USER71> I have mostly stopped using Google Gmail because they still can't do something simple like... I don't know... sort by sender? They keep changing the interface, but they never seem to improve the utility.

</comment><comment><USER72> I use the content filter tabs (Social, Promotions, etc.).

Gmail refuses to let me move to a tab and mark new emails as read just about every time. It just hangs. I'll refresh and the same thing happens.

Multiple other issues as well.

</comment><comment><USER73> Yes - I've since switched to the Apple email client.

</comment><comment><USER74> The Gmail UI refresh is so bad that it's the final straw on the camel's back to get me to swap to something else. I was already considering it just due to privacy concerns, but I was sitting on that decision. The fact that it takes 30s for the page to load and another 30s to do something as simple as checking the box beside an email and deleting it made my choice for me.

</comment><comment><USER75> What aggravated me most is that sometimes clicking on a button has no effect. First I swapped to the HTML only version of gmail but found it too limited. I have now been using Thunderbird for a week or two. It is not perfect, but it actually works quite well. Plus you can have a little calendar view for the day's events on the side.

</comment><comment><USER76> If it's like the new google sites, they're clearly off loading everything possible to browser as JavaScript, making site slow, sluggish and unresponsive. - I guess that's just the norm for the future web sites. [https://sites.google.com](https://sites.google.com)

</comment><comment><USER77> My experience has been mixed. I do most of the work stuff on Chromium and the UI is okay-ish, used to be better, but whatever.

However, the personal stuff I keep it for Firefox, and it's just as OP said: 4-6 seconds to complete an action and even when the UI has loaded, not all icons are shown immediately.

</comment><comment><USER78> I am on slow connection the entire week and it is a pain in the butt. I m sick and tired at looking at spinners and progressbars. It's not just gmail, everything google ( i suspect material designed) is sluggish. Try adsense if you want to ruin your day.

</comment><comment><USER79> Yes sluggish, even on google fiber.

</comment><comment><USER80> It's unusable. I have gone back to a mix of the basic html version and a desktop client.

</comment><comment><USER81> Yes. I switched to using the "Basic HTML" version by default. Either turn JavaScript off and refresh the page once logged in, or click "Load basic html (for slow connections)" while the loading animation plays to get to it.

</comment><comment><USER82> I'm finding it much quicker in just about every way than the old UI, using Firefox.

</comment><comment><USER83> I keep 6 gmail tabs pinned and I don't find it sluggish at all on my 2016 MacBook Pro. The only thing that's slow for me is how long the non-default add-ons take to display after you load a message.

</comment><comment><USER84> On top of the new gmail being extremely slow the new google Ads or AdWords is so much worse. I have to run an ec2 instance at work in order to get just "ok" speeds. This is with fiber optic internet...

</comment><comment><USER85> Yep I posted something similar earlier [https://news.ycombinator.com/item?id=18284264](https://news.ycombinator.com/item?id=18284264)

</comment><comment><USER86> The archiving delay kills me. I used to archive an email and close the window but not anymore. One would think it's a single request to the back-end and the UI could be updated after that.

</comment><comment><USER87> The only part of Gmail I need redesigned is the settings page. I thought, "surely, this page from before the last redesign will finally get the treatment it needs." I was wrong.

</comment><comment><USER88> After the inbox debacle I decided I didn't want to use Gmail and am now a happy Mailspring user. If it could just implement Google inbox's sweep function, it would be perfect.

</comment><comment><USER89> Yes! And the recent versions of Chrome on macOS are equally bad.

</comment><comment><USER90> That's why I switched to the simple HTML version of the Gmail. Not as fancy, but it covers 90% of my needs. When I need fancy interface, I temporarily switch to it.

</comment><comment><USER91> Yes I have definitely noticed the same sluggishness. Does anyone have any resources or recommendations for transitioning off of Gmail and onto another email provider?

</comment><comment><USER92> The new gmail interface is just super busy and confusing and slow.

Spent my early morning disabling features just to curb info overload.

Google is turning into microsoft and microsoft into google.

</comment><comment><USER93> Not really. I've been using it every day and not noticed the problems others have. I have a fairly old refurb PC. Notwithstanding the page loading time.

</comment><comment><USER94> yesterday i was writing email with my new bluetooth keyboard and i realised that, words are appearing on screen after 5 seconds delay. first i blamed new keyboard and replaced batteries. then blamed chrome and checked memory/cpu usage all was fine. then i wrote email in vi and paste into gmail, even select old text and paste was extremely slow. thanks i saw this post, you are right it is almost unusable.

</comment><comment><USER54> Yes, I have reported it to them and never heard back.

</comment><comment><USER95> Noticed that too. Even with a powerful computer. The tags also take times to be automatically by associated to email you've just sent.

</comment><comment><USER96> Ugh, i've been delaying switching from Inbox. Still holding out hope that someone at Google lets that thing live somehow...

<comment><USER97> I avoided inbox on the web for the same reason as people are complaining about Gmail here; the mobile app is nice, but the web version was borderline unusable for me.

<comment><USER68> I felt similarly but the innovation Inbox brought to email was just too big to ignore. It was a new paradigm on how to use e-mail.

Killing Inbox is just another terrible decisions in a string of terrible decisions coming from Google. "Eh, only had a few million users anyways, who cares? What's product support? Everyone's a beta tester!"

</comment></comment></comment><comment><USER98> Seriously considering going back to imap+MH.

</comment><comment><USER99> Inbox does this now, as well. Half the time I open the page, I cannot even use it, despite seeing the emails loaded.

</comment><comment><USER100> If you have something liké Adblock or UblockOrigin try to disable thème for Gmail, for me If had a speed boost.

</comment><comment><USER101> .... it works perfectly fine for me

<comment><USER102> Just had a click around to confirm, Chrome on a mac, everything is instantaneous. I thought they must have been heavily pre-loading it opened messages so quickly, but I checked the network tab and it's making requests.

</comment></comment><comment><USER103> Yes. Me. It is slow. And sometimes mail doesn't appear. I have to refresh the page.

</comment><comment><USER104> It probably uses Angular. :-0

</comment><comment><USER105> All snark aside... You get what you pay for. I am slowly moving away from Google services. Paying in some cases reduces functions you might be used to, but also introduces freedom of ownership (well, maybe). But overall we are spoiled and I prefer using non mainstream services now.

<comment><USER106> imagine a world where user experience is modulated proportional to revenue generated through the user, to subtextually train us to spend money in the way they like.

>You get what you pay for

Could you try disabling google ads, buying a couple of products and report back if it improves the user experience?

<comment><USER107> Its just too easy to setup your own mail server these days.

I moved to my own domain, and use emacs + mu4e and have had zero problems. I do still have my old gmail address forwarded to my mail server and can reply when needed.

</comment></comment></comment><comment><USER108> I mostly hate the design and UX.

Also the fact that I can't go back to the previous version.

</comment><comment><USER109> "HTML (for slow connections)" applies to all equally! Finally, an egalitarian experience! And they said communism could never work.

</comment><comment><USER110> How about that the back button takes you off site instead of back one email?

</comment><comment><USER111> No, I don't use GMail.

Fastmail is great, though.</comment>