skysight-inc/HackerNews huggingface dataset:
You still have:

Earth -> LEO

LEO -> Asteroid transfer orbit (ATO)

ATO -> asteroid capture orbit (ACO)

ACO -> landing

Takeoff -> Earth transfer orbit (ETO)

ETO -> Earth Capture Orbit (ECO)

ECO Earth de-orbit burn(s)

Your delta-v for return may be low (60 m/s), though most are higher (see below), but that relies on finding near-earth asteroids with favorable mineral characteristics. You can reduce the mass you're returning _if_ you can refine or reduce it on-site, but that requires additional mass to be transferred out.

Orbital mechanics are far from my forte, but none of this comes cheap, and you're still stuck with costs in the order of $5,000 - $10,000 / kg for Earth to LEO. Which includes the mass of your vehicle, its fuel, and any mining equipment your lugging around.

https://en.wikipedia.org/wiki/Delta-v_budget#Near_earth_obje...

A catalog of 11,834 NEOs as of yesterday maintained by NASA / JPL shows a minimum delta-v of 3.8 km/s and a high of 26 km/s. Mean is 7.97 km/s, median is 7.1 km/s.

http://echo.jpl.nasa.gov/~lance/delta_v/delta_v.rendezvous.h...

This isn't a matter of fixed startup costs. Every fucking mission incurs the transfer fuel costs.
My brief survey suggests that their training sample did not include very much hardcore pornography.

"a man and a girl are learning to play with a small pool", while poetic, is a stretch in this case.
Python natively supports this sort of list comprehension (https://docs.python.org/2/tutorial/datastructures.html#list-...), and the Lisp source is being translated into a Python AST, so that snippet is probably being directly mapped into whatever AST form is necessary to invoke the list comprehension.
if you searched for uses of stl, you'd be is appointed because everything is reimplemented as TArray, TPair, TMap, etc.

In case anyone else is wondering "why didn't they just use STL?", here's an answer from an Unreal employee: https://answers.unrealengine.com/questions/2695/rocket-and-t...
I can agree that it is a matter of taste and different people will want different things. The problem is that 99% of us have no say. For me personally open plan is hell. I am mentally drained by the constant distraction by lunch. I have a really hard time sitting down to focus deeply on a problem because my subconscious has been conditioned to expect interruption. It's worse than trying to work in the same room as my kids playing.

I can disagree reasonably, but what good does that actually do me? Do I talk to my manager about it? He agrees but has no control over the layout. The upper-level management? They don't agree and don't care. Find a new job that's not open-plan? I already did, and then my team got all moved into one big conference room.

This isn't good for my mental health or productivity. But its what most companies do so I'm stuck.
Let me call bullshit on your comment: http://www.forbes.com/sites/jamesconca/2012/06/10/energys-de...
What Google Would Look Like with a Material Design Revamp
VetiGel: Band-Aid of the Future Stops Bleeding Instantly [video]
Even leaving aside the reliability issue (which can be chalked up to the fact that this one is a demo of a non-commercial project that got overloaded), you're comparing two entirely different things.

Check out the "static demo" pages, e.g. http://www.cs.toronto.edu/~nitish/nips2014demo/results/79133...

For this image, the University of Toronto software generates sentences like "a cow is standing in the grass by a car", whereas Rekognition only produces a ranked list of categories. ("sports_car", "car_wheel", etc.)

EDIT: this is an even better example: http://www.cs.toronto.edu/~nitish/nips2014demo/results/89407... I'm cherry-picking the cases where the algorithm does well, of course. But even if it's unreliable, the fact that this works at all is impressive.
> Bitcoin. Ubiquitous news reporting (death of newspapers). Privatized space industry. Twitter. Netflix. Gene sequencing for pennies. Working from home. 3D printing.
Its easy to list whole categories of innovation, and say "Anything else?" Aren't those enough?

What qualitatively new capability Bitcoin gives me? What's Twitter? Online movies? Well, yes! It does not improve our lives radically but still.

> Privatized space industry.

You get the point here. Nice!

> Gene sequencing for pennies.

We need faster/wider adoption of it. Article mentions it. Right now I cannot benefit from it in everyday hospital.

> Working from home.

Was possible before. Only quantitative improvement. Although awesome.

> 3D printing

Is a good counter-example. It's been around for years. And still I didn't hear about someone who uses it on a daily basis to improve their lives. Amazing applications in medicine is the only exclusion so far. Expensive industrial 3D-printers for prototyping etc. are well expensive and not wide-spread.
Thanks! Can't believe I didn't think of that :/

What's the distinction between C-c C-space and C-c C-r? It looks like the former computes proof obligations for ?s, but what does the latter do? And why couldn't we use the latter in the first instance, to deduce the outermost STEP ? ?

Edit: never mind, that did work.
You can create a list comprehension using a macro. In common lisp, lisp comprehension is implemented by the loop macro.
http://www.gigamonkeys.com/book/loop-for-black-belts.html

It is a little more involved, but basically you define a syntax for list comprehension and then parse it using the macro to generate the final result.
While I'm generally pro-solar, more workers is not an inherent good with an energy source... quite the opposite. The idea of energy is to require as few workers as possible so that human attention and labor can be spent on other things.

This is likely directly related to the fact that coal has a higher EROEI than solar (neglecting long-term externalities of course).
The Chairs of Ancient China: The Evolution from Floor-Level Seating
Personally, I'd expect that caching the output of a pair of power stations in my clothing would dramatically shorten my life expectancy.
I don't disagree with anything you've said, it is important that the job is fulfiling for both introverts and extroverts and that's a very difficult balance to strike.

It's important to point out though that if you make asking questions too easy for new employees, they can end up leaning on that as a crutch instead of developing the troubleshooting skills necessary to solve problems independently.

I've been on both sides of this fence. I've been that new colleague hunting for info that isn't clearly documented, and I've also been the senior colleague who was the go-to person whenever a problem came up that didn't have an immediately-clear answer. I was lucky in that shortly after I started my only senior resigned leaving me with nobody to ask, which forced me to get good at that kind of troubleshooting.

It makes me wonder if new colleagues should be given a time period for when they are allowed to ask any question no matter how stupid. After that time, they can of course still ask questions but it's expected that they try to find an answer before asking. Along the same lines of pair-programming for colleagues who have been here less than 1 year.
This article isn't great. The data is from Sony. I guess if fusion is a news site they need to 'confirm'. But it's impossible for the data to be anything else. I've never seen one faked spread sheet, let alone millions.

The leaked data so far is in a 35 gig multipart rar. The list of files only(No directories or metadata) is 400meg -> 1 gig uncompressed. Both are on PB.

The NK angle seems to be there was Korean comments in the malware. But there's also a theory it was insiders angry about the restructure.

The hackers were using the Sony PlayStation network to seed these latest torrents. IE they still had some control days later.

This sort of thing is pretty hard to stop. Security kills productivity, you won't be rewarded for lowing output with no proof you didn't anything useful, that's the nature of the issue.

Limits on stolen data in the old days was more about getting it out, not security. With the huge pipes in and out these days this will become more common. The only thing stopping people doing this everywhere currently is they can't be bothered.

[edit] This is also a good lesson on why you should never put anything in writing you don't want everyone to know.
Arc is just the language the forum was written in yeah? Is the forum system itself open source?
And at $100k, there would be a lot fewer people taking the jail-and-silence risk.
I like using Fossil for my personal projects. I don't always use every feature, but it's all very small and self-contained and I can just copy the executable into the project root without having to worry about the system environment.
> The whole business about having to waste an hour to get back into the zone after an interruption is, frankly, total BS.

there's your opinion and then there's science which actually goes out and sees how the real world works (http://en.wikipedia.org/wiki/Interruption_science)
Vanguard target date retirement fund. Auto-invest set and forget. Maybe once I have more I'll do a 3-fund portfolio to reduce the expenses a bit. Returns should generally track the market, pretty much hold until retirement.
The Humongous 'nfu' Survival Guide
Discussion of that time: https://news.ycombinator.com/item?id=2167875 (511 points, 1401 days ago, 196 comments)
CAM MORON MUST GO, ON TWITER
Ask HN: Working at digital agency company vs. startup
I've been working at the start-up for little more than three years after graduating. And had a question what would be the life in working at digital agency.
If I work at the digital agency, will I be learning less than working at start-up?
> counted 142,698 employees

There are about three times that many people employed growing corn, however. So should we switch all our power plants to corn based ethanol?
That's like flying because you like airline food. No one flies if they don't have a destination. No one will put a captcha on their site if it doesn't tell computers and humans apart; that's its primary job.
Yes thats correct.
https://github.com/hylang/hy/blob/dcf29d3d2a147fe66a19971214...
Source for those interested. Note that Hy replaces all - in names for _, thus we can have prettier names :)
Thanks for the very straightforward explanation of how strongly typed functional programs can have effects in the real world.

(forgive mistakes; I've never used function pointers in C)

You mostly got it right; the function declaration would look like this (I moved the * for pointers onto the parameter name for stylistic reasons related to how C declares types):

void main(op *instruction, int *length, void (*callback)(...))

Also, your function pointer calls should omit the * in front (it would be applied to the return value of the callback, which is void in this case, so you'd get an error during compilation).
On the off chance the creator is here, explaining what Watsi is, even if only in a few words, would be very helpful. I'd never heard of Watsi before. I had to click on the 'stories' link and then click on the Watsi homepage to find out.

Additionally, finding out what's in the bundle is similarly counter-intuitive. The 'Explore All Assets' link showed two separate popups that seemed like it was required to pay or at least register just to see a list of what I'd actually get.
So you sort of write stuff that defines your language as a 'macro' (and it looks like the rest of the lisp?) and it executes on your code first to transform it?
"Real" List Comprehensions in 24 Lines of Lisp[0]

[0]: http://lisp-univ-etc.blogspot.com/2013/01/real-list-comprehe...
Sorry, I'll get off your lawn now.
For the units thing, you might want to take a look at http://mathematica.stackexchange.com/questions/15338/simpler...

Also I have this in my init.m:
Unprotect[WolframAlpha];
ClearAll[WolframAlpha];
WolframAlpha[x__] := Null;
Protect[WolframAlpha];
I think I would generally agree with what you said here.

I'm curious if you've succeeded in finding an office environment that would let you work that way ?

Unless you're working from home most of the time, it seems like "the management" would generally not be too keen to this.
Giraffes in danger of quietly going extinct
SuperDuino Is a Tiny Arduino Board with a Built-in Touchscreen
HN for woodworkers: www.woodspotting.com
Yes, thats where the power of lisp is.
Say we want to implement do/while. In Python you would have to go into the compiler. In a Lisp, like Hy. We can just write it as a macro.

We implement yield-from on Python2 using a macro.
http://dustycloud.org/blog/how-hy-backported-yield-from-to-p...
Yes that's exactly what's happening. Hy has two levels of things mostly: a "compiler" that does the low-level mapping of base python constructs (and whatever can be mapped to AST)... here's where list-comp is implemented: https://github.com/hylang/hy/blob/master/hy/compiler.py#L137...

Anything above that is written as Hy macros, in Hy itself: https://github.com/hylang/hy/blob/master/hy/core/macros.hy

There's a lot of other core code that's written in Hy itself too. https://github.com/hylang/hy/tree/master/hy/core
CVS receipt redesign
There are a couple of things that I would like to point out about digital sampling.

Early on in digital audio, anti-aliasing filters were awful. The ADCs weren't very good either, but the AA filters were bad. Using a higher sampling frequency was one method to help this problem by providing more padding in the frequency domain so that a more gradual AA filter could be used.

Later, this was completely OBE with the advent of oversampling. Most ADCs in use now are oversampling delta-sigma converters operating a very high sampling rates that perform decimation on the output to provide a 16 or 24 bit waveform at the normal 44.1kHz or 48kHz sampling rate. Delta-sigma converters, and high sampling frequencies are actually the basis for Sony's direct stream digital (AKA Super Audio CD).

Today, you can be reasonably assured that an ADC will provide a very clean, low noise, noise output in the vast majority of cases. For music playback, this never mattered anyway. Whether or not the transport of digital audio is at 44.1 kHz or 1 MHz, the quality to the human ear will be the same as long as it was sampled correctly and accurately.

That said - sampling at 44.1 kHz, 48 kHz, or even oversampling, may not capture all that sound has to offer our ears. One thing that can happen with music for instance is beating. Beating occurs when two notes are sounded at slightly different frequencies (say 20,000 Hz and 20,100 Hz) there will be an audible beat at their difference. Where this can come into play is in close mic recordings. If I record guitar A) with an overtone at 30,000 Hz and guitar B) with an overtone at 30,100 Hz, these two would have an audible 100 Hz beat. However, if we filtered and sampled at 48,000 Hz or over-sampled then filtered, we would lose both overtones and the ability to hear that beating.

How important is that beating? Good question - but with live music it's not a problem and with close mic recordings it is. For recording, there are reasons to use higher sampling rates for at least the mixdown process. I still think it's silly to have 192 kHz audio for listening to recordings at home.

Bit depth on the other hand is something I think we could use more of - especially with classical recordings. Audio quantized to 16 bits only provides about 96 dB of SNR. I would much prefer having 20 or 24 bit audio to fully encompass the actual range of human hearing that is closer to 120 dB.

The other thing that cannot go without mentioning, MP3s, AAC, and other lossy audio formats are pretty good - but they DO NOT compare to lossless audio. Having Google, Apple, and Amazon all step up to 44.1 kHz 16-bit audio sourced from equal or greater source material would be huge improvement over MP3s and AAC.
> they could've used celestial navigation systems/star trackers

Well, that implies they have the expertise to do so. Using a GPS is orders of magnitude easier.
What about Clojure seems dense or implicit to you? Clojure and Python have a similar feel to me. Both are well-designed in the sense they strive for a small set of primitives useful in solving a broad range of problems.
And also why he stopped using it when it hosed his repo:

http://www.mail-archive.com/fossil-users@lists.fossil-scm.or...
AT&T's tantrum, Apple's stumble, and Shazam puts the “D” in BDD
Though see also: https://web.archive.org/web/20111008041308/http://sheddingbi...
http://www.deathbycaptcha.com/

http://www.captchasniper.com/

http://captcha-breaker.gsa-online.de/

http://textcaptcha.com/
*taught :\
SoftBank Invests $250M in GrabTaxi, Uber’s Archrival in Southeast Asia
I think it would come down to the people you work with and the companies themselves. In some ways you're comparing apples to oranges.
Is this something that can be integrated easily with existing Python code? I'd be interested in implementing a small module in Hy, rather than Python, and then include/use/consume it from Python.

All the uses I saw listed on the blog were as a replacement for Python, it seemed like, so this might be a direction of integration that wasn't intended.

edit: Perhaps I should read more and ask less. It looks like this is what `import_file_to_module` does, right? :-)
A note that screen real estate and attention here pertains mostly to paid impressions - be they advertisements or politicizing messages. When it comes to content sought by the user, it's hard to say that the user is giving the service provider real estate and attention. It is only when the service provider is showing content not for the benefit of the consumer but for their own self that the attention and real estate can be thought of as 'rented' to them.

I would agree with the assertion that there are practically no free websites on the web. Since when did we convince ourselves we can get things for free?

There are major exceptions. Wikipedia is for the most part free. It does not advertise to you, nor does it siphon and sell your data. It does not track you around the web, it does not sell your Wikipedia viewing behavior to urchin for cents. It is driven by donations.

HN also appears legitimately free to me. As far as I know YCombinator does not mine or sell your data or collect data other that what is required for the forum to be a forum. YCombinator makes its money by other means. It certainly benefits by cultivating a technical online community, which is why I think it does it - though what influence YC can/does project on the community could be thought of as a social cost (I know very little to nil about whether or how much this is done).

Google, however, is not one of these cases. Nor is most of the web.

I'm not sure if the original point still makes sense with 'non paid' (nor am I sure 'non paid' is right). The original point uses 'free' (in caps) to emphasize a sense of charity they use to inform their 'entitled' argument. First, their argument is essentially 'What you expect this to be free? You are entitled!' Second, I'm not sure that replacing the term will work, unless it also communicates charity.

The point here is that the exchange does not constitute charity. Google thinks the trade is a very good deal. Presumably internet surfers do too. But there is an exchange and that needs to be recognized.

Anyway this means that any term that communicates 'charity' will be ignorant of the conditions of how Google's service works - and I would have posted the same misgivings.
Star trackers are available off the shelf, and aren't export restricted. They're essentially precision CCDs with on-board logic.

Disclaimer: I am a geo/navi/celestial positioning nerd.
Macros (the general Lisp concept) are really interesting. I'm still trying to grok them myself, so if I made any mistakes please downvote and correct away.

A normal Lisp function call might look like this:

(myfunc arg1 arg2 arg3)

where arg1, etc can be literals, variables, expressions. Like in most programming languages, each of the arguments is evaluated and then the function is called with the evaluated values of those arguments. When it's done, a value is returned.

A macro is a lot like a function call:

(mymacro arg1 arg2 arg3)

However, it works differently. First of all, the arguments are passed straight into the macro - if arg1 is something like (+ 1 2), the macro will see (+ 1 2), not 3 (as the function would).

Secondly, the macro is intended to return a list, which can be a function call or another macro call. (The macro could also return a final value.) The list can then be evaluated to either expand another macro, or to call a function to produce a final value. So you can think of a macro as a special sort of function that, rather than taking in values to produce another value, takes in literal code to produce transformed code (which then can be evaluated to produce a final value).

Now, one of the uses of macros that people cite is, for example, implementing your own control flow structures. Why are the two related? Lisps have something which are known as special forms, which look like function calls but don't have their arguments evaluated before being passed in (like how macros work). The reason that matters can be described by a simple example: let's say you wanted to implement a very simple version of 'and' as a function (Clojure syntax):

(defn my-and [left-expr right-expr] (if (not left-expr) false (if (not right-expr) false) true))

However, the problem is that left-expr and right-expr will both be evaluated before my-and can even begin executing, along with the attendant side effects, etc. The problem is that functions can't choose whether or not their arguments should or shouldn't be evaluated - they just get the values of their arguments after they've been evaluated[1]. It's not really possible to implement the traditional short-circuiting 'and' using functions, or many control flow structures where you do not want to evaluate every possible branch unconditionally.

However, macros receive the literal code comprising their arguments, and they can choose to evaluate one, none, some, or all of their arguments depending on their internal logic. This makes them better suited for implementing behavior that resembles those of the Lisp special forms.

[1] This is the difference between call-by-name and call-by-value semantics. Most languages are call-by-value, as described above, but (e.g.) Scala has '=>' and Swift has '@autoclosure' to allow for some sort of call-by-name support.
Unblocking the Network Effect
Storing data on the blockchain
> The von-Neumann level nature of the machine really doesn't enter into it, though.

It does enter when you try to execute the code; which is a translation from declarative to imperative (assembly).

> To extend your analogy to the absurd, it doesn't make sense to write your program out symbolically in a programming language, because at the end of the day it is electrical values in a processor.

Care to tell me one single example of a declarative computer?

I'm more of a hardware engineer than a programmer, and I can't think of any universal logical circuit with memory that is not imperative. Even at the transistor layer, everything is imperative. This includes gate-model quantum computers and biological computers.
There are some analog models that work for specific problems, but there certainly are nowhere near being declarative.

And the point was, at the high level, declarative -> imperative translation (which is done by a compiler) will typically be worse that an imperative -> imperative translation.

This is why a very written compute kernels in C outperforms its, say, Haskell equivalent, typically by orders.
It's also the reason why scientific computation, signal processing, transcoding software etc. (when raw CPU performance outweighs everything) is typically written in Fortran/C/C++ with a mixture of assembly.

The reason is simple; they map to the underlying hardware well. It is also the reason why assembly languages are imperative.