优秀的Meteor学习资源
查看: 4921|
评论: 0|来自:
摘要: 不久前，CSDN研发频道向大家介绍了一款新鲜出炉的现代网站开发平台——Meteor.js，Meteor.js是建立在node.js上的一个开源平台，用于快速构建“现代化”实时Web应用。如果你对Meteor.js非常感兴趣，可以参考Meteor Ro ...
不久前，CSDN研发频道向大家介绍了，Meteor.js是建立在node.js上的一个开源平台，用于快速构建“现代化”实时Web应用。如果你对Meteor.js非常感兴趣，可以参考。与此同时，如果你想了解更多关于使用JavaScript和Meteor.js进行应用开发相关信息，我们将提供一些学习资源给大家，帮助你能快速地使用它们进行应用开发。JavaScript除了需要对前端库/框架进行了解外，比如jQuery或者MooTool，还需要了解JavaScript这门语言，所以在学习之前，对JavaScript进行一番了解则是必然的。可以在互动教程网站上学习。推荐一本非常适合初学者学习的书籍：，作者是Marijn Haverbeke。其在线版本不仅免费，里面还提供一些交互式代码示例。另外，你也可以在上查看一些教程。如果你已有一定的基础，你可以阅读。祝你突破成功，是时候成为。Mozilla Developer Network有许多，可以当做参考。在准备学习Meteor之前，请了解一些，这些视频对提供你的技能水平是非常有意义的。常用的Meteor资源掌握JavaScript的一些基础知识后，你就可以投入到的学习中了。由于Meteor.js旨在彻底简化App的开发，所以你很快就会看到成果。在前往Meteor网站之前，，此外，也是非常好的学习资源。下一步是去学习覆盖了许多你意想不到的主题。如果你还未准备充分，你可以使用代替普通的Meteor。提供200多个用于Meteorite的包。如果你遇到一些特殊的问题，可以上提问。如果你喜欢网络聊天室，你可以加入。编码教程阅读Andres Scala写的。Andrew Munsell提供了。EventedMind向你展示了如何使用（去）。Tutsplus网站上提供了一个教程，。为Meteor把一个。Ken使用Meteor创建了ChoosePix，并且给大家。Stephen Walther的里面关于表单验证的部分非常不错。就某种程度而言，你可能还想对有些了解。但它与SQL在思考方式上存在一定的哲学差异。代码案例下面是我们从Github上发现的一些使用Meteor.js开发的代码示例：&是一个文档分享网站。测试Sam Hatoum编写的。Sam还编写了。向大家演示了如何使用。产品必读完成代码编写工作并且对App进行测试，但如果你想让该款App能在市场中存活下来的话，那么下面提供的信息你可能会很感兴趣。运行速度慢？可以看一下Stephen Pope遍写的。如果你打算自己托管Meteor应用，最好对有所了解。也是个不错的主意。阅读Julien Chaumond写的。书对于初学者来说，利用业余时间多看一些书籍是个不错的选择，它们能给你提供结构化的指导和一些系统概念。Isaac Strack编写的。Jacob Clark编写的，这本书目前只完成了4个章节。将于2013年4月出版。如果你对JavaScript还有所畏惧，那么使用CoffeeScript会容易很多，看看。相关框架Angular.js：上提供了许多好的学习资源。Backbone.js：可以在进行全面的学习。包用于路由的以上是作者所收集到的有关Meteor.js和JavaScript的学习资源，如果你有更好的资源，欢迎与我们分享。来自：
刚表态过的朋友 ()
快毕业了，没工作经验，
找份工作好难啊？
赶紧去人才芯片公司磨练吧!!自由、创新、研究、探索
Linux/Windows Mono/DotNet [ Open Source .NET Development/ 使用开源工具进行DotNet软件开发]锐意进取，志存高远.成就梦想，只争朝夕.从你开始，创新世界.【That I exist is a perpetual supprise which is life. Focus on eCommerce】
Meteor是什么
基于nodejs的实时web APP开发框架。
Meteor能带来什么
简单的说，你可以用js搞定客户端、服务端的开发。另外，客户端、服务端的界限被极大的模糊。客户端的界面跟服务端的数据是双向绑定的，修改服务端的数据，用户界面会随着更新；你也可以在客户端直接修改服务端的数据库。
系统的归纳下，对于（前端）开发者来说，可能比较吸引人的点。
统一开发语言：客户端、服务端都可以用js搞定。
提高开发效率：开发者可以用10行左右的代码就开发出一个具有多点实时更新的应用，因为底层框架已经帮你处理好了数据更新、数据同步以及界面更新的工作。
数据驱动下的多端同步更新机制：基于DDP协议，服务端数据的修改会引起客户端界面的更新，同时客户端对数据的改动也会同步到服务端。
统一插件系统：同样的插件，可以同时运行在客户端、服务端。
简易热部署：通过简单的命令，即可快速部署到生产系统。同时对所有当前已链接的应用进行更新。
高实时性：通过巧妙的延迟补偿策略，让终端的用户感觉是在访问一个实时无延迟的应用。
原生应用：可通过编译工具，将web app编译成原生的终端应用程序
数据库访问：客户端、服务端都可以直接访问数据库（安全性隐患）
getting started
demo请，参照官方demo进行的仿写，进一步进行了简化。也可直接参考官方demo
meteor的入门demo还是比较好上手的。跟着ste by step的教程走，基本就可以捣鼓出一个像样的TODO LIST的demo了，所以这里也不打算细讲，只是挑一些重点备忘下。
首先，安装meteor，然后通过meteor create这个命令创建一个新项目。
meteor create meteor-todo-list
创建好的项目结构如下。
大致包含以下内容。有点像传统的web页面，1个HTML页面，再加1个css文件、1个js文件。
├── .meteor
meteor-todo-list.html
打开html页面，你会发现只有head、body、template三个标签。如果接触过模版引擎的同学会有中熟悉之感。其中：
head、body两个标签中的内容，最终会被嵌入到输出给终端用户的HTML页面中。
template则定义了页面需要用到的模版，有点向web component规范看齐的意味。
举例来说，head标签中内容如下
我们访问页面就可以看到title为程序猿小卡
至于body标签，如果对handlebars熟悉的同学，大致就知道是干嘛用的了。{{&create}}引入定义好的模版，该模版的name为create。{{#each tasks}}则是对数据进行遍历，至于数据源，下面会提到。
我们再来看看这段模版。name为create，就可以在页面里方便的通过create这个名字来引用这段模版（包括模版嵌套）。而模版数据会在&meteor-todo-list.js&小节提到。
meteor-todo-list.js
打开meteor-todo-list.js，会看到一行显眼的代码。正如meteor官方介绍所说，meteor应用的代码可以同时跑在客户端、服务端。有些场景下，某些代码只适合跑在客户端，那么，就可以用下面的判断。
if( Meteor.isClient ){
meteor-todo-list.html里其实就一堆模版。相应的，需要为这些模版提供数据。数据大都是存在数据库的，那么就需要有数据库操作。
除了数据之外，还要处理用户交互，那么就涉及到事件绑定。
1、数据 & 数据库操作
数据在meteor应用了扮演了极为重要的角色，作为实时双向更新的引用，meteor服务端数据的修改，会导致客户端界面的更新。同时，客户端用户操作导致的数据更新，也会实时同步到服务端。&比如这段代码，意思就是，模版body用到的tasks数据，就是这个同名方法的返回值。
比如页面有这么一段无聊的模版，那么就可以通过Template.nonsense.helpers来注册nonsense这段模版需要用到的数据。我们的页面里其实没有name为body的模版，这是因为内部做了特殊处理，body、head标签默认当模板对待了。
下面来讲数据库操作，这里用到了人民大众热爱已久的mongodb。
首先，我们我们创建collections，对应的是一系列的文档集合，下面我们做的就是对这个文档集合进行操作，比如增、删、改、查，这四大操作demo里都覆盖到了。
var Tasks = new Mongo.Collection("tasks");
举个例子，返回所有的task数据，类似mysql里的select *。
return Tasks.find({});
插入一条task。
其余操作类似，这里不赘述，更多细节参考。
2、事件绑定
相当直观。以下面代码为例。更多细节参考
Template.create.events表示为&create&这个模版渲染出来的节点绑定事件。
click .js-add表示：为.js-add这个选择器匹配中的节点监听click事件。
event就是常规的事件对象。而template相当于模版自身的引用，可以通过template.$(selector)来选中模版内部的子节点。（类似backbone内部节点操作的设计）
Template.create.events({
'click .js-add': function(event, template){
var ('.js-text'),
value = $input.val();
Tasks.insert({text: value, createdAt: new Date()});
$input.val('');
meteor-todo-list.css
没什么好讲的，跳过。。。
DDP是&分布式数据协议&(Distributed Data Protocol)的简称，meteor双向实时更新机制的底层依赖的就是这东东。
粗略瞄了下协议，大致有两个特点：
平台无关的通用协议：DDP只是定义了协议的格式和一些规范，但具体用什么语言在什么平台上实现无所谓，你可以用js写，也可以用java写。
json格式：从协议说明，以及实际抓包来看，服务端、客户端数据通信采用的都是json格式的数据，前端极为友好～
实际看看例子。在chrome控制台下，切到WebSocket这个tab，就会看到不断的有收发包。部分是用户操作发出（如删除操作），部分是用于保持通信状态的心跳包。（可以这样翻译吧。。）
协议比较长，内容本身倒是不复杂，有兴趣的自行围观。。。
meteor有自己的包管理机制，也有个专门的社区在维护&&。关于这个，有空再单独拎出来讲讲。
编译原生应用
同样没什么好讲的，直接贴上官方文档地址&&，有空再贴几章截图。。
TODO demo：&官网：&入门教程：&DDP协议：
github博客：&新浪微博：&站酷主页：
阅读(...) 评论()
随笔 - 14024
评论 - 900Learn Meteor.js Properly | JavaScript is Sexy
(Learn Meteor and Everything You Need to Know about It)
At the end of this article, I outline two comprehensive study guides to help you learn Meteor properly. The study guides are for both beginners and seasoned developers. The first study guide, which uses a book, a paid screencast, and some free online resources, teaches you how to build a sophisticated, modern social-media web application with Meteor. And the second study guide, which uses only free resources (one affordable screencast and free online resources), is just as instructive as the first, though you won’t build a specific web application throughout the course.
Our Career Paths and Courses Website Is Now Live
Learn.Modern Developer Launched
Our first cohort is in session: 97% of our first cohort on target to graduate. Enroll in the second cohort. Career Path 1: JavaScript Developer and Career Path 3: Modern Frontend Developer usually fill up quickly.
First, I give a comprehensive Meteor overview, in which I discuss just about everything you want and need to know about Meteor before you commit to investing your time and other resources in this still burgeoning though exceptional technology.
Time to read the Meteor Overview:
14 minutes ?
Table of Contents
What You Will Learn in this Meteor Overview
I explain exactly what Meteor is, how it differs from typical JavaScript frameworks, what it offers developers specifically, its alternatives and contemporaries, whether you should be excited or skeptical about it, and where to find Meteor jobs. I also enumerate some of the endorsements written by Meteor converts, and I explore the justifiable criticisms, known limitations, and frequently asked questions that many have raised about Meteor. You will learn all this and much more.
I am honored that you have joined me and I am hopeful you will find this article helpful and illuminating and the accompanying study guides and recommended resources sufficiently instructive. If you don’t, then I would have failed and I would l please notify me in the comments below. Don’t hesitate to alert me of any grammatical errors, typos, general errors, misinformation, missing information, outdated content, or incomprehensible sentences or passages. You won’t hurt my feelings, for I am most interested in providing you accurate, clear, and comprehensible material, and only you can determine whether I have done that.
Learn Meteor Properly Study Group
People have already started study groups for this study guide. One study group starting today (November 3) on
already has over 100 members. You can also find the group on .
If you want to start a study group, send me
Email Address :
Let’s begin with a comprehensive overview of Meteor.
How Will Your Life Change After You Learn Meteor Properly?
No, you won’t be cleansed of your sins and washed of your immoralities after learning Meteor properly. Neither will you lose five pounds nor grow two inches.
However, if you have never developed any kind of application before, you will experience ecstasy, so powerful and liberating it will free you to envision, build, and realize your imaginations, like an artist discovering paint and canvas for the first time.
If you currently use Meteor (and even if you have read a Meteor book or some tutorials), you will emerge better equipped to understand and handle common Meteor errors and the often-misunderstood Meteor “magic,” allowing you to experience Meteor’s true efficacy. Efficient, productive, painless.
If you use Rails, Node.js, PHP, Django, Go, Scala, or Java, you will understand Meteorites’ (i.e., Meteor developers) unapologetic praise for Meteor. You wouldn’t be convinced that every facet of Meteor is better than every facet of Rails or Django (it isn’t) or that Meteor will kill Rails or Python (it won’t). But you will undoubtedly acknowledge and appreciate, even if reluctantly, the efficiency and painlessness Meteor affords, as well as its effectiveness in making you a more productive developer—indeed, a happier developer. But be careful, my friend, for even a faithful developer can be tempted by seduction, lured by betterment, and give in to pleasure.
If you currently use proven but old-school technologies to develop applications, learning Meteor properly will allow you to experience the current state of modern web application development. This will prepare you for the foreboding robotic and futuristic frameworks that will inevitably evolve out of technologies like Meteor. You will therefore become familiar with the latest, experience the now, and embrace the inevitable.
Or, if after learning Meteor properly you remain unmoved, unconvinced, or unimpressed, then we would love to hear from you. For you may have invaluable information about efficient web-development tools that we can all use.
Meteor Transcends (Goes Beyond) Typical JavaScript Frameworks
To characterize Meteor as a “JavaScript framework” would be to:?
rob Meteor of its comprehensive and
that is, unlike typical JavaScript frameworks, Meteor offers much more than just a front-end, a backend, or a combination of the two with some libraries. It offers everything you need to build web applications: a seamlessly integrated ecosystem that includes frameworks, libraries, database, tools, and more?
overlook its
that is, you can not only develop traditional RESTful web apps and modern real-time web apps with Meteor, but you can also deploy and host web apps, build and deploy mobile apps, connect Arduinos, and more?
and ignore it that is, Meteor has proven effective not only in helping developers build all sorts of applications and packages efficiently and painlessly, but also in empowering others—including the poor1, the nontechnical2, and the uninitiated3—realistically and inexpensively acquire a highly valued skill: the capacity to develop complete web and mobile applications in relatively short time and with limited resources
For these reasons—its comprehensive and integrated ecosystem, extensive usefulness, and expansive efficacy—Meteor transcends, or goes beyond, typical JavaScript frameworks, a characterization more apt for frontend frameworks like Backbone.js, Ember.js, Angular.js, and the like.
What Exactly Is Meteor?
Since Meteor is not a JavaScript framework, what is it then?
Written in JavaScript on the Node.js platform, Meteor is an open-source Isomorphic Development Ecosystem (IDevE) for efficiently and painlessly developing web and mobile applications. The Meteor ecosystem seamlessly integrates all the components (tools, libraries, databases, and frameworks [frontend and backend]) necessary for building and deploying applications.
In short, Meteor provides you with everything you need—except for your desire and a text editor—to develop and deploy complete applications.
Meteor makes developing applications efficient by providing a no-fuss API that works the same everywhere and by including many pre-built functionalities most applications need. And it makes the process painless (relatively painless) by removing many of the technical hurdles developers usually have to contend with when developing applications.
Isomorphic Development Ecosystem (IDevE)
Isomorphic. Isomorphic refers to using the same code on the fron that is, using the same API everywhere (frontend, backend, and even for mobile apps). For example, a piece of isomorphic code is Meteor.logOut(); calling this piece of code would work the same on the frontend and the backend, and even in your mobile Meteor apps. You can think of isomorphic as homogeneous (of the same kind).
Development. Meteor provides all the tools for the application development life cycle, from setup
and configuration tools to API and deployment tools.
Ecosystem. To understand the difference between a JavaScript framework like Angular.js and a development ecosystem like Meteor, consider this: A framework is like an it has a sink with running water, a stove, and a you can cook in such a kitchen of course, but you must bring your own vegetables, pots, containers, and everything else you need, including cabinets for storage. An ecosystem, on the other hand, is like a furnished kitchen with a
you need only your desire, maybe a recipe too, and you can cook any kind of meal in the kitchen. The ecosystem provides you with everything you need—all the ingredients, all the utensils, all the containers, all the storage space, and more—to cook complete meals from beginning to end.
The Meteor ecosystem includes a seamlessly integrated frontend, backend, a well-conceived isomorphic API linking the entire core system as well as linking third- and the tools and managers. The stocked Meteor kitchen—the Meteor ecosystem, with all the vegetables, cabinets, utensils, and ingredients—allows you to season, cook, and enjoy: setup, develop, and deploy.
Incidentally, you don’t have to deploy or host your Meteor apps with M you can use any other service provider or deploy your apps to your own server.
Alternatives to Meteor
The alternative to an IDevE (Isomorphic Development Ecosystem) is either an MDevE (Multifarious Development Ecosystem) or an MDevE Generator. An example of MDevE is , which combines multifarious (i.e., of various types—different APIs: MongoDB, ExpressJS, AngularJS, and Node.js APIs) libraries, frameworks, and tools to create a development ecosystem somewhat similar to Meteor. Though the APIs are multifarious (not isomorphic), they are still integrated, such that Mean.js presents an integrated ecosystem like Meteor. Mean.io, which is nearly identical to Mean.js also deserves a mention as an MDevE.
, also an alternative (though not a viable one as of November 2014) to Meteor, is the only other MDevE I it presents an integrated ecosystem like Meteor and Mean.js, but Derby is simply incomplete and buggy at this juncture, and its documentation and examples need much work.
An example of an MDevE Generator is , which allows you to easily use the command line to generate MDevE ecosystems like Mean.js. Indeed, Mean.js (an MDevE) and Yeoman (an MDevE Generator) are viable alternatives to Meteor.
Another IDevE like Meteor is , a new open source ecosystem almost as ambitious as Meteor. But like Derby.js, Hoodie has a long way to go to be considered a viable alternative to Meteor. We can justly conclude then that Meteor is the only viable IDevE available today.
What Specifically Does Meteor Offer Developers?
As I noted above, IDevEs (like Derby.js and Meteor), MDevEs (like Mean.js), and MDevE generators (like Yeoman), pushing beyond modernity, offer developers similar automation, configuration, and suite of libraries, frameworks, and tools. Meteor, in particular, offers developers much more than those technologies, though, and, arguably, its seamlessly integrated ecosystem has no equivalence today, as you will see from the list of features outlined below:
Meteor not only has a one-step installation for configuration and setup, but it also has an
isomorphic API, which refers to using the same code on the frontend or backend, or even for mobile and web apps. This saves developers hours, perhaps even days and weeks, since there is no need for developers to wrestle with installing, configuring, and learning disparate libraries, module managers, multifarious APIs, drivers, and the like.
It offers not only a front-end framework, like Backbone.js, but also a backend that seamlessly integrates with the frontend, and an easy-to-use API for communica this provides developers with straightforward, no-fuss client-server data management (Collections, Models, etc.), server-side methods, and server session management.
It provides not only bidirectional persistent communication (like socket.io), but also simplified reactive programming (like Bacon.js). The reactive programming library works in conjunction with the front-end framework to reactively (that is, instantly and continuously) update the UI whenever dependable data or variables change. Moreover, a Meteor community developer has implemented the Meteor front-end templating engine on the server, providing server side templating for Meteor. I should caution that this implementation is still in its infancy.
It offers not only a stack that includes MongoDB database (with PostgreSQL and others planned), but also a front-end representation of MongoDB, called Minimongo, written entirely in JavaScript and available in every connected client. Meteor integrates the two (MongoDB on the backend and Minimongo on the frontend) in a well-conceived manner to mitigate latency, a concept called latency compensation. This results in considerably faster page updates and reloads, leading to a more satisfying user experience for developers and end users alike.
It not only has a standardized Mongo API on both the frontend and backend, but it also has Oplog tailing for MongoDB, resulting in applications using substantially less server resources.4
It has a standard front-end router (created by a Meteor community member) that implements the best features from other popular front-end routers, and this router also provides server side routing and includes a familiar API like Express.js’s routing API, even allowing for connect middleware, RESTful endpoints, and the like.
It has a lightweight front-end framework, Blaze.js, that has a templating engine that supersedes Handlebars.js, with a rendering engine similar to the WIP (Work in Project) HTMLBars. I should note that Blaze is neither as feature-rich and robust as Ember.js nor as expansive and extensible as Angular.js.?
Its integrated live browser reload (also known as hot code load and hot code push) not only automatically reloads your live web page whenever you make development changes on the frontend (HTML, CSS, images, JavaScript, etc.), but it also automatically refreshes just the necessary DOM elements on the page (without reloading the entire page), even when there are dependent changes to data on the backend (MongoDB) or frontend (Minimongo).
It comes with requisite core packages to handle minification, preprocessing, concatenation, OAuth and custom user authentication (signup, login, forget password, etc.)., emailing, packages for popular frameworks like bootstrap, backbone, and jQ and even a package for SEO compatibility.?
It has its own command line tool that provides many of the functionalities provided by tools such as grunt, NPM, NVM, and the like. And if you add EventedMind’s em5
scaffolding tool, you also have some (though not most) of the functionalities provided by popular scaffolding tools prominent in Rails and Yeoman.
It allows you to use NPM modules and it provides its own build system (a custom package manger) that transcends NPM, providing nearly all the worthwhile and crucial NPM functionalities and more. You can install third-party or custom Meteor packages , the official repository for Meteor packages. So you have access not only to NPM’s 98,000+ modules, but also to Meteor’s AtomophereJS 2600+ smart packages. ??Let’s allow Geoff Smith, one of the founding members of Meteor, to expound on the advantages and goals of Meteor’s package manager:
The main [goal] is “Isomorphic JavaScript.” This has come to refer to JavaScript code that can run equally well on the client or on the server, meaning that you can write your JS once and run it anywhere…you can add the http package and use the HTTP.get() function on both the browser and the server. It works everywhere, so now your Facebook friends-fetching code can be used anywhere in your app.6
Two-level namespace, where packages that are “safe bets” (widely used, mature, supported, tested) get a short name like “forms”, and experimental, up-and-coming, or personal packages get a name prefixed with the author’s name, like “gschmidt:forms.7
The package system needs to integrate nicely with Meteor’s asset building/bundling system.7
When you update to Meteor [0.x.x or 1.x.x], you’re pulling a new set of core packages, which are guaranteed to work together (because we’ve tested them, a lot!) We want to keep this experience, where you don’t have to micromanage the versions of all of your packages, and where “meteor update” always gives you a consistent known-good snapshot.7
It uses synchronous style coding, courtesy of the Fibers JavaScript library. This provides an easy to read code structure that many find more appealing than the asynchronous structure of callback functions, common in most JavaScript frameworks. I should caution that you must pay close attention to the section in the road map that deals with making async calls in Meteor because many seem to have trouble when making async calls in Meteor.?
It even provides support for mobile apps through Cordova Phonegap integration. You can easily deploy your Meteor app as a mobile app, using these simple commands:
meteor run ios
“runs your Meteor app in an iOS simulator and starts the server.”8
meteor run android
“runs your Meteor app in an Android simulator and starts the server.”8
I should note that I have not tested the mobile support and it appears to be embryonic as of October 2014. . And .
If you are wondering, hot code reload does work on iOS apps. Apple approved this functionality for apps in the AppStore.9???
Meteor takes a proactive approach to security, reportedly with a core developer dedicated to addressing .
It has an official testing framework, Velocity,. With Velocity, you can use your favorite testing frameworks like Jasmine or Mocha, and run acceptance tests with Selenium. ?
Finally, it not only has a team of dedicated and capable engineers with a vision for changing the world (nearly every team has that), but it also has a lovely bank account: $11.2 million in funding10??? (hardly any team has that). This essentially secures Meteor’s stability for the near future, guarantees frequent updates and timely responses to Github issues, and ensures constant interaction with the community (well, when they think it necessary anyway).
Best Text Editors and IDEs for Meteor
You will develop Meteor applications easier if you use an IDE like , the only IDE that supports Meteor. Watch this
that shows you how to use Meteor with WebStorm:
You should also watch these
to learn a bit more about WebStorm. While not the most comprehensive tutorials, they do teach you a thing or two.
is also an outstanding editor for building JavaScript applications, and you can use it to develop Meteor apps.
&Should You Be Excited or Skeptical About Meteor?
With such a comprehensive and seamlessly integrated suite of tools and libraries, and a database, as well as a package manager, in one ecosystem, Meteor does much more than popular front-end frameworks like Angular.js and Backbone.js do, and more than MDevEs like Mean.js and Derby.js do.
Does this mean you should use Meteor to develop every kind of web application, or that Meteor is a better choice in most situations? No. Arguably, the versatility (the sheer number of options it offers) and modularity (the sheer number of ingredients, that is, frameworks and libraries you can integrate with it) afforded by an MDevE Generator like Yeoman provide the freedom some developers prefer over an isomorphic ecosystem like Meteor, even though Meteor is inherently modular to some degree: some of its components can be swapped or used outside the Meteor ecosystem.
Nonetheless, even though Yeoman is more versatile (i.e., you can generate all sorts of ecosystems with it, including Meteor itself) and modular (i.e, you can swap any p e.g., Backbone.js for Angular.js) than Meteor, I wouldn’t be surprised if, by the time Meteor reaches version 2.x.x, its funding, effective marketing, seamlessly integrated ecosystem, and all the other benefits I enumerated above will make it a natural and preferred choice for many web developers.
Are you excited to learn more about Meteor, to learn Meteor properly, to start building apps more efficiently?
Yes? No? Maybe?
At this point, having read all the benefits that Meteor offers, you likely look forward to learning and using (or continuing to use) Meteor. You may even be grinning approvingly, giving the thumbs up or the peace sign while your neurons delight in anticipation of the Meteor experience:
On the other hand, you might be skeptical or critical about Meteor, a new and largely untested technology. Perhaps you might even dislike Meteor (for any number of reasons), and you could be biting your teeth disapprovingly, calling my previous paragraphs bull’s pizzle while your blood boils and your fingers or perhaps more politely, you could be crossing your arms in defiance while your brow knit in contempt:
If you are among the thumbs-up, nodding, smiling, neurons-sizzling majority, I am hopeful you will find (or continue to find) Meteor as useful and fun to work with as I have. And I trust the Meteor core developers will continue to stabilize, secure, and optimize Meteor so developers needn’t worry about its limitations.
On the contrary, if you are so far unconvinced of Meteor’s wizardry and you are among the teeth-grinding, blood-boiling, brow-wrinkling minority, I do understand and respect your skepticism, for skepticism often authenticates, validates, and even disproves. Nevertheless, please keep reading. By the time you finish reading this article, following the road map, learning Meteor, and developing at least a couple of applications with it, Meteor will have charmed you just as it has charmed many others. For even a proud and defiant heart can be made gentle and agreeable by a motherly hug that resonates, an intimate kiss that titillates, a delightful web technology that captivates:
&A Chorus of Praise and Appreciation for Meteor
Convinced or unconvinced, smiling or smirking, thumbs up or arms crossed, you have learned enough from me about the virtues of Meteor, so let’s hear from others in the tech community. Read for yourself the chorus of respect, of admiration, of exuberance:
On Hacker News, Reddit, and Twitter:
Anonyfox:?
The biggest step forward for JS development is Meteor, hands down. For anything “appy”, the productivity is just insanely good. … I spent the last months doing meteor exclusively, and compared to the usual node/RoR/php stuff on the server and angular/backbone/ember on the client, meteor is just superb IMO.
Rywalker:?
I am a Rails dev since 0.8 —&but since moving to Meteor the past few months, I’ll not go back to Rails
Superplussed:?
I was initially put off by [It’s non-npm package manager] as well… Now I see the the benefits of the closed ecosystem. In Meteor you are dramatically constricted in choice, but everything that is available to you works effortlessly together. If you install a package, you pretty much know it’s going to work. I really think that what is currently seen as a negative regarding the ecosystem is going to develop into one of its over-riding strengths. Suffice it to say, I’m sold on Meteor.
Both in its current state given its youth, and in the direction it is moving.
I run an agency in Belgium () and we switched completely to meteor for all of our new projects. I think it’s the framework of the near future.
Mark_l_watson:?
I am very impressed by Meteor! Earlier this year I did an experiment: I coded a complete application in Clojurescript + Clojure back end, and then afterwards in Meteor.
I have tons of Clojure experience (with little bit of Clojurescript), and not too much use of Javascript. I spent much less time on the Meteor version and it had lots more features. Really no comparison. Unless you really dislike Javascript I suggest you try Meteor.
Last week, we had a last minute project that required some sort of webapp that could allow X number of users viewing a certain page on the browser and editing things off simultaneously with good enough conflict resolution. Of course, I could have done it with Rails on the backend… But as curious as I am, I decided to checkout Meteor and it was perfect for my case. In less than an hour (with Meteor) I had everything working as expected. The app was for a big social event and all it mattered in the end is that it worked and impressed everyone involved. No one really cares what you build it with, as long as you deliver. In my opinion, Meteor is worth a shot if you’re building a small scale reactive system.
it has really come a long way since i started developing with meteor about 4 months ago. if the pace of development continues as it did so far i think it will become even more relevant as time passes. Blaze is an absolute delight to work with nowadays and the framework in general feels smaller and more flexible allowing easy use of individual components.
Hharnisc:?
Over the past year I’ve been replacing the tools I’ve built with Django one by one (as well as a few new ones along the way). Because of the publish/subscribe model and reactivity I’m finding that my codebases are smaller when compared to most Django projects.
Meteor: an ultra-simple environment for building modern websites, using the familiar MongoDB API
& MongoDB (@MongoDB)
Crowded meteor.js workshop at
happily hacking already
& Fernando (@oinak)
The dawning of a new age of Javascript on both web client and server.
Impressive tech. JS FTW
& Garry Tan (@garrytan)
Justifiable Criticisms, Known Limitations, and Frequently Asked Questions about Meteor
Some developers have raised a number of justifiable and unjustifiable criticisms about Meteor. While some of the concerns and criticisms have been either debunked or resolved in recent versions of Meteor, some remain justifiable. The frequently asked questions, known limitations, and justifiable criticisms about Meteor follow, along with a comment or an answer to each:??
Frequently Asked Meteor Questions
Q: Can I build mission critical applications with Meteor?
?A: , Coauthor of DiscoverMeteor
Meteor is still beta software, but it’s actually very close to the 1.0 release. So within the next few months, it’ll probably be safe to assume that Meteor is ready for whatever you can throw at it!?
Q: What kinds of applications can I not build with Meteor?
??A: Sacha Greif, Coauthor of DiscoverMeteor
Meteor isn’t great for anything that’s mainly static content, like blogs or simple static sites. As a general rule, Meteor is great for apps, but not for sites. Another factor to consider is the fact that Meteor doesn’t do server-side content generation yet, meaning that your app won’t work without JavaScript enabled.
Q: Do you have proof of Meteor holding up and scaling well in production?
?A: (?? Awaiting an official response from Meteor Development Group)??
Q: What big companies or funded startups are using Meteor?
???A: Sacha Greif, Coauthor of DiscoverMeteor
There’s
on the Meteor site, but it could probably be updated. Two companies not mentioned there are
Q: Does Meteor scale at least as well as Rails in production?
?A: (?? Awaiting an official response from Meteor Development Group)??
Known Meteor Limitations
Meteor works only on Mac, Linux 64, and Linux 32.
It does not officially support Windows, Solaris, and Freebsd.
It supports only one database: MongoDB.
It has no support for sharding on MongoDB.
Its frontend framework does not have reusable UI components.
It has only partial support for Redis.
It does not work well with SEO, even with its Spiderable hack.
Justifiable Meteor Criticisms
Dnprock: Reactive template is nice but can lead to very hard to debug issues…. There’s no really good way to debug reactive update trigger.
?A: (?? Awaiting an official response from Meteor Development Group)???
Lack of generators when compared with Rails and other frameworks
Neya: We’re talking about the basic reason why people choose rails: Productivity (Getting stuff done) and getting your product out to the market. I think in this perspective nothing beats rails:
rails new blog
rails generate scaffold Post title:string text:text
How many lines of actual code I have written so far to actually get my basic blog idea up and running? None.
?A: (?? Awaiting an official response from Meteor Development Group)?
Many [, Meteor package management] packages don’t have the mo the readme file for most packages is missing.
?A: , Developer
and Coauthor of DiscoverMeteor
This is up to the package author to resolve, but the core Meteor packages are currently in the process of being “readme-ized” by MDG (e.g. )
Its front-end framework, Blaze.js, is neither as feature-rich and robust as Ember.js nor as expansive and extensible as Angular.js.
?A: (?? Awaiting an official response from Meteor Development Group)?
Learn Meteor Now If…
The noted Meteor limitations and criticisms are negligible when compared with the noted benefits, unless you absolutely abhor MongoDB or it cannot scale well for your particular use case.
Furthermore, Meteor is nearing version 1 (relatively stable), websites are already using it in production, you will no doubt develop applications quicker with it than you will with many competing technologies (after you learn it properly), you will be a more attractive job candidate (especially in the coming months), and you will be able to develop nearly any kind of application with Meteor that you can think of.
Accordingly, you should learn Meteor now if:
you plan to develop a startup (not a native mobile app) now or within the next year,
you have to develop a real-time, RESTful, or single page web app
you want to build an MVP (Most Viable Product) or a prototype of a large application
you are now learning to code and you want to build your first web application ( first)
you are a javascript developer (node.js, or any of the many frontend JavaScript frameworks),
you are convinced that Meteor provides the best and most complete ecosystem for building web applications that work on both desktop and mobile clients (though mobile support is still embryonic as of October 2014)
you are a Ruby on Rails or PHP or Java developer and you want an alternative web technology to help you build applications and prototypes faster (note that Meteor lacks some of the generators prominent in Rails)
you are a hacker
you are cool and you like to be on the forefront of technological advancement
you think you are not cool (this means you are cool)
you consider yourself an old-school or hardcore programmer, and you dislike modern frameworks that are trying to make it easier t stay abreast and embrace the now and the future, my friend
you plan to build your own JavaScript (or some other language) framework or ecosystem
you want to learn or teach modern web application development
If you want to work for a large firm as a front-end developer, you may be better off learning a popular front-end framework like Angular.js, Ember.js, React.js, or Backbone.js. You should also learn one of these front-end frameworks if you want a high-paying front-end developer job soon, since, as you will see below, while Meteor jobs exist, you may not find as many opportunities for a Meteor developer as you would for an Angular.js or Backbone.js developer.
If your company has a strong and talented group of backend developers developing the backend, and the front-end is developed and handled separately from the backend, you may want to focus on using one of the noted front-end frameworks on the front-end.
If you need a robust SQL database like PostgreSQL or MySQL for your application, you may want to choose a different technology like Rails (if you know Ruby) or Node.js (if you know JavaScript), instead of Meteor, since Meteor doesn’t support these databases as of November 2014.
And, as Sacha Greif, coauthor of DiscoverMeteor, notes:
Meteor isn’t great for anything that’s mainly static content, like blogs or simple static sites. As a general rule, Meteor is great for apps, but not for sites. Another factor to consider is the fact that Meteor doesn’t do server-side content generation yet, meaning that your app won’t work without JavaScript enabled.
Moreover, not many large firms (if any) are using Meteor as of November 2014, so keep this in mind before you commit to learning Meteor now.
Meteor Developer Jobs
The biggest downside to learning Meteor today is that there doesn’t exist an abundance of Meteor jobs for Meteor developers. Unlike job postings for technologies like Ruby on Rails, Node.js, Backbone.js, and Angular.js (especially), comparatively fewer Meteor jobs exist today. And this shouldn’t be surprising since Meteor is a younger technology than those noted. This shouldn’t deter you from learning Meteor, however. Consider that you can find Meteor jobs now (see the links below) and large companies will soon discover that the Meteor magic can result in considerable productivity and financial gain, not to mention a boost in employee (developer) morale.
Meteor jobs:
For the most up-to-date Meteor jobs, follow MeteorJS Jobs on Twitter:
Most Helpful Meteor Resources
Somewhat surprisingly, given Meteor’s relative newness, you can find quite a few helpful Meteor blogs and websites. Knowing who, which Meteor guru, to follow and which websites to rely on requires a bit of research, so I will save you some time.
I don’t want to overwhelm you with Meteor resources (many are popping up almost daily, and most seem to overlap), so I will keep the list brief with those that I find most helpful:?
: A Hacker News style news site for Meteor. Get the latest Meteor news, updates, and blog posts from around the web.
: An exhaustive resource with invaluable Meteor tips
: Here you can find a number of quality Meteor tutorials from an author who always writes with the patience and diligence of an elementary school math teacher.
: This site has you covered from head to toe in Meteor resources. What else do you need?
: A reputable blog from the acclaimed authors (Sacha Greif and Tom Coleman) of the DiscoverMeteor book.
: Ask questions, discuss, share, meet up, and more
: Be inspired and learn from a transformational Meteorite bursting through the atmosphere?
: Kick back with a cup I do.
: Write Meteor code in the browser, like JSBin
Other Noteworthy Meteor Resources
Follow Meteor.js (), EventedMind (), and DiscoverMeteor () on Twitter?
Get on the Meteor mailing list. Go to this link and scroll down to “Get on the mailing
list”:?
Notable Hackers in the Meteor Community
To keep up with the latest Meteor news and happenings and to learn how to optimize and scale your production Meteor apps, you need to know and follow this gentleman:?
Arunoda Susiripala
Arunoda () is arguably the most prominent Meteor hacker. He is also editor of the preeminent Meteor newsletter , and founder of .
Meteor Cred:
He developed some important Meteor smart packages that help Meteor applications perform better (i.e., increase speed, scale, and use less server resources) in production. For example, he developed
(it speeds up Meteor by using MongoDB O Meteor’s core developers have since implemented much of Smart Collection’s technology into Meteor’s core),
(it speeds up pages by as much as 10X, and it has been incorporated into Iron Router, Meteor’s primary router),
(it allows Meteor developers to easily use NPM modules in Meteor),
(it allows you to deploy your Meteor apps to your own server),
(it allows you to render Meteor templates server side, a huge limitation in the current version of Meteor), and many more packages crucial to helping your Meteor application perform and scale well in production. In addition, his Meteor performance and monitoring startup, , is used by many production Meteor apps.
Sign up for his Meteor weekly newsletter.
(This is all you need, really, to keep up with latest Meteor happenings.)
Chris Mather (who created the indomitable , and who probably has a clone because of all the seemingly insurmountable Meteor work, Meteor teaching,
and Github issues he attends to); Tom Coleman (whose firm developed the official Meteor packaging system, , and who created the first Meteor router, the first Meteor packaging manager and repository, and many useful Meteor packages); Abigail Watson (who maintains the exceedingly useful Meteor Cookbook, noted below, and other useful Meteor projects); and the versatile Sacha Greif (without whom, arguably, Meteor would not be as po every startup and open-source project need a Sacha Greif, for he can evangelize your technology like no one else can) have all contributed significantly to the Meteor community and ecosystem.
I know many others have contributed perhaps just as much if not more, so please forgive me for failing to list those names here. I may likely add more names as I am informed of them.
Meteor Tutorials Needed
How to Handle Errors in Your Meteor Application
Meteor Accounts UI Overview
Comprehensive Meteor Tutorial on Making Async Calls:
Update: Phuc Nguyen has written a comprehensive tutorial on this very topic:
Comprehensive Tutorial on Meteor Packages (for Meteor Version 0.9.x)
Acknowledgments
Thanks to Robin Coffman—perhaps the best editor, no doubt a fastidious and exceptional editor—for her punctilious effort editing this article.
Thanks also to Phil Howley, Tony Homer, Nathan Burkiewicz, Yuichi, and Jonas for thoughtfully taking the time to point out some typos and errors in this article, which I have modified many times after Robin officially edited it.
Learn Meteor Properly Overview?
For the ultimate study guide, we are using a book, a paid screencast, and some free online resources. Don’ I managed to negotiate 35% discount off the paid screencast and 20% off the book for you. (No, I don’t benefit in any way when you buy these resources.). So the total for the two resources is $50.05.
For the more affordable study guide, we are using one paid screencast and some free online resources. With the noted 35% discount, the screencast costs just $18.85. So that’s all you need, at least $18.85, to learn Meteor properly.
What’s the Difference Between the Two Study Guides?
The ultimate road map guides you through building a sophisticated social web application, while the more affordable road map does not guide you through building a specific web application. Other than that and other than the difference in cost for the resources, the two road maps are they both use the same screencasts from EventedMind and some free online articles.
Be Empowered
After you complete the study guide and experiment with Meteor, I invite you to use Meteor to develop a web or mobile app. And use your completed app to generate passive income ($) or massive income ($$$$), to empower a community, to prove Meteor’s effectiveness to your boss or colleagues, to solve world problems (I have many ideas I am eager to share with you), to solve problems among your peers or in your neighborhood, to get a job, to create the next Instagram or Facebook or any startup, or to do just about anything you like. If you do build something with Meteor (it needn’t be the next Facebook or Hacker News clone), please post a link to it in the comments below.
Prerequisite
You have to know JavaScript to develop applications with Meteor. Don’t make anyone mislead you. First, if you haven’t done so already, read the entire article above to understand what Meteor is, what you can do with it, and what it can do for your career. Then go
and come back and learn Meteor by following the road map below.
What You Will Learn
In the ultimate road map, you will learn how to build a relatively sophisticated web application (a feature-rich, real-world example of Hacker News—much better, in fact); how to use Meteo how the DDP protocol is used to communicate between the s how to implement collections and subscriptions (the data models for Meteor); how to use the latest (ver 1.0) version of IronRouter, the main M how to cre and how to use every part of the Meteor ecosystem necessary for developing world class applications. We will dig deep, learning the basics and the digging deeper into each topic. You will learn more than you need to know to develop the social news application, but enough for you to feel comfortable using Meteor on your own.
In the more affordable road map, you will learn nearly everything taught in the ultimate road map, except you will not build a specific web application.
Duration: This course will take approximately 6 days (about 40 hours) of studying and coding to complete.
The paid resources for this road map:
Use this discount code (jsissexy_learn) to get 35% off the EventedMind screencast. And use this discount code (JAVASCRIPTISSEXY) to get 20% off the DiscoverMeteor book when you checkout:
($39 $31.20)
($29 $18.85)
Important Note: Don’t just watch the vide be sure to write your own code and build the application as you follow the lessons.
Cost of Resources (EventedMind plus DiscoverMeteor): $50.05
The Ultimate Study Guide for Learning Meteor Properly
Let’s get to work.
Have a Go at the Appetizer: A Gentle Introduction to Meteor
Before we begin the study guide, the main course, you should at least have a gentle introduction to Meteor. Go take either one of the following tutorials:
1. : This free online book (it’s a tutorial that will take about 30 minutes) gives you a gentle introduction to Meteor, with basic instructions on using the terminal and more. If necessary, skip some of the elementary instructions.
2. The official
Be sure to come back and have a go at the main course after you finish the appetizer, or you may remain unfilled.
Introduction: Setup and Getting Started
EventedMind:
EventedMind:
EventedMind:
DiscoverMeteor: Read the Introduction chapter
DiscoverMeteor (This is optional): Read the Using Git & GitHub chapter
Chapter 1: Anatomy of a Typical Meteor Application
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 2: Reactive Programming and Meteor Frontend Framework
EventedMind:
EventedMind:
Meteor Manual:
(Read sections 1 to 4)
Meteor Manual:
Read sections 0 to 3. The sections are brief but illuminating
DiscoverMeteor: Read the Getting Started chapter
DiscoverMeteor: Read the Templates chapter
Chapter 3: Meteor Collections and Mimimongo
EventedMind:
EventedMind:
EventedMind:
DiscoverMeteor: Read the Collections chapter
DiscoverMeteor: Read the Latency Compensation chapter
Important Note: Don’t do the exercise yet. Don’t add the code from this chapter to your application yet. You will do that on day 5. Just read the chapter and study the code.
Chapter 4: Publications and Subscriptions
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Meteorhacks:
DiscoverMeteor: Read the Publications and Subscriptions chapter
Chapter 5: Routing In Depth (Using Iron Router)
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
DiscoverMeteor: Read the Routing chapter
Chapter 6: Meteor Reactivity In Depth
Meteor Manual:
Read sections 5, 6 and 7
DiscoverMeteor: Read the Reactivity chapter?
DiscoverMeteor: Read the The Session sidebar
Chapter 7: Introducing the Meteor Accounts Package
DiscoverMeteor: Read the Adding Users chapter
Chapter 8: Understand Meteor Methods
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 9: Advanced Routing and Advanced Subscriptions
EventedMind:
(In this section, you will learn how to use the iron tool to create views.)
EventedMind:
(In this section, you will learn how to use the iron tool to create routes.)
EventedMind:
EventedMind:
EventedMind:
DiscoverMeteor: Read the Creating Posts chapter
DiscoverMeteor: Read the Allow and Deny chapter
DiscoverMeteor: Add the code from the
Latency Compensation chapter (You already read this chapter on day 2, but you didn’t add the code then. So add it now.)
DiscoverMeteor: Read the Editing Posts chapter
DiscoverMeteor: Read the Errors chapter
Chapter 10: Meteor Packaging System and NPM
Meteor Hackpad Document:
(ignore the version number)
DiscoverMeteor: Read the Creating a Meteor Package chapter
Chapter 11: Using the Meteor MongoDB API
DiscoverMeteor: Read the following chapters:
Denormalization
Notifications
Meteor Security Overview
?: A Primer on Meteor Security
: Cross Site Scripting(XSS) and Meteor
Chapter 12: Complete the Social News Application
DiscoverMeteor: Read the following chapters:
Advanced Reactivity
Pagination
Advanced Publications
Animations
End of course ———————————–
Appendix A: Seven Meteor Techniques and Tips You Should Know
Make a note of the topics in this section so you can refer to them when the need arises.
Writing Async Code in Meteor
Implementing RESTful APIs in Meteor
Details on
For an detailed overview of various ways to implement a RESTful endpoint in Meteor,
Meteor Performance and Scaling
Monitor Your Meteor Applications
monitors your Meteor application for performance issues and it tracks errors.
Meteor Security
Cost of Resources (EventedMind): $18.85
A Comprehensive Study Guide for Learning Meteor Properly
Let’s get to work.
Introduction to Meteor for New Programmers
Before we begin the study guide, if you have never developed a web application before, read the free online book at the link below. This brief book,
Your First Meteor Application, gives you an elementary introduction to Meteor, with basic instructions on using the terminal and more. Be sure to come back and complete the entire road map after you finish the little book:
Introduction: Setup and Getting Started
EventedMind:
EventedMind:
EventedMind:
Chapter 1: Anatomy of a Typical Meteor Application
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 2: Reactive Programming and Meteor Frontend Framework
EventedMind:
EventedMind:
Meteor Manual:
(Read sections 1 to 4)
Meteor Manual:
Read sections 0 to 3. The sections are brief but illuminating
Chapter 3: Meteor Collections and Mimimongo
EventedMind:
EventedMind:
EventedMind:
Chapter 4: Publications and Subscriptions
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 5: Routing In Depth (Using Iron Router)
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 6: Meteor Reactivity In Depth
Meteor Manual:
Read sections 5, 6 and 7
Chapter 7: Introducing the Meteor Accounts Package
?Notice: The section on “Installing the necessary packages” is a bit dated, so install the packages using to the DiscoverMeteor instructions you learned earlier.
Chapter 8: Understand Meteor Methods
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 9: Advanced Routing and Advanced Subscriptions
EventedMind:
(In this section, you will learn how to use the iron tool to create views.)
EventedMind:
(In this section, you will learn how to use the iron tool to create routes.)
EventedMind:
EventedMind:
EventedMind:
EventedMind:
Chapter 10: Meteor Packaging System and NPM
Meteor Hackpad Document:
(ignore the version number)
Chapter 11: Using the Meteor MongoDB API
Meteor Security Overview
?: A Primer on Meteor Security
: Cross Site Scripting(XSS) and Meteor
Important Notice About MongoDB
At this point, you will definitely need my book,
, to help you build your own Meteor applications, since none of the noted resources, or any other book for that matter, cover MongoDB in depth for Meteor applications.
End of course ———————————–
Appendix A: Seven Meteor Techniques and Tips You Should Know
Make a note of the topics in this section so you can refer to them when the need arises.
Writing Async Code in Meteor
Implementing RESTful APIs in Meteor
Details on
For an detailed overview of various ways to implement a RESTful endpoint in Meteor,
Meteor Performance and Scaling
Monitor Your Meteor Applications
monitors your Meteor application for performance issues and it tracks errors.
Meteor Security
Share this:
Would you rather attend a community college (set to begin in days) because you are in a hurry to get started, or would you rather wait to attend a more prestigious school like MIT or Oxford, even though you will have to wait three months to begin?
No, we are not MIT or Oxford, but the comparison (i.e., our comprehensive and highly-rewarding program vs. the ones noted above and others available online and offline) is valid.
Note that I have posted this same comment on the new post for discussing our Career Paths and Courses. Here is the link:
Trackbacks for this post
Mailing List
Email Address :
Programmers, Bloggers, Writers, Write Well
Recent Posts
Most Popular Posts
Send to Email Address
Your Email Address
Post was not sent - check your email addresses!
Email check failed, please try again
Sorry, your blog cannot share posts by email.}