bmn_

This is a re-submission. Previous discussions:

• https://news.ycombinator.com/item?id=10812214 (368 comments)

• https://news.ycombinator.com/item?id=10757785 (2 comments)

• https://news.ycombinator.com/item?id=616146

Lots of misunderstanding going on in the comments. Let me set your confusion right.

w3id.org is basically the same as purl.org, see https://en.wikipedia.org/wiki/Persistent_uniform_resource_lo... for a background explanation. They are services that promise to be extremely stable and long lived and where you coin permanent URLs for certain Web technologies (e.g. Link relations RFC 5988 §4.2, XML namespaces, …) that require an identifier that never changes. So in theory you can put any well-formed URI there because most of the time, software will just compare for URI equivalence (RFC 3986 §6), but if a user wants to, he can also dereference the resource identifier and possibly arrive at a human readable document describing what's going on, for example visit http://www.w3.org/2001/XMLSchema in your Web browser. You cannot do this with content addressable IDs (named hashes/ni scheme, IPFS, DHT), URNs (guid/uuid scheme), etc. In order to achieve that practical goal, the dereferenced document needs to be published on a Web host, and the domain name associated with the Web host needs to be under your control.

Now, for coining purls, you put in an indirection. When you lose control of your domain name, simply redirect to a new one. In practice this eliminates link rot. There are other things on the Web that make use of redirection mentioned among these comments, like archives and link shortening, but that's out of scope for purls – you are not supposed to coin purls for general Web documents like news articles (millions a years), but specific documents whose URI serves as an identifier for a schema description or the like (dozens a year).

The difference between the different purl services is their governance model. IMO w3id is best aligned with the interests of hackers that make use of Web technology.

A nice thought, but pointless. Failing tests do not matter to the PHP release managers, they ship it anyway.

http://redd.it/qeq7k#c3z0vva

https://github.com/rakudo/rakudo/commit/d995c87b51

These symbols become part of the city's identity, I'd say that's pretty important.

Vastly more important is the proper purpose of the signage. It signals to someone unfamiliar with the surroundings there is an underground train station here. The targeted persons who require this signage and are helped most by it are predominantly not residents of the city and therefore have little reason to feel identity or affiliation.

Much like regulated traffic signs, it is better that cities do not design their own unique logos, but use a standardised one. See the paragraph on http://mic-ro.com/metro/metrologos.html starting with "Some logos are ubiquitous, at least nationwide" for places where cooperation won out over individuality.

Not generally!

    $ perl -E 'say sprintf "%.64f", 0.1 + 0.2'
    0.3000000000000000000108420217248550443400745280086994171142578125
    $ perl -E 'say sprintf "%.64f", 0.1 + 0.2 - 0.3'
    0.0000000000000000000000000000000000000000000000000000000000000000

Rapid pace is fine because the language spec is backward compatible. The module problem is rather mostly on the API level. To fix:

• On the technical side, needs the equivalent of CPAN testers to automatically show where stuff breaks.

• On the social side, needs the fostering of a culture where breakage is considered ill-mannered, and module maintainers hence go to lengths to prevent it or fix it promptly.

http://nickgravgaard.com/elastic-tabstops/

That site does not work for me. I paste into the input field and it automatically turns into %F0%9F%90%88.

Compare with https://codepoints.net/ instead.

Edit: great, HN is broken too.

You are mistaken. Near the end there is a hyperlink to the claims document. It is titled "Facebook's terrible post" and points to the URL <https://facebook.github.io/react/blog/2015/05/01/graphql-int....

There was apparently only a 30 minute window to do so. HN moves too fast for nuanced counter-replies to the commentary. If I just made a top-level comment, it would say something along "I agree in broad strokes", which is not that useful.

the original paper has done (IMHO) a poor job as explaining what it is about

Please read <http://roy.gbiv.com/untangled/2008/specialization>. The paper is for experts. Non-experts can learn from a suitable technology book instead.

people spend so much time debating what is and what isn't REST should be a red flag that maybe it isn't the answer to everything

Does not follow. People spend so much time debating what is and what isn't REST because there are a great number of people who do not understand the topic, have no actual interest in learning it properly, and then come to wrong conclusions and start making wildly inaccurate arguments.

Not all Web application problems can be cleanly modelled over REST, so indeed it is not the asnwer to everything, but most can. For those that can, using the REST architectural style is more advantageous than, let's say, remote-procedure calling.

All the simple REST examples make it look like it is the perfect solution for CRUD tasks.

All the simple REST examples are written by those ignorants I mentioned above. The simple CRUD model falls apart when there is just a little more complication involved. REST does not mean just CRUD, as any decent REST book teaches.

If the server returns 404 for a resource, what actually happened? Did the web server or my application return the 404.

⁇ If the server returned 404, the server returned 404. This means the client application/the user agent made a mistake, indicated by the leading digit 4.

Conflating HTTP and application error codes leads to confusion.

When following REST, that conflating is actually a good practice. Not doing so means tunnelling a proprietary, possibly ad-hoc protocol over HTTP, resulting in non-interoperability. There is no need for any confusion, the response body can deliver a precise problem description applicable to the concrete error condition, perhaps even giving an indication how to fix the problem. There is a wealth of status codes <https://github.com/for-GET/know-your-http-well/blob/master/s... and many of them semantically map to typical application error states, and it's okay to fall back to generic codes like 422 or 400.

HATEOAS is just superfluous. […] I just haven't found a practical use for it.

You need to bring a better argument to the table. Establishing relations between and traversing resources using links and other hypermedia controls is central to the REST architectural style. Every Web browser does this, for timbl's sake!

REST encourages creating a CRUD interface for every single resource.

Not true. Nothing in REST encourages this. It's the software architect's fault if there are 100 (supposedly underutilised) resources, not the fault of the architectural style.

Admiration and social standing as currency was used by Howard L. Myers in "All around the universe" 31 years earlier than Doctorow.

http://www.baenebooks.com/10.1125/Baen/0743436075/0743436075...

Get a Nemo or Sailfish device. http://enwp.org/File:Mer_and_mobile_operating_systems.svg

Public build service is https://openrepos.net/ and it already has lots of packages that you know from a normal Linux desktop and you can also host your custom stuff there. High-level package manager is packagekit or zypper.

Having a private repo is easy, too. Package format is RPM, repo format is http://createrepo.baseurl.org/

RSS never was an open standard like you would expect from a real standards organisation, e.g. IETF or W3C.

Because of dominance posturing and fights between the multiple parties involved in the development of RSS, it is a train wreck of ad-hoccery and incompatibilities, and serves as a prime example of how not to do things. https://web.archive.org/web/2004/http://diveintomark.org/arc...

Remember who actually killed it?

Atom.

There is really no way for a simple program to account for all of those possible edge cases.

The post to linked you contained a piece of boiler-plate code which accounts for said cases.

Have you considered how your formatting is going to look when people intersperse Right to Left words in your output for example?

There are modules to handle this. It of course means that you have to stop using non-Unicode-aware functions like `sprintf`.

Use named captures or list assignment. $1 $2 etc are already a code smell in Perl 5. Action-at-a-distance is the enemy.

Nope.

http://web.archive.org/web/2011/http://merlyn.posterous.com/...

http://www.modernperlbooks.com/mt/2013/02/goodnight-parrot.h...

https://www.ohloh.net/p/parrot (contributor graph at the bottom)

https://github.com/Gerberus/xca

Languages that cannot deal with graphemes are lame. I daresay this solution below should score 20 in OP's imaginary scale.

    $ perl -CADS -E'say $ARGV[0] =~ /(\X{5})/' देवनागरीदेवनागरी
    देवनागरी

Length of output string is: 5 graphemes, 8 codepoints, 24 octets (UTF-8).

There was, and as a result a lot of people shitcanned that distro, and said incident left an indelible black mark on the vendor's reputation.

Perl did time-travelling variables first, namely in 2007: Positronic::Variables

https://www.flickr.com/photos/gunnarwolf/1343377956/

This in the picture is Conway giving the talk.

Very possible. However, consider:

• 10 just came out.

• The authors possibly want to show just how complicated and arduous it is to disable this utter disrespect of user privacy, thus teaching the users that all these screens and settings amount to a so-called dark pattern (assuming the best case).

――――

I advise you to omit "uhm" from your online forum posts. It comes across as condescending because it makes it sound like you think your conversation partners are morons.

Without an explanation which part of the article sows FUD, it makes me think you just don't even know what that acronym means.

70 comments and not a single one mentions http://enwp.org/EN_13402

This is reinventing https://metacpan.org/release/webchat

You should just give up.

It fails not at all.

Result of https://www.howsmytls.com/

    Version: Good
    Ephemeral Key Support: Good
    Session Ticket Support: Improvable
    TLS Compression: Good
    BEAST Vulnerability: Good
    Insecure Cipher Suites: Good

    Protocol Support: Your user agent has good protocol support.
    Logjam Vulnerability (Experimental): Your user agent is not vulnerable.
    FREAK Vulnerability: Your user agent is not vulnerable.
    POODLE Vulnerability: Your user agent is not vulnerable.
    Cipher Suites (in order of preference): TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 (0x6b)   Forward Secrecy ←←←←← listed first, other ciphers elided
    Protocol Details: Session tickets   No ←←←←← feature is labelled in yellow, all other details are labelled in black or green, elided

    var multi_line = 'You already \
        can do this in ES5.';