Jitterdämmerung - <AUTHOR> http://blog.metaobject.com/2015/10/jitterdammerung.html <comment><USER2> There is another use case for JIT compilers that has not been considered: speeding up programming language development.

PyPy's meta-tracing JIT-compiler framework [1] allows you to generate reasonably fast tracing JIT compilers for languages essentially by writing an interpreter. Laurie Tratt has written a nice description of this, and the advantages this delivers [2]. This make the development of new programming languages much simpler, because you don't have to invest a lot of time and effort into producing a reasonably fast compiler (whether JIT or AOT) at the beginning of language development. Yes, in many cases you can build AOT compilers that beat JITs produced by meta-tracing an interpreter, but not easily so.

Tratt's team has used this approach for building impressive multi-language tools [3] that allow you to write programs in heterogeneous languages like Python, Prolog and PHP at the same time.

[1] [http://stups.hhu.de/mediawiki/images/f/f5/Tracing_JITs11_tra...](http://stups.hhu.de/mediawiki/images/f/f5/Tracing_JITs11_tracing_the_meta_level.pdf)

[2] [http://tratt.net/laurie/blog/entries/fast_enough_vms_in_fast...](http://tratt.net/laurie/blog/entries/fast_enough_vms_in_fast_enough_time)

[3] [http://soft-dev.org/](http://soft-dev.org/)

<comment><USER3> "Yes, you can build AOT compilers that beat JITs produced by meta-tracing an interpreter" \- not for all the languages. As mentioned below, there is a certain tradeoff associated with JITs - warmup time, memory consumptions etc. But for certain class of problems (say compiling Python) and for certain class of use cases (running at top speed), I dare you to compete with PyPy. The biggest contender so far comes from the Zippy project, which is indeed built on truffle which is a meta JIT, albeit a method based one.

<comment><USER2> An interesting question is: can one build a meta-AOT compiler framework that converts an interpreter into a reasonably good AOT compiler?

If not, why not?

<comment><USER3> Not sure, don't have much experience with that. This is a "classic" futamura projection - you write an interpreter and the "magic" turns it into a compiler. I'm not aware of any consumer-grade compiler like that, but there is a huge swath of research on that.

You can very easily create a dumb one - you just copy-paste interpreter loop essentially (which is what e.g. cython does if not presented with annotations), however the results just aren't very good

<comment><USER2> Research on partial evaluation (PE) was fashionable in the 1990s, but largely fizzled out. I was told that was because they could never really get the results to run fast. I'm trying to understand why. Clearly meta-tracing and PE have a lot of overlap. Truffle is based on some variant of _dynamic_ PE if I understand what they do correctly. Most of the 1990s work in PE was more about static PE I think. The paper [1] touches on some of these issues, but I have not studied it closely yet.

[1] [http://stefan-marr.de/downloads/oopsla15-marr-ducasse- meta-t...](http://stefan-marr.de/downloads/oopsla15-marr-ducasse-meta-tracing- vs-partial-evaluation.pdf)

</comment></comment></comment></comment></comment><comment><USER4> Static typing in Java does not give enough information to optimise because of polymorphism. The JIT can observe runtime behaviour and inline method calls at monomorphic sites.

[http://insightfullogic.com/2014/May/12/fast-and- megamorphic-...](http://insightfullogic.com/2014/May/12/fast-and-megamorphic- what-influences-method-invoca/)

Worth noting also that Azul's Zing ReadyNow technology for AOT (and indeed their no-pause C4 collector) address some of the specific gripes raised here around the JVM...

<comment><USER5> Zing's ReadyNow is useful but really highlights some of the problems with JITs (in some domains). I think that ReadyNow is very interesting because its existence points to some interesting consequences of JITs in performance sensitive domains.

The driving force behind ReadyNow (as I understand it) was that many performance sensitive systems needed to be fast out of the gates on start up. This means that an interpreted->compiled->optimised-compiled transition was not acceptable.

Developers would try to solve this by running dummy data through the system before it was open to real traffic. But this had the unfortunate consequence that the JIT would optimise for dummy data only, including clever inlining at, apparently, monomorphic call sites etc. When real traffic flows into the system the JVM sees that its optimisations are no longer effective/valid. This would trigger a de-compilation/re-compilation of many code sites causing a very noticeable stutter.

Now we have ReadyNow. If you are really committed to Java or the JVM and you don't like these JIT stutters this is your solution. But this is an extra layer of complexity and another thing to be managed and another thing to fail. This is on top of your JVM, jar file soup you may already be struggling with.

I would prefer a good AOT compiler to remove this concern and give me quite good predictable performance. YMMV of course.

Sources

[http://www.azul.com/products/zing/readynow-technology-for- zi...](http://www.azul.com/products/zing/readynow-technology-for-zing/)

[https://groups.google.com/forum/#!searchin/mechanical- sympat...](https://groups.google.com/forum/#!searchin/mechanical- sympathy/ReadyNow/mechanical-sympathy/QT_P5dGXjXw/W9uiT-dSqjMJ)

</comment></comment><comment><USER6> The problem with native code is platform disparity. It's absurd that so many binary variants are required when shipping code to e.g. Android or iPhone.

This _can_ apply to x86, too. Not sure if all your users have TSX-capable CPUs? You're now shipping two binaries. Not sure if your users have AVX? Now you have at least three binaries.

This is the biggest advantage of intermediate languages - your code can at the very least execute everywhere with a single image, and in some cases automatically take advantage of platform features such as AVX.

I think ART takes the correct approach: ship IL and AOT it on the device. Hopefully some day we can get the same type of system for LLVM IR.

<comment><USER7> The idea of using a portable bytecode and AOT it on installation time goes back to the mainframes.

OS/400, now IBM i, is probably the last living mainframe doing it.

<comment><USER8> Also, we ship JIT compilers with the software right now, so why don't just ship AOT compilers instead?

<comment><USER9> Gentoo linux distribution works that way. It has automatic package management system (Portage) similar to apt-get or rpm (and even more similar to ports in *BSD). The source meta-packages (specyfying the compiler flags, patches etc) are maintained by the community.

You configure a system-wide flags specifying your cpu, optimization level, the features you want to enable and disable (many libraries and apps have flags to compile support for some features or not), etc. There were also app-specific flags IIRC.

When you install a package it downloads sources and the meta-package from portage, then it is compiled on your machine with your flags added for your specific processor with only the features you enabled. It was supposed to be much faster than "bloated ubuntu", but I suspect now it was mostly placebo :)

On the other hand installing Open Office on my Celeron 2000 laptop with 256 MB RAM took 10 hours, and if I wanted to enable some feature that turned out to be useful after all - I would need to wait another 10 hours.

I used it for 2 years when I was on university but then it was too much to wait for hours when I needed sth.

<comment><USER10> > It was supposed to be much faster than "bloated ubuntu", but I suspect now > it was mostly placebo

Gentoo predates Ubuntu by several years. I remember reading some "gentoo ricer" threads bike-shedding over ultimately inconsequential optimization flags. But don't underestimate the simple benefit of `-march` and similar. At a time when binary distributions were pushing x86 binaries which ran on i386, compiling for a newer architecture could give a substantial increase in registers available, instructions available, and instruction scheduling quality. In aggregate, this definitely can improve performance.

Since then, I believe Debian moved to an i686 base which narrows the gap.

</comment></comment></comment></comment></comment><comment><USER11> One aspect the author doesn't talk about is emulation: The Wii/GameCube emulator Dolphin uses JIT to translate the console's PPC machine code to x86 machine code.

I'm also not sure if "scripting languages" truly don't need a JIT. The development of LuaJIT for example has been sponsored by various companies, so there seems to be a need for the fast execution of Lua code: [http://luajit.org/sponsors.html](http://luajit.org/sponsors.html)

<comment><USER12> Yes, but to be fair, Lua is one of these few examples where JIT makes a lot of sense because the extreme simplicity of the language, which greatly expands the opportunities for a JIT to generate efficient code with relatively low overhead and JIT compiler complexity.

This approach is great for some things, but it does sacrifice the flexibility and expressiveness of the language. Anything not part of the core language (which is a lot compared to most other programming languages, e.g. anything related to OOP, or more advanced data types than strings, floats and tables) has to be re-invented and/or bolted-on, which IMO makes it unsuitable for most kinds of applications.

This should not be interpreted as critique about Lua the language bu the way, I'm a big fan of Lua for embedded scripting and I generally love tools with a narrow focus (as opposed to kitchen sink technology). I would not choose Lua for anything besides embedded scripting though.

<comment><USER13> What would you choose instead?

<comment><USER12> That all depends on the application, I guess ;-)

Usually I end-up using Python for smaller things that aren't mission-critical or need maximum performance, C++ for almost everything else, and Objective-C for OS X/iOS stuff. Maybe Java for things where both performance, safety and ease-of-development/maintenance matter (the latter would be mostly for other people who would have to work on the same projection who are less skilled in C++, as I'm not at all a fan of the language myself, but I recognize it has some properties that make it a suitable choice for many kinds of applications ;-). I don't have enough experience with any other programming languages that can be deployed easily across Linux and OS X, so I can't comment on those. Rust seems to have some good ideas so I may want to learn more about it in the future.

If I wanted to write something for Windows platforms I'd most likely gravitate towards C#, from what I know about the language it appears to have all the good things of Java without its downsides.

</comment></comment></comment></comment><comment><USER7> Fully agree, JIT makes sense in dynamic languages or real-time conversion of op-codes, for everything else AOT is much better solution.

Having already quite a good experience with memory safe languages when Java came into the world (mostly Wirth and ML derived languages), I never understood why Sun went with the JIT approach. Other than trying to sell Java to run in the browser.

There were already quite a few solutions using bytecodes as portable executable format that were AOT compiled at installation time, e.g. mainframes and research OSes like Native Oberon variants.

The best is to have both on the toolchain. A interpreter/JIT for development and REPL workflows. Leaving the AOT for deployment/release code.

<comment><USER14> > for everything else AOT is much better solution

Not if everything else includes long-running servers that may require various kinds of fiddling at runtime, like injection or turning off and on of monitoring/troubleshooting code, nor if you want to have zero-cost abstractions that are actually high-level abstractions (as opposed to the other kind of zero-cost abstractions, that are basically just weak abstractions that can be offered for free).

<comment><USER7> Once upon a time I did drank too much of JIT Kool-Aid, and for a moment I though it was the future, kind of.

However bearing the scars of the pain of "kinds of fiddling at runtime, like injection or turning off and on of monitoring/troubleshooting code" actually means in practice, changed my mind.

It is so damn hard to tune them, that there are consulting companies that specialize in selling JIT tunning services.

And in the end they offer little performance advantage over using PGO or writing code that makes better use of value types and cache friendlier algorithms.

This was one reason why Microsoft introduced PGO for .NET in .NET 4.5.

So yes, I really mean everything else.

<comment><USER14> I've gone the opposite way, and I really like my long-running server code to be JITted when possible. I only wish my old C++ servers could be tweakable at runtime as my Java servers[1] and I really like being able to use languages (even for DSLs or rule engines) that have a few powerful abstractions, and let the JIT make them run nearly as fast as the infrastructure code.

If you really need careful tuning of optimizations (which is never a walk in the park), it will be made much nicer with this: [http://openjdk.java.net/jeps/165](http://openjdk.java.net/jeps/165)

[1]: Just like Erlang, only fast! ;)

<comment><USER7> It is possible to have powerful abstractions, AOT and performance.

One just has to look at Haskell, OCaml, Common Lisp, Ada, Eiffel, SPARK, Swift, .NET Native,....

The fact that for the last decade mainstream AOT was reduced to C and C++, kind of created the wrong picture that one cannot have performance in any other way.

I always dislike how they present some of the language features (stack allocation, structs and arrays) as if there wasn't any other language with them.

For monitoring, although one doesn't get something as nice as VisualVM or JITWatch, it is possible to bundle a mini-monitoring library if really needed.

Something akin to performance counters in Windows.

<comment><USER14> Ada (/SPARK) is a complex language that makes the developer think of every optimization-related implementation detail as they code (not unlike C++ or Rust), and Haskell/OCaml would benefit if functions that do pattern-matching could be inlined into their call site and all of their branches removed but one or two (the same goes for the other languages on the list).

<comment><USER7> Just to provide some feedback that I should have written on the sibling comment.

I use both Java and .NET since they got out, there is the occasional C++ library, but they are the core of my work. So I know quite well their eco- systems.

Some of the mentioned scars were related with replacing "legacy" C++ systems, while keeping a comparable performance.

</comment></comment></comment></comment></comment></comment></comment><comment><USER15> The article seems to ignore a variety of very real benefits that you get from the JIT. In many real world cases, there are optimizations that the JIT can perform. For example:

        final boolean runF = ...; //In *this* program run, it works out to be false.
        ...
        if (runF) {
          f(x);
        }

The JIT can just eliminate this branch entirely. More interestingly:

        if (cond) {
          myVar = f(x); //f(x) has provably no side effects
        }

Supposing cond is nearly always true, the JIT can optimistically run f and in parallel check cond. In the unlikely event that cond is false, the JIT will still compute the return value of f(x), but just not do the assignment.

It surprised me when I saw all this happen, but the JVM's JIT is actually pretty smart and works very well for long running server processes.

<comment><USER16> In the first case, either the "if" is run in a tight loop, and then the branch predictor will likely predict it correcly, or it isn't, and then branch elimination brings only trivial improvement.

In the second, what do you mean by "run f and in parallel check cond"? How that would translate to the machine code? You want to run and synchronize cond and f(x) between two separate CPU cores or what?

<comment><USER15> And if it's not run in a tight loop, the JIT can often still detect it.

I don't know why you believe such things are trivial. On one occasion I altered some code which broke this, and it added about 10-20 seconds to a 15 minute HFT simulation. If that code made it to prod, those 10-20 seconds would be distributed around the hot parts of an HFT system. That's not remotely trivial, at least for performance critical applications (HFT, RTB, etc).

In the second example, basically what happens (if you get lucky - I haven't found the JVM JIT to be super consistent) is that computation of cond and f(x) will be put into the pipeline together, and only the assignment to myVar will be conditional. This is strictly NOT something the CPU can do by itself, since there are side effects at the machine level (allocating objects, and then GCing them).

</comment></comment></comment><comment><USER17> Why did Java stay with a JIT for so long, anyway? Java is hard-compilable, and GCC can compile Java. The original reason for a JIT was to speed up applets running in the browser. (Anyone remember those?) Server side, there was never much point.

<comment><USER11> Cynical answer: It wouldn't fit the "write once, run anywhere" slogan used to market Java.

<comment><USER18> JIT gives you more information about how the program is actually run. This allows a large number of optimistic optimizations that GCC etc... can not make.

This in theory allows faster code to be generated. Than ahead of time compilers can. In practice this is destroyed by the pointer chasing default datastructure in java.

If you are executing "C" using JVM techniques then a research JVM JITing C code gets within 15% of GCC on a reasonable set of benchmarks. ([http://chrisseaton.com/plas15/safec.pdf](http://chrisseaton.com/plas15/safec.pdf)).

These benchmarks are favorable for the AOT GCC as they have few function pointers, startup configuration switches and little dataflow variety.

I suspect that specific compiler optimizations on the C code for the dense matrix transform in GCC are bigger part of why GCC is faster than the fact that it is AOT instead of JIT.

There are also a number of AOT compilers for Java e.g. excelsior. But I have not seen superior performance with that over an equivalent hotspot release.

<comment><USER19> > JIT gives you more information about how the program is actually run. This > allows a large number of optimistic optimizations that GCC etc... can not > make.

They'd be surprised to learn that considering GCC supports profile-guided optimisation.

<comment><USER14> Modern JITs basically _are_ very sophisticated profile-guided optimizing compilers. Unlike AOT PGOs, though, JITs can adapt to changing program phases, that are common in server applications (e.g. when certain monitoring/troubleshooting/graceful-degradation features are turned on). On the whole, JITs can produce better code.

But this, too, is a tradeoff. Some JITs (like JS's in the browser) require fast compilation, so some optimizations are ruled out. Very sophisticated optimizations require time, and therefore are often useful when you have tiered compilation (i.e. a fast JIT followed by an optimizing JIT), and tiered compilation is yet another complication that makes JITs hard to implement.

<comment><USER20> An AOT compiler can decide to compile a JIT code generator into the binary, so even in theory AOT beats JIT. In practice it almost never makes sense to do this for a language that isn't full of gratuitous dynamism.

<comment><USER14> > An AOT compiler can decide to compile a JIT code generator into the binary, > so even in theory AOT beats JIT

That is not AOT. That is compiling some code AOT and some JIT[1]. It's not a contest. Those are two very common compilation strategies, each with its own pros and cons.

> In practice it almost never makes sense to do this for a language that isn't > full of gratuitous dynamism.

What you call "gratuitous dynamism" others call simple, general abstractions. BTW, even Haskell/ML-style pattern matching qualifies as "dynamism" in this case, as this is something a JIT optimizes just as it does virtual dispatch (the two are duals).

[1]: Also, a _compiler_ doesn't generally insert huge chunks of static code into its output. That's the job of a linker. What you've described is a system comprised of an AOT compiler, a JIT compiler, and a linker that links the JIT compiler and the AOT-compiled code into the binary. Yeah, such a system is at least as powerful as just the JIT component alone, but such a system is not called an AOT compiler.

<comment><USER20> JITs could only optimize pattern matching if one particular branch is picked all the time, but not statically knowable. That is a very niche case.

Really, in almost all cases where JITs are effective it's because of a language where you have to use a dynamic abstraction when it should have been a static one. The most common example being virtual dispatch that should have been compile time dispatch. Or even worse, string based dispatch in languages where values are semantically string dictionaries (JS, Python, Ruby). A JIT is unnecessary in languages with a proper distinction between compile time abstractions and run time constructs. Names should be a purely compile time affair. Instantiating an abstraction should happen at compile time in most cases. There goes 99% of the damage that a JIT tries to undo, along with a lot of the damage that a JIT _doesn 't_ undo. Sadly most languages lack these abilities. Rust is one of the few languages that has a sensible story for this, at least for the special case of type abstraction, traits, and lambdas. I'm still hoping for a mainstream language with full blown staged programming support, but I guess it will take a while.

<comment><USER14> > JITs could only optimize pattern matching if one particular branch is picked > all the time, but not statically knowable.

They would optimize it if one particular branch is picked all (or even most of) the time but not statically knowable _at any given (extended) call site_ , and by "extended" I mean up to any reasonable point on the stack. That is not a niche case at all. Think of a square-root function that returns a Maybe Double. At most call sites you can optimize away all matchings, but you can't do it statically. Statically-knowable is _always_ the exception (see the second-to-last paragraph).

> Names should be a purely compile time affair.

That doesn't work too well with dynamic code loading/swapping... But in any case, you're now arguing how languages should be designed. That's a whole other discussion, and I think many would disagree with you.

> There goes 99% of the damage that a JIT tries to undo, along with a lot of > the damage that a JIT doesn't undo.

At least theoretically that's impossible. The problem of program optimization is closely related to the problem of program verification (to optimize something you need proof of its runtime behavior), and both face undecidable problems that simply cannot be handled statically. A JIT could eliminate any kind of branching at any particular site -- be it function dispatch, pattern matching or a simple if statement -- and eliminating branches opens the door to a whole slew of optimizations. Doing branch elimination statically is simply _undecidable_ in many, many cases, regardless of the language you're using. If you could deduce the pertinent information for most forms of (at least theoretical) optimization, you've just solved the halting problem.

Whether or not what you say is true in practice depends on lots of factors (like how far languages can take this and still be cheaply-usable, how sophisticated JITs can be), and my bet is that it would end up simply being a bunch of tradeoffs, which is exactly where we started.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER21> I'm surprised to read about this direction, however little practiced it may be. JIT never was for the fastest of applications but in-time optimization should (and has, in some occasions) reach and even exceed the speeds of precompiled ('native'). Simply because the JIT optimizer has access to the actual runtime data that is being fed to the Tight Loop of Performance Bottleneck, and can do local and specific optimization for that run alone. AOT optimized binary can only do generic optimizations in theory.

<comment><USER22> Several years ago, HP (I think) published a research paper investigating JIT on precompiled binaries, exactly for this purpose. They claimed around 5-10% speedup on x86 code. Unfortunately the project never got released.

</comment></comment><comment><USER23> JIT may be a bad fit for real-time phone apps. But at the same time we're seeing the return of batch processes thanks to "big data".

At my last job I worked on Spark processes that took several hours to run. In research, performance is important but you do get to average. So I don't think JIT will go away for that case; it wasn't worth hand-optimising (most jobs were only ran a couple of times), but at the same time I was very glad it wasn't Python.

<comment><USER24> With Big Data we also see stream processing, which is much more Big Data than batch processing

</comment></comment><comment><USER25> I'm ambivalent about this subject.

On the one hand, it intuitively makes sense that JIT compilation is inferior to AOT compilation for an application that will be packaged once on a developer's machine and then run on thousands or millions of devices. Doing the JIT compilation on all of those devices is a waste of energy; it's better to do the compilation just once on the developer's machine.

Also, JIT compilation requires warm-up to get to good performance. The kind of consumer who won't pay more than a few dollars for an app will also be turned off by an app that isn't snappy right away. So the first impression is everything, and a warm-up period before good performance isn't as acceptable here as it is in server applications.

On the other hand, on the major mobile platforms, native apps which can be AOT-compiled have to be distributed by gatekeepers, i.e. the app stores. On these platforms, the only alternative to the gatekeepers is the web. So I have a non-technical reason to want the last major JIT-compiled language on the client side, JavaScript, to be good enough for a variety of applications.

I was going to comment on the advantages of JIT compilation with regard to polymorphism, but then I found that the OP addressed that with his argument about predictability being more important than best-case or even average-case performance.

Finally, I'm curious if the author of the OP would use the same argument about predictability over best or average case performance to argue for reference counting over tracing GC. Maybe Android's ART and .NET Native would benefit from using reference counting in combination with a backup tracing GC to handle cycles, like CPython.

<comment><USER7> .NET GC is quite good and they introduced features in version 4.6 that allow even for fine-grained control over when collections happen and how.

Reference counting is only helpful if directly supported by the compiler, to remove inc/dec pairs. Also it is worse than GC for multi-threaded applications.

Currently I think the only alternative to GC are Substructural type systems. Even C++ guys are now looking into this. The problem is making it palatable to the average mainstream programmer.

</comment></comment><comment><USER26> This widespread move towards AOT is interesting in comparison to the prevailing attitude 5 years ago.

"Have tracing jit compilers won?" [http://lambda-the- ultimate.org/node/3851](http://lambda-the-ultimate.org/node/3851)

</comment><comment><USER27> The "hybrid" model they refer to is very common in Game-Dev. C/C++ down at the engine level tied together with Lua/UnrealScript/Lisp/etc.

</comment><comment><USER28> In my company, we develop on windows, build on linux and run on solaris (JavaEE). Moreover (forget devops!) the deployment team are not the development team.

Having an environment (JVM + web server + our code) that is the same across the various hardware and company's teams is really something that helps.

So besides the AOT/JIT discussion, the value of the JVM in itself is really good for us.

<comment><USER7> Yes, but that hasn't anything to do with AOT/JIT rather a portable binary format for Java executables.

A few commercial JVM vendors do offer AOT compilation on their JDKs.

</comment></comment><comment><USER29> AOTs are best for when you want to use universal computers to run computations (e.g. apps).

JITs are best for when you want to use universal computers to run better universal computers.

</comment><comment><USER30> In the case of Android, the big downside is very slow system updates because all apps on the device have to be recompiled. But it probably can be fixed.

</comment><comment><USER31> This is one reason I am pretty excited about the potential for web assembly in terms of a cross-platform and cross-language performant target.

</comment><comment><USER32> The Julia language seems to be designed to be nothing more than optimised glue between two Python scripts. As a dynamic language, it's certainly a good match for a JIT (run at once after a quick edit). And that also explains why there can never be a standalone executable produced from Julia, since that would require AOT. My guess is that Julia will dodge the Jitterdämmerung for a long time to come, if not forever.

<comment><USER33> Julia does very little tracing, except to infer types, which it then passes on to LLVM. All the optimizations in Julia are because Julia stresses type stability, and once types are known, LLVM can generate very good code specific for those types.

You can easily annotate functions with types in Julia, and pre-compile specialized functions. Julia does very little runtime magic to speed up code, especially compared to PyPy. The speed just comes from a very clever type system + LLVM.

</comment></comment><comment><USER14> There is no "shift away from JIT", just a simple observation that JITs are a tradeoff that you sometimes don't want to make. They have three drawbacks and two advantages. The three drawbacks are 1/ slow warmup, 2/ somewhat increased RAM and CPU usage and 3/ complex implementation. The two advantages are 1/ (often _much_ ) better runtime performance (i.e. more optimized code) and 2/ much better support for runtime manipulation of code (for profiling, debugging "at-full-speed", hot-patching, monitoring etc.).

The slow warmup makes JITs a bad choice for quick command-line tools, and the increased RAM/CPU makes them a bad choice for battery-powered devices and those with very limited RAM. The better performance and optimization opportunities makes them the _only_ performant choice for some languages that are hard to optimize AOT (those that rely a lot on dynamic dispatch and/or have dynamic data-structures, i.e. maps instead of class instances). The better instrumentation support makes them a terrific choice for long-running server-side application, where the drawbacks don't matter. On the client-side, unless the language requires a JIT for decent performance (like JS), there is no compelling reason to use one, and that's why Microsoft's decision makes perfect sense, as they've decided to focus on .NET on the client. This has nothing to do with JITs' great utility in general.

One of the biggest breakthroughs in compiler technology in the last decade is Oracle Lab's Graal[1], which can also be used as an AOT, but with less- powerful optimizations. E.g. Graal does this: [https://twitter.com/ChrisGSeaton/status/619885182104043520](https://twitter.com/ChrisGSeaton/status/619885182104043520)

Graal (alongside its language-construction DSL, Truffle) has yielded implementations of Ruby, Python and JS that easily rival the state-of-the-art with far, far less effort, and also a very decent implementation of C (also with orders-of-magnitude less effort than the competition).

The third drawback makes developing JITs from scratch a bad choice for anyone but the most well-resourced teams, or those that are in no hurry, or those that target very simple languages only.

JITs have another drawback -- less predictable performance -- that matters mostly for hard-realtime code (or nearly hard-realtime), as deopts that momentarily slow-down performance as a better optimization strategy is sought. This is why hard-realtime JVMs offer a mixed JIT/AOT mode, where the hard realtime kernel (which values predictability over perfroamce) is AOT compiled, and the soft-realtime or non-realtime support code is JITted (which you want to run as fast as possible, but don't mind a rare hiccup).

[1]: [https://wiki.openjdk.java.net/display/Graal/Publications+and...](https://wiki.openjdk.java.net/display/Graal/Publications+and+Presentations)

<comment><USER34> > 1/ (often much) better runtime performance (i.e. more optimized code) and

Do you have a cite for that? Except for method inlining, which only requires a trivial JIT compiler, I haven't seen them beating normal compilers. The argument that you should be able to use the programs runtime data to perform specific optimizations seems to me to be oversold. Since the JIT compiler must be reasonably fast it eschews many optimization techniques that AOT compilers can afford to use.

<comment><USER14> Look at the tweet I linked to. And bear in mind that languages that are normally AOT-compiled (like C and C++) are often designed in such a way that information that is pertinent to most optimization is available at compile time, plus programmers in those languages don't make use of more general abstractions unless they have to (which makes, say, C++ more complicated as it has two dispatch mechanism that the user needs to be aware of). Such languages obviously won't be accelerated much by a JIT, but they have a big complexity cost, as various low-level optimization considerations have to be exposed by the language. JITs make simpler, higher-level languages as performant, and there's plenty of data to support that.

<comment><USER34> But your claim was "(often much) better runtime performance" What you link to doesn't support that. I can concede that a JIT can attain _equivalent_ performance to AOT compiled code. But I haven't seen any evidence that JIT:ing in practice increases performance. Note that there are many modern high-level performant languages that do not use a JIT, like Nim, Haskell, Julia and Rust.

For example, the V8 engine has both a JIT an AOT compiler. The engine compiles all code with the fast AOT compiler and then recompiles frequently used functions with the optimizing JIT compiler. If it instead compiled _all_ code with the optimizing compiler AOT, the JIT part wouldn't be needed and you would get just as fast code.

JIT can only beat AOT if you can exploit patterns in the dataflow of the program. Doing that profitably (i.e. the optimization must save more time than it costs to perform) is incredibly hard.

<comment><USER35> Haskell and Rust both require monomorphization, right? That's one thing the JVM doesn't require. You do pay a performance penalty for megamorphic code ([http://insightfullogic.com/2014/May/12/fast-and- megamorphic-...](http://insightfullogic.com/2014/May/12/fast-and-megamorphic- what-influences-method-invoca/)) but it's still a difference in what's allowed.

I also don't understand what you're saying with regard to V8. Can the optimizing AOT compiler actually do enough optimizations on a language as dynamic as JS?

<comment><USER36> Rust lets you choose between monomorphization (trait bounds) and vtables (Trait objects).

<comment><USER20> The semantics of those are different. With trait objects the vtable is attached to the value. You could instead imagine a language with two types of trait bounds: one specialized statically (like Rust trait bounds), and the other handled dynamically (like type classes in Haskell). The semantics of these would be identical (vtable travels independently of values), the only difference is performance. I'm not sure if you'd ever want Haskell's implementation strategy in practice though, unless you want to support features that can't be supported by static specialization like polymorphic recursion or higher rank polymorphism (not to be confused with higher kinds). Interestingly C# does support those features _and_ specialization because it specializes at run time. It's a less known very powerful feature, at least in theory :) You can abuse it to make the CLR generate arbitrary code at run- time.

<comment><USER37> In what way does the vtable being attached to the value cause different semantics (what you describe sounds like an implementation detail)? In particular, you can have Box<TraitObject> which has effectively identical semantics to TraitObject; yes, it's a fat pointer, but from the perspective of the trait itself there's no way to tell that this is the case. Anyway, the only ways I can think of to usefully differentiate the fat from a thin pointer in a parametric function are those in which Rust already fails to have proper parametricity for any type (including being able to access its type_id).

<comment><USER20> Steve Klabnik was not talking about Box<TraitObject> vs TraitObject, but about f(x:TraitObject) vs f<T:TraitObject>(x:T). In the former the vtable is attached to the value, in the latter the vtable travels separately. These do have different semantics, compare f<T:TraitObject>(x:Vec<T>) with f(x:Vec<TraitObject>). In the x:Vec<T> case there is a single vtable that gets passed to the function, and all elements of the vector share that same vtable. With x:Vec<TraitObject> each element of the vector has its own vtable.

In terms of pseudo Haskell types these two types would be:

        TraitObject t => List t -> Result
        List (exists t. TraitObject t) -> Result

Rust cleverly sweeps the existential under the rug.

<comment><USER37> Again, in what way is the use of fat pointers a _semantic_ difference, outside of parametricity-breaking functions like size_of_ty and type_id? You are describing an implementation detail. I can think of times that the compiler should be able to desugar the fat trait objects into thin ones in the absence of a Reflect bound.

<comment><USER20> As I explained, the difference is that in one case you have one vtable per object in the vector, in the other case you have one vtable for the whole vector. With one vtable per object you can have one vector containing objects of two different types that implement the same trait with a different vtable. With one vtable for the whole vector you cannot. The same difference exists in many languages, e.g. C# List<IFoo> vs List<T> where T:IFoo.

<comment><USER37> Oh, duh, yes. I missed the obvious thing :P Indeed, that is the point of existentials, sorry for being obtuse.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER38> For anyone confused at the title - it's a reference to a part of the epic Wagner opera "Der ring des nibelungen" called "Götterdämmerung" or "Twilight of the Gods"

<comment><USER39> I personally rate it as one of the best titles for a blog post I've come across in a while :-)

If someone eventually advances the state of distributed revision control systems then they'll get to write an article titled "Gitterdämmerung".

<comment><USER40> I think "Jitterdämmerung" is strictly better than "Gitterdämmerung" would be, because there really are multiple JITs but there's only one Git. (On the other hand, the Hamming distance to "Götterdämmerung" would be less.)

<comment><USER39> If we all took Dijkstra's advice we could claim that the current state of programming is "Gotodämmerung".

Not so good on the Hamming distance though...</comment></comment></comment></comment>


Groupon fix for furniture shoppers ends only in a bad trip - <AUTHOR> http://www.washingtonpost.com/wp-dyn/content/article/2010/10/18/AR2010101804965.html?waporef=obinsite <comment><USER2> I wondered when this one was coming. Furniture companies are notorious for giving you the best deal for them. Now they have exposed how to game Groupon I wonder how many will follow suit. I have always wondered if Groupon has a plan for once someone got wise and started raising rates on their items while a Groupon coupon was in effect. I figured it would be someone like a furniture company that would do so. Raise all the prices, put them on sale the week before the coupon is valid, then have the "sale" expire once the coupon becomes valid.</comment>


The Web development skills crisis - <AUTHOR> http://weblog.infoworld.com/fatalexception/archives/2008/07/the_web_develop.html <comment><USER2> I think web development is comparable to most other service industries. The core concepts change very slowly over time, but the tools and technologies used for implementation evolve much more rapidly and practitioners must keep pace with "relevant" changes (ignoring the noise, of course).

Here are some examples:

1) Auto Repair: The fundamental elements of a car (wheels, engine, pedals, brakes) change very little over time. However, the implementation or these elements changes rapidly.

2) Medicine: The fundamentals of biology don't change often, but advances in medical devices requires additional training.

3) Construction: Once you get past hammers, nails, and the basics; the tools and materials change often. You also need to be aware of new building codes and regulations.

4) Accounting: New accounting rules and regulations are passed each year and require additional training.

There are probably many more good examples as well. The key point being that those who are passionate about their particular field will be motivated to continue learning -- leveraging their experience to remain successful.

</comment><comment><USER3> _Experienced systems programmers will tell you that computer languages really are all the same, and that learning Python is trivial if you already know Blub._

No, I don't think we would tell you that...</comment>


Ask HN: Can Facebook (or Google, Apple, Amazon) Live Forever? - <AUTHOR> The Bloomberg article [0] had me thinking.
Can a dominant internet company (Facebook for example, since most people here seem to think they are more vulnerable than the others) prevent its ultimate demise simply by buying competitors and building a Berkshire-Hathaway-style holding company?
If not, what are the confounding factors? Antitrust? Company culture? Lack of vision?
Is big business necessarily the future of tech?
[0] https://www.bloomberg.com/view/articles/2017-02-17/mark-zuckerberg-s-manifesto-for-facebook-offers-a-social-dystopia <comment><USER2> They will adopt. As an example, Zuck explained this one of the previous F8 conf. I guess, FB was about sharing texts in the first place, then people started to communicate with images/pictures, they've adopted. Then it changed to gifs or videos, they've adopted. Then it's becoming VR/AR and these kind of things, and they're planning to adopt.

So, yes, in one way or another they'll live forever.

<comment><USER3> *Adapt and not adopt

<comment><USER2> oh sh.t. i was in a hurry. thanks!

<comment><USER4> I like the first one better. Like the Japanese companies that just keep adopting sons to keep continuous operations. The bigger question, of course, is would Google make you call it Daddy.

</comment></comment></comment></comment><comment><USER5> IBM was founded in 1911 so it's more than 100 years old. In computer science such a time span is basically "forever".

Of course 1911 IBM has nothing to do with today's IBM or 1950 IBM. IBM used to sell typewriters.

</comment><comment><USER6> For me probably yes, unless "digital thing" will be superseded by another type of commodity. Look at Shell, Exxon (Standard Oil) and any other >100 years old company, some of them are still dominant, Facebook will be too (IMO).

How about Google? probably yes too

Amazon? again yes

Microsoft/Apple? They have enough R&D power to adapt new tech if anything comes out in hi-tech space, probably yes too

</comment><comment><USER7> Who ever dominates the AI space first, will dominate everyone else. If amazon cracks deep learning before google, they'll be able to move a billion times faster, instantly.

I'd say anything can happen within the last 10-20 years.</comment>


GitHub officially announces Issue and Pull Request templates - <AUTHOR> https://github.com/blog/2111-issue-and-pull-request-templates <comment><USER2> Comments moved to [https://news.ycombinator.com/item?id=11119411](https://news.ycombinator.com/item?id=11119411).</comment>


Show HN: Historical stock price viewer - <AUTHOR> http://newinvestordaily.com/what-would-it-be-worth/ <comment><USER2> This is fun to play around with.

Can you explain how stock splits are accounted for in the "Percent gain" calculation for this case?: [http://newinvestordaily.com/what-would-it-be- worth/r/30991](http://newinvestordaily.com/what-would-it-be-worth/r/30991)

Intuitively that value would be much larger (300% or so instead of 40%).

<comment><AUTHOR> Splits and dividends should be factored into the price. I use the adjusted closing price [http://www.investopedia.com/terms/a/adjusted_closing_price.a...](http://www.investopedia.com/terms/a/adjusted_closing_price.asp).

However in this case with Ebay it wasn't a stock split but rather a big chunk of Ebay (Paypal) split off into a separate independent company. I think what happened is when Ebay and Paypal separated Ebay share owners gained the equivalent Paypal shares. So this would throw off the numbers.

</comment></comment><comment><USER3> This is EXACTLY what I was looking for. I posted 25 days ago looking for it:

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

</comment><comment><USER4> This looks really fun, but I can imagine a few pissed off folks seeing what they missed out on.

<comment><AUTHOR> Yeah hindsight does really hurt here but not everybody did well. For example check out Zynga [http://newinvestordaily.com/what-would-it-be- worth/r/23090](http://newinvestordaily.com/what-would-it-be-worth/r/23090)

</comment></comment><comment><USER5> Could not find Uber in the list of companies!

</comment><comment><USER6> Can you add ETFs?</comment>


PIFuHD: High-Resolution 3D Human Digitization - <AUTHOR> https://shunsukesaito.github.io/PIFuHD/ <comment><USER2> I'm glad I clicked this because it's awesome, but it wasn't at all what I was expecting. Maybe change the title to _PIFuHD: High-Resolution 3D Human Digitization_?

</comment><comment><USER3> So I am building a farm robot, and for various reasons I think having a 3D reconstruction of the plants would be useful. I'm hoping that this technique might be useful for reconstructing models of plants from a small number of images. The model doesn't need to be perfect, just close. I think this will help in doing reinforcement learning on simulated data, among other things.

Great research coming out of Facebook Reality Labs!

</comment><comment><USER4> More info on this blog: [https://ai.facebook.com/blog/facebook-research-at- cvpr-2020/](https://ai.facebook.com/blog/facebook-research-at-cvpr-2020/)

</comment><comment><USER5> This is amazing. Does anyone have any insight on what makes the back view possible?

<comment><USER6> It requires a video and the person needs to rotate. It doesn't imagine the back view. It appears to be doing optical flow and photogrammetry.

<comment><USER3> It is not doing photogrammetry and it works on a single image. It has learned what people look like (and training may have used photogrammetry in some way) and it can imagine a good 3D model from even a single image. The last line of the abstract:

"We demonstrate that our approach significantly outperforms existing state-of- the-art techniques on single image human shape reconstruction by fully leveraging 1k-resolution input images."

</comment></comment></comment><comment><USER7> The pretrained model is unavailable.

edit: downloading now, maybe the server was overloaded.

<comment><USER6> If you try it your own video, make sure the person is rotating so the model see all sides.

<comment><USER8> I'd recommend watching the "1 minute presentation" video linked at the top of the page. It mentions generating the model from a single image.

[https://youtu.be/-1XYTmm8HhE](https://youtu.be/-1XYTmm8HhE)

</comment></comment></comment><comment><USER9> Application - better fitting of clothes brought online? Consumer happy, company returns rate drops. Seems like an obvious one no?

</comment><comment><USER10> High resolution doesn't mean high accuracy in this case.

<comment><USER6> Similar to how the early GANs for generating faces were low res. I would expect follow up work to get much better fairly quickly.

<comment><USER10> You can't create an accurate 3D model from what you can't see. It can be high resolution though...

<comment><USER11> It's not about being "accurate" as in representing exactly what it can't see but rather be "authentic", since you don't care about things like patterns or logos clothes aren't that hard to figure out and so are body shapes.

Backpacks, and other attachments that are on the back or occluded ofc can't be predicted or fitted with-in the model to represent their real life counterparts well not unless you train the model on every possible backpack.

That said training this model on people's photographs and their 3D scans and then possibly on a dataset of clothes and accessories from big brands might actually allow you to much more accurately predict the unseen parts of the image by not only filling the gaps based on predictions but by actually specifically matching the items of clothing and accessories to draw additional information that way.

Most fashion brands already have detailed images of their products from multiple angles and even have 3D views of many items.

Combine that dataset with this model and you'll probably be able to increase the accuracy of these models considerably.

</comment></comment></comment></comment><comment><USER12> Tweet of Obama reconstructed as Larry Bird in 3...2...</comment>


Persona on Firefox OS phones - <AUTHOR> http://identity.mozilla.com/post/47114516102/persona-on-firefox-os-phones

<comment><USER2> for people that only read the title. it mentions, that native persona is coming to desktop firefox.</comment>


Show HN: Music Search Engine - <AUTHOR> http://tunesicles.com/

<comment><USER2> Okay - so, first thought upon hitting the page is "What? What am I supposed to do? There's a black, blank YouTube box but no play button. I'm lost - I'm outta here."

What is a music search engine anyway? I'm truly confused.

<comment><AUTHOR> Thank for the feedback. Ill add a welcome page or something. And I wasnt too sure what to call it. But basically it allows you to search youtube and add songs to the playlist all from the dropdown. You can also add entire albums instantly.

</comment></comment><comment><USER3> Like the search. What search engine do you use?</comment>


Writing an Interpreter in SQL for Fun and No Profit [video] - <AUTHOR> https://www.youtube.com/watch?v=MPSMH8w7nfw <comment><AUTHOR> Speaker here. If you liked the talk, you may also like the other talk I've given on generating fractals with SQL[0]. You can also find it blog post form[1].

Originally, before I had given the fractal talk, I had wanted to make a compiler from a low level imperative programming language to SQL. I had done a similar thing in the past to write FizzBuzz in the esoteric programming language Fractran[2]. By doing that, you can fairly easily produce SQL queries that perform arbitrary computations. When I was brainstorming what examples to give, I thought it would be really cool to generate fractals. After thinking for a bit, I realized it would be easier to write the SQL queries directly than it would be to write a compiler to SQL. That's how the fractal talk came about.

After I gave that talk, I revisited the idea of compiling to SQL. After playing around with for a bit, I discovered it wouldn't be too hard to write a programming language interpreter in SQL which is how this talk came about.

If you have any questions, feel free to ask.

[0] [https://www.youtube.com/watch?v=xKoYIvMFnoQ](https://www.youtube.com/watch?v=xKoYIvMFnoQ)

[1] [https://malisper.me/generating-fractals-with-postgres- escape...](https://malisper.me/generating-fractals-with-postgres-escape-time- fractals/)

[2] [https://malisper.me/building-fizzbuzz-fractran- bottom/](https://malisper.me/building-fizzbuzz-fractran-bottom/)

<comment><USER2> The SQLite official documentation lists examples of using SQL to generate the Mandelbrot plot and to solve Sudoku.

[https://sqlite.org/lang_with.html](https://sqlite.org/lang_with.html)

<comment><USER3> I ran the query before and it was a lot of fun.

</comment></comment></comment><comment><USER4> Super cool hack! The author uses defunctionalised continuations to build an abstract machine directly as a CTE. I guess the fixed point of the transition function is returned by the CTE ... He also alludes to using the Y combinator to build recursion in the toy language being constructed. Ace abuse of SQL.

</comment><comment><USER5> I love the JSON-as-a-parser hack.

In TSQL (MS SQL Server) it would run into the CTE recursion limit; I'm not sure if Postgres is any different in this regard. I suspect that this could be solved and optimized with a WHILE loop and, most likely, something similar to ORDPATH[1].

[1]: [http://www.dbis.informatik.hu- berlin.de/fileadmin/lectures/W...](http://www.dbis.informatik.hu- berlin.de/fileadmin/lectures/WS2011_12/NeueKonzepte_Vorlesung/ordpath.pdf), [https://github.com/mejedi/libordpath](https://github.com/mejedi/libordpath)

<comment><USER6> FWIW in MSSQL there's always the `option (maxrecursion 0)` trick

</comment></comment><comment><USER7> I have implemented SQL parsers 4 times in my life, and for the life of me I still have to look at the spec everytime i write a query.

<comment><USER8> He is not parsing SQL, he has written a Lisp interpreter in SQL.</comment></comment>


A few things I've learned about typeface design - <AUTHOR> http://ilovetypography.com/2010/03/25/a-few-things-i%E2%80%99ve-learned-about-typeface-design/

<comment><USER2> Sounded like an interesting article but honestly, it's late in the day here and I cannot make sense of the language in that article. Maybe I am stupid but to quote the chicken-farmer in Napoleon Dynamite: "I don't understand a word you just said".

Example sentence:

"Typography and typeface design are essentially founded on a four-way dialogue between the desire for identity and originality within each brief ("I want mine to be different, better, more beautiful"), the constraints of the type- making and type-setting technology, the characteristics of the rendering process (printing or illuminating), and the responses to similar conditions given by countless designers already, from centuries ago to this day."

Amazing visual stuff in the article though, but so academic and wordy... will give it another try tomorrow.

<comment><USER3> Typography is a complicated field requiring some knowledge of technical, artistic, and psychological material. I wouldn't expect a typographer to be able to come to HN and understand the technical meaning of "functional" in "functional programming" or "idempotent" in a discussion of REST, nor would I expect a programmer to understand the technical language of typography.

If you'd like to learn more, some excellent books are:

\- The Elements of Typographic Style by Robert Bringhurst \- Detail in Typography by Jost Hochuli \- The Stroke by Gerrit Noordzij

<comment><USER2> I've read a couple of books on typography/design but none of them have been deep at all, just very basic on what different kinds of type styles are good at. I've got "Designing With Type" and it's very basic <http://www.designingwithtype.com/5/home.php> I've been wanting deeper material. Thanks a lot for the book tips they look like very promising -- added them to my tobuy list.</comment></comment></comment>


Ask HN: Angellist seems to have withered out, is there a 'new Angellist'? - <AUTHOR> Looking to hire developers. <comment><USER2> Do you want to hire remote developers? remoteok.io

Local developers? linkedin, glassdoor, stackoverflow, github jobs

I'm a developer looking for a job, you can hit me up at [redacted]

<comment><AUTHOR> Thanks for the suggestions. I'm mostly looking to hire in Finland - you're not located there, are you?

<comment><USER2> Sure. Unfortunately, I'm not in Finland.

</comment></comment></comment><comment><USER3> You said 'Yes' to _Company X_ 2 days ago. _Company X_ has viewed your profile.

 _Company X_ : Active 4 days ago.

How they've seen my profile if they weren't active at that time?

I applied to a few dev jobs and this happened. Their messaging was 'broken' in a similar fashion some time ago.

@sol_invictus, so maybe not all messages are coming through to you. Just a theory.

<comment><AUTHOR> Yes, the UI is bugged. The 'send message' function for instance doesn't seem to work at all. I had to hunt the person I was trying to message from LI and send them a DM through that.

Additionally, it contains less active people at least in my geography when compared to 1 or 2 years ago.</comment></comment>


Google Refused to Confirm If the CIA Have Access to ArabCrunch GMail - <AUTHOR> http://arabcrunch.com/2010/09/breaking-google-refused-to-confirm-if-the-fbicia-have-access-to-arabcrunch-email-on-google-no-word-on-mossad.html When gmail accounts for Chines human rights and political activist, Google delivered major threats to China in stopping its service in the country and closing it offices. In the blog post google said that it shared this information for the sake of a global debate about freedom of speech!! Seems Google is only worried about opposition to the .. <comment><AUTHOR> In China google talks about human rights and the right for human rights activist to oppose the chines government but if the person is Arab no rights then. SOLD OUT! specially the guys has sources he needs to protect</comment>


Your Mother, the Hacker: It's time to mom down and bake some code. - <AUTHOR> http://www.hackermothersday.com

<comment><USER2> Some of us moms could probably teach you a thing or two about coding. We're not all home baking cookies. Some of us spent our maternity leave writing keygens for shareware and learning the intricacies of using softice for reverse engineering.

<comment><AUTHOR> Hi Amy!

We know that there are some amazing moms out there coding and killing it! And, we love them!

We made two versions of the Mother's Day site: <http://skillcrush.com/mothers- day/>

The whole idea is that we want to celebrate moms & encourage more of them to get in the digital game ;)</comment></comment>


Smithsonian Digitizes 40,000 Asian and American Artworks - <AUTHOR> http://www.theverge.com/2015/1/3/7485921/see-the-massive-stunning-collection-of-art-the-smithsonian-just-put

<comment><USER2> Direct link: [http://www.asia.si.edu/collections/edan/default.cfm](http://www.asia.si.edu/collections/edan/default.cfm)

<comment><USER3> Yikes - they're using Coldfusion!

</comment></comment><comment><USER4> The collection is beautiful. Making these works available to the whole world, in an online searchable format is very valuable.

The search facet designations offered by Freer Sackler are useful. It would be cool if visitors/users could generate their own facet designations to allow for user-derived contextual value and meaning related to attributes of each work. Hashtag-enabled comments and meta-collections would be a good first step.

Do you think this would be useful?

</comment><comment><USER5> Seemingly missing: a download link. Since most of these are hundreds of years out of copyright, and they have already gone through the effort to digitize them, wouldn't it be a good idea to upload them to WikiCommons as well?</comment>


Death at the Needle: The Tragedy of Victorian Seamstress Mary Walkley - <AUTHOR> https://mimimatthews.com/2016/09/20/death-at-the-needle-the-tragedy-of-victorian-seamstress-mary-walkley/ <comment><USER2> It's unclear the intent of the author, but for this community it can be taken as a reminder that scandal is often ephemeral - stirring up the press and public but making no lasting change. The tragedy of a Victorian seamstress, the San Bernardino iPhone, Sandy Hook... To effect change requires a concerted, persistent, depressingly long effort to see it through, not just shouting for a bit.

I forget where I read it recently, but there was a piece about how some great strides forward were made not overnight, even though they may have seemed that way (I think the context may have been civil rights), but through decades of constant, vigilant advocacy and activism.

<comment><USER3> I felt like the author allowed the reader to draw their own conclusions but my takeaways were in the same vein: awareness and outrage don't immediately solve problems.

<comment><AUTHOR> I feel the same. I don't think that there is an intent other than education on 19th century history and events. The readers get to draw their own conclusions.

</comment></comment></comment><comment><USER4> Garment-stitching work is notorious for these kind of conditions, it's just moved around the world over the years to places like Bangladesh.

</comment><comment><USER5> Seemstress = Startup Developer?

I was reminded of the airbnb foundation legend : three designers on airbeds on the floor of an apartment. I also picture rows of developers crouching over macbooks (when any sane employer has keyboards and 2*24' monitors + a decent chair).

<comment><USER6> No seamstress did not make wages in the top 10% in the richest country on earth while working 7 hour days.

<comment><USER5> Well...

The seamstresses in the story lived in the richest country in the world (at the time!) And at that time inequality in GB was so eye popping that these poor girls may have actually been close to the top 10%, although a gigantic distance from the top 1% and an unimaginable distance from the top 0.1%

Also startup developers (proper startup developers) do not work 7 hrs, they work 14hrs.

<comment><USER7> I found some info for the US, I assume England would have similar numbers.

[http://www.nber.org/chapters/c2500.pdf](http://www.nber.org/chapters/c2500.pdf) page 101 suggests seamstress was making about 1/3 what a carpenters made. Thus seamstresses where far from the to 10%.

The US numbers look for top 10% was ~1/3 of all income top 5% = 20% of all income so 90-95% was ~10% of all incomes. The bottom 40% was 13.6% of all income. Page 32: [http://eml.berkeley.edu/~webfac/cromer/e211_f12/LindertWilli...](http://eml.berkeley.edu/~webfac/cromer/e211_f12/LindertWilliamson.pdf)

So, someone at 90.001 percentile was making about 8x what someone at 20.001 percentile.

PS: Inflation is hard to calculate for this time-span but it was the equivalent of something like 2$ per hour.

</comment></comment></comment></comment><comment><USER8> If you are interested, check out Magdalene laundries as well.</comment>


Facebook is down - <AUTHOR> https://www.facebook.com/# <comment><USER2> Wow... It's funny, but I always used FB as the example of a large, distributed application that is mostly available all the time... This is the first instance of FB being truly down that I can think of.

I'm guessing it's a federation/network issue more than at the application level, but that's just my own opinion without insight into their systems. I don't have FB access from where I am so no idea what the real issues are.

</comment><comment><USER3> This is going to have such a bad knock-on effect on all apps that rely on the Facebook Graph API. I mean, I can't even use Tinder right now!

</comment><comment><USER4> Yey;)</comment>


Show HN: SFTransit - easy San Francisco transit times - <AUTHOR>

Hello HN,
I built www.sftransit.us to make it easier to get live transit arrival/departure times on your cellphone. Right now, it does Muni and BART. You don't have to download anything, and it takes one click to find times for nearby stops.
I don't live in San Francisco right now (but am moving out there in a few months). I'm really keen to know if this is a useful service, and to know if there's anything that would make it more useful to you. I'm aware there are a few existing tools for this (like Routesy, and the official site [of course]), but I don't think any are as hassle free...
http://www.sftransit.us <comment><USER2> I'll have to try it out next time I need to get anywhere (which will be soon) but just clicking through you appear to have the two things I really need: a one-click spot for nearby stops of all transit (well, you've got Muni and BART but that's both a good start and the majority of my transit) and the ability to save frequent stops. The ability to check buses around a given stop is also something I've been wanting, though less often.

I don't know if you're planning any of this already but I do have a couple suggestions based on my current frustrations with nextmuni:

1\. Favourite buses in addition to favourite stops and prioritise said buses when nearby. I know that 21 and 5 are the two best buses to get me home but when I'm downtown they often aren't even on the nextmuni's nearby list because of the density of buses. I'd love to be able to favourite those buses and have them show up first (or at the very least always show up) if a stop is sufficiently nearby even if I'm at a stop I don't frequent.

2\. This one would be a bit more of an involved feature and I'm not sure how feasible it is with whatever dataset and/or APIs you have to work with. Basically, I want to be able to input my destination and have the site serve me buses with stops near both end points (if any exist), giving me time estimates near my current location.

Configuring "nearby" would be handy but far from critical, also.

<comment><AUTHOR> Hey, thanks for the feedback!

Number one makes a lot of sense - I'll take a look at that. You're right that number two is tricky, but I think it's possible to do something good there - I'll look at it, for sure.

</comment></comment><comment><AUTHOR> clickable: <http://www.sftransit.us>

If you're interested, it's built on Python/Flask, redis, geo.js.</comment>


Coded Message - <AUTHOR> The field of Genetic research is still relatively new, and so we can expect more information to come forward over time.  One field of interest that's gained much attention lately, is that of Chimera humans— essentially those who have the DNA of a fraternal twin (absorbed during the early stages of gestation).  Geneticists now understand that many people (and other animals) contain not just random DNA from the twin spread throughout the body, but entire organs that are fully functional.  From here we can conceptualize that it is possible for the twin's brain to have been also absorbed... AND, be fully functional!  In comes another piece of new scientific information concerning the very real case of the Hogan conjoined twins who are joined at the head in such a unique way— their conjoined thalamus acts as a bridge between their brains that enable them to feel/see... what the other twin feels, and including communicating to one another by thought only, or "talking in our head" as they call it.  So the question we need to ask ourselves is — what if chimerism occurs with the brain, whereby the fraternal twin brain was absorbed and fully functioning, and what if one brain is joined to it's twin via the thalamus that acts as a bridge much in the same way as the Hogan's?  The absorbed twin in this case would be able to influence the thoughts of their host twin... and if thoughts can be influenced so can actions.  Without a physical twin body (as with the Hogan's) who are both able to speak, communicating this "thought sharing" ability poses a problem, one that can be overcome via the absorbed twin influencing it's host twin's thoughts and actions in such a way that it can generate "pattern clusters"... and this enables us to pose a serious question: could it be possible that some of what we chalk up as "coincidence" or "synchronicity is in fact generated by this ability of absorbed twin(s)? <comment><AUTHOR> Here is one example of a coincidence/synchronicity that may fit the "twin" bill in regards to the birth and death info of two notable persons found on their respective wikipedia pages: —Thomas Fitzalan, 5th Earl of Arundel (13 October 1381 – 13 October 1415) —Tommy Whittle (13 October 1926 – 13 October 2013) was a British jazz saxophonist. Not only had they both died and were born on the same day— October 13, their first name Thomas means "twin" in origin.

<comment><AUTHOR> [https://en.m.wikipedia.org/wiki/Thomas_Fitzalan,_5th_Earl_of...](https://en.m.wikipedia.org/wiki/Thomas_Fitzalan,_5th_Earl_of_Arundel)

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

[http://www.behindthename.com/name/thomas](http://www.behindthename.com/name/thomas)

[https://en.m.wikipedia.org/wiki/Krista_and_Tatiana_Hogan](https://en.m.wikipedia.org/wiki/Krista_and_Tatiana_Hogan)</comment></comment>


Ask HN: the greatest mission statements - <AUTHOR>

Please share the best and most inspiring company mission statements you know of. <comment><AUTHOR> _Build the best product, cause no unnecessary harm, use business to inspire and implement solutions to the environmental crisis._

–Patagonia's Mission Statement

[http://www.patagonia.com/us/patagonia.go?assetid=2047](http://www.patagonia.com/us/patagonia.go?assetid=2047)</comment>


Can Nashville Pull Off a $5.2B Transit Makeover? - <AUTHOR> https://www.citylab.com/transportation/2017/11/can-nashville-pull-off-a-52-billion-transit-makeover/544301/ <comment> Trill-I-Am $10 billion of urban transit spending won't fundamentally fix the problem in Nashville because so, so many people commute in from out of the county because of white flight. We need regional transit solutions but they won't happen because 1.) The suburban counties currently reap all the economic benefits with none of the costs (transit) 2.) The wealthier suburban counties (Williamson) don't want people (read: anyone that isn't rich and white) from Davidson County coming into their county. 3.) The extremely republican dominated state government isn't going to spend any money on infrastructure for the main democratic stronghold of the state.

<comment><USER2> I'm rich and white living in Williamson county. I moved here when I wasn't rich (but still white) because Franklin (seat of Williamson County) is a great place to live.

I would welcome rail from here to Nashville, I don't get up there much primarily due to traffic. I've lived in many places, including Manhattan and San Francisco, and I sorely miss the convenience of the train.

Simply put, rapid transit would be great for commerce in Nashville and it would either alleviate in some way or at least mitigate traffic congestion that will be compounded by the rapid growth of Nashville's suburban communities. I think costs of extensions into these communities should be shared, but ultimately funding rapid transit through sales tax makes sense because commerce/tax base should increase.

Anyway - just came here to give some perspective - don't get the impression that Williamson County, Tennessee is full of racists. It is not as diverse as Davidson County, but nonetheless a wonderful place to live.

EDIT: I forgot to mention that I'm anxious to see how autonomous cars will affect situations like the one facing Nashville.

<comment><USER3> I have a hard time imagining the combination of self driving cars and VR not having a DRAMATIC affect on cities. As I've said many times before eye contact will be the killer app for VR. What happens to cities when you can look someone in the eye over the internet, or place them alongside you while you use your laptop? I don't understand how that could be anything but transformative for the economics of cities.

<comment><USER4> _I have a hard time imagining the combination of self driving cars and VR not having a DRAMATIC affect on cities._

Ah but what will that effect be? There's nothing about a self-driving car that increases road capacities. And since a self-driving car doesn't get bored or frustrated, there's less of a disincentive for a self-driving car to drive during rush hour. So it seems like if all else remains equal, self-driving cars are going to make traffic worse, not better (sure, if you could combine them with ride-sharing, they might reduce things but lyft and Uber right now could be ride-sharing but they aren't. No reason to expect a self-driving taxi would better unless something impels it).

<comment><USER5> I'm with you, many folks seem to believe self driving cars will increase existing road capacity tenfold or something- I just don't see it. Once every car on the road is self driving they can maybe drive "too close" at speed, but overall there's still a limited amount of space on the pavement.

Now, if these self driving cars were high passenger capacity, that might have a great effect- but of course then we'd just call them a bus.

<comment><USER6> I don't think anyone really knows, but say we have cheap taxis, ride sharing, driving "too close", and far fewer accidents? There's still a limit but it should be quite a bit higher.

<comment><USER5> Trouble is the concept of induced demand, which roads enjoy in spades

</comment></comment></comment></comment></comment></comment></comment><comment><USER7> This seems like a puff piece that does nothing to capture the debate around this proposal that is taking place in Nashville.

Yes, there are state-level politics involved, but there are a LOT of Nashville residents that are strongly against this plan on the grounds that it will be outdated and under-utilized before it is ever completed.

The Mayor's PR machine and the local Chamber are working hard to create support for this proposal, but it will be an uphill battle and will likely fail with the voters.

<comment><USER8> How can it be outdated? Do residents think self-driving cars will take over by the time the system is ready?

<comment><USER7> Partly. The train will take 10 years to build (assuming it is on-time).

We also feel that ride-share will continue to expand. We don't have any pooling services (yet), but that is also inevitable.

The other big complaint is that this is one 25 mile train from one side of town. But we aren't a coastal city like Seattle (where public transit is doing well). We have 3 major interstates (i24, i40, and i65), so that means there are bedroom communities in 6 directions from town. And m at least one of those (i65 south of town) has a two-way rush hour due to so many people living in Nashville and working in the south suburb (Brentwood / Franklin). Of course, that is not where the train is going b/c that is the wealthiest suburb and they don't want a train.

So, shuttling in a few people from one side of town into an urban core with a lackluster hub/spoke bus system inside the city, isn't going to do much.

The strongest argument for Mayor Barry's proposal seems to be "We have to do SOMETNING, so let's do this."

<comment><USER5> Is there a real reason to believe that highways can provide all the transit the city will ever need? Like, if only people would finally rideshare (which cities have been promoting since, what, the 60's) all the traffic would be gone?

Is there a train layout that would be much more attractive?

<comment><USER7> My comment about the highways is that people live/work in 6 directions (due to traditional access via interstates). A train on one of them won't do much, especially since it isn't even the busiest direction.

<comment><USER9> The 10-year proposal includes light rail in several directions. Not sure why you think it's only 1?

[http://www.tennessean.com/story/news/2017/10/26/nashville- un...](http://www.tennessean.com/story/news/2017/10/26/nashville-underground- tunnel-why-mayor-megan-barry-transit-team-says-tunnel-wouldnt-too-big- dig/795533001/)

<comment><USER7> Not really. It comes to downtown from the north, and then goes west, but stops at I440. So that has zero benefit to the people who commute from the west on I40.

</comment></comment></comment></comment></comment></comment></comment><comment><USER10> I'm moving from San Francisco to Nashville in December for a plethora of reasons, but I can tell you that Nashville is growing and expanding like crazy. I believe it is in the top 10 fastest growing US cities and it is VERY business friendly (no state income tax) and has favorable small business conditions. While Nashville is certainly a music city, the business environment continues to improve. Even with a 1% increase in sale tax to support Let's Move Nashville, I think this has a great chance of passing. I'm very bullish on the Nashville economy :-).

<comment><USER11> > I'm moving from San Francisco to Nashville

As a Tennessean who wouldn't mind moving to San Francisco, I'm curious if you can share any of your reasons? I haven't noticed many tech benefits in Tennessee over SF beyond lower cost of living.

<comment><USER10> Well, if I share my opinions of why I want to move out of downtown SF I'm sure I will just get downvoted here on HN, so instead I'm just looking for a change. Ready to settle and slow life down. I absolutely love music (played drums and piano) and really enjoy the amazing live music scene in Nashville. I also found that people are super friendly, charming, and ultra polite in Nashville.

<comment><USER12> What You don't like the blight of the homeless smacking you in the face in San Fran? I guess it's in Nashville (I never saw it while living there for 3 years from Baltimore) too but it's not a lifestyle there or a city other cities dump their homeless problem on.

I loved San Fran on my first visit then I stayed at a hotel on Market st and visited Haight Ashbury..omg!

</comment></comment></comment></comment><comment><USER13> Aside from the dense and compact NYC subway, is there any transit system in the USA that people would say is a great example to follow?

<comment><USER14> Chicago's rail system ("The L" elevated line + Metra hub and spoke to the suburbs) as well as the CTA bus system are very good.

My suggestions to improve would be better funding for light rail, dedicated lanes for buses that other vehicles can't enter, priority access at intersections, and a congestion charge to enter the core ("The Loop").

EDIT: Dropped "light" from "light rail system".

<comment><USER15> Minor quibble but Chicago's elevated and commuter rail systems are all heavy rail, not light rail.

<comment><USER16> Whats the difference? Heavy is the same stuff as freight trains, and light is smaller?

<comment><USER17> It's not a rigorously defined phrase but yes basically.

</comment></comment></comment></comment></comment><comment><USER18> $5.2 billion for around 25 miles of light rail? Honestly by American standards that's pretty affordable. Denver spent a similar amount for much more rail but in the process got a commuter rail line where the grade crossings don't work.

<comment><USER19> It really depends. St. Louis has built light rail along existing rail ROWs in rural areas, inside existing Downtown tunnels, and through new urban tunnels built specifically for light rail.

The costs vary wildly along each of those segments.

$5 billion to build new tunnels? That's a bargain. Along rural ROWs? That's a boondoggle.

</comment></comment><comment><USER20> Make it fully automated, self driving, on controlled trackways with entry and exit on the opposite sides of cars.

Why? They do it with elevators don't they? I recall when all elevators had operators - yes a person in the car to push the floor button.

This evolved from old systems with a hand operated cable line with a window the operator put his hand into to pull up/down and to level the car. This led to elevator operator unions, and strikes - which led to fully automated push button elevators when the unions got whiney and greedy. Operators were getting $50,000+ for riding and pushing buttons. .

So the were all left out in the cold and courts supported automated elevators.

Then there were the movie projector operators, relics of the carbon arc in the old days. Now fully automated digital projection rules this work place,

<comment><USER21> I do deliveries to some buildings that still have freight elevator operators, in a USA city.

I don't know what they are paid, but it is worth every penny for them to manage the elevators. There is not enough "supply" of freight elevator in most tall buildings, so these operators distribute the capacity to the dozens / hundreds of people needing to use the elevator each day.

$50k per year is a bargain for all the time they save for the thousands of deliveries and other uses each year.

If you have experience in this area, then I should not say this: it's easy to criticize some work as useless when one is totally ignorant of the problem space. But buildings don't hire these operators as a charity.

<comment><USER20> Yes, I agree, freight management differs greatly from people walking in and pushing buttons for their floor.

We now have a new system where you go in and push what floor on an external pad and the system tells you what car to go to.</comment></comment></comment>


Page Rank 0 to 4 in Under Four Months, How I did it - <AUTHOR> http://blog.whyspam.me/index.php/2010/04/16/page-rank-0-to-4-in-under-four-months/

<comment><USER2> Really well written article, thanks for sharing. One thing I would change though:

 _"It is hosted under blog.whyspam.me because a subdomain's PR goes towards the main site."_

In my research and experience, its more beneficial for SEO to host your blog at mydomain.com/blog/ instead of blog.mydomain.com. The reason being that Google treats subdomains as different sites.

You're still linking from the blog to the main site, so a good bit of PageRank will pass through, but you might have an even better impact were the blog hosted on the same subdomain.

Cheers!

<comment><USER3> I would prefer to use blog.mydomain.com and then do a 301 redirect to bring all Google juice into the main domain.

<comment><USER4> 301 redirects don't pass 100% link juice so why waste backlinks to a subdomain that you don't plan on actually using? Are you just saying have it available as a convenience thing in case someone tries to guess your blog URL?

<comment><AUTHOR> Is that true? what about 302 redirects?

As far as the guessing for blog name if your 404 pages are good enough it won't matter, for me if you go to <http://whyspam.me/blog> they'll still see the link to the blog, even though you're viewing a 404 page.

<comment><USER2> Avoid 302 redirects, they pass no PageRank.

301's do dampen PageRank as well, though the exact amount is not known. I've always put it around 10-15% (i.e., after each 301 you are left with 85% of the original value). I also suspect that its contextual - so a 301 from www.mydomain.com to mydomain.com would probably be dampened less than a 301 to a completely different domain (e.g., bit.ly).

</comment></comment></comment></comment></comment><comment><AUTHOR> This is the process I took to get to page rank 4 from january to april. Before this I've never had a page rank 4 website, so while i'm sure I could do this again in much less time, I wanted to give those getting started an idea of what they can do to improve their PR, and demystify the whole process. With so many articles like "PR5 in 5 days", it can be demoralizing to not see results for awhile.

I did not spend a full 4 months on SEO alone either. I have another full time job, and was also working on usability studies etc. Enjoy, and let me know if you have any questions!

</comment><comment><USER5> not to sound negative, but Google doesn't update the public PR information in real time...they do it once every ~4-5 months. So your "PR jumped to 1" "PR jumped to 2" etc doesn't hold much water. I'm guessing you just saw that PR jumped to 4, so you extrapolated your efforts backwards.

<comment><AUTHOR> The update in PR was from the corresponding jumps I saw on my search keywords in google webmasters as well as actual PR. I saw 0 in december/january, and then noticed a jump of search rankings in feb. In late march my page rank was actually observed as 3 and then in april around the 6th I saw that my PR was reported as 4. Which was accompanied by another jump in my keyword rankings.

Update - I put a note at the bottom of the article to better reflect how I got the numbers.

</comment></comment><comment><USER6> I guess I would question the value in striving for high PR. Modern SEO is far more about engaging with the social scene than hunting down obscure link directories/blogs.

If you have a cool service, then find a way to get people to tweet about it. imho, a far more relevant way to drive awareness.

<comment><USER7> Google can send you a ton of high value traffic. Getting on Google page 1 can be done (almost) by yourself, without having to convince others to tweet, blog, share on facebook, etc. Plus, once you're there, it takes very little effort to stay, as compared with staying relevant in the social web.

Social is the hot thing right now, but when you're starting at zero, SEO is still a great way to bootstrap yourself to decent traffic.

<comment><USER8> Yep, the bursty, generally curious (rather than intentful) traffic from social media links absolutely pales in comparison with the consistent, large, and high-converting amount of traffic Google can send.

Social media is much better at engaging with customers to get feedback and figure out where the holes in your product are.

</comment></comment></comment><comment><USER9> Not actually that impressive, as Page Rank is an exponential scale.

[http://www.rimmkaufman.com/rkgblog/2007/07/24/climbing- page-...](http://www.rimmkaufman.com/rkgblog/2007/07/24/climbing-page-rank- mountain/)

<comment><AUTHOR> Good link, i like the graph. As i've mentioned in previous comments, i'm not trying to impress, just inform. It maybe obvious to you what is needed to go up in page rank, but it wasn't obvious to me, so i did some research and now here I am!

</comment></comment><comment><USER10> When I first started writing at my site, I got to PR 4 in about 6 months or so. And I didn't really check my score for about four months.

My strategy was really simple: produce good content, and the readers (and links) will come. Nothing more, nothing less (well ... maybe a few common- sense initial tweaks at the start, like readable-permalinks and Google- friendly sitemaps). So maybe this isn't the most efficient way of scoring a high PR, but I believe that good content is more valuable in the long run than a artificially boosted good position in a search engine.

<comment><AUTHOR> Good content drives good SEO, and good SEO drives people to your good content. It really is a chicken-and-egg scenario when it comes to search engine optimization. Ultimately is no way to artificially boost your position for long, and your content will have to drive visitors.

</comment></comment><comment><USER11> The site is also listed in dmoz.org (almost impossible to get included in these days)

The biggest part of "how he did it" was creating something people wanted to share and link too. The feature on killerstartups got him past PR2, which I haven't been able to do after a year on any of my sites. Then Shady Email got him to 4.

It was much less hard work than I was hoping, it was much more the development of a fun idea related to another previously successful site, Shady URL

<comment><AUTHOR> If you get your link included in a number of directories and that number is greater than the number of outgoing links you should be able to at least get up to PR3 without much difficulty. If not, use google webmaster to see if your site is being flagged for doing something wrong.

</comment></comment><comment><USER12> Richard, thank you for writing this up.

I have two questions and a minor bug report for you:

1) It seems you were tracking your Page Rank closely in this time period. Can you quantify the relationship between PR and actual rank or organic search traffic on your site? (I.e., do you know and can you share stats like "At PR N I had X organic search visitors per month"?). This will be obviously be different from site to site (as it depends on query frequency) but these would be interesting data to see.

2) I didn't take the time to watch the video, but you can briefly explain what WhySpamMe is? Is this essentially mailinator except with forwarding to your actual email address? (That's not a knock on WhySpamMe, I'm just trying to understand it. I actually think that's an interesting twist.)

3) Just FYI, I noticed that on an earlier post on your blog ([http://blog.whyspam.me/index.php/2010/02/13/whyspam-me- suppo...](http://blog.whyspam.me/index.php/2010/02/13/whyspam-me-supports- hati/)) you misspelled "Haiti" as "Hati" a couple of times. For that matter, I think "Unicef" should be "UNICEF" (all caps), as it is an acronym. That's the way they seem to spell it officially (although their logo is all lower case, so go figure.)

<comment><AUTHOR> 1) I'm planning another article later with some stats and some notes on usability (specifically about how adding the video you didn't watch lead to a huge increase in conversions).

2) I don't like comparing services to other services "the facebook of dog kennels!" but yes we act much like mailinator though we forward the emails to your actual email account. This is much more convenient IMHO and since the email accounts never expire you can use it for services you actually care about such as amazon.com etc.

What mailinator and the others don't do is keep track of which websites send you unsolicited spam, or sell your info. We keep track of this and publish it to <http://whyspam.me/websites>.

3) Thanks, there's a reason I became an engineer and not an english major ^_^ I'll fix the spelling as soon as i get a chance.

</comment></comment><comment><USER13> Anything less than a PR6 isn't really spectacular.

<comment><USER14> Agreed. My site went from 0-3 in about 6 months and I did absolutely nothing (and I mean _nothing_ , I just wanted to write so I haven't considered SEO even a little) except write some blog articles.

<comment><AUTHOR> Great, just a little more work and you can get PR4 with not much problem!

</comment></comment></comment><comment><USER15> I've never really paid attention to PR (although apparently my blog is sitting at 4 without trying anything, which is kind of neat), but I'd really like to see is a graph of Page Rank over time. Does such a service exist? I doubt it would be easy to do so for any arbitrary page, but even a way to add my site to it and check it occasionally (perhaps get email alerts when the status changes?) would be cool.

</comment><comment><USER16> "During March, i was featured in killerstartups.com, i saw a big spike in traffic, and resulted in a lot of 'me too' articles from other websites in other languages."

If you ever want a few dozen free visitors and some links, submit to KillerStartups - their ridiculous posting schedule means that they write about pretty much anything you submit, in my experience.

</comment><comment><USER17> I launched Penolo (a twitter app for sharing sketches: <http://penolo.com>) a little under 3 weeks ago; it's already PageRank 4 (if you can believe the checkers).

Didn't do any link-building, just happened.

I guess give people a reason to link to you: saves you a few months of effort.

<comment><USER17> I should point out, I linked to it from my personal site, which is a Pagerank 5, and probably didn't hurt... :)

<comment><AUTHOR> Wish i had some PR 5 sites under my belt.

<comment><USER18> My site, Feedback Army is PR5. I still don't get that much of my traffic from search engines.

<comment><AUTHOR> If that's the case use tools such as wordtracker's to see if the keywords that you're targeting get enough traffic. You could also be competing on some keywords where your competition has a higher PR. Or possibly the customers you want simply don't think to use search engines to find your type of service. What percentage of your traffic comes from search engines?

<comment><USER18> I've looked at Google's Keyword Tool and tried a bunch of different possibilities. There are certain keywords I'm targeting but despite my PR5 pagerank, I'm not at the top of the page on these yet. So it's a slow move forward. Still people continue to write about FBA so I expect this is a long term investment. As my site gets more quality links and longevitiy, I expect one day I may see more search traffic for the terms I'm targeting. Just not yet. A lot of the search traffic I get is people searching for feedback army by name. I take this as an encouraging sign about awareness of the product itself.

<comment><AUTHOR> I think that is good as well. Generally a large portion of my traffic is direct traffic. Most visitors when they discover my site have a need to generate a email address, but the next day or later that afternoon many will go directly to my url. I typically see a spike in users the day _after_ i see a spike in traffic. All this SEO stuff can certainly take a long time and not seem to be paying off, FBA seems like a great service that I would like to use in some upcoming usability reviews. Just hang keep up the good work, and one day you'll be #1

</comment></comment></comment></comment></comment></comment></comment><comment><USER19> <http://blog.kadavy-inc.com/> got on the front page of HN one time, and became PR4 almost instantly. I did link this blog _to_ my personal site, which is a PR4 - however, that site does not link back.

<comment><USER19> Well, so much for that. Now Google Chrome and Twitter both think my site serves malware. Anybody know what to do about this?

<comment><AUTHOR> where are you getting that from, check out [http://www.google.com/safebrowsing/diagnostic?site=http://bl...](http://www.google.com/safebrowsing/diagnostic?site=http://blog.kadavy- inc.com/)

google says everything is working ok

</comment></comment></comment><comment><USER20> If any SEOs are out there reading this, we're looking for a consult at my startup. Check profile.

<comment><USER21> What do you need help with exactly? Happy to help

</comment></comment><comment><USER22> How does he know his Page Rank score? I didn't know such values were made public.

<comment><USER23> It's not a secret at all. The Google Toolbar will tell you.

<http://toolbar.google.com/>

<comment><USER24> And while it's telling you the pagerank it's sending your entire browsing history* and then some back to google so the can store it in the google cave.

*probably minus https/intranet sites</comment></comment></comment>


Russian Cyber Hacks on U.S. Electoral System Far Wider Than Previously Known - <AUTHOR> https://www.bloomberg.com/news/articles/2017-06-13/russian-breach-of-39-states-threatens-future-u-s-elections <comment><USER3> The easiest way to fix this is also probably the most un-sexy way:

Eliminate the electronic aspect and go full manual records and tallying.

Essentially revert to a completely manual system.

Sure, no one would really like it. The logistics and storage needs would be immense. It would take a longer time to count the votes.

But if done right, it would mean a system secure from any electronic tampering.

Perhaps some of the records could be stored electronically - but all with a hard air-gap; I'm sure there would be a way to take some of the pain out of the system.

But even if not - even if it has to go back to completely manual, pen and paper, storage in massive warehouse of paper or whatnot - and all the pain that would entail - isn't it worth it to preserve what we have - <USER2> democratic and representative political government system?

I think many would agree with me; my fear is that far more would rather have convenience and shiny tools, and don't give a damn about possible security issues. Far more than that just don't care at all (which is endemic to the whole process, but is a wholly separate discussion of course).

</comment><comment><USER4> There was this company I know who rigged their shareholders elections routinely. If an ordinary company can do it, nation states definitely can. And if they can rig their own elections, they certainly could try to tamper with the elections of other nations.

The need for elections is representative democracy's big weak link.

</comment><comment><USER5> The main question is: did Russian hack the DNC server to leak the emails?

</comment><comment><USER6> and facts from politicians

</comment><comment><USER7> Didn't Obama and Comey say that U.S. elections are unhackable? Were they lying?

<comment><USER8> No they did not, at least not in the context of this story.

At the time, the story was Trump's fallacious claims that there was widespread voting fraud and tampering with voting machines. The implication was that there were millions of illegitimate votes for his opponent. There was no justification for his view that it was possible, or even if it was, that all fraud would favor the Dems.

The context of this hacking is mostly of voter databases. This information can be used for propaganda campaigns, and other kinds of targeted attacks that suppress voter turnout, intimidate, and sew distrust in the system.

<comment><USER9> > the story was Trump's fallacious claims that there was widespread voting > fraud

Well he wasn't completely wrong there:

[https://apnews.com/6b71a926cb624a209851b41ac616b184](https://apnews.com/6b71a926cb624a209851b41ac616b184)

<comment><USER8> I believe he claimed that there was something like 2-3 million fraudulent votes. Yes, he was completely wrong.</comment></comment></comment></comment>


Apple is removing App Store games that show the Confederate flag - <AUTHOR> https://games.yahoo.com/news/apple-removing-app-store-games-140619696.html

<comment><USER2> See existing discussion: [https://news.ycombinator.com/item?id=9777854](https://news.ycombinator.com/item?id=9777854)</comment>


US$16M Canadian 'farmhouse' is last hurrah for a wild real estate bonanza - <AUTHOR> https://www.scmp.com/news/china/society/article/3094466/gargantuan-us16-million-canadian-farmhouse-last-hurrah-wild-real <comment><USER2> Everything about this is nuts. What a contrast. Opulent mansions even for Los Angeles, right in the middle of old school, hard working rural communities. All to escape the taxman...

<comment><USER3> And, perhaps more significantly, to launder money.</comment></comment>