松本行弘的程序世界

8.4935 评价豆瓣读书
阅读
¥40.00
  • 导言
  • 目录
  • 作品信息

《松本行弘的程序世界》是探索程序设计思想和方法的经典之作。作者从全局的角度,利用大量的程序示例及图表,深刻阐述了Ruby编程语言的设计理念,并以独特的视角考察了与编程相关的各种技术。阅读《松本行弘的程序世界》不仅可以深入了解编程领域各个要素之间的关系,而且能够学到大师的思考方法。

《松本行弘的程序世界》面向各层次程序设计人员和编程爱好者,也可以供相关技术人员参考。

松本行弘 Ruby语言的发明人,在1993年发布了Ruby语言的第一个版本,以后一直从事Ruby的设计与开发。2011年加入著名SaaS厂商 Salesforce旗下PaaS公司Heroku,任首席Ruby架构师,致力于加快Ruby Core的开发。他还是NaCI及乐天技术研究所的研究员。著有Ruby in a Nutshell和The Ruby Programming Language 等书。他的博客地址http://www.rubyist.net/~matz/

  1. 版权声明
  2. 推荐序
  3. 中文版序
  4. 前言
  5. 第 1 章 我为什么开发Ruby
  6. 1.1 我为什么开发Ruby
  7. 1.1.1 编程语言的重要性
  8. 1.1.2 Ruby的原则
  9. 1.1.3 简洁性
  10. 1.1.4 扩展性
  11. 1.1.5 稳定性
  12. 1.1.6 一切皆因兴趣
  13. 第 2 章 面向对象
  14. 2.1 编程和面向对象的关系
  15. 2.1.1 颠倒的构造
  16. 2.1.2 主宰计算机的武器
  17. 2.1.3 怎样写程序
  18. 2.1.4 面向对象的编程方法
  19. 2.1.5 面向对象的难点
  20. 2.1.6 多态性
  21. 2.1.7 具体的程序
  22. 2.1.8 多态性的优点
  23. 2.2 数据抽象和继承
  24. 2.2.1 面向对象的历史
  25. 2.2.2 复杂性是面向对象的敌人
  26. 2.2.3 结构化编程
  27. 2.2.4 数据抽象化
  28. 2.2.5 雏形
  29. 2.2.6 找出相似的部分来继承
  30. 2.3 多重继承的缺点
  31. 2.3.1 为什么需要多重继承
  32. 2.3.2 多重继承和单一继承不可分离
  33. 2.3.3 goto语句和多重继承比较相似
  34. 2.3.4 解决多重继承的问题
  35. 2.3.5 静态语言和动态语言的区别
  36. 2.3.6 静态语言的特点
  37. 2.3.7 动态语言的特点
  38. 2.3.8 静态语言和动态语言的比较
  39. 2.3.9 继承的两种含义
  40. 2.3.10 接口的缺点
  41. 2.3.11 继承实现的方法
  42. 2.3.12 从多重继承变形而来的Mix-in
  43. 2.3.13 积极支持Mix-in的Ruby
  44. 2.4 两个误解
  45. 2.4.1 面向对象的编程
  46. 2.4.2 对象的模板 = 类
  47. 2.4.3 利用模块的手段=继承
  48. 2.4.4 多重继承不好吗
  49. 2.4.5 动态编程语言也需要多重继承
  50. 2.4.6 驯服多重继承的方法
  51. 2.4.7 Ruby中多重继承的实现方法
  52. 2.4.8 Java实现多重继承的方法
  53. 2.5 Duck Typing诞生之前
  54. 2.5.1 为什么需要类型
  55. 2.5.2 动态的类型是从Lisp中诞生的
  56. 2.5.3 动态类型在面向对象中发展起来了
  57. 2.5.4 动态类型和静态类型的邂逅
  58. 2.5.5 静态类型的优点
  59. 2.5.6 动态类型的优点
  60. 2.5.7 只关心行为的Duck Typing
  61. 2.5.8 避免明确的类型检查
  62. 2.5.9 克服动态类型的缺点
  63. 2.5.10 动态编程语言
  64. 2.6 元编程
  65. 2.6.1 元编程
  66. 2.6.2 反射
  67. 2.6.3 元编程的例子
  68. 2.6.4 使用反射功能
  69. 2.6.5 分布式Ruby的实现
  70. 2.6.6 数据库的应用
  71. 2.6.7 输出XML
  72. 2.6.8 元编程和小编程语言
  73. 2.6.9 声明的实现
  74. 2.6.10 上下文相关的实现
  75. 2.6.11 单位的实现
  76. 2.6.12 词汇的实现
  77. 2.6.13 层次数据的实现
  78. 2.6.14 适合DSL的语言,不适合DSL的语言
  79. 第 3 章 程序块
  80. 3.1 程序块的威力
  81. 3.1.1 把函数作为参数的高阶函数
  82. 3.1.2 C语言高阶函数的局限
  83. 3.1.3 可以保存外部环境的闭包
  84. 3.1.4 块的两种使用方法
  85. 3.1.5 最终来看,块到底是什么
  86. 3.1.6 块在循环处理中的应用
  87. 3.1.7 内部迭代器和外部迭代器
  88. 3.1.8 在排序和比较大小中的应用
  89. 3.1.9 用块保证程序的后处理
  90. 3.1.10 用块实现新的控制结构
  91. 3.1.11 在回调中使用块
  92. 3.1.12 块处理的特别理由
  93. 3.2 用块作循环
  94. 3.2.1 块是处理的集合
  95. 3.2.2 块应用范围的扩展
  96. 3.2.3 高阶函数和块的本质一样
  97. 3.2.4 用 Enumerable 来利用块
  98. 3.2.5 Enumerable的局限
  99. 3.3 精通集合的使用
  100. 3.3.1 使用Ruby的数组
  101. 3.3.2 修改指定范围的元素内容
  102. 3.3.3 Ruby中的哈希处理
  103. 3.3.4 支持循环的Enumerable
  104. 3.3.5 用于循环的each方法
  105. 3.3.6 使用inject、zip和grep
  106. 3.3.7 用来指定条件的select方法
  107. 3.3.8 排序与比较大小的方法
  108. 3.3.9 在类中包含(include)Enumerable 模块
  109. 3.3.10 列表内包表达式和块的区别
  110. 第 4 章 设计模式
  111. 4.1 设计模式(1)
  112. 4.1.1 设计模式的价值和意义
  113. 4.1.2 设计模式是程序抽象化的延伸
  114. 4.1.3 Ruby中的设计模式
  115. 4.1.4 Singleton模式
  116. 4.1.5 Proxy模式
  117. 4.1.6 Iterator模式
  118. 4.1.7 外部与内部,哪一个更好
  119. 4.1.8 内部迭代器的缺陷
  120. 4.1.9 外部迭代器的缺陷
  121. 4.2 设计模式(2)
  122. 4.2.1 模式与动态语言的关系
  123. 4.2.2 重复使用既存对象的Prototype模式
  124. 4.2.3 亲身体验Io语言
  125. 4.2.4 Ruby中的原型
  126. 4.2.5 编写抽象算法的Template Method模式
  127. 4.2.6 用Ruby来尝试Template Method
  128. 4.2.7 动态语言与Template Method模式
  129. 4.2.8 避免高度依赖性的Observer模式
  130. 4.2.9 Observable模块
  131. 4.2.10 Observer模式与动态语言
  132. 4.3 设计模式(3)
  133. 4.3.1 软件开发的悲剧
  134. 4.3.2 开放—封闭原则
  135. 4.3.3 面向对象的情况
  136. 4.3.4 非面向对象的情况
  137. 4.3.5 OCP与Template Method模式
  138. 4.3.6 Observer模式
  139. 4.3.7 使用Strategy模式
  140. 4.3.8 Strategy模式与OCP
  141. 第5章 Ajax
  142. 5.1 Ajax 和 JavaScript(前篇)
  143. 5.1.1 通信及异步页面更新
  144. 5.1.2 技术要素之一:JavaScript
  145. 5.1.3 技术要素之二:XML
  146. 5.1.4 XML以外的数据表现形式
  147. 5.1.5 技术要素之三:DHTML
  148. 5.1.6 JavaScript技术基础
  149. 5.1.7 原型模式的面向对象编程语言
  150. 5.1.8 使用prototype.js库
  151. 5.1.9 prototype.js的功能
  152. 5.2 Ajax 和 JavaScript(后篇)
  153. 5.2.1 巧妙使用DHTML
  154. 5.2.2 获取document节点
  155. 5.2.3 获取和更新标签数据
  156. 5.2.4 设定事件处理程序
  157. 5.2.5 追加标签节点
  158. 5.2.6 本地HTML应用
  159. 5.2.7 和服务器间的通信
  160. 5.2.8 使用Prototype.js的优点
  161. 5.2.9 在服务器上保存数据
  162. 5.2.10 Web应用的脆弱性
  163. 5.2.11 使用JavaScript的感觉
  164. 第 6 章 Ruby on Rails
  165. 6.1 MVC 和 Ruby on Rails
  166. 6.1.1 模型、视图和控制的作用
  167. 6.1.2 用秒表的例子来学习MVC模式
  168. 6.1.3 生成视图和控制部分
  169. 6.1.4 GUI工具箱与MVC
  170. 6.1.5 同时使用工具箱和MVC
  171. 6.1.6 MVC的优缺点
  172. 6.1.7 Web应用中的MVC
  173. 6.2 开放类和猴子补丁
  174. 6.2.1 开放类
  175. 6.2.2 猴子补丁的目的
  176. 6.2.3 猴子补丁的技巧
  177. 6.2.4 灵活使用开放类的库
  178. 6.2.5 猴子补丁的几点问题
  179. 6.2.6 其他办法
  180. 6.2.7 Ruby on Rails和开放类
  181. 6.2.8 ActiveSupport带来的扩展
  182. 6.2.9 字节单位系列
  183. 6.2.10 复数形和序数
  184. 6.2.11 大规模开发和Ruby
  185. 6.2.12 信赖性模型
  186. 6.2.13 猴子补丁的未来
  187. 第 7 章 文字编码
  188. 7.1 文字编码的种类
  189. 7.1.1 早期的文字编码
  190. 7.1.2 纸带与文字表现
  191. 7.1.3 文字是什么
  192. 7.1.4 走向英语以外的语言(欧洲篇)
  193. 7.1.5 英语以外的语言(亚洲篇)
  194. 7.1.6 Unicode的问世
  195. 7.1.7 统一编码成 16 位的汉字统合
  196. 7.1.8 Unicode的两个问题
  197. 7.1.9 Unicode的文字集
  198. 7.1.10 文字表示的不确定性
  199. 7.1.11 Unicode的字符编码方式
  200. UTF-16
  201. 7.2 程序中的文字处理
  202. 7.2.1 文字编码有多个意思
  203. 7.2.2 只能处理文字集中包含的文字
  204. 7.2.3 纷繁复杂的文字编码方式
  205. 7.2.4 影响力渐微的Shift_JIS与EUC-JP
  206. 7.2.5 Unicode有多种字符编码方式
  207. 7.2.6 为什么会发生乱码
  208. 7.2.7 字符编码方式错误
  209. 7.2.8 没有字体
  210. 7.2.9 变换为内部码时出错
  211. 7.2.10 发生不完全变换
  212. 7.2.11 文字集的不同
  213. 7.2.12 字节顺序错误
  214. 7.2.13 从编程语言的角度处理文字
  215. 7.2.14 以变换为前提的UCS方式
  216. 7.2.15 原封不动处理的CSI方式
  217. 7.2.16 使用UTF-16 的Java
  218. 7.2.17 使用UTF-8 的Perl
  219. 7.2.18 用UTF-16 的Python
  220. 7.2.19 采用CSI方式的Ruby 1.8
  221. 7.2.20 强化了功能的Ruby 1.9
  222. 7.2.21 是UCS还是CSI
  223. 第 8 章 正则表达式
  224. 8.1 正则表达式基础
  225. 8.1.1 检索“像那样的东西”
  226. 8.1.2 正则表达式的语法
  227. 8.1.3 3 个陷阱
  228. 8.1.4 正则表达式对象
  229. 8.1.5 选项
  230. 8.1.6 正则表达式匹配的方法
  231. 8.1.7 特殊变量
  232. 8.1.8 字符串与正则表达式
  233. 8.1.9 split的本质
  234. 8.1.10 字符串的扫描
  235. 8.1.11 置换
  236. 8.2 正则表达式的应用实例与“鬼车”
  237. 8.2.1 解析日志文件的方法
  238. 8.2.2 避免使用$的方法
  239. 8.2.3 从邮件中取出日期的方法
  240. 8.2.4 典型拼写错误的检索方法
  241. 8.2.5 Ruby 1.9 的新功能“鬼车”
  242. 第 9 章 整数和浮点小数
  243. 9.1 深奥的整数世界
  244. 9.1.1 整数是有范围的
  245. 9.1.2 尝试位运算
  246. 9.1.3 操作特定的位
  247. 9.1.4 表示负数的办法
  248. 9.1.5 Ruby的整数
  249. 9.1.6 挑战公开密钥方式
  250. 9.2 扑朔迷离的浮点小数世界
  251. 9.2.1 计算机对小数的处理
  252. 9.2.2 固定小数点数不易使用
  253. 9.2.3 科学计数法也有问题
  254. 9.2.4 小数不能完全表示
  255. 9.2.5 有不能比较的时候
  256. 9.2.6 误差积累
  257. 9.2.7 不是数的特别“数”
  258. 9.2.8 计算误差有多种
  259. 9.2.9 误差导致的严重问题
  260. 9.2.10 BigDecimal是什么
  261. 9.2.11 能够表示分数的Rational类
  262. 第 10 章 高速执行和并行处理
  263. 10.1 让程序高速执行(前篇)
  264. 10.1.1 是不是越快越好
  265. 10.1.2 高速执行的乐趣与效率
  266. 10.1.3 以数据为基础作出判断
  267. 10.1.4 改善系统调用
  268. 10.1.5 数据可靠吗
  269. 10.1.6 只需改善瓶颈
  270. 10.1.7 profiler本身成了累赘
  271. 10.1.8 算法与数据结构
  272. 10.1.9 理解O记法
  273. 10.1.10 选择算法
  274. 10.1.11 调查算法的性能
  275. 10.1.12 高速执行的悲哀
  276. 10.1.13 性能优化的格言
  277. 10.2 让程序高速执行(后篇)
  278. 10.2.1 确认程序概要
  279. 10.2.2 发现瓶颈
  280. 10.2.3 使用更好的profiler
  281. 10.2.4 高速优化之一:削减对象
  282. 10.2.5 高速优化之二:利用立即值
  283. 10.2.6 高速优化之三:利用C语言
  284. 10.2.7 高速优化之四:采用合适的数据结构
  285. 10.2.8 全部以C语言计算
  286. 10.2.9 还存在其他技巧
  287. 10.3 并行编程
  288. 10.3.1 使用线程的理由
  289. 10.3.2 生成线程
  290. 10.3.3 线程的执行状态
  291. 10.3.5 信息共享所产生的问题
  292. 10.3.6 数据完整性的丧失
  293. 10.3.7 死锁
  294. 10.3.8 用锁来实现对资源的独占
  295. 10.3.9 二级互斥
  296. 10.3.10 用队列协调线程
  297. 10.3.11 锁模型与队列模型的比较
  298. 10.4 前景可期的并行编程技术,Actor
  299. 10.4.1 何谓Actor
  300. 10.4.2 操作Actor的 3 种处理系统
  301. 10.4.3 Erlang的程序
  302. 10.4.4 Pingpong处理的开始
  303. 10.4.5 启动pingpong程序
  304. 10.4.6 Erlang的错误处理
  305. 10.4.7 Erlang的使用场所
  306. 10.4.8 面向Ruby的库“Revactor”
  307. 10.4.9 Revactor的应用场合
  308. 10.4.10 另一个库Dramatis
  309. 第 11 章 程序安全性
  310. 11.1 程序的漏洞与攻击方法
  311. 11.1.1 4 种软件漏洞
  312. 11.1.2 因权限被窃取而成为重大问题
  313. 11.1.3 安全问题的根源
  314. 11.1.4 “守护神”引起的问题
  315. 11.1.5 多样化的攻击手段
  316. 11.1.6 缓冲区溢出
  317. 11.1.7 整数溢出
  318. 11.1.8 SQL注入
  319. 11.1.9 Shell注入
  320. 11.1.10 跨站点脚本攻击
  321. 11.1.11 跨站点伪造请求
  322. 11.1.12 社会工程
  323. 11.2 用异常进行错误处理
  324. 11.2.1 异常的历史
  325. 11.2.2 Java的受控异常
  326. 11.2.3 Icon的面向目标判断
  327. 11.2.4 Ruby的异常
  328. 11.2.5 异常发生
  329. 11.2.6 异常类
  330. 11.2.7 异常处理的设计方针
  331. 11.2.8 异常发生的设计原则
  332. 第 12 章 关于时间的处理
  333. 12.1 用程序处理时刻与时间
  334. 12.1.1 时差与时区
  335. 12.1.2 世界协调时间
  336. 12.1.3 夏令时(DST)
  337. 12.1.4 改历
  338. 12.1.5 日期与时间的类
  339. 12.1.6 2038 年问题
  340. 12.1.7 DateTime类
  341. 12.1.8 Time与DateTime的相互变换
  342. 第 13 章 关于数据的持久化
  343. 13.1 持久化数据的方法
  344. 13.1.1 保存文本
  345. 13.1.2 变换成文本的Marshal
  346. 13.1.3 使用Marshal模块
  347. 13.1.4 复制有两种方式
  348. 13.1.5 仔细看Marshal的格式
  349. 13.1.6 不能保存的 3 类对象
  350. 13.1.7 制作面向对象数据库
  351. 13.1.8 试用PStore
  352. 13.1.9 变换为文本的YAML
  353. 13.1.10 用YAML制作数据库
  354. 13.2 对象的保存
  355. 13.2.1 高速的Object Prevalence
  356. 13.2.2 Object Prevalence的问题点
  357. 13.2.3 使用Madeleine
  358. 13.2.4 访问时刻信息
  359. 13.2.5 让Madeleine更容易使用
  360. 13.2.6 Madeleine的实用例Instiki
  361. 13.3 关于 XML 的考察
  362. 13.3.1 XML的祖先是SGML
  363. 13.3.2 XML是树结构的数据表现
  364. 13.3.3 优点在于纯文本
  365. 13.3.4 缺点在于冗长
  366. 13.3.5 不适合重视效率的处理
  367. 13.3.6 适合于信息交换的格式
  368. 13.3.7 XML的解析
  369. 13.3.8 XML处理库REXML
  370. 13.3.9 XML的代替
  371. 第 14 章 函数式编程
  372. 14.1 新范型——函数式编程
  373. 14.1.1 具有多种函数式性质的Lisp
  374. 14.1.2 彻底的函数式编程语言Haskell
  375. 14.1.3 延迟计算:不必要的处理就不做
  376. 14.1.4 灵活的“静态多态性”类型系统
  377. 14.1.5 近代函数式语言之父OCaml
  378. 14.1.6 强于并行计算的Erlang
  379. 14.1.7 用Ruby进行函数式编程
  380. 14.1.8 用枚举器来实现延迟计算
  381. 14.2 自动生成代码
  382. 14.2.3 消除重复代码
  383. 14.2.4 代码生成的应用
  384. 14.2.5 代码生成的效果
  385. 14.2.6 编写代码生成器
  386. 14.2.7 也可以使用XML
  387. 14.2.8 在EJB中使用代码生成
  388. 14.3 内存管理与垃圾收集
  389. 14.3.1 内存管理的困难
  390. 14.3.2 垃圾收集亮相之前
  391. 14.3.3 评价垃圾收集的两个指标
  392. 14.3.4 垃圾收集算法
  393. 14.3.5 引用计数方式
  394. 14.3.6 标记和扫除方式
  395. 14.3.7 标记和紧缩方式
  396. 14.3.8 复制方式
  397. 14.3.9 多种多样的垃圾收集算法
  398. 14.3.10 分代垃圾收集
  399. 14.3.11 保守垃圾收集
  400. 14.3.12 增量垃圾收集
  401. 14.3.13 并行垃圾收集
  402. 14.3.14 位图标记
  403. 14.4 用 C 语言来扩展
  404. 14.4.1 开发与执行速度的取舍
  405. 14.4.2 扩展库
  406. 14.4.3 看例题学习扩展模块
  407. 14.4.4 QDBM函数
  408. 14.4.5 初始化对象
  409. 14.4.6 实现方法
  410. 14.4.7 关于垃圾收集的注意事项
  411. 14.4.8 其他的Ruby API
  412. 14.4.9 扩展库的编译
  413. 14.4.10 扩展库以外的工具
  414. 14.5 为什么要开源
  415. 14.5.1 自由软件的思想
  416. 14.5.2 自由软件的历史
  417. 14.5.3 Emacs事件的发生
  418. 14.5.4 开源的诞生
  419. 14.5.5 OSS许可证
  420. 14.5.6 开源的背景
  421. 14.5.7 企业关注开源的理由
  422. 14.5.8 Ruby与开源
  423. 14.5.9 选择许可证的方法

作者〔日〕松本行弘

译者柳德燕李黎明夏倩张文旭

类别 图书 / 非虚构

出版社人民邮电出版社

出版日期

ISBN9787115255075

提供方图灵社区

标签计算机(1380)编程(372)程序设计(171)programming(3)ruby(1)松本行弘(2)

喜欢这本书的人也喜欢

来自豆瓣读书的评论31