Are Monads a Waste of Time? - <AUTHOR> http://lambda-the-ultimate.org/node/5504 <comment><USER2> In university I was obsessed with Haskell and being clever and writing code that was an unholy stack of lambda functions and fancy constructs like monads and monad lifting. I used the typical intellectual supremacy argument inherent to many fields of study where you reason that something isn't used in industry because industry people are stupid and cannot possibly grasp all these advanced abstract concepts.

Eventually I realized that Haskell code is slow to write, hard to reason about efficiency, lazy evaluation sucks for most things, and most importantly Haskell is hard to read by others. Going on Hoogle to look up some package and seeing some abandoned doctoral thesis used by nobody where the only documentation is types becomes exhausting after a while.

Go is now my favorite language.

<comment><USER3> Pure FP is just using math as its primary source of programming patterns and techniques, while most other languages, like OOP, use arbitrary conventions to abstract code. Because mutation gives you tremendous flexibility, you can model many kinds of patterns, give it some analogy like inheritance in animals, and then write a language that has it out of the box. Haskell on the other is using math to construct its patterns, so while the learning curve is higher, eventually you realize this is the ultimate abstraction (category theory), and it cannot go more abstract than that. This is useful in some scenarios requiring more logical rigor, but I agree it's not always the best tool.

<comment><USER4> > eventually you realize this is the ultimate abstraction (category theory), > and it cannot go more abstract than that

This is exactly the kind of false sense of intellectual superiority to avoid. Mathematicians and category theorists don't talk like this. Even the parts of Haskell that have the flavor of category theory aren't _really_ all that much like category theory.

<comment><USER3> Maybe you can expand on that, and/or show me something more abstract than category theory. Programming = abstracting information processing. Category theory = the mathematics of abstract functions (or morphisms a.k.a. changing something)... so it makes sense that CT captures something very fundamental about computation.

<comment><USER4> 1\. Just because we have not thought of something more abstract does not mean category theory is the "ultimate" abstraction that cannot be surpassed. You would have said the same thing about sets before category theory was invented. 100% guaranteed there will be another, more abstract paradigm when the need arises.

2\. Just because one thing captures something fundamental about computation does not mean it captures everything fundamental about computation, nor does it mean nothing else can capture fundamental aspects of computation (disjoint from what may or may not be captured by category theory). For example, category theory does a terrible job representing the mathematical subfield of complexity theory, despite it being entirely about computation. For that matter, "how abstract" is not always comparable, and the intellectual dick measuring of what is the most abstract is counterproductive. Even basic questions in particle physics have no known model in mathematics that doesn't break under gentle prodding, so is particle physics more abstract than mathematics?

3\. Haskell does a lousy job representing the majority of ideas that make category theory useful to mathematicians. For example, universal properties are neglected Haskell, and at best they're implicit. Nobody actually thinks about the math when they're writing Haskell programs, they just think about Haskell types and programs, which makes the "techniques and patterns" of Haskell programming just as arbitrary as the conventions in random Javascript libraries. It's just that there are fewer names for the same thing because fewer people write serious programs in Haskell.

<comment><USER5> _> Haskell does a lousy job representing the majority of ideas that make category theory useful to mathematicians. For example, universal properties are neglected Haskell, and at best they're implicit. Nobody actually thinks about the math when they're writing Haskell programs, they just think about Haskell types and programs, which makes the "techniques and patterns" of Haskell programming just as arbitrary as the conventions in random Javascript libraries. It's just that there are fewer names for the same thing because fewer people write serious programs in Haskell._

That's an excellent point. So many people think they're doing category theory when they're writing Haskell, but Haskell is essentially nothing like the mathematics it borrows terminology from. They're really not comparable. Which is absolutely fine, but then people shouldn't draw parallels to the actual mathematics when the terminology is similar in name only.

</comment></comment></comment></comment></comment></comment><comment><USER6> Just to point out the probably obvious thing: that's only one type of monad (the state monad). There are many other things which form a monad and can't be represented easily in JS or other imperative languages.

Even though even the state monad is a clear win in my opinion (since it explicitly delimits a stateful computation which can then be embedded in a pure one in a principled way), the concept itself is much broader and thus much more useful than just allowing for imperative syntax in a pure language. For example, the continuation monad, which is just a library in Haskell, can't be implemented in most imperative languages without extending the language itself (async in JS, C#, etc).

<comment><USER7> > delimits a stateful computation which can then be embedded in a pure one in > a principled way

You probably meant to say smth different, but to many this reads like "you can embed and call impure code inside pure code while the pure code stay pure" which doesn't make much sense. I mean, you always do _the opposite:_ embed/call pure code _from_ the impure one.

<comment><USER8> With the state monad (State not StateT) you can run it in pure code because the runner is pure. It only "mutates" one context and when it's all unwrapped it's actually pure functions all the way down.

<comment><USER9> You probably meant ST, but yes, much to nnq's surprise, this is possible!

<comment><USER10> The fact that something called "ST" is one of the most important libraries in the language, and it's the one that you should choose for State (leave aside the "State" library! that's not the one you want!) shows how for all Haskell's power, it's terribly unusable for trivial reasons that never get fixed due to extreme deference to legacy mistakes. See also: Prelude.

<comment><USER11> ST is not the monad that should be used for state. You should use State for that.

ST is an optimization trick mainly used by framework implementors. In my professional experience writing Haskell, I've never seen st used for anything important

<comment><USER10> I wouldn't call "mutable arrays" an optimization trick mainly used by framework implementors, or "not important"

[https://wiki.haskell.org/Arrays](https://wiki.haskell.org/Arrays)

</comment></comment></comment></comment></comment></comment></comment><comment><USER12> Monads make a lot of sense in a pure functional language like Haskell, because it allows you to program in an imperative style _when you need it_ , and keep the rest of the program pure and functional.

The benefit of State and IO monads is not that you can use them everywhere so you now have an imperative language. The benefit is you can explicitly delimit their use, and you still get the "easier to reason about" for the rest of the code.

For languages which already supports mutable state everywhere by default it does not make much sense to use monads for this.

<comment><USER13> I really like D's approach instead. A function declared pure can have no side effects but it can do whatever kind of mess it wants within its own code. It can have loops, assignments, reassignments, memory allocations, but it can't mutate variables outside its scope nor can it call any impure functions. I find this is a very practical compromise that lets you have the good parts of purity without ever getting the urge to write a blog post about monads.

[https://dlang.org/spec/function.html#pure- functions](https://dlang.org/spec/function.html#pure-functions)

<comment><USER10> This is "const" in c++

<comment><USER13> I don't think this is the same. My C++ is getting rusty, so correct me if I'm wrong, but making a function const is mostly about making the "this" pointer const. A const function can still mutate global variables or call non-const functions, such as operator<< on cout. A pure D function can do neither of those things.

<comment><USER10> That's fair. C++ has const methods on objects, but I think nothing at global scope. But you shouldn't have global mutable state :-)

</comment></comment></comment></comment></comment><comment><USER14> Somewhat tangential, but I became infatuated with Idris's Effect system as a more approachable alternative to using monads directly. Yes, it's still monads under the hood IIRC, but the syntax is a lot easier to reason about IMO.

[https://www.idris-lang.org/documentation/effects/](https://www.idris- lang.org/documentation/effects/)

<comment><USER15> I feel like a recurring theme I find in Idris (though keep in mind it's just something I play with every now and then, not something I use with any kind of regularity) is that it has this "feels like Haskell, but less frustrating and cleaner" quality. I feel like I make less dumb mistakes while using it, and it gives me pretty much all the stuff I love about Haskell.

You of course have the relatively simple effects system (as mentioned),, but you also have the ability to use `do` notation without being in the monad context, and eager evaluation, which I find makes my program simpler to reason about.

<comment><USER14> I agree. I like to think that Idris is to Haskell what C# is to Java, with the exception that it's still a non-production-ready academic open source language.

<comment><USER16> It's not that academic AIUI - it was designed for production use, right?

<comment><USER14> From the release notes of 1.0[0] last year:

> Idris is primarily a research tool, arising from research into software > development with dependent types which aims to make theorem proving and > software verification accessible and practical for software developers in > general. In calling this "1.0", we mean no more than that the core language > and base libraries are stable, and that you can expect any code that > compiles with version 1.0 to compile with any version 1.x.

> Since Idris has less than one person working on it full time, we don't > promise "production readiness", in that there is still a lot to do to make > the compiler and run time efficient, and there may be libraries you need > which are not available. And, there will certainly be bugs!

[0] [https://www.idris-lang.org/idris-1-0-released/](https://www.idris- lang.org/idris-1-0-released/)

</comment></comment></comment></comment></comment><comment><USER17> Can someone please explain in a simple way what Monads are and why I want to use them in normal daily programming (assume, incorrectly, that I only know Python)?

I know I can google this, and have, and unfortunately I came away even more confused as a non-Haskell practitioner.

<comment><USER18> My advice is not to worry about it (unless the itch bugs you so much that you're willing to invest a lot of time researching the answer).

I don't think you'll ever get a single, straight answer that satisfies you. Just reading this discussion, I'm sure you can see that people describe monads in wildly different ways. Some descriptions are minimalist (perhaps a bit reductionist): it's just an algebraic data structure, nothing to get excited about. Many rely heavily on metaphors: containers, "programmable syntax", and yes, even burritos have been used to explain them. Some conflate monads with properties that do show up often in monadic code, but aren't themselves inherently monadic (immutable data, pure functions, sequencing of evaluation). Some are very language-limited, in the sense that the description invariably turns into a debate over the semantic fine-points of the language being used (this will almost _always_ happen when Haskell gets discussed, because expression evaluation is a very subtle thing in Haskell). Frankly it's a mess. The only safe ground you have is the algebraic definition, but that's not terribly useful for building an intuition about how one might _use_ them.

I think that you (and me, and most everyday programmers) would use them in your code only if you were using some library that was designed in a monadic style. In Haskell, so many libraries use monads these days that it's a given: using Haskell for any practical purpose means using monads, whether you want to or not. In Ocaml (about as close to Haskell as you can get without being purely functional), they show up mainly in third-party libraries, mostly when you want to do something tricky like asynchronous I/O -- again, you use monads if you want to use the library. But in run-of-the-mill imperative languages, though, monads don't tend to show up very often, and when they do, they usually are very specific to one library or another.

<comment><USER19> I like this answer, but it leaves one important thing out. Mathematicians have been studying abstraction for thousands of years. When they decide something is useful, that probably means it has broad applicability and enough functionality to get interesting results out of.

Mathematicians decided monads are useful.

Take advantage of that. Even if you're working in a language that can't express the abstraction, you can allow it to inform your library design. If something could be a monad, that's usually a better choice than something ad- hoc instead. (Sometimes it's overkill and a monoid would suffice, but both are better choices than an ad-hoc interface without any broadly accepted theoretical basis.)

<comment><USER18> I'm glad you brought up monoids here as a (sometimes) alternative -- in addition to their inherent properties, people have a much easier time wrapping their heads around monoids.

And yes, while abstraction is generally good, principled abstraction is generally better. At the same time, a lousy monadic library is still lousy. The sets of "great libraries" and "algebraically informed libraries" intersect, but neither subsets the other!

</comment></comment></comment></comment><comment><USER20>
       f = let s1 = 23 in let s2 = 42 in s2

Grammatically, this reminded me of Erlang. Hence, then indirectly of Prolog. And now that I think about it, Prolog is considered a logic programming language. I'm not advocating logic programming lanaguages, but it seems that it might stand to reason that the features of logic programming languages facilitate reasoning about programs written in them.

Looping back, Erlang doesn't generate discussions about monads. Erlang is engineered so programmers don't think about monads. Erlang programmers just use them. It's transparent. It's non-controversial because Erlang doesn't stake out an intellectual argument.

<comment><USER21> Erlang is pure, but it's not lazy, so it's not an issue like in Haskell.

<comment><USER20> I'm not sure there is anything lazier than "Let it crash." Erlang is lazy at the question in addition to being lazy at the answer. However, all that laziness is transparent because Erlang is an engineering artifact not an academic artifact.

</comment></comment></comment><comment><USER16> > The question is, just looking at the above code, it looks like "s" is > mutated. Yes the implementation in the monad could be pure and use state > threading, but how does that help us reason about the above imperative > program?

The value of the monad is precisely that both these things are true. We can use our fast-and-loose imperative intuition most of the time, but if we ever get confused about how the "mutation" of s interacts with some other effect (e.g. a continuation), we can desugar the code into the pure state-threading version and bring all the power of our pure, referentially transparent reasoning tools to bear. Most of the time we don't, because that version of the code looks a lot more cumbersome, but it's there if we need it. Whereas if we find ourselves in the same position with the Javascript, we're stuffed; when the effect interactions get too complicated to reason about imperatively, we have no alternative.

</comment><comment><USER22> You're using monads whenever you use Java 8 streams, Javascript promises, ActiveRecord and collection operations in Rails / Ruby; monads are everywhere these days. Monads are one of the handiest design patterns you can use; all you really need is a decent lambda syntax and you're off to the races.

<comment><USER23> The monad abstraction takes a lot of unlike programming features and abstracts away most of the important stuff to show something they have in common. The question is whether users of those features need to know about this abstraction? Why should we care that they have something in common? They're mostly different.

As concepts get more abstract, they get harder to teach. I don't think knowing that JavaScript promises are a monad is all that helpful when learning to do async I/O.

<comment><USER24> > _Why should we care that they have something in common? They 're mostly > different._

You can of course ignore it, but it's useful to care about this because they are actually _similar_ over this shared commonality. You start seeing patterns over which you can apply the same general functions. Just like you can map over an Option or a List or any "mappable-over" structure.

This is similar to asking (in a made up language, forget the specifics): "why should I care that Lists and Sets and Arrays and Enumerations have a shared 'iterable' interpretation? Sets and Lists are mostly different!" Well, because sometimes it's useful to have functions that operate on iterables, instead of writing one for Lists and another for Sets. Once this idea "clicks" in your mind, you start seeing more and more of this commonalities, and it starts to shape how you think about coding.

<comment><USER23> Sure, I agree.

My point is that just as with other design patterns, it's possible to overdo it and lose your audience. Enthusiasts can definitely go overboard here.

</comment></comment></comment></comment><comment><USER25> I stumbled through high school math and never took any in university so this is all wizardry to me. All I know is that when I began using immutable data in JavaScript, my data processing workflows and state machines became nearly trivial to understand and debug. Pure functions are also beautiful to reason about and test and debug.

I'm not sure about monads. I barely understand them. But if I could have one wish, it would be to make immutable data structures first class in more languages, like JS and Python.

<comment><USER18> Your intuition about the benefits of pure functions & immutability are spot- on, and I think that any proponent of monads would agree that these are fundamentally more important concepts than monads themselves. (Many of the ways that people use monads would break, or lose their point, if the data they operated over could be mutated outside of the monadic context.)

You can get an awfully long way with immutable data structures without involving monads. There are plenty of languages that give priority to immutable data, but don't have monads in any inherent way: Prolog, Erlang, Ocaml, and Scheme (to a slightly lesser extent) all come to mind.

<comment><USER26> Prolog has definite clause grammars (DCGs), which are _very similar_ to monads.

You can think of a DCG as giving you two _implicit_ arguments, which you can use to express concatenations and in fact arbitrary relations between states.

There are also ways to access these implicit arguments, which are similar to the corresponding constructs in Haskell.

DCGs are a very important feature of Prolog. They are frequently used for parsing and state transformation tasks. Like monads in Haskell, DCGs often make working with immutable data much more convenient, because you can make the more uninteresting parts of your code _implicit_. Other logic programming languages like Mercury also support DCGs.

<comment><USER18> It never occurred to me that there were similarities between DCGs and monads, but that's an interesting argument. Thank you for this!

</comment></comment></comment></comment><comment><USER27> I've been wondering a similar thing, lately.

In principle, I like the way that Haskell enforces purity at the compiler level, and kicks everything impure out to the boundary of the program. I can _try_ to write code that's that clean in another language, but it's always an unstable equilibrium. The compiler won't help me make sure functions stay pure, so all it takes is adding one little bit of statefulness to one function out there, and suddenly, like a virus, everything that calls it, everything that calls anything that calls it, and so on is impure, too.

On the other hand, monads are *@#$% opaque. I can't help feeling that, for many use cases, they are unnecessarily opaque.

At the risk of being branded a heretic, not all assignment makes a function impure. If the function never modifies or uses a mutable variable that's visible outside its scope, while it's visible outside its scope (e.g, it's fine to return that accumulator when you're done with it), and it's more efficient (either in terms of performance or code clarity) to get the job done with some mutation, why not? I'd like a language that doesn't worry so much about what consenting adults do behind closed doors. Rather than not letting me do it at all, I'd rather a language that just helps me make sure I'm doing it in a safe manner that doesn't lead to viral impurity.

<comment><USER28> > not all assignment makes a function impure

That's exactly what the ST monad/STRef's are for. {new,read,write}STRef let you manipulate mutable references while keeping track of their scope in the type of the reference. runST encapsulates a chunk of code that manipulates mutable variables in an externally-pure way into a pure function. The "Lazy Functional State Threads"[1] paper on it is a pretty good read.

[1]: [https://www.microsoft.com/en-us/research/wp- content/uploads/...](https://www.microsoft.com/en-us/research/wp- content/uploads/1994/06/lazy-functional-state-threads.pdf)

</comment></comment><comment><USER29> I think no, and why can be found in these articles:

[http://degoes.net/articles/modern-fp](http://degoes.net/articles/modern-fp)

[http://degoes.net/articles/modern-fp- part-2](http://degoes.net/articles/modern-fp-part-2)

<comment><USER30> Those posts by Degoes are more polemical than techniques that he actually uses in production.

</comment></comment><comment><USER9> Monads cannot be a waste of time. Monads just _are_. It can be a waste of time to design an effect system for Haskell around monads (it's probably not) or it can be a waste of time to design an effect system for Javascript around monads (it might well be). But _monads_ cannot be a waste of time.

<comment><USER31> Your comment is really pedantic. Obviously the concern is whether _using_ monads is a waste. If I say "television is a waste of time" are you also going to correct me that tvs just _are_?

<comment><USER9> By no means.

There's this idea floating around that monads are things that had to be "introduced" into Haskell to "solve" certain problems with purity. This idea is false. Furthermore this question misses half the point of monads, that is, that you can program generically over them. Sure, that one example makes the IO monad look just like code in any other imperative language. But I can also use do notation and monad combinators with lists, coroutines, promises, futures, ASTs, and indeed any other monad I care to come up with. It may seem that any individual monad _qua_ monad is a waste of time but when taken in totality it is a completely different question.

Since the question mentioned no other monad than IO it doesn't begin to address the important issues.

</comment></comment></comment><comment><USER32> > Are Monads a Waste of Time?

No, they are not supposed to have side effects.

<comment><USER33> Very funny. Although like most humour, somewhat wasted here.

<comment><USER34> I think at the right dosage, it's welcome. For me, mild doses of good humour upgrade the most serious of discussions without detracting from their professionalism.

<comment><USER35> Agreed, let's not become robot news.

</comment></comment></comment></comment><comment><USER36> Th author asks a general question, using JS code as an example of imperative code because it's faster to write and the syntax is familiar to many programmers.

The second top comment starts with:

> JavaScript is a mess with its truthiness, implicit conversions, dubious > semicolon insertion, second class references, automatic variable > declarations, weird scoping, etc.. You'd need to try harder to make the > Haskell imperative monad just as bad as JavaScript.

 _That is not the point_ , is it?

Thankfully most other comments discuss the actual question asked, not the pet peeves aimed at a particular language.

</comment><comment><USER37> I have been told a story that some CS courses trying to upscale to FP as the birth language have people teaching inside the IO monad to preserve imperative order, such that the graduates come out coding a strongly typed language almost completely bound in imperative systems design.

I feel the moments of clarity for me around the roles of monadic elements in a program are like brainwaves which vanish as soon as I try to grasp them. Right now, I'm stuck on the idea my FP colleague described as the boundary of the real-world, the thing which follows time order and cannot be gone back to in time or sequence. Most FP example fragments do things inside a domain of existence which is bounded solely by the variables of the problem. Solving a fibinnaci for some n thousand integers left in memory is distinctly unlike processing a UNIX pipe sequence yet the latter is said to be very like functional composition.

</comment><comment><USER11> The answer to the posters question is yes... monads are a waste of time if you're using them to handle state changes. It's best to just use explicit threading in that case.

The only time (I think) it's okay to use stateful monads in haskell is when it simplifies the code syntactically by removing extra cruft. Otherwise, explicit state is always going to be clearer to understand.

On the other hand, most uses of monads in Haskell are not to handle state. In my Haskell SQL library Beam[1] for example, we use monads to build a relational algebra AST at run-time and then dynamically optimize it. The SQL generating system inspects branches of the AST at run-time to generate sensible SQL expressions. Because the DSL is implemented as a monad, we get a bunch of stuff for free. At my work for example, we use a straightforward haskell `forM` to generate large joins.

Because of the Haskell purity, we can know _for sure_ that re-executing parts of the AST will not be dispruptive, because the code is pure.

I'm currently working on a little utility library for editing rich text with Haskell and I've used the continuation monad to automatically derive a zipper for my data structure. I get O(1) updates at my current position, for free. All I have to do is write a little interpreter. Because of Haskell's purity, I get a lot of functionality without doing anything. This is actually a big deal, as the same implementation in an imperative language involves complicated data structures and O(log n) complexity (look at the GTK text btree source file [2] for the kind of complexity I'm talking about). Because of the flexibility involved with the underlying monad, I have a 'fast' implementation of my zipper for simply modifying text, a 'visual' implementation that records a list of DOM updates to visualize the text as its being edited, and a 'network' implementation that outputs a list of commands for suitable editing. One simple data structure, one monad, three interpreters, and I have a collaborative text editing system.

Ultimately, the point is that you should only use an abstraction if it simplifies your code or reduces the error surface. If it does neither, then it's wasteful

[1] [https://github.com/tathougies/beam](https://github.com/tathougies/beam) [2] [https://github.com/GNOME/gtk/blob/master/gtk/gtktextbtree.c](https://github.com/GNOME/gtk/blob/master/gtk/gtktextbtree.c)

<comment><USER38> > I'm currently working on a little utility library for editing rich text with > Haskell and I've used the continuation monad to automatically derive a > zipper for my data structure.

Could you go into more detail about this?

<comment><USER11> Sure... most people familiar with zippers know that it can be thought of as the algebraic derivative the underlying type.

What's perhaps less known is that this is the same as 'differentiating' the traversal of the data type.

The continuation monad is a sort of 'derivative' of a computation in that it nearly captures the 'infinitesmal' difference between two steps in a computation.

If your computation is the traversal of your tree, list, or text markup, then you can make a zipper from that without having to declare new data structures. This is isomorphic to declaring your own data structure. Its only advantage is convenience (that I know of at least).

Oleg Kiselyov goes into great detail with this idea and has lots of example code: [http://okmij.org/ftp/continuations/zipper.html](http://okmij.org/ftp/continuations/zipper.html)

<comment><USER38> Thanks for the answer, it'll keep me busy for a week or two!

</comment></comment></comment></comment><comment><USER39> How is this related to Monads? This is an argument against mutation, or saying that Haskell doesn't handle mutation better than js, which is absolutely true; mutation is heavily discouraged in pure FP... Monads can be utilized to encapsulate the concept of sequential computation - if that sequential computation happens to be mutations you're gonna have a bad time.

</comment><comment><USER40> The problem here is not the Monad, but the "do" notation. Rewrite your code without it, and will be more clear and less "waste of time"

</comment><comment><USER41> As others have said, there are many different kinds of monads.

In my mind, for practical reasons, uniqueness typing >> state monad.

Uniqueness typing allows programmer to use stateful programming locally while developing strictly functional programs in at scale. Best of the both worlds.

</comment><comment><USER3> it's the only thing you can use if you want to write imperative style within pure FP. Obviously a simple example like that makes no difference, but with a giant app, if you eliminate mutations you get many benefits, and in such apps, sometimes you want to express things imperative, but still not mutate. So in other words, Monads are obviously useful, because the first assumption is that mutation is the root of most bugs, so you eliminate it but still use Monads to emulate it.

</comment><comment><USER42> Aren't the state like effects limited to the scope of that block?

<comment><USER12> No, but the state is part of the type signature, so the scope is explicit.

</comment></comment><comment><USER43> The much less discussed killer app of monads is monad transformers, which add a new dimension of program architecture to the toolbox.

<comment><USER44> I agree, although it's funny because the community has been trying to come up with replacements for mtl for some time now.

</comment></comment><comment><USER45> Maybe.

</comment><comment><USER46> Monads are just monoids in the category of endofunctors. Don't complicate that too much!

</comment><comment><USER47> Every discussion I've seen about functional programming is entirely divorced from the practicalities of real programming.

<comment><USER48> OK, I'll bite. Here's the essential truth of functional programming, applicable to all of real programming: _Constrain your state space or die._

</comment></comment><comment><USER49> Functional programming has the following issues:

\- it tries to abstract away von Neumann architecture and make it more math- like, stateless, true and permanent. Yet von Neumann is completely stateful (resembling real-world in its complexity and model approach), causing all kinds of frictions, for which monads and other syntactic sugar were invented

\- while Turing complete, it has some weird properties, making it difficult or inefficient to change communication between various components that are using deep function calls when such a need arises in the future. This leads to using mutable "shortcuts" that render a lot of advantages functional programming might have had useless and starts resembling imperative/OOP programming with its issues again

\- trivial things like IO can't be modeled without side-effects, so any software requiring input from keyboard, loading external files etc. can't be pure

\- often functional constructs make code unreadable despite readability being one of the main reasons for its existence

\- bottom-up creation of algorithms is preferred by many language authors, making it difficult for beginners

\- if you really want to know how it works, it takes 5+ years PhD level of studies in abstract math

Disclaimer: I approach 100 languages I've used in production, worked for companies that created some of the most popular languages and hate them all ;-) I hope to work on AI-assisted language creation in the near future.

<comment><USER44> Hello, most of your points seem wrong in the extreme and I feel like addressing them. I confess I pressed the enter key hard a few times as I wrote this, gritting my teeth at some of your points. But I have tried to keep a level tone to help people see that many of these points either are simply FUD or, in a few cases, haven't been true for well over a decade.

But, _first and foremost_ , it's very clear you've conflated Haskell (and perhaps Purescript?) with all functional programming. This is a mistake, and many functional languages do not make use of pure functions, laziness, monads, or algebraic data types.

> \- it tries to abstract away von Neumann architecture and make it more math- > like, stateless, true and permanent. Yet von Neumann is completely stateful > (resembling real-world in its complexity and model approach),

Most languages abstract away von Neumann architecture to some point. This is generally seen as a feature, as the notion of "von Neumann" itself has evolved substantially over time such that many historical practices are no longer meaningful (example: overlays).

For the last 2 decades, it's been considered Industry Best Practice to do this, as we're increasingly finding we don't want the limitations of this classical architecture to limit our computations or computers.

For example, it's quite easy to push computations to GPUs or TPUs in Haskell because by default it doesn't force assumptions onto users about what state means.

> causing all kinds of frictions, for which monads and other syntactic sugar > were invented

No, Monads were not invented to solve this problem in Haskell. They were a subsequent improvement to the original solution.

> while Turing complete, it has some weird properties, making it difficult or > inefficient to change communication between various components that are > using deep function calls when such a need arises in the future.

This is quite untrue. And if it _were_ true then it's quite a curious chain of events that functional composition has only become more mainstream and relied upon in many languages, and before the proliferation of closures and functional composition frameworks and techniques (e.g., Dependency Injection) came into being to model the kinds of interactions composed functions make natural.

> This leads to using mutable "shortcuts" that render a lot of advantages > functional programming might have had useless and starts resembling > imperative/OOP programming with its issues again

I am surely not alone in having no idea what you're talking about other than perhaps the occasional use of unsafePerformIO in haskell, but even then.

> \- trivial things like IO can't be modeled without side-effects, so any > software requiring input from keyboard, loading external files etc. can't be > pure

Monads are a way of modeling impure computation purely. And IO _is_ a side effect. It's absolutely wrong to suggest the IO monad is some short of shortcut or inherently impure, or that it's deficient in any way compared to a block of Javascript for modeling the real world.

None of that is true.

> \- often functional constructs make code unreadable despite readability > being one of the main reasons for its existence

This is a matter of opinion and training. One could make the same argument of React/Redux reducers (really, the state transitions are in the actions?), Google's Guice DI framework (what is happening), or elaborate builder-notation spec framework tests.

Most people will find languages like Clojure or Ocaml pretty familiar.

What I will agree with is that languages that more closely model referential transparency tend to appeal to some tools modeled after category theory that require up-front study to really understand and apply. Most languages have one or two things like this: Ruby has proc vs block, Python has many arbitrary restrictions and list comprehensions, C has pointers, C++ has generics, Java has reflection, Javascript has callbacks, Haskell has Functor->Applicative->Monad.

> \- bottom-up creation of algorithms is preferred by many language authors, > making it difficult for beginners

This has _nothing_ to do with FP and everything to do with programming in a modular fashion. Every language with modules naturally leads people to bottom up styles. That includes Javascript.

> \- if you really want to know how it works, it takes 5+ years PhD level of > studies in abstract math

The Haskell compiler is a big, complex piece of work. But so is the C++ compiler, the Java JVM is surely bigger, the CLR is fantastically complex, and have you ever looked at some of the bugs in the Python interpreter?

Of course it takes dedicated study to understand a modern compiler. That's only natural.

> Disclaimer: I approach 100 languages I've used in production,

Okay. 100.

> worked for companies that created some of the most popular languages and > hate them all

Who? Maybe we've worked together.

> I hope to work on AI-assisted language creation in the near future.

You're very late to the starting line here.

<comment><USER49> > Who? Maybe we've worked together.

I don't want to be doxxed, but let's say I worked for your fierce competitors and the ones your former employer "borrowed" a lot of ideas from. Also rejected an offer from them.

> You're very late to the starting line here.

I am not talking about gradient boosted decision trees-based meta-programming here.

Finally, it's good to have an open discussion about this. I simply don't want to tell everyone that functional programming is the "promised land". I hope we can figure out much better programming abstractions in the future.

Good luck at Udacity, some NDs like SDC/Robo/DLF were simply awesome!

<comment><USER44> > I don't want to be doxxed, but let's say I worked for your fierce > competitors and the ones your former employer "borrowed" a lot of ideas > from. Also rejected an offer from them.

You worked for Sun and Oracle, then? I imagine the feelings around the (somewhat technologically inferior but vastly more popular) JVM are pretty complicated.

> I am not talking about gradient boosted decision trees-based meta- > programming here.

Neither am I.

> Good luck at Udacity, some NDs like SDC/Robo/DLF were simply awesome!

Thank you.

<comment><USER49> > I imagine the feelings around the (somewhat technologically inferior but > vastly more popular) JVM are pretty complicated.

Yeah, type erasure messes up everything, you can feel its bad influence on Scala & Kotlin. I am a big fan of Anders' languages since Delphi days as well and listening to ideological justifications internally how JVM is better or IDE is evil was sometimes funny. But it was open, so it won in the end and I am glad about it :)

But it wasn't the only company, I worked for; another one that produced another rising star and was deep in meta-programming as well; with love-hate relationship with your former employer as your ex would love to kill us but some of your customers completely depended on our products, so you had to let us live.

I am looking at how to use Deep Learning/RNNs/NLP/TTS/SS/CV in automating away many of the annoying rudimentary development tasks in favor of programmers only caring about higher abstractions. IMO for that I found functional programming woefully inadequate; your opinion might be different, nevertheless I'll see if I can push it in the direction I like in the future and how far it can get.</comment></comment></comment></comment></comment>


Redfin CEO Glenn Kelman sounds off on housing market: U.S. a 'landlord nation' - <AUTHOR> https://www.geekwire.com/2018/redfin-ceo-glenn-kelman-sounds-off-housing-market-says-u-s-become-landlord-nation/ <comment><USER2> One of the most important political fights for almost anyone under 40 is the fight to smash what this author correctly calls a "housing cartel." It's not a formal organized cartel but the effect of NIMBYs and neighborhood associations and the like is collectively identical to one.

I don't personally care if these people are "well-meaning" or not. They're destroying the economic welfare of an entire generation -- namely their own children.</comment>


The State of XMPP and Instant Messaging [pdf] - <AUTHOR> https://fosdem.org/2016/schedule/event/state_of_xmpp/attachments/slides/957/export/events/attachments/state_of_xmpp/slides/957/FOSDEM_2016__The_State_of_XMPP_and_Instant_Messaging.pdf <comment><USER2> I think that Telegram is more like 3rd one.. It has nice desktop apps and group chats with bots like jaconda.im Dunno about other messengers, but Telegram offers channels! And this is awesome! + nice options to share with telegram via some links

<comment><USER3> Telegram is still 2nd gen, as Group Chat is secondary feature, no message correction, but has reply</comment></comment>


Ask YC:  What would happen in social news if people submitted/voted on short search engine queries? - <AUTHOR>

There would be no title or URL, just a short search engine query.<p>Would this be interesting? Would it result in more variety? <comment><USER2> I think spamming and black hat SEO tactics would make it tough to keep things fair, but if you could beat that problem sure.

</comment><comment><USER3> Amichail, as much as I appreciate your sense of creativity, I sense that a lot of what you suggest doesn't solve any issues, or wouldn't even be something people find useful and enjoyable to use. Perhaps you're thinking about it too analytically. Take a more dumbed down approach, and be more critical of people's lives in general. You'll come up with a horde of relevant issues to remedy.

<comment><AUTHOR> If something is entirely obvious, then it probably wouldn't interest me much.

If something is potentially useful/enjoyable but not obviously so, then it probably won't attract many users.

I guess I like experimental ideas more, but users are probably less willing to invest their time in experiments.</comment></comment>


Why I won't work for Google - <AUTHOR> http://qnrq.se/why-i-wont-work-for-google/ <comment><USER3> The primary reason I won't work for Google is because I'm nowhere near smart enough. But I like to tell myself that the ethical shortcuts they've taken in pursuit of the almighty dollar are a good secondary reason. It's just that I don't need a secondary reason, so yay, consequence-free ethics!

<comment><USER4> > The primary reason I won't work for Google is because I'm nowhere near smart > enough

I think plenty of people tend to vastly overestimate Google's (or Facebook's, ...) hiring bar. I know quite a few people who would be happy to work there and (I believe) can easily beat the hiring process, but they self-eliminate themselves from the game, so I definitely recommend to folks not to make a prejudice about whether they can get into, because they generally don't have many data points, and go interview anyway. Let them figure out whether you are smart enough or not; don't self-eliminate. Never let the widespread propaganda lead you to believe that everyone hired by a successful company in the valley is a genius. They collectively hire many thousands of people; it's hard to believe they are all geniuses.

<comment><USER5> Honestly, I used to think the same way. I am a college dropout that has about 3 years professional experience (thoigh I have been programming since I was a kid) and I suddenly have a Google recruiter coming after me and trying to get me to interview. I have worked with a guy who now works at Google and some people who interviewed at one time or another. They say the same thing as the parent post; Google hires good programmers, and they happen to have some geniuses. Don't quit the race before you even start it.

<comment><USER6> Did you actually interview with them? I have Computer Science education, 10+ years of industry experience, am very familiar with most of the Cormen book and have been programming since I was a kid. I was interviewing with Google twice (after their recruiters reached out to me) and haven't made the bar.

Don't think that the fact of recruiter getting in touch mean anything -- they are playing their own numbers game.

<comment><USER7> > Don't think that the fact of recruiter getting in touch mean anything -- > they are playing their own numbers game.

Exactly. In some conversations I've had with fellow dev's they seem to equate a message from a recruiter with a job offer. I never understood this. Sure, I get messages from recruiters on LinkedIn but it's prob. the same generic letter blasted to hundreds or even thousands of candidates. The quality of your online profiles (SEO?) as a programmer is directly related to the volume of messages you get from recruiters.

<comment> brown9-2 It's an easy mistake to make when you aren't very familiar with the modern recruiting process.

It is literally the job of the recruiters to keep the pipeline as full as possible.

<comment><USER5> I don't make the mistake of thinking a recruiter calling me on several occasions, attempting to get me to interview is a job offer. What I find surprising is that the recruiter still wants me to interview even after I explained who and what I am. Maybe that's just an overzealous recruiter trying to fill numbers. Maybe Google has relaxed standards outside of what people usually think. One of the first things I said to the recruiter was something along the lines of "Are you sure you have the right guy?"[0] followed up with "I'm not quite sure that I am qualified". Between talking to the recruiter and people who work there or passed the interview, it sure doesn't seem like they are only looking for geniuses.

I'm just trying to offer a point of data regarding what Google by proxy of their recruiters, looks for. The recruiter himself has been working for Google for quite a while, so either he really knows how to game the system, is currently desperate, or Google doesn't have as extreme standards as one would think.

[0] - [https://twitter.com/67726e/status/431870786169630720](https://twitter.com/67726e/status/431870786169630720)

<comment> brown9-2 I don't think it really matters to the recruiter if you are qualified, or if they are judged on how many people they source end up getting offers. They are just there to get you in the door.

<comment><USER5> I suppose that would depend on how the recruiters operate. I'd imagine that at Google's size, they probably have recruiters just feeding people into the pipeline. I tend to assume people aren't just doing a shitty job, in this case throwing people at a wall and seeing what sticks, despite how much it clashes with my "imposter syndrome" mentality.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER8> I'm still waiting on proof from Snowden as to Apple/Google/Facebook's direct, illegal cooperation with the NSA. So far, all I've seen proof of is compliance with warrants(which admittedly are questionable, but Google has a direct financial gain in fighting them, not helping them), claims that they've fought them, and evidence that the NSA is both tapping the trunk as well as decrypting SSL'd communications.

<comment><USER9> > Google has a direct financial gain in fighting them

Wait, what? Google has a direct financial gain in fighting warrants? How do you figure?

<comment><USER8> In fighting overbroad warrants, via the National Security Letters. Having NSLs at all significantly increases consumer distrust in Google, and gives them literally zero gains in return. It even costs them work, if you're looking at the small stuff. They don't get anything out of it.

Edit: Clarified what NSL means.

<comment><USER9> NSLs and warrants are completely different things. Warrants are (or can be) for the contents of messages, and must be signed by a judge. NSLs only cover metadata, and only require an FBI agent's signature. An NSL is a type of subpoena, not a type of warrant.

Also, fighting them takes work too. Much more work (done by more highly-paid individuals) than complying with them. The PR angle may make it a net gain, but I don't think there's a slam-dunk case for that being true. What about consumers who believe NSLs are a necessary tool to fight terrorists?

<comment><USER8> > NSLs and warrants are completely different things. Warrants are (or can be) > for the contents of messages, and must be signed by a judge. NSLs only cover > metadata, and only require an FBI agent's signature. An NSL is a type of > subpoena, not a type of warrant.

Are we sure that's all NSL's cover? I've been told repeatedly that we can't be told _what_ is required under the NSLs by their very nature(despite being overturned by the Supreme Court). Also, I was under the impression a subpoena also requires a judge's approval.

Regardless, while the two(a subpoena and a warrant) are different, in this case their nature is more than a bit similar, considering subpoenas generally are used to produce information, whereas warrants are to be able to reasonably search for information- which on a server, the two are only differentiated by who is accessing the data and how.

<comment><USER9> >I've been told repeatedly that we can't be told what is required under the NSLs by their very nature(despite being overturned by the Supreme Court).

NSL power is defined by law, and is limited to metadata, not content. I suspect what they meant is that specific details about whose information is being requested, and how many requests are received, can't be released.

>Also, I was under the impression a subpoena also requires a judge's approval.

An administrative subpoena is a type of subpoena that does not need to be signed by a judge. An NSL is a type of admin subpoena that the FBI uses for national security matters, but the FBI uses admin subpoenas in other investigations, too. Many other federal agencies also have admin subpoena power, and some states grant it to their agencies as well.

</comment></comment></comment></comment></comment></comment><comment><USER10> Perhaps a few people don't understand why OP takes this so seriously. This is the 'long game', the game for the betterment of human existence. (Cliche? yes, true enough? - probably)

If you still feel these huge corporations have our best interests at heart, you are being a touch naive.

They are not 'evil' ofc, but they're probably not the best idea for the future.

<comment><USER11> What is your best idea for the future? Do you think I or anyone else would find it palatable?

Here's the thing: the profit motive is the impulse of corporations, not the sum total of all behavior. There are great people in corporations that do amazing shit within corporate structures. Coca-Cola have done incredible social art installations recently - [http://www.youtube.com/watch?v=ts_4vOUDImE](http://www.youtube.com/watch?v=ts_4vOUDImE)

Google is a huge corporation based on the profit principle, but making coin has been the means for Page to fulfil his dreams of being remembered as our modern Tesla.

<comment><USER12> About Coca Cola, there is this very good talk by Melinda Gates about what they do in the developping world: [http://www.ted.com/talks/melinda_french_gates_what_nonprofit...](http://www.ted.com/talks/melinda_french_gates_what_nonprofits_can_learn_from_coca_cola)

I think enabling enterprising people to do business may be the most positive thing Coca Cola does to the world.

For Google, it seems making money is not the end game. What they do have many positive fallouts, but I'm not sure they move the 'real' world forward as much as Microsoft (while openly evil, they brought a unified computing environment to the world) or Apple or even Amazon.

<comment><USER10> With all due respect, and thank you for the reply - I feel compelled to say this:

I used to think like that, however after many years of observing the _complicit_ abuse corporations like these preside over - I can no longer hold that opinion.

<comment><USER12> If it is about Coca Cola, I have an idea of what kind of abuse or corporate behavior it has, and I don't think 'sugared water' is much needed in our world (I don't deny the value, I just think it's not a need). But even for such a company, there are some positive fallouts.

In the ranking of evil companies, I'm not sure they even come close to the French water groups or big medical corporations, but I might just lack information.

Edit: for Amazon and Microsoft, of course I get how bad they can behave. Amazon more so when it comes to distribution level workers and general social behavior. Microsoft I don't kniw if there are people ignorant of what they did the last decades.

</comment></comment></comment></comment></comment><comment><USER13> > We witnessed Google sending cease and desist letters to the developers and > maintainers of the popular Android CyanogenMod for violating some patents by > modifying open source elements of an open source licensed project

Taking into account that this is not what happened between Google and Cyanogen I doubt about the knowledge of him

<comment><USER14> He doesn't even get the phrase "Don't be evil" right. He writes "Don't do evil" multiple times.

Then he is surprised that google reads email. How else are they supposed to find out if something is spam or not if they don't read it? And email isn't secure in the first place. Anyone that doesn't know that shouldn't be up for a technical job at an internet-based company in the first place.

It seems like his complaint is that google allegedly turned emails over to the government. Well then why is he bringing up the distraction of "google reads my mom's email!!!"?

</comment></comment><comment><USER15> I can't access the linked blogpost because the website is offline, but from the comments here I understand that the main reason the author is invoking for not working at Google is because of Snowden's revelations and Google implication with the NSA.

I think this is strange, we knew way before Snowden's revelations what Google did with the privacy of their users. That in itself should be enough to not want to work there, if you care about it. I know more than a handful of people (including me) who refused jobs from Google (often more than one time, for example I had to ask them to write down to not contact me again after the third time) _before_ Snowden's revelations. The reasons were multiple: "don't be evil" is a joke, Google has been a big company for years now and not really a fun startupy place, it may happens that the job you want is not the kind of jobs that Google offers, and it's not even true anymore (or at least, it is less and less) that having worked at Google make your resume special.

<comment><USER16> cache:qnrq.se/why-i-wont-work-for-google/

<comment><USER17> I don't know if ironic is the right word, but it certainly is funny reading the Google's cached version of the article.

<comment><USER15> And I suppose in a Google browser too, because as I expected, my Firefox doesn't know what to do with cache: URLs.

<comment><USER18> Stick it into Google: [http://google.com/search?q=cache:qnrq.se/why-i-wont- work-for...](http://google.com/search?q=cache:qnrq.se/why-i-wont-work-for- google/)

<comment><USER19> This doesn't work behind the great firewall, unfortunately.

</comment></comment></comment></comment></comment></comment><comment><USER20> The response doesn't seem convincing. By this standards he's not supposed to work for any corporation. I am a Google fanboy, I agree, and this might skew my opinion, but I am always open to debate.

<comment><USER21> Agreed. The response seems to conflate a bunch of different things and pretend it's all Google's fault. Snowden didn't blow the whistle on Google. Google can't control what the NSA is tapping or what court orders it gets. Maybe some people inside Google knew about inter-datacenter taps and didn't do anything about it, but once all of Google became aware, they started encrypting those links. Automatic indexing of email contents leaves Google open to subpoenas for information about that indexed content, but the emails would be there to subpoena either way. I don't understand the problem.

What has Google ever done to _help_ TLAs wiretap anyone?

<comment><USER22> Encryption is worthless if you have handed over the cipherkeys... but I guess this might fool some of the public at least.

<comment><USER23> Encryption can be done in a matter where the private keys are stored in the user's end, making it far harder for the likes of the NSA to break the encryption.

One example of this is Jitsi's implementation of Off The Recording chatting. When using an XMPP server through Jitsi, the NSA may be able to read the cipher text sent but not the plaintext because the keys are stored on the chat participants computers. Not even the chat server owners know the chat plaintext.

</comment></comment></comment></comment><comment><USER24> "Nicklas, a simple no thank you I am not interested would have sufficed -Patrick"

</comment><comment><USER25> I think this unduly conflates his displeasure at the automated scanning of emails to target advertising and the NSA etc. bulk access to data. The former doesn't make the latter any more likely. All webmail services must hold their customers' emails, and they are therefore open to being read by a government or third party. Users could encrypt their emails, but it's very hard to do this while also making logging in and accessing anywhere fast easy for all users.

<comment><USER26> Yes, exactly.

Any webmail service that stores email unencrypted on its servers is subject to subpoena / FISA requests, and there isn't much they can do about it.

They could roll out client-side encryption -- but there's little business incentive for them to do so on free accounts. That said, as an option for paying apps users, it would be quite valuable.

Automatic scanning of emails isn't ethically suspect in my opinion.

My reasons for not working at google right now are: lack of desire to engage in big company politics, the apparent softening of the 20% time policy, regular-corporate/long hours, and the commute I'd have to take. Otherwise it'd be near top of my list should I go back into full time business.

<comment><USER27> What about the fact that they colluded with Apple and other companies to keep their engineer salaries as low as possible?

<comment><USER26> I'm by no means a fanboy. From what I understand the salary thing wasn't exactly a conspiracy, but it was an extremely poor policy. I don't think anybody has much to complain about in terms of the benefits package from google, though.

In terms of "big companies", their sins are relatively innocuous, and if I wanted to work in big tech they'd be #1 on my list given the technology & resources that they make available. I'd certainly never work for Apple, Facebook, Oracle or Microsoft. I'd need a lot of convincing to work for Amazon.

</comment></comment></comment></comment><comment><USER28> All mainstream modern technology companies are in a no win tragic situation. They are accountable to the state which overrides their ability to make any kind of actual independent decisions when the interests of the state are at stake. Going against this would be an exercise in futility and you may well end up in prison for doing so.

Getting angry at them for what they are forced at gunpoint to do is just wasted energy, though I do agree with seeking alternatives free from the influence of the state and not patronising companies that are forced to operate in those interests purely from the perspective of pragmatism.

All they can do is stick to the letter of the law. I think the harder the state clamps down and the more totalitarian it becomes, the more black market alternatives for mainstream services will come into being and the more pressure there will be for a truly free parallel economy to flourish.

<comment><USER29> > All mainstream modern technology companies are in a no win tragic situation.

Actually the big companies (and to a lesser degree other significant entities like Wikipedia) that essentially hold the keys to the Internet and have the money -- if anyone, they are in a position to change things. They have tremendous power. Think civil disobedience. Corporate disobedience? There are many legal as well as illegal things these corps could do to flip the bird at the state. And the result might be that they get heard, unlike all the EFF campaigners and individuals who can only complain on Internet forums.

<comment><USER30> A company called Qwest tried that, and its CEO ended up in prison on trumped- up charges of insider trading. Calls for other people to become martyrs for your favorite cause don't have a lot of moral authority in my book.

<comment><USER31> > ended up in prison on trumped-up charges of insider trading

Or on charges that fit the statute, but are over-criminalized.

We have way too many laws. Everyone is violating them, so drawing the ire of criminal prosecutors = jail term.

</comment></comment></comment></comment><comment><USER32> This is a lot longer than my response I gave the Google recruiter:

      I appreciate you contacting me, but I'm currently in the process of
      raising a funding round for my startup which precludes me from
      looking at other opportunities right now.  However; if you know any
      investors in the IoT space, I would love to chat.

Funny thing is that in about 6 months, they are going to probably contact Him, and Me again.

<comment><USER33> Here's what I wrote them last time, more or less:

> Thank you for your interest and taking the time to discuss employment > opportunities, but at this time I have decided not to pursue a further > relationship with Google as an employer. I wish you the best in your future > endeavors.

<comment><USER34> Mine was:

"Unfortunately, Google is not a company i have any interest in working for. Thanks for getting in touch, though, and good luck with your hunt."

The impression i've formed is that Google is full of people who are quite smart, but think they're really smart, and have decided to build themselves a technical ecosystem that has no interaction with the rest of the world. That doesn't sound like fertile ground for personal growth.

Also, given that i am in London, it would have meant working on AdWords, which sounds dull.

<comment><USER35> I'm also in London. Last time (5-6 different Google recruiters over the last 6-7 years) I went through phone screening with the recruiter after she was very convincing when telling me why this time would be different (after I'd given her my "standard" paragraph by e-mail about why I generally think talking to Google is a waste of my time). This was for a management position, and she then got me set up for technical interview.

The guy in question gave me a bunch of totally idiotic questions about details about filesystem implementations, and clearly didn't like it when I pointed out to him that there wasn't one single answer to the questions he raised the way he'd asked them, and proceeded to give him an outline of the various solutions that applied for a few different filesystems. He wanted specific textbook details about a filesystem that was entirely irrelevant for the position.

My impression was that he was "textbook smart", and would answer questions about the specific stuff he'd studied very well - the questions he asked fit very well with that -, and would probably excel at brainteasers, but his interpersonal skills and broader understanding of the subjects he asked me about appeared to be so weak that had I been on the other side of the table, I'd never have considered hiring him.

I "failed" that interview, only to have the recruiter bring it up in some recruitment committee or something and get it set aside and get me through to the next step on the basis of the notes I sent her of all the issues I saw with the questions. But only after she spent a lot of time lamenting the process (this is a common team with Google recruiters - every one I've spoken to has been incredibly frustrated at their own processes).

But by then I'd lost interest - the guy in question was in the group I'd have managed, and I really did not like the thought of having to deal with him on a daily basis. Or the thought of a team staffed with similar people... Or the thought of working somewhere where the HR processes are so messed up that their recruiters spends half the time they talk to me apologising about how their recruitment works.

I know there are lots of great people at Google, but every interaction I've had with their recruitment process makes me less inclined to want to work there.

</comment></comment></comment></comment><comment><USER36> [http://webcache.googleusercontent.com/search?q=cache:b-3Zibp...](http://webcache.googleusercontent.com/search?q=cache:b-3ZibpM6IIJ:qnrq.se/why- i-wont-work-for-google/+&cd=1&hl=en&ct=clnk)

<comment><USER37> How ironic that one would be using Google's cached version to read this

<comment><USER38> More ironic that Google has a cached copy and CloudFlare not.

<comment><USER39> Not really ironic because nobody expects that CloudFlare Always On cached copies will actually work.

</comment></comment></comment></comment><comment><USER40> Pretty well-written sentiment, only thing is that recruiters cast a pretty wide net and certainly wouldn't read through anyone's life story if presented with the opportunity.

However, I'm sure that if every person who gets contacted by a Google recruiter responds with a similar diatribe about their disillusionment with Google's ways, they just might take notice.

<comment><USER41> Since it's made the top spot on HN, the recruiter himself no longer matters. Hundreds of Google employees will read it today.

</comment></comment><comment><USER42> Just out of curiosity, what do you folks see as the difference between looking at text with the intent to correct spelling (like this text box does) versus looking at text to put an advertisement next to it?

(If I wanted to go reductio ad absurdum, what about looking at text to change <a href="...">foo</a> into a link?)

To be clear: I'm honestly curious, not trying to defend or advocate for one interpretation over another.

<comment><USER23> In my opinion, Google's activities are "evil" because they intentionally profile their consumers through parsing all their personal data (email, shopping history, etc). Furthermore, Google chooses to spy on their users through a matter that allows the NSA to collect entire profiles for Google's users. Google does this mainly for the money involved.

<comment><USER43> Agreed. I also have no visibility into the data Google has gathered about me, or any way of telling them to delete all the data they have on me.

<comment><USER44> [https://www.google.com/dashboard](https://www.google.com/dashboard)

</comment></comment></comment></comment><comment><USER45> I won't work for google, apple, or microsoft due to the illegal no-poaching agreements they made. I don't want to work for amazon because they are retail - engineering is overhead to be trimmed.

Through some weird twist of fate I find myself actually admiring Facebook, not the site, but the company.

<comment><USER46> Most of the large tech companies mostly turn me off, though there are little glimmers of things they do that are positive. Ironically, I've been breaking my radio silence on G+ over the past couple of days discussing some of this in relation to Gundotra's exodus and the "death of G+" discussions (short answer: yes and no).

I just got accused of having favorable views of Facebook (I don't -- I think what the company does is detestable and Zuck's morals are beyond reprehensible .... except that the company's stand in breaking the wage-suppression collusion cabal was a stunning case of doing the right thing).

But in terms of a company which could tempt me ... there aren't many.

<comment><USER47> Personally, I want to fix them if possible. That is why I posted a wishlist for Satya on a blog's comments for example, and why I like to discuss Google with for example michaelochurch. On Facebook, I posted this: [http://www.quora.com/What-has-happened-to-Mark- Zuckerbergs-o...](http://www.quora.com/What-has-happened-to-Mark-Zuckerbergs- opinion-on-privacy-since-the-early-days-of-Facebook?share=1)

</comment></comment></comment><comment><USER48> To be fair Google is a great company. But because of some actions they have taken they are not so outstandingly appealing as they were few years ago. Of course that's natural given their size. Many big companies are way worse. But still, they are now just another company that's good to their employees (many of whom are still quite passionate about it). No more, no less, that's all Google is.

</comment><comment><USER49> Wouldn't want to work with this guy. Fair points but come on, the poor recruiter is the wrong person to rant to.

<comment><USER50> _the poor recruiter is the wrong person to rant to._

Why? If enough talented individuals reject a Google position (or more accurately, entry to Google's interview process) for moral reasons, the message will be sent up the chain of command.

Google thrives on talent. If it becomes hard to acquire new talent, they have a serious problem.

<comment><USER51> Well, for one thing, rejecting it at the point of a recruiter reaching out to you is a weak signal. Get through the hiring process and then reject the job offer, and it will become a much stronger signal. I'm willing to bet dollars to donuts that way fewer people reject job offers than turn down recruiters soliciting for a phone screen.

With only a little bit of sarcasm, I would also say that accepting the job offer, working loyally for some amount of time, and then quitting in protest would be a much stronger signal still.

</comment></comment></comment><comment><USER52> Quite frankly if we put in a balance everything good and bad Google has ever done, the positive things they've done outweigh the negative things by a ton. I think that of all the tech companies Google is the most awesome. Seriously I am glad I don't have to pay an Apple tax or a Microsoft tax to develop mobile apps. I am grateful that Android is OSS just for that Google will always have my sympathy.

<comment><USER53> You are paying a Google tax. It's simply being paid on your behalf by advertisers, who get reimbursed from you when you buy products from companies who advertise on Google. If you don't buy any products that have advertising costs, then you are being subsidized by other consumers. In addition, we all are paying for the overhead inefficiencies of this indirect system, with all the middlemen and middle-pieces involved. Lastly, we all pay for the social costs of advertising. We'd all be better off if Google and the other so-called free web services nixed ads and just charged us straight up.

There is no free lunch, and there is no free web. We all have to start seeing this truth.

</comment></comment><comment><USER54> There are more reasons to not work for Google, including their (sometimes?) rather poor interview process.

<comment><USER20> That comes as a surprise to me. Poor interview process? They have the world's best engineers at their disposal, don't they? A poor interview process would point otherwise.

<comment><USER55> "They have the world's best engineers at their disposal"

That's what they like telling the world. They probably employ a lot of smart people, because they can afford better work conditions and salaries.

However, they don't have the monopoly on smart engineers. You can't rank people from best to worse: everyone is different. You can certainly recognize that some people are smart, but there is more smart people outside of google than inside.

The notion that they "have the best" is ridiculous, because there is no such thing as "the best engineers".

I'd prefer saying they have optimized picking their engineers so that they have more chance of picking smart ones.

</comment></comment></comment><comment><USER56> A better Google is one you pay for and whose income and subsequently motivations align with the customer, not third parties.

The idea of Google being a virtual personal assistant who knows everything about you but who you can trust to keep that information private is very cool and I think more aligned with where Google really wants to go. The problem is that they need to rely on advertising for now which means you'll never really trust what that PA says and what it is telling others about you.

</comment><comment><USER57> I think it's naive to be that proud. Sure Google isn't the best company in the world as far as its policies about costumer data and privacy but if OP's mother or friends are really concerned about their privacy they can opt out and use another equivalent service to Google Search, Gmail, etc. But then again most mainstream services if not all have their own dark policies, don't they?

</comment><comment><USER58> If you want Google to leave you alone for the rest of eternity, all you have to do is go work there and enjoy the perks for a few months (the food is excellent and they pay quite well) and then try to find work more suitable to your skill set than what the Hogwarts Hat of blind allocation has assigned you to for the next 2 years of your life(1).

Since you will most likely have been assigned to a team no one wants to work on (hence the openings), the mere act of questioning the almighty G will enrage the inept mid-level management chain and they will in turn blacklist you with HR. Once you are blacklisted, you will be cordially invited to not let the portal barrier impact your posterior on the way out. And beyond occasional accidental profile views on linkedin, no more Google recruitment spam.

It worked for me. It can work for you.

1\. Exceptions to this rule are when you are hand-picked for a moonshot, an acquihire, or for your specific skills, at which point, Google is an excellent place to work. Ignore everything I'm saying in these cases, you've hit the jackpot.

</comment><comment><USER59> It's not so hard to get in touch with Google recruiters. You just need to get a not so bad score at their Codejam contest.

As a side note, about a year ago, a girl from Google called me from London for a job opportunity (in French, my mother tongue, it nicely surprised me). Anyway, I put the girl call down as I was waiting a call from my then girlfriend to meet up for our first date. We all seem to have different reasons to refuse a job opportunity from Google !

</comment><comment><USER60> A 2011 version, different author [https://news.ycombinator.com/item?id=2933619](https://news.ycombinator.com/item?id=2933619)

</comment><comment><USER61> He made Patrick read way too much. I wouldn't work for Google because I consider it to be an extremely dangerous and immoral company. It's not the only one but it's up there at the top with the likes of Facebook and to some extent Microsoft, Oracle, Apple.

One could go on forever on this but an email to them is probably not the right place to do this (although he did publish it).

</comment><comment><USER62> if only Patrick got a dollar every time he got this response

did anyone else find the quote at the end at least a little ironic?

<comment><USER36> he must get more than a dollar, from his employer

<comment><USER62> depends how many of these he gets

</comment></comment></comment><comment><USER63> There are typical kinds of people. He seems to be very idealistic. And it's awesome and free advertisement for him as a person/hacker, where he (and his github projects) now can profit. He is in high dept towards google now :)

</comment><comment><USER64> Oh please. You got contacted by a recruiter and NOT given a job.

</comment><comment><USER65> a bit offtopic: I suppose cloudflare's "always online" mode wont work unless the origin server sends a cache headers that lasts for long ?

</comment><comment><USER66> Some searching shows he is supportive of #anakata, and maybe people can read up.

<comment><USER67> They both live (lived?) in Cambodia, it seems.

</comment></comment><comment><USER68> > Google says "Don't do evil" on one hand.

They stopped saying that, so past tense should be used when mentioning it.

<comment><USER43> So they didn't actually mean what they said?

<comment><USER68> They did, but only for a while, until it became too inconvenient for their company goals.

</comment></comment></comment><comment><USER69> from the panic_bcast source

        s.bind(("", 1337)) # Listen on all devices

haha

</comment><comment><USER70> I mean, I get that he's trying to make a point here, and he clearly feels as strongly about this as he's written. But it sounds like an idealistic 13-year- old wrote the whole diatribe: "Boo, how dare you you big jerk spy. Spying on my mom and friends. You just want money. Like a big fat bully jerk."

Seriously? All corporations are in pursuit of profit. I get the underlying issue he has, but only through the context of growing up with Google and seeing them grow to what they are now. His post is littered with tons of hard to believe idealistic BS.

Berating them for not closing down their service like Lavabit? Are you kidding? "Yes, let's shut down our 15+ year old company, one of the most profitable and successful in the world, just to prove a point" \-- surely that's the rational thing to do. I'm not a fan of Google's "spying", but you need to look at the situation from the lense of this being how they (and Facebook, and probably any other web-based company that had the clout) are seizing a competitive advantage that almost no one else can provide. People are feeding them petabytes of data, and it's in their best interest to turn that information into financial gain. Yes, I think a big side-effect of that they appear to be intrusive and "evil", but to pretend that the company is the issue, and that only Google would take advantage of such a situation is comical, and incredibly naive. The writer of the article surely can understand that any other entity with such great access to user information would use it.

<comment><USER71> Profit is wonderful, even more so if earned through other means than tracking users' Internet activity unknowingly. Most users of the Internet don't know that Google sees them in most corners and much of the data collection remains.

Most users don't know how to defend themselves pro-actively. For example we have the disaster of people being connected with their political views in France[1]. The same (not really, hashed emails) vulnerability was then used by the Swedish Researchgruppen[2], an extremist leftwing organization, to publish who said what under the assertion of anonymity and as a direct followup leftwing journalists are now chasing outed "trolls" with baseball bats and cameras[3] for a TV show(!).

1: [http://www.wired.co.uk/news/archive/2013-10/29/de- anonymisin...](http://www.wired.co.uk/news/archive/2013-10/29/de-anonymising- political-forums)

2: [http://torquemag.io/if-you-wouldnt-say-it-in-person-would- yo...](http://torquemag.io/if-you-wouldnt-say-it-in-person-would-you-say-it- online/)

3: [http://www.friatider.se/plansch-for-nya-tv3-serien- aschberg-...](http://www.friatider.se/plansch-for-nya-tv3-serien-aschberg-med- basebolltra-jagar-asiktsregistrerade)

Nedless to say these individuals are being directly targeted and harmed due to what they wrote on the Internet. It's not the fault of Disqus or Gravatar, it's the consequence of uninformed users.

Now imagine the hoards of victims that will emerge in the shadows of a Google database leak. For it will leak, of course it will, it's only a matter of time. If data can get out of North Korea it can get out of Google.

The dangers are not necessarily what Google is doing but what Google enables others to do.

Google closed down their service in China in protest againt what they said was anti democratic; remaining in the US is a hypocrisy, although perfectly aligned with other propaganda.

You are right, this is very much government driven. I agree - we should remove the government. Google can lead the revolution by closing down or switch jurisdiction in protest. Their voice is heard, ours is not.

</comment></comment><comment><USER72> Are you even serious? I read your post. Its a nice fairytale. Let me explain to you what my dad has tought me: We live under structured societies and under a specific set of rules we call LAW. (I most certainly disagree with that... but thats life and how it is) Yes under my fantasy world everyone would have the same possibilities and everyone would be happy yada yada. But under the Actual world we are living at ... Google is just another part. The set of LAWS that have been up there and been built for the past 200-300 years made it clear that Goverments are above those Laws and can do anything they like.

If it wasn't Google tracking your data, it would be someone else doing it cause thats how the world that they setted up works! Do you think Google is happy with handing out info to goverments? No, its done cause they are forced to, and yes they can ask something in exchange. Thats the game of Power (Read Game of Thrones, you might understand that.)

So I suggest you to get out of that imaginary world of yours and live life (I don't say change your ideas), but if you really want to blame someone - <USER2> YOURSELF, for voting for the politicians in your country and for not being able to force them into taking your opinion and stop spying on you.

Also regarding adSense and all the tracking... Well thats how business works, if you don't like it then its ok. Noone forced you to use google search or gmail or whatever it is that google has included in their adSense algorythm

Regards, A friendly man that lives TODAY!

<comment><USER71> Hi, OP here.

>> We live under structured societies and under a specific set of rules we call LAW.

We don't, you do. I packed my backpack and moved to the 3rd world at 22 and haven't ever been back because I need chaos. There is practically no law where I am, and that was one of many reasons for abandoning your structured societies.

>> Read Game of Thrones, you might understand that

Amazing insult. "Read a book, you idiot! A really stupid one!" Thanks for the smile. :-)

>> So I suggest you to get out of that imaginary world of yours and live life (I don't say change your ideas), but if you really want to blame someone - BLAME YOURSELF, for voting for the politicians in your country and for not being able to force them into taking your opinion and stop spying on you.

I live in the jungle, life is great here! You should try it. I never voted for any politician. I will never blame myself for something that I didn't create.

>> Noone forced you to use google search or gmail or whatever it is that google has included in their adSense algorythm

Agree, but on the other hand the general public is uninformed about these matters. I consider customer unawareness to be quite a problem in general. How can we fix it? I don't think asking those that you disagree with to change is a good approach.

</comment></comment><comment><USER73> Well, I suppose this is not entirely unlike applying for them and not getting the job.

</comment><comment><USER74> Google Should Modify these 8 Points [http://www.thegeekyglobe.com/google- should-modify-8-points.h...](http://www.thegeekyglobe.com/google-should- modify-8-points.html)

</comment><comment><USER75> I won't work for Google for a very simple reason

After you went through an unsuccessful interview with them (even if it's more than 5 years ago), if you send them your CV again, it goes to /dev/null

Really

So, yeah, other companies are hiring... And there are good possibilities outside of the big companies, it may even be more fun and less red tape

<comment><USER76> This is untrue.

For one, I am a counterexample.

Also, I know members of hiring committees, and they tell me that if you have a failed interview one year, and a pretty good interview the next, that is a stronger hire signal than a pretty good interview without the previous failed one. That is, it shows growth.

<comment><USER75> Hard when you don't even get an interview anymore and recruiters leave you hanging without an answer.

Your experience doesn't match mine, I'm not saying you're being untrue, I'm saying YMMV

<comment><USER76> I'm simply pointing out that your explanation is not the correct one, since it's not consistent with other evidence.

</comment></comment></comment></comment><comment><USER77> I think you should work for Google. They might teach you a thing or two about how to handle traffic.

<comment><USER22> Yeah, I suppose you (hpaavola) have one or more thing to teach Cloudflare about how to deal with traffic (which this host is using as frontend)?

<comment><USER78> Cloudflare is not having any issue, it's just used here as a proxy to help with caching and static files. The real server hosting the application is down.

However this comment was a bit useless.

<comment><USER79> Cached version: [https://webcache.googleusercontent.com/search?q=cache%3Ahttp...](https://webcache.googleusercontent.com/search?q=cache%3Ahttp%3A%2F%2Fqnrq.se%2Fwhy- i-wont-work-for-google%2F&oq=cache%3Ahttp%3A%2F%2Fqnrq.se%2Fwhy-i-wont-work- for-google%2F)

(Ironically by Google)

<comment><USER80> This is a funny coincidence.

</comment></comment></comment></comment></comment><comment><USER81> Google first approached me in 2010. Here is the relevant part of my otherwise short reply:

 _Google follows what I believe to be unethical business practices – including, but not limited to, condoning censorship, invading their users' privacy,_ [publishing] _proprietary software, and making available and encouraging the use of network services with far too little user control of the programs._

A little more than a year later, Kragen Javier Sitaker wrote this, which I thought was the best explanation of why one wouldn't want to work for Google:

[http://lists.canonical.org/pipermail/kragen- tol/2011-August/...](http://lists.canonical.org/pipermail/kragen- tol/2011-August/000938.html)</comment>


Show HN: Login with Matrix - <AUTHOR> https://loginwithmatrix.tiktalk.space/ <comment> mike-cardwell Not sure about this claim:

"More secure than E-Mail or SMS, because the codes are end-to-end-encrypted (Not in this demo, but supported by Matrix)"

Assuming encryption is turned on for a room, it's opportunistic unless both sides have verified each other out of band.

Maybe as a second factor, or as a user identifier (instead of email), it would be useful. But I wouldn't use it as the sole token for logging in.

<comment><AUTHOR> With almost every online service, you can easily reset your password through E-Mail. So if someone gains access to your E-Mail account, the person can take over your other accounts. If you use your Matrix ID (without a password like in the demo) instead of E-Mail, it's the same count of factors (because you can't even guess the password if using "Login with Matrix" because there is none) and the only difference remains in the communication protocol (E-Mail and Matrix). And because Matrix uses E2E, it's _more secure_ than a plain E-Mail, even if not verified. Also, afaik Matrix requires you to verify a new session (with a logged-in device or recovery key) to gain access to encrypted messages, which makes it a lot harder to fully take over your Matrix account with E2E messages than your E-Mail account, even if someone guessed your password for either one. It's of course a good idea to add additional factors (Hardware Keys, OTP App) to the whole process for improved security, but this is true for both E-Mail and Matrix and that's why I think that "Login with Matrix" is more secure than an E-Mail/Password Login.</comment></comment>


These are the fastest-growing skills in tech - <AUTHOR> http://news.dice.com/2014/09/15/fastest-growing-tech-skills-dice-report/

<comment><USER2> Data Source? Seems like you'd lose a lot of the nuisances when you use headings like "noSQL", "BigData", "Cloud" and "Cybersecurity".

I'm a admittedly junior developer, but nonetheless "tech" and if you asked me what any of those descriptions _really_ meant, I wouldn't be able to answer.

Yea, of course we all know what noSQL, cloud and Hadoop are (I hope so!) but what do you call a distributed data warehouse based on a hadoop architecture? nosql? hadoop? cloud? What about the "cybersecurity" you need to use to keep it all safe? This isn't an academic distinction, these labels rely on the implementation of mechanisms under different labels to make sense.</comment>


The World's Most Expensive Comic Book Art - <AUTHOR> http://www.wired.com/underwire/2012/09/10-most-expensive-comics/?utm_source=twitter&utm_medium=socialmedia&utm_campaign=twitterclickthru

<comment><USER2> Suppose that in 1938, someone had bought a large supply of the same paper that comic books were printed on, along with a large supply of the same ink that was used. They then put these into storage and waited a decades, until they knew what comic books from the '30s and '40s were valuable.

Would they then be able to make forgeries of those comics, using their properly aged paper and ink, and so fool collectors? Or would it be possible to tell that even though the ink and paper are of the right age, the ink was recently applied and the whole scheme would fall apart?</comment>


Watch the Ridgecrest earthquake shatter desert floor in before-and-after images - <AUTHOR> https://www.latimes.com/california/story/2019-07-22/ridgecrest-earthquake-images-broken-ground <comment><AUTHOR> The frequency of earthquakes in this regions is remarkable. Here is a list of earthquakes of 3.0 magnitude or greater in the last 3 days.

       MAP 3.7 2019/07/23 16:45:48 35.887N 117.720W  6.9   18 km (11 mi) ESE of Little Lake, CA
       MAP 4.1 2019/07/23 00:45:02 35.626N 117.428W  5.2   16 km (10 mi) S   of Searles Valley, CA
       MAP 3.9 2019/07/22 18:36:18 35.743N 117.560W  3.0   14 km ( 9 mi) W   of Searles Valley, CA
       MAP 3.0 2019/07/22 13:12:27 35.643N 117.445W  2.9   14 km ( 9 mi) SSW of Searles Valley, CA
       MAP 3.0 2019/07/22 11:31:20 35.852N 117.666W  3.6   24 km (15 mi) ESE of Little Lake, CA
       MAP 4.2 2019/07/22 09:26:56 33.996N 116.044W  7.9   16 km (10 mi) S   of Twentynine Palms, CA
       MAP 3.1 2019/07/22 02:45:10 35.957N 117.714W  3.1   18 km (11 mi) E   of Little Lake, CA
       MAP 3.0 2019/07/21 10:09:22 35.699N 117.543W 10.1   15 km ( 9 mi) WSW of Searles Valley, CA
       MAP 3.1 2019/07/21 04:56:11 35.656N 117.513W 10.0   15 km ( 9 mi) ENE of Ridgecrest, CA
       MAP 3.1 2019/07/21 03:41:37 35.609N 117.475W  7.2   18 km (11 mi) E   of Ridgecrest, CA
       MAP 3.0 2019/07/21 00:36:57 35.778N 117.618W  7.7   18 km (11 mi) NNE of Ridgecrest, CA

<comment><USER2> Paul Nicholls made an excellent visualisation of the sequence after the Christchurch (New Zealand) quakes [https://www.christchurchquakemap.co.nz/all](https://www.christchurchquakemap.co.nz/all) . The [https://geonet.org.nz](https://geonet.org.nz) site also got an update at that time and is fantastic for live data.

</comment></comment><comment><USER3> What happens if you have a property boundary that gets offset by a fault moving - do you own the moved land or do you own own the land that has moved into your area on a map and lose the land that moved out?

<comment><USER4> Isn't land still mostly defined by physical markers? The distances between the markers would change, and thus the property sizes.

<comment><AUTHOR> If my house moved to my neighbor's yard after an earthquake...he could have it. I'm outta there.

Just kidding. It is an interesting question though. I suppose the legal answer would vary by locality. It seems that any definitions derived by GPS, which normally would seem to be most accurate, would be too inflexible in this circumstance. It would seem hardly fair to get sued because you left your house in their new front yard.

</comment></comment></comment><comment><USER5> [http://archive.is/N7blH](http://archive.is/N7blH)

</comment><comment><USER6> The visualization is fascinating, but the really interesting thing to me is that Google Earth had what appear to be custom imagery of the affected area within a day or two of the event.</comment>


Goodies on Tandy Color Computer 3 (CoCo3) - <AUTHOR> http://users.aei.ca/twilight/sock/index.html <comment><AUTHOR> This guy used to run a BBS I used back in the stone ages!

[http://users.axess.com/twilight/sock/cocofile/rs232mod.txt](http://users.axess.com/twilight/sock/cocofile/rs232mod.txt)</comment>


Is Reincarnation Real? - <AUTHOR> http://ieet.org/index.php/IEET/more/prisco20120701

<comment><USER2> Maybe it's a buffer overflow phenomenon in the Matrix? Question is: can someone write an exploit...</comment>