Threads (in Ruby): Enough Already - <AUTHOR> http://yehudakatz.com/2010/08/14/threads-in-ruby-enough-already/

<comment><USER2> This post is a useful rundown on where threads stand in Ruby now, but it hangs on a bit of a straw man argument. The argument for evented concurrency assumes threads _work_. Async design isn't a reaction to MRI's crappy green threads.

It's also not a very compelling argument for threading to say "web programs don't share a lot of state, so you don't have to worry about synchronization". If all you do are CRUD apps, you can indeed punt scaling to the database. That doesn't mean threads are more effective than events; it means you made concurrency and synchronization someone else's problem. There's nothing wrong with that, but it's not a convincing demonstration of threading.

<comment><USER3> > _The argument for evented concurrency assumes threads work. Async design > isn't a reaction to MRI's crappy green threads._

Truly? To my understanding, event loops require inversion of control (and likely callbacks and broken exception handling). This is a large cost that requires a benefit to be worth it. I understand that benefit to be: you don't have to deal with threads (or bad implementations of such).

This blog post comes to mind: [http://www.unlimitednovelty.com/2010/08/multithreaded- rails-...](http://www.unlimitednovelty.com/2010/08/multithreaded-rails-is- generally-better.html)

<comment><USER2> Not being a patterns guy or a Fowlerite, I can't tell you whether async "requires inversion of control". Apropos nothing, I'm also unlikely to recognize "dependency injection" when I see it, as my first language was C, not Java.

Async code isn't "likely" to require callbacks; it will almost certainly involve callbacks, those being a central design feature of async code. You should play with the idea for a bit before forming an opinion about it.

I don't know what you mean by "broken exception handling". This may be a Rails-ism I'm unfamiliar with. I'm very familiar with Rails (we ship a fairly large product built on it), but I've never tried to shoehorn async I/O into it; like Twitter and presumably every other large site, we do Rails on the front-end/UI and fast things on the backend, in our case with EventMachine.

Like I said: I'm _not arguing_ that Rails threading is bad, or even that Rails should have better async support. If I cared that much about the performance of my front end, I probably wouldn't be serving requests directly off Rails. Rails developers may very well be better off with threads. But that fact has little to do with the merits of threading and async _as concepts_.

<comment><USER4> 'I don't know what you mean by "broken exception handling".'

Take the following Python-esque (but not Python) psuedo-code in a threaded language:

        try:
            header = read(socket, header_size)
            if has_short_flag(header):
                 return read_until_closed(socket)
            else:
                 handle_message(header, socket)
        except SocketClosedException:
            log("lost socket while processing headers in packet")

The evented equivalent of this code will have to be chopped into pieces at each of the read calls, and it is impossible to wrap the second read calls in the same exception handler like this. You can manually route exceptions around if you're careful, but that is definitely a pain in the ass and is sometimes very hard to test (hard to test exception handling for an exception you can't really fake for some reason). (Of course you can't always test it in threaded code either, but it's radically simpler there and therefore less likely to break, you don't have to test the plumbing.)

This is one of the reasons I've spent the last few years _fleeing_ event-based code towards things like Erlang, rather than running towards it; I've been doing event-based code for non-trivial work and things well beyond "demos" and the plumbing just explodes in your face if you want to build actually-robust software where simply crashing in the middle of a request isn't acceptable. Despite my best application of good coding practices and refactoring you still can't get close to the simplicity of something like Erlang code.

(By the way, if you are stuck in evented land, one of the things I have learned the hard way is that anywhere your evented API has an error callback, you _absolutely must_ provide one that does something sensible. I now always wrap such APIs in another layer of API that does nothing but crash as soon as possible if no error callback is provided. If you can't figure out what your error callback for a given such call should be, that's your design trying to tell you something's wrong.)

<comment><USER2> If you're an Erlang advocate, I'm not going to convince you of the utility of eventing in any other language. I respect your decision but am uninterested in choosing a programming language based on a concurrency model.

That said, your (admittedly hypothetical) example is hideously broken. In EventMachine, and written properly:

      def receive_data(buf)
        @buf << buf
        while have_complete_request?
          begin
            send_data(handle_next_request)
          rescue => e
            log(e)
          end
        end
      end

Notice the _single exception handler_ bracketing the entire request. (This code is wordier than I'd like because I hoisted the exception handler out of handle_next_request to illustrate it).

The mistake you made (and it's common to a lot of evented code) is in driving the entire system off raw events. Don't do that. Buffer, to create natural functional decomposition.

Evented code is rarely _as simple_ as synchronous code, but there's no reason it has to be needlessly choppy.

That said, I think this design is overvalued. Yes, it's true, you (probably) can't always wrap an entire request's processing in a single exception handler in any evented Ruby library I know about. But I wouldn't wrap an entire request handler in a single exception handler in any case! If I was preparing to deal with a database exception, I'd wrap the code making the database call in an handler for the database exception. If I was preparing for a filesystem exception, &c &c &c.

Incidentally, I've been doing very, very, _very_ large scale evented systems for going on about 10 years now (large scale: every connection traversing tier 1 ISP backbones), and, sorry, this stuff has never blown up on me. I may have been shielded from exception drama by working in C/C++, where exceptions are not the norm. I was a thread guy before that. Threads definitely did blow up on me, a lot.

<comment><USER4> I don't think you can do that with Javascript or Node.js. When you have a callback, you lose all stack above it.

See, I wouldn't even call that "evented code" in the way that people are using the term, regardless of what it says on the tin, precisely because you aren't losing the stack frame here and can still catch exceptions and such. Evented to my mind is something like Node.js is when you have to chop up your code manually. At least, I've never seen anybody demo Node.js code that isn't chopped up manually and I am at a loss as to what features of Javascript would let you translate that Ruby snippet directly without losing something fundamental about the stack.

Under the hood, _everything's_ event-based (with optional preemptive multitasking), there's just varying levels of compiler optimization that affects how much you have to do manually and how much you have to worry about it. The inner event loop of Erlang and the inner event loop of Node.js and in fact the inner event loop of just about anything nowadays looks pretty much the same.

That's not the way in which I say evented code blows up. If you can write like that, it doesn't blow up, because you don't have to sit there and basically manually implement your own stack handling if you want anything like that sort sane exception handling, it all just works.

Since this is a terminology issue there is, as always, grey areas, but since I mostly use the term evented in the context of the Node.js hype I tend to use it that way. I've been doing stuff like your snippet for a while too and it hasn't blown up on me either, which is why I'm so down on the style of coding Node.js entails, which does.

The point of my snippet is not that that is a brilliant choice intrinsically, the point is that you don't have the choice and end up implementing anything like that manually.

<comment><USER2> You've lost me. Nothing in this code depends on having a single consistent stack from main() to handle_next_request().

<comment><USER4> You need a "consistent" stack in the whole of everything executing under "handle_request" if you want that "one single exception handler bracketing the entire request". You don't get that in Javascript; you need a language with more power. There are several viable options: Threading, continuations, some hacked up thing like Python's yield (which is neat, but limited). But something.

Javascript's a very nice, dynamic language in most ways but its functions are very, very weak. They'll get better in the next version of ECMAScript, though. (Node.js will probably benefit from it.)

<comment><USER2> I'm pretty sure you're wrong about this. The exact same idiom I used to buffer up requests and feed them whole to a single function that could catch all possible exceptions works just fine in Javascript. Is this an issue with JS exceptions that I'm unaware of? I may just be talking past you.

<comment><USER4> You're talking about the function of what I posted, I'm talking about the form.

        try:
            something = some_io_that_needs_an_event_callback()
            if do_something_with(something):
                more_io_with_callback()
                some_other_callback_thingy()
            else:
                yet_other_io()
                some_other_io()
        except AnyException:
            do_something_sane()

is not a structure available to you in Node.js, again, pending somebody proving otherwise in Javascript (though I've made this complaint in other places where somebody really should have shown me the code). That expands to tons of code in Javascript, code which is very resistant to abstraction.

Your code block says it is available to you in Ruby. There's no reason why it shouldn't be; it's not a hard compiler transform to manage that. Taking code that looks like a "thread" but compiling it into events and using something- like-continuations to keep the stack together is on the order of a homework problem. Based on what I know about Ruby, the responsibility of those pieces is split up differently but all the pieces must be there. But it's not something Javascript can do (quite yet, and based on what I've seen in Python the 'yield' approach has its own issues).

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER5> Ok, dumb question--I'm a bit naive on process forking. On Linux with Ruby, if I fork a process, must the new process stay on the same core? Forked processes begin by sharing memory initially in Ruby, correct? Can anyone enlighten me on the mechanics of forking and if there are scenarios where it helps with utilizing multiple cores (maybe relatively independent workers that just read shared settings?).

Forking seems...a little weird to me coming from my previous Windows background.

<comment><AUTHOR> Forking creates a new process, initially "sharing" memory via copy-on-write semantics (and therefore being eligible to run on another core). However, C Ruby's default mark-sweep garbage collector touches pretty much all memory immediately, eliminating the typical memory savings of a forking model.

As I commented earlier, Ruby Enterprise Edition (made by the same guys as Passenger) ships an alternate GC that doesn't actually write to the memory space of the original objects in order to mark them.

As a result, some memory (but not necessarily as much as you'd expect) can be shared between processes forked from the same parent and running on multiple cores. Sort of a middle ground between totally separate processes and shared memory via non-GIL'ed threads.

<comment><USER5> So you won't get much by way of memory savings, but you might expand the volume of work each batch of threads (now on separate processors) could complete if you forked cores - 1 times?

<comment><USER6> There are different kinds of memory in a process, e.g. code segment, read-only data segment, and read-write data segment. The code and read-only memory can be shared between the parent and child processes. The read-write memory pages are copied-on-write when they are modified. There can be fair amount of sharing.

</comment></comment></comment></comment><comment><USER7> This article is a good wake-up call, but even if Rails itself is now (since 2.2) thread-safe, I need to be fairly sure that _all_ my libraries are before I can enable threaded request dispatch in my Rails app. That's a lot of code inspection / thorough regression testing / inevitable bugs.

The Brightbox team tried to tackle the related problem for moving to Ruby 1.9 with a crowdsourced library review site: <http://isitruby19.com/> Does anyone know of a similar site where people can report whether libraries are thread safe? (The code for Is It Ruby 1.9 is available on github - <http://github.com/brightbox/isitruby19> \- so it would be easy enough to set up a clone, but I can't commit to maintaining such a thing.)

<comment><AUTHOR> The Rails Plugins site (<http://railsplugins.org>) that we built at Engine Yard has 406 registered plugins, and a criteria for thread safety (<http://railsplugins.org/plugins?criteria[]=2>).

The way it works is that the author can specify whether or not he thinks it's threadsafe (yes/no/maybe), which is then verified by users who can specify whether they agree. If a user marks a plugin as not-threadsafe (or not-Rails 3, or not-JRuby, or not-Ruby 1.9), the author has 7 days to help the user come around before it sticks.

So far, there are 60 plugins marked as threadsafe (which means that either the author said "yes" and nobody disagreed, or the author said "maybe" and all the votes so far say yes).

<comment><USER7> That's awesome, and exactly what I was looking for. Thanks!

I found that the postgres gem, the most immediately important for me, isn't listed. Do I need to be the gem author/maintainer to register a gem, or can I just add it?

<comment><USER8> Wycats noted in the comments of the article that the pg driver is indeed safe for use in rails threaded mode.

As a psql fan, it makes me wonder what the rails world would be like had dhh had picked psql from the start.

</comment></comment></comment></comment><comment><USER9> Somehow the takeaway from all these posts seems to be to stick to JRuby. Am I reading that right?

<comment><AUTHOR> If you use C Ruby, you'll need one Ruby process per core, managed by something like Passenger (mod_rails) or Unicorn.

If you use JRuby, you'll need one Ruby process per machine (for N cores), managed by the JVM.

For boxes with a lot of cores, JRuby's larger memory footprint is overtaken by the ability to share that memory across a number of cores.

This story is also somewhat complicated by Ruby Enterprise Edition, which adds copy-on-write semantics to Ruby's GC, and is built by the same guys as Passenger, making it possible to share SOME memory between processes.

With all that said, we're really talking about marginal amounts of RAM. The real takeaway is that if you're running 6 processes per core (very common), you're doing something very wrong.

FYI: At some point in the future (1.2?), Rubinius will also be able to run a single Ruby process per machine.

<comment><USER10> Rubinius wise, I'm actively working on making in concurrent. Yes, a future release will incorporate that work, which allows one Rubinius process to fully use as many cores as a machine has.

<comment><USER11> Concurrent GC too?

<comment><USER10> Concurrent GC is not currently planned, but it should be noted that our generational GC does wonders to reduce GC pause time anyway.

Additionally, even Hotspot typically defaults to their stop-the-world GC. This is because a concurrent GC typically spreads part of the GC time around, ie, performance is slower to reduced GC pause time. But even a concurrent GC typically has to stop all threads at some point to get everything consistent.</comment></comment></comment></comment></comment>


An ode to the idea guy - <AUTHOR> http://sahay.co/post/43136803898/an-ode-to-the-idea-guy

<comment><USER3> Totally with you on that. Great hospitality ventures weren't built by architects, or construction guys, or even L&T. It takes a huge variety of skills, understanding (and experience) of markets, user empathy (have seen so many products/startups fail just because they don't really get the real world user out there), etc. Respect is important. And it might save your skin - <USER2> same one you put in the game.

</comment><comment><USER4> well written, up my street</comment>


Ask HN: Looking for a helping hand - <AUTHOR> Hey, I really need some help. I should have asked sooner, but sometimes the first steps are the hardest.
A few years ago - as my partner's parents are aging - I made the decision to emigrate to my partner's homeland and setup a business with my partner. As so often happens, businesses don't always work out, and after a while the business failed. In short succession some of my close family members died, and all this resulted in me suffering from Alopecia universalis eventually leading to me becoming an almost complete recluse.
Time has started to heal these wounds, but the a lack of any network and some language barriers, starting again has been tough (I'm unable to work related to my studies in this second language). The only respite in all this is that learning to code has allowed me to feel some self worth, confidence, and a pathway to becoming a productive member of society again.
Starting again means I have a worthless C.V., a large period of unemployment, and next to no experience to show off my skills. I have learnt Ruby and Rails, with some side helpings of related techs (JS, React, HTML, CSS, SQL, PLPGSQL, Git, APIs, etc.), but I now feel as though after dipping my toes into Elm, Elixir, Phoenix, Prolog, etc, that learning new things will not magically get me work…
I have tried job boards, freelancer portals, contributing to open source, and bug hunting, but I can't get my foot in the door when it comes to work that will help me build up my C.V. so I can help provide for those that I care for rather than continuing to be dependent.
The part where I need your help
I am looking for any work that you think I could be suitable for, long or short term (I'm in the E.U. but willing to be available in any timezone), the only caveat is that I will need to work remotely.
I have kept this anonymous as I would like to keep my professional an private life separate, but I will be happy to supply any further info as needed. <comment><USER2> * Make your stuff visible on github. If I read an application with a github link I always check there. If it looks good you will get invited.

* Do voluntary tech work for your local (church/religious) community. This will give you connections that eventually lead to gigs or employment.

<comment><AUTHOR> Do you have an email to which I can send my github profile?

Thanks for reading and taking the time to provide some advice.

</comment></comment><comment><AUTHOR> I've posted my info on [https://news.ycombinator.com/item?id=17902903](https://news.ycombinator.com/item?id=17902903) (Ask HN: Who wants to be hired? (September 2018)) to try to aid my search.</comment>


Solve your problem by almost asking a question on StackOverflow - <AUTHOR> http://blog.jerryorr.com/2014/04/solve-your-problem-by-almost-asking.html

<comment><USER2> This has happened to me countless times. The encouraged culture of asking smart questions[0] is probably Stack Overflow's best feature.

      [0]: http://catb.org/~esr/faqs/smart-questions.html</comment>


Flappy Fraud? – Review Analysis on Flappy Bird - <AUTHOR> https://sensortower.com/flappy-bird-scripted-reviews-analysis

<comment><USER2> "I was able to create a new iTunes account with the same billing info and address of my normal iTunes account and leave a legitimate review on Flappy Bird in 2 minutes, 24 seconds on my first try. Someone who was doing that task for hours a day could probably get it down to under 2 minutes per account."

After about 5 accounts from the same IP, they shut you down. (Personal experience).

</comment><comment><USER3> So Author is not sure what to conclude but add's a link bait title "Flappy Fraud?".

Its just sad to see people like this.

</comment><comment><USER4> The writing is on the wall for me. I am sure that they created enough reviews to get it internally ranked on iTunes/GP & gained organic momentum (in addition the press it generated) but definitely some foul play involved here IMO.</comment>


You Like the iPad, Eh? ARCHOS Has a Tablet for You - <AUTHOR> http://www.besttechie.com/2013/01/10/you-like-the-ipad-eh-archos-has-a-tablet-for-you/

<comment><USER2> Something that too many companies had to learn the hard way over the years: Do not copy an Apple product expecting customers will like a copy of the genuine product. If I like the iPad, I will buy an iPad.</comment>


Show HN: Client for Binance.com Public WebSocket APIs. Built with Oat++ - <AUTHOR> https://github.com/oatpp/example-websocket/tree/master/client-binance.com <comment><USER2> Interesting, do you have any stats about it's speed advantage over let's say Node.js? In general binance API it's really high frequency'ish at all, it only pushes updates every second (aggregated)...</comment>


Why rechargeable (AA/AAA) batteries not popular? - <AUTHOR>

I have been using these for a while. Good value for money and using these is more environment friendly(supposedly). It is difficult to find these in stores, can order it online only. Is it because of the alkaline battery maker's lobbying/deal with stores? Less profit for stores? Consumers don't care, not worth the hassle? <comment><USER2> Too expensive, performance degrades over time, you have to have a charger for them and when they run out it takes hours before they're recharged, during which you can't use whatever it is that needed batteries.

<comment><USER3> Stcredzero's listed amazon AA batteries: $12.95 for four.

Another amazon listing for Duracell 4-pack Alkaline: 4.95 for four.

Rechargeable: $3.24 per battery

Alkaline: $1.24 per battery

3.24 divided by 1.24 = 2.61.

After 3 recharges, the rechargeable has now become cheaper than the alkaline battery. It seems difficult to believe the performance would degrade sufficiently after only 3 recharges to justify sticking with alkalines.

As for the lengthy recharge, the solution there is buy a second set. Keep one in the charger (a good one that goes to trickle when done), when you run down, swap. Result, no effective wait time for fresh power.

<comment><USER4> I recently purchased 3 sets of AA Energizer brand rechargables. They kept their charge in some of my electronics for all of 24 hours in many cases.

They seem like a great idea, but in my recent (last 2 years) experiment, the performance actually does degrade that quickly. It could have just been a bad batch, but it was 3 separate 4 packs of battteries, all with their own chargers.

<comment><USER3> If it was the chargers that were packaged together with the batteries, then the problem was likely the charger destroying the batteries rather than any fault of the battery itself.

</comment></comment></comment></comment><comment><USER5> Here is an article on this by Jeff Atwood on his "Coding Horror" blog.

[http://www.codinghorror.com/blog/2008/03/adventures-in- recha...](http://www.codinghorror.com/blog/2008/03/adventures-in-rechargeable- batteries.html)

<comment><AUTHOR> Thanks. This is very helpful.

</comment></comment><comment><USER6> I use these all the time in many gadgets. They're easy to find in supermarkets, so it depends where you live I suppose.

</comment><comment><USER7> Stores have incentive to sell goods that expire fast.</comment>


Waltz: A Distributed Write-Ahead Log - <AUTHOR> https://wecode.wepay.com/posts/waltz-a-distributed-write-ahead-log <comment><USER2> This design seems to be an example of a deterministic database system. There's an excellent review of deterministic databases here: [http://www.cs.umd.edu/~abadi/papers/abadi- cacm2018.pdf](http://www.cs.umd.edu/~abadi/papers/abadi-cacm2018.pdf)

The core concept of all deterministic databases is simple: if your database is deterministic, multiple geographically-distributed replicas can execute the same transaction log independently, and they will all reach the same state. The problem of implementing a distributed database is reduced to implementing a distributed log.

However, there is one oddity of the Waltz design: the central locking mechanism. Other deterministic databases don't have anything like this, because it's not necessary. You can keep track of locks locally on each replica, and you can rely on every replica to reach the same conclusions about which transactions succeeded and failed, because they are deterministic.

Can anyone clarify why they are managing centralized locks?

<comment><USER3> Essentially if each instance can keep track of validating transactions locally, the whole thing can be easily implemented with Bookkeeper and distributed log API [0]. Bookeeper guarantees single writer (the master node which is appending to log) for each ledger. All it needs to be done is to put concurrency control metadata (like version, timestamp, ...) inside the message so each node can validate stuff locally.

[0] [https://bookkeeper.apache.org/docs/4.9.2/api/distributedlog-...](https://bookkeeper.apache.org/docs/4.9.2/api/distributedlog- api/)

</comment></comment><comment><USER4> This design can be extended to support interactive transactions.

Here's how:

1\. Assign each transaction a log position. For strict serializability instead of just serializability, make this the highest log position ever acknowledged successfully to a client. This can be batched for throughput.

2\. Have each client record their read set and write set, which includes the objects/ranges the transaction read and the writes / operations to be performed.

3\. Have clients persist this R/W set into the log, or send directly to the lock server if it is also the master assigning log positions. Again, use batching for throughput.

4\. Have your lock server either as a part of the master processing assigning log positions, or have it tail the log separately. The lock server will receive batches of transactions, take locks in the log's defined order, then commit another entry to the log with the commit/abort decision for each.

5\. Respond to the client with the commit / abort decision.

To make this easier to program you'll probably want to include a read-your- writes cache on the client.

You can also scale out this log by having clients commit their operations to multiple logs. The only thing that needs to be serialized is the locking and commit / abort decision making. These other logs can be sharded by key range or just chosen randomly, as long as the commit / abort decision log includes which other log the data itself was committed to.

FoundationDB works roughly like this. The terminology is different (resolver instead of lock server, R/W set is conflict ranges, log position is version number, etc) but this is basically how it works.

<comment><USER5> Persisting executed transactions to a log with their read/write sets, and then determining if they actually commit also starts to sound like [http://web.eecs.umich.edu/~michjc/eecs584/Papers/cidr11_hyde...](http://web.eecs.umich.edu/~michjc/eecs584/Papers/cidr11_hyder.pdf) to me

<comment><USER4> Yes, it is more similar to Hyder than FoundationDB if you persist the R/W sets to the log itself. FoundationDB gets around this by only keeping the lock table in memory. When any process in the transaction pipeline fails, the master (which holds the version number) advances the version far enough into the future that any in-progress transaction would fail because it is too old.

</comment></comment></comment><comment><USER6> Last I heard from some friends in YC when considering a position there, Wepay was handling less than 10^6 payments per day. Is that still the case and is something with such low requirements a good replacement for Kafka in the wild?

<comment><USER7> Your comment made me realize that I had confused WePay with WeChat Pay, which has a slightly different scale. The "We$VERB" field is getting a bit crowded.

</comment></comment><comment><USER8> I have this nasty feeling that for the scale mentioned the whole logic can be safely run on a single high performance server with the decent database. Those little servers around can either run on the same server or placed on separate server/s around the main one. All nice and simple and no distributed transaction problems.

<comment><USER9> I think Waltz is designed for availability, rather than performance.

For a company like Wepay, maybe a couple minutes of downtime is incredibly expensive and having a single server just isn't going to cut it.

<comment><USER8> Maybe it is "incredibly expensive", can't argue with this. Have hot standby database servers then located elsewhere. Still way simpler

<comment><USER9> > _Have hot standby database servers then located elsewhere_

They explained why this wasn't ideal for them in the article.

</comment></comment></comment></comment><comment><USER10> Waltz seem related to Tango. [http://muratbuffalo.blogspot.com/2014/09/paper- summary-tango...](http://muratbuffalo.blogspot.com/2014/09/paper-summary- tango-distributed-data.html)

</comment><comment><USER11> Here's a dumb question about log-structured systems like this: does this system work nicely with backfills? Suppose you start logging events with Waltz and you want to migrate an existing system's data into the same log. Or something goes wrong and oncall needs to manually insert old events. Does Waltz have capabilities to backfill events into the historical log or reassign transaction IDs?

This might not be needed if this is strictly used for FIFO event consumption, but I guess I was thinking of trying to make a system like this support time- sliced queries.

<comment><USER12> These are good reasons to use a bitemporal database [1].

A log gives you "transaction time" but you need to create an efficient representation of "valid time" for backfilling and corrections.

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

Disclosure: I work on a database for Kafka that provides point-in-time bitemporal Datalog queries [https://github.com/juxt/crux](https://github.com/juxt/crux)

<comment><USER11> Yeah, I'm currently getting bitten by various workloads that query by `created_at` instead of a canonical timestamp :) Thanks, I'll take a look!

For the "valid time" primitive I was thinking of implementing something like a hybrid logical clock that CockroachDB has (but with looser guarantees, mostly just need uniqueness and monotonicity). A sequential ID would provide a slightly nicer interface for pagination but has all the problems that I previously mentioned.

</comment></comment></comment><comment><USER13> Looks like this also uses Zookeeper. Does anyone know of a simple streaming log system / database? Like, SQLite3 for streaming? I'm using this for personal projects more and more, and the solutions I see in this space are always big, distributed and hard to setup and keep running.

I've been using a simple file format that just writes each message out sequentially in a simple format like: [event-id][event-type][event- size][event-bytes]. And there's a small TCP server that speaks Redis protocol to support remote access. But it's not really production code, rather something I hacked together over a couple weeks in the evening.

<comment><USER14> If you're already using the Redis protocol then Redis v5 has Streams as a first-class data structure.

It's fast, has consumer groups (like Kafka), and also supports individual message acknowledgement.

<comment><USER15> Is Redis Streams backed by disk? How does it perform when the size of the stream exceeds available RAM?

Also, what's Redis' multi-node failover/high availability story these days (with streams)? Last I heard, it wasn't that great [1], but it's been a while.

[1] [https://aphyr.com/posts/283-jepsen- redis](https://aphyr.com/posts/283-jepsen-redis)

<comment><USER14> Redis is an in-memory data store that has different options for persistence (snapshots + oplog) but it's not designed to persist every operation immediately. All data structures are covered including Streams.

Redis keeps the entire working set in RAM so it'll start dropping writes or freeze if you run out of memory. This is where the simplicity and speed comes from and is a fundamental limitation.

There's a simple replica system that works well but failover switching is the problem and requires a separate process or running the Redis Sentinel. There's also Redis Cluster but that just shards the keyspace and doesn't offer any scalability with a single key or stream, and is still hard to manage with the same failover issues.

The OP asked for a single-node option so I suggested Redis, if you need a serious messaging cluster then I recommend Kafka or Pulsar instead.

<comment><USER15> Thanks. That confirms pretty much the picture I had in my head of how Redis works these days.

It's frustrating that there's no obvious middle ground this and Kafka and Pulsar, both of which are memory-hungry JVM apps with multiple external dependencies. Both require ZooKeeper; Pulsar also requires BookKeeper. None of these components are operationally simple.

I'm a fan of NATS itself, but NATS Streaming's clustering design leaves a lot to be desired. In particular, it punts on failover/HA, asking you to instead run an SQL database or shared file system that provides this. (An obvious low- maintenance option here would be CockroachDB, but NATS doesn't support it.)

<comment><USER14> There are other options. RabbitMQ [1] is the usual although clustering has always been fragile.

If you dont care about open-source then there are plenty of other options like AMPS [2] or Solace [3]. The latter has a free edition.

1\. [https://www.rabbitmq.com/](https://www.rabbitmq.com/)

2\. [http://www.crankuptheamps.com/](http://www.crankuptheamps.com/)

3\. [https://solace.com/](https://solace.com/)

<comment><USER15> I wouldn't put RabbitMQ in this category — it is a classical message broker, not a log. Once you've consumed a message, it's gone, unless you have set it up so ACKed messages are funneled into another queue, but that stuff is finicky and doesn't patch over the fact that underneath it's designed for mutable, ephemeral queues. In particular, you can't peek back into the queue to find older items. You have zero visibility into the contents of the queuem, and you certainly can't treat it as a dependable database.

And, as you say, fragile. I've run RMQ in production for years and I would be _very_ happy if I could throw it out. It's the least well-behaved component in any stack I've used it in. Even Elasticsearch ( _shudder_ ) is better at not losing data. Not just the clustering, either. Even for a persistent queue, RMQ will start to chug RAM for any message that is delivered but not yet ACKed, for example, making it dangerous for apps that want to batch large groups of messages for efficiency. (It seems to me that it was not designed for that at all, but for one-by-one consumption, which is of course much slower.)

I'm looking for a mature distributed log that is clustered and lightweight. Kafka except, say, written in Go.

<comment><USER14> Try out Solace then. It's fast and supports HA for the free edition with throughput limits.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER16> What if I have multiple entries to update in one message(ensure atomicity)? Or write based on multiple reads? One lock id cannot guard them all...

</comment><comment><USER17> > This works well, but the drawback is that a service has to write to two > separate storage systems, a database and Kafka. We still need check-and- > repair.

what about kafka connect ?

</comment><comment><USER18> How does this compare to Kafka?

<comment><USER19> The first paragraph on that page covers that at a high level.

> Waltz is similar to existing log systems like Kafka in that it > accepts/persists/propagates transaction data produced/consumed by many > services. However, unlike other systems, Waltz provides a machinery that > facilitates a serializable consistency in distributed applications. It > detects conflicting transactions before they are committed to the log.

<comment><USER17> > serializable consistency in distributed applications.

Kakfa supports transactions not sure about serializable though.</comment></comment></comment>


NEET, a NEAT library in Haskell - <AUTHOR> https://hackage.haskell.org/package/neet

<comment><AUTHOR> (Also on github: [https://github.com/raymoo/NEET](https://github.com/raymoo/NEET))

I wrote this NEAT library from around a month and a half to a couple weeks ago, and I haven't gotten much review from other people. This is the first haskell library I've written that could have wider appeal, so I don't have a lot of experience behind me. Are there any obvious deficiencies in the way I've coded this? I don't expect anyone to use it heavily at this point, but if anyone does, it would be nice if I could have some feedback on usability too.

Here's an example program I wrote to mess with NEET: [https://github.com/raymoo/neet-cave](https://github.com/raymoo/neet-cave) (requires OpenGL, GLUT, GLFW, maybe some others)

EDIT: Neet itself also comes with an example program in Neet.Examples.XOR.xorExperiment. Note that for some reason it freezes for me if I run it from a ghci session in emacs, but works fine if I do it outside my editor.</comment>


Take the Arc Challenge - <AUTHOR> http://www.paulgraham.com/arcchallenge.html <comment><USER2> Arc seems to embody the idea that "Language design is library design, and vice-versa", but how can we tell where the boundry is?

When I look at something like

      (defop said req
        (aform [w/link (pr "you said: " (arg _ "foo"))
               (pr "click here")]
          (input "foo")
          (submit)))

what I see is more or less ordinary lisp that uses a library to solve an issue with applications that rely on http. I'm sure plenty of us could do the equivalent with the appropriate Python/Perl/Php/Ruby library, but then the obvious criticism would be that you're not really comparing lanugages. You would be comparing libraries.

Plenty of examples over here: <http://arclanguage.com/item?id=722>

Is it really the case that when you boil it down, Arc (language+libraries) is about making small web programs? If not, why this challenge and if so I suspect it won't live up to the 100-year idea.

<comment><USER3> It's true that this example will do more to distinguish Arc from other languages than from other Lisp dialects. But if I'd used a Lispy sort of problem as a challenge, everyone would have accused me of cheating by using an example that favored Lisp dialects.

I'll eventually post some comparisons of the same programs in Arc and other Lisp dialects.

<comment><USER4> I'm very interested in the Arc vs. Lisp comparisons. (especially vs. CL)

</comment></comment></comment><comment><USER5> > Though simple, as such tests have to be, this is not a contrived example. > Web apps have to do this sort of thing all the time.

No. Web app _prototypes_ do that sort of thing all the time. For production web apps, the problem ends up including such confounding factors as meeting accessibility policy, making the HTML surrounding the form elements match what a web designer came up, etc. The more web development work I do, the more wary I am of any system that writes HTML for me. Inevitably the system ends up putting too many constraints on what HTML can be output.

Witness the ASP.NET framework, which writes lots of HTML for you. Unlike Arc it was written with the best practices of the time in mind, but it's aged badly as the web has grown and changed. Doing accessible, cross-browser, standards-based work in ASP.NET today involves a certain amount of fighting the framework which offsets the initial productivity gains.

I understand that Arc is intended for exploratory work and rapid prototyping. But that's exactly why the Arc challenge is meaningless. We're being asked to compare Arc to languages that provide -- dare I say it -- a great deal more flexibility and expressive power when it comes to outputting HTML.

So here's my challenge: Take a sample Arc application and modify it to replace tables with appropriate block elements that have designer-specified IDs and classes. Use <label> elements for each input if you aren't already. Replace a few regular submit buttons with image buttons or vice versa. Reorder some elements, and throw a few more arbitrary containers in here and there. Compare that process against a conventional language and let's see where we get.

In my line of work, that kind of scut work is _absolutely_ part of prototyping. Before I can build the real thing my prototype has to be approved by people who have a hard time looking past even minor visual inconsistencies with what they're used to. For that reason I'm very wary of any design that makes fine-grained control of HTML any harder than it has to be, and I've come to value clean view/everything else separation even in early prototypes.

I suspect that Arc is much more appealing to people who don't live with such constraints.

<comment><USER3> Do you consider News.YC a mere prototype? It's been around for a year, never gets runtime errors, and serves about 80k pages a day without breaking a sweat. And the source is full of code like this.

I think you're confusing types of software with organizations that sponsor them.

Arc certainly wasn't designed for use in the sort of environment where programs are 10% functionality and 90% the embodiment of the random bureaucratic processes of the organization paying for them. More for the opposite end of the spectrum, in fact. That's where you need power.

That said, if you care to make your challenge a precise one, it's likely I (or someone else) would try implementing it in Arc, if only out of curiosity.

<comment><USER6> How about releasing the source to news.yc so we can see how terse it is for a non-trivial application :)

<comment><USER3> I will eventually, but first I have to abstract out all the news.yc-specific stuff.

</comment></comment></comment></comment><comment><USER7> Just counting the tokens in the codetree is not an acceptable measure of brevity, because it implies that adding primitives to a language always makes it more powerful as long it makes your application shorter just once.

But adding primitives has a cost too. You could just have _let_ , or you could have a _let_ for one value, one for more values, one for more values initialized as nil, or as 0, or as an empty string, etc.

In Ruby I write expressions like this a lot: condition ? string : "" I'd like to say: condition &&? string

This would make my applications shorter, but, I claim, less readable and no more powerful.

To measure power, it is not enough to look at succinctness - you must hold something else constant too.

<comment><USER3> Sure. There are lots of pathological counterexamples to the length test. I took that as understood.

</comment></comment><comment><USER8> PHP:

      if ($S['foo']) echo "you said {$S['foo']}";
      elseif (PtoS('foo')) link('said','click here');
      else form('foo');

For me, making programs short is not a design goal. But if it would, I would do it like above. My framework then would include this functionality:

      S[] contains all session variables
      P[] contains all posted variables
      PtoS copies an entry from P to S. Returns false if P was not set.
      link() prints a link
      form() shows a form with the given fields. target is the current url.

</comment><comment><USER9> Paul, in emphasising code brevity I think you are missing a greater good. I believe most of us subconsciously look for a language that is frictionless -- one that allows us to express our ideas without the language getting in the way. To me this is a far more appropriate measure of a language's power than the length of a program. I'd love a language that would allow me to stay in flow* and express my creativity without having to stop and think about the actual language itself. That would be the ultimate Zen power tool.

To be more specific here are three attributes that seem to aid frictionless flow. (perhaps in order of importance) -

\--> Expressiveness -- i.e. simple, explicit and unambiguous abstractions.

\--> Obviousness and readability. -- i.e. no need to decipher tokens, and the code structure illuminates the intention and flow of the process.

\--> Terse. -- i.e. apart from the obvious benefit of requiring less work it also helps me 'keep the whole program in my head'.

There's nothing wrong with brevity of course, but when pursued for it's own sake it seems to be counter productive, in that when you focus on terseness alone there can be a tendency to ride roughshod over the more important attributes: expressiveness and obviousness. You then end up with code that's not as enjoyable to create and whose beauty is lost, except perhaps initially to it's creator.

BTW Paul, this is a great first shot, so a big thank you. I, for one, am routing for Arc to be a widespread success, if only so I can do most of what I need to do in a language that I really enjoy.

* On Flow -> <http://www.life2point0.com/2006/06/the_little_book.html>

<comment><USER10> I think by aiming toward brevity, what he is actually aiming for is the ability to refactor code into something more brief.

The idea is that by ensuring the progression of long code becoming shorter, and by upholding his second principle (axiomaticity), he is making sure that the code he does factor out will be useful to future programmers. He is removing the need to write common boilerplate code -- and giving the ability to remove boilerplate code to all programmers.

And that supports the idea that PG likes about Lisp -- that the language evolves with the program. The reason it seems to only be good for web programs is that his principle application is a web program. If he were to work on some other kind of program, say a word processor, you would see different kinds of abstractions.

The point is that the language can be adapted to ANY kind of application. That is what he is aiming for. And that's why he doesn't want you to have to count library import statements. He wants to compare the code you have to write repeatedly, not the once-off code. He is claiming that the code you have to write repeatedly indicates how expressive a language is. If you have to repeat yourself, then the language does not adequately represent the abstraction you want to capture.

That's what _On Lisp_ is about. That's what basically all of his Lisp essays are about. Paul Graham is aiming for brevity so that he knows that any programmer can make their program brief by evolving the language. Brevity is a sign of a tight fit between language and the concepts expressed in the program.

</comment></comment><comment><USER11> I have _generally_ felt that short programs feel more elegant and enjoyable -- as long as the "flow" of the program is clear immediately by looking at it. So PG's emphasis on brevity is correct, I think.

The other problems people talk about (make this refactorable, etc. etc.) are essentially problems which arise when we transition from a small code base to a large one. And to have any insight about that, I suspect we will actually need to first _build_ something truly large in Arc. Without doing that, arguments from both sides will just be fanciful and sensationalistic blog crud.

New languages are designed so that we can think differently. Let's first try to honestly think about such an artifact and see if we can express it easily using Arc. Hack first, folks, then talk.

</comment><comment><USER12> I think it is quite mistaken to put brevity above everything else. For a 100-year language, presumably with corresponding 100-year codebases, surely the promotion of readable and refactorable source code would be the key. Macro systems already provide a means toward brevity - whatever the language itself does becomes inconsequential given that.

</comment><comment><USER13> Here's a Scheme version. (Gauche, with a web framework Kahua):

        (define-entry (said)
          (define (page . s) `((html (body ,@s))))
          (page
           (form/cont:
            (@@: (cont (entry-lambda (:keyword foo)
                         (page (a/cont: (@@: (cont (entry-lambda () (page "You said: " foo))))
                                        "click here")))))
            (input: (@: (name "foo")))
            (input: (@: (type "submit"))))))

I'm defeated. I admit Arc is quite optimized for web app, at least.

Now, beyond a certain point, optimization becomes specialization. It's like compression. The more you know about the domain, the shorter you make the frequent patterns, and the net amount of code gets smaller. But how do you know you're not overspecializing?

Some of Lispers, including me, have this fear for overspecialization. Reading arc does have an effect to cure that. I see some nice abstractions in arc which I'd like to steal from.

I'm more curious, though, to see wider range of applications in arc and how the core abstractions will live up.

(btw, Paul, if you read this could you reset my password in Arc forum and send it to firstname.lastname@example.com?)

<comment><USER14> and if he doesn't read this, just email him about it, he doesn't bite...

<comment><USER13> I did. Twice.

<comment><USER13> And now problem solved. Thank you, Paul.

</comment></comment></comment></comment><comment><USER15> I'm interested in this part: "Steele and Sussman tried to start over when they first began working on Scheme, but they seem to have been practically the only ones. And they made, at least from the point of view of brevity/power, some serious mistakes early on."

Paul, out of curiosity, what are those serious mistakes?

<comment><USER16> I'm also curious.

</comment></comment><comment><USER17> Take the C++ Challenge (entries will be judged by quality rather than fewness of lines.)

<http://en.wikipedia.org/wiki/Id_Tech_4>

Take the Java Challenge (entries will be judged by quarterly revenue, rather than fewness of lines)

<http://www.ebay.com>

</comment><comment><USER18> The idea behind Arc seems to be to create a new language to stand the test of time. The problem I'm having with this challenge, and Arc in general, is that it's very domain specific.

Now, lisp /scheme is really great at making DSLs. This example makes me think that Arc isn't a new all-purpose language, but rather a DSL language that can easily be modified to withstand criticism. "It doesn't have feature x!!!" ...2 weeks later... "Well, it does now."

I'm not saying that DSLs are insignificant, or that Arc's creation was trivial, but when examples like this are used, it feels more like a framework than a new paradigm. I think most Python/Ruby/Haskell/(modern language) hackers could fairly easily implement a library to do what Arc does in about as many lines, but they wouldn't call it a new language.

</comment><comment><USER19> is program shortness really that important?

what percentage or time developing an app do you guys spend typing? For me it is quite low but maybe i'm not a superhacker or i just type fast

<comment><USER3> It's not so much about typing as thinking. It's not just to save typing that you use high level languages instead of machine languages, right?

</comment></comment><comment><USER20> Suggestion to Arc fans: do not do XML examples, as C# 3/VB 9 and LINQ to XML will leave you in the dust.

</comment><comment><USER21> Everyone loves a short girl (particularly Asian), you can throw them around the room and generally have a good time with them.

A short, hideous girl (Arc)? I wouldn't hit it.

I'm sticking to the short and beautiful (Python/Ruby).</comment>


Show HN: Project Repat - Turn t-shirts into quilts - <AUTHOR> http://projectrepat.com

<comment><USER2> Very cool. I have an entire box of shirts I've collected over the years and no longer wear but hate the thought of throwing away. I'll have to try it.</comment>


At Facebook, Median Pay Tops $240,000 - <AUTHOR> https://www.wsj.com/articles/at-facebook-median-pay-tops-240-000-1523924535 <comment><AUTHOR> relevant excerpt:

"Facebook calculated the 37-to-1 pay ratio by comparing Mr. Zuckerberg's compensation to that of a specific individual identified as a median worker. Facebook factored in the salary, bonus or sales commission and the value of equity awards granted to that employee as of Oct. 31, 2017. Many of Facebook's Silicon Valley peers have not yet filed their proxy statements. Twitter Inc. last week said the annual total compensation for a median employee in 2017 was $161,860."

<comment><USER2> 161 seems super low to me for a place that probably wants people to do actual work like i'd expect people might do at twitter...</comment></comment>


Bing – internet speed - <AUTHOR> https://www.bing.com/search?q=internet+speed <comment><USER2> It's only available in US, here is the direct link for others countries: [https://www.bing.com/widget/t/speedtest](https://www.bing.com/widget/t/speedtest) The max speed I could get was 120Mbps down / 130Mbps up (from Switzerland)

<comment><USER3> That's it! End of speedtest.net</comment></comment>


Why you should go with your gut feeling - <AUTHOR> http://www.newscientist.com/channel/being-human/dn14615-why-you-should-go-with-your-gut-feeling.html?feedId=online-news_rss20

<comment><USER2> Reminds me of the book "Blink" by Malcolm Gladwell</comment>


Derivative Works in Open-Source - <AUTHOR> https://www.linuxjournal.com/article/6366 <comment><AUTHOR> This article provide sufficient explanation on derivative works in open- source. What do you think ?</comment>


SpaceX wants to launch 30k more satellites - <AUTHOR> https://www.latimes.com/business/story/2019-10-15/spacex-30000-starlink-satellites <comment><USER2> Dupe - [https://news.ycombinator.com/item?id=21261230](https://news.ycombinator.com/item?id=21261230)</comment>


Tests Too DRY? Make Them Damp - <AUTHOR> https://testing.googleblog.com/search/label/TotT <comment><AUTHOR> I posted this as a point of discussion; I disagree with some of the points in this blog post.</comment>


Samsung Sold its Hard Drive Business to Seagate for $1.4 Billion - <AUTHOR> http://bits.blogs.nytimes.com/2011/12/20/seagate-samsung-acquisition/ <comment><USER2> WD and Seagate now make 87% of all disk drives. Unsurprisingly, they just slashed warranty on various drives down from 5 to 3 years, and even down to only 1 or 2 years for some models. Oligopoly will suck for us consumers.

<comment><USER3> True, only if the WD HGST merger goes through.

<comment><USER2> The UE authorized the merger, AFAIK they're only waiting for the Chinese green light.

<comment><USER3> EU approval is only conditional. US SEC and China are still pending. Cannot comment on the chances of it going through.

I work at HGST.

</comment></comment></comment></comment><comment><USER4> $1.4 billion, mates. $1.4 billion for a business with manufacturing plants, complicated global logistics... Now let me remind you that Facebook is valued 85 (!) times more.. o_O

<comment><USER5> Stock market valuations are almost useless... unless you work with stocks.

If Facebook disappeared tomorrow, nothing of value would be lost and another web site would take its place.

<comment><USER6> Not really, what disappears is the Facebook "potential" to make money, and the valuation is done thinking at this possibility. Now if you look at it in this way, billions of people using Facebook can be monetized probably much better in the long run compared to selling a new HD from time to time to millions.

<comment><USER7> What amazes me is that people actually think this is the right way to look at things...

<comment><USER8> Meh. It's an opt-in system.

If somebody is more concerned with something else there's nobody forcing them to focus on making money.

<comment><USER9> Actually, it's not purely opt-in. Remember when our tax money "rescued" the banks because of their reckless lending/investments less than two years ago?

<comment><USER8> Ouch. Valid point.

</comment></comment></comment></comment></comment></comment></comment><comment><USER10> And then there were 4[1]. And soon to be 3[2]. And one of those doesn't make many drives[3].

So we have a duopoly in hard disks. I'm quite surprised regulators allowed this deal.

[1] Seagate, WD, Hitachi, Toshiba

[2] WD is buying Hitachi

[3] Toshiba doesn't make many drives, and only makes 2.5 inch and smaller.

<comment><USER11> Are they all from the same country? Either way, the PC industry and the related component industry is fading away, so Samsung did the right move here. They probably want to focus more on the mobile markets.

<comment><USER12> Right. We're entering the post PC era. Pretty soon everything will be done on tablets or 'in the cloud.' Neither of which require hard drives.

<comment><USER13> Where exactly do you think data 'in the cloud' is actually stored?

Given, this may well require _fewer_ hard drives (due to better capacity utilization), but still requires hard drives.

</comment></comment></comment></comment><comment><USER14> 1.4B or around 980M formatted.

</comment><comment><USER15> So it's now Seagate, Western Digital, and Toshiba. Signs that innovation has moved elsewhere, perhaps.

</comment><comment><USER16> Apple is the largest buyer of SSDs in the world, but their largest supplier has been Samsung, a company they've been increasingly at odds with in the phone business.

In one day, it is announced that Samsung has sold this business, and that Apple has purchased a competing SSD supplier. Just like that, the shape of the market shifts dramatically.

<comment><USER17> "In one day, it is announced that Samsung has sold this business, "

Not really, they had sold the hard drive business, but not the SSD business. Read the article, you will notice it says that it provides Seagate a LINK with the SSD business, not with the business itself.

</comment></comment><comment><USER18> For anyone that is curious about Seagate's SSD play and have been waiting for them to do something customer-facing for a while now: they have actually been doing enterprise flash storage for years, but I would assume through this acquisition we will now see official customer-facing drives being sold next year.

Likely rebranded Samsung 830s for starters (which is a solid drive) and hopefully get some updates and a common controller/firmware between the consumer drives and enterprise drives in 2014/15 to bring them in more a competitive lineup with the SanForce controllers that are dominating (note: still waiting to see what the 3rd gen Intel's perform like, they may change the landscape. Hard to say at this point).

Not thrilled to see only two options when it comes to spindle drives, but I imagine those aren't long enough for this world to really create a hub-bub.

</comment><comment><USER19> "Most of the world's disk drives are not able to be built because Thailand is underwater"

Consolidation when supply is depressed is anticompetitive.

<comment><USER15> This deal was decided months ago, as was the WD/HGST acquisition.

<comment><USER19> It's not clear to me where you're going with that observation.

<comment><USER15> Should they cancel an acquisition because of a temporary manufacturing problem? IMO the flooding shouldn't affect our thinking about whether these deal are competitive or anticompetitive.

<comment><USER19> When there are few suppliers, depressed demand makes it easy for oligopolists to behave like monopolists.

Should they cancel the deal? Certainly their shareholders wouldn't like them to do it out of the kindness of their hearts. I do think that competition watchdogs should be looking at HD mfers very closely now.

</comment></comment></comment></comment></comment><comment><USER20> I'm surprised that they sold the SSD business. I'm guessing that's primarily what Segate was after.

<comment><USER21> They did not sell their SSD business. They sold their Hard Drive business.

<comment><USER22> "The agreement gives Seagate select elements of Samsung's hard drive business, including Samsung's high-capacity M8 hard drives and semiconductors used to make solid-state drives"

<comment><USER21> Samsung will continue to make SSDs and other products based on its NAND business, but Seagate will gain NAND supplied by Samsung that it needs to launch its own SSD business along with acquiring the entire Samsung HDD business.

This was probably the only way for Seagate to complete the deal. Samsung's NAND business is probably more valuable than the entirety of Seagate.

Here's the rundown: [http://www.seagate.com/ww/v/index.jsp?locale=en- US&name=...](http://www.seagate.com/ww/v/index.jsp?locale=en-US&name=samsung- seagate-alignment-announce- pr&vgnextoid=d00a78162ab6f210VgnVCM1000001a48090aRCRD)

</comment></comment></comment></comment><comment><USER23> Thats bad, because the Samsung discs had a much better quality than Seagate or Western Digital. We now have a monopoly of two low quality discs.

<comment><USER24> Duopoly.

Incredibly interesting list of existing duopolies: <http://en.wikipedia.org/wiki/Duopoly#Examples_in_business>

</comment></comment><comment><USER25> As of late, Seagate drives have been pretty crappy, which is a real shame given their former glory. Maybe this purchase will change something.

<comment><USER2> Storage professional here. Disk drives failure rate is usually 0.5 to 3% a year. Drives do fail, so you can't draw any statistical significant figures from the failure of a couple of drives among a total of four or five (or even ten or twenty).

However my company's selling drives by the thousands, and here's what I can say: Seagate barraccuda are the worst pieces of crap being sold since the infamous IBM 80GB debacle; their failure rate is 10% a year, no less. Unsurprisingly Seagate just dropped their warranty to ... 1 year! Keep away from these at all costs...

Seagate Constellation seem to be OK but I only have a few of these.

Hitachi 1, 2 and 3 TB look impressive: 1 failure among 2 thousand drives, in 2 years.

WD seem OK, but I haven't nearly enough of them to get significant numbers (a couple hundreds).

<comment><USER26> Unfortunately, I recently picked up a couple of Barracuda because of a price break fluke that let me essentially escape the flooding price inflation.

I guess I will use them with trepidation (redundant backups, mostly sitting on a shelf) and plan to phase them out in the coming year and/or into transient cache.

Thanks for the heads up.

P.S. I was set to go with Hitachi (2 TB 7200 RPM) when their prices more than doubled on me. Price aside, are they still a good bet like they were a couple of years ago? (I recall reading that at one point Google was favoring them.)

Also, since I'm adding a postscript, does anyone recall the HD failure rate study that someone put out a few years ago? Of course, things change, but behind the particular models in seem to recall some useful inferences about company/brand quality/reliability.

<comment><USER2> There were several interesting studies these past years : one from google, one from NetApp, an older one from the CERN:

Google 2007: <http://research.google.com/pubs/pub32774.html>

Carnegie Mellon 2005: <http://www.usenix.org/events/fast07/tech/schroeder.html>

CERN on data integrity: [http://indico.cern.ch/getFile.py/access?contribId=3&sess...](http://indico.cern.ch/getFile.py/access?contribId=3&sessionId=0&resId=1&materialId=paper&confId=13797)

NetApp 2010: <http://synergy-ds.com/netapp/wp-7005.pdf>

<comment><USER26> I may be remembering the Google study and/or something else from about that time frame. I have a vague recollection now of both Google's opinion and and something else that had at least some degree of separation from Google.

Thanks very much for the informative response. I'll have a look at these (as soon as I talk myself down sufficiently from my guilt over my price-motivated Seagate purchase ;-).

In part, I also pushed the button on Seagate (despite the 1 TB "click of death" episode from a few years ago) because a recent WD laptop HD purchase went rather bad with incessant parking that is apparently inherent to the model's firmware. I finally fixed that on the XP Pro machine it lives in by finding and setting to run on start-up:

<http://sites.google.com/site/quiethdd/> [1]

But not before SMART reported significant aging for the drive. Which rather pissed me off. (I should pull it and RMA it -- 5 year warranty.)

So, that helped lead me to Hitachi. Then the price inflation, plus the news that WD is buying Hitachi, and I figured I'd give Seagate another go.

I hate purchasing consumer electronics, these days.

\--

1\. Which I found at about the same time I learned I could tweak the relevant settings manually -- so, I went with the pre-packaged implementation.

</comment></comment></comment></comment></comment><comment><USER27> With samsung the world leader in ram I would have thought they could've done some great things in ssd field. Bummer.

<comment><USER15> As the largest flash vendor, Samsung may win no matter which controllers are used. Seagate has no consumer SSDs so I can understand why they want to buy that business from Samsung.

<comment><USER27> Ah, the good 'ol iPhone bundling tactic. I'm definitely not an opponent of sticking to what you're good at, and doing it best. And with this deal, I guess that's what's happening with both companies!

</comment></comment></comment><comment><USER28> 1.4B .. money they will need to keep investors happy while burning money on smartphones

</comment><comment><USER29> Glad the sale wasn't the other way.

I remember when Seagate first bought Maxtor.

</comment><comment><USER30> In the short term this is good for Seagate. In the long term though, I think this is good for Samsung. More and more of our memory needs are being met by online storage.

Sure we'll need NAND going into the future. But are we going to need it in the quantities that we currently demand when cloud storage is becoming more and more popular?

<comment><USER31> Online storage providers still need to purchase hard disks.

<comment><USER30> Online storage providers don't use NAND, and they won't be consuming drives at the same rate as consumers.</comment></comment></comment>


Show HN: Simpler HN - <AUTHOR> https://www.8hrs.xyz/ <comment><USER2> Just a bug report, bbc.co.uk is getting truncated to co.uk i.e. third level domains or tlds like co.uk or ac.in are being treated as domains.

<comment><AUTHOR> thanks for looking at the site.i fixed the bug now. btw nice photographs on your site.

<comment><USER2> Yes, fixed, but was it fixed only fro bbc.co.uk? because I see another something.ac.uk website. href url is correct, but the part after title is stripping based on some regex?

List of Valid TLDs: [http://newgtlds.icann.org/en/program-status/delegated- string...](http://newgtlds.icann.org/en/program-status/delegated-strings)

Some tlds can have single dot; like .com & some might have multiple; like firm.ind.in or co.uk or ac.in or such.

Check more discussion here at SO question: [https://stackoverflow.com/questions/10306690/what-is-a- regul...](https://stackoverflow.com/questions/10306690/what-is-a-regular- expression-which-will-match-a-valid-domain-name-without-a-subd)

Thanks for looking at my photo website :)

<comment><AUTHOR> It may the issue with database updates. Gradually it should display the proper domain names. Here is the function I am using to get the domain name. [https://play.golang.org/p/W5Z5yoDs3IZ](https://play.golang.org/p/W5Z5yoDs3IZ)

Also the code of 8hrs.xyz is on github.com/mseshachalam/x

</comment></comment></comment></comment><comment><USER3> If you like HN but prefer less information and on an hour delay, this may be for you!</comment>


Introducing Tectonic – A Kubernetes and CoreOS Platform - <AUTHOR> https://tectonic.com/blog/announcing-tectonic/ <comment><USER2> > Tectonic is a commercial distribution of the combined Kubernetes and CoreOS > stack.

> Tectonic pre-packages all of the open source components required to build a > Google-style infrastructure and adds additional commercial features, such as > a management console, corporate SSO integration, and Quay, our enterprise > ready container registry.

Well, I don't care. Fix etcd before anything. Cluster recovery doesn't work well (it's an understatement), etcd has issues with high loads, and leader election has its quirks. CoreOs is barely usable at this state.

This is the kind of thing you need to expect when running a CoreOS cluster: [https://github.com/coreos/etcd/issues/863](https://github.com/coreos/etcd/issues/863). etcd is not "production ready", well, this should be taken care of as it's a central part of the system.</comment>


AmEx Links Up Facebook With Coupon-less Deals, And Lets Merchants Go Social - <AUTHOR> http://techcrunch.com/2011/07/18/amex-facebook-deals-go-social/

<comment><USER2> I don't know anyone who is going to download this.</comment>


Paul Graham: Some VCs Push For Large Rounds, Even When Startups Don't Need Them - <AUTHOR> http://www.forbes.com/sites/tomiogeron/2013/06/27/paul-graham-some-vcs-push-for-large-rounds-even-when-startups-dont-need-them/

<comment><USER2>
        "Graham suggests that if one reputable venture firm were
        to break this non-spoken 20% Series A agreement, the best
        startups would instantly flock to that firm. "It's going
        to happen," Graham says. "You might as well anticipate it
        and look bold.""

pg,

Any plans on using the collective attractiveness of YC to help push that 20% stake down? e.g. would you talk to a lot of the startups in the current batch about collectively sticking to a lower percentage like 15% to get the ball rolling in the direction of the new funding landscape?

It seems like YC companies keep raising larger and larger rounds, oftentimes more money than they really need for 18 months of runway. With that in mind, the logical thing to do is to collectively help them give up less equity to get back to 18 months of runway.

<comment><USER3> > would you talk to a lot of the startups in the current batch about > collectively sticking to a lower percentage like 15%

I'm not a lawyer or even a particularly skilled investor, but that smells like an SEC violation. Even if it wasn't, I think it'd be something akin to price fixing.

Would someone who knows more care to chime in? Am I wrong?

<comment><USER2> Isn't the current situation of 20% as a bottom limit the same?

The US has a history of cartel like behavior in finance. Just look at the percentage charged for IPOs [0]. I'm sure if you created a similar graph for venture capital financing that you'd see a black line on the graph just like the one created by Mark Abrahamson, Tim Jenkinson, and Howard Jones.

Trying to break that 20% barrier would seem acceptable. After all, the goal here isn't to get the VCs to take less equity for the same amount of money, but to provide more flexibility in the tradeoff between cash and equity.

[0] [http://www.sbs.ox.ac.uk/research/people/Documents/Tim%20Jenk...](http://www.sbs.ox.ac.uk/research/people/Documents/Tim%20Jenkinson/AJJexecsum.pdf)

<comment><USER3> Some questions:

Do you believe that the 20% as a bottom limit is the result of a group colluding with intent, or is it just the result of a type of evolutionary convergence?

By chain rule, as long as the market has some modicum of elasticity, isn't fixing supply analogous to price fixing? Maybe I'm assuming that the supply of appealing early stage equity is much lower than it is? Or is something flying over my head and this has nothing to do with supply of said equity?

I definitely agree on the bigger point. The whole early stage equity market is weird as hell, and it seems like there are plenty of opportunities to manipulate/exploit it.

<comment><USER2> I would say culture and sometimes intentional and sometimes unintentional collusion.

Investments are made in other industries all the time and the percentage owned after an investment can vary dramatically, from fractions of a percent to majority ownership. What makes VC investments so special that its own nature would result in settling upon a nice conveniently round number like 20%?

Plus, the 20% isn't fixed in stone. It's an asymptote. It's not unusual for it to range as high as 30 to 35%. I'd love to see a graph like the one in the IPO study. I'm sure it would be very illustrative of collusion.

</comment></comment></comment></comment></comment><comment><USER4> Fred Wilson (Union Square Ventures) just wrote about something similar in his blog post today.

[http://www.avc.com/a_vc/2013/06/valuation-vs- ownership.html](http://www.avc.com/a_vc/2013/06/valuation-vs-ownership.html)

Edit: mentioned in the article - I should read more carefully!

<comment><USER5> 'We are also very much focused on what is in the best interest of the entrepreneur. You might ask "how can taking $2mm for 20% be better than taking $5mm for 20%?" and you'd be right asking that question. The answer is you can get the other $3mm later at an even higher price. That has been the history of many of our investments.'

Can someone explain to me how this makes sense. I'm still going to have to give away x percent of the company to raise another $3mm. What am I missing here?

<comment><USER6> "... at an even higher price" is perhaps unclear; I presume he meant "... at an even higher valuation". That is, the total percentage of the stock you have to sell to the investor to raise the money is less if you raise in two stages than if you get it all up front.

There's an assumption here: that you actually manage to make demonstrable progress in the business between the first and second round. If you think it's going to take longer to show progress than the amount of time $2M will give you, then you should raise more to start with.

</comment></comment></comment><comment><USER7> This is essentially a shallower version of "The New Funding Landscape" ([http://www.paulgraham.com/superangels.html](http://www.paulgraham.com/superangels.html)), which was published in 2010.

<comment><USER8> Yeah. It read like our beloved pg dumbed down to a Forbes puff piece level. Which kind of puts it at the business nerd equivalent of celebrity gossip for those not seriously interested in VC and startups. Such things can be a little painful to read if you're a startup nerd rather than a mainstream business nerd - not because it's wrong, but because it's shallow to us.

I wonder what impact it'll really have, though? Most people aren't in any position to ever deal with VC from either end, except at a far distance. And the VCs and startups are plenty aware of the situation already.

</comment></comment><comment><USER9> "Graham also released some metrics on Y Combinator: it has 564 startups total. Of the 285 that have valuations, the total valuation of the companies is $11.6 billion."

!

<comment><USER10> I wonder which companies are skewing that the most, anybody have a list of the top Y Combinator companies?

Obviously the average of $46 million doesn't provide a clear picture at all.

<comment><USER11> Just taking out Dropbox and Airbnb, the average for the rest already drops quite a bit. With Dropbox at more than $4bil [1] and Airbnb at $2.5bil [2], that leaves the remaining 283 at about $5bil total, or $17.6mil each. Taking out others like Weebly would drop it further.

[1] - [http://www.forbes.com/sites/quora/2013/02/07/why-is- dropbox-...](http://www.forbes.com/sites/quora/2013/02/07/why-is-dropbox- worth-more-than-4-billion/)

[2] - [http://www.bloomberg.com/news/2012-10-19/airbnb-said-to- be-r...](http://www.bloomberg.com/news/2012-10-19/airbnb-said-to-be-raising- money-from-peter-thiel.html)

<comment><USER12> So what you're saying is that if you take all of the successful companies out of an investor's portfolio, that portfolio will have a lower value.

<comment><USER13> Well I think more precisely, he's implying if you take out the few heavy hitters, then the value drops precipitously.

<comment><USER14> Or stated even more precisely, the mean and median are very different :)</comment></comment></comment></comment></comment></comment>


Apply HN: Notisha – Microlearning for Faith-Based Communities - <AUTHOR> Notisha is a microlearning platform for faith-based communities.
Here's our demo video (https://www.youtube.com/watch?v=L4IxzMP4pSI).
PROBLEM
1. Most believers have a very shallow understanding of what they believe in.
2. It's very hard to find high quality, structured and spiritually nourishing content that can be consumed in between our busy schedules on a daily basis.
SOLUTION
We are creating a platform where a believer will be able to select up to 5 topics to learn from every day from different spiritual leaders/teachers. The content is packaged in bite sized chunks as text or less than 5 minute video tips/tutorials. We are starting with the marriage and relationships topic.
HOW WE MAKE MONEY
The first 2 teachings of the day are free, the next 3 are available on subscription.
STAGE
We are currently in the prototyping phase but will be releasing a mobile app within the next 7 days. Here's the apk (http://bit.ly/1SR0kPJ) for the current build.
We'd love to hear from you on what you think about it. <comment><USER2> What an interesting way to write what is deemed the problem. Can you post sample content? It would be nice to read it.

How do you plan with filtering content by religion?

<comment><AUTHOR> >> How do you plan with filtering content by religion?

When registering for Notisha we'll ask you the religion you profess. With this information we'll be able to suggest to you content from teachers from your religion.

>> Can you post sample content?

Here is a sample content that may be sent to Christians who've subscribed to the Marriage & Relationship topic

Marriage requires that you learn to keep your mouth in check. You can't control what enters through your ears but you are 100% responsible for what comes out of your mouth. Knowing when to open your mouth and speak, and when to shut it in silence is part of the maturity expected in every couple. Many people destroy their own marriages by the missiles that come from their own lips. "Those who guard their mouths and their tongues keep themselves from calamity." (Proverbs 21:23)

Things to note; the content is brief and quotes a bible passage at the end.</comment></comment>


A Theory of Changes for Higher-Order Languages [pdf] - <AUTHOR> http://www.informatik.uni-marburg.de/~pgiarrusso/papers/pldi14-ilc-author-final.pdf

<comment><USER2> It looks to me like the authors attempt to develop a method to automatically make any program memoizable, similarly to how you can automatically differentiate a huge family of differentiable functions in your favorite symbolic math program (Mathematica, maybe?)

Are there more examples of differential plugins (that to me look akin to the table of derivatives in your Calculus I book)?

From the paper:

Users of our approach need to (1) choose which base types and primitives they need (2) implement suitable differentiation plugins for these base types and primitives (3) rewrite (relevant parts of) their programs in terms of these primitives (4) arrange for their program to be called on changes instead of updated inputs.

Anyone seen some more examples other than they toy example in the paper?

Not a PL person, sorry if I misunderstood something.

</comment><comment><USER3> I recently wrote an R package that computes the differences between arbitrary R objects as closures precisely for the reason the authors gave in their abstract: it is much more computationally feasible to remember changes in program outputs than to perform full recomputation. In their lingo, this means I defined a change structure for R objects.

[https://github.com/robertzk/objectdiff](https://github.com/robertzk/objectdiff)</comment>


Love Your Terminal - <AUTHOR> http://blog.andrewhays.net/2012/11/29/love-your-terminal.html From old HN: https://news.ycombinator.com/item?id=4852016 <comment><AUTHOR> From old HN: [https://news.ycombinator.com/item?id=4852016](https://news.ycombinator.com/item?id=4852016)</comment>


Microsoft OCR Library for Windows Runtime - <AUTHOR> http://blogs.windows.com/buildingapps/2014/09/18/microsoft-ocr-library-for-windows-runtime/

<comment><USER3> We had great results using tesseract-ocr[1] with SWT (state of the art text detection algorithm, via libccv[2]) on Linux.

You can use our python bindings for both[3,4], although they might be slightly outdated:

[1] [https://code.google.com/p/tesseract- ocr/](https://code.google.com/p/tesseract-ocr/)

[2] [http://libccv.org/doc/doc-swt/](http://libccv.org/doc/doc-swt/)

[3] [https://github.com/veezio/pytesseract](https://github.com/veezio/pytesseract)

[4] [https://github.com/veezio/pyccv](https://github.com/veezio/pyccv)

<comment><USER4> Be aware that SWT is patented [1] if you want to use it commercially.

[1] [http://www.google.com/patents/US20090285482](http://www.google.com/patents/US20090285482)

<comment><USER5> This link shows the claims of the published application. The recently allowed claims are a lot more narrow and less problematic. Still worth reviewing though in case you are worried you infringe:

[http://www.scribd.com/doc/240266916/12122729](http://www.scribd.com/doc/240266916/12122729)

</comment></comment></comment><comment><USER6> This is very cool! I've been working on a receipt scanning tool in C# for keeping track of kitchen inventory (tired of calling my wife asking if we have sesame oil or some odd ball thing)

I found a few libraries, but they only worked with relatively perfect scans (my goal is to be able to just use a phone). When I get home definitely going to give this a go.

</comment><comment><USER7> Off topic, but this made me think that it would be neat if libraries on places like github and nuget could someout include "cited by" data. Something that referenced open source (maybe closed source too) projects that had a dependency to the library similar to google scholar or CiteSeerX.

<comment><USER8> You can get a DOI for github.

<comment><USER9> Then what? There's nothing magical about DOIs. You need someone to store the citation metadata. And generate / deposit citation metadata. And maintain the persistence of the DOI. What precisely does the DOI represent? A codebase? A fork of it? A file? A file at a particular revision? A changeset?

</comment></comment></comment><comment><USER10> It doesn't appear that you can use this in a 'normal' .NET app. Any ideas why?

<comment><USER11> This is really one of my big frustrations with Microsoft.

On one hand, they really try to push everybody to upgrade to their newest and shiniest, by making a lot of stuff (like this) only available on Windows 8+.

On the other hand, they don't even bother to put in a box with "What operating systems will this work on", so you don't have to do trial/error, research WinRT, and then be disappointed when you realize this will apparently never work on Windows 7. And maybe only in Metro apps? What is Windows Runtime and am I just supposed to know this?

I really enjoy coding C# and working in .NET. Microsoft has some really great stable techs which work well for years and years - but increasingly if you want anything new and shiny from them, you have to run the newest OS. Which if you work with anything related to enterprise, good luck only targetting Windows 8.

And honestly, despite working almost exclusively with MS tech, I just don't really trust any platform from them that doesn't have significant traction and track record as they all too often just give up and try something new - <USER2> sometimes without real replacements available.

<comment><USER4> The MSDN documentation for the classes [1] clearly states the supported platforms. Admittedly the restriction to store apps is missing on the page for the namespace [2].

      Minimum supported client  Windows 8.1 [Windows Store apps only]
      Minimum supported server  Windows Server 2012 R2 [Windows Store apps only]
      Minimum supported phone   Windows Phone 8

[1] [http://msdn.microsoft.com/en- us/library/windows/apps/xaml/wi...](http://msdn.microsoft.com/en- us/library/windows/apps/xaml/windowspreview.media.ocr.ocrengine.aspx)

[2] [http://msdn.microsoft.com/en- us/library/windows/apps/xaml/wi...](http://msdn.microsoft.com/en- us/library/windows/apps/xaml/windowspreview.media.ocr.aspx)

<comment><USER11> Ah, don't know how I missed that. Thanks.

Crazy that it's limited to 8.1, and not even working on 8.0.

I really wonder if there is a valid technical reason, or they just use it to push upgrades.

<comment><USER12> It's crazy that it's Windows Store only. On my only Windows machine the Windows Store won't even open because I have UAC disabled.

<comment><USER13> Who on Earth uses Windows Store apps on Windows Server? We would totally consider using this if not for that.

</comment></comment></comment></comment></comment></comment><comment><USER14> On [http://msdn.microsoft.com/en- us/library/windows/apps/windows...](http://msdn.microsoft.com/en- us/library/windows/apps/windowspreview.media.ocr.aspx) they mention the supported languages and their statuses, but Korean is only "Good".

I freely admit that I do not speak Korean, but if one compares "Chinese Simplified" characters (listed as "Very good") with those in the Korean alphabet, I am surprised those two entries aren't transposed.

Is there something that makes recognizing Korean harder than Chinese Simplified, or was that just a product management decision?

</comment><comment><USER15> "demonstrated in code snippets below". The code snippets are actually images and even worse, they're JPEGs which is the reason why the text looks horrible.

<comment><USER16> If only there were some automated way to convert those images to text.

<comment><USER17> Now that is possibly the cruellest irony I've seen for a while. Well spotted :)

</comment></comment></comment><comment><USER18> is this better than the terrassect OCR?

<comment><USER19> I think that's a sort of apples and pears type of comparison.

Tessarect can be used everywhere, and is used dominantly on open platforms. This is a offering from Microsoft to be used on their platform only.

They may both be good, but they have widely different platform targets.

<comment><USER20> My guess is he meant better at actually OCR'ing text, not better for implementation.

</comment></comment></comment><comment><USER21> tesseract is really looking great with google adding searchable pdf as output in the latest release candidate.

</comment><comment> Norm-- So from reading the list of reasons for inaccurate results, it sounds like this library is totally useless for images taken with mobile phones, yet it is only allowed to run on mobile ;)

Now I would be more interested in an image correction library

".... Blurry images Handwritten or cursive text Artistic font styles Small text size (less than 15 pixels for Western languages, or less than 20 pixels for East Asian languages) Complex backgrounds Shadows or glare over text Perspective distortion Oversized or dropped capital letters at the beginnings of words Subscript, superscript, or strikethrough text"</comment>


Ask HN: Why aren't we talking about Alton Sterling or Philando Castile? - <AUTHOR> I'm seeing posts about the bomb-disposal robot and lots of interesting little stories that I'd love to read some other day but this is the one news site I know of that doesn't mention Alton Sterling or Philando Castile. Why is that? <comment><USER2> Via the Guidelines:

> Off-Topic: Most stories about politics, or crime, or sports, unless they're > evidence of some interesting new phenomenon.

<comment><USER3> I would consider using a robot bomb to kill a suspect an "interesting" (for scary values of interesting) new phenomenon: [http://motherboard.vice.com/read/dallas-pd-using-a-bomb- robo...](http://motherboard.vice.com/read/dallas-pd-using-a-bomb-robot-to- kill-a-suspect-is-an-unprecedented-shift-in-policing)

<comment><USER4> And that aspect of the story is indeed being discussed:

[https://news.ycombinator.com/item?id=12055492](https://news.ycombinator.com/item?id=12055492)

[https://news.ycombinator.com/item?id=12057421](https://news.ycombinator.com/item?id=12057421)

</comment></comment></comment><comment><USER5> Because the topic doesn't belong in a news aggregator about technology, science and business. My heart is near the victims and you can show them respect in other meaningful ways.

<comment><USER6> Pretty much this. There are so many places to talk about these things. It doesn't mean that people here don't consider the topic important, I've seen discussions on twitter, facebook, reddit, and elsewhere that explore many of the same points that the news media is exploring.

</comment></comment><comment><USER7> If I was Mr. Castile, the last thing I would want is to have my good name [0] banded about in pairs with Mr. Sterling who was an armed felon and sex offender with a history of resisting arrest [1].

[0][http://heavy.com/news/2016/07/philando-castile-criminal- reco...](http://heavy.com/news/2016/07/philando-castile-criminal-record- arrest-record-police-racial-profiling-criminal-history-rap-sheet-felon-crime- falcon-heights-minnesota-police-shooting-facebook-live-video-watch-lavish- reynolds-diamond/)

[1][http://heavy.com/news/2016/07/alton-sterling-arrest- record-c...](http://heavy.com/news/2016/07/alton-sterling-arrest-record- criminal-history-rap-sheet-sex-offender-sex-offense-crime-baton-rouge- louisiana-police-shooting-blane-salamoni-howie-lake-shot-charges-video- youtube-facebook-watch/)

</comment><comment><USER8> [https://news.ycombinator.com/item?id=12054230](https://news.ycombinator.com/item?id=12054230)

And many other submissions besides.</comment>