skysight-inc/HackerNews huggingface dataset:
"affiliated swivel-eyed Marxists" I'm not sure this is really the sort of dialogue that we want to encourage on hackernews.

Overall your point is that you'd like as many heavily left leaning members to be on the show as you believe their views will be torn apart logically. You'd have been better off with something like that because if not your analysis just comes across quite bitter and biased.
> The author doesn't really justify why he needed to port the python script to rust in the first place.

And they don't need to. When I first learned Rust, I tried to write a `filter` function. Why would I ever do that? I could write `filter` much easier in Python, or heck, just use the `filter` method on iterators that is already in the standard library. I did it because I saw it as an opportunity to learn. I wanted to connect something I knew (`filter`) with something I didn't know (Rust).
The built-in git GUI also makes that very easy.
They buried the lede (presumably since it was inconvenient to the thesis of the piece):

“Housing is seriously unaffordable in Tokyo-Yokohama, with a 4.4 Average Multiple (average house price divided by average household income). Osaka-Kobe-Kyoto has an Average Multiple of 3.5 and is thus rated as moderately unaffordable. Despite these ratings, Japan has the most affordable housing of any megacities (over 10,000,000 residents) in the Demographia Survey.”

If you think real estate in Japan is "affordable", you need only talk to Japanese people. Salaries here are low, and the economy has been stagnant for decades. Younger people tend to live with their parents until marriage, and if you ask them why, they'll tell you: they can't afford to live on their own.

Yes, Construction is rampant, but that's mostly because buildings here are ripped down every few decades, not because cities are necessarily building more or larger buildings. There's just tons of churn.

I've said it before, and I'll say it again: if you want affordable cities, a big part of the "secret" is tanking your economy for a few decades.
I think having Result alone does not make error handling complicated, but having different error types for each operation (and concrete result) instead of using one generic error type for all of them does by pushing the job of unifying erros towards the user.

Go works around the problem by Error being an interface, which means any function can return any kind of error without needing to transform it to another form. However Go benefits from the Garbage Collector here - I totally understand why Rust libraries don't want to return heap allocated errors.

Maybe C++ std::error_code/error_condition provides some kind of middle ground: It should not require a dynamic allocation. And yet the framework can be expanded: Different libraries can create their own error codes (categories), and error_codes from different libraries can all be handled in the same way: No need for a function that handles multiple error sources to convert the error_codes into another type.

The downside is that the size of the error structure is really fixed and there's no space to add custom error fields to it for error conditions that might require it. A custom error type in Result<ResultType,ErrorType> can be as big or small as one needs.
the article links to a post from the Irish Independent Online which gives more detail:

http://www.independent.ie/irish-news/news/garda-launch-blasp...

Reading between the lines, this looks more like an attempt to challenge the blasphemy law than to punish Stephen Fry. From the link above:

"[The complainant] said he was asked by the garda if he had been personally offended by the programme and If he wished to include this in the written statement.

I told the Garda that I did not want to include this as I had not personally been offended by Fry's comments - I added that I simply believed that the comments made by Fry on RTÉ were criminal blasphemy and that I was doing my civic duty by reporting a crime."

Atheist Ireland responded by republishing a list of blasphemous statements on their website, atheist.ie, in solidarity with Stephen Fry. They note:

"If we are prosecuted, we will challenge the constitutionality of the blasphemy law. If we are not prosecuted, it will again highlight the absurdity of this law, which should be repealed immediately. We again call on the Irish Government to honour its commitment to hold a referendum to remove the ban on blasphemy from our Constitution."

What is troubling is that, though the law was designed to be unenforceable in Ireland, it has been used as a template for corresponding law in theocratic countries such as "Pakistan and other repressive states".
I could not get it to identify a British Pound symbol after several attempts. The top proposed glyph was much more obscure and the following ones were increasingly obscure from there.

I suspect that the training corpus may have been a table of Unicode glyphs rather than text from the wild.
No one expects the Irish Inquisition!
Ah ok -- thanks for the link!

Do you know how this (dumping regenerative current on the supply bus) would work if there are multiple motor channels on the same bus that are simultaneously regenerating at the same time?
I've heard this before, and I've also seen IntelliSense labelled as a crutch. I don't understand this - how does IntelliSense prevent mastery of a language? Does it make a difference if someone's mastery of a language involves them using IntelliSense?
I created UltraHook.. it only replaces ngrok for the simple "receiving webhooks on localhost" use case.

The infrastructure is sponsored by Enchant.com
I don't know Rust, or the general direction of the community around it.

Is there some chance, that over time, most popular functionality will end up in well architected crates that abstract away some of these complaints?

A bad example, perhaps, because they probably go too far with it, but a lot of java's verbosity fades away because there's a rich ecosystem of libraries that already know how to do what you're trying to do. There is, of course, a downside to that...important implementation details become opaque to the users of these libraries.
I think the complaint is more that Rust has seemingly tried very hard to make error handling "simple". But in the process it has managed to invent a whole series of new idioms and special syntax that is alien to pretty much everyone. There's a thread in /r/rust about this same article where you can look and see people suggesting all sorts of ways to write this that are split into clear sedimentary layers depending on when the writer learned the language.

At this point the cognitive load required to read and understand Rust implementations of "typical" practical problems is rather higher than it is for C++. And it seems to be getting steadily worse from my perspective on the outside.
Abortion aside, Ireland is in fact much more progressive and liberally minded than the US and most of southern Europe.

These comments were made during an interview on the Irish public broadcasting network; just for a comparison, in Italy nobody would have even dared to speak their mind so clearly about God on tv, or the show would have likely been cancelled. Twenty years ago the sitcom "Father Ted" became the most popular show in Ireland, and it would be still considered too blasphemous to be aired by any of the major tv networks in Italy.
> This is why hate speech laws are dangerous.

You are mixing apples and oranges. Hate speech laws are perfectly fine, they intent to protect people from being harassed and attacked for what they are (philosophically, religiously, skin color...). This is not hate speech law: no group or people or people are involved here, only an imaginary character. If I say "death to religious people", this should be criminalized. If I say "death to god", there is nothing wrong with that.
> some fans banded together to start a blog called the Harry Styles Promo Team

"some fans" would be the bit I flatly don't believe
Of course, but given that the laws are on the books, this is one of the best cases that could come up because it will almost certainly either lead to no case, or make them look silly, and by extension make thes laws look pointless.

Norway used to have these laws as well, and a major factor in the decline of their use was exactly that it started making the government look stupid rather than serve a purpose the government was still attached to. The last successfull prosecution happened in 1912, I think, and the last prosecution in 1933 made the prosecutor look sufficiently silly (the case was only brought because it was pushed hard by a professor of theology and prominent preacher) that no further cases were brought.

The person persecuted the last time they were used were a writer named Arnulf Øverland who held a speech to a student organization in Oslo titled "Christianity - The tenth plague", ending by comparing the influence of Christianity on Europe to the biblical plagues and concluding the spread of Christianity was the worst of them all. I think he'd have rather liked Stephen Fry's answer...

While nobody should be prosecuted for this, when they go after people like him, or like Stephen Fry, in settings where said people feel safe to make these statements in the first place, it tends to be the beginning of the end for such laws rather evidence the suppression is still working.

(We should be more worried about the places where people don't dare utter such things in the first place)
Yes, exceptions are better than return codes, but I would argue Result types are better than exceptions. Checked exceptions in Java have their issues. Exceptions in C++ are odd beasts (though that's getting better, they're still not checked and therefor basically anything that isn't noexcept can throw them (oh wait! noexcept can throw! it just crashes immediately)).
No it was a private talk about company strategy.
In an abstract sense, it's possible to offer more functionality without requiring much more friction. This is the premise of languages with good type inference, relative to earlier versions of C++/Java.

Though there might be more friction at some points, I imagine the Rust developers are taking these examples as good benchmarks for improvements.

EDIT: This exercise is very similar to the frustration when starting to use Haskell.

A lot of "simple" things feel more difficult because of the functional purity. But then you discover more patterns or libraries that help to handle this.

Design patterns surely exist for Rust that have yet to be discovered, but will turn out to properly encapsulate a lot of the difficulty (when combined with language improvements)
Completely agree. One of git's strengths is the flexibility to support many development styles and workflows. It's possible for each developer to follow their own style locally, but still have a consistent team style once commits land on 'master' following rebase.

Learning about interactive rebase greatly aided by local development flow, because it freed me from too much agonizing about commit structure before much code is written. It's a lot easier to decide how to structure commits to tell a story with the code in front of you.
Thanks. How does your tech work? Very interesting.
I have run into something very similar in somebody else's python program where they declared a string that was later used (based on some conditionals) to locate a file. The thing is that most of the conditionals were never hit under ideal conditions (like passing all args etc.). It took me a lot of time to track down the bug (also because of the lack of awesome debuggers for Python).
The “password” in that command would be stored in your memory only, that's the benefit of this idea.
The reason this law still exists is because blasphemy is included in the
Irish constitution and so to remove it would require a referendum which
"would rightly be seen as a time wasting and expensive exercise" [1];
the law is effectively a dead letter. With this becoming popular, we'll
probably get a referendum moved forward with the result being overwhelmingly in favour of removing it. The person who reported him claimed he/she was not offended[2]; it wouldn't surprise me if it was done just to highlight the silliness of the law.

[1]: https://en.wikipedia.org/wiki/Blasphemy_law_in_the_Republic_...

[2]: http://www.independent.ie/irish-news/news/garda-launch-blasp...
For me, the biggest benefit of TDD is it helps me stay focused by creating a similar challenge-effort-success loop to a video game.
> import json
> with open("config.json") as f:
> contents = f.read()
> config = json.loads(contents)

translates to:

extern crate serde_json as json;

fn read_json() -> Result<json::Value, Box<std::error::Error>> {
let file = std::fs::File::open("config.json")?;
let config = json::from_reader(&file)?;
Ok(config)
}

And

> import configparser
> config = ConfigParser()
> config.read("config.conf")

can be translated to:

extern crate config;
use config::{Config, File, FileFormat};

fn read_config() -> Result<Config, Box<std::error::Error>> {
let mut c = Config::new();
c.merge(File::new("config", FileFormat::Json))?;
Ok(c)
}

Difficult stuff indeed.
Community Control of Police Spy Tech in Oakland
That sounds bigger than it is. A circle with 40 mile radius ~= 5000miles. If you go a similar distance from NYC or DC etc the prices are still inflated because it's considered commuting distance, plus this is an average.

For comparison the US median home price is ~220k. But, the Median price in Fairfax VA which is 30 miles from DC is $510,000. Chantilly VA which is ~35 miles from DC is 400k.
I feel like there are trade offs. With the image approach, I can tell what I'm engaging with at a glance instead of a few clicks and page loads. I know whether a link is a blog post, repo, promotion, article, tweet without having to decipher the domain, and I can even tell whether a site will accost me for my email address.

On the other hand, one could argue a lot of what the images tell can be inferred from looking at the title and metadata alone, but this has definitely reduced my "false positive" clicks. Vanilla HN wins hands down for information density.
AMD has a similar system, likely with simular issues. Their smaller footprint means they just take longer for people to notice than an Intel snafu. Hopefully this will give them a preemptive heads up to harden theirs before an exploit is discovered.
It's their standard style of photography recently. I don't even think it looks bad - just pretty opinionated
EC membership, not EU - from the perspective of the British, they voted for membership of a trading block, which then morphed into a new megastate wannabe without any vote taking place to legitimise it.
Please don't do that. Development history like frequent commits and merges has enormous value, for bisecting and debugging. Once detroyed, it's never coming back.

What's the purpose of git commit tree at all if it doesn't truthfully represent the development process?
On the short term - I mean, a century, maybe plus another half - it wasn't. Technology was making the life of everybody miserable, except for some very few.

With time something else changed¹, and tech became a good thing.

1 - My bet is on ubiquity. Capital became so common it started to lose the competition with labor, and all the low hanging fruits for automation were gone, so it couldn't compete on new ways.
There are many ways to have both enforced error handling AND less boilerplate. Java's checked exceptions are much maligned but would work very well here. Another way would be having more syntactic sugar for Result-style monadic error handling, like the do notation in Haskell or for..yield in Scala.

Another issue raised by the original post is the fact that Rust has no top-level concrete error type that is convertible from all of the specific error types. This is also something that could be fixed without compromising other qualities of the Rust type system.
I've known people from India to react in disbelief to the idea that chili peppers historically didn't exist in India (or anywhere in Asia).
tangential, but in HK airport you're passively screened for a high temperature at all entrances to combat the spread of flu.

http://news.xinhuanet.com/english/2009-04/28/content_1127068...
I came across this theory the other day https://en.m.wikipedia.org/wiki/Baumol%27s_cost_disease

It seems to me to nicely explain the rise in incomes for, ironically, the least "productive" professions such as Health care, professorship, etc relative to anything that can be automated for high productivity.
Eye tracking in video games
C does not force you to check errors, as everything that could fail must return an error code and you could simply forget to check it. Python checks the error for you, as anything that could fail throws an exception, and so you have to go out of your way to actively write code to manage to override that check (with a try/except) to ignore the error.
A difference i see is that Soros is supporting organisations that are acting according to their charters and stated aims.

Very often this activity puts them add odds with the local strongman like Orban in hungary.

I have not seen support of widespread deception of this organisations to achieve some hidden agendas.

So, i do think it is legitimate to discuss the role of NGOs in society or the specific aims of Soros NGOs.

But this is a far cry from, for example russia, financing front organizations to undermine other nations and spread their propaganda.
Three Virtues (1996)
> Were all the benefits of automation going to the bottom line of the business owners, you would see a steady increase in corporate profit margin.

It's no coincidence that "corporation" was something that only became viable on that time.

Really, you got a very selective symptom, got a positive result, and are just dismissing it. Why?

> The richest 1% earn roughly half their income from wages and salaries

That's only because 1% is too big a number. Square it and look again.
http://250bpm.com/blog:4

https://news.ycombinator.com/item?id=3953434
Yeah, John is great. His Unicode handling in Cyrus was way ahead of it's time.

I left CMU & the project 14 years ago. It's nice to know that some code lives on.
> There's a thread in /r/rust about this same article where you can look and see people suggesting all sorts of ways to write this that are split into clear sedimentary layers depending on when the writer learned the language.

As someone that participated in that conversation, I think that's a pretty inaccurate characterization of it. It's not about when the writer learned the language, but rather, what problem you're trying to solve. If you'll allow me to summarize very briefly (perhaps at the expense of 100% accurary):

* Use unwrap/expect when you don't care.
* Use `try!`/`?` with Box<Error> in simple CLI applications.
* Use `try!`/`?` with a custom error type and From impls in libraries.
* Use combinators (e.g., map_err) when you need more explicit control.

You might imagine that you could use any number of these strategies depending on what you're trying to do, which might range from "a short script for personal use" to "production grade reliability."

All of this stuff was available at Rust 1.0. (Except for `?`, which is today an alias to `try!`.) It all falls out of the same fundamental building blocks: an `Error` trait with appropriate `From` impls.

The one exception to this is that, recently, there has been a surge in use of crates like error-chain to cut down on the code you need to write for defining custom error types and their corresponding `From` impls. But it's still all built on the same fundamental building blocks.
I'm curious, how do you reconcile server- and client-side rendering to be the same? Specifically, I'm thinking about initial page load/reload and route transitions. Do you share templates/partials between PHP and JavaScript?
These people are part of a global, often criminal elite yet at the same time want the protections of a strong nation state and discover they can't have both at the same time. That's funny in a dark way.
And yet it is much more affordable than, say, San Francisco (9.2) or Vancouver (10.3) by that same metric, which was their point. By this metric at least, Tokyo fares far better than comparable cities - no lede buried.
> I will literally give you $10,000 if¹ you can give me a MD5 preimage attack.

It's almost certainly a question of when, not if, I will be able to collect on that offer.
Aren't both the same thing?

How else can you sign a binary?
HN and twitter are text only sites. Not everything is a text only site.
The brand is known, so maybe don't mention Turbo Tax but if you show the logo and it's a real testimonial it won't hurt too much that it's all Indians.
>Millions of people decided they know better than facts. That's it.

I don't think people voted for Trump because they think he was spouting facts (when did facts ever factor in a US election ?).

I think they voted for him because they felt that between him and Hillary it was a bad choice either way, so why not go with the 'new kid on the block' this time around.
One of my favourite sketches on religion is from Atkinson's live show when the devil, Toby, welcomes people to hell [1]. It satirises Pascal's Wager [2] and the general issue of most peoples lack of reasoned choice of religion so casually and effectively after various easy digs at the usual victims.

[1] https://www.youtube.com/watch?v=91DSNL1BEeY

[2] https://en.wikipedia.org/wiki/Pascal's_Wager
http://www.metro.tokyo.jp/ENGLISH/ABOUT/HISTORY/history03.ht...

Tokyo added around 1.5 million people from 2000 to now. That takes a lot of construction.
Former UNICEF advisor: Female genital mutilation is 'gender egalitarian surgery'
Was the expect method​ supposed to be named except, as in exception? That would make a lot more sense.
I think that part of it is that the idea of a Result type being normal will help prevent much of the cruft and burying we see with exceptions. I also feel like handling Result types is more natural than exceptions.

First, you _have_ to do it, even if that means a try! and passing the buck. The syntax for this isn't as monstrous as it is for checked exceptions as well.

Second, it feels more like a natural code-flow, not the break that exceptions provide.

Third, it's useful for more than just "Exceptions". Coupled with Optional types, it provides a more expressive way of not-hapy-path-code where exceptions just feel heavy handed. For instance https://docs.python.org/3/library/stdtypes.html

d[key]

Return the item of d with key key. Raises a KeyError if key is not in the map.

The key not existing isn't really exceptional. A proper optional, union, or result type handles this case much more easily.

In sum, I think the expressibility of Result and Option, along with a more natural flow for handling them will make working around them less tempting/viable/easy to pass over in a code review.