skysight-inc/HackerNews huggingface dataset:
> I think what is reasonable to say is that while we are all created equal in the sense that we are human, that's far as as natural equality extends. Some of us are taller, shorter, we have different interests, etc.

Your observation that "humans aren't all the same" is orthogonal to the ideal that humans should be treated equally despite their physical characteristics which are outside of their control. I cannot control what gender, sexual orientation, or ethnicity I'm born as, and you should not assume anything about my abilities based on those characteristics.

Good and bad are things we decide together because we're stuck living together; that's what society is. Equality is something a lot of us decide is good. It's not "natural" but that doesn't make it bad. I think it's good to aspire for a more equitable society.

Racism is bad exactly because it assumes things about people based on a physical characteristic outside of their control (skin color). That concept is general.

> > Or should government (a set of formalized rules and people who enforce them) attempt to equalize the playing field, and thus treat us all unequally?

Equalizing the playing field does not "treat us all unequally." That's the point of equalizing. A government trying to equalize the playing field is a government that acknowledges the playing field is already unfair. If you're born rich you are already advantaged. If you're born white you're already advantaged. Government is within its rights to say "oh shit 1% of the citizens who participate in this system have disproportionate power compared to the vast majority; we should equalize it so everyone can have a better life." << This is what a progressive income tax is for.

> In your own example, by ensuring in your model safety for women, we must treat men differently from women, and therefore ensure that for women to be safer, men must be less free.

Wrong. By ensuring model safety for women, we must hold them to the same standards that we hold women to. Both women and men who harass people should be ostracized. Historically only women had to bear the burden of "how do I come across" because of men. Today men should equally bear the same burden and be responsible for how their words and actions make others feel.

Men aren't "less free" in this model, they just have to be "more responsible." A level of responsibility women have already been forced to have. E.g why is it that women have to watch what they wear? Feminists aspire to a world where men should not assault or harass women, regardless of what they wear. We should all be equally responsible for our own behavior.

> government is at least in theory a set of formalized rules intended to reflect what the informal rules of society are

Agreed, this is a fact. Which is exactly why people who seek equality lobby government to update laws, to reflect our evolved societal norms. Laws should protect LGBTQ from discimination in the workplace for example, and help bridge the pay gap for women in the workplace. Laws were responsible for first freeing slaves in the US and then ensuring equal rights.
So, I probably shouldn't have been surprised, considering it's HN, but the number of people who reached out to me on this was surprising and touching. I think I've responded to everyone directly, my apologies if I missed you.

I'm glad to report that, since last I'd spoken to them about the problem, they've figured out what to do and consider the matter solved. The material is recovered, recatalogued, and in good order.

Thanks again everyone for the concern, interest, and offers! I know where to come if something like this comes up again!
In Haskell it certainly is a closed definition, you would get a "multiple declarations" syntax error if you tried to split the definition up. I would assume the same for Clean also.

In the Haskell REPL, you would need to enter the definitions together.
The problem is the assumption of a "simple RPC" protocol... there is no such thing. There are network issues, proxy errors, and two-sided race conditions that complicate any network related code. Network programming is distributed programming, which is not easy. RPC protocols try to mask that difficulty, but more often than not they sweep it under the rug.

RPCs make it easy to get started on a dev machine. making network calls appear like function calls definitely speeds things up when the network is working perfectly, but it papers over the complexities of debugging network issues and complex distributed race conditions, which will inevitably come up later.

Being explicit with network communication has its benefits.

(corollary: for the same reason as above, I don't like lazy evaluation of database queries that exist in many languages. When you hit a database, it should be intentional, you should know about it, and should properly prepare for any necessary network issues, caching, and cursors. Many modern web frameworks gloss over this).
You mean, making comments like this one?

> Bullshit. Whingeing shitheads that never contribute where it counts. Coinbase has done fuck all to contribute to bitcoin development except be cheerleaders for every asshole fail train driver who has tried to destroy it. If they gave a shit they would have contributed to lightning development.

http://archive.is/qUkIr

The emperor has no clothes.
Utilities across the country are changing how they handle net metering (buying back at the wholesale instead of retail rate). It greatly changes the payback on these solar installations... I’m guessing that has more to do with any slowdown than Tesla’s management. Not to mention that the low hanging fruit may already be largely picked.
If the blocksize was increased to double its current resource requirements, where i live in Australia, it would be impossible to run a node at any price.

And because the people who run nodes know this, they reject your proposals that reduce bitcoin network security.
I think there’s something even more fundamental.

The article talks about how to communicate between systems. But many systems don’t need to be distributed.

If you can avoid writing a distributed system, that’s easier than even a “better REST”, if such a thing were to exist.

For example, old-style non-SPA web applications, can directly use underlying logic classes directly, can throw exceptions, need not serialize data, one connection to the DB with one transaction capable of rollback, and so on.

Or monolithic servers rather than microservices.

Sometimes you need RPC, but for those situations where you don’t, avoiding RPC completely is a significant reduction in complexity.
The proper REST API should be specified as the set of domain-specific document formats (media-types) and have a custom browser as a client. Turns out, we already have HTML and web-browsers, so there is little point in actually building such APIs. It's always more appropriate to build a website instead. On other hand, what usually called 'REST' is nothing else but RPC where 'procedure call' = 'http method + url'. There is nothing wrong with that (with the exception of the name), but trying to satisfy any REST/HATEOAS constraints on top of RPC foundation seems difficult and pointless.
You don't even need that. I don't think there is anything wrong with returning a 200 response with a JSON body that has some 'error' tag built into it. It may not be purely RESTful, but if it's obvious to the developer interacting with the API, who cares.
No need for the ad hom.
REST can be as simple as you want it to as verbose and rigid as you want it. Defining an API has certain public expectations such as request/response and basic HTTP status codes, but again can be easy or more detailed. There are RESTafarian and pragmatic ways to implement REST APIs.

Much of the problem of any tech becomes that engineers/developers are supposed to make complex things simple but instead sometimes make simple things more complex because it seems smarter. Complexity is needed only enough to make it simple to interface with and consume. REST is an example of web services done right and more simple compared to SOAP which was supposed to be the Simple Object Access Protocol but they forgot the simple part and just kept adding layers.

APIs should be easy to work with and as non changing as possible in the public signatures and routes/data/configs or else versioning should come in on major changes which should be handled wisely. Sometimes that is RESTafarian or pragmatic, sometimes more HTTPRPC, sometimes that means schemas for consumption, sometimes pretty urls, sometimes ids and name blurbs, sometimes responses wrapped in app messages/wrappers, sometimes directly on HTTP(s) response bodies, and it all depends on if it is public or private and if you control both endpoints, the clients and business needs.
Show HN: Neural Style Transfer with Caffe2 on Your Android Phone
FWIW sales of packets of ten were banned in the UK earlier this year, to deter youngsters from buying cigarettes.
The good deals on fibre in Vancouver come from companies like Novus[1] that only serve the downtown core. Most of the city is stuck with Telus and Shaw.

[1] http://www.novusnow.ca/internet/
Oh my gosh this is amazing, such a labor of love. Everyone clearly needs a reverse engineered disassembler on their wrist.
Thank you for sharing this! It's nice to see Prolog used for such tasks, which are a good fit for a logic programming language.

I have one small suggestion that I hope you find useful: Currently, the code is rather imperative: It contains lots of side-effects that have immediate consequences which cannot be easily reasoned about. You can use Prolog this way. However, you forfeit its most interesting advantages if you use it as an imperative language instead of a declarative one.

A major attraction of Prolog is that it allows you to declaratively describe what holds. Therefore, I recommend to aim for declarative descriptions of situations, and limit side-effects to a few isolated areas of your program.

Here is an example: In brexit.pl, you currently have the following:

notice_persons_at(Place) :-
person_at(X, Place),
write('Apparently '),
write(X),
writeln(' is here, that is your'),
writeln('chance for a quick chat. Type "\e[1mtalk.\e[0m" to start'),
writeln('start the conversation').

Consider formulating this declaratively, for example as follows:

notice_persons_at(Place) -->
{ person_at(X, Place) },
['Apparently ',X,' is here, that is your ',
'chance for a quick chat. Type ', bold(talk), 'to start',
' the conversation'].

I am using a Prolog definite clause grammar (DCG) to describe the output that is expected to occur at this place. Since I am decoupling this description from the actual side-effect of emitting the output, I have won a lot of convenience, flexibility and versatility. You see that this description is shorter and can be used not only for actually emitting the output, but also to easily test whether the program (still) behaves as intended.

In addition, it allows you to later switch to a different way of outputting this text altogether. For example, at one point, you may want to convert this into a web-based application: In that case, the output should no longer be emitted on the system terminal, but sent as HTML snippets to the client.

Thus, I recommend to first focus on a clear declarative description of everything that should occur in your program, formulated as a DCG or via a domain-specific language you may want to design for this specific task of implementing a text-based game. Later, you can flexibly interpret this language in any way you want!

The same goes for the uses of assert/1 and rectract/1 that are currently sprinkled through your code: This imperative style prevents you from using the predicates in all directions. If you use a more declarative formulation, you will be able to use the code in much more flexible ways. A declarative way to express state changes is to think in terms of relations between states. Think about it this way: There is an initial state, and a user's actions relate any given state to a new state. Thus, state changes can be modeled as relations between states, and you will be able to use such predicates in reverse and also in the most general way!
These are just some of the abuses that the FCC has interfered with and circumvented in the past.

As you say, all fixed without needing net neutrality.
Switching to Disqus will hardly increase the appeal for most of the same people that dislike FB. See for example these stats on Disqus: http://donw.io/post/github-comments/
Are you actually quoting reddit on yc? Thus demonstrating that reddit vote brigading is occurring on yc?
Keeper: privileged ui injected into pages (again)
I just recently read a bit about different ways that human understand and I think there is an interesting point you can make in this 'us vs them' in relation to this. I'm still digesting it but it's a very interesting view of the mind.

I will try to keep this short, so bare with the simplifications. The idea is that humans understand in many different types of ways and they are connected/overlapped. These ways are: mythic, romantic, philosophic, ironic and somatic. Mythic understanding comes out of oral culture and brings along with it narrative, fantasy, metaphors, binary structuring, etc. Romantic understanding came out of literacy and brings romantic rationality, humanized knowledge, transcendence within reality, etc. Ironic understanding brings self-reflection, and so on. One type of understanding is not better/worse than the other, they are important in different ways. For those who are interested, check out "The Educated Mind" by Kiearn Egan.

So, us-vs-them comes out of a mythic understanding of the world. The gut reaction is often to reject the source from which the bad behaviour comes from completely. But mythic understanding and it's binary structuring (along with fantasy, metaphors, abstract thinking) is crucial for human sense-making. So I don't think we should suppress mythic understanding and all that comes along with it, we need to have a balance between these different ways of understanding. Just imagine how many great things invented started as fantasy and strange metaphors in someones head!

That's the epistemological view of it, then you have the political one, that's a totally different beast and so I will end my comment here.
I'm seconding this. I could not find a good resource to understand what "attention" actually _is_.

(The next step for me would be to follow the citation trail to the original paper, but that might not be the best place to come to an understanding of the thing.)
Being Scandinavian I think I can safely say that I haven't put too much credence into what Americans pass for news. :)

I have studied history and economics though, and typically you wouldn't want inequality to grow too far unless you want a violent redistribution of wealth. Considering America was already collectively crazy enough to elect Trump, I'd hate to see what happens when things get even worse.
Abstract:

The dominant sequence transduction models are based on complex recurrent or
convolutional neural networks that include an encoder and a decoder. The best
performing models also connect the encoder and decoder through an attention
mechanism. We propose a new simple network architecture, the Transformer,
based solely on attention mechanisms, dispensing with recurrence and convolutions
entirely. Experiments on two machine translation tasks show these models to
be superior in quality while being more parallelizable and requiring significantly
less time to train. Our model achieves 28.4 BLEU on the WMT 2014 English-
to-German translation task, improving over the existing best results, including
ensembles, by over 2 BLEU. On the WMT 2014 English-to-French translation task,
our model establishes a new single-model state-of-the-art BLEU score of 41.0 after
training for 3.5 days on eight GPUs, a small fraction of the training costs of the
best models from the literature.
Don't agree at all. There is a huge difference between calling a function "foo()" that makes an RPC call and the relatively equivalent REST call "http.GET('/foo')". The former feels like a function call, and callers will assume it operates like one. However, in reality the former is not a function, it's making a network call, and it's incredibly unreliable.

In theory, the latter does the same thing, but it's far more explicit, the developer knows it relies on the network and accordingly that it may fail. Developers will be more inclined to plan for errors when the possibility of such errors are more obvious.
I think there’s a tendency in software for people to start out without understanding all the complexities they’re going to encounter. I think this is just human nature.

When you start out doing RPC you think, I don’t want to bother with schemas, I don’t want to bother with hierarchical error codes, I don’t foresee the need to set the user’s password but not retrieve it. So you don’t want to bother with a technology which makes your life more difficult, to solve problems you don’t have and cannot foresee.

So you choose something simple. But you run into all these problems anyway, because they exist, no matter if you were capable of foreseeing them or not.

But by then it’s too late. You’ve written 50 KLOC and you just have to keep going.

I believe this is why many technologies become popular which are actually too simple to handle the types of problems they try to solve.

I blogged about this concept here: https://www.databasesandlife.com/the-cycle-of-programming-la...
It shows that multiple attention heads can replace CNN's and RNN's, creating a powerful new paradigm for neural nets.
Interesting link! I was thinking more from a privacy point. Easier to create a fake-Disqus account. :D
Spending precious time reading corporate propaganda disguised as objective scientific evaluation is also not helping.

The truth is that Facebook has exploited something in our human psychology that was never available before. It fucks up with our heads in a way we can't even recognize because we don't really have "bad mental state" receptors wired in.

I want to be lenient on Zuckerberg and his fellows: they created a Leviathan that started making more money they could ever imagine. Now they're captive in a system that for no reason whatsoever would let them scale back such monstrosity. It's not on them anymore.
> Visa currently processes about 3,674 transactions per second

weird I assumed it was more. It's still 300M a day or 100bn/yr but still.
> Are you actually quoting reddit on yc?

No, I am quoting you, not reddit. Reddit didn't write that comment.

> Thus demonstrating that reddit vote brigading is occurring on yc?

That doesn't follow, at all.
I don't know what "literary fiction" is, exactly. I suspect that, for the most part, it's been a status symbol. Back in the day, one needed copies of the latest stuff on tables and shelves. But on Facebook, one can fake it, based on Goodreads etc. No dead trees needed.
I suggest you apply the latest microcode update, seeing that you have LSD_UOPS being dispatched

I haven't been following that bug closely, but I think I'm OK on this machine since hyperthreading is turned off? This a a benchmarking machine, so I have to be careful about making changes that will affect historical results.

the general principle of stalling the frontend to prevent the backend being overloaded still holds

I think I agree that this is what is happening. Why it's necessary, and the exact mechanism by which it helps are places that I'm uncertain about. I presume you are seeing the instructions showing up as IDQ_MITE_UOPS?

From https://www.intel.com/content/www/us/en/architecture-and-tec... Section 2.3.2.2, here's some more limitations of the Decoded ICache:

The Decoded ICache consists of 32 sets. Each set contains
eight Ways. Each Way can hold up to six micro-ops. The
Decoded ICache can ideally hold up to 1536 micro-ops.
The following are some of the rules how the Decoded ICache
is filled with micro-ops:
• All micro-ops in a Way represent instructions which are
statically contiguous in the code and have their EIPs
within the same aligned 32-byte region.
• Up to three Ways may be dedicated to the same 32-byte
aligned chunk, allowing a total of 18 micro-ops to be
cached per 32-byte region of the original IA program.
• A multi micro-op instruction cannot be split across Ways.
• Up to two branches are allowed per Way.
• An instruction which turns on the MSROM consumes
an entire Way.
• A non-conditional branch is the last micro-op in a Way.
• Micro-fused micro-ops (load+op and stores) are kept as
one micro-op.
• A pair of macro-fused instructions is kept as one micro-op.
• Instructions with 64-bit immediate require two
slots to hold the immediate.

As theory would predict, I was able to get the "fast" speedy by forcing legacy decoding by adding a enough junk TEST/JZ pairs. The "non-conditional branch" limitation might explain why both JMP and CALL/RET have the same effect. I wonder if the occasional alignment effects I see have to do with splitting op-stores across a 32B boundary?

Focus on port 4, the only port available for memory stores.

Yes, we'd expect 4B, and we instead see 1.6B for the fast case and 2.0B for the slow. My version above is at 1.4B, and I'd guess is proportionally faster. Have you seen tricks that reduce this to some lower number?

We'd also expect P2 plus P3 to equal 4B? It's interesting that these are closer, but still quite a bit over.

By dispatching fewer instructions that we can handle per cycle, there is less speculation and thus less wasted work?

While there is less waste in terms of power efficiency, are we actually seeing P4 be a bottleneck? It's hard to tell as the total cycles also goes up, but I think it's still at 90% rather than 100% utilization.

So while it looks bad, I'm not sure that anything will necessarily go faster if we reduce the number further. It may be that the maximum difference is whether we get a 4 cycle turnaround on the store-load forwarding versus a 5 cycle.
Attention is just a weighted sum over a set of vectors, where the weights sum to one. Attention weights are usually created by neural nets. The word "attention" might seem more grandiose than what it actually does.
Yes, it's really important to have the frontend types generated directly from what the backend generated graphql schema specifies. We shouldn't have to type anything at all.

I wrote an article about using apollo-codegen to generate all the Typescript types:

https://medium.com/@crucialfelix/bridging-the-server-client-...

It's still a few steps too many, but it's getting there.

I'm about to write up the second article which deals with mutations. This lets me import only one type:

import { SetAptListOnWebProps } from "../mutations";

and then this.props.mutate is fully typed:

(property) mutate: (options: MutationOptions<{
apt: string;
listOnWeb: boolean;
}, {
setAptListOnWeb: {
apt: {
id: string;
listOnWeb: boolean;
__typename: "Apt";
};
__typename: "SetAptListOnWebPayload";
};
}>) => Promise<{
data: {
setAptListOnWeb: {
apt: {
id: string;
listOnWeb: boolean;
__typename: "Apt";
};
__typename: "SetAptListOnWebPayload";
};
};
errors?: GraphQLError[];
loading: boolean;
networkStatus: NetworkStatus;
stale: boolean;
}>

First type argument is the mutation input variables, the optional second is the shape of the optimistic response.
This is correct, gains in ISAs are tax free and have no impact on cgt allowance. So if cryptocurrencies were a good investment an ISA would be an excellent place to hold them and convert gains to currency you can spend, but I don’t think any isa providers support them.
How Long Before Sodium Batteries Are Worth Their Salt?
The similarities between Uber and E Corp are getting closer by the day.
You criticizing Trump but also echoing his rhetoric - Make Canada Great Again, keep Canadian TV Canadian.
Off topic. Did you intentionally use the word then after the comma in the second sentence in the second paragraph "then the sleazy salesman"?

I see this a lot here on HN where I assume the word should be than. Is this some regional dialect quirk?