Hacker Read top | best | new | newcomments | leaders | about | bookmarklet login

So you couldn’t write the query. It just isn’t practical to create an index for every query which comes to mind during research, and even to create the index, you have to use a terrible, undocumented embedded query language.


sort by: page size:

Actually I guess the query language and indexing is pretty limiting too.

Because they don't support complex queries.

Designing queries up front seems like a step to far, you might as well just write them , at least you could debug them as there's a low chance you ll get them right first time.

It's really hard to design something like that that anyone would get value out of using because matching the query isn't a binary notion.

There is a difference though - you don’t have a query language that makes it easy to do, and the actual technology pushes you to make a different more correct choice.

It's worse than trying to write a paper on the Teh tribe in the Amazon in Microsoft Word with autocorrect. The relationship between query terms and results is complex and opaque.

Yeah that’s the problem. If I need to add that to all my queries why use it at all?

Maybe my queries are not difficult enough. Do you have an example?

... It's a parlor trick.

The computational complexity going on is minimal compared to the effort it takes to create and maintain the dataset. Accessing it with a formal query language is then straightforward.

The parlor trick is making the formal query language seem as informal and colloquial as possible. But fiddle with breaking it and you'll see you're just running searches on very specific and very specifically tagged data.

Edit: Having thought about it more, the reason it's 'underutilied' is that it's actually not that useful. Your knowledge of its dataset is more important than its ability to provide it for you--witness the person below who knew that it could provide nutrition information.

Your index on its information is better than its index, in other words.


Thanks for asking. Had a similar issue--no avenue to practice queries intentionally, outside of solving a real-world problem with all the confounding factors that entails.

Nice options ITT.


I think this might be partly due to the query language being JSON? It makes every example huge and hard to understand. JSON is a serialization format that's human-readable, it's not a human-first language. So it's a pity that's how you're expected to write searches (I know they have some SQL support now, but I've never seen it in the docs)

That actually sounds way worse than just using queries.

In other news: it's 2013 and people are still not using query builders.

My guess is that this being possible would be the norm, rather than the exception. And that keeping track of individual queries is not.

Such queries are not universally supported, and a program using them has to be prepared to expect a lack of response to the query. (This is one of many issues with such queries.)

The problem with writing raw queries is that you don’t get that sweet sweet type checking

I wanted to show an example of an embedded language people could relate to. Querying is something most everyone has done and has felt the pain of doing from other language. Any other non-trivial example of an embedded language would be even harder to understand b/c the problem domain wouldn't be familiar to the reader. It's a tough concept to communicate, I did my best.

It might not be worth for everything, but extremely simple queries on extremely simple schemas would not be the goal here.

You can make a more specific query instead.
next

Legal | privacy