Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

This is self-published research by a think-tank, not a peer reviewed scholarly publication; also, the actual paper for this finding doesn't yet seem to be available, just summaries by news organizations. This article does link to some older papers by them, which go into very little detail on methodology.

As such, it's really hard to say what kind of abuse they are talking about; slut shaming and rape threats, while both awful, can be quite different. Also, I am curious about how they accurately determine gender of Twitter users; there are many fake accounts on Twitter, and I don't believe Twitter even reports gender identity of users.


It actually sounds like old research was either reproduced or simply read at a forum for stopping internet abuse (#ReclaimTheInternet) by this researcher (http://www.demos.co.uk/people/alex-krasodomski-jones-2/).

Another research paper, by a different author from the same think-tank, from 2013-14 had the same result: http://www.demos.co.uk/project/misogyny-on-twitter/


Is there any research that show being peer reviewed in fact makes a difference? General speaking, I would think research should just speak for itself.


Generally speaking, you think... well that's nice. Meanwhile, in the world of the scientific method, the issue is that everyone needs to know that you didn't just write something down for fun or profit. If your results can't be replicated... thbbpt.


The elephant in the room with science across the board is that replication studies are not an attractive way to pull in grant money. It's a big problem!


> If your results can't be replicated

Results aren't replicated during peer review, are they?


Depends on the publication, I believe. There was a comment here a bit ago where someone pointed out that such journals do exist (for example, Organic Synthesis https://en.m.wikipedia.org/wiki/Organic_Syntheses ).


Not necessarily, but at least the methods can be evaluated to see how likely it is that they can be. A black box with, "Trust us, here's what we found" is weak as hell, unless you're still into Pons and Fleischmann I guess.


Strange that you believe any science that's not reproducible is science. Or assume that if the science is not reproduced, it's sciencifically valid.

Science is not a singlar effort, nor is peer review without replication.

Please question your assumptions about what science really is.


Strange that you believe any science that's not reproducible is science. Or assume that if the science is not reproduced, it's sciencifically valid.

That's the exact opposite of what I said. What's wrong with you?


What did I say that's conflicted?


Try reading the thread closely, looking for nuances you may have missed.


So given how little work is done reproducing findings, there is minimal value?


You can generally respond even if you don't have the link by clicking on the timestamp ("1 hour ago" or whatever) to go directly to my comment.

My comment was not meant to point out that libsodium doesn't make a general OpenSSL replacement. It was meant to point out that if you restrict the problem domain enough, of course it's possible for people to write secure C. I can write a secure "Hello, World!" program; even a secure networked "Hello, World!". But being able to write a secure "Hello, World" does not mean that I am capable of writing secure C in general.

Pointing out one small piece of code that is apparently secure isn't what a claim like "nobody can write secure C" is really about. "Nobody can write secure C" means that when programming in the large, implementing standardized network protocols with all of their warts, having codebases that evolve over time, that no one can consistently and reliably write secure C.

So sure, libsodium may, as of now, have no known CVEs. But it's based on NaCL, which is written by djb. He's also written qmail and djbdns, both claimed to be secure. qmail has had exploitable problems on 64 bit platforms with large amounts of virtual memory: http://www.guninski.com/where_do_you_want_billg_to_go_today_... and djbdns has had security problems exploitable on any platform: http://article.gmane.org/gmane.network.djbdns/13864.

OpenBSD is likewise a minimalist system with a heavy emphasis on security, but even with that approach, they have had to change their slogan to "Only two remote holes in the default install, in a heck of a long time."

Now, of course, this does point out a few things. Minimalism is important for security; and more minimalist approaches and care in writing code can help reduce the frequency and severity of critical vulnerabilities. But even given some of the most careful, security conscious approaches, people still make mistakes.

That's why, when practicing responsible security, you should use defense in depth. In addition to all of the care, review, minimalism, principal of least authority, isolation, etc, you should also use tools that can prevent whole classes of bugs at compile time.


> You can generally respond even if you don't have the link by clicking on the timestamp ("1 hour ago" or whatever) to go directly to my comment.

https://twitter.com/CiPHPerCoder/status/727530489255485440


Ah, that sucks.


It also doesn't interoperate with any widely deployed crypto standards.

Yes, NaCL is a better design for cryptographic primitives, being much more limited in scope and reducing the number of primitives supported. It's great, if you can control both sides of the protocol so you can use something like this, and if you can also write your own safe, secure protocol code on top of it that doesn't introduce any errors of its own.

The problem being solved by OpenSSL is much harder; for interoperability, you need to support a much wider range of standards, and they are always changing. It also supplies the full protocol stack to implement TLS, including multiple versions of TLS, rather than just the crypto primitives.

It's when you have code that is trying to do all of this, and evolve over time, with contributions from multiple people, that it's easy for such mistakes to creep in. Writing a single piece of code in C with no vulnerabilities is hard, but not impossible; maintaining such a piece of code, implementing complex and changing standards, over time, over a variety of platforms, and so on, without introducing vulnerabilities, does seem to be impossible in C.


Not interoperating with TLS's CBC construction is a feature, not a liability.


Of particular interest here is also webpki:

https://github.com/briansmith/webpki

Which is designed to validate TLS certificates. This is doing the ASN.1 parsing and signature verification in a zero-copy, memory safe way, built on top of ring for the core crypto primitives.

Now, this isn't a full implementation of what you would need for replacing OpenSSL for certificate handling (and also isn't yet complete); in particular, this is extremely limited in scope as only being for client-side certificate verification. This particular OpenSSL issue was when parsing and re-encoding certificates, which is out of scope for webpki. But it is a good starting point for demonstrating memory-safe and efficient handling of complex tasks like parsing and verifying of TLS certificates.


I think one problem with this discussion is what is encompassed by "tech". If you just use "tech" as an abbreviation for "technology", then sure, tech has been driving human civilization for millennia. Agriculture? Buildings? Roads? Language? Writing? Man, those are some technologies that have paid off big time.

If by "tech", you mean "high tech", well, that encompasses an awful lot of different things, and of course the goalposts are constantly moving as today's high-tech becomes tomorrow's tech becomes the next day's obsolete.

If by "tech" you mean computer hardware, software, networking, and networked services, then sure, that's a pretty important driver of some other advances, but likewise advances in other fields help to drive this as well. Globalization, shipping, mining, energy, RF engineering, photonics, aerospace, and so on all play into this, and all both benefit from and contribute to the success of computer hardware, software, networking, and networked services. But just because this form of high tech can help with other fields, doesn't mean it's driving the economy. It may be increasing productivity to a certain degree, but there is an awful lot of the economy which is only minimally influenced by these kinds of things.


Also reminiscent of the Zip drive "click of death" problem, in which bad media could damage drives in such a way that the drives could damage media that would further damage other drives:

https://en.wikipedia.org/wiki/Click_of_death


I don't know if there was any strict requirement to use Python, but you mention the difficulty in finding a library to parse regular expressions.

One of the many great features of the Rust regex crate (https://doc.rust-lang.org/regex/regex/index.html) is that there's actually a regex_syntax crate that provides this parsing support (https://doc.rust-lang.org/regex/regex_syntax/index.html), which can be used for purposes like this, to do alternative kinds of matching engines.

Rust's regex library also has pretty good DFA and NFA matching engines, and an Aho-Corasick engine for parts of the regex that can be decomposed into just a set of simple strings to match, as well as some fairly well optimized exact substring search to speed up search for expressions with some substring that must match exactly, so it can be fairly fast for the kinds of matches like your "TAG(A|C|T|G)GG" example.

Another, even more radical change, would be to build a finite state transducer of your data set, which you can then do regex matching on directly by taking a union of an automaton representing the regex and the FST representing your data (which is itself an automaton). I learned about FSTs from the author of the Rust regex crate: http://blog.burntsushi.net/transducers/. An FST is actually used internally for certain types of searches in Elasticsearch/Lucene (https://www.elastic.co/guide/en/elasticsearch/reference/curr...). I don't know if these would be suited to this problem as is by just building an FST from your set of sequences, or maybe using the overlapping subsequences idea to make FSTs from a larger number of shorter strings, but it would be an interesting project to explore.


Insanely cool, thanks for sharing - this would be interesting to replace our final filter (if I'm interpreting correctly, a trigram index would still speed up the initial search)

And yeah, Python is a strict requirement since the rest of our code is in Python - figured it wasn't worth throwing in another language when a rough parser worked.


> (if I'm interpreting correctly, a trigram index would still speed up the initial search)

Your trigram approach is roughly isomorphic to the FST approach. The main benefit of an FST is that it can store a huge number of keys in a very small amount of space that is still searchable without a separate decompression phase. In the case of trigrams with a low alphabet size, an FST probably isn't a big win. But say if you wanted to increase to a bigger N-gram for some reason, then perhaps an FST might help you out. It's true that Rust's fst library has a way to apply regexes to the FST for very fast search (Lucene also has this), but its subjects are terms in the FST, which in your case corresponds to trigrams. This means you still have to go through the "extract a set of trigrams from a regex to pre-filter on" dance.

And yeah, using the regex-syntax crate from Python would have been a fair amount of work. In particular, it still needs a C API before you can use it from Python, which would probably be a fair amount of grunt work.

In any case, as a computational biologist in a former life, this is very cool work. Nice job! :-)


This is such an FST based sequence search engine: http://78.189.139.203/demos/seqbul

Currently, only viral sequences are supported.


For the union of the automata, do you mean intersection? Maybe when I look over the transducers post less quickly I'll see my mistake.


Yeah, I meant to write intersection. My mistake.


Every piece of software, in the release notes, should include a brief blurb about what the software is, and a link to get more information.

And yes, the "home" button should go to the project home, not the blog home (or there should be a separate button for that).


Most of the times I've seen fonts break like this, it's because people have outdated local versions of the fonts installed on their system.

Can you check to see if you have the font installed locally, and if uninstalling it (or updating it) changes the behavior?


  What this might point to is room for a new high-level 
  language that maps better to the reality of current 
  hardware.
Isn't that exactly what the author said in his last two paragraphs, including a hand-wavy sketch of what he thinks that high-level language might look like?


Since the site is down and I can't read the article I can only guess here.

For me it's something with value types & memory coeherancy sematics. That's what you need to get the most out of your hardware.

Good candidates for that today are Rust, C, C++ and maybe C#(don't have enough experience with their value types to make a judgement yet).


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: