Haskell on a Horse: a new web framework based on arrows and continuations - <AUTHOR> http://haskell.on-a-horse.org/ <comment><USER2> _To deal with high demand, the server is being restarted once a minute._

Wow, they really are trying to imitate Rails.

</comment><comment><USER3> "Haskell on Horseback" would have more of a ring to it.

<comment><USER4> Haskell on Horse would be more addictive.

(Actually, calling something $Foo$ on $Bar$ puts me off. It suggests the developers are not starting out looking at what makes the base language unique in its own right, and will likely make poor design choices from wanting to mimic something from a different, incompatible, realm.)

<comment><USER5> I'm pretty sure they're referencing the Old Spice commercials and the similarity to 'Ruby on Rails' is only coincidental. The framework itself looks nothing like Rails.

<comment><USER6> I haven't actually seen those commercials. The name is a pun of "Ruby on Rails".

I intended the name to draw a contrast, not to suggest a similarity! The metaphor of 'rails' is that ruby development is sped up by being kept on a particular track ('convention over configuration') - there is also a connotation of industrial strength, power, etc. A person on a horse calls to mind the opposite characteristics: exploratory, unconstrained, human.

<comment><AUTHOR> Oh, I had also assumed you were referring to the Old Spice commercials. So sclv's comment made no sense? ...

[http://www.reddit.com/r/programming/comments/cuq2u/haskell_o...](http://www.reddit.com/r/programming/comments/cuq2u/haskell_on_a_horse_a_new_web_framework_based_on/c0vf545)

<comment><USER6> Well, I found his comment pretty funny, but I had to google it first to figure out what he was talking about.

</comment></comment></comment></comment></comment></comment><comment><USER7> Does this support templating, data models, etc? How far removed is this from a "traditional" MVC web framework and how can on-a-horse be applied in real business? Does it have built-in support for ajax responses, dynamic partial rendering etc?

<comment><USER8> I'm ok with proof of concept sort of things - everything has to start somewhere. However, I think that having an idea of what it'll eventually be good at helps. Haskell seems to be fairly performant... what else? Concise? I suppose, although I can't read it enough to tell what it's even doing.

<comment><USER9> The following is my synthesis of current trends; I do not necessarily believe it entirely and I'm not completely advocating it.

One of the recent focuses in the functional world has been composition. Object orientation promised us the ability to have components that could be easily strung together to make programs. It has basically failed. We have OO frameworks and libraries, and we have little tiny OO containers, but the levels inbetween have not manifested the way they were "supposed" to. And even to the extent that libraries and frameworks have succeeded, they often don't play well together. In particular, if you use my preferred definition of "framework" vs. "library", which is that the framework calls you and you call the library, it verges on the impossible to use two frameworks simultaneously. That is to say, you can not compose two of them together.

If you say "Why would you want to do that?", the answer is really simple: You want features from both. You're probably so used to the idea that this is impossible that you've completely internalized it and can't hardly even think about why you might want to do that without rebelling at the thought of how obviously impossible that would be. But there's no fundamental reason why this should be.

So, the Haskell functional community has been kicking around ideas about how to provide truly compositional components. It is absolutely true that there are libraries and frameworks already in existence, but they often don't _compose_ well. The parts are very large and they often are built on assumptions that either can't be satisfied simultaneously, or can only be satisfied with great effort. This looks like one person's stab at solving the problem.

If it sounds like I'm handwaving, to some extent I am. Functional-style composition is hard to wrap your head around if you've been programming in OO for long enough that you think in native OO, and I am not aware of generally accepted terminology for this. It goes both down to a much finer granularity than you are used to in OO (example: a monad is actually this little three- line snippet thing that has been refactored out of all of the implementations of monads, and it's a refactoring at a level so weird and subtle it is weird to come at it if you're not used to it), and ideally up to that middle level that OO is missing. It seems to be a relatively new focus in the community. The goal they are shooting for is to cover that middle ground a lot more richly than OO frameworks have. And again, I emphasize, it is not that OO frameworks like Django have _no_ composition; it is that it is limited in ways that are hard to even see if you've adjusted too much to the OO ways of thought. I also want to highlight that this is a _goal_ ; there's no guarantee this is actually possible on the web, but there are some aspects of Haskell that may make it easier to do in that language that any other, in particular the rigid focus on purity everywhere. (On the other hand, getting the strong types to play together well can be a challenge too; with such strong typing as there is in Haskell you have to get the types _exactly right_ or, virtually by definition of "exactly right", you will be mandating wrong behavior or ban safe behavior, with the mandates and bans being much stronger than in languages with weaker type systems.)

On the web, we have special challenges in that an "atomic element" of a web page may consist of HTML that is generated based on a call from a database and a bit of this file over here, depend on a CSS rule being in the page, require certain Javascript which may itself be generated from some data pulled from some other IO source, may require additional images, and so on and so on. Moreover, for performance reasons you need to be able to do things like control where the <script> tags appear _exactly_ , you don't want to include 40 CSS files, one for each of the 40 individual components that a page happens to have. And the community would like to make it so you have compile-time assurances that the website has all necessary resources in it, so for instance you can use strong typing to "assert" that the CSS a given component requires is statically verified to exist. For one small bit of this, Google for "type- safe url handling" for some discussion about how to make one small part of this process type safe. Oh, and when all is said and done, it would be nice if the types were still humanly-comprehensible. :) Working all of this to some sort of compositional framework is going to be a challenge.

So, if you go back and look at the page having gotten through that wall of text, I think it might help you work out what the author thinks is interesting about an otherwise obviously-trivial "web framework". The "more complex example" is the meat of the idea, in which some simple components are wired together compositionally to produce a hierarchal expression manipulator, which would take much more code in most other frameworks. (Though of course being perfectly possible.) Of course by no means is this a manifestation of everything I said above, I see no work on the things being composed with their JS or CSS resources, and so on. This is more like a first step towards what I described in the previous paragraph, not the completion by any means.

I don't know that anybody has spelled all these ideas at once; like I said, this is my synthesis and you are getting it through my biases. But I thought it might sort of answer your question.

<comment><USER7> You put into words what I couldn't put my finger on about functional programming. With my introduction to ruby and prototype (over C), I'm finally understanding the mathematical-monadic-compositional aspect to functional programming that makes it so powerful.

Its not even what you do with it - its the emergent behavior that makes it so compelling.

Basically what I think you've summed up (but in less words) is that this is a proof-of-concept or a building-block for much more sophisticated examples, showing real approaches of building complex and powerful (especially the UI based expression analyzer) web applications with amazingly little code.</comment></comment></comment></comment>


Notes on a Smaller Rust - <AUTHOR> https://boats.gitlab.io/blog/post/notes-on-a-smaller-rust/ <comment><USER2> As someone who recognizes himself as beginner programmer, i do not consider the borrow checker as my major issue with the language. Heck, i haven't even reached that issue.

Everytime that I have turned away from Rust, despite trying half a dozen times is due to its super busy and alien looking syntax. I just can't parse the code.

<comment><USER3> Honestly, I don't see any intrinsic problems with Rust's syntax that makes it unusually ugly.

Rather, I think the problem is that the syntax is 100% fine in isolation, but has some issues when taken together with experience in other languages — when you skim the code, some parts of it beg to be looked at like C++, while other parts push you to read it like a functional language. Unsurprisingly, neither fully works, which makes the experience jarring. Once you accept that Rust is its own language with its own rules and stop trying to borrow (hah!) from your experience with other languages, it feels much better.

<comment><USER4> > Honestly, I don't see any intrinsic problems with Rust's syntax that makes > it unusually ugly.

You literally just got a user experience report claiming that it is.

<comment><USER5> It's coming from someone who isn't comfortable with C or Java either.

There's no winning over everyone. Of course Rust's syntax will be completely jarring if you're coming from Crystal or Ruby.

In my personal experience it's a little jarring at first and then it completely goes away.

<comment><USER6> I'm comfortable with C/++ and Java, to a greater extent than a lot of people I've worked with. There are still things in Rust that are papercuts:

* The need to put :: before <> in expressions for generic parameters, but not in type signatures.

* Using :: instead of just . even though most of the time the naming convention will delineate the difference anyway

* Error handling with futures

* Self-referential structs

* Passing a shared pointer through multiple move closures

IMHO the frustration involved in these things is not typically worth being more explicit. The :: thing may seem a bit pedantic, but it is simply more physical effort (Shift-colon-colon vs dot) and creates more visual noise.

If/when all of the things above are addressed, I think Rust could give Python a run for its money.

</comment></comment></comment></comment></comment><comment><USER7> I like how the strengths of Rust are summarized by 3 points:

* Algebraic data types

* Resource acquisition is initialization

* Aliasable XOR mutable

I think it can help not only to design a Smaller Rust as discussed here, but also to grasp the key design points of this language which is a bit daunting.

<comment><USER8> I like how these three points aren't just "strengths of Rust", but...

> the necessary components ... to make imperative programming work as a > paradigm

You know, before Rust imperative programming just didn't work. Didn't work as a paradigm, even!

<comment><USER9> It had state mutation as a massive liability - which is probably why FP has seen such a surge in recent years. Rust is the only language that mostly solves that _without_ totally changing the paradigm.

<comment><USER10> It doesn't really change the paradigm compared to FP even, it just enforces a clear separation at all times between _sequential_ state mutation on the one hand and references to _shared_ (and generally immutable, except as provided for by explicit mutability mechanisms) state on the other. Which is essentially what FP languages end up doing, though they go about it somewhat differently.

<comment><USER9> Right. The problem is that functional purity always comes with overhead; data structures like Clojure's help a whole lot, but there's still a cost.

But one of the primary motivators for functional purity is to avoid unintended side-effects.

In pure FP, You never even have to bother your mind with _unexpected_ side- effects because there are _no_ side-effects.

Rust instead gives you the vocabulary to carefully articulate _intended_ side- effects, preventing all other, _unexpected_ side-effects at the same time. So you can colonize the wilderness, instead of avoiding it altogether, and for that you get to skip the overhead of treating everything as immutable. Not that this is an indisputable improvement for every use-case, but it's a novel tradeoff and one that is definitely preferable in many domains.

</comment></comment></comment></comment></comment><comment><USER11> > I would probably experiment with exceptions if I were making this language.

Hard disagree. Rust made conscious design decisions (i.e. limiting type inference) to enable local reasoning, and exceptions are non-local.

<comment><USER12> Checked exceptions (like Java) are isomorphic with Rust's Result type. You could convert a checked exceptions syntax into Result exception-carriers on each return with a mechanical transformation, of a Rust+exceptions program into Rust-today program.

<comment><USER13> Suppose you have

        fn foo(i: i32) -> string throws IOException
        let x: Vec<i32> = ...
        let y = x.iter().map(foo).collect()

What's the type of y ? There are no good answers here: if it's Vec<string> then where did the errors go? If it's Vec<Result<IOExecption, string>> then the user is pretty confused about where the Result came from. You can't propagate the IOException through the map() call in the general case (it might be in a third-party compiled library etc.). In Java this is a compilation error and the reason checked exceptions are useless in practice.

<comment><USER12> In Java, you'd expect map() to throw, and the type of y to be Vec<string>, in Rust parlance. If one of the conversions failed, you'd expect the stack to unwind as the exception propagates, and you'd expect that the use of map() means you're not particularly interested in which item failed, you just want to abort (roll back) on failure. This is the 99.9% use case for exception in Java, or C#, or Delphi; you almost never catch exceptions.

If you're interested in which item failed, ideally you'd be using a method that doesn't throw at all, and instead returns an error condition. I like how C# makes this clear, with Parse and TryParse on Int32. You use Parse when you want unwinding and abort behaviour including stack unwinding, and TryParse when you want to handle errors, and you don't use exceptions for expected errors, since expected errors are not exceptional.

(If the map is lazy, you'd expect the materialization in collect() to throw. But the return type wouldn't change.)

IMO, the kind of code you write on a daily basis is the primary determinant of your preference for error codes vs exceptions. If you need to handle error conditions frequently, you'll prefer error codes, because they're data, like all other data, and you can use the general compositional tools at your disposal to manipulate them. If you handle error conditions exceedingly rarely, and mostly just want to abort, unwind, roll back, go back to the main loop and log them, then exceptions are your friend.

I do not think there is a fundamental superiority either way. I think there are tools for purposes. I do think that Java's checked exceptions are half- baked; they're half-way into the compile time type system in a language whose applications are generally better suited to run time exceptions.

<comment><USER13> > In Java, you'd expect map() to throw

You'd have to use unchecked exceptions to achieve that though. There's no way to propagate the checked exception across that call, because there's no way to make map() generic over exception-or-not in a Java/Rust-like type system.

> If you're interested in which item failed, ideally you'd be using a method > that doesn't throw at all, and instead returns an error condition. I like > how C# makes this clear, with Parse and TryParse on Int32. You use Parse > when you want unwinding and abort behaviour including stack unwinding, and > TryParse when you want to handle errors, and you don't use exceptions for > expected errors, since expected errors are not exceptional.

Result gets you that without needing to write two implementations of every method. You call unwrap-or-panic in the cases where error is not expected/handled, and handle it in the cases where you want to handle it.

</comment></comment></comment></comment></comment><comment><USER13> Interesting. Coming from an FP background I'd say the opposite - the confusing part of Rust is all these special-case imperative control flow keywords, a more smalltalk-like "everything is just values and functions" syntax would be the best way to simplify it.

I'd agree with stepping away from guarantees about when allocations happen etc. But I think at the point where you remove those from Rust you really just have OCaml.

<comment><USER14> Well, it'd be OCaml without a garbage collector. And to be honest, that would be a very useful and handy language for systems development.

<comment><USER13> OCaml is already a good language for systems development - people are far too scared of garbage collectors. And if you make the changes in the article then I think you give up most of the concrete benefits of non-GC - you won't have easy C interop without control of stack/heap/allocation, and since trait objects could end up nested arbitrarily far, I think you might still get GC- like pauses where a simple-looking code line ended up doing an arbitrary amount of unwrapping and freeing work.

<comment><USER14> I guess it depends on your definition of systems development. If you mean "writing systemsy applications" like IoT things or whatever, sure, fine, a GC isn't going to be an issue and probably will help.

If you're talking about a language to write drivers or an operating system, etc in then a GC is just a big No. In that domain we don't even have Malloc/Free, let alone GC services. Having the overhead and normative lifestyle assumptions of _any_ kind of runtime is a big Nope.

<comment><USER15> Counterpoint: The Oberon System successfully implemented a garbage-collected OS kernel: [https://en.wikipedia.org/wiki/Oberon_(operating_system)](https://en.wikipedia.org/wiki/Oberon_\(operating_system\)).

</comment></comment></comment></comment></comment><comment><USER16> I'm really conflicted about

 _> Aliasable XOR mutable_

because it prevents _eventual_ synchronisation (e.g. single writer, multiple readers of a "monotonic" data structure like a counter)... I'm not convinced that it's entirely necessary, nor how easily it can be proved safe, but AFAIK many garbage collection runtimes work using eventual synchronisation... Probably other algorithms as well!

Another thing that's not (AFAIK) covered by Rust's ownership system is flexible memory pools... where you can have _proofs_ that some memory is accessible and pass those proofs around (whether at runtime, or just during compilation on the type system level)... although that might be entirely isomorphic to just passing around owned pointers to memory (pools), so maybe Rust _does_ support it.

People with lots of experience with Rust, what scenarios do you need to use unsafe Rust for?

<comment><USER17> Interior mutability via atomic values ([https://doc.rust- lang.org/std/sync/atomic/index.html](https://doc.rust- lang.org/std/sync/atomic/index.html)) works great for the first one, and, indeed, some sort of atomicity/synchronisation is required even in languages without the XOR rule (such as C++) to prevent undefined behaviour.

There's a variety of safe arena types that give allocation inside pools too: [https://crates.io/search?q=Arena&sort=downloads](https://crates.io/search?q=Arena&sort=downloads)

<comment><USER16> Atomics are very useful indeed, but an overkill for some situations. In particular, if there's just one writer and multiple readers, the write doesn't need to be synchronised (as there's no possibility of someone else mutating the value in the middle of you incrementing it). An example would be the GC thread incrementing the _epoch_ id/count that all mutator (user) threads read.

Presumably you'd still need _some_ sort of synchronisation otherwise the memory will stay mutated just in one CPU's cache, you need to "flush" the updated memory so that other CPUs can then see it, but that's likely cheaper than executing _the whole_ operation atomically... Basically, increments are fundamentally not atomic (i.e. composed of multiple separate operations) whereas reads (of a single word) are, so if all mutations happen from a single thread (assuming a sensible CPU architecture and cooperative compiler) there's nothing else that needs to be done to ensure atomicity, you only need to care about the "happens before" relationship.

But then I'm not a low-level programmer so the above is probably all wrong :)

<comment><USER17> They have to go via the atomic types or it is undefined behaviour. One can use a very weak ordering (such as Relaxed) to require little or no "physical" synchronisation by the CPU. Like C++, Rust atomics offer a range of levels of synchronisation, weaker than sequential consistency.

A platform like the JVM disguises this because every read and write (even without 'volatile') use minimal synchronisation to avoid the worst aspects of the danger here. This ensures that programs that do it wrong (e.g. forget a 'volatile') are "only" incorrect, but not unsafe.

<comment><USER16> Ah, you're right, weaker ordering takes care of a lot of these issues! Good point, thanks!

</comment></comment></comment></comment></comment><comment><USER18> > Resource acquisition is initialization

I recently built a small prototype Entity Component System, and one of the big learnings for me was to what extent RAII is an anti-pattern with respect to performance. It's actually amazing how fast a modern CPU can be when you're not using it to allocate and initialize small blocks of memory at a time.

I understand the benefits of RAII in terms of bookkeeping, but it seems like there is opportunity for a new resource management paradigm which is more optimized for using computing resources.

<comment><USER19> Can't you just initialize everything at once before you need it rather than initializing one object here and there?

<comment><USER18> It depends heavily on the problem domain. In some cases this is possible, but it's often the case that you will not know what resources you will need at the beginning of execution.

Also the implementation of "initialize everything at once" in an RIAA paradigm is not necessarily going to be the most efficient possible implementation. For instance, I might want to do something like this (in a made-up language):

        struct A { ... }

        func init() {
            let a1 = new A();
            let a2 = new A();
            let a3 = new A();
        }

The most efficient way to implement this would be to allocate enough memory to store a1, a2, and a3 and then run the initialization method 3 times over that memory. But it's likely that instead the compiler will allocate a1, initialize a1 and so on with a2 and a3. Since the allocations are separate, maybe another thread takes precedence between the allocation of a2 and a3 and allocates some memory, so these values are not contiguous in memory, and I get worse caching performance when accessing them.

In this toy example with 3 values it doesn't make aa lot of difference, but if you add up all these marginal costs in a large application it absolutely does cost a lot of performance.

<comment><USER10> > The most efficient way to implement this would be to allocate enough memory > to store a1, a2, and a3 and then run the initialization method 3 times over > that memory.

Only if a1, a2, a3 are also _freed_ at once. In which case, you can just put all three in a struct that is allocated as a single block. Rust doesn't yet support this very well _in the general case_ , because its support for what C++ calls "placement new" and customized allocation in general is not complete or stabilized. But doing this in a more hackish special-cased way is already possible in many cases.

<comment><USER18> > Only if a1, a2, a3 are also freed at once.

Yes exactly. This is meant to be illustrative of the case suggested in the parent comment, where all required runtime objects are known and can be initialized together at the beginning of execution.

edit: it may be possible to program around some of the worst performance pitfalls of RAII in many cases, but you will end up with very non-idiomatic code, which I would take as evidence that RAII is not ideal for memory performance.

</comment></comment></comment></comment></comment><comment><USER20> The lack of ADTs in mainstream languages is really quite baffling, given their obvious utility.

Thankfully it looks like they're trickling in via Typescript/Swift/Kotlin.

<comment><USER21> Do TS and Kotlin support them now? Last I checked TS was relying on string comparisons and Kotlin wasn't even bothering outside sealed classes

<comment><USER22> TS is a bit more powerful than it appears here, because string literal values are recognized at the type level, so can be checked by the compiler when distinguishing cases. See for example: "Discriminated Unions" at [https://www.typescriptlang.org/docs/handbook/advanced- types....](https://www.typescriptlang.org/docs/handbook/advanced- types.html#discriminated-unions).

</comment></comment></comment><comment><USER23> See, everyone has a different thing they find important about Rust. He suggest abandoning zero cost abstractions (letting stack/inline allocation be decided by the compiler instead) which I think would remove most of the power of the language. Default thread safe primitives sounds really wasteful too.

I think languages similar to Rust but with less complexity will be a very cool space to watch going forward. All sorts of interesting language designs possible.

I'm working on a language that does "Rust-like" things, but unlike the article, what I am going for is the efficient memory management, in this case the inline structs (zero cost abstraction) and compile time memory management (automatic lifetime analysis). The biggest difference with Rust is that it is fully automatic: when ownership can't be determined at compile time, by defaults it falls back to a reference count increase at runtime (in Rust this would just be an error). The advantage is zero annotations, and a language that can be used mostly by people that don't even understand ownership. There may be ways to explicitly (optionally) enforce ownership in the future, for those who want more control.

Language: [http://strlen.com/lobster/](http://strlen.com/lobster/) Details on memory management: [http://aardappel.github.io/lobster/memory_management.html](http://aardappel.github.io/lobster/memory_management.html)

</comment><comment><USER24> > As I said once, pure functional programming is an ingenious trick to show > you can code without mutation, but Rust is an even cleverer trick to show > you can just have mutation.

Yea, I like this.

</comment><comment><USER25> > _In other words, the core, commonly identified "hard part" of Rust - > ownership and borrowing - is essentially applicable for any attempt to make > checking the correctness of an imperative program tractable. So trying to > get rid of it would be missing the real insight of Rust, and not building on > the foundations Rust has laid out._

Sure, but people wanting a smaller Rust might not care about the "real insight of Rust", but of the surface syntax, speed, apis, tooling (e.g. cargo), and so on...

I'd like a Rust like language that's GCed for example, and drops all the lifetime annotations and so on...

<comment><USER26> I guess it depends what you think is the real core of Rust - for me, Rust's primary innovation and primary differentiation point is giving you safe memory management without a garbage collector. Anything that steps away from it (so stepping away from the borrow checker, lifetimes and so on) becomes something that isn't Rust anymore.

After all, just about everything else in Rust is in Haskell.

<comment><USER27> The borrow checker is undoubtedly the core innovation of Rust, but it's not what people new to the language want. When I first came to rust, I was looking for a c++ alternative that had similar syntax and low level power, but also a sane standard library and modern language features like closures.

When I first learned about the borrowchecker I thought it was brilliant. Then I spent some time fighting it and I hated it. Then I learned to love it...until I got backed in to a corner and had to re-architect a project I'd been working on for months. Now I have mixed feelings about it.

So I agree Rust isn't Rust without the borrowchecker, but I empathize with all the noobs who want a rust without it because many people just want a language with some traction that fixes c++ past mistakes, and they end up getting a massive paradigm shift thrown at them instead.

<comment><USER18> It's surprising to me that a language hasn't emerged which is more purely a modernization of C. It seems like you could go a long way just keeping C's basic abstraction in place, reworking some of the clunky bits and adding some basic quality-of-life improvements from the past 30 years of language design.</comment></comment></comment></comment>


Ask HN: Designing your own PhD? - <AUTHOR> Hey HN
I'm just wrapping up a double masters in neuroscience and machine learning, and I was wondering if it was possibly to basically do the equivalent work of a phd, publish 5-6 papers on your own?
The topic I'm really getting interested in is at the intersection of Wetware Computing (https://en.m.wikipedia.org/wiki/Wetware_computer), Neuromorphic Computing, and Deep Learning. I've found some programs like the iPhd at University of Washington, but I can't find too many professors who would be willing to allow me to work on these topics on my own.
Would it be feasible to work on my own for a few years, assuming finances weren't an issue, and publish a few noteworthy papers and open source work? Would that basically be the equivalent of what a PhD is supposed to signal? <comment><USER2> I'm a professor in pure mathematics (at a university with a Ph.D. program), in the United States. I'm a little bit biased, since I went through the system, but that said --

> Would that basically be the equivalent of what a PhD is supposed to signal?

Signal to whom? Probably not, in my estimation, but maybe -- it depends on what you're attempting to accomplish.

Enrolling in a formal, traditional Ph.D. program has lots of benefits; getting to work under a mentor is only one of them. Perhaps the most significant is that you become part of a network of peers: you surround yourself with people whom you can bounce ideas off of. Also, there will generally be lots of visitors passing through, with lectures and opportunities to go out to dinner with the speakers afterwards -- also invaluable learning perspectives.

Unfortunately interdiscplinarity is a difficult thing: most faculty only know their own discipline. (University _administrators_ love interdisciplinary research, but impressing them is irrelevant before you have a tenure-track position.)

> and publish a few noteworthy papers

Noteworthy to _whom_?

It sounds like you want to pioneer a new research area that nobody works on. Would you be satisfied to do work that, in some abstract sense, is worthy of taking note of? Or is it important to you that other people actually notice? If the latter, then you almost certainly want the backing of an advisor and of an institution.

In general, professors tend to appreciate students who take the initiative and seek out their own research projects. Depending on your long-term goals, I would recommend seeking out professors who work in one of the topics you mentioned, and depending on their response, consider enrolling in their Ph.D. programs.

Best of luck!

</comment><comment><USER3> CS Ph.D. here. Yes, it's possible, but I would strongly recommend against it. The main reason is that you are almost certainly not as smart as you think you are, and so trying to advance the state of the art in human knowledge (which is what a Ph.D. is supposed to be all about) on your own is very likely to fail. This would be true even in a perfect world, and the world we actually live in is far from perfect. The process of publishing is fraught with politics, and being affiliated with an institution is a not-insigificant advantage in and of itself, completely apart from the benefits of actually being on the inside and having access to people to whom you might not otherwise have access to. Trying to do a Ph.D. equivalent on your own is like trying to climb Everest on your own with a 50-lb dead weight attached to your ankles. It might be possible, but the odds are very much against you.

</comment><comment><USER4> I would advise you to search around a bit more thoroughly for universities who are doing such work.

I don't know much about CS PhD programs, but in biomed, solo publications are very rare, just due to the amount of resources needed. Also, you lose the credibility of an institution, and your work will be more heavily scrutinized, or just thrown out for being too much work to review.

As to whether it would be the "equivalent" or a PhD, it won't get through a resume parser, and won't get you a teaching position or even a postdoctorate position, but companies probably won't care.

<comment><AUTHOR> Thanks for the advice, I appreciate it's clarity. I guess I'd be better served through a PhD program anyway, for the doors opened when it comes to publishing etc

</comment></comment><comment><USER5> PhD by publication is usually an (unofficial, unadvertised) option in many UK/Australian universities. If you published four or five good papers, that would more than fulfil the requirements for the degree (if the university technically requires you to write a thesis, at that point you just bind your four papers together and call it a thesis).

At least in Australia, you need to begin a PhD before, or at least very close to, when you start working on this stuff. So if you go this route, make sure you talk to an interested professor+university _before_ you go off for a few years and work on stuff. The reason being is that universities get a large award from the government when students complete a PhD, and so all of the work you publish has to be "part of" your degree - you can't bring a large amount of work along from elsewhere.

</comment><comment><USER6> I understand the situation might be different in the US, but in the UK and in other countries a PhD with a hands-off supervisor can be as lonely as your heart desires.

<comment><AUTHOR> I'm actually looking into UK PhD programs, especially since I already am recieving a joint masters in CS and Biology

</comment></comment><comment><USER7> I think you need to tell yourself if you need to get PhD degree, or like to have that capability people can do as PhD. Just do it if you just need that capability, and I bet you can learning more that you expected.

</comment><comment><USER8> PhD student here doing neuromorphic computing and running deep learning models on analog hardware. The 'neuromorphic computing" is a vaguely defined term, which can mean anything from developing novel Spiking NN models to the design of hardware capable to run those models (e.g. TrueNorth). Wetware computing is probably even lesser understood area. Neither has much to do with deep learning field, which does not use spiking NN computation.

On the other hand, there are very promising research directions precisely in the intersection of neuroscience and deep learning (e.g. biologically plausible credit assignment problem, learning algorithms of the brain, objective functions in the brain, sensori-motoric integration, etc). It's rare to find a person with solid understanding of both fields, especially in academia.

If I were you I would look at residency programs at big companies (Google Brain, Facebook AI fellowship, etc). Also, there's a company called Numenta which is probably looking for people with your skills (they are trying to reverse engineer neocortex' algorithms). From what I heard, those places give you some freedom to choose your own problems, encourage publishing papers, and provide very bright people as mentors.

</comment><comment><USER9> There would be several professors interested in students like you. You have to mail them and talk about your topic and idea. There are many who would accept an enthusiastic Ph.D.

</comment><comment><USER10> PhD by Publication is an option here in the UK. Check this link from Warwick University to see if you're eligible and if this is something you'd be interested in: [https://warwick.ac.uk/study/postgraduate/research/phdbypubli...](https://warwick.ac.uk/study/postgraduate/research/phdbypublishedwork/)

<comment><USER11> Interesting! Does this mean that you can focus on publishing a few papers and make a proposal highlighting all your contributions and papers, then apply to get a PhD title.

<comment><USER12> Nope, you still formally sign up like a standard PhD student but will organize your thesis as a series of published and peer-reviewed papers, instead of the standard format, at the normal end of your PhD program. There is neither an accelerated path nor a diy option because the PhD is strictly meant as training time in the UK, much more like an apprenticeship than autonomous contribution.</comment></comment></comment>


Lovecraft—Crowdsourced, pattern-based code improvement - <AUTHOR> http://alimony.github.com/ideas/lovecraft.html

<comment><USER2> This looks awesome - as long as all (or at least most) of the suggestions it makes are actually improvements in some meaningful way. Perhaps including a performance analysis and automated functionality test to assess the suggested change's effects?</comment>


Labrador: A web-based, database agnostic client for Rails development databases - <AUTHOR> http://chrismccord.github.com/labrador/

<comment><USER2> The install code toggles are a really nice UI feature.

<comment><AUTHOR> Thanks. Given the different platform setups and the fact that this is just a Rails app, I couldn't think of a better way to maintain the simple copy/paste setup without resorting to | sh or a separate install script.

</comment></comment><comment><USER3> This looks very nice. I'm a Linux (Fedora) user and the options for GUI database tools are very limited. I'm also a Rails developer, so I'll be interested in pitching in if I can. One question, since pow isn't an option for me, how do I connect labrador to my databases?

P.S. I love the name.

<comment><USER3> Ok I think I answered that question by doing this:

        cd ~/apps/.labrador
        rails s -p 3002
        firefox localhost:3002/~/apps/myapp

now I get:

        No such file or directory - /tmp/mysql.sock

<comment><AUTHOR> You guessed right. This is how you run the app without pow. Next on my todo list is adding url path option to the readme for non OSX users, and maybe recommending something like `alias labrador-start='cd ~/.labrador && bundle exec rails s -p 5200`. I've successfully had things up and running on Ubuntu with mysql. Do you have the socket: defined in your database.yml?

</comment></comment></comment><comment><USER4> Pumped about this. Going to take a look when I am done with the nine-to-five. Good work!

</comment><comment><USER5> This is awesome!

Can we hope for Redis support in the future?

<comment><AUTHOR> Thanks! Redis support and manual connections are the next features I would like to get in place.</comment></comment>


Show HN: The Most Influential Works on TvTropes According to PageRank - <AUTHOR> http://www.joshuasnider.com/QuisCustodiet/ <comment><USER2> This is pretty cool. I suppose I'd like to see a breakdown of the influences some of the more popular sources had on other things, or maybe to know who are the most prolific borrowers of references and themes (influencees? Chrome tells me that's not a word). Nevertheless, it's interesting to think about cultural references within a very closed environment like TV shows and movies as a network, with all the reasoning affordances as such.

As an aside, TV Tropes doesn't use HTTPS as far as I know (and according to this too [0]), so none of the show/movie links resolve unless you go in and remove the prefix and let the browser figure it out. Looking at your source, it seems you could just change the "[https://"](https://") to "[http://"](http://") or even "//" (although this would break when(/if) you start using HTTPS down the road).

[0]: [http://tvtropes.org/pmwiki/posts.php?discussion=13461707110A...](http://tvtropes.org/pmwiki/posts.php?discussion=13461707110A77275900)

<comment><AUTHOR> A giant graph could be in the cards for future work, schedule permitting.

As for https, I'm currently hosting this with GitHub, but using my own domain so my browser kept complaining (correctly) that the page was using a SSL certificate from another domain. Eventually, I'll move to hosting this on my own somewhere, probably when I get the urge to run some server side code. Then I'll most likely make https the default.

</comment></comment><comment><USER3> The list tracks well with the relative number of instances of cosplay or t-shirts worn SDCC. (With gaps since "Marvel" isn't going to show up that way on the site)

So I'm thinking the math is solid.

<comment><AUTHOR> Yeah, I was worried when I was doing this that, say Batman, would be underrepresented due to all the references pointing to specific movies or comic books, but that worry seems to be misplaced. Maybe later work will group entries into categories, but I'd only do it if it could be done programmatically.

</comment></comment><comment><USER4> This is awesome work! Is there anywhere we can get the generated graph data? Whether in the form of adjacency list or matrix. I want to do some analysis on this graph too :-)

<comment><AUTHOR> I have it as a SQLite database on my machine. The full database is too big to upload to GitHub, but I'll see if the table with the edges can be made into a small enough JSON file to be uploaded.

<comment><AUTHOR> Check out [https://raw.githubusercontent.com/jsnider3/QuisCustodiet/mas...](https://raw.githubusercontent.com/jsnider3/QuisCustodiet/master/edges.js).

<comment><USER4> I have tried some graph analysis using my own graph analytics framework: Gunrock ([http://gunrock.github.io/gunrock/](http://gunrock.github.io/gunrock/)). The PageRank is pretty similar (the first three are DoctorWho, StarWars, and EVA.) My colleague and I are interested in doing more analysis on this site. We are trying to build a crawler and maybe using bipartite graph to build some kind of recommendation system. All inspired by your project here. Stay tuned :-)

<comment><AUTHOR> Thanks, this is exactly the kind of thing I hope to happen when I post on HN. I have the crawler I used at [https://github.com/jsnider3/QuisCustodiet/blob/master/crawle...](https://github.com/jsnider3/QuisCustodiet/blob/master/crawler.py), but it needs some post-processing at the end to filter out links that redirect and pages that aren't works of pop culture.

<comment><USER4> This is great. It helps a lot!</comment></comment></comment></comment></comment></comment>


Too clever to be good at spelling  - <AUTHOR> http://www.timesonline.co.uk/tol/life_and_style/education/article4602591.ece

<comment><USER2> <http://www.thefreedictionary.com/intercede>

Might have something to do with all the "misspellings."</comment>


Fractal Lab - Interactive WebGL fractal explorer - <AUTHOR> http://fractal.io/

<comment><USER2> I think I'm going to get the shader source for one of the more pretty fractals and max out the details and then run it on that ec2 server instance with the very powerful gpu. New wallpaper.

</comment><comment><USER3> This is an obscenity. I remember leaving my 486/33 running for an hour or two to render something at 800x600x256color, and now I'm flying through Mandelbulbs on a web browser, fiddling with them in real time. Excuse me, futureshock moment here.

</comment><comment><USER4> This looks insanely cool, but it won't render for me. I'm running the newest version of Chrome on Snow Leopard which is supposed to support WebGL, other examples work fine, but I'm just getting a checkered background.

<comment><USER3> I hate to ask, but did you actually click "Render"? Just clearing away the text that is in the middle when you first load it has exactly that result if you don't click "Render", which is why I ask. It was also non-obvious to me that when I changed fractal types, I had to click "Recompile"; everything else updated live, so I expected that to as well.

</comment></comment><comment><USER5> Doesn't work for me at all. Win 7, Chrome 9</comment>


Apache Flink 1.10 Announced: Kubernetes, Hive Integration, Full TPC-DS, PyFlink - <AUTHOR> https://flink.apache.org/news/2020/02/11/release-1.10.0.html <comment><AUTHOR> Overview of the most notable new features (in my opinion):

\- Improved Memory Management and Configuration

\- Reworked job submission (allowing things like Zeppelin or other interactive notebooks)

\- Native Kubernetes integration (there's now multiple ways to submit Flink to K8s)

\- Hive integration: Use your Hive tables, UDFs etc. in Flink SQL

\- Full TPC-DS coverage for batch: this basically means Flink supports a lot of SQL syntax

\- PyFlink supports user defined functions (based on Apache Beam's portability framework). This makes Flink's Python support really strong

... there are many more features in the announcement (1200 tickets were resolved)</comment>


U.S. has withdrawn its request to identify a Trump critic - <AUTHOR> https://www.washingtonpost.com/news/the-switch/wp/2017/04/07/the-u-s-government-has-withdrawn-its-request-ordering-twitter-to-identify-a-trump-critic/ <comment><USER2> >The government, in order to enforce its subpoena, would have had to demonstrate that whoever is behind the Twitter account was likely violating some law. There also were serious questions about whether the type of subpoena used, which is typically for investigating violations of export rules, was appropriate for the type of case DHS was probing, experts said.

Based on how fast the government dropped their request, it seems very clear that this was nothing more than an attempt at stifling dissent. How disturbing.

<comment><USER3> One of the more interesting lines of thought on Ars was that the request was so badly implemented (without a judge's signature; could have a been a National Security Letter instead; other similar reasons), that it was almost as if the person implementing it was doing it because he was pressured to by higher-ups, not because of true desire to see the request succeed.

Either way, I'm glad to see the negative attention the request received and even more glad to see the request withdrawn.

<comment><USER4> Or from a more paranoid standpoint, they got exactly the public response they wanted.

Dissenters, or at least supposed dissenting federal employees now know they're considered suspect. This attempt died, but in light of this do you, anonymous federal employee considering speaking out against the direction of your department, want to risk being next?

<comment><USER5> > This attempt died, but in light of this do you, anonymous federal employee > considering speaking out against the direction of your department, want to > risk being next?

yes, actually. this is encouraging exactly that. the government withdrawing its request in less than 24 hours because it didn't have a leg to stand on means that even in Trumpistan the constitution still means something. that said, encryption and anonymity seem more important now than ever.

</comment></comment></comment></comment><comment><USER6> Any government employees who played a part in this outrageous attempted abuse of power should be removed from their position(s) of authority.

<comment><USER7> I don't know enough about this case to comment on the specifics.

As a general rule, I am not in favor of terminating someone's employment because they made a bad call. You can't expect people to take risks & try bold things when their failure means unemployment. People need to be able to learn from their mistakes.

<comment><USER8> > You can't expect people to take risks & try bold things

This is a branch of the government and law enforcements, whose responsibilities, powers and limitations are codified in writing. This is not a scrappy little startup - there are edicts in place about how to do things, not to "be bold" when you have such power behind you.

<comment><USER7> Being bold can include doing what you think is right, knowing that taking a stand will be extremely hard.

Say an Islamaphobic Congress passes a law that bans wearing turbans, and that becomes extremely popular. A bold for someone in the executive branch could be actively defying that law, challenging it in the court system. Someone has to fight the good fight, and I hope government has people like this.

<comment><USER9> Right,but it cuts both ways. If you can't fire people for illegal behavior then the situation could just as easily be the opposite with an isalmaphobic government employee violating the the first amendment or civil rights act.

At the end of the day, it's hard to imagine how governments or for that matter businesses could operate if employees were immune to being fired for their job performance. There would be little motivation for actual work and little penalty for taking outsized risks. Seems hopelessly naive.

Of course this might make fighting the good fight harder sometimes, but that's how it is. If doing the right thing were always easy, everyone would do it.

</comment></comment></comment></comment></comment><comment><USER10> Now, when do we have the discussion how this request should never have been submitted in the first place?

And better training (or retraining) for CBP agents on the proper scope of the law?

</comment><comment><USER11> It backfired tremendously. That Twitter account wasn't very well known, and the controversial government actions helped it become a trending topic in social networks.

That twitter account and others form what they call the "alt gov", and they invite followers to follow other alt gov accounts.

At the end of this exchange, the alt gov people won many followers. The government actually unintentionally helped them with free publicity.

<comment><USER12> Exactly. Maybe a honey pot?

Take the opportunity to list malcontents in case it's needed later? Narrow the search space in case something come up on down the line? Starting at these nodes who knows what kind of interesting trees might unfold?

I image after all they most likely could identify the person if they _really_ wanted to. Twitter's well publicized "stand" aside.

</comment></comment><comment><USER13> So many secret, flippant requests for it companies to give up user data.

</comment><comment><USER14> Can the lawsuit proceed anyway even if the request has been dropped?

<comment><USER15> No, courts are not very interested in wasting their time with a lawsuit where the person suing isn't actually asking for anything if they win.

<comment><USER16> IANAL, but this sounds incomplete. Declaratory judgements are a thing. Presumably that doesn't apply in this case for various reasons.

<comment><USER17> Declaratory judgement are only for cases where the mere possibility of an adverse decision is materially impacting you. For example investors being nervous. Its not intended to be a way to make a point.

</comment></comment></comment></comment><comment><USER18> _" request to identify a Trump critic"_

That was seriously what the subpoena was made about, a "critic"? No wonder moderates feel totally detached from this kind of alt-left (or in other cases alt-right) echo chambers.

Journalism these days...

<comment><USER19> In what way is that description inaccurate?

<comment><USER18> The request was to identify a "government official impersonator" not a "critic".

Either that was really the real motive of the officials that made the subpoena or not (my guess is actually not btw), is certainly not up to the lousy journalist that wrote that title to decide.

<comment><USER20> > is certainly not up to the lousy journalist that wrote that title to decide.

Journalists are allowed to interpret. In fact, that's a core part of journalism.

<comment><USER18> I think you are mistaking journalism with creative writing.

The core part of journalism is to present facts and let the interpretation up to the reader.

<comment><USER21> So, like a phone book?

Journalism should be about illuminating a topic, including providing context.

I have my gripes with journalism that misuses facts and statistics to spin an alternate reality, but I don't think this was the case.

The twitter account never pretended to be a US official, it's always been clear that they are an "alt" account.

So for you to claim (someone who, if I'm not mistaken, has zero first hand knowledge about the situation) that your interpretation is more accurate than a "lousy" journalist who actually researched the issue is to my mind a little weird.

BTW, I'm sure you're aware that editors write headlines, not journalists right?

<comment><USER18> _" So, like a phone book?"_

No, like a scientific paper. Have you ever tried to read one and understand this alien concept on how you can actually present facts without giving leeway to your personal politic views and fantasies?

<comment><USER20> Scientific papers are opinionated. Look at the one for PageRank:

[http://infolab.stanford.edu/~backrub/google.html](http://infolab.stanford.edu/~backrub/google.html)</comment></comment></comment></comment></comment></comment></comment></comment>


Image hoster pushes 1.8 PB per month through Cloudflare CDN - <AUTHOR> http://postimage.org <comment><USER2> Yeah unlimited does have it's limita....OMG you're funneling 1.8 petabytes?!?!! That's like 1,800,000 gigabytes or 1,800 terabytes every month. EVERY MONTH. Unlimited does not mean you can serve the bandwidth of a small country through 1 ISP.

 _" Please contact us if you have a CDN that is capable and willing of serving 1.8 Petabytes of outgoing traffic per month free of charge," -PostImage_

Is the company run by spoiled entitled millennials? It takes a lot of equipment and staff to create a network that can serve that and they just want it all for under $1k? You know data centers have costs too. Other startups spend years of their lives putting together a team that can assemble infrastructure to handle that and they want it for free? For their barely- cash-flow-positive project that doesn't earn them a decent living...

I can't believe they just asked that. Sorry but PostImage sounds like the biggest moocher in the web right now. If your ISP provider says "unlimited data" does that mean you can funnel the traffic of Russia through your internet connection? You want for "free" what others are paying thousands and thousands of dollars for?

What is wrong with you? Seriously? It's like you're trying to run a top-tier web company on pocket change.

<comment><USER3> I agree, but to be fair, I think "unlimited anything" is almost always misleading, Why not advertise with a generous free tier with clear limits?

<comment><USER4> Services offer this because if you don't have any users, it's easier than building in and enforcing limits. If your service gets traction then it makes sense to spend the time and money on development, not before. I personally wasted a lot of time on building limits for a service that has yet to gain traction.

</comment></comment></comment><comment><USER5> Equivalent pricing:

Amazon Cloudfront: $59770 per month

Google Cloud CDN: $50000 per month

Fastly: $144200 per month

etc etc. If they can't get together $12000 per month for Cloudflare, they sure as hell don't have a viable business model.

<comment><USER6> Or like $1000-$1500 per month for a dedicated server with 10G unlimited bandwidth. This is as low as it gets.

<comment><USER5> Could you run the service off a few OVH dedicated boxes with 3Gbps? Sure, you could, but it's going to be painful, and at that point imgur is the better choice anyways.

<comment><USER6> No, it's not painful at all. I think multiple boxes on different ISPs is the way they should go, but it's going to be more expensive, than a single cheapest 10G box.

</comment></comment></comment></comment><comment><USER7> The solution is really simple, don't host images through a CDN. Though it might not be as fast, it will be way cheaper.

I'm really suprised they didn't look at all the stories of people before trying to start image or video hosts on Cloudflare and getting booted, as if all the other image hosts were too stupid to use Cloudflare for $200/month instead of paying CDNs tens of thousands a month.

<comment><USER8> Of course we were puzzled by CloudFlare's pricing structure. However, all of their advertising material kept reiterating that they were making money off low-tier customers by collecting lots of data required to properly serve their business and enterprise customers. So our sense of alarm and disbelief was somewhat suspended until CF contacted us about our bandwidth consumption, but even then we didn't realize how much trouble we were facing, as they first told us that a $1k subscription would do the trick.

Watching competing projects also added some degree of assurance. Without giving out any specific names, we are aware of a number of competing projects that even now keep heavily relying on CloudFlare (although I am obviously unaware of how much they pay), so we didn't consider it an abusive behavior. In contrast, we were also aware of at least one competitor that kept pushing a considerable portion of their uploads to imgur and basically parasitizing on them for a long time until imgur's abuse team finally took notice and brought down the hammer.

<comment><USER9> _However, all of their advertising material kept reiterating that they were making money off low-tier customers by collecting lots of data required to properly serve their business and enterprise customers._

This makes it sound like we are doing some monetization of low-tier customer data. We are not doing that with any data (low-tier or anything else). That would be hella creepy.

We do track abuse (DDoS attacks, etc.) whoever they hit and use that information to protect other customers. So, in that sense low-tier customers help our overall business, but it's a common lie from our competitors that we are somehow monetizing traffic. Cloudflare's business is pretty simple: work out how to operate our services as cheaply as possible, charge web site/application owners more than that amount.

<comment><USER8> Apologies, that was a poor choice of wording on my part. While I do entertain the theoretical possibility that CF silently uses low-tier customer data in interesting ways (such as data mining and tracking user behavior), my actual expectations of the way CF actually uses this data exactly matches your description (DDoS mitigation & things like that).

</comment></comment></comment></comment><comment><USER10> Cloudflare claims unlimited bandwidth then says you are using too much bandwidth? Isn't this one of those blatant false advertising claims?

Also it's super unfortunate if they go down breaking so many images hosted so many places.

<comment><USER11> Cloudflare's terms of service specifically deal with this: "Using an account primarily as an online storage space, including the storage or caching of a disproportionate percentage of pictures, movies, audio files, or other non- HTML content, is prohibited."

If they put their website behind Cloudflare, but not their image serving domain, presumably that would be fine. Cloudflare is made for a site that serves up web pages with some content like your logo, a few images, etc. Those images can be cached and it's a small amount of data since something like the YC "Y" image is the same served for everyone on HN. A site like Postimage serves image content that's hard to cache since it's mostly different for each visitor.

Cloudflare is pretty explicit that it's not meant for a site that will be mostly serving up loads of pictures.

<comment><USER12> > Cloudflare is made for a site that serves up web pages with some content > like your logo, a few images, etc.

For an interesting counter-example: 4chan (including its image-CDN subdomain!) is served through CloudFlare. It seems that CloudFlare really _is_ willing to host and distribute multiple petabytes of image content per month, as long as it's for the sake of something else (e.g. pages of threaded conversation) that's not an "online storage space."

Though, I think in 4chan's case it might _also_ help that pages and their image resources both get expired off of the site quite quickly. You can create a page that hotlinks image URLs from 4chan's CDN subdomain, but the correspondent resources at those URLs won't be there five hours later, so there's little point to doing so. Unlike most image-hosts one could name.

</comment></comment></comment><comment><USER13> 1.8PB/month is an average of 5.48Gb/s. Assuming you can make do with peak capacity of ~4x average, you can buy 20Gb/s of transit for ~$2k (these guys for example [https://www.fdcservers.net/ip- transit.php](https://www.fdcservers.net/ip-transit.php)). You can probably get a decent deal from somewhere more well known if you ask for a quote, with that kind of traffic, especially if it get a little publicity.

<comment><USER14> You'd get something, but it won't be a CloudFlare level CDN.

At best, you can get AdvanceHosters. They're Russian based but have 7 CDN pops across the US and Western Europe, they'll let you push 1.2PB for 7500 $/month

You won't get asia/oceana/australia traffic for those prices, and you certainly won't get S. American of S. African traffic for those prices.

</comment></comment><comment><USER15> Building your own CDN is not an option? Something small only to reign in the costs

<comment><USER7> Building your own CDN these days requires you to own a large ip block and ASN, and colo at several locations so the DC will actually bother routing to you, in order to deploy anycast.

Certainly too expensive for a small deployment which is why people buy from CDNs instead of setting up their own.

If it was as easy as just doing dns geolocation (which is awful due to geolocation failing and ISP caching), few people would bother buying from CDNs.

<comment><USER16> You shouldn't be anycasting TCP, only UDP. DNS is sufficient.

<comment><USER7> If anycast TCP didn't work, then cloudflare wouldn't exist. DNS is not sufficient. It takes forever to handle downtime because ISPs don't respect TTL.

<comment><USER6> You are incorrect, I'll try to explain.

Anycast is essentially an SPOF. Well, not only anycast and not anycast per se, but a single AS it is under. It breaks from time to time because of various mistakes, bugs, etc. and brings down every server as a consequence. This occurs roughly every couple of years and takes hours to resolve.

So, with anycast, if you have 10 servers in different places, you get hours of downtime for 100% of users from time to time.

With DNS, on the other hand, if one server goes down, it affects only 1% or so of users of a particular server, that have incorrect TTL in the resolvers they use, others see change in DNS right away and use working server. But, those 1% of users don't all go to that server at the same time, only small percentage of them does and also sees the old record. Leaving us with let's say 10% of that 1% on 1 out of 10 servers, or 0.01% of all users unable to see the new DNS record for an hour or so. If a typical server on some random AS goes down five times a year, you get 0.01% * 5 * 10 or 0.5% of users affected for an hour per year. Now if you use round robin and let users see multiple records nothing is even going to stop working in the browser for them, just going to make them wait longer until they see a set of working records.

To summarize, anycast is 100% of users not able to reach any server for hours every couple of years, while DNS is 0.5% of users experiencing slowness for an hour per year. In other words: anycast alone cannot be reliable enough for a CDN.

<comment><USER7> I never said you can't use dns on top of anycast.

<comment><USER6> You have to understand that anycast comes from ISP/networking people, who are biased towards network level solutions for anything and don't care about hard numbers, no matter how badly anycast looks there.

EDIT: Anyway, resilience, just like security, needs a threat model to avoid wasting resources on things that don't actually work, otherwise it's all just hype.

<comment><USER7> As someone who has looked into deploying a DNS based CDN, I have frequently found ISPs ignoring TTL.

Routers handle bgp updates much faster. Anycast routing is much more superior to geolocation which gives a completely incorrect location as high as 10% of the time. Anycast ips are also the best way to handle DDoS attacks. Attackers can easily shut down ips listed in DNS while people's ISP and browser repeatedly try to access the same dead IP for hours.

If DNS was an acceptable option, I would have gone with that instead of paying a CDN for an anycast solution.

These are all from my personal observations, they are not something I just heard from "ISP/networking people".

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER17> Never heard of them. Does imgur say how much traffic they have per month?

</comment><comment><USER18> Never heard of them before but apparently they have been around since 2004 and they support 450k websites and their only revenue model is advertising. I doubt they had a solid technical and business plan behind this service.</comment>


How Valuable Is Revenue For Startups? - <AUTHOR> http://andrewdumont.me/post/18529660490/value-of-revenue-for-startups

<comment><USER2> It's all about net present value and nothing to do with eyeballs.

A startup with no revenue can only have a spectacular valuation if investors believe the time and risk adjusted future profitability of the company merits that valuation.

The alternative explanations (the investors are relying on the greater fool theory, or are themselves fools), seem pretty unlikely.</comment>


My favorite debugging tool - <AUTHOR> http://us1.campaign-archive1.com/?u=ba9c5a596f88fa86026dd89a2&id=01a7043a5b&e=35d9c2c5b6 <comment><USER2> I love strace, DTrace, Procmon, and all these tools. Nothing gives me more pleasure when I'm called to solve a mistery issue and end up spending time checking syscalls, timing, etc.

That being said, that's the worst debugging experience your company can have because it outlines a bigger problem: your monitoring sucks.

In the scenario presented by this article, better monitoring of the database layer could have allowed the sysadmin to connect the dots much faster and find the root cause. So the DB might be able but spilling the wrong beans? You may need some functional monitoring checking what it's outputting from time to time.

I absolutely love low-level debugging tools but using them on a daily basis doesn't scale. I do use them almost every single day, because other teams failed to properly monitor and understand their systems. That doesn't mean it's the most efficient way to go about this.

<comment><USER3> The nice thing about using low level debugging tools is that they are a quick way to get a sense of the problem before you need to start thinking about it. When you are staring at their output trying to figure out what the problem is, then you may be doing something wrong.

</comment></comment><comment><USER4> strace can slow the target by up to 200x ([http://www.slideshare.net/brendangregg/linux-performance- ana...](http://www.slideshare.net/brendangregg/linux-performance-analysis-and- tools/38)). While you can solve plenty of issues with it, you have to be very careful about its use in production. In many cases, it just can't be used.

perf added a "trace" subcommand in 3.7, for buffered syscall tracing ([http://www.brendangregg.com/perf.html#More](http://www.brendangregg.com/perf.html#More)). This should eventually be like strace, but with MUCH less performance overhead.

sysdig is a newer tool that uses a similar low-overhead interface, and provides an expressive syntax. It's still early days, but sysdig could ultimately replace strace (or perf will via trace).

<comment><USER5> Sure, there are going to be a few performance sensitive workloads that you can't use it on, but for the vast majority of issues I've used it for, it's been far more useful than perf or dtruss (on Mac OS X, I've never used dtruss on Solaris so I don't know if it's in better shape).

The big advantage is that it already knows how to decode most syscalls, decompose flags into symbolic arguments, decode things like stat return values, and so on. dtruss on Mac OS X can decode some syscalls, but doesn't generally know how to decode structures or pull apart flags, so there's some information you just can't see, and some which you have to laboriously manually decode. perf, as you note, decodes even less than dtruss. When I'm trying to debug an issue, the more information I can gather and see at once, the better.

Very few of the occasions I've had to use these tools have been particularly performance sensitive. Your example of the huge difference is because dd is copying fairly small blocks at a time, and thus making a fairly high number of system calls relative to the amount of data being transferred. Usually, I'm just looking for why an operation fails, or why a process is stuck; if it takes a little longer to get to that failure, that's OK, and if the process is stuck then stracing it generally won't affect performance.

sysdig looks pretty interesting, thanks for the reference! It's too bad they can't use the existing perf infrastructure in the kernel, and need to add their own kernel module; that makes it that much more cumbersome to deploy and use.

</comment></comment><comment><USER6> strace, and tcpdump. It's really a toss up between them as to which i have solved more problems with. I was sort of rooting for tcpdump before reading the article.

</comment><comment><USER7> +1 for recommending strace.

In discussion with others about its merits I have had people show some better tool that works perfectly in their test case dev environment on their local machine, possibly with fancy graphics. So then the question is 'why is your site so *%^%% slow then!!!' \- what is it doing!!!

Put strace on there (I think you can do a local wget from the server and hook it to that, so no need for any setup) and sure enough it will tell you what it is doing. Sure the output is verbose, but there are command line switches for that. If that verbose output shows it is looking up some db value 10000 times just to show a web page then you can see that someone hasn't written the code too well. This might not be easy to spot in the code, even if it is the neatest code you ever saw, however, nothing is hidden in strace.

Because disk operations and db read/writes are time expensive they stick out like a sore thumb in the strace log. Normally you need to run strace a few times to see whether caching is working as it should or if these lengthy calls will need some code refactoring.

All considered though, I have only used strace when things have got very desperate. Factors that have contributed to the emergency include developers that do not have any interest whatsoever in performance, lame hosting environments bought by people that have no understanding of the requirements and insufficient 'rush job' testing where there is no testing, just some deadline. strace succeeds where 'the proper way' hasn't been setup yet or just isn't useful.

</comment><comment><USER8> Just wondering how many people will click the "Unsubscribe" link at the bottom...

</comment><comment><USER9> +1 for strace (and tcpdump)

A bit better, in case your API is down, maybe you could have a script that grab a strace (and maybe a gdb backtrace, see [http://poormansprofiler.org/](http://poormansprofiler.org/)) of the usual suspect and join that to the alert.

</comment><comment><USER10> It's a good one. I have a snippet on Gist that collects all the workers for debugging, instead of rushing to capture the PID and then starting strace. Have a look: [https://gist.github.com/VictorBjelkholm/df475e61457dabbf9d47](https://gist.github.com/VictorBjelkholm/df475e61457dabbf9d47)

</comment><comment><USER11> Nice trick for identifying bottlenecks. If you want to leavarage your "debugging" skills, try this wonderful course: [https://www.udacity.com/course/cs259](https://www.udacity.com/course/cs259)

</comment><comment><USER12> +1 for strace, but your problem is lack of monitoring. You should have at least one monitoring script doing a select on a known value which you compare to.

</comment><comment><USER13> > foobared

You're looking for FUBARed, which means "fucked up beyond all recognition". "foobared" has no meaning.

<comment><USER14> While the original phrase was FUBARed, the common use of "foo" and "bar" as placeholder variables has lead to programmers using foobar instead. Of course foo and bar come from FUBAR, just using 3 letters for each.

<comment><USER13> "foo" and "bar" are metasyntactic variables that have nothing whatsoever to do with the meaning of FUBAR. Using "foobar" to mean FUBAR is utter nonsense, and serves only to show that the writer has no idea what FUBAR is and is spelling it phonetically. Which is to say, they're typing the word wrong.

<comment><USER15> "foo" and "bar" of course have _a lot_ to do with the meaning of FUBAR, there's even a RFC(!) about that:

[http://www.ietf.org/rfc/rfc3092.txt](http://www.ietf.org/rfc/rfc3092.txt)

<comment><USER13> > 1 April 2001

This is an april fool's joke (one that significantly postdates the rise of "foo" and "bar").

<comment><USER15> Which still doesn't mean the material isn't well researched. Nobody up to now refuted the historical references. In short, "foo" and "bar" didn't "just fall to Earth" they were written by the people who were surrounded by "FUBAR."

Which again means that it's better if you don't consider them as the innocent "no meaning" variables. They have as much "no meaning" as WTF means "worse than failure."

<comment><USER13> The jargon file, which is what that RFC references, provides no evidence for its claim that "foo" in conjunction with "bar" has generally been traced to FUBAR. It's a plausible-sounding claim, because of pronunciation, but that's by no means definitive. In addition, it freely admits that "foo" predates FUBAR.

The entry on "foobar" (as opposed to "foo") also stresses that "foobar" does not generally reference FUBAR:

> Hackers do _not_ generally use this to mean FUBAR in either the slang or > jargon sense.

And once again, it suggests that "foobar" may have been spread among early engineers partly because of FUBAR, but it provides no evidence for this suggestion aside from its apparent plausibility.

So yeah, ok, it's plausible that the popularity of "foobar" was boosted by the acronym FUBAR. But regardless of the truth of that, the _meaning_ of "foobar" has nothing to do with the meaning of FUBAR. It's a metasyntactic variable, and that's it.

<comment><USER15> If you still believe in non-relatedness then you certainly believe that when somebody names the variable SFU in his source examples, he could have been just thinking of Microsoft"s "Services For Unix"

"[http://en.wikipedia.org/wiki/Windows_Services_for_UNIX](http://en.wikipedia.org/wiki/Windows_Services_for_UNIX)

Or "nothing, just metasyntatic" but absolutely no chance that he have been thinking about

[http://en.wiktionary.org/wiki/STFU](http://en.wiktionary.org/wiki/STFU)

I've already mentioned the another example:

[http://thedailywtf.com/](http://thedailywtf.com/)

Initially it really meant what the internet would first think it meant.

[http://en.wiktionary.org/wiki/WTF](http://en.wiktionary.org/wiki/WTF)

As the site got more popular, it was necessary to make the name less offensive for the uninitiated, so the "worse than failure" tag was invented much later.

[http://thedailywtf.com/Articles/The-Worse-Than-Failure- Progr...](http://thedailywtf.com/Articles/The-Worse-Than-Failure-Programming- Contest.aspx)

Just "metasyntatic." Three nice letters. Don't try to associate with anything rude. We're all polite here.

<comment><USER13> > when somebody names the variable SFU in his source examples

I have never seen SFU used as a variable name, whether in source examples or in production code. And were I to see that, I would never even consider the possibility that it's trying to reference the acronym STFU. Because that doesn't make sense. Googling for "SFU" as slang comes up with a reference suggesting that it could potentially mean "So Fucked Up", which I'll grant uses the same swear word but otherwise has a rather different meaning than STFU. But that does not seem like common usage. And when not explicitly looking for it as slang (after all, source code variable names are typically not slang), it is a lot more likely to refer to many other things, including various universities and Services for UNIX.

As near as I can tell, you're basically just making stuff up at this point.

Also, I don't think you understand what "metasyntactic" means. WTF in TheDailyWTF is not "metasyntactic". Neither is naming a variable "SFU", regardless of what you intended to convey with that name. A metasyntactic variable, by definition, is a placeholder name _without meaning_ that is intended to be substituted with some other context-appropriate thing. "foo" is the most common such variable, "bar" is the second most common. You cannot simultaneously claim something is metasyntactic and also claim that it has meaning.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER16> "My site is DOWN, and it's down hard. Requests are timing out."

A bit OTT on the drama there.

</comment><comment><USER17> gdb is the best

<comment><USER18> The UI is pretty terrible though in my opinion. Registers should always be visible so that you can watch them change without having to type it after every command.

<comment><USER19> Launch GDB with the -tui flag.

[https://sourceware.org/gdb/onlinedocs/gdb/TUI.html](https://sourceware.org/gdb/onlinedocs/gdb/TUI.html)

<comment><USER20> Or C-x a after launching GDB. Followed up by "layout regs" and "layout split" and you have a pretty decent debugger.

</comment></comment></comment></comment><comment><USER21> What? He could have just as easily looked at the database monitoring and figured out that it was down. Unless he doesn't have database monitoring in which case using the worker process itself as a database monitor is an extremely poor substitute. Furthermore, have you ever seen the output from strace? It spits stuff out nonstop. He could have very easily missed the call to the database. Or maybe the call is supposed to take a few seconds and then the fact that it is waiting on that call is telling you absolutely nothing.

This is a very poor reason for learning how to use strace. There are simpler tools for everything he mentioned.

<comment><USER5> Except, you don't necessarily know that it's the database that's the problem. It might be trying to do a DNS query, and that's timing out. Or spinning in a loop trying to read from a socket that has no data available. Or blocking on a filesystem operation on a networked filesystem that has become disconnected. Or any number of other things.

The nice thing about strace is that it pretty quickly tells you exactly what the program in question is doing with the outside world, which many times can provide you the quick clue you need about what's going on.

strace is a pretty simple tool, at its most basic usage it's just "strace <pid>", and the nice thing is that it's pretty universal; it comes in handy many, many times, for solving many different kinds of problems. Have some third party code that seems to exhibit different behavior on different machines, but don't know what is different about its environment that's making it behave differently? strace it and see what files it opens for configuration data. Your program not making any progress, and it doesn't seem to be CPU bound as it's only using a few percent of CPU? strace it and see what system calls its blocking on.

Note that for this kind of use case, where the process is hanging, you generally don't get way more output than you can handle; the fact that it's hanging on this particular call means that that's the call that you will see at the end of the output for several seconds until it times out.

It's certainly not the only tool in your arsenal; there will be other cases where more specific tools are more appropriate. But it's a really useful general purpose tool.

My general purpose debugging arsenal, when I need to debug something that I haven't written, generally consists of tcpdump/wireshark to capture and analyze any network traffic, strace to see how the program is interacting with the world outside of it, turning up logging on any relevant systems to their maximum value and looking through that output, and then finally if all else fails attaching to it with GDB and stepping through the code.

Sure, it's always better to have more specific tools, to have turned on appropriate monitoring, and so on. But you don't always have that luxury. Sometimes more specific tools haven't been written. Sometimes your monitoring may find that your database is up, as it is accepting connections, but its actually hanging when you try to do anything, or it's succeeding for reads but hanging on writes, or the like. Monitoring code is never going to be as thorough as you like, there will always be something that you miss, and so you need general-purpose tools that can be used in any situation to get a handle on what is going on quickly so that you can narrow down on the problem.</comment></comment>


Ask HN: What's the best way to write an API specification in 2017? - <AUTHOR> Swagger, RAML, API Blueprint.. there still seem to be as many options as ever with no clear winner.<p>What have your experiences been like with these tools? <comment><USER2> I have used Swagger a lot and I like it as well other option I like the most it gituhub also let you document things</comment>


Daniel Ellsberg on WikiLeaks (Economist Interview) - <AUTHOR> http://www.economist.com/blogs/democracyinamerica/2010/07/daniel_ellsberg_interview

<comment><USER2> I've got karma to burn, so I'll just point out that Daniel Ellsburg is not, in fact, an authority on the impact or ethics of this Wikileaks dump. Counterintuitive as it may sound, Daniel Ellsburg is not actually qualified to judge whether Wikileaks did the same thing for AfPak that Ellsburg himself did for Vietnam.

The Pentagon Papers showed the war in Southeast Asia to have been an outright lie, and one to which the administration had resigned itself to losing but was feeding troops into in an attempt to extricate itself "gracefully". It exposed overtly illegal activities on a _strategic_ scale, such as the widespread bombing of Cambodia and Laos, which the government had previously disavowed. The Pentagon Papers impacted the standing of the administration on a policy level.

Anybody on Hacker News can compose an argument that suggests that somewhere in the Wikileaks dump is information that would expose:

* strategic decisions to expand the AfPak conflict (say, continuous coordinated airstrikes into Baluchistan)

* strategic acceptance of defeat in AfPak and a decision to make a face-saving retreat at the expense of American lives

* the notion that we occupied Afghanistan for reasons other than the elimination of the Taliban (for instance, to grab resources, or to counter a resurgent Iran)

But so far, _no such information has been turned up_. Instead, we have the meme that "the Wikileaks dump is like the Pentagon Papers in their raw original form". But we don't know that. For that to be true, they would need to paint a clear picture of a shocking distinction between reality and the ongoing narrative of the conflict; we'd have to be secretly at war with Pakistan or Iran, or already resigned to letting the Taliban reclaim the country, or something at that scale.

Furthermore, the Pentagon Papers and the Wikileaks dump aren't ethically equivalent. Ellsburg leaked 4,100 pages of digested intelligence and policy information. Wikileaks dumped 70,000 documents taken directly from field reports. Wikileaks claims to have "minimized harm" (presumably by scrubbing names from reports or withholding documents they believed would have exposed people to harm). Ellsburg didn't have to take responsibility for avoiding that kind of harm; the NVA probably could not have organized death squads to react to his disclosure.

Has this happened already in Afghanistan? Nobody has provided evidence that it has, but it seems pretty clear that it's a real risk. Death squads don't care about due process. All they need is a town, a time, and a rough description.

All this, as usual, is not meant to say that the US Government is on the "right side" of this issue. For one (obvious) thing, none of this information should have been available, to anybody; negligence in DoD information assurance makes them just as culpable for deaths of outed informants.

But I'm still left wondering: if you don't draw the line at a decent (tens of % points) chance at outing (and thus killing) an informant in Afghanistan while you're sitting behind a laptop in a safe western country, where do you draw the line? Is there any line at all?

<comment><AUTHOR> Thanks for your comment. Insightful commentary like this is why I read HackerNews.</comment></comment>


Show HN: A better typing tutor, based upon the OK Plateau Effect - <AUTHOR> http://oktypist.com/ <comment><USER2> Sometimes it skips to the next word before you are finished a word, and it's not clear if you need to press space or keep typing, but pressing space skips to the next word after THAT. Pretty frustrating, actually.

<comment><AUTHOR> That's exactly the point -- you need to try to keep up. This slight frustration is the part that makes you get better ;)

<comment><USER2> But your score includes mistakes that you make! Is a space not a mistake? Is it not a key that you need to press? When it skips to the next word, it's quite non-intuitive to not put a space first.

If you don't press space, you're violating the idea of words. If you press space, the sentence you've constructed in your head is broken. Either way, it slows me down and frustrates me too much to play :)

<comment><AUTHOR> The way it's coded, there are 2 conditions that move it forward: either pressing space, or the timer expiring. Pressing the space thus is not an error, but rather the condition that moves the text forward. Also, as I mentioned below, the timer gets faster as you get more words correct.

The original study used only a timer, and had the same frustration which you speak of here.

</comment></comment></comment></comment><comment><USER3> >> It will force you to type faster than you are able

The text is appearing really slowly for me. Is there something that I'm missing? I have to keep waiting for it to catch up to me.

EDIT: I was using Firefox. In Chrome, it's completely different.

<comment><USER4> It was randomly delayed for me as well (granted I'm using Chromium v20...). That (and the otherwise mentioned skipping to the next word erratically... and the not explaining visually how errors are handled) made it nearly useless to me. I would not be inclined to prefer it over, say Type-racer, except as a curio in the show-HN area.

<comment><AUTHOR> Thanks for pointing out the Chrome vs. FF. I'll take a look.

<comment><USER5> Reporting the same. Chrome and Safari are fine, FF lags significantly.

<comment><AUTHOR> Updated the FF about 30min ago; try again now :)

<comment><USER5> The number at the bottom isn't updating at all (stuck at 0). Edit: refreshing twice brought it back– odd. I have to say though, it's quite a bit of fun. I'm not slow and I can already feel the push, I'm really glad you showed this :)

</comment></comment></comment></comment></comment></comment><comment><USER6> It would be a much better experience if it were immediately obvious that words marked in red must be abandoned.

<comment><AUTHOR> Each non-matching character counts as an error; but you can still recover. Eg, if you type "heloo" instead of "hello", it is only 1 error.

</comment></comment><comment><USER7> I normally get a 50-70 WPM score on typing tests, but got a 6 on this. There was a fair amount of errors but surely 6 isn't the best representation of WPM with adjustment for errors.

<comment><USER8> I also am getting what I believe to be an inaccurate wpm. I am getting 30 but I normally score around 65wpm. It might be because it makes the mistake of counting actual words instead of 5 character chunks.

<comment><AUTHOR> When you get to the end, it explains that it uses net WPM (NOT Gross WPM), which is error-adjusted to create an "effective" WPM.

</comment></comment></comment><comment><USER9> Shared with two friends in chat and said, "prepare to be challenged."

Their responses:

"Two seconds in and I'm pissed."

and

"This is infuriating"

So congratulations? These are both people that do extensive amounts of work on the computer but none of it involves copying quickly.

For me, I'm a bit curious why words per minute matters for people. It seems like the only time typing so quickly matters is when you are copying things down (written or spoken). Don't you think it is only a matter of time before no one will have to copy something down into text format manually ever again?

I have little knowledge about how the brain works when copying information but it seems that when someone is working hard to quickly copy something down they are not analyzing the meaning of the content nearly as well as if they were sitting and listening. It seems like time could be better spent.

I still think this is an interesting site. I would love to improve my typing accuracy.

<comment><AUTHOR> Hahaha :) Re: copying... I'm not sure that there's really a necessary distinction between copying input and simply being able to type fast. In this scenario, yes, you're simply copying input; for that reason I added a 800 ms delay to allow the brain to process the word before the variable timer is enabled, so ultimately what's being tested is your ability to write what is in your brain already.

That said, I do acknowledge that WPM is not necessarily the best gauge of efficiency. I'm a programmer, and I'm not sure exactly how WPM relates to my work (I'd be curious to see a study) since much of what I type is "nonsense" words to begin with, and WPM is largely a function of your ability to habitually reproduce the same character sets (aka, common words in your given language).

</comment></comment><comment><USER10> I find I type slower because the text keeps moving.

<comment><AUTHOR> The text moves forward a little faster than you are able to type; this is the principle of the OK Plateau -- you need to be forced to "try" to type faster. However, it is certainly uncomfortable! But, no pain, no gain.

</comment></comment><comment><USER11> How is it based on the OK Plateau effect? All I'm seeing is an (innacurate) WPM counter, does something else happen after a certain amount of typing?

edit: ok, I was typing too fast to notice that it automatically moves on after some time.

<comment><AUTHOR> Yep, and not only does it automatically move -- it speeds up as it moves. Eg, as you get more words correct, the speed and which it moves forward increases.

<comment><USER2> Quite a neat idea.

</comment></comment></comment><comment><USER12> Sometimes, if you mistype a word or forget a space, it incorrectly matches the word you're typing to the word on screen. Took me a while to figure that out and go back a few words to retype them.

</comment><comment><USER8> I made a prettier, nicer and more configurable one of these a while ago that works in Firefox too for my own use based off of Keyzen. You can set your preferred target speed and it has more accurate wpm, click measure at the bottom to to make it skip over words after time runs out.

Try it at <http://thume.ca/keyzen>

Because of this post I also submitted it to HN, upvote if you like it: <http://news.ycombinator.com/item?id=4829982>

<comment><USER4> It works well and looks nice, but part of typing quickly is seeing the next word in advance so I know what to start typing after the space. Your app doesn't show me those words, so I have to hite space-bar and then wait some time before I know what key to strike next (probably worth mentioning that part of seeing the next word involves consuming the word, rather than individual characters -- so that standard letter-groups are queued up).

Edit: ...and now I can reply. Go figure.

<comment><USER8> There is a setting for that, look in the bottom bar. I had some friends test it out and got the same complaint.

<comment><USER4> Thanks for the quick feedback, and for giving an alternative option. But it doesn't do what I need: show the word _before_ I finish the previous word. I look at the next word as I'm typing the current word (something like: parse word, start typing, load next work, repeat). If I can't see the next word until I've finished the current, my overall speed goes _way_ down.

Please understand that I'm not trying to be difficult, but that this is how I normally type. I'm interested because I haven't found the best typing app yet. But for a typing test to be accurate for me, it has to conform to the way text (or my train of thought) normally works.

</comment></comment></comment></comment><comment><USER13> My instinct is to go back and correct my typos, but it seems like this punishes you for doing that?

If so, I think that not correcting my typos is a habit I would prefer to avoid.

<comment><AUTHOR> Actually, the best way to improve is to just keep going, without correcting -- but to keep typing the rest of the word correctly. Eg, if you know you typed the 2nd character incorrectly, just make sure you get the 3rd right.

</comment></comment><comment><USER14> Totally hated this, which of course means that you're on the right track! (They say that your software should evoke strong feelings).

<comment><AUTHOR> Haha thanks

</comment></comment><comment><USER15> The animations when switching a to a new word are _very_ jarring and distracting. Perhaps a more continuous method (like a tape roll that's constantly moving) would help with the transitions?

<comment><AUTHOR> Animations? No animations... perhaps it's slow javascript?

</comment></comment><comment><USER16> Running slowly for me, I am having to wait for the text.

</comment><comment><USER17> Does this get more than 2-3 words ahead? Perhaps I'm typing faster than I read (which makes no sense), but I'm missing words.

<comment><USER17> And it can be gamed as well. Hold the space bar down from the start. 1,380 net WPM.

<comment><AUTHOR> True. But you're only cheating yourself ;)

</comment></comment></comment><comment><USER18> The Chrome extension apparently adds a user tracking script

</comment><comment><USER19> I feel like I'm in swim practice. Holy hell.

</comment><comment><USER20> Wow!</comment>


Numbers and patterns in nature  - <AUTHOR> http://republicofmath.wordpress.com/2010/12/31/numbers-and-patterns-in-nature/ <comment><USER2> Anyone interested in this topic should also check out "Nature's Numbers" by Ian Stewart (ISBN 9780465072736).</comment>


Show HN: Frock: Clojure-flavoured PHP - <AUTHOR> https://chr15m.github.io/frock-clojure-flavoured-php.html <comment><USER2> It could be a good tool to learn clojure coming from php or vice versa.</comment>


Jupiter might have wrecked the first version of our solar system - <AUTHOR> http://www.washingtonpost.com/news/speaking-of-science/wp/2015/03/23/jupiter-might-have-wrecked-the-first-version-of-our-solar-system/

<comment><USER2> "the new study suggests that certain weird quirks seen in our solar system could be explained by Jupiter coming in like a wrecking ball and smashing its original planetary companions to smithereens."

And _this_ is why we can't have nice things.</comment>