By far, the most common complaints I have heard when researching about GCP online are the following:
1) You cannot use SQL in the same way other platforms allow you
2) Only a subset of language features are supported for Java and Python and it is a little hard to know when you will run into that issue
3) As a combination of 1 and 2, it is not easy to migrate out of GCP and this makes it a kind of vendor lock in.
While many people seem to agree that the platform itself works very well, if you are developing on GCP, free credits or not, doesn't this mean you are knowingly getting into a platform that will be hard to leave?
Can someone who has worked with GCP address if these concerns are still ongoing? Also, are there some positives which are not easy to see from the outside which might have helped you choose them/stick with them?
> 1) You cannot use SQL in the same way other platforms allow you
Are you talking about Postgres support? Because they also announced that today. Or are you talking about something else?
> 2) Only a subset of language features are supported for Java and Python
The new "App Engine Flexible Environment" seems to support most things, including Python 3 and libraries with C extensions. Are you perhaps talking about the old App Engine environment?
Google is competing against Amazon AWS and Microsoft Azure. All theee cloud platforms have some degree of lock-in, true enough, but all three platforms also provide APIs and services th make building systems easier.
Those limitations apply to the old model of App Engine they call the Standard Environment, which abstracted much more over the underlying resources (you didn't have to think about what VMs you were using).
At some point they realised that maintaining their own parallel forks of the runtimes was a loser's game and now gently push you toward the "Flexible Environment", which maps more transparently onto GCE (their equivalent to EC2) instances (which is better for them since you're billed much more directly according to your resource use), and has much more up to date runtimes, and you can supply your own docker image if none of them fit.
The only people I know of who actively use the Standard Env anymore for new projects are trying to have a hobby project run for free in the free tier.
You don't have to manage servers operations at all, just write your own server application. If you're testing proof of concept or have a hobby application, it's incredibly useful.
I created a note-taker app for videos but never had the time to make it into something more useful. They are not transcripts, of course, because those would take a whole lot longer to create. It is hosted on GitHub pages for now.
Just curious - and I am asking anyone here who feels similarly, if someone created a list of these "notes" for a given channel on YouTube, would you be more likely to sit through the videos?
The fee for the certification is around $100, which was said to be the filter which prevented frivolous apps from being submitted to the App store. Shouldn't that help?
intentionally bad programmers don't need the certification, just to pay the standard $25 play store fee. I think this program will help the quality of play store iff they can get a lot of people through without sacraficing content, such that their certificates actually matter in the market.
If you clicked through to the two links from laretluval and brudgers, you can see why natural language processing as a field is struggling to gain quick adoption (in proportion to well understood concepts). Look at laretluval's links: The people who are doing the hardcore research are doing a really poor job of explaining what exactly they are trying to accomplish. Can a programmer who is good at programming but not familiar with computer science concepts actually figure out what exactly tregex does, even after reading the page a few times? Do you seriously expect someone to download a PPT file (yes, ppt, not a pdf) to understand the basics?
Contrast that with brudgers link - it is actually a readable summary even though I personally think the person who posted that blog entry still needs to learn more concepts in NLP/English grammar/hierarchical data structures to scale the project
- all his examples are active voice
- using regex will fail as the sentence becomes more run on like the one you are currently reading
- hand crafting rules for English grammar is actually super hard because even trained linguists sometimes disagree on the parse tree produced by fairly short sentences (I think I learnt that from watching a YouTube video by Chris Manning, unfortunately I don't have the reference right now)
I don't understand how the NLP community seems so oblivious to this issue.
Alternative explanation: NLP is lagging behind what we expect because it is a very challenging domain. Explanations of NLP concepts are nontrivial because fairly complex computational tools are required to get anywhere— smoothed n-gram models, PCFGs, LDA topic models, etc. Like computer vision, it requires a combination of statistics, computer science (runtimes and data structures), and an understanding of the target domain. To understand the basics may require taking an NLP class, reading Jurafsky and Manning, and looking at quite a few lectures (which, yes, are occasionally distributed as PDFs).
I agree with your criticism in general, but the lack of outsider-friendly explanation here seems justified because something like a parse tree matcher is more of a tool that's useful inside the NLP research community than for end users. When does an end user ever need to find trees with a particular syntactic structure? On the other hand, it is very useful for debugging parsers, verifying annotation standards in corpora, etc.: things that NLP researchers have to do.
There is some NLP software that does a great job of explaining what it does, how it does it, and why this is useful. http://spacy.io/ comes to mind. Maybe that's the happy exception.
I would argue that parse tree matching is useful to end users (programmers) who are trying to extract some meaning from a sentence. By matching a parse tree, you can match and extract the contextual information about a sentence, e.g. the subject, action and object. Compare this to the intent matching machine learning approach where you feed a model some sample sentences and manually tag the sentences (e.g. wit.ai). You feed a sentence to this black box and you might get the right intent and context matching but you don't know what's going on and you have no control over the matching. Manually create rules for matching parse trees is a little more work than manually tagging sentences but it allows for more control and transparency over how the matching is done.
I am the person who posted the blog entry. It's true that I don't know much about how NLP parsing works but I do know how the parse trees are structured. I believe matching parse trees is scalable. The examples in my post were for short imperative commands but it is relatively simple to create rules for more complex sentences. It might not be perfect in every case but I would say for a majority of cases it works well.
I'm glad you were able to understand the blogpost and I agree that the material on tregex is not clear and would be difficult to pick up. I hope the library I wrote will let programers start using the Stanford parsing libraries more easily.
Does it mean, then, that as the people who are anti-immigration such as Donald Trump get elected and geographic mobility (potentially) decreases, we can work our way backwards and say that these languages are less likely to die? In other words, does the trend towards anti-globalization lead to the unexpected side effect that some languages may actually take longer to die?
And it might mean some people get the chance to improve their own countries too, instead of being forced to immigrate (by globalization pressures) and try their luck on another.
Yes, but it would hardly be unexpected, and though this gets into iffy and boring questions around definitions, I don't think it's a side-effect either.
The existing HackerNewsCollapse extension mentioned in the other comment already does this. I built a Chrome extension which extends this further by also trying to summarize the comment thread based on word frequency of entire subtree (with mixed results)
The field of memory training has a system (called the major system) for converting arbitrary numbers into words by assigning distinct sounds to the 9 digits - 0 is s, 1 is t(d), 2 is n and so on.
For example, 95 would be p + l sound - say a pillow. Try to visualize a giant pillow (have something exaggerated and preferably silly) on that spot.
It even has a cheesy 'Time saved' feature to help you see how much time you might have saved by not reading the full comment thread :-) Not sure how useful it actually is, but it was a lot of fun to develop. I used C#, edge.js, ideas from natural language processing, tree algorithms etc.
Unfortunately it only works on Win 64 right now (although I built it with node-webkit so making it cross platform desktop app should be feasible in the future)
I made an app which uses the idea of spaced repetition to help you memorize flags. I was really amazed when I learned about this system a while back, and made this app to help my niece learn some interesting stuff. My app is really rudimentary and buggy, but I believe we are soon going to be seeing plenty of apps which incorporate these kind of ideas and really help us hack our learning process.
Indeed. Maybe someone just decided to take the most provocative pieces of the book and stitch together an article, and used a data driven HN-baity headline generator program? :-)
While many people seem to agree that the platform itself works very well, if you are developing on GCP, free credits or not, doesn't this mean you are knowingly getting into a platform that will be hard to leave?
Can someone who has worked with GCP address if these concerns are still ongoing? Also, are there some positives which are not easy to see from the outside which might have helped you choose them/stick with them?