|
6、修改教案
被培训者根据自我分析和讨论评价中所指出的问题修改教案，准备进行再循环（再重复角色扮演）。如果采取单循环则可进入下一教学技能的学习或进入教学实习阶段。
我们可以借助我们的录像设备，来详细观察我们上看存在的问题，以做改进
我们可以从同组的人那得到反馈
可以从指导教师那里得到反馈
下面是微格教学的过程的示意图，我们现在只能从编写教案开始，无法为你们提供示范，但大家可以在这一些时间，可以有意识地去观察你认为讲课比较优秀的老师行为与技能，也许你可以从他们的身上找到示范与启事。
从上面我们可以看出微格教学与传统教学的有很多不同，所以教案的编写也有所不同。形式不一样，重点也不一样。
编写教案之前，首先应明确以下几个问题：
（1）学生学什么？即你想让学生在本课中学到什么知识，是事实、概念、技能、思想、观念，还是兼而有之。这些是通过对教学内容和学习任务的分析而得到明确的。并且能够知道这些知识的内在结构和逻辑关系。
（2）教学程序是什么？即根据对教学任务和课题的分析及所教班级学生的特点，明确教学的步骤和顺序，以及教学技能的基本程序。
（4）为了达到教学目标和更好地促进学生有效地参与到教学中来，选择什么样的教学方法和教学手段。（5）如何评价？即对教师的教学效果和对学生的学习结果评价的方法。
以上的四点是和普通教案同的：
下面是不同的地方：
（1）教学目标：表达要具体、确切，便于评价。
（2）教师的教学行为：按教学进程，写出讲授、提问、实验、举例等教师的活动内容。
（3）应用的教学技能：在教学过程中教师的某些行为可以归入某类教学技能，在其对应处注明。对重点训练技能应注明其构成要素。这样便于检查教师教学技能的训练成果，是训练教师对教学技能的识别、理解和应用能力的一项内容。
（4）学生行为：教师能估计到的学生在回忆、观察、回答问题时的预想行为。对学生行为的预先估计是教师在教学中能及时采取应变措施的基础。
(5）时间分配：教学中预计教师行为、学生行为持续的时间。
大概结构如下：
我国规定的教学的十大技能：(具体的内容大家要自己查找)
导入技能
教学语言技能
提问技能
讲解技能
变化技能
强化技能
演示技能
板书技能
结束技能
课堂组织技能
另外三个与之相关的网址：
http://www.qiexing.com/post/89.html
http://www.qiexing.com/post/207.html
http://www.qiexing.com/post/199.html
如何才能够更有效的学习这些内容？如何才能更好地适应以后社会发展的需要以及改变我们的学习方式？是我一直思考的问题，所以在这个学期我想和大家来一起寻找在当前特别是在网络环境下有效学习的途径，以更好地利用我们的网络资源与条件。
我准备的要做的事情有下面几方面：
第一，让学生熟悉网络环境 下的一些与学习相关的工具及利用，努力培养利用网络学习的习惯。
第二，为学习者提供优秀的学习资源，并能跟踪这些资源被利用的情况以及学生的学习过程。(困难)
第三，尝试利用电子档案袋的思想改进教学。电子档案袋被看作发展性评价的重要手段，评价的过程也是教学的过程。
阿尔伯特・爱因斯坦
（注：这是半个多世纪以前，一个具有高度智慧的老人，一个伟大的科学家在最后的日子里留给人类的宝贵的精神财富！是一篇不可多得的卓越的美文！）
我们这些总有一死的人的命运多么奇特！我们每个人在这个世界上都只作一个短暂的逗留目的何在，却无从知道！
尽管有时自以为对此若有所感。但是，不必深思，只要从日常生活就可以明白：人是为别人而生存的
首先是为那样一些人，我们的幸福全部依赖于他们的喜悦和健康；其次是为许多我们所不认识的人，他们的命运通过同情的纽带同我们密切结合在一起。
我每天上百次的提醒自己：我的精神生活和物质生活都是以别人（包括生者和死者）的劳动为基础的，我必须尽力以同样的分量来报偿我所领受了的和至今还在领受着的东西。
我强烈地向往着俭朴的生活。并且时常发觉自己占用了同胞的过多劳动而难以忍受。我认为阶级的区分是不合理的，它最后所凭借的是以强暴为根据。
我也相信，简单淳朴的生活，无论在身体上还是在精神上，对每个人都是有益的。
（注：感恩的心态）
我完全不相信人类会有那种在哲学意义上的自由。每一个人的行为不仅受着外界的强制，而且要适应内在的必然。
叔本华说："人虽然能够做他所想做的，但不能要他所想要的。"这句格言从我青年时代起就给了我真正的启示。在我自己和别人的生活面临困难的时候，这句格言总是使我们得到安慰，并且是宽容的持续不断的源泉。
由此带给我的体会可以宽大为怀地减轻那种容易使人气馁的责任感，也可以防止我们过于严肃地对待自己和别人；它导致一种特别给幽默以应有地位的人生观。
（注：宽容的品质）
要追究一个人自己或一切生物生存的意义或目的，从客观的观点看来，我总觉得是有些渺茫。
可是每个人都有一些理想，这些理想决定着他的努力和判断的方向。就在这个意义上，我从来不把安逸和享乐看作生活目的本身──我把这种伦理基础叫做猪栏的理想。
照亮我的道路，是善、美和真。要是没有志同道合者之间的亲切感情，要不是全神贯注于世界──那个在艺术和科学工作领域里永远达不到的对象，那么在我看来，生活就会是空虚的。
我总觉得，人们所努力追求的庸俗目标──财产、虚荣、奢侈的生活──都是可鄙的。
（注：追求真理的精神）
我有强烈的社会正义感和社会责任感，但我又明显地缺乏与别人和社会直接接触的要求，这两者总是形成古怪的对照。
我实在是一个"孤独的旅客"，我未曾全心全意地属于我的国家、我的家庭、我的朋友，甚至我最为接近的亲人；在所有这些关系面前，我总是感觉到一定距离而且需要保持孤独──而这种感受正与年俱增。
人们会清楚地发觉，同别人的相互了解和协调一致是有限度的，但这不值得惋惜。
无疑，这样的"孤独的旅客"在某种程度上会失去他的天真无邪和无忧无虑的心境；但另一方面，他却能够在很大程度上不为别人的意见、习惯和判断所左右，并且能够避免那种把他内心的平衡建立在这样一些不可靠的基础之上的诱惑。
（注：自我内心的剖析）
我的政治理想是民主政体。让每一个人都作为个人而受到尊重，而不让任何人成为被崇拜的偶像。
我自己一直受到同代人的过分的赞扬和尊敬，这不是由于我自己的过错，也不是由于我自己的功劳，而实在是一种命运的嘲弄。
其原因大概在于人们有一种愿望，想理解我以自已微薄的绵力，通过不断的斗争所获得的少数几个观念，而这种愿望有很多人却未能实现。
我完全明白，一个组织要实现它的目的，就必须有一个人去思考，去指挥、并且全面担负起责任来。但是被领导的人不应当受到强迫，他们必须能够选择自己的领袖。
在我看来，强迫的专制制度很快就会腐化堕落。因为强制所招引来的总是一些品德低劣的人，而且我相信，天才的暴君总是由无赖来继承的，这是一条千古不易的规律。
就是由于这个缘故，我总强烈地反对今天在意大利和俄国所见到的那种制度。
像欧洲今天所存在的情况，已使得民主形式受到怀疑，这不能归咎于民主原则本身，而是由于政府的不稳定和选举制度中与个人无关的特征。
我相信美国在这方面已经找到了正确的道路。他们选出了一个任期足够长的总统，他有充分的权力来真正履行他的职责。
另一方面，在德国政治制度中，为我所看重的是它为救济患病或贫困的人作出了可贵的广泛的规定。
（注：美国的强大、北欧富裕、西欧的文明以及苏联和东欧由于落后带来的解体和改革，证实了爱因斯坦当年的判断）
在人生的丰富多彩的表演中，我觉得真正可贵的，不是政治上的国家，而是有创造性的、有感情的个人，是人格；只有个人才能创造出高尚的和卓越的东西，而群众本身在思想上总是迟钝的，在感觉上也总是迟钝的。
（注：此段表达了爱因斯坦对追求真理所需要的素质――创造力的赞许）
讲到这里，我想起了群众生活中最坏的一种表现，那就是使我厌恶的军事制度。一个人能够洋洋得意的随着军乐队在四列纵队里行进，单凭这一点就足以使我对他鄙夷不屑。
他之所以长了一个大脑，只是出于误会！光是脊椎骨髓就可满足他的全部需要了。文明的这种罪恶的渊薮，应当尽快加以消灭。
任人支配的英雄主义、冷酷无情的暴行，以及在爱国主义名义下的一切可恶的胡闹，所有这些都使我深恶痛绝！
在我看来，战争是多么卑鄙、下流！我宁愿被千刀万剐，也不愿参与这种可憎的勾当。
（注：以上几段表达了爱因斯坦对战争强烈的厌恶）
尽管如此，我对人类的评价还是十分高的，我相信，要是人民的健康感情没有遭到那些通过学校和报纸而起作用的商业利益和政治利益的蓄意败坏，那么战争这个妖魔早就该绝迹了。
我们所能有的最美好的经验是奥秘的经验。它是坚守在真正艺术和真正科学发源地上的基本感情。
谁要体验不到它，谁要是不再有好奇心，也不再有惊讶的感觉，谁就无异于行尸走肉，他的眼睛便是模糊不清的。就是这样奥秘的经验──虽然掺杂着恐惧──产生了宗教。
我们认识到
有某种为我们所不能洞察的东西存在，
感觉到那种只能以其
最原始的形式接近人类心灵的
最深奥的理性和最灿烂的美
──正是这种认识和这种情感构成了真正的宗教感情；
在这个意义上，而且也只是在这个意义上，我才是一个具有深挚的宗教感情的人。
（ 注：产生宗教的渊源和构成宗教感情的基础）
我无法想象存在这样一个上帝，它会对自己的创造物加以赏罚，会具有我们在自己身上所体验到的那种意志。我不能也不愿去想象一个人在肉体死亡以后还会继续活着；让那些脆弱的灵魂，由于恐惧或者由于可笑的唯我论，去拿这种思想当宝贝吧！
（注：爱因斯坦心中的上帝不同于普通基督教徒的上帝）
我自己只求满足于生命永恒的奥秘，满足于觉察现存世界的神奇结构，窥见它的一鳞半爪，并且以诚挚的努力去领悟在自然界中显示出来的那个理性的一部分，倘若真能如此，即使只领悟其极小的一部分，我也就心满意足了。
早上，一同行MM问起RSS有没有前途这个事情，她认为RSS用的人不多，以后未必也有很大前途，在中国就更少了。我说了2个观点，一个是RSS现在少不代表未来少，二是当没人知道什么是RSS的时候，它就有前途了。
就像你去问现在的人知道HTTP是什么意思，估计大多数人都会摇头。因为我们根本不用去了解，只需要去知道打开浏览器敲网址，足矣。
正如我在读大学的时候，当着上百同学的面BS老师，我说，我根本不用了解什么叫二进制，CPU怎么做出来的关我P事，我又不是要去做硬件开发。当时老师很气愤，把我直接轰出课堂，不过这老师期末给我一个60分，不用补考，至今我仍很遗憾，大学竟然没补考。
Do you want a border around your image? Copy the code below. You can change the HEX code (#000000) to whatever colour you want. If you wanted a white border, you could change it to #FFFFFF. You can also change the width of the border, by changing 1px to 2px, 3px, and so on.
你希望为图像设置一个边框效果吗？请复制下面这段代码。你可以通过设置代表颜色的六位代码来为你的图像加上一个你喜欢的边框。如果你希望边框是白色的，那么你就把代码改成"#000000 "。你也可以改变边框的宽度，通过将"1px"改为" 2px"或"3px "等等。
| <img src="IMAGEURL.jpg" style="BORDER:1px SOLID #000000"> |
协作知识建构：教师博客群发展的新视角 |
编者按：这篇文章是目前中国大陆最实在的关于教育网志发展策略研究的文章，特此推荐给各位网友，供大家在 相关文章：《一项关于教师反思的研究报告》－－魏宁 |
| 教师博客（Blog）已经从一个个教师个体走向区域性的教师博客群，初步形成了教师学习-发展共同体。这些以学校、地区为单位的教师博客群在激发教师兴趣、提高反思意识与能力、促进教师间交流与协作等方面发挥了巨大的作用。 一、协作知识建构：教师博客群发展的新视角 二、教师博客群中协作知识建构的过程及原则 对于协作知识建构过程中各步骤的原则，国内外已有学者针对学习社区进行了研究。笔者参考我国学者甘永成给出的学习社区知识建构原则，细化了博客群中协作知识建构过程，在这个五步过程中，给出了相应的知识建构原则（表2）。 三、教师博客群发展中值得注意的几个问题 1.尽量减少"隐客"现象 2.博客群中的领导应该是"隐性领导"，专家应该是"平民化专家" 3.博客群中教师不应完全"匿名" 4."观点收敛"是博客群讨论中知识建构的关键
在博客群的交流、讨论中，虽然帖子的数量不少，但是不同教师的帖子之间缺乏观点的收敛，这也是目前博客群协作知识建构水平较低的重要原因。主要表现为在 博客的主帖（首帖）下面，其他教师的跟帖中大多都在陈述自己的观点，较少有教师参照前面的帖子进行归纳、总结。缺少"观点的聚合或收敛"，讨论过程可能是 散漫和没有明确方向的，没有围绕一个话题（主帖）展开，导致讨论没有任何结果。 笔者提出以下两种对策尝试解决这一问题： 笔者期待今后在更大的范围内、更先进的地区、用更多的数据进行针对博客群的研究，以发现更多有价值的信息。
参考文献 |
| 网络地址：www.being.org.cn/theory/ebcc.htm |
Blog 对学习系统的影响分析 |
|
| 摘要：本文从Blog对学习系统改变的分析，阐明了这种改变的必然性和意义。并展示了未来学习系统的可能图景。如传授者和传授知识的分离；学习主动性的本质提高；知识的传承性得到了更广泛的土壤等。 引言 对学习者的影响 对知识的影响 对传授者的影响 结语 参考文献 |
| 网络地址：www.being.org.cn/theory/blog-edu.htm |
Diigo 在初中英语教学中的应用（部分）
The Application of Diigo in Engish Instruction in Middle School
学 院 数理信息学院
年级专业 03级教育技术学（师范）
学生姓名 陈茜茜
完 成 日 期 2007 年 4 月
引言
你是否有过这样的经历，曾经看过很好的资料没有保存到你想用到他的时候却在网上再也找不到，或者正在做一个研究为找不到相关材料而烦恼。让我们进入DIIGO之旅，为你解决所有问题。
Diigo的全称为"Digest of Internet Information, Groups and Other stuff. "中文翻译就是"信息，组和其他的材料的互联网标注书签"。世界上著名的CNET(全球IT网站的风向标)杂志在2006年评出互联网10大"最受欢迎研 究工具"，Diigo排名第4
。那么DIIGO到底有什么用呢？，引用该网站上的一句话，The Diigo team is dedicated to provide innovative and useful web services for our users. 简而言之，DIIGO 致力于为使用者提供社会性的注释和有用的网站服务。
相信大家应该都用过书签，书签可以提醒你阅读的位置，可以为你保存精彩的内容。而diigo就像是一个网上的标注书 签，可以在diigo网站中保存你做过标记网页，同时也可以让你看到别人在网页中做的标记。而且可以建立组群体，大家一起讨论感兴趣的问题。可以说是传统 书签的一个升级。可以说他提供了一个网络书签服务,通俗的说就是一个放在网络上的海量收藏夹。互联网标注书签服务做为一种个人的信息整理平台, 基于它在网络上的这一独特的优势, 它能提供很多本地收藏夹所不能提供的功能。其核心价值经由保存浏览的网页, 发展成了一个新的信息共享的中心, 能够真正做到"共享中收藏、收藏中分享"。如果每日使用互联网标注书签的用户数量较大, 用户每日提供的链接收藏数量足够, 互联网标注书签网站就成了汇集各种新闻链接的门户网站。谈到diigo这个互联网标注书签网站，当然不得不提到他的发展平台，那就是现在炙手可热的 web2.0。
第二章 Diigo
2.1Diigo 简介
图一：www.diigo.com 官方网站主页
Diigo是可以在任何网页上做标记并且与他人分享的工具和网站Diigo的团体致力于为使用者提供网页注释和有用的网站服务。Diigo这个名词是信息，组和其他材料的互联网注释书签。
"diigo是美国一家网络技术公司最近开发出一项新技术，可使用户浏览网页时就像看书一样，标注出网页上的有用内容，并对网页内容发表评论。"不久前新华社报道diigo在短短4个月就迎来了数十万用户。
生于成都，曾在全球知名的加州大学伯克莱分校担任教授的任伟创立了diigo网站。"其实就是让互联网真正像图书一 样。"diigo董事长任伟说，现在下载Diigo客户端的数十万用户中，有相当一部分都是研究人员，你对网页的整理批注默认为共享，这样任何人都可以在 网站上找到他人整理好的现成互联网资料。
到现在为止，任伟对Diigo的投入只有100万元人民币，电子科技大学的一个学生团队也参与到网站的建设中去了，成都成为该网站的一个研发中心。中国和美国和美国两地的员工加起来只有16人。
虽然中国人对Diigo还比较陌生，但包括新华社、CNET等国内外知名媒体对这个新技术有大量报道。美国第一大 IT专业媒体CNET今年评出的互联网10大"最受欢迎研究工具"中，Diigo排名第4，google入选的四个工具（Google Scholar、Google Book、Google Earth、Google Home）都排在其后面，同时入选的还有微软、雅虎等巨头。2
其实Diigo最大的特色就是网页的在线标注功能，用CNET的话说，"如果在一个3000字的文章当中，你仅仅只 需要一句话，那么就能知道在网站上做记号是一件多么实用的事情"。虽然普通人上网可以选择收藏网页的链接，但是Diigo可以让网友注释某段文字，记录自 己针对某段话的一些想法，下次你再登录网页时，这些都可以显示出来。
2.2 Diigo 的特点
首先,diigo提供了最好的网上注释服务。这到底意味着什么呢？Diigo 让网络成为图书。网页在线标注功能，Diigo 可以让用户注释某段文字，记录自己针对某段话的一些想法，下次你再登录网页时，这些都可以显示出来。你可以在任何网页的任何地方添加高亮的重点标识以及粘 贴个人注释。与此同时，一旦你对这个网页添加了注释和高亮，那你可以永久地保存此网页，也就是说你可以在任何时候任何地方的网络计算机上看到你所做的高亮 标识和注释。或许你曾经做过的书签很漂亮也很多，但是他们或许你不经意间就有可丢失或者变旧了，但是diigo 作为新一代的网络书签将永久保存你的注释和高亮。所以特别适合那些工作中经常与大量的文献研究的人。当然，现代人崇尚简约的风格，或许可以让网络来帮你做 一些繁琐的事情，让你的生活和空间变得更加广阔。
其次，diigo拥有最强大的网页剪辑工具,更重要的是你所剪辑的内容还可以被共享和搜索。Diigo 不仅是一个很好的个人书签，而且是一个很好的网络共享和搜索平台。对网页的整理批注默认为共享，任何人都可以在网站上找到他人整理好的现成互联网资料。举 例：如果你最近在网上搜集整理关于白血病治疗的资料，利用 Diigo 就可以对现成的网页批注，把所有资料整理好后设成一个专题，其他用户在搜集类似话题时，可以在Diigo 找到这些资料，不用再慢慢搜集。
第三：强大的博客平台。任何你注释的网页都可以立即转变成博客发表。一旦你安装了diigo，你马上可以对你感兴趣 的内容通过右键可以立即将它以博客的形式发表，diigo 支持各种类型的博客，包括：WordPress blog,blogger blog, live journal blog, Typepad Blog, Movable Type Blog, Windows Live Spaces, Drupal Blog。同时，你既可以将他们发表在Diigo 自带的博客上，同时你也可以添加自己的博客，将你感兴趣的博客发表在你自己的博客上。
第四，综合性书签，可以集合本地文件夹，美味书签，simple , Furl, Spurl的综合功能，将你所关注的内容永久性地保存在diigo网站中附带有全文搜索功能。
第五：一个庞大的合作平台。利用高亮和网络注释的功能可以进行网上交流和共享。比如说，你准备做一个关于影响中学生 英语学习水平的调查研究，那你可以在diigo上注册成用户，将你搜索的材料添加到Diigo中，让其他的diigo用户可以共享到你搜集的资料，你也可 以分享其他人关于此调查研究的材料。甚至你可以建立一个组,专题讨论一个主题，然后邀请其他学者或者其他用户参与到你的研究中去。所谓众人拾柴火焰高，在 diigo中建立的组就像一个智囊团一样，定会为你的研究提供帮助。
第六： 最专用化的搜索工具和独特的内容搜索菜单。就像Google的工具库一样，但是更加专业化，只要轻松右键，你可以对音乐，地图，参考，本地图书馆，纽约时 报等进行相关搜索。只要轻松点击右键，Diigo包括对相关内容的博客搜索，全文搜索，网页搜索，diigo网站，baidu搜索，MSN搜索， Google搜索等等，可以所提供了一个全面的简便的搜索工具。他的搜索功能可以说是功能强大。可以对全文的题目，内容，关键字，也可以用不包含搜索，比 如我不想包含某关键字也可以进行搜索。
第七是Diigo 的组论坛功能，Diigo小组论坛允许使用者发起和参与到讨论中。一个组的管理人员可以根据预选好的种类制定组的标志或者允许组成员自定标志。后面一种方 法从潜在地给予用户更大的自由空间。使我们每个组更加独一无二，就像diigo 的许多特点一样独一无二。Diigo组的建立也是非常简单的，只要在Diigo的组中建立自己的组或者加入现在存在的组。当你参加了别人的组你可以在其中 看到组成员的书签等等。当然你也可以自己建立一个组，为自己的组在DIIGO中添加一个地址连接，分类自己的组，标识组的特点，而且你还可以很简单的通过 邮件邀请朋友加入到你的组中。
图二：diigo中建立的组
第八，diigo 提供了一个集合库，可以时时刻刻更新。
一个新的透明的工具在DIIGO库中可以被利用到。以前，一个被固定的纪录必须要高亮标识。而现在你可以直接加一个 流动的纪录标识而不需要有高亮标识它。你也可以随时移动你的纪录框也不一定要加高亮标识。只要简单地单击粘贴或右键菜单在你的工具栏上就可以拉。当然你也 可以像往常一样同时用高亮标识和记录框。
其实Diigo最大的特色就是网页的在线标注功能，用CNET的话说，"如果在一个3000字的文章当中，你仅仅只 需要一句话，那么就能知道在网站上做记号是一件多么实用的事情"。虽然普通人上网可以选择收藏网页的链接，但是Diigo可以让网友注释某段文字，记录自 己针对某段话的一些想法，下次你再登录网页时，这些都可以显示出来。通过集合社会书签，剪辑，加入适当的注释，标签，全文搜索，以及简单的共享和交互， diigo提供给我们一个有用的工具同时也给知识渊博的人一个丰富的社会交流平台。在整个过程中，是整个网站成为可以书写，参与和交互的媒体。
diigo提供的社会注释服务使使用者可以在任何的网页上添加高亮颜色和重点标识。想象一下一个巨大的透明的覆盖图 会出现在任何一个网页中。使用者可以以私人或公共的方式在网页中添加自己的东西。与此同时他们可以查看别的读者对于此网页的评论，聆听他人的心声并与他们 交换自己的意见和建议。
1.3 Diigo的安装和使用
非常简单，只要你登陆DIIGO 的官方网站www.diigo.com然后注册，到工具处马上会看到一个它的下载页面，你马上就可以下载安装，它只有2.65mb在你的电脑中占用极少的位置，对于网络的速度几乎没有影响，对系统的要求也不高，windows 2000或xp皆可。只要简单的安装你就可以开始你的DIIGO之旅。
只要你安装了这个软件，在你的浏览任何网页的时候只要右键你就可以对该网页进行DIIGO的高亮，高亮加注释以及相关网页，书签，博客，本站，相关内容等搜索。你可以非常方便地找到你所要的信息。
1.4 diggo与传统浏览，以及decilious 的比较
我们经常被问起我们的网站与传统浏览器有什么差别或是和其他社会书签网站的区别，比如说，delicious好吧， 最最明显的特点是diigo提供了高亮和注释的服务。当然还有其他的一些重要的特色使我们这要执著于diigo。我们许多使用者都相信diigo几乎是目 前为止最好的提供在线书签和注释服务网站。
下面就是DIIGO和传统书签，和Del.icio.us的区别比较图 。
表一
DIIGO
传统浏览
delicious
有高亮/注释/向前/博客功能
无
无
边浏览边注释：在浏览的同时可以高亮，扫描，在纪录框中添加注释。
被动的浏览：网页只能被浏览
无
方便编译高亮：你可以很简单地将高亮的内容编译成一个文件
不是很简单就可以拿出数据，只能通过复制粘贴完成。
无
相互影响和合作：网页上所带的特殊的纪录框，可以让你和阅读此页的人交流
独立：你只是浏览网页不能和别人交流，成为朋友
无
高亮和注释网页：让浏览者可以很容易注意到这些部分
不提供
无
和博客紧密联系：通过这个软件可以毫不费力地与博客相连
无
受限制
可以在任何时间到任何地方：无论你用什么浏览器在那里上网，diigo都会在网站保留你的书签。同时允许同时做几个书签并保存到当地文件中
受限制也没有备份
由此功能，但是不能备份到当地文件夹
搜索：名字，书签，高亮，笔记，全文搜索，用户都能搜索，并可以组合搜索
不提供全部搜索方式
不能全文搜索
私人化设置：你能决定要共享或是私人化
不能共享：你的书签保留在你的磁盘中
可以
标签 ：一个更好的组织信息和发现东西的方法。可以简单结合书签和标签
文件和子文件：很难找
可以
存档：真正将你觉得重要的网页保存，而不只是连接
不存档：你感兴趣的网页可能会没有
无
图片收藏
不能
无
简单地重新组织和编辑书签
重新编辑很复杂
受限制
未读标识
无
无
引进：
限制引进
限制
订阅：
无
可以
缓冲书签：如果暂时不能加入书签可以在本地存放，直到成功
无
无
团体：共享
单独发现
可以
其他特点：
1．书签表可以被添加和删减
1．搜索可以满足特殊要求
3.内容选择菜单让你可以随意搜索高亮
4．常规选项满足各种设置
无
无
通过上面的图表比较图，相信大家可以很清晰地看出Diigo 较之传统浏览方式和delicious 之间的优势所在。
1.5 diggo 在初中英语教学中的应用
2.5．1实验目的：
信息技术的发展总是在为我们的教育教学提供更多更方便的技术。Diigo就是其中的代表。DIIGO 作为一个信息，组和材料的网络标注是一个很好的工具,Diigo在教学中的使用正在国外兴起
http://diigo.com/。如果我们正确的应用和大力的发展，必将得到很好的发展。
Diigo在初中英语教学中的大力推广必将会为老师和学生的工作学习提供帮助,为此我们进行了一个试验。
试验地点：上海市嘉定区xx中学 试验对象八年级学生和老师
试验目的：论证diigo将会为中学英语教学工作提供帮助，创建一个很好的学习平台和氛围。
为了适应二期课改的精神，发展以学生为中心的教学模式，培养学生自主学习能力。老师在英语课程的备课中可以将课文的 放在diigo的站点中，将教学内容重点难点通过Diigo的在线标注功能，标注出来。让同学们可以在预习过程中，可以有针对性地预习，同时在复习过程中 也可以随时登陆网站，进行及时的预复习工作。更重要的是，在这个平台中学生可以与老师进行及时有效的沟通。学生可以在其中标注自己学习有困难的地方，老师 就可以在课堂或网络中进行重点分析。这样使教学更加有效和精彩。而且老师可以时刻更新自己的教案，丰富自己的教学。因为存在Diigo网站的材料可以永久 性地保存，即使一些同学对某一阶段的内容没有学好，同样可以在网上进行补习。与此同时，对于一些学有余力的同学，可以在网上自学到老师预先放的学习材料。 可以更加方便和有重点性地自学。
作为教师可以运用到diigo 这个软件找到与其课程相关的内容，可以丰富自己的知识，开阔自己的思想，并且可以将这些材料利用diigo的高亮和注释保留在DIIGo 的官方网站，方便下次使用。当然你也可以就此课题建立一个组，让别的老师以及学生加入你的组。所谓"众人拾柴火焰高"，让大家一起来讨论和参与到研究和学 习中，这样比单纯的一个人的研究要更加全面和准确。如果说以前要展开这样的一个讨论将会有许多的前提和准备工作。但是现在有了互联网有个diigo ，你可以轻轻松松做到这一切。在世界上不同角落的人在不同的时间都可以加入你的讨论中，而且diigo独有的一个公众化和私人化切换功能，即使你觉得自己 的想法不够成熟也各进行私人化的处理，等待自己的思想更加成熟以后再进行讨论和发言。
2.5.2教案设计
单元概览
单元标题
A famous person（一个名人）
框架问题
基本问题
What should we learn from the famous person？（一语双关，表示我们可以从名人身上学到什么，还有从这篇文章中学到什么？）
单元问题
1．怎样的人才算名人？
2．古往今来，名人的标准一样吗
3．我们应该如何看待名人？
4．我们还知道哪些名人？应该向名人学习什么？
5．假如你是名人，你会怎么做？
内容问题
1．What is Bill Gates dream?（比尔的梦想是什么？）
2．简单描述比尔？
3．你心目中的名人是谁？为什么？
单元概述
本单元我们将学习课文"一个著名的人"，通 过课文的学习让同学们了解，比尔盖兹的生平和精神，知道他的梦想和格言，同时鼓励同学学习他的钻研精神。学习比尔以后，我们户补充学习另外一些名人，比如 雷锋，海伦凯利，爱迪生，张海迪，通过学习他们的生平事迹和名人名言，让我们的同学可以掌握一些名人事迹的表达，同时可以从名人身上看到自己的不足，努力 向名人学习。
关键词
梦想：dream ,famous, proverb寓言
2.5.3实验过程：
初二年级X班英语课 地点：计算机机房 时间：四月
课前准备，由于现在信息技术发展全班2/3同学家中可以连接上互联网。老师在实验一周之前向同学介绍了diigo 这个软件，由于是全英文软件，老师对这个软件进行了一定的指导和讲解。老师在课前对diigo做了一定研究。要求每位同学以英语名加学号的方式在 diigo中注册一个用户名。
这是本文的第三课时，学生已经学习了关于一个名人，比尔的故事。课前让同学回家自己找一个名人介绍，写在diigo中，本课时的任务让同学在通过计算机一起学习更多名人的故事，和表达方式。
实验过程：利用现在多媒体的方式教学总是让学生感到又兴奋又激动。然而从前的教学学生所扮演的角色一直是多媒体信息 的接受者，但是这一次不同，学生成为了信息的主人。每个同学都希望在互联网上一展自己的风采。希望同学可以阅读自己的材料。在上课期间，我让同学先复习了 课文，因为我对重点地内容都进行了高亮的处理，学生很容易找到和掌握课文的重点。对于课文中的知识点的提问，同学们都能踊跃发言，反映很好。到了学习同学 们找的材料的时候，即使平时上课不能积极主动发言的同学都能举手发言。因为我想每个人都需要别人的认可和肯定，特别是学生。所以他们希望别人知道他是努力 的，是很棒的，所以他们在课堂中踊跃发言。整个课堂气氛活跃。我把一些名人的概要以几个提示次的形势展示在计算机中，学生都能较好地组织起语言，良好地表 达自我。有位老师说过只有让每位学生积极参与到其中的教学才是成功的教学。借助diigo的教学恰好做到了这点。而且根据人的记忆科学，眼，口，耳，手， 脑共同参与到其中效果最佳，学生最不容易遗忘。我把最后10分钟留给学生让他们在网上自由学习其他同学介绍的名人，名言和事迹。很多同学都在别人的作业中 留了标记，做了评语。我想这也许就是一场头脑风暴，因为学生在这里可以学的不只是一个名人名言，也不止听到老师一个人的评价。很多同学在课后还继续学习， 留言。
到了第二天，我的发现真是惊人，几乎所有的同学可以向我用英语描述二到三个名人。眼，口，耳，手，脑共同参与到学习中，对于英语这么语言的学习是很重要的。
图三：diigo中标有重点标识符和有标签的英语课文
2.5.4验结果：
从此次diigo参与的英语教学活动，大大提高了学生的英语学习热情。从英语学习的被动接受者变成了主动参与者和组织者。而且diigo的便捷的交流平台让学生老师之间有了更多的互动和沟通。通过这样一种共同学习的方式，达到自主体验，交流体会的目的。
2.5.5师和学生对于diigo的评价
学生1说：我想每天都这样上课，真有趣！
学生2说：感觉我自己就像小老师一样！
学生3说：这个东西就像是我在笔记本上作的重点号，好方便！
学生4说：如果老师可以将每节课的内容都放在diigo上，我对考试就更加有信心拉！
老师1：我在也不用收藏夹拉，在也不用担心保存的网页会找不到拉！
老师2：博客没时间写，有了diigo就方便多拉！
老师3：我是一个新老师。我已经在diigo中建立了一个叫sharing ，希望和各位老师一起分享教学中的经验和故事。
2.5.6IIGO 参与到教学中的意义及其功能：
第一：丰富教学模式，给学生创造了一个空中英语教室。
与传统的英语教学相比，diigo将课堂延伸到了课堂之外，使学生老师可以真真切切地感受到现代科技带来的便利和全 新的教学模式。新颖的事务总是能够引起学生的好奇心。学生借助diigo的教学不仅可使本身的课堂变得丰富多彩，而且在课后学生可以在任何地方任何时间进 行自主学习。比如说有的学生可能在课堂中较为羞涩不敢提问，可是在网络这个自由的空间中他们可以把自己的思想和问题提出来。这样给每个学生创造了另一空中 英语教室。熟能生巧，这样我们的学生不仅可以在课堂中学习英语而且可以在课后也参与到英语的学习中，英语作为一门语言，经过反复的操练，多种模式的学习和 体验，一定会让学生的英语水平突飞猛进。
第二： Diigo 提供给老师和学生一个新的交流平台。
目前，学校正在开展读书月的活动，我们可以建立一个图书分享的组。让同学和老师加入到组中，这样他们对于自己喜欢的 图书可以和他人一起分享，同时也可以写下自己的读书感想，标识自己觉得优秀的文章和段落。这样既可以发表的观点也可以节省阅读时间。同时，老师可以建立一 个blog或者DIIGO 组，与老师之间交流心得体验。与自己的学生也可以多沟通交流，让学生读懂老师也让老师聆听学生，这样我们的教学和工作将会更加顺利流畅。特别是刚刚参与教 学的新老师，可以利用这个工具更好地了解学生，了解教学。
第三：Diigo丰富教学，扩展教师学生知识面。
所谓众人拾柴火焰高。老师可以用diigo的搜索功能丰富和完善自己的教学。现在的diigo用户大多以一些研究人 员为主，将自己在教学中的困惑，知识上困惑放到Diigo中让大家群策群力为你出谋划策比起一个人苦思冥想，闭门造车要好得多。作为学生，就像我们的实验 中提到的一样，在diigo中因为大家可以看到很多的同学整理的关于名人的材料，而不是课本和老师补充的材料的学习，所以就像一次头脑的风暴一样。看到不 同人一个研究的观点，帮助学生正确树立自己的观点。对于研究工作者而言，diigo也不失为一个很好的交流和研究平台。
第四：diigo为现在流行的网络教学提供方便。
网络教育以其优越的特点在我们的信息社会中迅猛发展。Diigo作为一个很好地互联网标注软件和信息交流平台。如果 能够运用到网络教学中，那么它一定会成为受到同学和老师的欢迎和青睐。因为先阶段的网络教育发展虽然让学生可以不用上课堂在模拟课堂中或者是老师教案和教 学内容方到网络中共享，整个内容和形式还是老师教授为主。学生与老师的交流通过电话和电子邮件。对学生的学习反馈工作，还只是停留在老师对学生的作业和电 子邮件中。而利用diigo，老师可以随时指导学生对课堂的反应和反馈，可以及时调整教学。对于学生可以不仅与老师沟通，也可以与专家沟通，了解其他学生 的学习情况。让网络课堂，变得更加逼真和丰富。
第五：diigo提高教学的效率，从"启发式"教学到"互动式"教学。
前面提高到因为diigo独特的在线标注功能，老师可以方便的了解学生英语学习中的困惑和薄弱环节，可以有的放矢的 针对薄弱环节进行加强和训练，提高了教学的效率。所谓"启发式"教学的核心是调动学生的积极性、主动性，激发学生独立思考。但是，如果在教学中应用不当， 也容易出现仅仅是教师提问来启发学生回答的情况。在教学中，教师应引导学生自主学习和合作学习，实现学生与教师之间、学生与学生之间的广泛互动，使"启发 式"教学转变为"互动式"教学。老师在英语课程的备课中可以将课文的放在diigo的站点中，将教学内容重点难点通过Diigo的在线标注功能，标注出 来。让同学们可以在预习过程中，可以有针对性地预习，同时在复习过程中也可以随时登陆网站，进行及时的预复习工作。更重要的是，在这个平台中学生可以与老 师进行及时有效的沟通。因此，整个教学过程有了更多的互动，互动从课堂延伸到课后，到学习的每时每刻中。学生可以在其中标注自己学习有困难的地方，老师就 可以在课堂或网络中进行重点分析。这样使教学更加有效和精彩。而且老师可以时刻更新自己的教案，丰富自己的教学。因为存在Diigo网站的材料可以永久性 地保存，即使一些同学对某一阶段的内容没有学好，同样可以在网上进行补习。与此同时，对于一些学有余力的同学，可以在网上自学到老师预先放的学习材料。可 以更加方便和有重点性地自学。
第六：为学生自主性学习，提供引导。
根据二期课该的精神，注重学生自主性学习的培养。授之以鱼，不如授之以渔。如果将我们的拓展课，可以放在diigo 中建立一个个课题组，让学生利用diigo 卓越的搜索功能，自主找到相关内容。这样回到我们的课堂中，因为学生已经在网络中进行了一部分内容的学习，我们现实课堂的反应就会更加热烈，学生的学习热 情也会不断增强。同时网络是一把双面刃，学生很容易受一些观念和事务的误导，老师通过在diigo中可以了解学生的思想，可以加以正确的引导和及时地反 馈。
参考文献：
[1]www.diigo.com Diigo官方网站,2007年5月5日
[2]孙志国 ，《Web2.0, 以个人为中心的互联网时代的到来》，《农业网络信息》2005 年第12 期交流园地
[3]提姆奥莱理（Tim O'Reilly），翻译作者：玄伟剑，《什么是web2.0》，互联网周刊，2005年11月25日
[4]http://www.china-nurse.com/2006/12-8/39997.htm ,2007年4月20日
[5]孙茜，Web210 的含义、特征与应用研究，现代情报，2006 年2 月第2 期
[6]黎加厚,学习管理系统Moodle与新课程改革.ppt, 海盐讲座,2007年3月29日
[7] http://www.itedu.org.cn，2007年4月5日
[8] http://www.sh-xing.com/blog/article.asp?id=188 2007年5月8日
--------------------------------------------------------------------------------
2资料来源： http://www.china-nurse.com/2006/12-8/39997.htm
陈茜茜同学的联系e-mail： qianqianchen1919@yahoo.com.cn
这个是台湾邹景平老师设置的http://goldred.wikispaces.com/，有兴趣的朋友也可以去写。
在 07-5-10，孙方<szichuan@gmail.com> 写道：
> http://wikispaces.com
> 感觉使用起来很方便，但好象不支持中文，英语水平好的人可以试试
> ，因为我现在英语水平实在有限，不能使用英语写什么东西，就申请了一个，没有什内容，
>
http://qiexing.wikispaces.com/
>
> --
> 孙方敬上
> 且行 http://www.qiexing.com 提供你需要的资源
> 你只要点击这里http://www.feedsky.com/msub_wr.html?burl=qiexing
> 就可以通过邮件实时订阅我们的信息
> 你只要点击这里你就能参与我们的讨论： xy_98@googlegroups.com
> --~--~---------~--~----~------------~-------~--~----~
>
> 且行是试着去做的意思，我们希望能在这里可以把我们的一些想法变成现实，为了保证我们的专业性，论坛采用会员制,你可以向你的朋友发送邀请，转载的文章请注明出处。
> 使用且行论坛的几点建议：
> 1，讨论自己思考过的问题；
> 2，如果你喜欢用电子邮件，你可以使用邮件评阅这个论坛，而且可以向xy_98@googlegroups.com
> 发信就可以参与到论坛的讨论。（文档可以以附件形式传送），如果你喜欢WEB方式请访问：http://groups.google.com/group/xy_98
> 3，不要发广告及其它与主题无关的信息。
> 4，为了方便别人的联系，请你完善自己的资料，或者留下可以与你联系的通讯方式。
> 你有什么问题可以与：E-mail: szichuan@gmail.com QQ:379155084 联系。
> -~----------~----~----~----~------~----~------~--~---
>
>
北大社会学教授郑也夫，多年来采取一套非主流的教学法。他给上他的课的本科生布置作业：下去搞社会调查。调查的题目可以很细小，但必须是第一手的调查，然后根据调查结果写成报告，不准东抄西抄，人云亦云。
他 这个教学法，从在人大教书时开始，一直保持到他调到北大以后。大人学生的作业，已经精选成书出版，题为《都市的角落》，是他教的"城市社会学"的作业。后 来他开了"消费社会学"的课，学生的作业又被编成《消费的秘密》，不日也将出版。如今学术书籍出版困难，博士的书也难排上，几个本科生的东西哪个出版社愿 意出？结果，郑也夫用自己的名气和出版社讨价还价：你们想出我的书，就得出这些学生的书。而且要付学生钱。钱多少可以另当别论，但不付钱没有门儿！
书出来了。评价相当不错。国外一些社会学家也颇为赞许：深浅先不说，至少这一篇篇的小报告抓住了问题，为以后的研究开拓了思路。
回想一下前几年，我们斥资多少亿建设世界一流大学。钱烧了，房子盖了，博士课程上马了，但是大学教育还是没有改进。在这场喧嚣中，郑也夫的工作反而没有人注意。这恰恰说明了我们的教育改革是如何本末倒置。教育首先发生在课堂上。我们在创一流的过程中，有多少人提到了课堂？
不 久前《金融时报》的一篇文章中指出，随着中国大学的扩展，中国每年毕业的工程类本科生比美国多四倍，但绝大多数质量低劣。这些人中，只有十分之一能胜任跨 国公司"外包"到中国的工作。要知道，跨国公司一般把最尖端的技术留下国内。外包出来的工作，多属于低端的创造性不高的重复性工作。连这样的工作也才有十 分之一毕业生能适应，我们的高等教育在干什么？有着这样的高等教育，创新社会还从何谈起？
现在是反省过去几年高等教育改革的时候了。反省的开端，是问一个基本问题：我们投入了那么多钱，大学的课堂里究竟发生了什么变化？我们也必须带着这个问题，设想下一步的改革。
在 我看来，我们首先要改革的，是以考试为中心的满堂灌的教育方式。这一改革分两个方面。第一，课堂不仅是传授知识，而且要训练学生创造知识。理工科的大课之 外必须有实验室的工作。文科课程则应该设讨论班，把大课的班分成小班，由研究生主持围绕所学内容进行自由讨论。这样，学生有了参与"思想过程"的机会，研 究生获得了宝贵的教学经验，并领取一定的报酬，支持自己的学业。我自己的国外教书时，就反复对学生强调一点：你们在高中时，一天到晚考试，考试的目的是发 现"你不知道什么？"所以你们总要死记硬背。如今进了大学，我们更关心的是"你知道什么？"你要通过讨论把自己所知道的东西和所能贡献于世界的东西表达出 来。你毕业后找工作，别人雇佣你不是因为你记住了哪个皇帝哪年死的，而是你能提出你自己的看法，对你的雇主有用。大学就是要培养你这种能力。这也是讨论班 的意义所在。
第 二项改革，则是要求每个学生都要作研究。最近，一些美国的教授提出，要维持美国的创新力，必须要求每个大学生作研究。实际上，在美国一些好大学，你就会发 现许多学生参与由教授亲自主持的研究项目。到香港读书的一些大陆学生也有反映：在那里，学生常常要参加教授领头的研究团队，和大陆的大学教育形成鲜明的对 比。道理很简单，只有通过实际的研究，学生才能知道自己真正懂什么，不懂什么，能为社会提供什么，还有什么欠缺，体会到创造知识的艰辛。这样的过程，不仅 增加他们的创意，也刺激他们更有目标地学习新的东西，能够更好地适应现实世界。用我们的老话，就是在干中学，学中干。也只有这样，让我们头疼了几十年的所 谓"高分低能"的现象才能被克服。
所有这些，并不需要大笔的经费，需要的是许多象郑也夫这样的教授。大学的管理者们，应该把眼睛放在这些能够真正改变教学的人身上。
人物名片：吴晓蕾，2006年9月毕业于北京大学教育学院，获得教育技术专业硕士学位。2006年2月负责建立了 LanguageCalls国际语言培训公司北京学习中心（目前发展成LanguageCalls中国地区培训中心），现任LanguageCalls中 国地区培训中心销售支持和客户支持部门负责人。
一个尚在实习的北大女生独立负责在北京建立了一个国际培训机构的北京学习支持中心，并在北京中心两个月的运作之后，使得外国老板做出了将整 个机构运作中心从美国迁往北京的决定。故事听起来似乎颇具传奇色彩，然而当故事的主人公吴晓蕾的声音从电话另一头娓娓传来的时候，她的自信、她的智慧以及 她"从无到有"的创造力完全可以成为这个故事最好的注释。
"看到教育这个专业时，我很激动。"
吴晓蕾是那种对自己和对自己的目标有着非常清醒认识的人。
经过了四年的土木工程专业学习，本科毕业后吴晓蕾顺顺当当地在西安本地的设计业工作了近两年，然而她还是选择了来到北京、通过考研来改变自己的生 活，因为她了解自己，她知道自己所期望的生活方式。2003年9月她如愿走进了北大教育学院，攻读教育技术专业的硕士研究生。"从土木工程到教育技术的跨 度是很大的，很明显这是两个不同性质和类型的工作，两个领域对人的要求是不一样的，尤其是性格方面和心境方面。因为我的性格是属于需要和别人去交流，通过 交流产生价值，因此我觉得自己更适合做像教育一类的工作吧。"
喜欢与人交流的吴晓蕾似乎天生与教育这个领域有缘，"当时看到教育这个专业时，我是很激动的。"吴晓蕾毫不遮掩地用了"激动"这个词来形容自己当时 的感受，"可以说教育是在我们每个人身边都无所不在的，但通过学习教育，尤其是我选择的远程教育这个专业领域，你可以感受到一种新的思想带给人们生活的变 化。"
当时的中国已经出现了网络学习的方式，敏锐的吴晓蕾充分把握住了这一点，"我是很看好教育这个领域，自己也阅读了很多这方面的资料，觉得这个行业的 潜力是非常非常大的，而这个行业还有许多事情要做，这些事情又是和我的性格很符合的，就是需要与人交流。无论是实际去操作教育或者建立一种教育的体系、创 立一家教育公司都可以达到我当初的设想，所以我选择了教育。"
吴晓蕾现在的工作似乎已经证明了当初的选择是正确的。她把自己的性格、经历与一个有生命力的行业完美对接起来――从引进客户到为客户做支持，都是需 要通过交流来创造价值的工作，而设计方面的学习和工作经历培养的细节精神又成就了她对部门乃至机构所有架构体系的潜心设计和成功运作。
发现属于自己的潜在机会
由于自己一直对e-learing（数字化学习）行业非常有兴趣，读研期间吴晓蕾在一家在中国起步比较早的很不错的e-learning公司里实 习，"可以说当时实习的工资特别特别低，低到你难以想象，开始做得工作也是一些特别琐碎的工作，比如写写平台的说明书啊，但对我来说这些都不是那么重要， 我重视的是一种机会。"
吴晓蕾一开始就努力让自己在琐碎的工作中做个有心人，她一方面努力地做好自己的工作，哪怕是很基础很琐碎的工作，另一方面也注意培养自己和公司同事 们的人际关系，在她看来"只有让大家对你有一个很好的印象，才有机会去做一些更有价值的实习工作，也只有认真做每一件事情，你才能从中发现属于自己的机 会。"所以，尽管当时身边很多同学都认为这个公司没有多少吸引人的机会而劝她另作打算时，吴晓蕾一直坚持着，从一点一滴的工作和交流中发现属于自己的机 会，她的一句话意味深长："无论做什么事情，你都要很认真很投入地去做，而不要仅仅看到事情的本身。"
机会总是青睐有准备的人。一个很偶然的机会，LanguageCalls公司请吴晓蕾所在的这家公司开发软件平台，LanguageCalls 是在香港注册的一家由加拿大人Andrew和美国人Lloyd创办的语言培训公司，培训的语言涉及英语、法语、汉语等，教师遍布美国、英国、法国、新西 兰、澳大利亚等国家，它旨在为学习者提供和母语者在线的一对一交流的语言培训服务。在双方洽谈的期间，英语不错的吴晓蕾积极地去协助会谈，并主动和 LanguageCalls公司的加拿大籍的首席运营官和美国籍的首席技术官交流。吴晓蕾的能力和素质通过这次偶然的机会被她的老板发现，会谈之后，老板 当即决定让她来跟进这个项目，做项目经理助理。就这样，吴晓蕾从小小的实习生成了项目经理助理，而晓蕾说由于当时项目经理非常忙，所以她实际上做了项目经 理应该做的一切工作，说到这里，吴晓蕾谦逊地说："不是说我当时懂多少，什么都会做，而是我觉得我非常认真，每件事都用百分之百的精力去投入。"
项目结束之后，吴晓蕾就收到了LanguageCalls的邀请，他们计划在北京建立一个学习支持中心，想让吴晓蕾来负责这项工作。就这样， LanguageCalls从吴晓蕾的客户变成了她的雇主。刚刚还是一个小小实习生的吴晓蕾将要开始靠自己的力量在北京拉起这家国际教育培训机构的大旗 了。
小小实习生组建一个实体公司
正如古话所说的万事开头难，吴晓蕾在北京学习中心建立初期遇到的困难也许是她职业发展历程中曾遇到的最大的困难，"当时我要想的问题细到去哪里买办 公用具，去哪里租办公室，去哪里招人，如何招人，因为当时公司只是一个初始的形态，什么都没有，两个老板都是外国人，不懂中国的国情，也并不常在中国，等 于这边就剩我一个人，而我之前一点经验都没有，可以说一切都是从无到有。"然而对想成功的人来说，困难本身就是一种机遇和锻炼。一边忙着准备毕业论文，一 边为北京学习中心的建立筹划着、奔波着、忙碌着，吴晓蕾把自己充分调动起来，一切都是从做中学，从学中做，就好比摸着石头过河。
这段工作历程也许让吴晓蕾难忘终身，同样让她深有体会的是她意识到个人之外团队的力量，在创业的这段日子里总会有朋友、同事在自己的工作中给自己很 大的帮助，创立北京学习中心那段艰苦的时期里来自朋友的鼓励和建议也给了吴晓蕾很大的帮助，至今她还记得当时自己遇到困难时一位朋友的两句话："一句是 '你要有信心，肯定一年之后的你和现在不一样，因为你在做一件很有挑战性的事'，而当时一切的事都需要没有经验的我来做，因此这位朋友的第二句话就是'不 妨找团队和专业人士来帮你，可能会多花一点钱，但比你从头学起更有效。'"在朋友的建议下，吴晓蕾又学着用不多的资金来划分每一块开支，请专业人员的、装 修开支的、给兼职员工的工资等等，她学会了运用有限的人力和财力资源来发挥最大的效果，所有这些都是吴晓蕾从无到有一点点摸索来做的，一个小小实习生、在 校的学生一步步地学习如何组建一个实体的公司，尽管开始时脚步蹒跚，但吴晓蕾最终克服了重重从未经历过的困难之后走了过来，收获了初尝成功的喜悦之余也收 获了宝贵的经验和自信。
选择留下 选择不断挑战
在一路摸索和不断努力下，Languagecalls北京学习支持中心终于在2006年2月底建立了。吴晓蕾在自己的职业发展道路上迈出了成功的第一步。接下来，在北京中心运作了两个月之后，外国老板决定把运作中心从美国迁往北京，这样整个团队在北京有了一个中心。
当时的吴晓蕾是以实习生的身份来组织筹建北京中心的，"当外国老板提出让我建立中国地区的培训中心时，我想他对中国的情况不太了解，也没有什么社会 关系，就当是帮朋友吧，因为实际上我当时还有很多其他的机会，毕竟是北大同学总会有一些机会，而LanguageCalls当时在中国也仅仅开始起步，因 此当时只是单纯帮朋友，并没想到会真正到这里工作。"
也许是由于付出很多心血和努力创建起来的公司总是会让人有一种一旦结成就再也难以割舍的感情，当吴晓蕾临近毕业需要真正选择自己的职业时，她犹豫 了，自己手里有令同学们羡慕的大公司的入职邀请，而此刻的她通过一段时间在LanguageCalls的工作，也意识到这个领域的创意和前景都非常吸引自 己，"我自己从小受到的教育也决定了自己似乎不太适合做一个一成不变的工作，因此当面临很不错的offer时我还是最终选择了留在这里，因为我觉得这个工 作更有挑战性。"
一年多之后，北京中心的整个体系架构都已经比较完善了，谈到目前的发展，吴晓蕾显得很有信心："目前中心有来自11个国家40个正式员工，包括20 个外籍员工，而当时初建时只有2个正式员工。现在的服务范围涉及多个语种，主要是中文和英语，中文教师主要在国内，英文教师在加拿大、美国、英国、法国、 以色列、新西兰等国家。中国地区学习中心的客户已经有包括宝马、达能在内的多家公司客户，这些公司所有的语言培训项目都是由我们来做，还有一些企业的高层 管理者以个人身份来学，中国电信和网通也将作为我们的合作商。"
从北京学习中心的从无到有，到建立中国地区学习支持中心，喜欢不断接受新的挑战的吴晓蕾继续在创造着新的"从无到有"，随着业务的发展，中国地区学 习支持中心开始重新划分部门，吴晓蕾现在所在的销售支持和客户支持部门其实也是一个从无到有的建立过程。这一次吴晓蕾又站到了"从无到有"创新的前沿， "公司划分为教育、IT、人事等，随着有了固定的客户群之后又创立了销售支持和客户支持部门，包括销售前端引进的新客户如何为他们量身定做服务、提供24 小时全在线的服务等等一系列流程都必须规范化，这些都需要我来做，我把它从无到有建立起来了，而且现在运作得非常好，我可以很放心地离开办公室去开会、去 见客户，部门可以很好地运作，把客户维护好。"
谈到未来的希望，吴晓蕾信心十足地表示，她希望今后能不断去做一些更有挑战性、起点更高一些的事情。不断的挑战使得的她不断地走向成熟，同时也不断地走向新的成功。
保持平和心态 学会换位思考
回首自己走过的创业道路，吴晓蕾觉得自己能够克服很多困难，走到今天，有两个因素是很重要的，一个是心态，另一个是思考问题的方式。"自然而然地到 什么时候做什么事，保持一种坦然平和的心态很重要。"晓蕾说，"还有就是要学会站在别人的角度思考问题，比如做市场前端工作的人和做市场后端工作的人有时 候因为站的角度不同，很多想法会有冲突，这时候大家不妨换位思考，这样才能站得更高，对全局有所认识，在换位思考的同时听取别人的意见，这样才能形成客观 的认识和正确的决策，同时还可以形成良好的人际关系。"保持平和自然的心态和学会换位思考、经营良好的人际关系，这也是吴晓蕾对各位北大的在校同学的建 议。
尽管已经走出北大校门，吴晓蕾一直对北大、对北大的同学抱有很深的感情，她很真诚地说："我一直觉得能来北大自己是很幸运的。我想北大带给我的第一 就是知识，当时在学校抱怨甚至怀疑学的东西似乎没有什么用，但实际工作之后才发现这些东西不是没有用，也许不是直接使用自己学的东西，但是它对我们理解某 个行业提供了一个很好的知识基础，第二就是眼界，因为北大学生能看到的和能接触的东西很多，从而机会实际上是很多的。我很感谢北大给我的这些馈赠，我想它 们足以让我受用终身。"（文/吕媛）
原文作者：vipuser
原文链接：名词的尊严和利益
译者：维游
（这是一篇旧文，因为和翻译有点关系，推荐到译言大家读一下，有什么看法大家可以多多讨论 ！）
blog这个词很简单，就是weblog的简写，意思就是网络日记。但把blog翻译成中文是个麻烦事，你想得到在意义上"博客"，"部落格"与网络日记有什么联系吗？台湾用"部落格"，大陆用"博客"，那么我们一起用"网志"吧！是为了名词的主体性，还是尊严？也许这里只是一个习惯和先入为主的问题，但谁又能够否认其中透露除的一丝尊严问题呢？
还有一个是是Ring Back Tone，也就是电话接通后听到的不是嘟嘟声，而是语音或音乐信号。在北美通常叫做Private Ring Back Tone，在韩国称为Colorful Ring Back Tone，简称为CRBT。而有人把它翻译成中文叫"彩铃"，这个翻译很妙，可惜你不能随便使用，因为那是中国移动的注册商标，而中国联通要推行这项业务怎么办呢？苦思冥想，终于有了"炫铃"这个也很酷的名字。但是MMS在中国移动叫"彩信"，中国联通该叫什么呢？"彩e "！有没有感觉味道差很多。而这给用户带来的是什么呢？经常是混淆，你用联通的彩铃了没？虽然大家都知道什么意思，但是这种说法已经侵犯了中国移动的利益了。这是名词的利益问题。
而我总想到wiki，wiki该叫什么呢？好像越来越模糊，有人声嘶力竭地叫喊我是把wiki翻译成"维客"的第一人，好像名词翻译过来就属于他了。而维基百科集体智慧的维基，其他站点也该让他们用用，而网站页脚的"维基"，打上了（R）的标签，是否已经注册成为商标了呢？我没有去调查，但我不希望它已经是商标，因为维基并不等于维基百科。
当你没有背景知识，面对一个中文新词，想破脑袋也不知道它是什么意思，而当看到英文时一下子就明白时。你不会有点什么感想么？
名词虽然最终会随着时间流淌到一条大河里面，但一个词语的尊严和利益不免太过显露了人的自私和贪婪。
相关文章：
今天Google Reader发布消息称，因为很多人并不订阅Google Reader shared Item，所以Google把Gmail整合进Google Reader以方便用户通过发送电子邮件与朋友进行分享。
新功能具备如下特色：
通过Google Reader快速发邮件；
发送显示在Google Reader中显示的整条新闻，包括格式和图像；
使用Gmail邮件地址薄自动添加联系人。
以下是试用新功能的图片介绍：
转载:cnbeta
With Flash CS3 comes support for ActionScript 3.0 - the newest, standards-based programming language for Adobe Flash (SWF) movies and applications. More so than in the past, you may find it difficult to get started with ActionScript 3.0 compared to older versions of ActionScript. The transition from ActionScript 2 from ActionScript 1, for example, could probably be seen as a cakewalk compared to the leap to ActionScript 3.0, especially for someone who is prone to working and coding in the Flash IDE (Integrated Development Environment). This article will help acclimate you to working with ActionScript 3.0 within the Flash CS3 IDE.
Requirements:
Not using or don't have Flash CS3? Learn to use ActionScript 3 using the Free Flex 2 SDK with the Beginners Guide to Getting Started with ActionScript 3 (Without Learning Flex).
Early syntax of ActionScript 1 with Flash 3 was simple and verbose and functionality was based mainly around frame navigation and basic mouse interaction. This remained consistent until about Flash 5 where ActionScript assumed a form more similar to JavaScript. This provided a great deal more functionality and a "dot-syntax" for variable and method access. ActionScript also became a prototyped language allowing for simple OOP functionality similar to that available in JavaScript. This was enhanced in the following release of Flash, Flash MX (6).
Flash MX 2004 (7) introduced ActionScript 2.0. There were two major improvements that came with ActionScript 2: variable data typing and a new class syntax. The variable data typing that ActionScript 2 supported was strictly for compile-time debugging. What this meant was that any type you associated with a variable was stripped away from the code when you compiled or published your movie and was used to, at that point in time, check against discrepancies within your own code. If no conflict was found during the compilation process, your SWF would be created and the ActionScript inside would run without any understanding of the types you assigned to them in your original code. Though this provided no advantage to the Flash Player during playback, it did provide Flash authors a helpful tool for debugging larger, more complicated applications.
The new class syntax was used to define classes in ActionScript 2 similar to those defined for languages like Java. Though Flash still didn't really support classes beyond its own prototypes (in the end, ActionScript 2 gets compiled to ActionScript 1), this new syntax provided a familiar style that was helpful for people migrating from other languages and provided a more concrete way to organize class definitions within separate AS files and packages.
That brings us to Flash CS3 (9; not much happened with Flash 8) with ActionScript 3.0. Here we have a new ActionScript language that not only received a new version number but also a new virtual machine �C the underlying software within the Flash Player that executes ActionScript during playback. Both ActionScript 1 and ActionScript 2 use AVM1 (ActionScript Virtual Machine 1) as they are essentially the same in terms of needs for playback �C remember ActionScript 2 mostly only added compile-time type checking and a new syntax which essentially became ActionScript 1 when compiled �C whereas ActionScript 3 runs in AVM2, the new virtual machine specifically for ActionScript 3 code. As a result not only can ActionScript 3 movies not directly communicate with ActionScript 1 or ActionScript 2 movies (ActionScript 1 and ActionScript 2 movies can because they use the same virtual machine; AVM1 and AVM2 movies can only communicate through local connection), but you may find that the changes in ActionScript 3 to be much more profound than the jump even from ActionScript 1 to ActionScript 2.
Code examples (of classes similar in functionality) from each version of ActionScript:
ActionScript 1
function Example(){this.num = 1;
}
Example.prototype.str = "text";
Example.prototype.doubleNum = function(){this.num *= 2;
}
ActionScript 2
class Example {public var num:Number;
private var str:String = "text";
public function Example(){this.num = 1;
}
public function doubleNum():Void {this.num *= 2;
}
}
Note: When compiled, the above ActionScript 2 class becomes equivalent to ActionScript 1 example.
ActionScript 3
package { public class Example {public var num:Number;
protected var str:String = "text";
public function Example(){ this.num = 1;
}
public function doubleNum():void {this.num *= 2;
}
}
}
ActionScript 3 is different. Very different. So different, in fact, that it requires a completely new virtual machine to run it. But at its core, its still ActionScript and as ActionScript you'll notice that many of the commands and programming concepts that applied to ActionScript 1 and ActionScript 2 still pretty much apply to ActionScript 3. Even with the example above, very little, at least syntactically, has changed. And sometimes the ActionScript 3 equivalent of ActionScript 2 code will look very similar, but not always. And in the end, there are enough changes to make a direct conversion between the two often very difficult.
These changes were necessary, though. ActionScript 3 was built with efficiency and productivity in mind. Not just efficiency in development (and this point can be argued for smaller projects but larger projects do benefit) but also playback performance where code in ActionScript 3 can be played back in the Flash Player up to 10 times (if not more) faster than ActionScript 2 code. Yes, you will find that many of the same menial tasks in ActionScript 1 and ActionScript 2 now seem to take twice as long to code in ActionScript 3, but in the end the extra speed and functionality. The casual coder may look to the sky shaking a fist, cursing, but the advanced programmer will jump with glee in rejoice.
Here are some of the new features in ActionScript 3:
When you write code in a Flash source file (FLA) using ActionScript 3, you're writing code on the timeline and only the timeline. If not writing in the timeline then you're writing code in an external class file (at which point you wouldn't be writing code in the FLA, now would you?). In ActionScript 1 and ActionScript 2, you could write code on the timeline as well as on objects such as buttons or movie clips when adding code to the Actions editor with those objects selected. Code then would be added within on() or onClipEvent() blocks and related to some kind of event like press or enterFrame. This is no longer possible in ActionScript 3. Code can only be written on the timeline and all events, like press and enterFrame now have to be defined there as well.
Figure: ActionScript cannot be assigned to selections
Variables are words in code that represent or contain different values or data. When you declare variables in ActionScript 3, you need to use the var keyword.
var myVariableName; // var required
The var keyword has been available in ActionScript 1 since Flash 5 but only now, in ActionScript 3 is it required. The only exception is when defining a new variable value in a dynamic object instance (one whose variable definitions are not predefined) using an explicit reference to that object.
myDynamicObject.newVar = value; // var not used
In the above example, newVar is a new variable being defined in the myDynamicObject object without the use of var. In fact, var can never be used with complex references, or any reference that requires a dot (.) or bracket access ([]) to reference the variable.
When defining a variable you must only use numbers, letters, dollar signs ($) and underscores (_) and a variable cannot start with a number. Whereas "bits32", "_bits32", and "$bits32" are valid, "32bits" is not valid for a variable name since it starts with a number.
You will also have to be sure not to create naming conflicts with your variable names and any internal variable names already defined in the current scope of your script. For example, when writing code in any timeline, you are writing code that is being defined for a MovieClip instance �C the MovieClip instance that is represented by that timeline. If you try to define a variable with a name that is the same as a predefined MovieClip variable (or function) you will get an error.
// Any timeline script
var name:String = "Joe"; // Error: A conflict exists with inherited definition
Similarly, you should not name variables after global objects or functions like Array, XML, or trace or those definitions will no longer be accessible to you.
Note: Since Flash Player 7, ActionScript is case sensitive, so the variables Name and name are not the same.
New to ActionScript 3 is the restriction that you can only declare a variable with var once in any one scope or timeline in code. In other words, if you declare the variable x at the top of your script and want to use it again at the bottom of your script, you should not use the var keyword for that variable again
var x = value; // ok
…
var x = differentValue; // error; you can only use var once
When defining variables on the timeline in Flash, this also applies to all frames in the same timeline, not just the current frame.
When declaring variables with the var keyword (and only with the var [or const] keyword) you have the option of specifying a variable type. A variable's type describes the kind of value it will be holding. This was a new feature in ActionScript 2 and continues to exist in ActionScript 3. So, for example, if you wanted the variable x to hold a number value, you would specify it as being of the type Number using the following:
var x:Number; // variable x contains number values
In both versions of ActionScript, typing like is optional. ActionScript 3, however, will also retain type information during movie playback, unlike ActionScript 2 which used it strictly for compile-time (during publishing) error checking. This means that you will have to be much more respective of your type decisions, especially since you cannot redefine a variable with var a second time in ActionScript 3 (doing this in ActionScript 2 would let you use different types for one variable).
By not typing a variable at all, you can use any type you want for that variable. However, ActionScript 3 also provides a special "untyped" type that represents just that �C no type. It is represented by an asterisk (*).
var anyValue:*; // variable can have any type
It's always good to specify some type for your variable as it can lead to better error checking and performance. By using the untyped type, you can specifically indicate that the variable can have any value without reading others reading the code to guess.
If you do not supply a variable with a default value, it will be assigned one based on its type. If no type was supplied, it will be given a value of undefined. The following list details the default values of different data types in ActionScript 3:
var untyped:*; // (or no typing) undefined
var boolean:Boolean; // false
var number:Number; // NaN
var integer:int; // 0
var unsignedInteger:uint; // 0
var string:String; // null
var object:Object; // null
Any other Object type results in default value of null. It should be noted that values of the type object (any kind of object including arrays and objects created from custom classes) have a default value of null, not undefined. In fact objects in ActionScript cannot be undefined. If they have no value, then they are null. Only with untyped variables or attempting to access variables that do not exist will get a value of undefined.
Number types are now unique in that they can no longer be undefined or null. If they have no value, they are seen as NaN ("Not a Number"). NaN is a tricky value, however. You can't really compare NaN with another NaN with the equality operator (==) because they probably won't be the same. If you ever need to check to see if a number is NaN, you should always use isNaN().
if (isNaN(myNumber)) // checks to see if Number is defined
The int and uint variables types are new in ActionScript 3. These are special kinds of Numbers that represent 32-bit integers or whole numbers. The int type is a normal integer and uint is an unsigned integer, or a whole number whose value cannot be negative. These kinds of numbers can only have whole number values. They cannot be null, undefined., or even NaN like the Number type on which they are based. Being that they are based on the Number type, however, you'll notice that they're type identities ("int" and "uint") are not capitalized. This indicates that there is no specific object type or class definition associated with that type. Instead, these types essentially share the Number definition with Number types (with the exception of the MIN_VALUE and MAX_VALUE constants).
There is one other type that is also not capitalized. This is the special void type. This was capitalized in ActionScript 2 but is no longer in ActionScript 3 since, like with int and uint, there is no specific definition associated with it. This type has not been seen so far as it only applies to functions.
Functions define reusable chunks of code, or custom operations in ActionScript. By creating a function you can perform the same operation multiple times without having to write the same code over again for each time you want to use it.
There are two ways to define functions in ActionScript. You can create a named function using the form function [functionName] ([parameters]) { [code] } or you can define an anonymous function using var [functionName] = function ([parameters]) { [code] }. Both essentially create a variable definition (following the same naming conventions used by variables) with a value of Function, though the second method does so a little more explicitly.
// Named function
function doubleNumber(num) {
return num*2;
}
// Same function defined as an anonymous function
var doubleNumber = function(num) {
return num*2;
}
The above example creates a function with the name doubleNumber which accepts a single number value and returns that value multiplied by two. To use the function, you call it using parentheses (()).
var x:Number = 10;
trace(doubleNumber(x)); // traces 20
As with variables, named functions cannot be defined more than once for any one given timeline
When assigning type to functions, define typing information for both the parameter list (the comma separated list of values you can supply the function) as well as the return value, or the value that the function supplies after it's executed. When using an anonymous function definition, the variable the function is being assigned to would also be typed to Function.
// Named function
function doubleNumber(num:Number):Number {
return num*2;
}
// Same function defined as an anonymous function
var doubleNumber:Function = function(num:Number):Number {
return num*2;
}
If a function does not return a value, then its return type should be void. When a function typed as void is executed, or simply fails to return a value with the return statement, its return value becomes undefined.
function returnsNothing():void {
// do nothing
}
trace(returnsNothing()); // traces undefined The returnsNothing function above not only returns nothing, but also accepts no values �C it has no parameter list. If you try to pass values into the function when it has no parameter list defined for it in ActionScript 3, you will get an error.
returnsNothing(3); // Error: Incorrect number of arguments
In ActionScript 2, the Void type was used as the parameter list in a function definition to indicate no parameters. In ActionScript 3, you just leave the list empty.
Note: The difference between parameters and arguments is that parameters are the value used to define the function. Arguments are the actual values provided to the function during use. You can see arguments as being parameter values.
With ActionScript 3, you can also now define default values for your functions.
// Here, message parameter is optional
function usesDefault(message:String = "hello"):void {
trace(message);
}
usesDefault("test"); // traces "test"
usesDefault(); // traces "hello"
By using defaults you not only get to specify values for parameters not used by the function caller, but it also lets you define functions with optional parameters, or parameters that aren't required to be used. Those parameters that do not have default values must be provided when the function is called. Because of this, all optional parameters must be defined at the end of a parameter list. You cannot have a required parameter defined after an optional.
// Error: Required parameters are not
// permitted after optional parameters
function usesDefault(message:String = "hello", num:Number):void {
// code
}
// Correct; usesDefault needs at
// least 1 argument, accepts 2 at max
function usesDefault(num:Number, message:String = "hello"):void {
// code
}
What if you wanted to allow a function to be called with any number of arguments? In ActionScript 2, you could do this simply by omitting any parameter list and referencing the arguments using the arguments object in the function. In ActionScript 3, having no parameter list means the function cannot be called with any arguments. Instead, you have to use a new parameter type known as …(rest). This parameter goes at the end of your parameter list (or it can be your entire parameter list) and indicates that any number of arguments can be used when calling the function. The …(rest) parameter is written as …[argumentsArrayName] where argumentsArrayName is the name of the array that will contain the arguments passed.
function passAnything(...statements):void {
trace(statements.length +": "+ statements);
}
passAnything(); // traces 0:
passAnything(1); // traces 1: 1
passAnything("a", true, 0); // traces 3: a,true,0
Note: When using … (rest) parameter, the arguments object is not available to the function call. Instead, the …(rest) parameter is to be used to obtain the arguments passed. Unlike arguments, however, …(rest) does not have the caller property used to reference the current function. In ActionScript 3, neither arguments nor …(rest) have the callee property used to reference the function calling the current function (callee was available in the arguments object in ActionScript 2 but removed in ActionScript 3).
Objects are complex values that contain, or can contain, additional values known as properties. The most basic kind of object is an Object object and is created using new Object().
var myObject:Object = new Object();
There are other kinds of objects in ActionScript that behave similarly. Every timeline in Flash, for instance, represents the timeline of a movie clip symbol which in ActionScript is represented by a MovieClip object or instance. The name variable of a timeline or MovieClip is a property of that MovieClip instance.
// Main timeline
trace(name); // traces "root1"
Functions defined in objects are known as methods. Together, properties and methods make up an object's members. Methods unique to MovieClip instances include gotoAndPlay() and gotoAndStop(). Primitive values like Boolean (true or false), Number (numeric values), and String (text characters) are not objects in the true sense as they represent basic values and do not act as containers for other values. Flash does, however, associate these primitives with certain object types (Boolean, Number, and String), or classes, which grants them certain object-like functionality. So, for instance, you can extract a certain chunk of text from a String primitive using the String.slice() method of the String class.
Classes are what define objects. They also act as an object type. The Array class, for instance, defines what properties and methods exist in Array instances (whose type is Array). When you look through the documentation available for Arrays, you're looking at a reference to the Array class.
var arrayInstance:Array = new Array(); // instance of Array class
With Object Oriented Programming (OOP), you are writing custom classes that define custom object instances. With a more traditional, or procedural, approach, you are mainly defining variables and functions that work together but without much emphasis on object usage. In Flash, this means writing code on the timeline. More about just how timelines and ActionScript work together will be covered later.
Since ActionScript 2, some classes in ActionScript were marked as being sealed. More specifically, they weren't marked dynamic (the opposite of sealed). If a class is not dynamic, then it is sealed. When a class is sealed, it means that instances of that class cannot have any additional variables or properties defined for them outside of those specified in the class's definition. The Object and Array classes in ActionScript are dynamic. You can define what ever variable values you want those objects. The Sound class, on the other hand, is an example of a sealed class.
var array:Array = new Array();
array.customValue = 1; // OK
var sound:Sound = new Sound();
sound.customValue = 2; // Error: Access of possibly undefined property
In ActionScript 2, enforcement of dynamic or sealed classes was handled by the compiler. Because of this, you could work around the restriction of sealed classes using the array access operator to reference variables
// ActionScript 2 workaround
var sound:Sound = new Sound();
sound["customValue"] = 2; // Works
This is no longer the case in ActionScript 3. Sealed classes in ActionScript 3 are enforced not only at compile time, but also runtime.
As you work with different objects in ActionScript, you will need to note which objects are dynamic and which are not. Here is a list of commonly used dynamic classes:
The this keyword in ActionScript is used to access the current scope, or the object the code in the current block is being run in the context of. Using this on the timeline will reference the MovieClip instance to which that timeline belongs.
// Main timeline
trace(this); // [object MainTimeline]
In functions, referencing this references the object in which the current function is defined. Since the same function can be easily defined in multiple objects, a single function can make use of the this reference and perform actions on different objects based on which object it is being called from.
var joe:Object = new Object();
joe.name = "Joe";
joe.showName = function():void {
trace( this.name);
}
var jane:Object = new Object();
jane.name = "Jane";
jane.showName = joe.showName;
joe.showName (); // traces "Joe"
jane.showName(); // traces "Jane"
Here, there was only one function definition for showName, initially defined to the showName variable in the joe object. That function was then assigned to the jane object, again using the variable name showName �C one function, two references to it in two different objects. The object from which the function is being called determines which object the this keyword references.
This behavior was consistent for ActionScript 1 and ActionScript 2 for all functions. Now, in ActionScript 3, this is only the case for anonymous functions. Named functions in ActionScript 3 now support method closures, or are bound to the object for which they are initially defined. If the above example can be written again using a named function. Watch what happens when the functions are called from their respective objects.
function showName():void {
trace(this.name);
}
var joe:Object = new Object();
joe.name = "Joe";
joe.showName = showName
var jane:Object = new Object();
jane.name = "Jane";
jane.showName = showName;
joe.showName(); // traces "root1"
jane.showName(); // traces "root1" It doesn't matter what object the showName function is defined, it's reference to this will always be the main timeline (root1). This is because, as a named function, in ActionScript 3, this will always reference the object instance of the original context of the function definition. This is especially useful for event handling where in, in the past, workarounds had to be used to maintain a valid reference to the instance for which a handler as defined (i.e. using mx.utils.Delegate in ActionScript 2).
Events indicate when something happen. Clicking on a button indicates a "click" event. When an external text file loads into the Flash player, there's a "complete" event indicating that the contents of that text file have been completely read into the player.
Virtually all ActionScript is executed based on events. Event commands written on the timeline in frames can be see as code executed during the event of the Flash Player reading and displaying that frame (this has changed slightly in ActionScript 3 with variable and function definitions which will be covered later).
Events then
For non frame-based actions, most events (specifically mouse and keyboard events) were originally handled within on([event]){} code blocks placed on button symbols.
// Starting with Flash 2 and available for
// ActionScript 1 and 2, a press event
// placed on a selected button symbol
on(press) {
// play timeline in which this button exists
play();
}
Events used with on (some introduced after Flash 2) include:
Flash 5 featured a new kind of event handler that could be added, not to button symbols, but movie clips. This was the onClipEvent([event]{} code block.
// Placed on a selected movie clip symbol
onClipEvent(enterFrame) {
// move this movie clip 5 frames to
// the right every time the Flash player
// draws a frame based on the frame rate
_x += 5;
}
With Flash 5 you could also load XML into the Flash player with the new (at the time) XML object. In order for a programmer to know when the XML has been loaded and parsed, an onLoad event handler would be defined for the XML object. This handler was in the form of a dynamic function definition that could be defined, deleted and changed for the XML object at any time.
// Flash 5 XML onLoad handler
var myXML = new XML();
// event handler called when
// XML has been loaded into myXML
myXML.onLoad = function(success){
// if XML has been loaded and parsed
// successfully, success is true
if (success){
trace(this); // trace XML
}
}
// load the XML into the XML object when
// loaded and parsed, onLoad will be called
myXML.load("xmlFile.xml");
Flash MX (6) greatly improved event handling. Not only were on code blocks allowed to be used on both movie clips and buttons (as opposed to just buttons) but, Flash MX also allowed dynamic event handlers to be created for buttons and movie clips in the same way the onLoad event handler was defined for XML objects in Flash 5. Whereas on and onClipEvent were static and couldn't be changed during runtime, using these function-based event handlers meant an event could be deleted or redefined as the Flash movie was playing, something especially useful for onEnterFrame events used to handle animation.
// Flash MX onEnterFrame event handler
// assigned for for a movie clip instance
myBall_mc.onEnterFrame = function(){
// move this movie clip to the right
// by 5 pixels every frame
this._x += 5;
// if the x position of this movie clip
// is greater than 200, delete the event handler
if (this._x > 200){
delete this.onEnterFrame;
}
}
More importantly, Flash MX introduced a new concept to Flash called listeners. Listeners are objects with methods (and, later, can include methods or functions only) that listen for and have a handler called as a result of an event. The key concept behind listeners is that you can have more than one event handler associated with any one event. With normal event handlers, like the onLoad event handler with the XML object, you can only define one onLoad function. If you define it again, you will be overwriting the old onLoad and replacing it with the new definition. It was very difficult to have more than one event handler associated with a single event. Listeners solved that.
With listeners, instead of defining an event handler for the object receiving the event, you assigned the event handler to another object �C any other object, and then had that object added to be a listener of the object receiving the event.
// Flash MX Mouse listeners; more than one
// object/handler reacting to the same event
var handler1 = new Object();
handler1.onMouseDown = function(){
trace("Handler 1");
}
var handler2 = new Object();
handler2.onMouseDown = function(){
trace("Handler 2");
}
Mouse.addListener(handler1);
Mouse.addListener(handler2);
// Clicking the mouse once results in the traces:
// Handler 1
// Handler 2
Since both handler1 and handler2 were listeners of the Mouse object, their onMouseDown methods were called as event handlers of the Mouse's onMouseDown event. If you ever wanted to remove an object from being an event listener, you could use removeListener().
This was a great concept but was only limited to a few objects including:
Enter ActionScript 2 with Flash MX 2004 (7). With ActionScript 2 came a new set of components that used an architecture known as V2 ("version 2"). This architecture used a new kind of listener format which was similar to using addListener but instead of adding objects as listeners of other objects, you listened to specific events from other objects. This used a new method called addEventListener that was part of a new (V2) class called EventDispatcher. The addEventListener method accepted not only an object with one or more event handlers, but also a name of the event you wanted to listen for. This not only prevented unnecessary events to be sent to objects that didn't have event handlers for them (e.g. handler1 and handler2 in the previous example received onMouseDown and onMouseUp events from the Mouse object even though they had no event handlers for them), but it also allowed you to use functions as listeners, not just objects with event handlers defined within them. Additionally, an event object was passed to the event handlers to provide information about the event.
// Flash MX 2004/ActionScript 2 button
// component event handlers
// Listener object with event handler
var handlerObject:Object = new Object();
handlerObject.click = function(event:Object):Void {
trace(event.type +": "+ this);
}
// Listener function
function handlerFunction(event:Object):Void {
trace( event.type +": "+ this);
}
// assign to be listeners of
// submit_button for the click event
submit_button.addEventListener("click", handlerObject);
submit_button.addEventListener("click", handlerFunction);
// Clicking the submit_button component:
// click: _level0.submit_button
// click: [object Object]
Because this form of event handling was built into the V2 component architecture (the EventDispatcher class being part of that architecture), you really didn't see it much anywhere else in ActionScript. The core language objects like Mouse and Key still used the older addListener method for handling events. This all changed with ActionScript 3.
Events now
ActionScript 3 completely revamped the way events were handled in ActionScript 3. There are two major themes that define ActionScript 3 events:
The EventDispatcher class is not entirely new. It existed, in some form, with the V2 component architecture present in Flash MX 2004 components. But now, with ActionScript 3, EventDispatcher has been made a native part of the ActionScript language and is responsible for essentially all event handling.
ActionScript 3 is class-based by nature. Classes, if you are not familiar with them, are predetermined definitions for objects in code. An Array object in ActionScript, for example, has a predefined set of properties (variables) and methods (functions) associated with it; properties like length, and methods like push() and pop(). These are all predetermined by an Array class which is defined internally by Flash. Should you want to make your own object definitions, you could make your own class to describe your own type of object. For example, consider the following object created with ActionScript:
// Rectangle object represented in code
var rectangleShape:Object = new Object();
rectangleShape.width = 10;
rectangleShape.height = 20;
rectangleShape.area = function():Number {
return this.width * this.height;
}
This example creates an object called rectangleShape which has two variables assigned to it, width and height, as well as a function called area which determines the area of the rectangle based on the values of width and height. In terms of functionality, this does about everything you need it to as far as rectangles go. But what if you want to make more rectangles? Do you have to through the same definition process? And what if you ever wanted to check to see if a certain variable was assigned to have a rectangle value? In this example, the type of object the rectangleShape is, is Object, not something that specifically indicates it as being a rectangle.
If you would like the rectangle instances to be a certain type, such as the type "RectangleShape" or something similar, then you could define the rectangle object in class and create new rectangles by creating new instances of that class. The definition for rectangleShape as a class could look something like the following in ActionScript 3:
// Defined in an external ActionScript
// file saved as RectangleShape.as
package {
public class RectangleShape {
public var width:Number;
public var height:Number;
public function RectangleShape(width:Number = 0, height:Number = 0){
this.width = width;
this.height = height;
}
public function area():Number {
return width*height;
}
}
}
As a class it would also be defined in a separate ActionScript file (a text file with an .as extension) and saved in a location within the Flash file's classpath �C or a location where Flash would know to look for it when the class is referenced or used in code. Then instead of using a generic Object value to define rectangleShape, you would use the RectangleShape class making a new instance of RectangleShape.
// Code used in Flash
var rectangleShape:RectangleShape = new RectangleShape(10, 20);
Here, not only was creating rectangleShape easier, but it also has a unique type associated with it that can be used to check to see if a certain value is in fact of the type (or originating from the class) RectangleShape.
But getting back to the point, though ActionScript has supported these classes in some respect all the way back to Flash 5 with ActionScript 1, only with ActionScript 3 are you seeing a more true representation of classes. And it just isn't a matter of having the option of creating these things called classes. In ActionScript 3, everything is an instance of a class and all the code you right becomes part of a class definition, even if not written within a separate ActionScript file meant to define a class.
This is important, especially if you are coming from an ActionScript 1 or ActionScript 2 background. Code written for ActionScript 1 and ActionScript 2 was either timeline based or added to button or movie clip selections. Even when a class was defined in ActionScript 1 or ActionScript 2 it was done so on the timeline �C where there was code, there was a timeline. In ActionScript 3, where there is code, there is a class.
So what does this mean for Flash CS3 and ActionScript 3? Does all code have to exist as external class files? Can you still write code on the timeline? What if you don't know, or want to know, anything about classes?
The good news is little has changed in terms of writing code for FLA files in the Flash IDE and you can still write code on the timeline, just as you always have. The compiler that creates published SWF from your FLA file will be able to handle all the technical issues revolving around this new aspect of ActionScript in the background, much in the same way it handles converting ActionScript 2 classes into ActionScript 1 code in the background without you, the user, really knowing. This means you won't have to know anything about classes nor will you need to mess with external class files if you don't want to when working with ActionScript 3 in Flash.
But don't get too excited. This doesn't mean that nothing has changed. In ActionScript 3, no longer can you write code for selections using on() or onClipEvent() code blocks and the Var option for text fields is no more leaving you to use TextField.text instead.
// Code like this defined on objects is
// no longer possible in ActionScript 3
on(press) {
textVar = "value"; // text field Var variables are no more
}
onClipEvent(enterFrame) {
// code
}
Also there's that whole deal with timeline scripts being converted to classes. Though this is mostly hidden from the user with a compile-time conversion, there are a lot of oddities that result from this behavior.
Timelines in Flash consist of one or more frames that contain graphics associated with visual elements displayed on the screen. A timeline with multiple frames will run through those frames as a Flash movie is being viewed showing an animation.
In addition to graphics, timelines can also contain ActionScript (as well as anchors and labels). More specifically, frames within a timeline can contain ActionScript. The code placed in each frame of a timeline gets executed when Flash displays that frame on the screen. With ActionScript 1 and ActionScript 2 Flash was working with a paradigm that depended heavily on the timeline as a foundation for not only animation but also ActionScript. To make a long story short, this model was limiting.
ActionScript 3 broke away from the timeline and instead isolates ActionScript definitions into separate class definitions that have no dependency on the timeline. Take the following ActionScript 2 class.
// ActionScript 2 definition in Example.as
class Example {
public var num:Number;
private var str:String = "text";
public function Example(){this.num = 1;
}
public function doubleNum():Void {this.num *= 2;
}
}
A FLA might use this class in frame 1 of the main timeline with the following:
// main timeline of ActionScript 2 FLA
var myExample:Example = new Example();
When compiled and published into a SWF, the SWF gets code that is attached to the timeline and essentially looks like this:
// compiled version
_global.Example = function(){
this.num = 1;
}
Example.prototype.str = "text";
Example.prototype.doubleNum = function(){this.num *= 2;
}
myExample = new Example();
All ActionScript 2 class definitions, when compiled, end up in the main timeline as ActionScript 1 definitions. And, really, to be more specific, the definitions actually end up in dynamically generated movie clip symbols placed in the library during compile time. Within these movie clips' timelines, however, the definitions are created within an #initclip/
