segphault

>I don't share the author's enthusiasm that it's "awesome" that "the schema is all backed by arbitrary code" -- I think this is a bad trade-off

Yup, and it also forces you to sacrifice programming language portability. Kind of important in a microservice scenario where you might want to have multiple distinct services written in different languages that support the same set of GraphQL types.

People don't seem to realize that there is a whole separate dedicated schema language for GraphQL that will eventually replace the mediocre embedded DSLs. The only reason the current implementations all use the embedded DSLs is because implementing a parser for the custom schema language is non-trivial.

There are a lot of things that I really like about GraphQL, but I think it would have been saner if they had aimed for a way to express the schemas and queries in something like JSON that everybody already speaks.

It's an iOS application. They are distributing it in the iOS App Store.

Matt links to the relevant GitHub repo in his blog post: https://github.com/wix/react-native-wordpress-editor

If you look at that repo, what they are doing is totally unambiguous. The README literally acknowledges that they are using Wordpress code, describing the contents of the repository as a "React Native Wrapper for WordPress Rich Text Editor."

They applied the MIT license to their wrapper, which is using the GPL-licensed Wordpress code, and then they embed the whole thing in their proprietary app. They are now compelled to publish the source code of their entire application if they want to comply with the requirements of the GPL.

Thanks for sharing, it's nice to see an example of using RethinkDB with Algolia.

RethinkDB originally added changefeeds for exactly this use case, long before hitting on the idea of leveraging the feature for realtime application development. It's pretty cool to see users intuitively picking up on the suitability of changefeeds for this sort of integration.

Back when I was a tech journalist, I always felt uncomfortable speaking with representatives of the Tor project. Their approach to communicating always seemed needlessly accusatory and combative. It left me with the strong impression that they are more interested in shouting down criticism and downplaying the extent to which Tor is abused rather than educating the public and engaging with the broader tech community in good faith.

The poor way that the organization and its members have dealt with the allegations made against Applebaum over the years seems emblematic of the broader problems with their culture and the inept way that they handle criticism and internal failures.

I think a lot of us, particularly open source enthusiasts and civil libertarians, are inclined to give them a free pass because we value the underlying ideas that the Tor project ostensibly represents. But it's increasingly clear that not holding the organization to higher standards of accountability was a disservice to the ecosystem.

D3 is a relatively low-level library for composing custom visualizations. There are some good high-level abstractions on top that integrate well with React and provide specific kinds of preconfigured charts. You might want to check out Uber's React Vis components: https://github.com/uber/react-vis

No, RethinkDB doesn't have disk encryption. The new encryption features in this release all relate to data on the wire.

Thank you for pointing this out. I honestly wasn't aware that there was a separate plugin for this. I'm relieved to have my precious :%s back, but I wish I had known about it earlier! :-)

While it's not as good as being able to attach to a remote/headless instance of the editor, something like Nuclide's remote project feature would be a step up from SSHFS... if it actually worked consistently.

I've unfortunately found it to be really flaky. About half the time I try to add a folder I get a "certificate not ready" error. And I get a lot of random error messages when I save files. With large projects, watchman exhausts the number of filesystem watches that can be created (though maybe I could fix this if there's a way to configure it to not recursively watch node_modules folders).

I also don't like the fact that Facebook stuffs all of its Atom improvements into one extremely heavy, monolithic plugin. It practically doubles Atom startup time for me. :-(

I really wish there was a way to use Atom in client/server mode. I'd like to leave a headless session running on my home Linux server and be able to attach to it from work. Right now, I use SSHFS to mount the remote directory so I can edit locally, but it leaves a lot to be desired.

Considering that Atom is all just Node and Chromium under the hood, it's surprising that there's no way to run at is as a server.

As a longtime Vim user, I've been pleasantly surprised with the quality of Atom's Vim bindings. Text navigation and pane management bindings mostly work as expected. You get multiple registers for yanking etc. That's the extent of what you get, however. There's no emulation for the colon prompt, no macros, and it obviously doesn't support any Vim scripting.

I've been happy with Atom after transitioning from Vim, but there are still a few pain points. One that's particular annoying is that Atom's search/replace is very poor compared to the power I'm used to having with :%s.

The main problem with a tool like this it that it needs to understand sentence structure in order to find a lot of common anti-patterns. Without some natural language processing, it's just going to be able to scan for word usage and simple things that you can catch with a regex. You could probably build something a lot more sophisticated on top of something like Apple's NSLinguistic​Tagger and related APIs.

After testing this against a dozen of my blog posts, I'm not terribly impressed with the output. I get more immediate value out of MarkedApp's keyword drawer and word repetition visualization.

It's really neat to see that the backend is built with RethinkDB and Common Lisp. I am looking forward to setting up my own instance from source and playing around with it. Great project.

Anybody know if this update addresses any of the issues with Java 8 interop? It'd be really great if you could just pass a conventional Clojure function to Java methods that expect to receive lambdas.

I downloaded the beta and tried it out. The concept is interesting, but the execution is still uneven (understandably so, considering that this is a beta). The way that the mobile app UI is rendered on the desktop is pretty bad, especially the lack of antialiasing on the fonts.

It has that uncanny valley feel that you'd expect when somebody reimplements a UI toolkit and tries to mimic the look and feel. I'd really like to know if it looks better and more native on a device.

There are also bits and pieces that don't seem to work as expected. Like, I'm having trouble getting the built in HTTP client to actually successfully complete a request.

The design tool is slick though, so I'm looking forward to seeing where they take it. It could be pretty compelling for rapid prototyping.

Angular 2 addresses a lot of the serious shortcomings in Angular 1.x. The Angular 2 approach to components and encapsulation feels cleaner and less complicated than the previous mess of services, factories, and directives.

Though initially skeptical of Typescript, I've found that Angular 2 really benefits from the advantages of having a coherent object model and optional type safety. Typescript never gets in the way, you can selectively use type declarations only where you want to use them. It's often helpful to leave them out while prototyping and then add them later when you want more robustness and easier debugging while you are working on writing the glue code and application logic that connects your various components.

As other posters have noted, you're still saddled with a lot of the artificial complexity and odd terminology that is pervasive in Angular 1.x. There are also bits and pieces of the library ecosystem, particularly the routing engine, that are over-engineered and painful to work with in practice. But, in general, I find version 2 much more intuitive and easier to reason about than version 1.x. Key features like data binding are much saner and behave more predictably.

I've never particularly liked Angular or React (my personal preference right now is for Vue or Polymer), but I think Angular 2 is a solid improvement over its predecessor. More significantly, I think the improvement is substantial enough to justify the team's decision to do a clean break.

Hey, I'm Ryan from RethinkDB. I wrote the OP blog post and I'm working on a follow-up that demonstrates how to use the Java driver in various alt-JVM languages.

You can take advantage of Clojure's Java interop to use the new official Java driver in Clojure, but it doesn't offer a very good user experience compared to clj-rethinkdb. It will work for a lot of simple cases, but it gets weird very quickly. When you define a function in Clojure, the underlying Java object is an IFn[0]. Unfortunately, you can't pass an IFn to native Java methods that expect to receive a Java 8 lambda (an anonymous class with a single method). You can work around this limitation by manually creating an object that conforms with the client driver's various ReqlFunction[1] interfaces, but it's not very pretty:

This ReQL expression in Java:

  r.table("fellowship").map(x -> x.getField("name")).coerceTo("array").run(conn)

Becomes this in Clojure:

  (-> (.table r "fellowship") (.map (reify com.rethinkdb.gen.ast.ReqlFunction1 (apply [this, x] (.getField x "name")))) (.coerceTo "array") (.run conn))

Note the use of reify and the ReqlFunction1 interface. You need to be careful to pick the interface that matches the arity of your anonymous function. For example, if you have four parameters, you use ReqlFunction4 instead of ReqlFunction1.

You could probably do some voodoo to abstract away some of the ugliness, but the way that clj-rethinkdb's r/fn macro works under the hood and translates into the wire protocol is frankly a lot more elegant than anything you could do with our official client driver and Clojure's Java interop IMO. That said, I'm not particularly well-versed in either Java or Clojure, so there may be something I'm overlooking. I hope this explanation is helpful to somebody. :-)

TL;DR: use clj-rethinkdb if you want to write sane-looking ReQL in Clojure.

[0]: https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.h... [1]: https://github.com/rethinkdb/rethinkdb/blob/next/drivers/jav...

This is the first I've heard of N1. It looks appealing, but after following the links and looking at it on GitHub, it seems like installing the sync server for self hosting is still non-trivial.

I went to the "releases" tab on GitHub and it looks like the last one was in 2014. I see things in the GitHub repo that suggest there are Dockerfiles and Debian packages, but I don't see an actual Debian package repository or an entry on the Docker Hub. Is the recommended way to use it today just cloning the git repo? Or is there a stable release of the sync server that's tested/known to work with the binaries of the client?

I like Kotlin, but I'm a little bit disappointed with some of the recent changes to the syntax. In particular, I'm sad that you can no longer use infix method invocation for any method.

It's a feature that I really liked using with third-party Java libraries, which is much less practical now that you have to explicitly define methods with the infix keyword in order to use it.

I can sympathize with companies that face the very difficult challenge of policing user-submitted content, but Udemy has always seemed really sketchy to me.

Earlier this year, I got inundated with Twitter spam from bots that were written to abuse Udemy's affiliate linking program. I made several attempts to bring the issue to Udemy's attention, but the company was totally ambivalent and didn't really care. I eventually configured my Twitter client to completely filter out any message that contains "Udemy" so that I wouldn't have to see a dozen or so obnoxious mentions directed at me every time I post a tweet with a programming-related keyword.

It doesn't surprise me much that their approach to addressing piracy is similarly lackadaisical. I doubt that they would have done anything at all beyond the bare minimum required by the DMCA if the issue hadn't escalated and produced widespread criticism.

Well, I guess Google had to find something to use the Dart VM for now that they aren't trying to cram into Chrome anymore.

Some interesting ideas here, though. It's strange how much it looks like web development, with route handling for navigation etc.

There are only two kinds of people who regularly complain about the state of Linux security: OpenBSD advocates and security vendors who want to sell you something. Seems like an awful lot of the latter are quoted in this WaPo piece.

CoffeeScript is largely just a shorthand built on existing JavaScript idioms, so the output is more or less 1:1. In order to provide some of the capabilities and behaviors that you would expect to find in a real Ruby environment, Opal has to use a fair amount of runtime code. As a result, the tracebacks and error messages that you get from Opal are often very unhelpful.

I also found that quite a few of the libraries in the Opal ecosystem (like the opal-browser library that wraps a bunch of important native web features) are fragile and under-documented.

That said, Opal worked far better than I actually expected. I built a simple demo with it a few months ago and was pleasantly surprised by many aspects of the experience. There's a third-party React wrapper called React.rb that is quite impressive.

I wrote about my Opal demo app here: https://www.rethinkdb.com/blog/ruby-opal/

And here are the slides from a talk I gave about full-stack Ruby development: https://speakerdeck.com/segphault/realtime-web-apps-with-ret...

Intellectual Ventures is a notorious patent troll, one that routinely uses shell companies to obscure the extent of its abuse of the patent system. It's disappointing to see ignorant people in the press continue to naively conflate "filing lots of patents" with "inventing."

A piece like this that uncritically lionizes Lowell and Intellectual Ventures without even bothering to highlight or address the criticism frequently voiced against the organization feels uncomfortably one-sided if not deliberately misleading.

OAuth is broken by design. Among many other serious issues, it's ridiculous that Twitter and other major OAuth adopters still implement it in a manner that relies on native/mobile client applications uniquely identifying themselves with "secret" keys that are trivially easy to extract.

It's deeply unfortunate that so many of the people involved with the spec chose to shout down critics and hand-wave away serious concerns until it was too late to fix the problems. OAuth 2 should have provided an opportunity to address the issues, and instead it just rubber-stamped many of the worst practices used by implementors.

It's understandably a little difficult to extract all of the relevant context out of that thread in the issue tracker, but the current consensus is indeed that this feature should be built with a plugin system--on top of the database's existing query language and feature set.

The plugin system will provide a sort of middleware layer alongside the database so that we don't have to bake in a lot of things that are domain specific or only relevant to particular use cases.

There's more discussion about the plugin system here: https://github.com/rethinkdb/rethinkdb/issues/4785

(Disclosure: I work at RethinkDB)

I couldn't help but notice that the blog associated with the site (linked at the bottom of the manifesto) is hosted on Tumblr and runs all of its offsite links through Tumblr redirects so that the clicks are all tracked. Surely that qualifies as exactly the sort of bullshit that this person is inveighing against.

Yes, but OP is wrong when he says that there is nothing to see. He just didn't take the time to even look. The source code of the underlying layout engine is published on GitHub: https://github.com/gss/engine

The people behind TheGrid are also the same people behind Grid Stylesheets, which uses an implementation of the cassowary constraint system to facilitate web layout: https://gridstylesheets.org/

Grid Stylesheets are actually a pretty compelling approach and it was well-received here when they first shared it with HN. While the claims about machine learning and AI are arguably eyeroll-worthy, there's definitely some non-trivial engineering powering their service. They aren't peddling vaporware and it's not a scam.

I don't think OP's knee-jerk reaction here is fair—and it certainly doesn't seem to be based on an evaluation of the actual technology in question.

Thanks for the response. It's good to hear that you're thinking about local access.

I realize that the node module thing is just one example of a feature that relies on hosting, but fwiw I wouldn't mind having to manually maintain a local package.json and node_modules folder for whatever libraries I want to be able to use in the environment.