These are false beliefs and one of the reasons that (this is obviously an estimate off the top of my head) about 95% of programmer time is wasted solving problems that have already been solved numerous times. I see people hinting at security or other concerns related to using Meteor in production, but I have yet to see an example where one of these concerns actually caused a production issue.
I would be very interested to hear if anyone had actually tested Meteor in production, or had specific concerns related to security or anything that leads them to the conclusion that they must come up with their own different/more complex solutions to problems that Meteor solves.
Taking advantage of a system that solves 90% of your problems rather than reinventing six wheels is not lazy. Its just sane and mature.
The psychology of programmers related to tools and frameworks is childlike. Its as if everyone is in a playroom with a bunch of tiny blocks of different shapes. Every once in awhile a kid figures out how to construct generally useful connector shapes or recognizable objects from the smaller blocks. Then when another kid wants to use the larger pre-composed structures to play with, everyone makes fun of him because he is 'cheating' and must be too dumb to use the tiny blocks.
I have deployed app written in meteor serving an API, and while it's a solid framework already, it still has some issues. Form handling is a bit of a hassle, compared to the rest, because it's still all done manually, and deployment on a custom server, while relatively straightforward, is a bit of a pain, because you end up having to manually reinstall some npm packages every time you update code. None of that are fundamental issues with the design of the framework, though. There's some quirks that aren't yet worked out, because it's a young tool, but it's already extremely powerful.
I used it to make an online multiplayer Go board where you can see your opponent moving the pieces, for the purpose of teaching games: https://github.com/muraiki/senseinogoban Being able to make something like this as a beginning programmer was really exciting! Since I'm pretty new to programming I don't know if the code is that great but it might give some ideas to people who are interested in using Meteor in a graphical way (as opposed to something like a To Do list).
The latest dev shop outlines what's in store for the 1.0 release (http://www.meteor.com/blog/2013/10/01/geoff-schmidt-at-devsh...) and based on where they're at now, it's exciting to think of what will be possible.
Definitely not a toy, though, and something that should be evaluated carefully.
I was looking toward Meteor for a similar project because of its handy client-server syncing capability, but decided not to use it because it didn't seem to suit the more traditional webpage model and the click-to-save-changes paradigm. But your site is making me reconsider this. I've been learning and implementing my site in Angular/Restangular, which involves me writing code to POST to/GET from my Rails backend. I'm aiming to let users add and remove nodes in a plan/document and rearrange their ordering - would that be easier to do in Meteor? I'd love to make use of Meteor's object syncing and other features. What's your experience been like? Did you try Angular or other JS MV* frameworks?
By the way, I love your site's design and iconography. If you built the whole service alone, I'd be very impressed.
I guess for your idea I'd have to see a sketch, but on the surface, yes, I'd say something like that would be pretty easy. The cool thing about Meteor is that it takes a lot of the thinking/logic out of the loop. So for example, you would have the nodes as a Mongo collection and for each plan/doc, just store their position info. Meteor/Mongo update automatically, so if say you used something like jQuery UI drag/drop, you would just have it update the given object in Mongo when you pick it up or put it down. Make sense?
My overall experience has been that I haven't gotten frustrated with Meteor like I did with other frameworks. It's not as rigid, sure, but if you take the time to develop a good design practice, it can be really efficient. Plus, having both front and backend code in JS is a serious time saver.
Thanks for the complements on design. Save for the octopus, logo, and animated gifs outlining the process (oh, and the nice header on the blog), this was a 100% solo effort.
It's been a year since I played with it, but at least at the time the weak side seemed to be integrating with any existing systems you may have, whether front or back or middle or sideways. In those cases the magic doesn't work for you and you've got to figure out how to plumb it. (Again this may have improved in the past year.)
I would sign up, but I really want to see a service before giving over my information. Screenshots, video, really anything. I dug around a bit hoping that you might have some screenshots in the KB or blog, but no luck.
Here's a video I sent out last week going over the signature process: http://vimeo.com/75510644 (a bit out of date, though, as it's missing the audit trail and permanent agreement features).
I really like the color scheme and if I wasn't in a "boring" contract I'd be looking directly into your services.
What kind of work are you doing?
I'm on what I'll call a floater business operations contract. It's an ongoing thing at 40 hours a week (at a great company) working on several different projects and providing assistance where needed. As far as stack, it's mainly a Microsoft establishment with other things sprinkled in (and getting more so with newer projects).
Best of luck!
What sort of work do you do with the Microsoft stuff? Is it like .net work or do you do more OS level programming?
Meteor: Meteor is a tightly integrated full stack framework where you program in a synchronous style. Meteor will likely be the solution of choice for people who want to build real-time applications in pure JS in a synchronous style.
Derby: Derby on the other hand also delivers a real-time development framework. However, Derby allows you to program in Node's traditional asynchronous callbacks style. Derby will likely be the solution of choice for developers who want to build real-time applications in pure JS using an asynchronous style.
I intentionally glossed over feature differences because the approach of each team is different enough that people will likely select one vs the other based on preferred programming styles (assuming neither team drops the ball...unlikely given the skills of the devs on each team).
SailsJS: It's also worth mentioning SailsJS b/c they are delivering the rapid development benefits of Meteor and Derby, but from a vastly different approach. Sails has a very cool evolutionary design and is a project worth following.
The big win for developers will be that these teams (and I'm sure other will emerge) are pushing the boundaries of development speed. This genie is now out of the bottle.
The other thing that's obvious is that there's a gaping hole for someone to fill with a package-oriented approach vs. the framework approach. True, Meteor/Derby/Sails are all a bunch of packages, but what I mean is there is an opportunity for someone to collect a bunch of standard NPM modules into a comprehensive development environment. The end goal would be to deliver similar benefits as a framework, except that devs would have no abstraction layers to deal with (more complex, but more power).
SignalR: One last solution to mention. For .NET devs, Microsoft released SignalR.
I tried Derby.js because of one important for me missing feature of Meteor: serverside HTML rendering - required for search engines and also for CMS or content like applications. IMO Derby.js got it right there.
Unfortunately Derby.js is seriously lacking professional documentation of any kind: Meteor already has books and 2 very good and long enough video courses (from pluralsight and tutsplus)
Of course I did :). It's not usable at all :). It's also not reducing the initial loading time (very high for any public webpage).
I saw one of the core devs speak in Chicago a week or two ago, and the main feeling I came away with was that the Meteor team has a well planned roadmap of features, solid funding, and a plan for generating revenue, all of which will hopefully mean Meteor isn't going anywhere.
Edit - I think this article hits on some of Meteor's strengths re: ease of development, but some of the features Meteor uses to accomplish this turn into gotchas later. For example, the autopublish and insecure packages are awesome for a 5 minute demo but for anything further they should be removed. Without them, devs are back to thinking about queries and what clients receive what data, permissions, etc. These are very important things obviously but it might be a little misleading for someone using Meteor for the first time.
If your idea works, then you can "mature" your codebase a little. But, from the get-go, you'll want to make something usable, to see if your idea works at all. Meteor is perfect for that sort of thing.
I have experience with Meteor in production and had some serious performance-related problems. Not that they're not solvable, but some solutions kill some core design decisions of Meteor. Just in case - I didn't pick Meteor for the project, I was asked to help with it.
Anyway, here's short list:
1. Collection synchronization does not really work even for relatively small amounts of data (say 10k records).
- It does not make much sense to send few MB of initial data to the client. Paging API was moved to some distant future and you end up writing REST-like API on top of Meteor, which breaks idea of collection synchronization, which contradicts statement on their website - "no need to write REST APIs anymore". I don't say it is not usable at all, you just need to be really-really careful about what you send to client and it is easy to fail at this.
- SockJS (transport protocol used by Meteor) does not have rate-limiting built-in. If client connects using one of the polling transports and payload is too large to be received in 30 (? - vanilla SockJS uses 5) seconds, server drops connection thinking that client timed out. Partially, it is SockJS problem and partially it is Meteor problem, as Meteor will just send all outgoing data without caring if client is on slow connection. But because of previous point, generally it is bad idea to send large amount of data anyway.
- Server-side subscription API is very limited. Official documentation has following sample: reactively count number of admins in collection. This is done by listening on collection changes and counting admins by incrementing (when admin is added) and decrementing (when admin is removed) single variable. If there are 10k admins in database, increment function will be called 10k times.
2. Minimongo is interesting concept, but fails on many levels:
- It is MongoDB written in JS, but slow
- Does not have indexes ("client won't handle amounts of data for indexes to be viable"), aggregation, map reduce, etc. There's no official API to create index on server-side either.
- Its reactive - whenever model is changed, Meteor figures out which fields were changed and broadcasts changes to all listeners. And this is _not_ fast. Inserting 10k items to collection will take around 2 minutes on AWS large instance with node executable using 100% CPU.
- Because MongoDB is not "reactive", Meteor just polls collections every 5 seconds to see if they changed by outside application. I really hope it only tracks addition/deletion of records and not scanning through all rows in database during each polling iteration
- Meteor API is hiding MongoDB handle, but there's a way to get it (through hack) and use it directly. And it takes 3 seconds to insert same 10k items
3. Client-side is not as convenient as current MV* frameworks
- Meteor is using non-reactive templating engines and attempts to make them reactive. And this might be performance bottleneck, especially on mobile devices. When single variable changes, Meteor will re-render whole template. If you have some 3rd party plugins (like WYSIWYG editor, which injects own DOM markup), you have to wrap it with special blocks, which prevent Meteor from re-rendering them.
- As a result of previous point, DOM is not stable.
- Unlike AngularJS/Ember/etc, Meteor does not track individual variables. AngularJS does it by checking if variable changed in digest loop, Ember uses property-like system, etc. Meteor has global, flat namespace called "Meteor.session", where application stores _all_ reactive variables that can be referenced by their name. `Meteor.session.set('mymodule.hello', 10)`. It is hard to structure application, when core reactive part is just a singleton dictionary.
- Once you get used to bidirectional data binding between forms and models, it is hard to get away with events. But that's minor.
4. Overall architecture (nitpicking):
- Meteor API likes singletons. `Meteor.session`, `Meteor.methods`, `Meteor.templates`, etc. Single, flat namespaces everywhere
- Even though code can be written in a way it can run on both client and server, there are subtle core API differences. Like it is not possible to use `HTTP.get` on the client without callback, but it works on the server, just blocks the fiber. If you use callback on the server, you need to block the fiber manually (using future or fiber API), etc.
- No server-side templates. Yes, there's crawlable package for Meteor, but it is just PhantomJS (WebKit) that runs on the server and renders pages for crawlers. Yikes.
This pretty much sums my experience with Meteor.
If you're objecting to the principle of offering the Mongo API or HTTP.get on the client when it's not exactly the same API, we feel the benefits outweigh the costs. The client-side functionality will only get better over time, though there will always be some things you can only do on the server.
Since 3 touches on my area: We're fixing the unstable DOM problem with fine-grained DOM updates. Also, the flatness of Session is not related to how dependencies are tracked. Meteor has a better dependency-tracking system than Angular or Ember; it's more flexible and doesn't require annotations to tell the framework what's happening.
However, the Meteor community has really done some great work in solving some core issues and others are on the 1.0 roadmap.
Some comments on this below based on our own experience.
> 1. Collection synchronization does not really work even for relatively small amounts of data (say 10k records).
The issues around polling and how the server side cursors/observe works is definitely not perfect. Started using the SmartCollections package which ditches polling altogether and goes with the MongoDB OPLOG for synchonization. Has been performing well for us so far and solved many issues around performance.
>2. Minimongo is interesting concept, but fails on many levels:
Really depends on the usecase. I'am not sure if there is any other alternative to MiniMongo at the moment for other frameworks.
The key thing is you really shouldn't expect to do many MB's of client data storage in your app.
>3. Client-side is not as convenient as current MV* frameworks
The key issue here is the how the DOM is re-written with the current rendering engine.
The new 'Meteor UI' rendering engine and component architecture is promising to solve this issues with html element level reactive-rendering as well as an method for proper UI components delivering similar capability to what Angular offers.
The framework is still growing up, but we are hard pressed to find something that delivers similar developer productivity.
Once you understand the framework and IF it fits your needs, Meteor can work well for production.
Yes, I'm aware about this package. However, in my case, I had to reactively count number of items in collection. SmartCollections does not have `observe` for server-side cursors and core Collection implementation is slow, so I decided to use `setTimeout` to check collection size every few seconds, which turned out to be much faster than generic collection implementation.
> The key thing is you really shouldn't expect to do many MB's of client data storage in your app.
True, it just contradicts point 003 on http://www.meteor.com/
Plus, I was also referring server-side. Application does not work with node.js MongoDB driver, it still goes through thin minimongo layer, which hides most of the driver API. And it is not fast either (due to reactivity) - see insert performance example.
Overall, I don't say it is not possible to run Meteor app in production (I have one). It is just there are alot of different quirks and gotchas in Meteor that should be worked out manually or with help of community-created packages. And all this information is mostly scattered around StackOverflow, Meteor bugtracker or in Meteor source code itself.
It is quite unpleasant to stumble upon collection synchronization performance when you have most of the application in place.
Would you be willing to share a sample of the document schema that was causing problems when syncing 10k documents? I'm very curious to know if these were large or small docs, single schema vs. varying schema, etc.
There are no indexes, so whenever client wants to find something in synchronized collection, it'll have to scan through all documents. With 10k documents it was locking up DOM (it was very noticable).
If documents are large, client won't be able to connect to the server with any of the polling transports - initial synchronization time exceeds 30 seconds and SockJS will drop connection. This is partially solvable by having reverse-caching proxy (i.e. nginx) forcibly compress all polling SockJS responses.
Obviously, it's still new and has some kinks but 1.0 is around the corner, and we've found the ease of development is well worth the few issues we've had to work around.
An example app: http://assistant.io
Can meteor use Postgres instead of MongoDB? Could meteor do sync with the database through a server-side rest client (instead of mongodb)? Is TDD possible? Is CoffeeScript possible?
Stop it. Stop being used for application programming.
It used to be the only choice for cross-platform web applications, but with cross-compilation emerging as a real alternative that is no longer true, so the sentiment has merit, and it is a proper criticism of a framework that relies entirely on writing everything in JS.
That's actually a problem a lot of multi-paradigm, flexible, expressive and powerful languages suffer. People want to use it like the language they mostly used, get frustrated about how it's a different language and not just a slightly different syntax.
I mostly blame it to the fact that most people learn Java and a certain style of Java as their first language. It's actually saddening, because it causes computer science to become more and more a "just good enough" thing. It's sad, because it started with people (and with that I mean Ada Lovelace, just like various scientists in nearly every decade of the last century) who did what they did not because it was cool and well-paid to do computer stuff, have your own startup, etc., but because they had enough enthusiasm and imagination to make this possible. Lovelace in the 1th century(!) imagined that there could one day be "calculating machines" used to draw paintings!
Your bar for 'proper criticism' is low.