Chrome will Soon Let You Share Links to a Specific Word or Sentence on a Page - <AUTHOR> https://www.chromestory.com/2019/02/chrome-scroll-to-text/ <comment><USER2> Technical question, apart from the (valid IMO) political arguments: Google's idea to implement this is to append the text fragment to the URL in a "#targetText" pseudo-query-argument in the URL fragment part. This sounds like it would extremely easily break existing web pages who use the fragment part for their own state.

In the blog post, there doesn't seem to be anything addressing this (or even just specifying how Chrome would combine the "targetText" fragment with an already existing fragment part)

Did they spend any thought on this?

Edit: Oh, right, the readme answers this:

> _Web pages could potentially be using the fragment to store parameters, > e.g.[http://example.com/#name=test](http://example.com/#name=test). If sites > are already using targetText in the URL fragment for their own purposes, > this feature could break those sites._

> _We expect this usage to be exceedingly rare. It 's an abuse of the purpose > of URL fragments and page arguments are typically encoded using the '?' > character (e.g. > [http://example.com?name=test](http://example.com?name=test)). Still, we may > run an experiment to see if targetText is available enough to use as a > reserved token._

We'll just completely change the commonly understand processing model of fragment identifiers, but it'll be fine since we don't think anyone is using them anyway...

No further questions...

<comment><USER3> Feature author here.

I'd like to first clarify that this is still in the super-early stage of development; none of this is shipped or finalized yet. The feature hasn't even requested approval to ship at which point these kinds of issues would be brought up. We take web-compat very seriously. If this breaks even a small percentage of pages, it won't ship. Part of the shipping process is ensuring we have at least a draft spec (W3C,WHATWG) at least some support from other vendors.

Sorry, the explainer text came off more dismissive than I intended. I wanted to get something implemented so we could start experimenting and see how this would work in the wild. #targetText= is a a first attempt at syntax, any criticisms or data on how this might break would be appreciated.

From my (limited) understanding of how fragments are used like this today, the way this would break a page is if the page itself was using "targetText=..." and parsing the result. This is something we can and will measure and see if we have a naming collision. For pages that use a "#var=name" type fragment, we could append "&targetText=...".

I'm not tied to any particular syntax here so if I'm missing why this is a monumentally bad idea, please file a bug on the GitHub repo: [https://github.com/bokand/ScrollToTextFragment/issues](https://github.com/bokand/ScrollToTextFragment/issues)

<comment><USER4> This is not rare at all, I use it almost every time I link to a wikipedia article, for example: [https://en.wikipedia.org/wiki/Newton%27s_method#Examples](https://en.wikipedia.org/wiki/Newton%27s_method#Examples)

That said, it seems easy to make this backwards compatible: if the existing #blah syntax is a valid link, that should take precedence.

FWIW, I think there's way too much cynicism in this thread. My first reaction on seeing the title was "cool! I would use that!".

edit: Hmm, I may have misunderstood the compatibility issue.

<comment><USER3> > That said, it seems easy to make this backwards compatible: if the existing > #blah syntax is a valid link, that should take precedence.

That's indeed how it works. The majority of the compatibility concerns appear to be with apps that a using _custom_ parsing of the fragment to perform app- specific logic, which is a valid concern.

<comment><USER5> Angular 1 does this.

</comment></comment></comment></comment></comment><comment><USER6> I would like to urge the browser developers/makers to adopt existing proposals which came through open consensus which do precisely cover the same use cases (and more!)

W3C Reference Note on Selectors and States: [https://www.w3.org/TR/selectors- states/](https://www.w3.org/TR/selectors-states/)

It is part of the suite of specs that came through the W3C Web Annotation Working Group: [https://www.w3.org/annotation/](https://www.w3.org/annotation/)

More examples in W3C Note Embedding Web Annotations in HTML: [https://www.w3.org/TR/annotation-html/](https://www.w3.org/TR/annotation- html/)

Different kinds of Web resources can combine multiple selectors and states. Here is a simple one using `TextQuoteSelector` handled by the [https://dokie.li/](https://dokie.li/) clientside application:

[http://csarven.ca/dokieli- rww#selector(type=TextQuoteSelecto...](http://csarven.ca/dokieli- rww#selector\(type=TextQuoteSelector,prefix=ed%2C%20browser- based%20authoring%20and%20,exact=annotation,suffix=%20platform%20with%20built- in%20support%20\))

A screenshot/how-to: [https://twitter.com/csarven/status/981924087843950595](https://twitter.com/csarven/status/981924087843950595)

<comment><USER7> I'm so glad that google just sometimes ignores W3C's horrible design-by- committe nonsense. Its the same reason XHTML failed.

        #selector(type=TextQuoteSelector,exact=foo)

vs.

        #targetText=foo

/edited to be a more fair comparison

<comment><USER6> I urge you to dig a little deeper and see why things like `prefix`, `exact`, `suffix` exists in that particular example:

[https://www.w3.org/TR/selectors- states/#TextQuoteSelector_de...](https://www.w3.org/TR/selectors- states/#TextQuoteSelector_def)

Please note that you've actually changed the example!

If you just want to include `exact` or "targetText", you can still do:

[http://csarven.ca/dokieli- rww#selector(type=TextQuoteSelecto...](http://csarven.ca/dokieli- rww#selector\(type=TextQuoteSelector,prefix=,exact=annotation,suffix=\))

or equivalent:

[http://csarven.ca/dokieli- rww#selector(type=TextQuoteSelecto...](http://csarven.ca/dokieli- rww#selector\(type=TextQuoteSelector,exact=annotation\))

but that selects all instances of the text "annotation" in the document. Which is precisely why we need `prefix` and `suffix` to be able to identify the actual selection that the user made.

So, here is the equivalent of your example:

[http://csarven.ca/dokieli- rww#selector(type=TextQuoteSelecto...](http://csarven.ca/dokieli- rww#selector\(type=TextQuoteSelector,exact=browser- based%20authoring%20and%20annotation%20platform%20with%20built-in%20support\))

I hope that clarifies.

This is just tip of the iceberg! Let's stick to fair comparison and consider extensibility.

<comment><USER8> Even with that in mind, the W3C spec adds unnecessarily verbose syntax fluff.

<comment><USER6> We can only compare what's on the table, ie. arbitrary text selection. The targetText proposal doesn't necessarily result in a unique identifier that deterministically corresponds to user's original selection. So, I'm not sure if there is any point in discussing the syntactical differences on specificity further at this point. Having said that, at the end of the day, it is going to be the application that generates and uses the identifier.

Please have a closer into why we should be mindful of different use cases here, especially those pertaining to different resource representations, ways to "select", and factor in the state of the resource/representation at the time of the selection. It is there for use. It doesn't mean that all possible options needs to make its way into the identifier. This is important because people are going to use these identifiers in documents, and preserving context matters. Like I said earlier, the W3C Note has considered these, as well as permitting the use of different (RFC) selectors for different media. Let's reuse instead of NIH-FUD.

</comment></comment></comment></comment></comment><comment><USER9> Back in the days of yore, I've made a super simple userscript [1] that was used in my close circles exactly for this purpose; basically is just

        window.find(document.location.hash.substring(1))

And yes, it was really convenient to exchange links without need to add "and there search for %word%". I haven't probably seen any other use of window.find [2] ever since.

[1] [http://userscripts-mirror.org/scripts/review/8356](http://userscripts- mirror.org/scripts/review/8356) [2] [https://developer.mozilla.org/en- US/docs/Web/API/Window/find](https://developer.mozilla.org/en- US/docs/Web/API/Window/find)

<comment><USER10> Cool, it's like it's exposing Ctrl+F.

</comment></comment><comment><USER11> Why aren't XPointer/XPath fragments used instead of yet another half-backed reimplementation of the same concept?

XPointer and XPath have been ratified by the W3C in (...checks...) 2003. They have since been revised, slimmed down and used in countless XML-based applications and specs.

The cool thing about XPointer is that it is basically impossible that its fragments are already used in the target document. No site would break if XPointer were used.

Examples of XPointers:

* Pointer to _all_ the occurrences of "target text" anywhere in the page (goodbye JS-inserted <mark>)

#xpointer(string-range(// _, "target text"))

_ Pointer to all occurrences of "target text" in a <p> in the <main> article

#xpointer(string-range(//main//p,"target text"))

* Pointer to the second <h2> heading

#xpointer(//h2[2])

* Pointer to that specific bullet point that you want your colleague to change ASAP

#xpointer(//ul[7]/li[3])

* Abbreviated fall-back to XPath

#//ul[7]/li[3]

<comment><USER6> XPointer is one of options for a fragment selector in W3C Reference Note on Selectors and States: [https://www.w3.org/TR/selectors- states/](https://www.w3.org/TR/selectors-states/)

See also [https://news.ycombinator.com/item?id=19169582](https://news.ycombinator.com/item?id=19169582)

</comment></comment><comment><USER12> At first glance, this seems like a really half baked idea to me. Some immediate thoughts:

\- Wasn't there a draft spec floating around in the early 00s that tried to accomplish this, but didn't catch on?

\- Fragments are already used to link to fragments, albeit more author friendly than user friendly I suppose

\- This won't fly very well with sites that still make use of fragment based navigation, will it? (Believe it or not, I still see new projects use this over the history API!)

\- What happens if there's an element in a page with the id or name `targetText`? This is not mentioned in the very tiny compatibility section[1] (where some actual data wouldn't hurt, btw)

\- The linked proposal[2] already mentions that more specific fragment semantics is defined in other media types, so why not follow suit and propose the HTML spec is amended, instead of making this a user agent feature?

\- Fragments in URLs are already pretty useless in sites that don't load content until after the dom is ready, i.e. anything that just loads a bunch of JS and _then_ builds the site in the client – how would this fare any better?

[1]: [https://github.com/bokand/ScrollToTextFragment#web- compatibi...](https://github.com/bokand/ScrollToTextFragment#web- compatibility)

[2]: [https://github.com/bokand/ScrollToTextFragment#encoding- the-...](https://github.com/bokand/ScrollToTextFragment#encoding-the-text- snippet-in-the-url-fragment)

<comment><USER13> > (Believe it or not, I still see new projects use this over the history API!)

want to guess which one doesnt need JS, or server-side handling to work?

<comment><USER12> I think maybe you're misunderstanding what I meant by fragment based navigation – that's probably my fault. I refer to the shebang style fragments, that was used to implement deep linking in primarily JS driven sites. This of course watered down the use of fragments in pages, and nearly made them useless frankly. Ironically, the history API – which of course as you say requires JS to work – is what probably saved fragments from being completely useless, since it meant everyone could return to using paths for deep linking and _still_ implement their sites as JS blobs if they so chose. Moreover it opened up for hybrid approaches, where the server can actually serve a pre- rendered site that's then amended by JS (or not!) since the server would now see the full path that users were navigating to, as opposed to /my-catch-all- entry-point. Servers never get to see the fragment, after all.

<comment><USER13> the issue is that your server now needs to somehow understand which part of the path is the "fragment" without any distinguishing characters by which to parse it out of the url.

if the server now sees deep urls like `/products/patagonia/parkas`, how does it know which part is the fragment? is it /parkas or /patagonia/parkas? what if you have urls that are not completely uniform? or have different uniformity at different prefixes?

the router needs to be more complex. but i agree that the history API has advantages over shebangs for deep app links.

<comment><USER12> Point isn't so much that the server _needs_ to do anything, you can still just serve up the same response no matter the path, and have the client render different results – just as you would with a shebang style navigation in the past. The difference is that you know have options, which you didn't before since the server _never_ saw the fragment part of the url, only / or /entry- point or whatever. So you _can_ have more complex logic server side (really, this was done in the past long before in-client routing was a thing) but you don't _have_ to, it can still be deferred to the client to deal with. Using shebang style navigation you never even really had the option – the history API enabled this.

<comment><USER14> Lots of (mostly free) hosting just serves the files you upload, so that wouldn't work unless you copied the files to be served at every possible route.

<comment><USER15> "#" Fragments aren't sent to the server at all. They are ONLY used to get to a specific anchor (old school) or processed by JavaScript to do something (often fake navigation by showing and hiding content). This article is adding a 3rd magic use for them.

<comment><USER14> Yeah, I know. Parent was saying that the History API doesn't need any server support, because you can just serve the same file no matter what the subpath, but my point is that lots of servers don't even have support for that. That's why the fragment is still more useful than the History API in some cases.

<comment><USER12> Fair point, thanks for adding this perspective! I of course assumed there was at least a modicum of control over this server side but as you correctly point out if there is no such control then shebang style navigation is your only option if indeed you must do client side routing. I once abused custom 404 pages (I think in GH pages, but it may have been some other free host with similar functionality) in order to achieve this kind of behaviour. It was just a demo so didn't matter much, but of course this is far from ideal for anything else.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER16> Something open, standardized, quite similar and already working is Web annotations. This includes 'robust anchoring' capability which could surely be used to solve this problem.

[https://www.w3.org/community/openannotation/](https://www.w3.org/community/openannotation/)

Hypothes.is is a well established open implementation.

<comment><USER17> [https://web.hypothes.is/](https://web.hypothes.is/) is the URL parent was referring to, but there was a typo.

This looks similar to Genius.com's annotations. I wonder how this will evolve with multiple providers allowing similar functionality. Ideally you'd be able to combine annotation networks for a single URI to get all possible annotations you want on a given page.

Problems with these types of systems are the same as product reviews like on Amazon. Astroturfing & false information. It'll be interesting to see how that evolves.

<comment><USER16> Hypothes.is is general purpose but has a focus on scholarship. They have different namespaces (including global) and work with different communities (and customers) to provide overlaid environments.

Moderation and curation are perennial issues. Maybe these ovelays will help. It's not the same, but Reddit has different communities on different subreddits (with different moderation policies) discussing the same thing.

And re portability, they've made some very encouraging noises about data portability and exhange. It's baked ito the standard, and their default content license is, I believe CC something.

Thanks for catching the typo!

</comment></comment></comment><comment><USER18> Because that is exactly what we have all been clamoring for. Gee thanks Google.

Ok, that is more than a bit dismissive and I shouldn't be as cynical as I am about it but I switched to Firefox for a reason, this crap just keeps interfering. But oh wait, want to watch Youtube.tv in Firefox, oh so sorry you can't because it won't do video acceleration. I remember when you had to run Silverlight to watch Netflix too, that sucked as well.

<comment><USER19> I use Chrome for a few spare things (like Youtube and full-screen gslides) but for all else FF or Safari (both with ublock+umatrix) are much better. FF handles XML rendering way way faster than Chrome - great for my job.

<comment><USER20> How do you run umatrix with Safari? I've thought it's not available.

<comment><USER19> I got that part wrong - sorry to tease. No uMatrix in my Safari. Just content blocker + ublock-origin.

</comment></comment></comment></comment><comment><USER21> I can't find an RFC about this, but it looks like something similar has been proposed in the past, with a slightly different API.

> In URIs for MIME text/plain documents RFC 5147 specifies a fragment > identifier for the character and line positions and ranges within the > document using the keywords "char" and "line". Some popular browsers do not > yet support RFC 5147.[5] The following example identifies lines 11 through > 20 of a text document: > [http://example.com/document.txt#line=10,20](http://example.com/document.txt#line=10,20)

[https://en.wikipedia.org/wiki/Fragment_identifier](https://en.wikipedia.org/wiki/Fragment_identifier)

<comment><USER22> I must say I prefer the RFC version - while still vulnerable to rotting from text changes, at least it should still link to the same general vicinity.

<comment><USER23> HTML documents don't generally have the concept of lines since text reflow based on the way user agent (browser) is rendering the document. That's why the RFC only talks about text/plain MIME type - browsers render those with all line breaks intact. You can maybe use a CSS selectors, but that adds a tremendous amount of complexity and is not easy for non-web developers to read anymore.

<comment><USER22> Oops, good point. I suppose you could do by newline/paragraph plus character instead, but that would be even more vulnerable to text changes.

</comment></comment></comment></comment><comment><USER24> Very significant limitation: it only links to the first instance of the target text.

What is the expected behavior if you highlight a second instance of some target text and try to create a link to it? It's bad that the spec doesn't discuss it. I can see this happening with short selections, like linking to a single word.

Seems like this could use more thought.

<comment><USER25> I think this is being over thought a bit. Even in it's most primitive form, it could still be quite useful in practice.

It's pretty easy to construct cases where it fails, but _all_ such systems will fail either due to changes in content or changes in structure, and many will fail due to ambiguity as well. It's only really useful to compare how this might fare against other approaches. An example would be producing an XPath expression. Which may be more robust to ambiguity but weaker to structural changes.

This system will fail if the content is different enough that the target text is gone, which I believe is very reasonable. And while you could construct ambiguous text that couldn't be disambiguated by picking a larger string, in practice the value added with the complexity of trying to solve that problem is probably not very good. For the purpose of linking to sentences and paragraphs, this system seems sufficient and probably even better than many alternatives. I don't think many articles have a lot of repeating sentences.

Other use cases than linking to actual text would probably have their issues. Like, trying to link to a cell of a table would be quite problematic. That case may be better handled with something like an XPath expression, but in any case it's a fairly different use case imo.

All in all, my initial opinion is that this design is useful and easy to understand. It gives you the equivalent of Ctrl+F which is not bad.

(Disclosure: I work at Google, but this is the first I've heard of this and I don't work on Chrome.)

<comment><USER26> Why not just use fragments? It's pretty easy to place a unique fragment at all places you care to link, except perhaps in the very nice case of reimplementing Ctrl+F, which would need JS anyway, so why not just expose an API call, like window.find[1]?

I really don't understand what this brings to the table, besides making people upset.

[1] [https://developer.mozilla.org/en- US/docs/Web/API/Window/find](https://developer.mozilla.org/en- US/docs/Web/API/Window/find)

<comment><USER25> Simple, it doesn't depend on requiring the content to have lots of identifiers. While you may convince some web developers to just add more identifiers, you can't convince everyone. And for largely unstructured plain text like mailing list archives, there's not really a logical way to do that anyways.

Re: making people upset. I mean, nearly anything will upset people. One way a search engine could incentivize people to add more usable fragment identifiers is by ranking pages with them higher, but I am certain many wouldn't be thrilled by that.

If this is implemented I don't think it will actually raise serious compatibility issues, and it's not a huge deal to remove it later, it should degrade softly.

</comment></comment></comment></comment><comment><USER27> It seems like more and more, Google is leveraging their near-monopoly on web browsing to just skip the proposal process and do whatever they want without discussion.

<comment><USER28> I agree with you on Google's monopoly but imagine if every browser has to go through proposal process to release any feature? Everything will just stagnate.

Browsers copy features from each other. If this is a useful feature, it would make its way to other browsers pretty soon.

<comment><USER29> Stagnation is not always bad. For one, it helps keep complexity down. We're at a point where building a browser is impossible unless you have literally millions and millions of dollars to invest. That is not good.

<comment><USER30> If building from scratch maybe, but when was the last time a browser was built from scratch? Even Chromium was forked from WebKit.

<comment><USER29> That's my point. The web is so complex that browser engines are becoming a monoculture. Even if you forked Chromium now, you'd need hundreds of engineers just to keep up with all the new things that are constantly added.

<comment><USER31> And yet the fact that the major engine implementation is opensource still allows each vendor to innovate by adding new useful features to the users.

We're really far from IE6 era of complete stagnation.

<comment><USER32> Not really, as far as the core browser engine tech goes. In practice it's too difficult to maintain a Chromium fork that diverges in any significant way other than the front end. Opera and Edge (per announcement) use vanilla upstream Blink.

</comment></comment></comment></comment></comment></comment></comment><comment><USER33> Almost caught up to the capabilities of Ted Nelsons Xanadu Hypertext System from the mid 20th century.

<comment><USER34> I was just seeing a documentary about him (the Internet actually) by Werner Herzog. It was the first time I had heard about Xanadu or Ted Nelson. His ideas were quite radical from what I know as the Web. And I got to thinking how the web might have been had Xanadu become mainstream.

But then I opened the Wikipedia page on Project Xanadu, it's second paragraph is:

> Wired magazine published an article called "The Curse of Xanadu", calling > Project Xanadu "the longest-running vaporware story in the history of the > computer industry".[2] The first attempt at implementation began in 1960, > but it was not until 1998 that an incomplete implementation was released. A > version described as "a working deliverable", OpenXanadu, was made available > in 2014.

So... I don't know what to make of it.

<comment><USER35> It's basically as if he proposed a teleportation device, but couldn't deliver any of it. And when Tim berners Lee build an airplane which everybody started using he starts complaining on how much better his idea was. In recent years he's only been doing that last thing.

</comment></comment></comment><comment><USER34> Seems very cool!

But the functionality feels like it'd be prone to breakage as new text is added to the document (possible in Wikipedia articles for example). But it'd be super-helpful for search engines as they will have a relatively recent copy of the text, and can auto-generate the links on the backend before showing the search results to the user.

<comment><USER36> I'd assume a hash of the content would be included with the link, and if the hash changes, then it would make a best-effort guess at the right location, with a different color highlight indicating that it's a guess. At least that's how I would do it.

<comment><USER3> What would you hash though? Content on a page changes frequently and dynamically so the hash would mismatch very frequently.

</comment></comment></comment><comment><USER37> Is this going to lead to an api of #<keywords> for different scrolling to behavior?

Also, what happens if the page already has an anchor text that happens to be the exact match? i.e. #targetText=My%20Heading is already an existing anchor

<comment><USER38> Then the = should be encoded as %23 in the URL and should not be interpreted as #targetText=<encoded target text>

</comment></comment><comment><USER39> Let me guess, it has nothing to do with [https://www.w3.org/community/openannotation/](https://www.w3.org/community/openannotation/)

<comment><USER40> "Look at you, standards committee - a pathetic creature of humans and ideals, panting and sweating as you chase after my unrestrained "innovations". How can you challenge a perfect, immortal GOOGLE!" (c) Shodan, probably

</comment></comment><comment><USER41> Similar Javascript feature existed for a long time:

Link to first occurrence of "pseudo" on page: [https://trac.edgewall.org/wiki/TracLinks#/pseudo](https://trac.edgewall.org/wiki/TracLinks#/pseudo)

Link to last occurrence of "highlight" on page: [https://trac.edgewall.org/browser/trunk/trac/htdocs/js/searc...](https://trac.edgewall.org/browser/trunk/trac/htdocs/js/search.js#?highlight)

</comment><comment><USER42> How is this supposed to work when most web pages these days are a mash of dynamically generated javascript?

<comment><USER43> Same as regular URL hash I guess? (Browsers tend to wait a little if they don't find the target)

</comment></comment><comment><USER44> Can this be used to gain some informations about the content of a webpage, with a timing attack ?

Searching a phrase on a webpage will be faster when the phrase exists, on average. If this timing is observable, this could be exploited to guess the content of a web page.

Someone did this already with selector-based anchors: [https://blog.sheddow.xyz/css-timing-attack/](https://blog.sheddow.xyz/css- timing-attack/)

<comment><USER3> Feature author here.

The CSS timing attack actually influenced the design process heavily. The original design was to use a stripped down CSS selector but we found this too large of an attack surface.

There's definitely still concerns around making sure a 3rd party can't exfiltrate information from the page using this but we think we've found a set of restrictions that should prevent this: [https://github.com/bokand/ScrollToTextFragment#security](https://github.com/bokand/ScrollToTextFragment#security)

</comment></comment><comment><USER45> Using the hash for navigation is still quite common, because usage of history pushState requires server support to correctly work on reload.

I'd also argue that SPAs using it for navigation are not abusing it. The purpose is to allow linking to different sections in a document. Navigation is effectively an advanced form of the same concept. It's just that as you navigate, the DOM happens to mutate to bring the content you linked to into view, instead of just scrolling down to it.

Hash fragments are for page authors to define, not the browser. While this sounds like a useful feature, it's implementation is simply wrong.

What they really want to do is extend the RFC for URLs to add an additional component. There are already unsafe characters that could be used for this purpose that would be nonbreaking.

For example, add a | at the end of the hash fragment, and anything after that can be for the browser to communicate page state independent of the page author's intent.

The current proposal, however, should be firmly rejected.

</comment><comment><USER46> So Chrome users will unknowingly be offered to create links which won't work in other browsers?

How come I'm not surprised?

These links should if nothing else be prefixed chrome:// to be explicit about it not being real web-links.

<comment><USER47> Does that help, surely that just means other browsers have to support chrome:// if they decide to adopt that feature?

</comment></comment><comment><USER48> Track what you and your friends like, build a graph mine that data and earn more ad revenue.

</comment><comment><USER49> I'd like this for PDFs. Often I want to share a PDF opened at a specific text. You can create a pdf url which jumps to a certain page. You can even link to a search for a certain word (single word).

But I can't link to a search phrase in a PDF. For some reason, they implemented searching for single words, but not phrases.

<comment><USER50> Searching for text in PDFs is a not easy to do in general.

</comment></comment><comment><USER51> I actually wrote a really similar extension a year ago, please give me feedback!

[https://chrome.google.com/webstore/detail/target- search/nohm...](https://chrome.google.com/webstore/detail/target- search/nohmjponpgbnhjokbmagdbnjpnmdaigb)

</comment><comment><USER52> Hey, let's break standards in a dumb way, what could _possibly_ go wrong?

</comment><comment><USER53> Interesting. I think this is useful if implemented correctly.

I had an idea similar to this a few years ago. Basically, you would be able to bookmark your place on the page and come back to it later or send the link to someone else. I didn't think that using a word or phrase was useful because it could show up multiple times on the page. Instead, I used the scroll distance. Here's a crude demo:

[http://jboyer87.github.io/page-progress/](http://jboyer87.github.io/page- progress/)

Of course, this isn't device-independent. I never went much further with it.

</comment><comment><USER54> I remember how many websites (15+ years ago) used to offer something similar to this. JS would pick out the query used on a search engine (and sent with the referrer) to scroll to and highlight matches to the query.

</comment><comment><USER55> This is indeed very useful feature to share specific content. I built larynx 'A tool to share content along with voice' with similar intention. In larynx a user can share screenshot of the particular snippet along with voice.

I wanted to build a similar future in the feature where clicking the link would take the user directly to the snippet, of-course it would work only inside larynx apps; but with chromium penetration Google can implement this feature seamlessly.

[1]: [https://larynx.io](https://larynx.io)

</comment><comment><USER56> I'm very excited about this. I've always thought this should be a fundamental part of linking the web. Along with linking to times in videos, audio, etc. I think youtube allowing you to jump to a certain time via the url is a great example. I've wanted to share podcasts down to a specific point in a conversation many times, and if it wasn't a video, I didn't know how to do it. It just feels like a fundamental way to share information.

</comment><comment><USER57> This breaks so much stuff. So many websites use #something for a myriad of purposes. And it's their discretion, their website. I've never even seen #arg=val used in URIs ever, so nothing would be expecting that. Or #arg1=val1&arg2=val2.

This feels just like when I discovered that one day Chrome just decided to use the canonical address of a page instead of the actual address, when sharing it, telling no one. These people are a plague on this world.

</comment><comment><USER58> Glad to see google wasting no time on their new browser monopoly to screw up everyone else's experience and push their own vision for the web. /s

</comment><comment><USER59>
        #targetText=whatever

Ew, this is so hacky and bolted-on.

But I guess this is the price we pay for letting the WHATWG go on with their coup against W3C.

</comment><comment><USER60> Great feature and a pretty straightforward polyfill, could even be implemented before Chrome releases it (the context menu to get the link being the hard part, but a select text + tooltip with "Copy link to this text" would work, or I'm pretty sure good designers will find great UIs for it, might even normalizes as a new pattern)

</comment><comment><USER61> This really reminds me of [https://indieweb.org/fragmention](https://indieweb.org/fragmention)

What I don't get is how it will be handled if you have more than one occurrence of the phrase on that page.

</comment><comment><USER62> The usage isn't as _pretty_ as Chromes but usage allows for changes in original text to not break the link:

[https://github.com/NYTimes/Emphasis](https://github.com/NYTimes/Emphasis)

</comment><comment><USER63> I love this, or at least the general idea that it represents, though the specific implementation might be a little odd. (I'd rather the link to be some sort of 'coordinate' \-- like a CSS selector, but for text?)

<comment><USER14> Something like [https://news.ycombinator.com/item?id=19169582](https://news.ycombinator.com/item?id=19169582) ?

</comment></comment><comment><USER64> firefox has an extension that does similar [https://addons.mozilla.org/en- US/firefox/addon/pinpointer/](https://addons.mozilla.org/en- US/firefox/addon/pinpointer/) discussed here [https://news.ycombinator.com/item?id=17556805](https://news.ycombinator.com/item?id=17556805)

</comment><comment><USER65> In my mind's eye, I can see someone chaining multiple events to trigger malicious behavior with this.

-Would the scrolling occur AFTER page load?

-What if the text that is passed in is removed/never existed?

-What if the text exists in multiple places? I guess it immediately goes to the first instance, but if you are trying to link to the second, third, etc., this API wouldn't work...

-What if the text screws up a URL query parameter?

-How will this impact SEO?

-Would this still work if the parent element of a text node is set to "display:none"?

I just hope it doesn't become a thing with sites relying on this functionality.

</comment><comment><USER66> During my, I dunno, 25 years on the internet, the number of times I've wanted to do this is 0. Not sure about the value proposition here.

</comment><comment><USER67> I bet this has been possible to accomplish with a custom browser extension. And also, services like Evernote or Genius might help.

</comment><comment><USER68> So... like xpath?

<comment><USER69> Yes, but worse. There is not a single day when I'm not annoyed that xhtml was abandoned.

</comment></comment><comment><USER70> It would be nice if google would link to the part of the webpage where your search text appears.

Maybe this is a step towards that goal.

</comment><comment><USER71> Another feature inching closer to Xanadu. Excited for this!

</comment><comment><USER72> Like Medium?

</comment><comment><USER73> good news for UX

</comment><comment><USER73> wow

</comment><comment><USER74> Everyone in this thread needs to put their money where their mouth is and go back to Firefox if they're currently using Chrome.

<comment><USER75> Did exactly this, a few weeks ago. Was heavy Chrome user, now fully on Firefox (and Safari on mobile). I am so satisfied with this decision, and the transition was much easier than expected.

<comment><USER76> I would do it instantly if the devtools were half as convenient as Chrome. Unfortunately they are super clunky

<comment><USER77> What are you missing? I was feared of this too, but they seem to be just fine.

<comment><USER78> Can't inspect websocket frames. It's ridiculous.

<comment><USER77> I'm out of that, but maybe somebody else in here got an idea how to fix your problem with that.

<comment><USER78> My solution is to use chrome when faced with that particular limitation. There's a bug open on the mozilla tracker and it's been there for a while but no one seems to care.

</comment></comment></comment></comment></comment></comment></comment><comment><USER79> Real use case for this is so Google can poke into context for links shared via services they have no ownership.

They got used to know exactly what people share and, much more importantly, what people click on email, thanks to gmail rewriting all links to a google track url (while misleading the user by a fake status text on mouse over). When they sum the info of 1. who send it, 2. who clicked on it, 3. what was the email context, they can further classify the page content. (for ads, search ranking, whatever they do today)

But they can't do that on whatsapp, facebook, etc. With this "feature", now they have at least a modicum of context when the page impression show up on their Google Analytics trackers. Did you visit that wikipedia page because of recent news events, or doing homework?

Or, we could just go with occam's razor and believe that a bunch of bored engineers at google decided to simply add a feature completely disconnected from any of their business plans, and spent a few months tweaking a git repo with nothing but a README file... while the actual code review has follow up questions that were left open and merged anyway: [https://chromium- review.googlesource.com/c/chromium/src/+/14...](https://chromium- review.googlesource.com/c/chromium/src/+/1434215/17/third_party/blink/renderer/core/page/scrolling/text_fragment_finder.cc#57) ¯\\_(ツ)_/¯

<comment><USER80> It's a shame because it is actually a good idea, but now Google has first- mover advantage, so any other implementations will just be a clone of what Google already did.

<comment><USER81> [http://archive.is/](http://archive.is/) got there first, sort of. If you archive a page then highlight some text, the URL changes to a direct shareable link to that text.

Bonus: being its own site, and implemented in javascript, it's already cross- browser.

</comment></comment></comment><comment><USER82> I am having trouble deciding if Google has finally beaten Microsoft on the 'we can do what we want to' front, specially given that Microsoft is running backwards in that race of-late?</comment>


Would that songs' "sharing" model violate copyright laws? - <AUTHOR>

So lately I have been to my friends house and he has like entire wall of CD, probably 10,000 or so.
I was browsing through and picked 4 that I like. He told me no problem, as I always return them "on time".
Then he said "you're web programmer, why dont you build a website where I could upload my music instead of you coming and looking through CDs one after another?", so I smiled (he is not that much into computers or internet) and replied "that's like a graveyard of companies that did it and quickly got in serious legal troubles". Although I am not aware if someone is/was in jail for audio copyrights infringement, but I am sure its not easy to live with $1B in liabilities because you had 1,000 songs and the judge said each was worth $150,000.
So he replied: "well, you borrowing those CDs from me right now. This is not illegal, as I do not make any money off of you and the same time if you posses those CDs, I cannot listen them at the same time, riight?".
Does he have a point or not?
In other words: lets say I design a simple website based on Amazon S3 (traffic) where you can upload your music (I could do a md5 checksum on client side of each file and if a it exists on server, skip uploading part [I know there are different bit rates and coders etc but that checksum approach would limit bandwidth usage anyways]) and "share it" with acknowledged/accepted friends only via "borrow/lend" model.
If A and B are friends, then A can look through B songs list, and B can look through A songs of list. At any time, either A or B can "borrow" a song/CD from B or A. Once this happens, that song/CD become unavailable to the owner, until he request it back (then it "comes back" right away into the owner's profile, and lender looses rights to play it). There would be no functionality to download/copy/own the song by lender (you could only play it via web or maybe some stand alone player or perhaps a plug-in to existing players?), but I wouldn't loose any sleep or put serious efforts into protecting the system, since there are always ways to break into it or copy files.
So what do you think?
Sharing to me means you had something (a file), you split it (copy) into two and shared it/pirated it. In this case, only one person at the time would have/own the song/album. Is it still pirating?
I wonder if that model would keep RIAA's claws off and give them some serious headache. ;-) <comment><USER2> Nothing can keep the RIAA off you; if they want to sue, they'll sue.

The main difference between lending CDs and "lending" digital files is that copies are being made in the latter case, and The Man will say that those copies are not authorized, are not necessary for playback, and are not fair use. The Man also sometimes takes the position that an individual cannot "outsource" their fair use rights, so even if it's legal for you to personally make a copy in some situation, they claim it's not legal for you to authorize a third party (especially a for-profit company, e.g. a music locker) to make that same copy on your behalf. So some things that might be legal in a P2P implementation (as long as it's not _called_ "P2P", they hate that) would be seen as illegal in a centralized Web 2.0 implementation, and since it's so hard to make money from P2P people just don't bother.</comment>


Ask HN: Feedback and beta test our new type of VPN service - <AUTHOR> https://www.oeck.com/features/ <comment><AUTHOR> Hi everyone,

We are in need of beta testers for our VPN apps and service. We have a few beta testers, but we are in need of many more.

The VPN provides new features that are unique to Oeck. We also offer high levels of security. Any and all help would be very much appreciated.

The service is completely free for the duration of beta, so please feel free to use the service for as long as you like.

Regards, Peter @ Oeck.

<comment><USER2> Why should we trust you with our internet traffic logs?

In my opinion, the answer is much more important than any one feature.

<comment><USER3> To add to this, three more pieces of feedback:

1\. Where is the company incorporated? This is a critical piece of information when choosing a VPN provider, and I cannot find it anywhere on your website. It should be front, and centre.

In Germany the law says you need an "Impressum" page added to your website, with your company information on it. While I do not live in Germany, I made a point of adding that page to every website I put online[1].

2\. The website does not work with JS disabled. If you tell me you sell security, or privacy, and your website does not work with JS disabled, I will likely walk away.

3\. In general, I tend to trust a company more if they open source their code, and if they run their business in the open. Mullvad[2], and Confirmed VPN[3] come to mind.

I would also recommend that you read, and try to meet the criteria set by the PrivacyTools folks[4], as a lot of your target audience will come from them, and trust their choices.

EDIT: Found the incorporation information in the FAQ after navigating a bit[5]. That is on me, my sincere apologies.

[1] [https://i.cpimg.sh/jEtNeUSR4TEd.png](https://i.cpimg.sh/jEtNeUSR4TEd.png)

[2] [https://mullvad.net/](https://mullvad.net/)

[3] [https://confirmedvpn.com/](https://confirmedvpn.com/)

[4] [https://www.privacytools.io/providers/vpn/#criteria](https://www.privacytools.io/providers/vpn/#criteria)

[5] [https://www.oeck.com/faq/privacy_and_security/](https://www.oeck.com/faq/privacy_and_security/)

<comment><AUTHOR> Hi jamesponddotco,

Thank you very much for taking a look! Although you have found information in your edit, I will reply so that other users viewing the thread have an easier time reading it.

1) The company is incorporated in Hong Kong. Although we are Australian, the privacy laws in Australia suck. We wanted to keep our customers safe, so that is what ultimately lead to the decision. You can find this information at [https://www.oeck.com/faq/](https://www.oeck.com/faq/) and more specifically at [https://www.oeck.com/faq/privacy_and_security/](https://www.oeck.com/faq/privacy_and_security/)

2) The website is built on top of Xenforo ( [https://xenforo.com](https://xenforo.com) ). Our navigation, .ovpn builder, alerts and other features rely on JS in order to function properly.

3) I answered this in the post above, but here is the copy/paste.

Open Source apps - Due to the way our VPN works, we found the best solution for us was to use the libvpn libraries. They can be found at [http://libvpn.com/](http://libvpn.com/)

These libraries, unfortunately, are not open source. However, they are very powerful and the code is of good quality. Due to this, we are unable to make our apps completely open source.

Again, open sourcing the apps, although it looks good, ultimately doesn't mean anything. Any malicious activity can be done in the back-end. The apps source code may show up fine, but the back-end of the service can do whatever the owners want.

That's not to say open sourcing them isn't a good thing, it is just that aside from the fact that we can't do so, ultimately it means little if the service provider wanted to screw its customers.

Thank you for the Impressum idea. We will add that soon. It is a good idea and easily implemented.

Regards, Peter @ Oeck.

<comment><USER3> > Our navigation, .ovpn builder, alerts and other features rely on JS in order > to function properly.

At the end of the day, that does not matter for the customer. If they have JS disabled, and you force them to enable it, you lost a customer.

As customers, we are expected to have JS enabled for signing up, and logging in, but a marketing website should not require it.

> Again, open sourcing the apps, although it looks good, ultimately doesn't > mean anything. Any malicious activity can be done in the back-end.

Sure, I agree with that.

However, notice that I said "if they open source their code, and if they run their business in the open". There is a lot that you can open source, but more importantly, you can operate your business in an open, and transparent way.

Take Confirmed VPN[1] as an example. They allow you to request a read-only account to audit their infraestructure, and AWS account, to make sure they do what they say they do.

Or SourceHut[2], which make most of their business decisions in the open, for anyone to see.

Opening your code is not the only way to have an open business.

[1] [https://openlyoperated.org/report/confirmedvpn](https://openlyoperated.org/report/confirmedvpn)

[2] [https://sr.ht/~sircmpwn/sourcehut/](https://sr.ht/~sircmpwn/sourcehut/)

<comment><AUTHOR> Hi jamesponddotco,

Thanks for taking the time with this.

Unfortunately there is not much we can do about the JS. We can put up static pages for marketing, but ultimately the website is there for the user to control various things to do with their account. It also allows guests to perform various tasks.

As far as your other point about the business itself being open, we are trying to run it in that exact manner. Regarding the audit, I replied to another user ( [https://news.ycombinator.com/item?id=23666681](https://news.ycombinator.com/item?id=23666681) ). However, if you have an idea on _how_ we can run the business more open, I am happy to take it on board. We keep users in the loop, took time with our terms of service and privacy policy, as well as provided a bunch of information in the FAQ.

Regards, Peter @ Oeck.</comment></comment></comment></comment></comment></comment>


Brad Pitt, Laurene Powell Jobs are reportedly invested in 'cold fusion' energy - <AUTHOR> https://www.cnbc.com/2019/06/14/brad-pitt-and-laurene-powell-jobs-are-reportedly-invested-in-a-mysterious-cold-fusion-energy-company.html <comment><USER2> They may be rich investors, they are certainly not smart</comment>


NuoDB another NewSQL database. - <AUTHOR> http://nuodb.com/ <comment><USER2> To be completely honest, I have never heard the term "NewSQL" before in my life. After a quick Google, it seems that the term basically means "SQL databases that go FAST LIKE NOSQL." (Though it's not really popular.) Which is, once again, completely missing the point.

I can't speak for professional devs - I'm just a hobbyist - but I'm not developing for "NoSQL" databases like CouchDB and Redis because I want to do SUPER WEB SCALE. I'm developing for CouchDB and Redis because they offer truly interesting alternative ways to look at your data. (In fact, Redis is what got me interested in data structures.) And if I wanted to write a project that used data that makes sense from a relational standpoint, SQLite (for development) and Postgres (for production) are just fine with me.

<comment><USER3> There are a lot of people who would like a full-fledged relational database that scales up to large clusters. Just because you're not one of them doesn't mean they don't exist, or that they're "completely missing the point."

<comment><USER2> I was referring more to the marketing aspects of the term (and proposing their solution as a counterpart to "NoSQL"), than the concept itself. There are a lot of people who think that "NoSQL" is all about magic scaling sauce, and this isn't really helping.

<comment><USER4> I don't really understand why one would accept the trade-offs of "NoSQL" if you aren't interested in "magic scaling sauce" (and clustered redundancy).

What's the advantage here? Less rigorous schema, moving data modeling and constraints into the more complex application code that's much more likely to have bugs?

I can't tell you how many times database constraints have caught application bugs with fatal data correctness consequences on the products we've worked on.

The only reason I can see for abandoning those declarative constraints is because of the scalability issues one must contend with (and even then, I'm somewhat unconvinced that they matter for all but the highest-load entities).

<comment><USER3> Some the the databases grouped under the over-broad NoSQL umbrella have reasons to use them other than magic scaling sauce. Redis, for example, is a ridiculously fast in-memory database that gives you data structures like sets, lists, hash tables, strings, numbers, and so on. It's tremendously useful for some problems.

For example, at Greplin we're using Redis for our document analysis pipeline. We're pushing thousands of documents through Redis every second, using it to durably hold data while it gets passed around through our various back-end worker server clusters. We've been very happy with how Redis has been performing; it handles the write-heavy workload beautifully, and is way more resistant to data loss than most systems for doing this sort of thing. We'll be even happier when it gets server-side Lua scripting in a stable release, and we can define our own commands. The point is, though, that this would be crazy to do with a traditional SQL database, or even something like Riak or CouchDB or most of the other NoSQL databases. Redis fills a different niche, and filling a lot of cool niches is what I think the NoSQL stuff should be about.

</comment></comment></comment></comment></comment><comment><USER5> For those wondering about it, don't bother searching for 'NewSQL'. It's a buzzword that doesn't actually mean anything other than 'it's not mysql, pgsql, oracle, or mssql.' They claim to improve on the standard DBs, but every single DB does it in a different way. The name is useless.

Instead, read the 'who we are' and 'how it works' bits on NuoDB's page. They were much more informative.

I think it sounds exciting and fresh... And doesn't seem to be open source at all.

I'm not allergic to paying money for software, but I've found I'm happiest when using something that I can guarantee will survive, even if may have to do so by my own hand. Commercial products have a tendency to be a pain in the rear.

<comment><USER6> Thanks for the heads up (was looking for more real info and not the damnable 'beta signup' form)

This sounds like SQL ontop of Cassandra (for a more or less mental-map if you are looking for one):

      Our distributed non-blocking atomic commit protocol allows database
      transaction processing at any available node. The system is
      designed to provide a consistent view of data, high availability,
      and the ability to detect and manage partitions in a predictable
      and consistent manner. Query processing scales with the number of
      available nodes, storage scales according to the choice of storage
      manager of which there are many. Storage managers are key/value
      storage engines that also operate as a distributed in-memory cache
      and participate in the commit protocol to ensure durability
      guarantees.

<comment><USER7> Given that they seem to favor consistency in the CAP model, it would be closer to Hbase in this regard. Cassandra is, by design, eventually consistent and can not offer these same guarantees.

<comment><USER8> This is false. Cassandra can offer any level of consistency you desire, on a per-operation basis. See the "ConsistencyLevel" section of <http://wiki.apache.org/cassandra/API>. The tradeoffs of the CAP theorem, of course, apply. But if you want 100% consistency (availability and partition- tolerance be damned) it's there for you.

There is a general misconception that the an entire DBMS must pick tradeoffs based on the CAP theorem. (IE, you can use a database that offers availability, but can NEVER offer immediate consistency) Instead, a DBMS may offer different CAP guarantees per operation.

<comment><USER9> I don't think so. Does Cassandra provide guarantees regarding the ordering of queries? Cause I couldn't see that.

Another problem I can see is when you write to 3 nodes, have W=2 and a write succeeds only one one node. Then later on through read repair the value propagates to the other 2 nodes. So our write "failed" but really in the end succeeded. I'm not too much into the Cassandra details but those two things immediately came to my mind when reading some of the wiki pages.

It boils down to not using/offering algorithms like 2-Phase Commit or Paxos but more sloppy quorums.

So from what I can tell, Cassandra can not guarantee strong consistency. But then again I could be wrong and missed something.

<comment><USER8> Taken directly from the page I linked from above:

"Note that if W + R > ReplicationFactor, where W is the number of nodes to block for on write, and R the number to block for on reads, you will have strongly consistent behavior; that is, readers will always see the most recent write."

Could you explain why this is incorrect? It seems the Cassandra devs use the definition of "consistency" from Brewer's paper, and Cassandra offers this level of consistency.

Your point about read-repair is correct when using QUORUM consistency level, but even then you can avoid that by using the ALL consistency level.

</comment></comment></comment></comment></comment></comment><comment><USER10> Now with _Cloudbursting_!

Looks like they are doing a pure enterprise push: _NuoDB, Inc., the thought leader in cloud database technology, ..._

</comment><comment><USER11> I'm a big fan of relational theory and I'm always happy to see any activity in this space. However, their "revolutionary" distributed model seems to be similar to something which is already out there, open source, and ready for use:

[http://bandilab.org/blog/2011-06-22.Ostap.Running_on_Multipl...](http://bandilab.org/blog/2011-06-22.Ostap.Running_on_Multiple_Nodes.html)

or maybe I just don't have enough information about the nuodb ?

<comment><USER12> Nope. Not enough info on NuoDB.

NuoDB doesn't have a centralized transaction controller. It doesn't have a centralized anything. And it isn't "like" anything else -- all new. It's a distributed database without distributed transactions.

In a nutshell, it isn't based on pages or disks but distributed objects. Each distributed object, called an atom, can exist in as many places as necessary. Each atom instance knows of the other instances and replicates changes. Transaction nodes do SQL and are diskless. Archive nodes listen to replication and store serialized atoms on disk, S3, or some other KV store. If a transaction node needs an atom, it gets it from another transaction node or, at last resort, from an archive node that fetches the atom from disk, S3, or wherever.

<comment><USER11> fair point about the transaction controller, this is indeed something which is not yet distributed in bandicoot. Though, I don't think it's a big deal as the tx is really simple and lightweight.

Anyway, let's go back to nuodb :) I'm really interested on how it manages the whole ACID. I did not get it from the page nor from your reply.

For simplicity, let's pick on durability only. The archive nodes listen to replication and store serialized atoms on disk. At the same time the atoms replicate the changes to other instances. Is the durability achieved by a synchronous replication?

</comment></comment></comment><comment><USER13> Has anyone actually tried this wonder-machine or is it Vaporware?

I remember submitting an evaluation request almost a year ago but never received a response.

Their homepage and blog don't seem to have changed since then either; no real information anywhere, only truck-loads of PR fluff.

</comment><comment><USER14> Their claims reminded me of Jim Starkey's history with the CAP theorem: [http://pl.atyp.us/wordpress/index.php/2010/03/cap-and- leases...](http://pl.atyp.us/wordpress/index.php/2010/03/cap-and-leases/)

</comment><comment><USER15> in case anyone else was wondering: the key CAP-related "compromise", from "how it works", is that on partition it supports transactions on only one sub-set of nodes (the "healthiest"); the others provide read-only snapshots.

<http://nuodb.com/how_it_works.html> (see "Availability and Resiliency").

<comment><USER16> In other words, it's plain old CA.

</comment></comment><comment><USER17> Anybody know why they changed the name? Nimbus seems more pronounceable.

<comment><USER6> To add validity to their new term "NewSQL" possibly? (I don't know, just guessing).

To the "NewSQL" term, I don't really have a problem with it... from their "how it works" it sounds like they are genuinely doing something interesting and cool with SQL. I have no qualms with them calling it "NewSQL".

I don't know why marketing terms get people so mad, sometimes they make sense.

I'd also point out that the first few times people used "NoSQL", I imagine there were comments along these same lines talking about how silly it was.

It isn't like they named it "WebScaleSQL" :)

<comment><USER12> Marketing statements notwithstanding, the name change was the result of something really boring -- a name conflict with another company.

Oh, "New-oh dee bee".

</comment></comment></comment><comment><USER18> can't wait to read the white paper

<comment><USER19> I'm guessing you're referring to their claim of being able to do distributed transactions?

 _Data is spread out across transaction and storage nodes and it always available. When network partitions occur NuoDB continues offering services via the most available and healthy segment while the other segments provide a consistent read-only snapshot while awaiting reconnection at which point they will synchronize with their counterparts. Clients can simply reconnect to the active partition of the cluster to continue processing updates._

I'm not sure how they can ensure that network partitions only occur between fully replicated sets (i.e. how can all the data be available in all locations?)

</comment></comment><comment><USER20> Alas, I can't downvote this link.

Can anybody explain why I should go with this instead of Pg?

To the submitter or anybody else sufficiently knowledgeable: When will ORMs get support for this? I use SQLA but could port Django or ActiveRecord code.

<comment><USER21> _disclaimer_ : I have a bias as we could be seen as a "competitor".

If I understand correctly, their SQL engine can scale through the use of a proprietary peer to peer technology. This would be new and would indeed make it possible to solve bottlenecks and scale the SQL database to a very large number of nodes.

However, I think it misses the point where SQL is simply not always needed. They will always be slower than a NoSQL engine that scales well.

Your example of ORMs is on spot: do you really need SQL as the back end of an ORM? If not, why pay the relational tax?

No silver bullet.

<comment><USER12> The question really isn't SQL but ACID transactions. If you can do ACID transaction, SQL drastically reduces the amount of data transmitted.

There is no intrinsic reason that ACID transactions, with or without SQL, can't scale, just that up until now, it hasn't.

And there's a reason that until now, it hasn't. From the beginning of time, academic computer "scientists" have confused the terms serializability and consistency. In short, serializability is a sufficient condition for consistency, but it isn't a necessary condition. If you design a system that enforces consistency without requiring serializability, it scales. Period. Legacy RDMSes don't work that way, but that's their problem.

<comment><USER22> Huh. Your insight is an interesting one, but I am having trouble understanding how it is actually useful.

If I may reduce to a concrete example:

Posit shared variables x and y, both zero, and simultaneously do (on threads T1 and T2)

        T1: atomic { y = 1; return x; }
        T2: atomic { x = 1; return y; }

where 'atomic' indicates a transactional operation.

Traditional ACID rules would state that either T1 takes effect before T2 (and so (T1, T2) return (0,1)) or T2 before T1 (so they return (1,0)). Other interleavings are not permitted -- returning (0,0) or (1,1) would violate consistency.

What it seems to me that you are saying is that both (0,0) and (1,1) might be OK, depending on your application domain -- maybe the app can specify a consistency rule that says that (1,1) isn't OK. Then you can design databases that follow application-directed consistency rules.

At first blush this seems impractical, so I am hoping you can elaborate on the point you were trying to make.

<comment><USER12> The C in ACID is consistent, not serializable (i.e. it's not ASID). Consistency means that declared consistency constraints are enforce -- no dirty writes, no violations of unique indexes, referential integrity, and anything else that the bells and whistles supports.

Let me give a simpler example: Database with one table of one field, a number. One transaction: count the number of records and store that number.

A serializable system will force one zero, one one, one two, etc. But a consistent system can have two zeros and no ones. Why? Because that's what each concurrent transaction saw? Nothing wrong with that. But if application semantics dictate that each value must be distinct, then put a unique index on the number and the system will enforce uniqueness. Automatically enforcing "auto-magic" constraints that nobody cares about is why serializability destroys scalability of distributed system.

In NuoDB all messaging is asynchronous and batched, making it very fast and efficient.

For more than you want to know, see [http://www.gbcacm.org/sites/www.gbcacm.org/files/slides/Spec...](http://www.gbcacm.org/sites/www.gbcacm.org/files/slides/SpecialRelativity\[1\]_0.pdf)

Someplace there's even an audio recording which I recommend if you're into self-abuse.

<comment><USER23> So running with your example, assume I have a transaction that adds 5 to a column value and then reads the value back.

If I start with a value of 0, then run my transaction twice, can both transactions return 5? Or is it guaranteed that one will return 10?

<comment><USER15> [sorry. replied earlier incorrectly]. one of the two transactions would abort in this case. snapshot isolation needs to check that any data mutated in the transaction were not also mutated externally. in the example you are replying to, there is no mutation, and so no problem, but in your example there is. see <http://en.wikipedia.org/wiki/Snapshot_isolation>

note that it's only _mutated_ values that are checked for conflicts, and only against other mutations (this is why it is efficient - the number of checks required is small). so you can get weird behaviour when multiple values are read while different transactions change each - there's a good example in the link above. this is called "write skew".

the whole approach is, in a sense, exploiting poor phrasing of the ansi sql-92 standard, which doesn't actually require serialisation even though that is the most natural way to interpret it (as far as i understand things). so you can think of MVCC as "exploiting a loophole" that leads to a more efficient system, but one that is less intuitive. on the other hand, this is not new - it's already the standard behaviour for postgres, oracle, sql server, etc.

<comment><USER11> Thanks for the clarification. However, this does not sound like something I could use in practice.

If I have two transactions and one of them is aborted because of the changes done by the other transaction what am I as a developer supposed to do? Retry? I hope not, because a retry is in other words serializing the execution. One after another.

So, if I have a system with a lot of concurrency (i.e. bank accounts and transfers) I'd better not use NuoDB because I'd get a lot of transfers aborted, not good. If I have a system with a very little write conflicts I'd go for serializability because that gives 100% consistency and will be fast anyway due to very little conflicts.

From the wikipedia link you posted, it is fairly clear that the Snapshot isolation is good when you don't need consistency. For that you'd have to either abort every time there is a conflict or introduce write-write conflict (ie. serializing).

<comment><USER15> (1) serializability will not be "fast anyway". it will be slow. this is the problem with, for example, mongodb's global write lock.

(2) you would not get "lots" of aborts with bank accounts because each transaction is, typically, to a different account. you're only going to get a problem when two processes try to change the same person's account at the same time.

(3) what this provides is standard-compliant ACID sql, the same as postgres, oracle, sql server, etc. if you use any of those and don't have retry in your code for when transactions fail then you're already in a mess.

i am not associated with this project, but what you're saying doesn't really make sense. as far as i can see, you're criticising it for being the same as everyone else in the standards compliant, sql world.

<comment><USER11> I'm not criticising it for being the same as everyone else. I'm just not sure how the whole thing works. I don't see enough information provided on the site, yet a lot of statements about providing full ACID and scalability.

re 1) and 2). I think they are related. The serialization can be done on account level. There is no need to have a single global write lock. This also implies that if the bank account transfers are typicaly to different accounts the serialization will be as often as the aborts. Hence very rare and the system will perform equally good in both cases. However, the serialization does not require further retries and doesn't force the application programmers to workaround the problems.</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment>


ECM – T.38's Dirty Little Secret (And Why It Matters) - <AUTHOR> http://blog.t38fax.com/blog/ecm-t38-dirty-little-secret <comment><USER2> Excellent article, being in IP Telecom I know how difficult it is to successfully use fax over G.711 audio-based SIP Trunks. Kudos!

<comment><AUTHOR> Thanks! One of my favorite articles actually, be sure to check out their service too!</comment></comment>


Elm, Elixir, and Phoenix: Reflecting on a Functional Full-Stack Project - <AUTHOR> https://teamgaslight.com/blog/elm-elixir-and-phoenix-reflecting-on-a-functional-full-stack-project <comment><USER2> If anyone wants to learn more about the stack, Pragmatic Studio are about to release their course on Elixir/Phoenix/Elm - building Multi-Player Bingo. [https://pragmaticstudio.com/courses/unpacked- bingo](https://pragmaticstudio.com/courses/unpacked-bingo)

I worked through their Elm course and it was excellent.

<comment><USER3> Your comment landed kind of spammy, is it a free course?

<comment><USER4> There are many comments on HN which recommend products/services that are not free. The fact that the course has a cost doesn't make the comment "spammy".

If the parent posted an affiliate link then that would have indeed been spam.

The courses from Pragmatic Studio are indeed excellent. Sometimes quality has a cost, and people should be ok with that. Not everything will be a free resource.

Note: I have no affiliation with Pragmatic Studio, they are just great courses.

<comment><USER3> Yeah, I should just ask the price ballpark.

It was not meant to criticize the OP but English is not my first language and sometimes I sound judgmental by mistake.

<comment><USER4> The courses on Pragmatic Studio are $50-80 each depending on the their length, which varies from 8-10 hours each.

</comment></comment></comment></comment></comment><comment><USER5> I'm a big fan of Elixir, but the community gravitation toward Elm has always struck me as a bit weird.

The two languages have nothing in common beyond both being functional, and it kinda feels like someone posted a "Elixir and Elm" blog post in the early days and it all just snowballed arbitrarily from there.

<comment><USER6> What are some relatively popular alternatives (that are not on the JVM)? Maybe the options are somewhat limited here if you want both to be functional.

<comment><USER7> Why not JVM? I'm asking because I'm starting to learn functional and I think Clojure is a very nice language to write both backend and frontend.

<comment><USER8> The JVM is a great kitchen sink environment. The BEAM and Erlang/Elixir are much more finely tuned for their strengths: distributed systems, fault tolerance, immutable data/functional programming.

If you need raw performance, the JVM is definitely better. If you don't want to have to deal with the inherent tension between a FP language and mutable surroundings, the BEAM is worth a look.

</comment></comment></comment></comment><comment><USER9> Seems pretty inconvenient that the library you want to use isn't allowed in elm's package repo.

edit: FYI, you have a typo:

> This is represented in Maybe's definition: type Maybe = Just a | Nothing.

Maybe's type is type Maybe a = Just a | Nothing

</comment><comment><USER10> That was a much more involved read than I expected. I haven't really tinkered with Elm much, despite hearing a lot about it.</comment>


GNU Hurd - <AUTHOR> https://www.gnu.org/software/hurd/hurd.html <comment><USER2> Is there any specific reason why it's on the front page _today_?

P.S.: Just checked xkcd, I guess it's because it have been mentioned in today's comic...

<comment><USER3> 2042 appears to be an important year in history!

</comment></comment><comment><USER4> [http://xkcd.com/1508/](http://xkcd.com/1508/)

<comment><USER5> The idea that some elderly neckbeard would, decades after the fall, still be painfully hacking away at Hurd amid the decaying remnants of a dead civilization is a vision easy to see.

</comment></comment><comment><USER6> What is the deal with GNU Hurd? I know it's become a bit of a punchline for software being late, but does anyone use it for anything?

This site says you can get a build of Debian based on Hurd instead of Linux -- does anyone use this? Is it purely an academic curiosity at this point?

<comment><USER7> Multiple attempts at replacing the Mach microkernel have fizzled out, meaning it's not even academically interesting. If Coyotos or Viengoos or L4.Sec had ever worked out, there would be something genuinely useful that people might want to work on.

<comment><USER8> I wasn't aware there were attempts to replace Mach with something else inside Hurd. I am really interested if you can share a bit of history about this; Especially if it's related to L4 and capability-computing. Same as Symmetry below, I would be interested in any L4 and seL4 based general purpose operating system project.

<comment><USER9> Very brief history is here:

[https://www.gnu.org/software/hurd/history/port_to_another_mi...](https://www.gnu.org/software/hurd/history/port_to_another_microkernel.html)

</comment></comment></comment></comment><comment><USER10> In any case, RMS is absolutely right about people not giving GNU enough credit in naming or in general.

<comment><USER11> GNU is becoming progressively less and less important.

The "killer apps" for Linux have never been GNU. Apache httpd and XFree86/Xorg are by far and above the most popular applications on Linux, and they aren't GNU projects.

Graphically, GNU is at its nadir of influence. Freedesktop.org controls most cross-desktop standards, libraries, and services. GNU's own desktop environment GNOME is no longer _nearly_ as popular as it used to be thanks to GNOME 3 being actively hostile to desktop users (and GNOME has always been part of GNU on paper only -- it's effectively a Red Hat project).

On the platform side, the init system has never been GNU. While the init system has always been a minor part of the OS, this is changing thanks to systemd (also a product of freedesktop.org) getting its hooks into everything on several levels.

Actually, I'd go as far as to say that freedesktop.org has far more influence on the userland than GNU does right now.

<comment><USER12> _GNU 's own desktop environment GNOME_

I am pretty sure GNOME is separate from GNU/FSF.

<comment><USER9> GNOME project, and its products, are the work of the GNOME Foundation [0], not GNU/FSF.

GNU links to GNOME from the name "gnome" within its list of "GNU packages" [1], but GNOME is, and has been for some time, its own separate organization. GNU claims that things it lists as "GNU software" consist of software "released under the auspices of the GNU Project" [2], but that doesn't seem to apply to GNOME in any meaningful sense _now_ , though _historically_ GNOME _was_ a product of the GNU project.

EDITED: to reflect historical relationship noted in cwyers reply.

[0] [https://www.gnome.org/](https://www.gnome.org/)

[1] [http://www.gnu.org/software/software.html](http://www.gnu.org/software/software.html)

[2] [http://www.gnu.org/philosophy/categories.html#GNUsoftware](http://www.gnu.org/philosophy/categories.html#GNUsoftware)

<comment><USER13> Looking at the history:

[http://www.gnu.org/press/gnome-1.0.html](http://www.gnu.org/press/gnome-1.0.html)

> The Free Software Foundation (FSF) announced the release of GNOME (GNU > Network Object Model Environment) 1.0 today at the Linux World Conference. > GNOME is an integrated desktop environment designed to run on GNU/Linux > systems.

> The Free Software Foundation, a tax-exempt charity formed in 1985, is > dedicated to eliminating restrictions of people's right to use, copy, > modify, and redistribute computer programs. It does so by protecting these > rights through the GNU General Public License. The aim is to give people the > freedom to cooperate with other computer users.

> "GNOME is a flexible GUI (Graphical User's Interface) that combines ease of > use and the flexibility and reliability of GNU/Linux. We're very excited > about GNOME and what it will mean for the future of GNU/Linux computing" > Miguel de Icaza, chief designer of GNOME said earlier.

At one point, the G in GNOME stood for GNU (now GNOME is just a name, not an acronym), and the FSF was active in its maintenance.

</comment></comment></comment></comment></comment><comment><USER14> Theoretically speaking, does Hurd still have anything to offer over the Linux kernel's monolithic architecture?

<comment> vezzy-fnord As it stands, the Hurd consists of file servers on top of Mach called translators, which provide OS services. It's a rustier version of what Plan 9 achieves via the 9P protocol.

By academic standards the design is uninteresting and perhaps outdated, though if it had actually flourished in the 90s as it was intended, the use of a multiserver microkernel in a mainstream OS would have been quite the achievement back then.

<comment><USER14> Thanks vezzy... Very interesting reading about multiserver microkernels. I also found the following articles on the Hurd website very informative:

[https://www.gnu.org/software/hurd/advantages.html](https://www.gnu.org/software/hurd/advantages.html)

[https://www.gnu.org/software/hurd/community/weblogs/ArneBab/...](https://www.gnu.org/software/hurd/community/weblogs/ArneBab/technical- advantages-of-the-hurd.html)

</comment></comment></comment><comment><USER15> Just in case, Samuel Thibault does talks about Hurd somehow regularly : [https://www.google.com/search?q=samuel+thibault+hurd](https://www.google.com/search?q=samuel+thibault+hurd)

</comment><comment><USER16> If you are interested in trying a microkernel OS, Genode (genode.org) is pretty interesting, with a secure display architecture, ability to run Linux in a VM etc.

</comment><comment><USER17> I wonder if someone is working on building an OS around seL4 now that it's open sourced? Obviously it would have to be designed differently than HURD is, but it sounds like it would be a nifty project.

<comment><USER17> A randomish additional thought. It seems like Arrakis[1]-like system is much more natural since then your database and your filesystem are both user level processes who have been given access to different hard drives. And your webserver and normal networking process can be different processes that have been given access to different channels on your ethernet connection.

Of course I'm just a robotics engineer, this is all woolly speculation.

[1][https://www.usenix.org/conference/osdi14/technical- sessions/...](https://www.usenix.org/conference/osdi14/technical- sessions/presentation/peter)

</comment></comment><comment><USER18> GNU Hurd, the Daikatana edition.

<comment><USER19> I have it on good authority that the Hurd is being used as the engine in Half- Life 3.

<comment><USER20> Kind of sad, I remember when Hurd was used in the same sentence as Duke Nukem Forever.

Then they finished Duke..

<comment><USER21> Au contraire, it's a reason to lighten up a little: we might live long enough to see HL3 and Hurd done!

</comment></comment></comment></comment><comment><USER22> I like how they're almost as fanatical about using the definite article as Apple are the opposite ("The GNU Hurd" vs. just "iPhone"): [https://www.gnu.org/software/hurd/hurd/what_is_the_gnu_hurd/...](https://www.gnu.org/software/hurd/hurd/what_is_the_gnu_hurd/gramatically_speaking.html)

</comment><comment><USER23> I wonder how many best practices and contemporary OS techniques have come and gone in the Hurd's source code over the years.

</comment><comment><USER24> its still alive?!?!?!

</comment><comment><USER25> Oops! you misspelled the name. It begins with a 'T', not an 'H' :-)</comment>


Show HN: Knuckleball – An in-memory data structure server - <AUTHOR> https://github.com/ral99/knuckleball <comment><USER2> Amazing. Sometimes things are done for academic pursuit. If everybody would stop reinventing the wheel then we will never get any alternatives at all. The product does not need to have distinguishing features from the onset, it may gain it later in its lifetime.

Building a data structure server is great exercise in understanding a lot of different things: networking basics, efficient storage, fast retrieval and memory safety. Obviously I don't mean to claim that the author of the project necessarily had the same aims.

<comment><USER3> > If everybody would stop reinventing the wheel then we will never get any > alternatives at all

Exactly. People complain about reinventing the wheel, but compare the wheels we have today with the wheels we had 2,000 years ago, plus all the different wheels in between.

The wheel has been reinvented many times throughout history, and we are all better off for it.

<comment> vertex-four Indeed. Ever seen how much technology goes into a modern car wheel and tire?

</comment></comment></comment><comment><AUTHOR> Hi, thank you all for the feedback! I'll update the README file to make the use cases more clear. I know Redis and it is great! Knuckleball is a server that I started to develop a few weeks ago for learning and academic purposes, not to compete against Redis.

<comment><USER4> A data structure server is a nice and lofty goal for that I think. It has networking, command/protocol parsing, async operation, nice data-structure work so fairly well rounded project.

I don't think everyone was naysayer about your submission. Some including me were confused about the purpose since it reflects how we should look at it. If it was done to explore redis like server but with different priorities/knob everyone would have wanted to explore if that helps their use cases or how that affect the tool. Since its for learning the focus might be how readable/understandable the code is and maybe trying to learn from it themselves.

I hope you learn the kind of things you were planning to.

</comment></comment><comment><USER5> I've had written a lot of C++ code 10 years ago. Before that, I've spent a good deal of time writing C. Ever since, and even though I've started to do Go 4-5 years ago, I wanted to "get back on the horse" with the C++14/17 movement.

It's been a scary thought; I'm dreading to realize all the know-how's I once had known, that I've managed to forget. So in the meanwhile I've been looking at starter-projects, big C++ projects (somehow, there aren't small, simple ones) to understand how modern C++ projects should be _structured_ these days.

To those looking at this negatively I say - this projects is great for what I've been looking for. You can take it and build a differently flavored server from it, and still have modern tooling (CMake, GTest). It is simple enough.

<comment><USER6> I knew enough C++ to be dangerous around the turn of the millennium (college), but haven't written anything in it since. I've often wanted to pick it back up, but the thought of putting that much effort into something that requires so much more effort to use safely than the languages I currently use has always kept it as a wish rather than reality. At this point, I think I've given up on C++, and I'll use Rust when I finally get around to going low- level again. If I'm going to give up the ease of an interpreted language, I might as well put a little more effort in and learn something that provides a bit more assurance for the work required.

Then again, we'll see if I ever get around to it. It's not like I'm swimming in free time.

<comment><USER5> I was (and am still) in the same situation. I managed to go the Rust path, just to realize I don't trust it will be valuable for the very long term (5y+) at this point. It'll be funny to save this comment and come back to it 3 years into the future.

However C++14/17 is getting a ton of new features and a fresh effort to push it towards Rust's innovation. I wouldn't be surprised that if this energy continues, we'll see a lot of Rust in C++.

What is completely certain, that 3 years into the future, if I look at this very comment I'm writing now, C++ will still be as common and valuable. Rust - not sure.

I know I sound like a conservative dinosaur now (but trust me, I'm not), but this kind of thought process you get only after 20 years in the field, and I do apply it only for topics that deserve it (systems programming).

<comment><USER6> That seems an entirely sensible stance. For me, there's a few other things that make me really want to use from Rust to ease some of the pain points of writing a language that low (error/null handling, destructuring match), so I'll stick with Rust for now. Worst case, I may need to apply my Rust experience to C++ later, but with the new features you are referring to and I keep hearing about, those features seem to be increasingly like what I would be doing in Rust, so there should be a lot of overlap of concepts and idioms by then.

</comment></comment></comment></comment><comment><USER7> I think this could be used as a lightweight bloom filter. One direct use-case I see is to build a cache of keys from some _other_ database during initialization.

In cases where the read exceeds write, such as genomic data processing, this can provide additional performance gain, as opposed to querying the database.

While redis _can_ be used, I think that this having a much smaller codebase is advantageous, in case one wishes to implement additional domain-specific requirements. Nice work!

</comment><comment><USER8> Not quite sure I understand the use case here, is meant to make updating a complex cache object easier?

<comment><USER9> same use case as redis.

</comment></comment><comment><USER10> I like it! Like others have said, doing something for the sake of learning (or even just for the heck of it) isn't a lost endeavor. I've been toying around with the idea of doing something similar, but .Net based, mostly for my own learning.

</comment><comment><USER11> I have not written _real_ C++ in a while, but this code is very nicely organized and written. Can't comment if its modern idiomatic C++. Its easy to read and make sense of what's happening. IMO, that is not easy to do. Congrats @OP!

</comment><comment><USER12> What's a good use case for this platform?

</comment><comment><USER13> Looks pretty cool! The world could use a competitor to Redis (which is also pretty cool).

</comment><comment><USER14> It sounds like a redis competitor - but I don't see any distinguishing features.

<comment><USER15> And the readme doesn't mention redis at all - is it possible that the author is simply unaware of the existence of redis, and has simply reinvented it? Because that would be absolutely hilarious :p

It would also be a fun project, though. Redis is something that I really wish that I had had the opportunity and the vision to build myself. Classic data structures as a service; too cool for school.

<comment><USER4> At first I thought there is a chance that someone thought about the advantage of the same thing. I have always thought that cache products that lets you build your custom distributed data structure would be a marvellous thing and while Redis does not provide the same feature it sort of allow one to build much more complex cache data structure using its primitive. But given that its implemented as a single threaded async server I have to assume its Redis inspired.

Now the curious question is whether it provides some different feature, its a learning exercise or something else.

<comment><USER16> Actually the latest Redis does allow you to build your own data structures using loadable modules, as announced at RedisCon 2016.

see [http://antirez.com/news/106](http://antirez.com/news/106)

</comment></comment></comment></comment><comment><USER17> As a gentle reminder to the commenters in this thread, please keep in mind the Show HN guidelines ([https://news.ycombinator.com/showhn.html](https://news.ycombinator.com/showhn.html)):

 _In Comments

Be respectful. Anyone sharing work is making a contribution, however modest.

Ask questions out of curiosity. Don't cross-examine.

Instead of "you're doing it wrong", suggest alternatives. When someone is learning, help them learn more.

When something isn't good, you needn't pretend that it is. But don't be gratuitously negative._

<comment><USER6> I assume people removed overly negative comments (or they were removed for them?), as at this point there's not a lot of negativity at all, and the top two comments are both pointing out that the Show HN guidelines, which are predominantly about being civil and avoiding negativity. It makes for a somewhat surreal reading experience.

<comment><USER18> When I saw first read the comments this morning, the now-greyed out comments at the bottom of this thread were the only thing posted. 5 or 6 comments, all variations on the theme "why bother, lol".

<comment><USER17> Same. From my experience, I think that initial conditions on a thread matter. From what I saw, I was worried the thread would snowball in the negative direction.

</comment></comment></comment></comment><comment><USER19> Most of the current comments are not abiding by the Show HN comment guidelines.

      In Comments

      Be respectful. Anyone sharing work is making a contribution, however modest.

      Ask questions out of curiosity. Don't cross-examine.

      Instead of "you're doing it wrong", suggest alternatives. When someone is learning, help them learn more.

      When something isn't good, you needn't pretend that it is. But don't be gratuitously negative.

In addition, not all software on the internet is meant to replace other software, compete with other software, or even be deployed in a production environment. The internet is more than large enough for lots of wheels of all shapes and sizes. Contributing to existing projects is good and so is writing your own programs.

I understand the underlying sentiment people are getting at - this seems similar to Redis - but we should keep an open mind. Maybe he wanted to write C++ instead of C? Maybe he was trying out boost::asio? Maybe he just wanted to write some code?

</comment><comment><USER20> Correct me if I am wrong: redis scalars are limited to strings and this seems to support integers and booleans. The query language is also different. So, I must conclude that something else is going on. Slashdot, is it you?.</comment>


Startup Quote: David Cohen, co-founder, TechStars - <AUTHOR> http://startupquote.com/post/6897602898

<comment><AUTHOR> I'd build stuff that's awesome and get people using it. Investors will come out of the woodwork when you do.

\- David Cohen (@davidcohen)

<http://startupquote.com/post/6897602898></comment>


Ask HN: Write a letter to Santa - <AUTHOR> Describe the technology, software, library or practice that you wish will come true in 2018. <comment> n-gauge elf files</comment>


Bikes built from Bamboo - <AUTHOR> http://www.bbc.co.uk/news/uk-14397027

<comment><USER2> Bamboo bike frames have been around for quite a few years but this is the first time I've seen anyone trying to commercialise them. I guess they might take off with the green crowd but otherwise I don't see people clamouring to buy one.

I wonder how they are repaired when broken. If you can fix them with wood glue they might be of more interest because it's easier/cheaper than getting somebody to weld it back together for you.

<comment><USER3> From what I've seen in the video the bamboo bikes are mountain bikes with quite good components, so I guess they are going to target the more expensive market segment. As for repairing a broken bamboo frame I can imagine it is easier than repairing a broken steel, aluminium or carbon frame - I have seen those frames braking already but I have never seen somebody repair them.</comment></comment>


Show HN: Graph Visualizer - <AUTHOR> https://github.com/xiaoxiae/GraphVisualizer <comment><USER2> Nice little tool.

You may want to provide some details/examples on input data formats for those of us not from graphing community

<comment><AUTHOR> Considering I made them up to be simple to use, that is definitely a good idea! I will take a look at it :).</comment></comment>