rails编译
‘壹’ 为什么有同鞋学习 Ruby 之后学习 Go
我的个人经验就是，用java的时候，各种架构太复杂，IoC，EJB各种，之前做Java时候从来没自己成功上线过一个项目，因为部署也不简单。当Rails出现的时候，感觉看到了曙光，15分钟就上线Blog，太快了。写起来太舒服了。
但是后来，项目越写越大，动态脚本语言的缺陷就暴漏出来了，依赖编译都能排除的Bug，只能通过多写测试来确保了，测试越写越多，越运行越慢，小团队可以，但是有谁见过比如50人做一个Rails项目，当然能做，但是肯定会花费更多额外的精力。
那Go就是编译，并发模型支持，写起来也不像Java那么繁琐，但相对Ruby还是要繁琐点，性能比Ruby强，就是写的时候，只管写代码，实现了，性能基本过得去，但Ruby和Rails都不一样了。
另外虽然我觉得Ruby的gems挺好，但是我个人觉得Go的包管理更好，稳定的包直接就用，不稳定的Fork到自己的Github上，进行
hack，然后直接引用自己的包，当然Ruby也能这种方式，但是发布Gem，还是比较有一定的台阶的，不是Fork下来就能用这种。
安装依赖，也不用去维护个gemfile，因为依赖都在代码里，编译器保证了你的依赖在你的代码里调用过的，引用了没调用过的包，你编译都通不过。
‘贰’ vasp支持python 编译器么
vasp支持python 编译器
CSS
CSS权威指南
Eric Meyer的CSS权威指南至今仍然是CSS2讲解最全面和最深入的参考书
Javascript and jQuery
Web开发的交互性会越来越多，Javascript已经成为了相当严肃的编程语言
JavaScript权威指南
目前最全面最好的Javascript学习书籍
jQuery基础教程 （第4版）
唯一尚可称得上紧跟jQuery发展脚步的学习指南
Rails
‘叁’ 怎么构建Ruby的开发环境
安装Ruby
在Windows系统下，安装Ruby最简单的办法是使用RubyInstaller。如果是为了使用Ruby on Rails，则可以下载RailsInstaller并安装。这会安装Ruby和Rails等相关工具。在这里，我选择安装了Ruby 2.3 64位。安装过程很简单，在这里就不细数了。为了方便命令行使用，建议选中将Ruby可执行文件添加到PATH的选项。
安装完成之后，打了命令提示符。输入ruby -v查看是否安装成功。
安装Ruby DevKit
有时候可能需要安装一些本地C/C++编译的Ruby插件和开发工具。这时候就需要安装Ruby DevKit。安装方法也很简单，到Ruby下载页面，找到DEVELOPMENT KIT字样，然后下载和自己Ruby版本对应的开发工具包。这应该是一个压缩包，将其解压到合适的位置即可。然后在安装目录中打开命令提示符，依次运行下面的命令即可。
安装完成之后，再次安装这些需要本地编译的插件就不会失败了。
安装IDE
Ruby语言最好用的IDE还是Jetbrains的RubyMine。下载之后安装即可。具体的配置方法我就不说了，在极客学院这里有更详细的ntelliJ IDEA使用教程 ，对PHPStorm、RubyMine等Jetbrians系的其他软件也同样适用。
‘肆’ 如何快速正确的安装 Ruby，Rails 运行环境 · Ruby China
安装 Ruby，Rails 运行环境首先确定操作系统环境，不建议在 Windows 上面搞，所以你需要用: Mac OS X 任意 Linux 发行版本(Ubuntu,CentOS, Redhat, ArchLinux ...) 强烈新手使用 Ubuntu 省掉不必要的麻烦！ 以下代码区域，带有 $ 打头的表示需要在控制台（终端）下面执行（不包括 $ 符号）步骤0 － 安装系统需要的包# For Mac # 先安装 [Xcode] 开发工具，它将帮你安装好 Unix 环境需要的开发包# 然后安装 [Homebrew]
$ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
OS X 安装 Rails 必要的一些三方库
$ brew install libxml2 libxslt libiconv
步骤1 － 安装 RVMRVM 是干什么的这里就不解释了，后面你将会慢慢搞明白。
$ gpg --keyserver hkp://keys.gnupg.net --recv-keys $ curl -sSL https://get.rvm.io | bash -s stable
# 如果上面的连接失败，可以尝试:
$ curl -L https://raw.githubusercontent.com/wayneeseguin/rvm/master/binscripts/rvm-installer | bash -s stable
期间可能会问你 sudo 管理员密码，以及自动通过 Homebrew 安装依赖包，等待一段时间后就可以成功安装好 RVM。然后，载入 RVM 环境（新开 Termal 就不用这么做了，会自动重新载入的）$ source ~/.rvm/scripts/rvm修改 RVM 下载 Ruby 的源，到 Ruby China 的镜像:
echo "ruby_url=https://cache.ruby-china.org/pub/ruby" > ~/.rvm/user/db
检查一下是否安装正确
$ rvm -vrvm 1.22.17 (stable) by Wayne E. Seguin <[email protected]>, Michal Papis <[email protected]> [https://rvm.io/]
步骤2 － 用 RVM 安装 Ruby 环境$ rvm requirements$ rvm install 2.3.0同样继续等待漫长的下载，编译过程，完成以后，Ruby, Ruby Gems 就安装好了。步骤3 － 设置 Ruby 版本RVM 装好以后，需要执行下面的命令将指定版本的 Ruby 设置为系统默认版本$ rvm use 2.3.0 --default同样，也可以用其他版本号，前提是你有用 rvm install 安装过那个版本这个时候你可以测试是否正确
$ ruby -vruby 2.3.0 ...$ gem -v2.1.6$ gem sources --add https://gems.ruby-china.org/ --remove https://rubygems.org/
安装 Bundler$ gem install bundler步骤4 － 安装 Rails 环境上面 3 个步骤过后，Ruby 环境就安装好了，接下来安装 Rails$ gem install rails然后测试安装是否正确$ rails -vRails 4.2.5然后开始你的 Ruby，Rails 之旅吧。 欢迎来到 Ruby 的世界！
‘伍’ Spring，Django，Rails，Express框架用哪些方面
首先从DRY原则开始说起
Don't Repeat Yourself，不要重复你的代码。
DRY原则的重要性怎么提都不过分，很多人说编程是种机械性的工作，而有很多程序员也自嘲为码农，意为编程成了一种没有技术含量的体力性工作。如果不想沦为这个境界，首先需要的就是将DRY原则融入你的血液，在今后的编码工作中加以运用。可以加我扣一六二二中间四七九最近四三五分享免费资料视频
1）最初级的DRY：语法级别
System.out.println(1); System.out.println(2); …… System.out.println(10);
我想只要学过基础语法，都会采用下面的形式。
for (int i = 1; i <= 10; i++) { System.out.println(i); }
如果发现有任何人采用上面一种形式的编码形式，那么不用怀疑，他对于编程绝对还没有入门。
我们当然会选择省力的做法，这种做法不但省力，还会有利于我们后续修改或扩展这组代码，如：
for (int i = 1; i <= 10; i++) { System.out.println(i * 2 + 1); }
我们进行这样的修改，只需要修改一处，而上面的形式却需要修改10处，当然会更麻烦且更容易出错，所以请记住能不重复就不重复。
2）进阶的DRY原则：方法级别
当我们经常写一些重复性代码时，我们就要注意看能否将其抽取出来成为一个方法，如：
try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
让我们将其抽取到一个方法 threadSleep() 中，这样我们只需要调用 threadSleep() 就可以实现原来的功能，不但所需敲击的代码更少，而且代码看起来更加清楚明白。而为了增加这个方法的复用性，我们还可以将其中固定的数字抽取成为参数，如：
private static void threadSleep(int millis) { try { Thread.sleep(millis); } catch (InterruptedException e) { e.printStackTrace(); } }
这样我们就可以利用这个方法实现不同时间的sleep了。要注意提高代码的复用性也是实践DRY原则的一个重要方法，在后面我们也可以看到框架为了提高所谓的灵活性进行的一些设计，如在适当的位置增加扩展点。
3）继续进阶的DRY原则：类型级别
现在我们看一个类
public class Person { private String name; private int age; // Setter & Getter ... }
我们新建一些Person类实例，并进行一些操作：
Person person = new Person(); person.setName("jack"); person.setAge(18); Person person2 = new Person(); person2.setName("rose"); person2.setAge(17); ..... System.out.printf("Name: %s, Age:%d\n", person.getName(), person.getAge()); System.out.printf("Name: %s, Age:%d\n", person2.getName(), person2.getAge()); .....
观察这些代码，其实有很大的DRY改造空间，首先可以添加一个构造方法
public Person(String name, int age) { this.name = name; this.age = age; }
其次，可以添加一个toString()方法
public String toString() { return String.format("Name: %s, Age: %d", name, age); }
这样的话，上面的代码就可以改成下面的形式。
Person person = new Person("jack", 18); Person person2 = new Person("rose", 17); ...... System.out.println(person.toString()); System.out.println(person2.toString()); ......
4）继续继续进阶的DRY原则：多个类组合级别
上面的代码我们其实还是有改善空间，就是利用容器类
List<Person> list = new ArrayList<>(); list.add(new Person("jack", 18)); list.add(new Person("rose", 17)); ...... list.forEach(p -> System.out.println(p));
这里利用JDK8的Stream API以及Lambda表达式输出，其实可以进一步简化为
list.forEach(System.out::println);
这里我们可以看到，基本上我们写代码只写有变化的代码，而尽量不写机械性重复性的代码，其实后面我们就会知道，这就叫专注于业务逻辑，所谓业务逻辑就是你这个项目中，与别的项目都不一样的地方，必须由你亲自去编写实现的部分。
其实容器类很大程度上也是为了帮助我们编写代码而被设计出来的，首先让我们不必为每一个对象起名字（省去了person,person2,...等变量），然后又为批量操作提供了可能性。像是这样一系列有用的类组合起来可以称之为类库。常用的类库有Commons-Lang包等，为我们提供了一大批实用方法，我之所以提到类库，也是因为框架其实也是一种特殊的类库，但是却与一般的类库有着本质的不同。
②
设计模式，更高层级的DRY应用
上面我讲到了DRY原则的几个层次，一般情况下大家也早就这样使用了，属于入门之后很容易自己就想到得一些层次。但是设计模式不一样，设计模式是经过长时间编码之后，经过系统性的总结所提出的针对某一类问题的最佳解决方案，又称之为最佳实践。
而在小规模的编码工作中，其实并不需要什么设计模式，只有大型程序才有设计模式发挥的空间，所以我们需要借助一些特定领域有足够规模的问题来了解一下设计模式存在的必要性。
1）连接数据库，进行一些操作，并安全释放数据库连接。
public static boolean updatePassword(String username, String password, String newpassword) { Connection conn = null; PreparedStatement stmt = null; ResultSet rs = null; boolean success = false; try { conn = beginTransaction(); stmt = conn.prepareStatement("select id, password from user where username = ?"); stmt.setString(1, username); rs = stmt.executeQuery(); if (rs.next()) { if (rs.getString("password").equals(password)) { PreparedStatement stmt2 = null; try { stmt2 = conn.prepareStatement("update user set password = ? where id = ?"); stmt2.setString(1, newpassword); stmt2.setLong(2, rs.getLong("id")); success = stmt2.executeUpdate() > 0; } finally { safeClose(stmt2); } } } commitTransaction(conn); return success; } catch (sqlException e) { rollbackTransaction(conn); throw new RuntimeException(e); } finally { safeClose(rs); safeClose(stmt); safeClose(conn); } }
上面是一个简单的数据库事务，虽然只有一个查询和一个更新，但是想要将其继续简化却并不容易，虽然其中有关于业务逻辑的部分只是少量几行代码，但是初始化，异常，提交，回滚操作让我们很难抽取出一个合适的方法来。虽然我们已经抽取出了 begin,commit,rollback,safeClose等方法，但是仍嫌繁琐。
我们发现之所以我们难以抽取方法，主要是因为流程，因为里面牵扯到流程控制，而流程控制一般是由我们程序员来控制的，所以也就必然需要我们手动编码来完成。难道真的就不能继续简化了吗？这就是需要设计模式的时候了。
2）应用设计模式“模板方法模式”
public static boolean updatePassword(String username, String password, String newpassword) { return connection(conn -> statement(conn, "select id, password from user where username = ?", stmt -> { stmt.setString(1, username); return resultSet(stmt, rs -> { if (rs.next()) { if (rs.getString("password").equals(password)) { long id = rs.getLong("id"); return statement(conn, "update user set password = ? where id = ?", stmt2 -> { stmt2.setString(1, newpassword); stmt2.setLong(2, id); return stmt2.executeUpdate() == 1; }); } } return false; }); })); }
可以看到，所有的conn,stmt,rs的开启和关闭，事务的提交和回滚都不用自己手动编写代码进行操作了，之所以可以达到这个效果，就是因为使用了模板方法设计模式，核心就是通过回调方法传递想对资源进行的操作，然后将控制权交给另一个方法，让这个方法掌握流程控制，然后适当的时候回调我们的代码（也就是我们自己写的业务逻辑相关的代码）。
这是需要额外写的几个方法
public interface ConnectionCallback<T> { T doConnection(Connection conn) throws SQLException; } public interface StatementCallback<T> { T doStatement(PreparedStatement stmt) throws SQLException; } public interface ResultSetCallback<T> { T doResultSet(ResultSet rs) throws SQLException; } public static <T> T connection(ConnectionCallback<T> callback) { Connection conn = null; T result = null; try { conn = beginTransaction(); result = callback.doConnection(conn); commitTransaction(conn); } catch (SQLException e) { rollbackTransaction(conn); throw new RuntimeException(e); } finally { safeClose(conn); } return result; } public static <T> T statement(Connection conn, String sql, StatementCallback<T> callback) throws SQLException { PreparedStatement stmt = null; T result = null; try { stmt = conn.prepareStatement(sql); result = callback.doStatement(stmt); } finally { safeClose(stmt); } return result; } public static <T> T resultSet(PreparedStatement stmt, ResultSetCallback<T> callback) throws SQLException { ResultSet rs = null; T result = null; try { rs = stmt.executeQuery(); result = callback.doResultSet(rs); } finally { safeClose(rs); } return result; }
你们可能会疑惑，这些代码加上我们写的业务逻辑的代码，比原来的代码还要长，有什么必要使用这个设计模式。这正是我前面已经指出的一个问题，那就是要你的程序规模足够大才有必要应用设计模式，试想如果你有上百个乃至上千个数据库操作方法需要写，那么是不是写这几个额外的方法，就不算什么了呢。
其实这正是DRY原则在更高层次上的应用，即结合设计模式来达到更高层次的代码复用效果，进而应用DRY原则。而想要在这个层次继续向上攀升，那就必须是结合众多设计模式以及一些高层架构设计，能够帮助我们实现这一目的的就是框架。
3）框架，是设计模式的集大成者，是DRY原则的最高应用
先让我们来看一下，使用框架会是什么样的一种体验？
这里以Hibernate + Spring声明式事务为例
@Transactional public boolean updatePassword(String username, String password, String newpassword) { User user = (User) session().createQuery("from User where username = :username") .setString("username", username) .uniqueResult(); if (user != null && user.getPassword().equals(password)) { user.setPassword(newpassword); return true; } return false; }
可以发现令人惊讶的简洁，而且代码逻辑异常清晰，完全不需要考虑conn,stmt,rs等资源的释放，以及事务的提交和回滚，但是这些事情其实框架已经默默的帮我们做到了。这才叫真正的专注于业务逻辑，尽最大可能的只写与业务逻辑有关的代码。
当然这些框架的效果虽然神奇，其实只要细细探究其内部原理，是完全可以理解并掌握的。
二、那么问题就来了，框架到底是什么？要不要学，怎么学？
上面我说过了，框架其实就是一个或一组特殊的类库，特殊在什么地方？特殊在控制权转移！
框架与一般类库不同的地方是，我们调用类库，而框架调用我们。也就是说框架掌握整个程序的控制权，我们必须一定程度上把程序流程的控制权交给框架，这样框架才能更好的帮助我们。
下面以JavaWeb开发为例再进行一些说明，并顺便简单介绍一下JavaWeb的一些脉络。
①静态网页时代
本来网站都是一个个静态HTML组成的，或许这些网页还是用Dreamweaver写的，但是这样的静态页面显然不能满足我们，很快我们就迎来了动态网页的时代。
②Servlet时代
如果熟悉HTTP协议的话，我们就知道其实访问网页的过程不过是一次TCP连接罢了。浏览器发起TCP连接到服务器，服务器接受请求，然后返回HTML代码作为响应。那么我们完全可以等到接受到请求之后，再动态生成HTML代码返回给客户端。
Servlet就是这么做的，其主要代码不过是利用out.write()一点一点的输出HTML代码罢了。当然我们可以在其中掺杂一点动态的东西，如返回当前的时间。
out.write("<!DOCTYPE html>\r\n"); out.write("<html>\r\n"); out.write("<head>\r\n"); out.write("<title>Index Page</title>\r\n"); out.write("</head>\r\n"); out.write("<body>\r\n"); out.write("Hello, " + new Date() + "\r\n"); out.write("</body>\r\n"); out.write("</html>\r\n");
③ JSP包打天下的时代
纯粹的Servlet很是丑陋，给前端程序员理解和修改这样的代码带来了很多困难。因此JSP技术被发明了出来，原理也不复杂，就是不直接写Servlet，而是先写好JSP文件，再由服务器将JSP文件编译成Servlet。而JSP中是以常见的HTML标签为主，这样前端程序员就能方便的修改这些代码了。
<!DOCTYPE html> <html> <head> <title>Index Page</title> </head> <body> Hello, <%=new Date()%> </body> </html>
PS：由只使用 Servlet到使用JSP，虽然是一个简单的变化，但这迎合了前后端专业分工的大趋势，让前段人员只需要懂得HTML/CSS/JavaScrip代码就可以开始工作，而不需要学习Servlet那枯燥无味的用法，因此借着JSP技术的东风，JavaWeb技术迅速的扩展开来了。
④ Servlet + JSP 时代
随着JSP技术的发展，用它写成的网站也越来越大，业务逻辑也越来越复杂。开发人员渐渐发现整个网站渐渐的再次变成了一团乱麻，不仅仅是JSP中夹杂了大量的Java代码，页面之间的耦合关系也越来越紧密。
即便是要修改一个简单的按钮文本，或者是引入一段静态的内容，也需要打开越来越庞大的JSP页面，艰难到找到需要修改的部分，有时还不仅仅是一处，这种修改是有很大的风险的，完全有可能引入新的错误。
这时候开发者渐渐意识到，仅仅使用JSP是不行的，JSP承担了太多的责任。这时人们又想起了Servlet，Servlet中主要使用Java代码，处理业务逻辑非常轻松。如果JSP只使用HTML代码，而将业务逻辑的代码转移到Servlet中，就可以大大的减轻JSP的负担，并且让前后端分工更加明确。
⑤MVC模式时代
在Servlet + JSP模式的基础上，Java阵营进一步发展出了一种适合JavaWeb应用的设计模式，MVC设计模式，即将程序分为显示层(Viewer），控制层(Controller)，模型层(Model)。如下图所示：
&amp;lt;img src=&quot;https://pic4.mg.com/_b.png&quot; data-rawwidth=&quot;744&quot; data-rawheight=&quot;325&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;744&quot; data-original=&quot;https://pic4.mg.com/_r.png&quot;&amp;gt;一次典型的访问是这样的流程：
一次典型的访问是这样的流程：
1. 用户输入网址或点击链接或提交表单，浏览器发起请求
2. --> 通过互联网，通过HTTP协议 -->
3. Tomcat接受到HTTP请求，生成HttpServletRequest对象，根据Web.xml的配置，调用开发者编写的HttpServlet，HttpServlet根据请求内容，调用JavaBean获取数据，JavaBean从数据库获取数据，返回HttpServlet，HttpServlet将数据转发给JSP，JSP负责将数据渲染为HTML，由Tomcat负责将HTML转化为HTTP响应，返回客户端。
4. --> 通过互联网，通过HTTP协议 -->
5. 客户端浏览器接收到HTTP响应，浏览器将HTML渲染为页面，并运行其中可能存在的Java进一步调整界面。
整个流程必须由开发者精确设计才能运作流畅，其中客户端HTML和Java属于前端设计，服务器运行的其他内容属于后端设计。虽然符合J2EE规范的Tomcat等应用服务器已经帮我们实现了最复杂的一块，即HTTP协议部分，还给我们提供了JSP这个模板引擎，以及自定义标签等手段。但是在控制层，在模型层，J2EE能给我们的帮助少之甚少。
就拿用户提交一个表单为例，而我们在Servlet中获取参数为例，虽然不用我们解析HTTP报文，应该已经是要谢天谢地了，但是我们要做的事情仍然很多，分析一下：
1. 客户端传过来的数据全是文本，而我们需要的是Java对象。
2. 凡是文本就有编码问题，而这需要前后端配合解决。
3. 客户端的输入是不可信的，我们必须校验参数的合法性。
4. 我们还必须将校验结果反馈给客户，并且最好不要让客户全部重新输入。
5. 我们往往不是只有一个参数需要，而是有几个甚至更多参数，要妥善的处理各种情况组合。
这些事情几乎全部都需要我们手动编码来完成，几乎每一个 Servlet 都充斥着这样的代码，设置编码，获取参数，校验参数，校验通不过返回错误信息，校验通过则进行业务处理。而更重要的是，获取参数仅仅是整个流程中的一小步，我们的Servlet中存在着大量的重复性，机械性代码，而处理业务逻辑的代码可能只有一两行。
‘陆’ 修改rails需要重启web服务器吗
就一句话
启动时加载后不变和启动后修改可以重新解析!!
下面是说明:
javaBean和Servlet需要事先编译好 因为web服务器只负责使用classes而不编译classes,然后在服务器启动的时候就加载,也就是说在服务器没有重启以前这些加载好了的classes是不会发生变化的,要让这些classes的改变生效的话只有重启服务器重新加载,其实也就是classes的更新了.
以上理解为要用新的就要重新加载!!
而jsp页面是由web服务器负责解析的,你每次改了jsp页面以后是要保存后刷新的,而刷新的作用就是告诉web服务器重新解析,只有在web服务器启动的时候才可以解析!!,但与是否重启服务器无关,因为就算你重启服务器,它解析jsp的方式也是那样,是实现好了的,不会改变!你只要用他解析jsp也就好了.
以上理解为要用新的只要重新解析!!
‘柒’ 关于Ruby
Ruby on Rails是一个用于编写网络应用程序的框架，它基于计算机软件语言Ruby，给程序开发人员提供强大的框架支持。Ruby on Rails包括两部分内容：Ruby语言和Rails框架。
什么是Ruby?
Ruby 语言是一种动态语言，它与Python、Smalltalk和Perl这3种编程语言有些类似。Ruby语言起源于日本，它的研发者是日本人松本行弘（Matsumoto Yukihiro）。松本行弘在1993年开始着手Ruby语言的研发工作，他开发Ruby语言的初衷是为了提高编程的效率。 1995年12月Matz推出了Ruby的第一个版本Ruby 0.95。
Ruby语言的主要特点如下。
1．纯的面向对象语言
在Ruby中，一切皆是对象。下面举一个例子来更直观地说明Ruby语言的这一特点。
在Java中，求一个数的绝对值的代码如下。
int c = Math.abs(-20);
而在Ruby语言中，一切皆是对象，也就是说“-20”这个数也是一个对象，因此，求一个数绝对值的Ruby代码形式如下。
c = -20.abs
这样的代码编写方式是不是更形象一些呢？
2．解释型脚本语言
Ruby 语言是解释型脚本语言，它既有脚本语言强大的字符串处理能力和正则表达式，又不失解释型语言的动态性。一方面，在最初设计Ruby语言时，Ruby的研发者松本行弘考虑到文字处理方面的需要，他借鉴了Perl语言在文字处理方面的成功经验。另一方面，松本行弘将Ruby语言设定为一种解释型语言，Ruby 的动态性使得由Ruby语言编写的程序不需要事先编译即可直接运行，这为程序的调试带来了方便。同时，这一特点可以实现开发过程中的快速反馈。
3．其他特点
（1）动态载入。可以在运行时候重定义自己，类也可以在运行时继承或取消继承。
（2）自动内存管理机制。
（3）多精度整数。
（4）迭代器和闭包。
（5）开源项目。有大量活跃的社区支持Ruby语言。
什么是Rails?
虽然Ruby语言有很多优点，但是一直以来，其流行的范围也仅限于日本。直到2004年，Ruby才逐渐被世界上其他地区的人们所认识，那么是什么让Ruby语言走向世界的呢？是Rails。
Rails 框架首次提出是在2004年7月，它的研发者是26岁的丹麦人David Heinemeier Hansson。不同于已有复杂的Web 开发框架， Rails是一个更符合实际需要而且更高效的Web开发框架。Rails结合了PHP体系的优点（快速开发）和Java体系的优点（程序规整），因此， Rails在其提出后不长的时间里就受到了业内广泛的关注。
Rails框架主要有如下的6大特点。
1．全栈式的MVC框架
Rails是一个全栈式的MVC框架，换句话说，通过Rails可以实现MVC模式中的各个层次，并使它们无缝地协同运转起来。
在实际开发一个MVC模式的Web应用项目时，如果使用Java开发，需要用到Struts（Model层）、Hibernate （Controller 层）和Spring（View层）3个框架，而且需要额外整合3个框架开发出的内容。而使用Ruby语言开发相同的项目时，只需要用到Rails框架就可以完成。
2．约定优于配置
为了说明各个对象之间的关联关系，一般的Web应用开发框架往往采用写入XML配置文件的方法。这种方式虽然可以解决一些问题，但是却带来了管理上的混乱。
Rails 对此的态度是约定优于配置，这意味着在Rails中不会出现XML配置文件。Rails使用Web应用多年来积累的各种常见约定（更具体地说是命名规则）来代替XML配置文件，而在Rails内部的映射与发现机制根据这些约定可以实现对象之间的关联。在第1章中，通过Rails的映射与发现机制实现了数据表与Ruby对象之间的关联。
3．更少的代码
使用约定来代替XML配置文件说明Rails本身完成了大量的底层工作，这意味着使用更少的代码来实现应用程序是极有可能的。此外，代码量的缩减也减小了出现bug的可能性，降低了维护程序和升级程序的难度。
4．生成器
Rails 使用的实时映射技术和元编程技术，免去了开发人员在开发过程中编写大量样板文件代码的烦恼。在少数需要使用样板文件代码的时候，开发人员可以通过 Rails内建的生成器脚本实时创建，而不再是通过手工编写。Rails的这个特点可以使开发人员更专注于系统的逻辑结构，而不必为一些琐碎的细节所烦扰。
5．零周转时间
对已有的Web应用系统进行修改后，其一般需要经过配置、编译、发布、重新设置、测试等一系列步骤才能投入使用，这明显浪费了许多时间。而使用Rails开发Web应用系统，可以通过浏览器即时查看程序运行结果，从而节约了大量的时间。
6．支架系统
Rails的支架系统可以自动为任何相关的数据库表创建一套包含标准CRUD操作和前台视图的系统。通过支架系统，开发人员可以方便快捷地操纵数据库中的数据表。此外，Rails也允许开发人员使用自己设计的代码或视图来替换自动生成的代码和视图。
目前，Rails的最新版本是2005年12月13日发布的v1.0.0。从RoR正式提出到v1.0.0的发布，RoR在一年多的时间里受到了业内人士的广泛关注。RoR受到广泛关注主要有如下两个原因：首先，RoR的开发效率高（部署容易）、功能丰富（支持Ajax等流行应用），有消息称对于相同的 Web开发项目，使用RoR开发比使用Java体系架构开发快5~10倍；此外，令人不可思议的高性能是其受到关注的另一个重要原因，根据CSDN上转载的新闻称使用RoR开发出来的项目性能，比基于Struts+Hibernate+Spring的Java应用还要高15%~20%。
RoR 当前遇到的主要问题是使用RoR搭建的大型商业应用还很少，究其原因可以概括为两点：第一，从开发能力的角度，RoR是一个基于Ruby语言的轻型Web 开发框架，很多开发者对其是否适合大型应用难以把握。第二，本身使用RoR开发的大型商业应用较少，使得后来者持观望态度。
综合分析来看，RoR的发展前景还是很光明的。RoR在短时间内取得了巨大的成就，它打破了Web开发领域的固有观念，方便快捷的开发方式使其被广泛接受。而事实上，现在已有几家跨国公司正在使用RoR开发自己的Web应用程序，并且有多家大型公司在考虑使用RoR进行Web应用开发。
‘捌’ asp.net（C#）做的网页编译完成后怎么打包
其实就是一项异步交互技术，可以做到局部刷新，增强用户体验效果，比如网络或GOOGLE中输入搜索词，下边就出来提示要搜索的内容，这就是AJAX技术实现的，还有GOOGLE地图，等等。
可以看一下下边的详述。
国内通常的读音为“阿贾克斯”和阿贾克斯足球队读音一样。Web应用的交互如Flickr, Backpack和Google在这方面已经有质的飞跃。这个术语源自描述从基于网页的Web应用到基于数据的应用的转换。在基于数据的应用中，用户需求的数据如联系人列表，可以从独立于实际网页的服务端取得并且可以被动态地写入网页中，给缓慢的Web应用体验着色使之像桌面应用一样。 虽然大部分开发人员在过去使用过XMLHttp或者使用Iframe来加载数据，但仅到现在我们才看到传统的开发人员和公司开始采用这些技术。就像新的编程语言或模型伴随着更多的痛苦，开发人员需要学习新的技巧及如何最好利用这些新技术。
AJAX模式
许多重要的技术和AJAX开发模式可以从现有的知识中获取。例如，在一个发送请求到服务端的应用中，必须包含请求顺序、优先级、超时响应、错误处理及回调，其中许多元素已经在Web服务中包含了，就像现在的SOA。AJAX开发人员拥有一个完整的系统架构知识。同时，随着技术的成熟还会有许多地方需要改进，特别是UI部分的易用性。
AJAX开发与传统的CS开发有很大的不同。这些不同引入了新的编程问题，最大的问题在于易用性。由于AJAX依赖浏览器的JavaScript和XML，浏览器的兼容性和支持的标准也变得和JavaScript的运行时性能一样重要了。这些问题中的大部分来源于浏览器、服务器和技术的组合，因此必须理解如何才能最好的使用这些技术。
综合各种变化的技术和强耦合的客户服务端环境，AJAX提出了一种新的开发方式。AJAX开发人员必须理解传统的MVC架构，这限制了应用层次之间的边界。同时，开发人员还需要考虑CS环境的外部和使用AJAX技术来重定型MVC边界。最重要的是，AJAX开发人员必须禁止以页面集合的方式来考虑Web应用而需要将其认为是单个页面。一旦UI设计与服务架构之间的范围被严格区分开来后，开发人员就需要更新和变化的技术集合了。
时刻想着用户
AJAX的最大机遇在于用户体验。在使应用更快响应和创新的过程中，定义Web应用的规则正在被重写;因此开发人员必须更注重用户。现在用户已经逐渐习惯如何使用Web应用了。例如用户通常希望每一次按钮点击会导致几秒的延迟和屏幕刷新，但AJAX正在打破这种长时间的状况。因此用户需要重新体验按钮点击的响应了。
可用性是AJAX令人激动的地方而且已经产生了几种新颖的技术。其中最引人注目的是一种称为“黄色隐出”的技术，他在数据更新之前时将用户界面变为黄色，更新完成后立刻恢复原来的颜色。AJAX开发人员将用户从Web应用的负载中解放出来;小心地利用AJAX提供的丰富接口，不久桌面开发人员会发现AJAX是他们的方向。
几种工具和技术
随着AJAX迅速地引人注目起来，我想开发人员对这种技术的期待也迅速地增加。就像任何新技术，AJAX的兴旺也需要一整个开发工具/编程语言及相关技术系统来支撑。
JavaScript
如名字所示AJAX的概念中最重要而最被忽视的是他也是一种JavaScript编程语言。JavaScript是一种粘合剂使AJAX应用的各部分集成在一起。在大部分时间，JavaScript通常被服务端开发人员认为是一种企业级应用不需要使用的东西应该尽力避免。这种观点来来自以前编写JavaScript代码的经历:繁杂而又易出错的语言。类似的，他也被认为将应用逻辑任意地散布在服务端和客户端中，这使得问题很难被发现而且代码很难重用。在AJAX中JavaScript主要被用来传递用户界面上的数据到服务端并返回结果。XMLHttpRequest对象用来响应通过HTTP传递的数据，一旦数据返回到客户端就可以立刻使用DOM将数据放到网面上。
XMLHttpRequest
XMLHttpRequest对象在大部分浏览器上已经实现而且拥有一个简单的接口允许数据从客户端传递到服务端，但并不会打断用户当前的操作。使用XMLHttpRequest传送的数据可以是任何格式，虽然从名字上建议是XML格式的数据。
开发人员应该已经熟悉了许多其他XML相关的技术。XPath可以访问XML文档中的数据，但理解XML DOM是必须的。类似的，XSLT是最简单而快速的从XML数据生成HTML或XML的方式。许多开发人员已经熟悉Xpath和XSLT，因此AJAX选择XML作为数据交换格式有意义的。XSLT可以被用在客户端和服务端，他能够减少大量的用JavaScript编写的应用逻辑。
CSS
为了正确的浏览AJAX应用，CSS是一种AJAX开发人员所需要的重要武器。CSS提供了从内容中分离应用样式和设计的机制。虽然CSS在AJAX应用中扮演至关重要的角色，但他也是构建创建跨浏览器应用的一大阻碍，因为不同的浏览器厂商支持各种不同的CSS级别。
服务器端
但不像在客户端，在服务端AJAX应用还是使用建立在如Java,.Net和PHP语言基础上机制;并没有改变这个领域中的主要方式。
既然如此，我们对Ruby o n Rails框架的兴趣也就迅速增加了。在一年多前，Ruby o n Rails已经吸引了大量开发人员基于其强大功能来构建Web和AJAX应用。虽然目前还有很多快速应用开发工具存在，Ruby o n Rails看起来已经储备了简化构建AJAX应用的能力。
开发工具
在实际构建AJAX应用中，你需要的不只是文本编辑器。既然是JavaScript非编译的，他可以容易地编写和运行在浏览器中;然而，许多工具提供了有用的扩展如语法高亮和智能完成。
不同的IDE提供了对JavaScript支持的不同等级。来自JetBrains的IntelliJ IDEA是一个用来JavaScript开发的更好的IDE，虽然许多开发人员也喜欢Microsoft’s Visual Studio产品(允诺会在最新的版本中改善对AJAX的支持)。Eclipse包含了两个免费的JavaScript编辑器插件和一个商业的来自ActiveStat的Komodo IDE。
另一个JavaScript和AJAX开发中的问题是调试困难。不同的浏览器提供不同的通常是隐藏的运行时错误信息，而JavaScript的缺陷如双重变量赋值(通常是由于缺少数据类型)使得调试更加困难。在AJAX的开发中，调试就更复杂了，因为其需要标识究竟是客户端还是服务端产生的错误。在过去，JavaScript调试的方法是删除所有代码然后一行行的增加直到错误出现。现在，更多开发人员回到为IE准备的Microsoft Script Debugger和为Mozilla浏览器准备的Venkman。
浏览器兼容性
JavaScript编程的最大问题来自不同的浏览器对各种技术和标准的支持。构建一个运行在不同浏览器(如IE和火狐)是一个困难的任务。因此几种AJAX JavaScript框架或者生成基于服务端逻辑或标记库的JavaScript，或者提供符合跨浏览器AJAX开发的客户端JavaScript库。一些流行的框架包括:AJAX.Net, Backbase, Bitkraft, Django, DOJO, DWR, MochiKit, Prototype, Rico, Sajax, Sarissa, and Script.aculo.us.
这些框架给开发人员更多的空间使得他们不需要担心跨浏览器的问题。虽然这些框架提升了开发人员构建应用的能力，但由于厂商已经开发了更细节的用户界面的打包组件解决方案，因此在AJAX组件市场中需要考虑一些其他因素。例如提供通用用户界面的组件如组合框和数据栅格的几个厂商，都可以被用来在应用中创建良好的通过类似电子数据表方式来查看和编辑数据的体验。但这些组件不仅是封装了组件的用户界面而且包括与服务端数据的通讯方式，这些组件通常使用基于标记方式来实现如ASP.Net或JSF控件。
展望
最近IE和火狐之间的浏览器之争变得火热起来，因此AJAX开发人员需要足够敏捷的作出反应。关键点在一些问题如CSS或XML，虽然各种浏览器形成采用最新标准的不同阵营(如Mozilla拥抱SVG和E4X标准及在最新火狐BETA版本中使用XUL，而微软使用自己的XAML技术)。所有这些技术代表当前AJAX主流JavaScript和XML的市场方向改变。
总的来说，AJAX开发人员必须尽快地跟进最新的技术并利用高产的工具集。成功的AJAX开发人员还需要留心他们的使用者以避免将任何问题扩大化。并且AJAX开发人员还需要持续地创新来创建增强Web应用易用性的新方法。
‘玖’ rake db:migrate RAILS_ENV="proction"创建数据库的时候报错
上rubygems上下载