瓦力  .....台湾译名

Wall-E

Jim Capobianco  .....titles

本·贝尔特Ben Burtt  .....(voice)

艾丽莎·奈特Elissa Knight  .....Eve

佛莱德·威拉特Fred Willard  .....Shelby Forthright

影片类型：

本书前言

Flash的难题
传统的HTML应用程序功能单一、人机交互性差、安全性能不高。随着RIA（Rich Internet Application）技术的不断发展，Web开发有了新的发展分支，即包含丰富用户体验的应用程序。
最早的RIA应用程序大多由Flash开发工具制作。RIA程序的效果非常理想，且可运行于不同平台中，但Flash工具的特点决定了它不适合开发中大型RIA程序。其一，Flash工具是专业用于制作动画的开发平台，适合于开发时间逻辑较强的程序，但并不适合于开发业务逻辑复杂的程序。其二，Flash工具倡导DIY精神，只提供最基础的组件，所以几乎所有的任务都要自行完成。
Flex横空出世
Flex技术的出现解决了Flash技术的大部分问题。使用Flex技术开发部署RIA应用程序非常简单。由于Flex技术基于MXML标准、CSS标准、XML标准、ActionScript 3.0标准，所以开发过程更规范、应用程序更容易扩展。Flex技术中提供丰富的组件，使得Flex开发人员只需将注意力集中于业务逻辑开发上。另外，Flex编程是面向对象的编程，开发过程与大部分编程语言相似，所以其他语言开发人员可较容易地理解和掌握Flex。从Google趋势（http://www.google.cn/trends?q=fl ... geo=CN&date=all）上可以看出Flex发展迅猛，如下图所示，

为了帮助初学者入门和掌握Flex技术，本人翻阅了大量英文文档，编写了大量实例代码，花费大约半年时间编写此书。本书全面地介绍了Flex技术，并以实例介绍了如何使用Flex技术开发应用程序。通过本书的学习，读者能够了解和掌握Flex开发技巧，具有一定的开发实践能力。
本书的特点
1．提供完善的售后服务：为了帮助大家学习Flex，我们为广大读者建立专门的讨论区，网址为www.rzchina.net。广大读者可以和作者进行对Flex技术进行讨论。
2．循序渐进，由浅入深：为了方便读者学习，本书首先让读者了解什么是Flex，使用什么工具开发，并详细介绍第一个Flex应用程序的开发过程。读者可通过第一个Flex程序，逐步了解和熟悉Flex技术的开发过程、开发技巧。本书先介绍ActionScript 3.0语言的语法，后介绍Flex组件开发、美化界面、数据传输、开发框架等内容，最后以综合实例帮助读者学习Flex技术。
3．技术全面，内容充实：本人花费2～3个月时间进行前期准备，详细分析了现行Flex技术及相关技术的特点和实例应用。全书包含Flex常用的各种技术和工具，如Flex Builder 3、LiveCycle Data Services、Cairngorm、Flex-Ajax Bridge，以及与这些技术的结合。
4．案例精讲，深入剖析：根据本人多年的项目经验和对Flex技术的深入研究，认为学习Flex技术的捷径在于多看多实践，所以本书中为每个知识点都提供实例代码。读者通过分析和理解代码及代码解释，可以更快地掌握Flex技术中的知识点和开发技巧。本书在实例代码中提供详细的注释，对有特殊用法或含义的代码进行详细阐述。
5．综合实例，灵活应用：本书最后三章分别介绍了Flex播放器实例、CairngormStore实例和视频分享网站。这三个实例都具有一定的代表性。通过Flex播放器实例，读者可以学习和掌握如何在Flex中控制视频和音频。CairngormStore实例是一个简单的在线购物网站。而视频分享网站是Flex现在最成功的商业应用。读者通过此实例地学习可了解和掌握如何使用Flex开发中大型的应用程序。
6．配有光盘，加速学习：本书配套光盘中包含书中全部实例的工程源代码，读者可以方便地学习和参考。查看和分析大量源代码能快速、有效地提高Flex编程能力，掌握开发技巧。

蚁群算法ACO(ant colony optimization)的原理以及实现源代码

转载自:全文检索技术,算法和数据结构,Flex

之前说的算法基本上都比较枯燥的（废话，算法都很枯燥……），这次要介绍的蚁群算法(Ant Colony Algorithm)却是一种源于自然现象的算法，也是一种 meta heuristic，即与具体问题关系不大的优化算法，也就是它是一种用来在图中寻找优化路径的机率型技术。Marco Dorigo于1992年在他的博士论文中引入，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。

小小的蚂蚁总是能够找到食物，他们具有什么样的智能呢？设想，如果我们要为蚂蚁设计一个人工智能的程序，那么这个程序要多么复杂呢？首先，你要让蚂蚁能够避开障碍物，就必须根据适当的地形给它编进指令让他们能够巧妙的避开障碍物，其次，要让蚂蚁找到食物，就需要让他们遍历空间上的所有点；再次，如果要让蚂蚁找到最短的路径，那么需要计算所有可能的路径并且比较它们的大小，而且更重要的是，你要小心翼翼的编程，因为程序的错误也许会让你前功尽弃。这是多么不可思议的程序！太复杂了，恐怕没人能够完成这样繁琐冗余的程序。

为什么这么简单的程序会让蚂蚁干这样复杂的事情？答案是：简单规则的涌现。事实上，每只蚂蚁并不是像我们想象的需要知道整个世界的信息，他们其实只关心很小范围内的眼前信息，而且根据这些局部信息利用几条简单的规则进行决策，这样，在蚁群这个集体里，复杂性的行为就会凸现出来。这就是人工生命、复杂性科学解释的规律！

下面就是实现如此复杂性的七条简单规则：

1、范围：
蚂蚁观察到的范围是一个方格世界，蚂蚁有一个参数为速度半径（一般是3），那么它能观察到的范围就是3*3个方格世界，并且能移动的距离也在这个范围之内。
2、环境：
蚂蚁所在的环境是一个虚拟的世界，其中有障碍物，有别的蚂蚁，还有信息素，信息素有两种，一种是找到食物的蚂蚁洒下的食物信息素，一种是找到窝的蚂蚁洒下的窝的信息素。每个蚂蚁都仅仅能感知它范围内的环境信息。环境以一定的速率让信息素消失。
3、觅食规则：
在每只蚂蚁能感知的范围内寻找是否有食物，如果有就直接过去。否则看是否有信息素，并且比较在能感知的范围内哪一点的信息素最多，这样，它就朝信息素多的地方走，并且每只蚂蚁多会以小概率犯错误，从而并不是往信息素最多的点移动。蚂蚁找窝的规则和上面一样，只不过它对窝的信息素做出反应，而对食物信息素没反应。
4、移动规则：
每只蚂蚁都朝向信息素最多的方向移，并且，当周围没有信息素指引的时候，蚂蚁会按照自己原来运动的方向惯性的运动下去，并且，在运动的方向有一个随机的小的扰动。为了防止蚂蚁原地转圈，它会记住最近刚走过了哪些点，如果发现要走的下一点已经在最近走过了，它就会尽量避开。
5、避障规则：
如果蚂蚁要移动的方向有障碍物挡住，它会随机的选择另一个方向，并且有信息素指引的话，它会按照觅食的规则行为。
7、播撒信息素规则：
每只蚂蚁在刚找到食物或者窝的时候撒发的信息素最多，并随着它走远的距离，播撒的信息素越来越少。

下面的程序开始运行之后，蚂蚁们开始从窝里出动了，寻找食物；他们会顺着屏幕爬满整个画面，直到找到食物再返回窝。

其中，‘F’点表示食物，‘H’表示窝，白色块表示障碍物，‘+’就是蚂蚁了。

参数说明：
最大信息素：蚂蚁在一开始拥有的信息素总量，越大表示程序在较长一段时间能够存在信息素。信息素消减的速度：随着时间的流逝，已经存在于世界上的信息素会消减，这个数值越大，那么消减的越快。
错误概率表示这个蚂蚁不往信息素最大的区域走的概率，越大则表示这个蚂蚁越有创新性。
速度半径表示蚂蚁一次能走的最大长度，也表示这个蚂蚁的感知范围。
记忆能力表示蚂蚁能记住多少个刚刚走过点的坐标，这个值避免了蚂蚁在本地打转，停滞不前。而这个值越大那么整个系统运行速度就慢，越小则蚂蚁越容易原地转圈。

源代码如下：

/*ant.c*/

#define SPACE 0×20
#define ESC 0×1b
#define ANT_CHAR_EMPTY ‘+’
#define ANT_CHAR_FOOD 153
#define HOME_CHAR ‘H’
#define FOOD_CHAR ‘F’
#define FOOD_CHAR2 ‘f’
#define FOOD_HOME_COLOR 12
#define BLOCK_CHAR 177

#define MAX_ANT 50
#define INI_SPEED 3
#define MAXX 80
#define MAXY 23
#define MAX_FOOD 10000
#define TARGET_FOOD 200
#define MAX_SMELL 5000
#define SMELL_DROP_RATE 0.05
#define ANT_ERROR_RATE 0.02
#define ANT_EYESHOT 3
#define SMELL_GONE_SPEED 50
#define SMELL_GONE_RATE 0.05
#define TRACE_REMEMBER 50
#define MAX_BLOCK 100

#define NULL 0
#define UP 1
#define DOWN 2
#define LEFT 3
#define RIGHT 4
#define SMELL_TYPE_FOOD 0
#define SMELL_TYPE_HOME 1

#include “stdio.h”
#include “conio.h”
#include “dos.h”
#include “stdlib.h”
#include “dos.h”
#include “process.h”
#include “ctype.h”
#include “math.h”

void WorldInitial(void);
void BlockInitial(void);
void CreatBlock(void);
void SaveBlock(void);
void LoadBlock(void);
void HomeFoodInitial(void);
void AntInitial(void);
void WorldChange(void);
void AntMove(void);
void AntOneStep(void);
void DealKey(char key);
void ClearSmellDisp(void);
void DispSmell(int type);
int AntNextDir(int xxx,int yyy,int ddir);
int GetMaxSmell(int type,int xxx,int yyy,int ddir);
int IsTrace(int xxx,int yyy);
int MaxLocation(int num1,int num2,int num3);
int CanGo(int xxx,int yyy,int ddir);
int JudgeCanGo(int xxx,int yyy);
int TurnLeft(int ddir);
int TurnRight(int ddir);
int TurnBack(int ddir);

int MainTimer(void);
char WaitForKey(int secnum);
void DispPlayTime(void);
int TimeUse(void);
void HideCur(void);
void ResetCur(void);

/* —————  */
struct HomeStruct
{
  int xxx,yyy;
  int amount;
  int TargetFood;
}home;

struct FoodStruct
{
  int xxx,yyy;
  int amount;
}food;

struct AntStruct
{
  int xxx,yyy;
  int dir;
  int speed;
  int SpeedTimer;
  int food;
  int SmellAmount[2];
  int tracex[TRACE_REMEMBER];
  int tracey[TRACE_REMEMBER];
  int TracePtr;
  int IQ;
}ant[MAX_ANT];
int AntNow;
int timer10ms;
struct time starttime,endtime;
int Smell[2][MAXX+1][MAXY+1];
int block[MAXX+1][MAXY+1];
int SmellGoneTimer;
int SmellDispFlag;
int CanFindFood;
int HardtoFindPath;

/* —– Main ——– */
void main(void)
{
  char KeyPress;
  int tu;

  clrscr();
  HideCur();
  WorldInitial();
  do
  {
    timer10ms = MainTimer();
    if(timer10ms) AntMove();
    if(timer10ms) WorldChange();
    tu = TimeUse();
    if(tu>=60&&!CanFindFood)
    {
      gotoxy(1,MAXY+1);
      printf(“Can not find food, maybe a block world.”);
      WaitForKey(10);
      WorldInitial();
    }
    if(tu>=180&&home.amount<100&&!HardtoFindPath)
    {
      gotoxy(1,MAXY+1);
      printf(“God! it is so difficult to find a path.”);
      if(WaitForKey(10)==0×0d) WorldInitial();
      else
     {
        HardtoFindPath = 1;
        gotoxy(1,MAXY+1);
        printf(”                     “);
     }
    }
    if(home.amount>=home.TargetFood)
    {
      gettime(&endtime);
      KeyPress = WaitForKey(60);
      DispPlayTime();
      WaitForKey(10);
      WorldInitial();
    }
    else if(kbhit())
    {
      KeyPress = getch();
      DealKey(KeyPress);
    }
    else KeyPress = NULL;
  }
  while(KeyPress!=ESC);
  gettime(&endtime);
  DispPlayTime();
  WaitForKey(10);
  clrscr();
  ResetCur();
}

/* —— general sub process ———– */
int MainTimer(void)
/* output: how much 10ms have pass from last time call this process */
{
  static int oldhund,oldsec;
  struct  time t;
  int timeuse;

  gettime(&t);
  timeuse = 0;
  if(t.ti_hund!=oldhund)
  {
    if(t.ti_sec!=oldsec)
    {
      timeuse+=100;
      oldsec = t.ti_sec;
    }
    timeuse+=t.ti_hund-oldhund;
    oldhund = t.ti_hund;
  }
  else timeuse = 0;
  return (timeuse);
}

char WaitForKey(int secnum)
/* funtion: if have key in, exit immediately, else wait ’secnum’ senconds then exit
   input: secnum — wait this senconds, must < 3600 (1 hour)
   output: key char, if no key in(exit when timeout), return NULL */
{
  int secin,secnow;
  int minin,minnow;
  int hourin,hournow;
  int secuse;
  struct  time t;

  gettime(&t);
  secin = t.ti_sec;
  minin = t.ti_min;
  hourin = t.ti_hour;

  do
  {
    if(kbhit()) return(getch());
    gettime(&t);
    secnow = t.ti_sec;
    minnow = t.ti_min;
    hournow = t.ti_hour;

    if(hournow!=hourin) minnow+=60;
    if(minnow>minin) secuse = (minnow-1-minin) + (secnow+60-secin);
    else secuse = secnow - secin;

    /* counting error check */
    if(secuse<0)
    {
      gotoxy(1,MAXY+1);
      printf(“Time conuting error, any keyto exit…”);
      getch();
      exit(3);
    }
  }
  while(secuse<=secnum);
  return (NULL);
}

void DispPlayTime(void)
{
  int ph,pm,ps;

  ph = endtime.ti_hour - starttime.ti_hour;
  pm = endtime.ti_min - starttime.ti_min;
  ps = endtime.ti_sec - starttime.ti_sec;

  if(ph<0) ph+=24;
  if(pm<0) { ph–; pm+=60; }
  if(ps<0) { pm–; ps+=60; }

  gotoxy(1,MAXY+1);
  printf(“Time use: %d hour- %d min- %d sec “,ph,pm,ps);
}

int TimeUse(void)
{
  int ph,pm,ps;

  gettime(&endtime);
  ph = endtime.ti_hour - starttime.ti_hour;
  pm = endtime.ti_min - starttime.ti_min;
  ps = endtime.ti_sec - starttime.ti_sec;

  if(ph<0) ph+=24;
  if(pm<0) { ph–; pm+=60; }
  if(ps<0) { pm–; ps+=60; }

  return(ps+(60*(pm+60*ph)));
}

void HideCur(void)
{
  union REGS regs0;
  regs0.h.ah=1;
  regs0.h.ch=0×30;
  regs0.h.cl=0×31;
  int86(0×10,&regs0,&regs0);
}

void ResetCur(void)
{
  union REGS regs0;
  regs0.h.ah=1;
  regs0.h.ch=0×06;
  regs0.h.cl=0×07;
  int86(0×10,&regs0,&regs0);
}

/* ———— main ANT programe ————- */
void WorldInitial(void)
{
  int k,i,j;
  randomize();
  clrscr();
  HomeFoodInitial();
  for(AntNow=0;AntNow<MAX_ANT;AntNow++)
  {
    AntInitial();
  } /* of for AntNow */;

  BlockInitial();
  for(k=0;k<=1;k++)
  /* SMELL TYPE FOOD and HOME */
    for(i=0;i<=MAXX;i++)
      for(j=0;j<=MAXY;j++)
        Smell[k][i][j] = 0;
  SmellGoneTimer = 0;
  gettime(&starttime);
  SmellDispFlag = 0;
  CanFindFood = 0;
  HardtoFindPath = 0;
}

void BlockInitial(void)
{
  int i,j;
  int bn;

  for(i=0;i<=MAXX;i++)
    for(j=0;j<=MAXY;j++)
      block[i][j] = 0;

  bn = 1+ MAX_BLOCK/2 + random(MAX_BLOCK/2);
  for(i=0;i<=bn;i++) CreatBlock();
}

void CreatBlock(void)
{
  int x1,y1,x2,y2;
  int dx,dy;
  int i,j;

  x1 = random(MAXX)+1;
  y1 = random(MAXY)+1;

  dx = random(MAXX/10)+1;
  dy = random(MAXY/10)+1;

  x2 = x1+dx;
  y2 = y1+dy;

  if(x2>MAXX) x2 = MAXX;
  if(y2>MAXY) y2 = MAXY;

  if(food.xxx>=x1&&food.xxx<=x2&&food.yyy>=y1&&food.yyy<=y2) return;
  if(home.xxx>=x1&&home.xxx<=x2&&home.yyy>=y1&&home.yyy<=y2) return;

  for(i=x1;i<=x2;i++)
    for(j=y1;j<=y2;j++)
    {
      block[i][j] = 1;
      gotoxy(i,j);
      putch(BLOCK_CHAR);
    }
}

void SaveBlock(void)
{
 FILE *fp_block;
 char FileNameBlock[20];
 int i,j;

 gotoxy(1,MAXY+1);
  printf(”                     “);
 gotoxy(1,MAXY+1);
 printf(“Save to file…”,FileNameBlock);
 gets(FileNameBlock);
 if(FileNameBlock[0]==0) strcpy(FileNameBlock,“Ant.ant”);
 else strcat(FileNameBlock,“.ant”);

 if ((fp_block = fopen(FileNameBlock, “wb”)) == NULL)
 { gotoxy(1,MAXY+1);
    printf(“Creat file %s fail…”,FileNameBlock);
  getch();
  exit(2);
 }
 gotoxy(1,MAXY+1);
  printf(”                           “);

 fputc(home.xxx,fp_block);
 fputc(home.yyy,fp_block);
 fputc(food.xxx,fp_block);
 fputc(food.yyy,fp_block);

 for(i=0;i<=MAXX;i++)
    for(j=0;j<=MAXY;j++)
      fputc(block[i][j],fp_block);

  fclose(fp_block);
}

void LoadBlock(void)
{
 FILE *fp_block;
 char FileNameBlock[20];
 int i,j,k;

 gotoxy(1,MAXY+1);
  printf(”                     “);
 gotoxy(1,MAXY+1);
 printf(“Load file…”,FileNameBlock);
 gets(FileNameBlock);
 if(FileNameBlock[0]==0) strcpy(FileNameBlock,“Ant.ant”);
 else strcat(FileNameBlock,“.ant”);

 if ((fp_block = fopen(FileNameBlock, “rb”)) == NULL)
 { gotoxy(1,MAXY+1);
    printf(“Open file %s fail…”,FileNameBlock);
  getch();
  exit(2);
 }

 clrscr();
 home.xxx = fgetc(fp_block);
 home.yyy = fgetc(fp_block);
 food.xxx = fgetc(fp_block);
 food.yyy = fgetc(fp_block);
 gotoxy(home.xxx,home.yyy); putch(HOME_CHAR);
  gotoxy(food.xxx,food.yyy); putch(FOOD_CHAR);
  food.amount = random(MAX_FOOD/3)+2*MAX_FOOD/3+1;
  /* food.amount = MAX_FOOD; */
  home.amount = 0;
  home.TargetFood =
    (food.amount<TARGET_FOOD)?food.amount:TARGET_FOOD;

 for(AntNow=0;AntNow<MAX_ANT;AntNow++)
  {
    AntInitial();
  } /* of for AntNow */;

 for(i=0;i<=MAXX;i++)
    for(j=0;j<=MAXY;j++)
    {
      block[i][j] = fgetc(fp_block);
      if(block[i][j])
      {
       gotoxy(i,j);
       putch(BLOCK_CHAR);
     }
    }

  for(k=0;k<=1;k++)
  /* SMELL TYPE FOOD and HOME */
    for(i=0;i<=MAXX;i++)
      for(j=0;j<=MAXY;j++)
        Smell[k][i][j] = 0;
  SmellGoneTimer = 0;
  gettime(&starttime);
  SmellDispFlag = 0;
  CanFindFood = 0;
  HardtoFindPath = 0;

  fclose(fp_block);
}

void HomeFoodInitial(void)
{
  int randnum;
  int homeplace;
  /* 1 — home at left-up, food at right-down
     2 — home at left-down, food at right-up
     3 — home at right-up, food at left-down
     4 — home at right-down, food at left-up */

  randnum = random(100);
  if(randnum<25) homeplace = 1;
  else if (randnum>=25&&randnum<50) homeplace = 2;
  else if (randnum>=50&&randnum<75) homeplace = 3;
  else homeplace = 4;

  switch(homeplace)
  {
    case 1: home.xxx = random(MAXX/3)+1;
        home.yyy = random(MAXY/3)+1;
        food.xxx = random(MAXX/3)+2*MAXX/3+1;
        food.yyy = random(MAXY/3)+2*MAXY/3+1;
        break;
    case 2: home.xxx = random(MAXX/3)+1;
        home.yyy = random(MAXY/3)+2*MAXY/3+1;
        food.xxx = random(MAXX/3)+2*MAXX/3+1;
        food.yyy = random(MAXY/3)+1;
        break;
    case 3: home.xxx = random(MAXX/3)+2*MAXX/3+1;
        home.yyy = random(MAXY/3)+1;
        food.xxx = random(MAXX/3)+1;
        food.yyy = random(MAXY/3)+2*MAXY/3+1;
        break;
    case 4: home.xxx = random(MAXX/3)+2*MAXX/3+1;
        home.yyy = random(MAXY/3)+2*MAXY/3+1;
        food.xxx = random(MAXX/3)+1;
        food.yyy = random(MAXY/3)+1;
        break;
  }

  food.amount = random(MAX_FOOD/3)+2*MAX_FOOD/3+1;
  /* food.amount = MAX_FOOD; */
  home.amount = 0;
  home.TargetFood = (food.amount<TARGET_FOOD)?food.amount:TARGET_FOOD;

  /* data correctness check */
  if(home.xxx<=0||home.xxx>MAXX||home.yyy<=0||home.yyy>MAXY||
     food.xxx<=0||food.xxx>MAXX||food.yyy<=0||food.yyy>MAXY||
     food.amount<=0)
  {
    gotoxy(1,MAXY+1);
    printf(“World initial fail, any key to exit…”);
    getch();
    exit(2);
  }

  gotoxy(home.xxx,home.yyy); putch(HOME_CHAR);
  gotoxy(food.xxx,food.yyy); putch(FOOD_CHAR);
}

void AntInitial(void)
/* initial ant[AntNow] */
{
  int randnum;
  int i;

  ant[AntNow].xxx = home.xxx;
  ant[AntNow].yyy = home.yyy;

  randnum = random(100);
  if(randnum<25) ant[AntNow].dir = UP;
  else if (randnum>=25&&randnum<50) ant[AntNow].dir = DOWN;
  else if (randnum>=50&&randnum<75) ant[AntNow].dir = LEFT;
  else ant[AntNow].dir = RIGHT;

  ant[AntNow].speed = 2*(random(INI_SPEED/2)+1);
  ant[AntNow].SpeedTimer = 0;
  ant[AntNow].food = 0;
  ant[AntNow].SmellAmount[SMELL_TYPE_FOOD] = 0;
  ant[AntNow].SmellAmount[SMELL_TYPE_HOME] = MAX_SMELL;
  ant[AntNow].IQ = 1;

  for(i=0;i<TRACE_REMEMBER;i++)
  {
    ant[AntNow].tracex[i] = 0;
    ant[AntNow].tracey[i] = 0;
  }
  ant[AntNow].TracePtr = 0;

  /* a sepecail ant */
  if(AntNow==0) ant[AntNow].speed = INI_SPEED;
}

void WorldChange(void)
{
  int k,i,j;
  int smelldisp;

  SmellGoneTimer+=timer10ms;
  if(SmellGoneTimer>=SMELL_GONE_SPEED)
  {
    SmellGoneTimer = 0;
    for(k=0;k<=1;k++)
    /* SMELL TYPE FOOD and HOME */
      for(i=1;i<=MAXX;i++)
        for(j=1;j<=MAXY;j++)
        {
            if(Smell[k][i][j])
          {
              smelldisp = 1+((10*Smell[k][i][j])/(MAX_SMELL*SMELL_DROP_RATE));
              if(smelldisp>=30000||smelldisp<0) smelldisp = 30000;
              if(SmellDispFlag)
           {
                gotoxy(i,j);
                if((i==food.xxx&&j==food.yyy)||(i==home.xxx&&j==home.yyy))
                  /* don’t over write Food and Home */;
              else
             {
                  if(smelldisp>9) putch(‘#’);
                  else putch(smelldisp+‘0′);
             }
           }
              Smell[k][i][j]-= 1+(Smell[k][i][j]*SMELL_GONE_RATE);
              if(Smell[k][i][j]<0) Smell[k][i][j] = 0;
              if(SmellDispFlag)
           {
                if(Smell[k][i][j]<=2)
             {
                  gotoxy(i,j);
                  putch(SPACE);
             }
           }
          }
          } /* of one location */
  } /* of time to change the world */
} /* of world change */

void AntMove(void)
{
  int antx,anty;
  int smelltodrop,smellnow;

  for(AntNow=0;AntNow<MAX_ANT;AntNow++)
  {
    ant[AntNow].SpeedTimer+=timer10ms;
    if(ant[AntNow].SpeedTimer>=ant[AntNow].speed)
    {
      ant[AntNow].SpeedTimer = 0;
      gotoxy(ant[AntNow].xxx,ant[AntNow].yyy);
      putch(SPACE);
      AntOneStep();
      gotoxy(ant[AntNow].xxx,ant[AntNow].yyy);
      /* ant0 is a sepecail ant, use different color */
      if(AntNow==0) textcolor(0xd);
      if(ant[AntNow].food) putch(ANT_CHAR_FOOD);
      else putch(ANT_CHAR_EMPTY);
      if(AntNow==0) textcolor(0×7);

      /* remember trace */
      ant[AntNow].tracex[ant[AntNow].TracePtr] = ant[AntNow].xxx;
      ant[AntNow].tracey[ant[AntNow].TracePtr] = ant[AntNow].yyy;
      if(++(ant[AntNow].TracePtr)>=TRACE_REMEMBER) ant[AntNow].TracePtr = 0;

      /* drop smell */
      antx = ant[AntNow].xxx;
      anty = ant[AntNow].yyy;

      if(ant[AntNow].food)
      /* have food, looking for home */
     {
        if(ant[AntNow].SmellAmount[SMELL_TYPE_FOOD])
       {
          smellnow = Smell[SMELL_TYPE_FOOD][antx][anty];
          smelltodrop = ant[AntNow].SmellAmount[SMELL_TYPE_FOOD]*SMELL_DROP_RATE;
          if(smelltodrop>smellnow) Smell[SMELL_TYPE_FOOD][antx][anty] = smelltodrop;
          /* else Smell[…] = smellnow */
          ant[AntNow].SmellAmount[SMELL_TYPE_FOOD]-= smelltodrop;
          if(ant[AntNow].SmellAmount[SMELL_TYPE_FOOD]<0) ant[AntNow].SmellAmount[SMELL_TYPE_FOOD] = 0;
        } /* of have smell to drop */
      } /* of have food */
      else
      /* no food, looking for food */
     {
        if(ant[AntNow].SmellAmount[SMELL_TYPE_HOME])
       {
          smellnow = Smell[SMELL_TYPE_HOME][antx][anty];
          smelltodrop = ant[AntNow].SmellAmount[SMELL_TYPE_HOME]*SMELL_DROP_RATE;
          if(smelltodrop>smellnow) Smell[SMELL_TYPE_HOME][antx][anty] = smelltodrop;
          /* else Smell[…] = smellnow */
          ant[AntNow].SmellAmount[SMELL_TYPE_HOME]-= smelltodrop;
          if(ant[AntNow].SmellAmount[SMELL_TYPE_HOME]<0) ant[AntNow].SmellAmount[SMELL_TYPE_HOME] = 0;
        } /* of have smell to drop */
     }
    } /* of time to go */
    /* else not go */
  } /* of for AntNow */

  textcolor(FOOD_HOME_COLOR);
  gotoxy(home.xxx,home.yyy); putch(HOME_CHAR);
  gotoxy(food.xxx,food.yyy);
  if(food.amount>0) putch(FOOD_CHAR);
  else putch(FOOD_CHAR2);
  textcolor(7);

  gotoxy(1,MAXY+1);
  printf(“Food %d, Home %d   “,food.amount,home.amount);
}

void AntOneStep(void)
{
  int ddir,tttx,ttty;
  int i;

  ddir = ant[AntNow].dir;
  tttx = ant[AntNow].xxx;
  ttty = ant[AntNow].yyy;

  ddir = AntNextDir(tttx,ttty,ddir);

  switch(ddir)
  {
    case UP:  ttty–;
          break;
    case DOWN:  ttty++;
          break;
    case LEFT:  tttx–;
          break;
    case RIGHT: tttx++;
          break;
    default:  break;
  } /* of switch dir */

  ant[AntNow].dir = ddir;
  ant[AntNow].xxx = tttx;
  ant[AntNow].yyy = ttty;

  if(ant[AntNow].food)
  /* this ant carry with food, search for home */
  {
    if(tttx==home.xxx&&ttty==home.yyy)
    {
      home.amount++;
      AntInitial();
    }
    if(tttx==food.xxx&&ttty==food.yyy)
      ant[AntNow].SmellAmount[SMELL_TYPE_FOOD] = MAX_SMELL;
  } /* of search for home */
  else
  /* this ant is empty, search for food */
  {
    if(tttx==food.xxx&&ttty==food.yyy)
    {
      if(food.amount>0)
     {
        ant[AntNow].food = 1;
        food.amount–;
        ant[AntNow].SmellAmount[SMELL_TYPE_FOOD] = MAX_SMELL;
        ant[AntNow].SmellAmount[SMELL_TYPE_HOME] = 0;
        ant[AntNow].dir = TurnBack(ant[AntNow].dir);
        for(i=0;i<TRACE_REMEMBER;i++)
       {
          ant[AntNow].tracex[i] = 0;
          ant[AntNow].tracey[i] = 0;
       }
        ant[AntNow].TracePtr = 0;
        CanFindFood = 1;
      } /* of still have food */
    }
    if(tttx==home.xxx&&ttty==home.yyy)
      ant[AntNow].SmellAmount[SMELL_TYPE_HOME] = MAX_SMELL;
  }  /* of search for food */
}

void DealKey(char key)
{
  int i;
  switch(key)
  {
    case ‘p’:   gettime(&endtime);
          DispPlayTime();
          getch();
          gotoxy(1,MAXY+1);
          for(i=1;i<=MAXX-1;i++) putch(SPACE);
          break;
    case ‘t’:   if(SmellDispFlag)
        {
            SmellDispFlag=0;
            ClearSmellDisp();
        }
          else SmellDispFlag = 1;
          break;
    case ‘1′:   DispSmell(SMELL_TYPE_FOOD);
          getch();
          ClearSmellDisp();
          break;
    case ‘2′:   DispSmell(SMELL_TYPE_HOME);
          getch();
          ClearSmellDisp();
          break;
    case ‘3′:   DispSmell(2);
          getch();
          ClearSmellDisp();
          break;
    case ’s’:   SaveBlock();
       break;
    case ‘l’:   LoadBlock();
       break;
    default:  gotoxy(1,MAXY+1);
          for(i=1;i<=MAXX-1;i++) putch(SPACE);
  } /* of switch */
}

void ClearSmellDisp(void)
{
  int k,i,j;

  for(k=0;k<=1;k++)
  /* SMELL TYPE FOOD and HOME */
    for(i=1;i<=MAXX;i++)
      for(j=1;j<=MAXY;j++)
       {
          if(Smell[k][i][j])
        {
            gotoxy(i,j);
            putch(SPACE);
        }
        } /* of one location */
}

void DispSmell(int type)
/* input: 0 — Only display food smell
      1 — Only display home smell
      2 — Display both food and home smell
*/
{
  int k,i,j;
  int fromk,tok;
  int smelldisp;

  switch(type)
  {
    case 0: fromk = 0;
        tok = 0;
        break;
    case 1: fromk = 1;
        tok = 1;
        break;
    case 2: fromk = 0;
        tok = 1;
        break;
    default:fromk = 0;
        tok = 1;
        break;
  }
  SmellGoneTimer = 0;
  for(k=fromk;k<=tok;k++)
  /* SMELL TYPE FOOD and HOME */
    for(i=1;i<=MAXX;i++)
      for(j=1;j<=MAXY;j++)
       {
          if(Smell[k][i][j])
        {
            smelldisp = 1+((10*Smell[k][i][j])/(MAX_SMELL*SMELL_DROP_RATE));
            if(smelldisp>=30000||smelldisp<0) smelldisp = 30000;
            gotoxy(i,j);
            if(i!=food.xxx||j!=food.yyy)
          {
              if((i==food.xxx&&j==food.yyy)||(i==home.xxx&&j==home.yyy))
                /* don’t over write Food and Home */;
            else
           {
                if(smelldisp>9) putch(‘#’);
                else putch(smelldisp+‘0′);
           }
          }
        }
        } /* of one location */
}

int AntNextDir(int xxx,int yyy,int ddir)
{
  int randnum;
  int testdir;
  int CanGoState;
  int cangof,cangol,cangor;
  int msf,msl,msr,maxms;
  int type;

  CanGoState = CanGo(xxx,yyy,ddir);
  if(CanGoState==0||CanGoState==2||CanGoState==3||CanGoState==6) cangof = 1;
  else cangof = 0;
  if(CanGoState==0||CanGoState==1||CanGoState==3||CanGoState==5) cangol = 1;
  else cangol = 0;
  if(CanGoState==0||CanGoState==1||CanGoState==2||CanGoState==4) cangor = 1;
  else cangor = 0;

  if(ant[AntNow].food) type = SMELL_TYPE_HOME;
  else type = SMELL_TYPE_FOOD;

  msf = GetMaxSmell(type,xxx,yyy,ddir);
  msl = GetMaxSmell(type,xxx,yyy,TurnLeft(ddir));
  msr= GetMaxSmell(type,xxx,yyy,TurnRight(ddir));
  maxms = MaxLocation(msf,msl,msr);
  /* maxms - 1 - msf is MAX
         2 - msl is MAX
         3 - msr is MAX
         0 - all 3 number is 0 */

  testdir = NULL;
  switch(maxms)
  {
    case 0: /* all is 0, keep testdir = NULL, random select dir */
        break;
    case 1: if(cangof)
          testdir = ddir;
        else
          if(msl>msr) if(cangol) testdir = TurnLeft(ddir);
          else if(cangor) testdir = TurnRight(ddir);
        break;
    case 2: if(cangol)
          testdir = TurnLeft(ddir);
        else
          if(msf>msr) if(cangof) testdir = ddir;
          else if(cangor) testdir = TurnRight(ddir);
        break;
    case 3: if(cangor)
          testdir = TurnRight(ddir);
        else
          if(msf>msl) if(cangof) testdir =ddir;
          else if(cangol) testdir = TurnLeft(ddir);
        break;
    default:break;
  } /* of maxms */

  randnum = random(1000);
  if(randnum<SMELL_DROP_RATE*1000||testdir==NULL)
  /* 1. if testdir = NULL, means can not find the max smell or the dir to max smell can not go
     then random select dir
     2. if ant error, don’t follow the smell, random select dir
  */
  {
    randnum = random(100);
    switch(CanGoState)
    {
      case 0: if(randnum<90) testdir = ddir;
          else if (randnum>=90&&randnum<95) testdir = TurnLeft(ddir);
          else testdir = TurnRight(ddir);
          break;
      case 1: if(randnum<50) testdir = TurnLeft(ddir);
          else testdir = TurnRight(ddir);
          break;
      case 2: if(randnum<90) testdir = ddir;
          else testdir = TurnRight(ddir);
          break;
      case 3: if(randnum<90) testdir = ddir;
          else testdir = TurnLeft(ddir);
          break;
      case 4: testdir = TurnRight(ddir);
          break;
      case 5: testdir = TurnLeft(ddir);
          break;
      case 6: testdir = ddir;
          break;
      case 7: testdir = TurnBack(ddir);
          break;
      default:testdir = TurnBack(ddir);
    } /* of can go state */
  }
  return(testdir);
}

int GetMaxSmell(int type,int xxx,int yyy,int ddir)
{
  int i,j;
  int ms; /* MAX smell */

  ms = 0;
  switch(ddir)
  {
    case UP:  for(i=xxx-ANT_EYESHOT;i<=xxx+ANT_EYESHOT;i++)
            for(j=yyy-ANT_EYESHOT;j<yyy;j++)
          {
              if(!JudgeCanGo(i,j)) continue;
              if((i==food.xxx&&j==food.yyy&&type==SMELL_TYPE_FOOD)||
                 (i==home.xxx&&j==home.yyy&&type==SMELL_TYPE_HOME))
           {
                ms = MAX_SMELL;
               break;
           }
              if(IsTrace(i,j)) continue;
              if(Smell[type][i][j]>ms) ms = Smell[type][i][j];
          }
          break;
    case DOWN:  for(i=xxx-ANT_EYESHOT;i<=xxx+ANT_EYESHOT;i++)
            for(j=yyy+1;j<=yyy+ANT_EYESHOT;j++)
          {
              if(!JudgeCanGo(i,j)) continue;
              if((i==food.xxx&&j==food.yyy&&type==SMELL_TYPE_FOOD)||
                 (i==home.xxx&&j==home.yyy&&type==SMELL_TYPE_HOME))
           {
                ms = MAX_SMELL;
               break;
           }
              if(IsTrace(i,j)) continue;
              if(Smell[type][i][j]>ms) ms = Smell[type][i][j];
          }
          break;
    case LEFT:  for(i=xxx-ANT_EYESHOT;i<xxx;i++)
            for(j=yyy-ANT_EYESHOT;j<=yyy+ANT_EYESHOT;j++)
          {
              if(!JudgeCanGo(i,j)) continue;
              if((i==food.xxx&&j==food.yyy&&type==SMELL_TYPE_FOOD)||
                 (i==home.xxx&&j==home.yyy&&type==SMELL_TYPE_HOME))
           {
                ms = MAX_SMELL;
               break;
           }
              if(IsTrace(i,j)) continue;
              if(Smell[type][i][j]>ms) ms = Smell[type][i][j];
          }
          break;
    case RIGHT: for(i=xxx+1;i<=xxx+ANT_EYESHOT;i++)
            for(j=yyy-ANT_EYESHOT;j<=yyy+ANT_EYESHOT;j++)
          {
              if(!JudgeCanGo(i,j)) continue;
              if((i==food.xxx&&j==food.yyy&&type==SMELL_TYPE_FOOD)||
                 (i==home.xxx&&j==home.yyy&&type==SMELL_TYPE_HOME))
           {
                ms = MAX_SMELL;
               break;
           }
              if(IsTrace(i,j)) continue;
              if(Smell[type][i][j]>ms) ms = Smell[type][i][j];
          }
          break;
    default:  break;
  }
  return(ms);
}

int IsTrace(int xxx,int yyy)
{
  int i;

  for(i=0;i<TRACE_REMEMBER;i++)
    if(ant[AntNow].tracex[i]==xxx&&ant[AntNow].tracey[i]==yyy) return(1);
  return(0);
}

int MaxLocation(int num1,int num2,int num3)
{
  int maxnum;

  if(num1==0&&num2==0&&num3==0) return(0);

  maxnum = num1;
  if(num2>maxnum) maxnum = num2;
  if(num3>maxnum) maxnum = num3;

  if(maxnum==num1) return(1);
  if(maxnum==num2) return(2);
  if(maxnum==num3) return(3);
}

int CanGo(int xxx,int yyy,int ddir)
/* input: xxx,yyy - location of ant
      ddir - now dir
   output: 0 - forward and left and right can go
       1 - forward can not go
       2 - left can not go
       3 - right can not go
       4 - forward and left can not go
       5 - forward and right can not go
       6 - left and right can not go
       7 - forward and left and right all can not go
*/
{
  int tx,ty,tdir;
  int okf,okl,okr;

  /* forward can go ? */
  tdir = ddir;
  tx = xxx;
  ty = yyy;
  switch(tdir)
  {
    case UP:  ty–;
          break;
    case DOWN:  ty++;
          break;
    case LEFT:  tx–;
          break;
    case RIGHT: tx++;
          break;
    default:  break;
  } /* of switch dir */
  if(JudgeCanGo(tx,ty)) okf = 1;
  else okf = 0;

  /* turn left can go ? */
  tdir = TurnLeft(ddir);
  tx = xxx;
  ty = yyy;
  switch(tdir)
  {
    case UP:  ty–;
          break;
    case DOWN:  ty++;
          break;
    case LEFT:  tx–;
          break;
    case RIGHT: tx++;
          break;
    default:  break;
  } /* of switch dir */
  if(JudgeCanGo(tx,ty)) okl = 1;
  else okl = 0;

  /* turn right can go ? */
  tdir = TurnRight(ddir);
  tx = xxx;
  ty = yyy;
  switch(tdir)
  {
    case UP:  ty–;
          break;
    case DOWN:  ty++;
          break;
    case LEFT:  tx–;
          break;
    case RIGHT: tx++;
          break;
    default:  break;
  } /* of switch dir */
  if(JudgeCanGo(tx,ty)) okr = 1;
  else okr = 0;

  if(okf&&okl&&okr) return(0);
  if(!okf&&okl&&okr) return(1);
  if(okf&&!okl&&okr) return(2);
  if(okf&&okl&&!okr) return(3);
  if(!okf&&!okl&&okr) return(4);
  if(!okf&&okl&&!okr) return(5);
  if(okf&&!okl&&!okr) return(6);
  if(!okf&&!okl&&!okr) return(7);
  return(7);
}

int JudgeCanGo(int xxx,int yyy)
/* input: location to judeg
   output: 0 — can not go
       1 — can go
*/
{
  int i,j;

  if(xxx<=0||xxx>MAXX) return(0);
  if(yyy<=0||yyy>MAXY) return(0);
  if(block[xxx][yyy]) return(0);
  return(1);
}

int TurnLeft(int ddir)
{
  switch(ddir)
  {
    case UP:  return(LEFT);
    case DOWN:  return(RIGHT);
    case LEFT:  return(DOWN);
    case RIGHT: return(UP);
    default:  break;
  } /* of switch dir */
}

int TurnRight(int ddir)
{
  switch(ddir)
  {
    case UP:  return(RIGHT);
    case DOWN:  return(LEFT);
    case LEFT:  return(UP);
    case RIGHT: return(DOWN);
    default:  break;
  } /* of switch dir */
}

int TurnBack(int ddir)
{
  switch(ddir)
  {
    case UP:  return(DOWN);
    case DOWN:  return(UP);
    case LEFT:  return(RIGHT);
    case RIGHT: return(LEFT);
    default:  break;
  } /* of switch dir */
}

written by Minidxer \\ tags: ACO, ant, colony, optimization, 原理, 源代码, 算法, 蚁群算法

Related Post

• 汉诺塔算法的递归与非递归的C以及C++源代码
• 约瑟夫环问题(Josephus)的两种解法（源代码）
• flexexamples.com–一个非常不错的Flex学习站点
• 一个有用的Java log输出函数
• 经典算法集合帖–2008-02-16
• 自己实现strtok函数（源代码）
• 二分搜索算法(折半查找)原理以及递归（recuition），迭代（iteration）的两种实现源代码
• DES加密标准的说明以及加密/解密函数的实现源代码
• Stein算法的简单描述以及C++/Java的三种实现源代码
• 欧几里德算法的简单描述以及C++与Java的各自实现(源代码)
• 几种经典的Hash算法的实现(源代码)
• Dwing写的471字节俄罗斯方块(teris)汇编程序源代码

究竟什么是Silverlight？对不同的角色，Silverlight的定义或许会不一样。

 

对于互联网用户来说，Silverlight是一个安装简单的插件程序。用户只要安装了这个插件程序，就可以在Windows和Macintosh上多种浏览器中运行相应版本的Silverlight应用程序，享受视频分享、在线游戏、广告动画、交互丰富的网络服务等等。

 

 

 

 

对于开发设计人员而言，Silverlight是一种融合了微软的多种技术的Web呈现技术。它提供了一套开发框架，并通过使用基于向量的图像图层技术，支持任何尺寸图像的无缝整合，对基于ASP.NET、AJAX在内的Web开发环境实现了无缝连接。Silverlight使开发设计人员能够更好的协作，有效地创造出能在Windows和Macintosh上多种浏览器中运行的内容丰富、界面绚丽的Web应用程序——Silverlight应用程序。

 

简而言之，Silverlight是一个跨浏览器、跨平台的插件，为网络带来下一代基于.NET媒体体验，和丰富的交互式应用程序。对运行在Macintosh和Windows上主流浏览器，Silverlight提供了统一而丰富的用户体验。通过Silverlight这个小小的浏览器插件，视频、交互性内容，以及其他应用能完好的融合在一起。

 

Silverlight为用户提供了低成本、高质量的流媒体解决方案。它采用荣获Emmy奖的Windows Media技术，使同等质量的视频传输流量下降了约46%，并与现有的Windows Media流量配置方案兼容。如果采用下一代Windows Server （Longhorn）系统中的IIS媒体包，流量还可能会进一步下降。

 

 

Silverlight的安装包本身已经包含了Windows Media的解码技术。因此，在客户端的操作系统中，不需要安装任何Windows Media Player等软件，就可以播放 WMV，VC-1，WMA和MP3等多种从高清质量到移动设备的视频以及音频。

 

Silverlight还提供了新的基于视频和动画的广告策略方案，可以在视频上增加视频、动画或其他交互性内容，使视频动画同步播放而不影响视频质量。

 

 

作为一个客户端的插件，Silverlight对于服务端没有任何要求。无论是Windows+IIS+SQL Server+ASP.NET的WISA架构，或是Linux+Apache+MySql+PHP的LAMP架构，或者其他CGI架构，都可以使用Silverlight，而不用作特别配置。Silverlight还可以和现有的网站设计融洽共处。

 

Silverlight支持LINQ和LINQ to XML等技术，以及JSON，RSS，POX，REST等常见协议，从而可以方便的获得数据，实现服务与数据的混合。Silverlight的页面描述采用了基于文本的XAML文件格式，可以实现搜索引擎优化，使富交互式应用程序的内容能被索引并搜索到。而通过Windows Live提供的Silverlight Streaming，可以快速发布并集成软件服务和富媒体的内容。

 

 

Silverlight基于.NET框架提供了灵活的编程模型。Silverlight 1.1包含了WPF（Windows Presentation Foundation）的一个子集，利用Microsoft .NET Framework 3.0中的呈现技术 XAML使Silverlight和基于Windows应用程序的表现层保持一致。从版本1.1开始，Silverlight的开发支持JavaScript, .NET托管语言和动态语言等多种编程语言。

 

Silverlight还提供了一系列工具。通过Microsoft Expression Studio，设计人员可以创建出交互式的用户接口和富媒体体验，为视频媒体进行编码和发布，并创建出符合W3C标准的网络站点。而对于开发人员，Microsoft Visual Studio 2008提供了丰富编程语言支持，强大的跨平台调试功能。并通过Microsoft Intellisense协助开发人员进行客户端和服务端的快速编码开发。因此，无论是开发人员和设计人员，都可以运用已有的技巧和工具，将Silverlight集成到现有的网络应用中。

 

虽然Silverlight目前还处于测试版本阶段，它已和国内外多家公司建立了合作关系。比如美国最大的棒球联盟MLB已采用Silverlight播放其网站上的部分视频。为20th Centry Fox、Sony Pictures Television等著名国际公司提供网络电视服务的Maven Networks也将把Silverlight带入自己的网络电视平台。作为2008年奥运会官方互联网赞助商的搜狐公司也与微软合作，打算使用Silverlight来完成互联网上的奥运火炬传递项目。相信不久，随着Silverlight 1.0的正式发布，互联网用户将会有更多的机会体验到Silverlight所带来的精彩的媒体体验和丰富的交互性内容。

 

 

1．版本：Silverlight目前推出了1.0 RC和1.1 Alpha两个版本。Silverlight 1.0版本重点重点在于丰富的界面及视频体验，支持JavaScript的编程开发；而Silverlight 1.1除了包含Silverlight 1.0的特性之外，还支持对.NET托管语言以及动态语言进行Silverlight应用程序开发的。

 

2．操作系统：Silverlight目前所支持的操作系统包括：Windows Vista，Windows XP，Windows Server 2003，Mac OS X 10.4，以及Mac OS X Leopard；Silverlight 1.1即将支持Windows 2000操作系统。

 

3．浏览器：Silverlight目前支持的浏览器包括IE 6，IE 7，Firefox 2.0，Firefox 1.5，Safari 2.0。Silverlight 1.1即将支持Opera浏览器。

 

4． 编程语言：Silverlight 1.0支持JavaScript，而Silverlight 1.1目前支持Visual C#, Visual Basic, Jscript和IronPython，很快将支持Ruby以及VBx的编程开发。

 

下图给开发人员提供了更完整的参考：

 

 

关于更多Silverlight的内容，可以访问以下站点：

1．Silverlight全球官方社区 http://www.silverlight.net

2．Microsoft Silverlight官方主页 http://www.microsoft.com/silverlight

3．Microsoft Silverlight开发中心 http://msdn.microsoft.com/silverlight

Posted by SilverlightShanghai | 1 Comments

目前的大部分 WebGIS 都已经使用了 Ajax ，下一步的发展方向是什么呢？ IT 技术的发展是 GIS 的重要推动力量，让我们来看看 MS,Google,Adobe 等领导者的动向，也许能够获得很多启发。

　　关键词：MS SliverLight，Adobe Apollo，Google Gear

　　RIA是Rich Internet Applications的缩写，翻译成中文为富因特网应用程序（Macromedia中文网站翻译为Rich Internet应用程序）

　　传统网络程序的开发是基于页面的、服务器端数据传递的模式，把网络程序的表示层建立于HTML页面之上，而HTML是适合于文本的，传统的基于页面的系统已经渐渐不能满足网络浏览者的更高的、全方位的体验要求了，这就是被Macromedia公司称之为的“体验问题”（"Experience Matters"），而富因特网应用程序（Rich Internet Applications，缩写为RIA）的出现也就是为了解决这个问题。

　富因特网应用程序的发展阶段图如下：

  

　　富因特网应用程序是下一代的将桌面应用程序的交互的用户体验与传统的Web应用的部署灵活性和成本分析结合起来的网络应用程序。富因特网应用程序中的富客户技术通过提供可承载已编译客户端应用程序（以文件形式，用HTTP传递）的运行环境，客户端应用程序使用异步客户/服务器架构连接现有的后端应用服务器，这是一种安全、可升级、具有良好适应性的新的面向服务的模型，这种模型由采用的Web服务所驱动。结合了声音、视频和实时对话的综合通信技术使富因特网应用程序（RIA）具有前所未有的网上用户体验。

　　“富”的概念包含两方面，分别是数据模型的丰富和用户界面的丰富。数据中的“富”意思是用户界面可以显示和操作更为复杂的嵌入在客户端的数据模型，它可以操作客户端的计算和非同步的发送接收数据。这种模式相对于传统的HTML页面的优点是程序运行于客户端，并且程序更多的是和用户进行交互，同时更少的和服务器进行交互。平衡客户端和服务器端的复杂的数据模型可以让你有更大的空间去创建更高效和更具有交互性的网络应用程序。“富”同样也描述了全面提升的用户界面，HTML只给用户提供了非常有限的界面控制元素，而富因特网应用程序（RIA）的用户界面提供了灵活多样的界面控制元素，这些控制元素可以很好的与数据模型相结合。传统的因特网模型使用线性的设计，提供给用户一些选择然后用户发送选择结果给服务器，这种单一的模式不符合应用程序的灵活交互的要求和用户的意愿。频繁的服务器请求和页面刷新有很多的缺点，包括页面打开缓慢和降低网络带宽。如果采用富客户界面，可以从以前的服务器响应影响整个界面，转移到只有收到请求的应用程序部分才会做出相应的变化。这本质上意味着界面被分解成许多独立的模块，这些模块都会对收到的信息做出相应的反应，有些会和服务器端进行交互，有些是这些模块之间的通信。 

RIA的应用程序模型 :

    

　　说了这么多，可能比较抽象，但如果说Adobe Applo(FLASH), SilverLight(WPF)等，大家其实已经或多或少都听说了，如今，一个新的竞争者Google Gear又加入了这场大战，让我们觉得RIA的世纪很快就会到来，Web终于迎来了等待已久的技术革新。

　　虽然现在Google Gear的功能比较薄弱，只有3个看似比较鸡肋的features，但我相信，很快，google会给它们自己的这个RIA平台加入更多platform indepdent的功能，使其发展成为一套完整的能够承载大型RIA应用的framework。 字串7

　　个人认为，按照相同重量级的对手之间的竞争态势来看，现在真可谓是天下三分：MS SliverLight，Adobe Apollo，Google Gear。

MS SliverLight：
　　微软的霸道可见一斑；什么都是另起炉灶，丝毫不考虑技术的可延续性。更多的将原来的Desktop Developer拉到了SilverLight的大旗下，却从不考虑Web Developer的处境。

 

　　优势：凭借MS强大的捆绑能力，毫无疑问，短时间内SliverLight会成为互联网上普及程度仅次于Flash Player的第二大“插件”。由于MS对windows的掌握程度，很容易在SilverLight中加入很多其他RIA平台中无法具备的能力，如Powerful 3D accelerate，集成WCF的通讯能力等等与windows紧密相关的能力。

 

　　劣势：由于SliverLight的强大的Windows相关的能力，很难在非Win平台上大有作为，非win平台的SliverLight很可能就是被阉割过的Compact版本，所以cross platform无从谈起。同时，由于MS在Web领域的积累不够，短时间内无法出现能够体现RIA优势的应用，导致SliverLight缺少Kill app的支撑，让Developer信心不足；并且SliverLight对于现有的应用没有考虑任何的可移植性，新的XAML，新的C#，VB.net等等这一切，都让原本的Web Frontend Engineer无法在短时间内选择SliverLight作为RIA开发的第一平台。

Google Gear：
　　这个出生的婴儿，看起来丝毫不像一个RIA平台，可是细细品味，能够体会到Google对Web开发阵营的真心体贴，假以时日，这个所谓的Browser Plugin必将一飞冲天。 字串5

　　优势：Google作为一个实实在在的Internet公司，对于Web产品以及技术的理解是前无古人的。Gear很好的作为一个已有Web Broswer的Plugin而存在，真正的体现了“RIA是Web的一种延伸”这句话。Google并不急于开发一种承载RIA的特殊浏览器，甚至一个基于Google Service的特殊操作系统；而是实实在在的将RIA这种变革带伴随着的技术升级的阵痛减到了最小的程度，让现有已经存在的Web application能够基于Gear开发一些更多的feature，保护现有Web application的投资，采用一种和蔼可亲的方式将RIA的承载平台贯彻到每家每户。而不会说：“你只要不下载我的runtime，对不起，您根本无法使用这个应用程序”。这样的做法，对于开发者和用户来说，都是乐于让人接受的事实。 字串8

　　劣势：正因为Google作为一个Internet公司，所以他失去了Desktop的话语权，导致Google的任何一个产品都只能考虑从Web通过浏览器一步一步的爬到Desktop上来；同时由于Google Gear对于cross platform的支持考虑，所以只能使用一些平台无关的api，同时，无法改变的是，基于浏览器的javascript interpreter确实非常低效，导致Gear很难让用户感觉到如同SliverLight能够提供的那种惊艳的感觉，取而代之的还是稍显死板生硬的加强版Web application。现阶段Gear的不完善性，比起SliverLight与Apollo来说还是太过幼稚，只能通过时间来弥补。 字串1

Adobe Apollo：
　　Macromedia这个公司，加入Adobe之后，凭借Adobe在电子出版界长久以来的地位与技术积累，在Flash中加入很多增强的PDF相关技术之后，可以说提供了一套完整的RIA方案，目前最完美的Full features support RIA platform非他莫属了。 字串7

　　优势：凭借Flash的表现能力，PDF的普及程度，可以说我们需要的RIA特性都包含在了Apollo之中，虽然现在Apollo还处于Alpha阶段，但是由于世界范围内众多Flash Player与Web developer的支持，Apollo还真是一点都不愁不红。或许对于开发者来说，心底的呼声就是：“我们一直想要一个这样的东西呢！” Flash/Xhtml+javascript这两种比较成熟的技术，Adobe在外面包了一层Apollo的皮，这就能够圆满的完成Web application -> RIA application的进化；这样的进化成本较低，效果较为明显，所以不难解释Apollo是如此的收到欢迎。再加上Flex这个Adobe的后期之秀，Adobe不仅要让Flash爬到桌面来，而且还要于SliverLight展开竞争；同样的MXML v.s. XAML ，c#/.net language v.s. actionscript3，势必非要争出个你死我活。

 

　　劣势：我真是想不出Apollo的劣势，因为通过Apollo的相关技术，我无法推导出Apollo有什么错。如果非要说一个的话，还是cross platform带来的对于hardware acclerate方面的牺牲，似乎这不是劣势。唯一担心的就是Apollo与MS的Sliverlight在Desktop展开正面冲突，其结果是否会由于技术无关的因素而吃亏，不得而知……或许如果Apollo能够作成Google Gear那样的浏览器插件，就真的是完美了。

 

　　PS：其他的相关RIA平台，由于重量级不够，没有列入详细的介绍；如Sun JavaFX, Mozilla FireFox3等等。有兴趣的读者，可以自己搜寻相关资料。

 

 

 

开发者在线 Builder.com.cn 更新时间:2007-09-07作者：Tim O'Reilly 来源:互联网周刊

 

 

 

 

 

 

Mashup -- SOA 的发展之路: Web 2.0 和基础概念

Web 2.0 是一个非常广泛的主题，为了简单起见，本文综合了各种不同组件，以便为在本系列文章的第 2 部分和第 3 部分中更详细地讨论 SOA、环境应用程序和 IBMMSK 设置一个平台。有关 Web 2.0 的更广泛、更详细的描述，请参阅 Tim O'Reilly 撰写的文章，在本文最后的参考资料部分提供了该文章的链接。

什么是 Web 2.0 呢？

相关内容

IBM Mashup Starter Kit:Start building Web 2.0 applications right now!
The ultimate mashup -- Web services and the semantic Web series
SOA meets situational applications, Part 1:Changing computing in the enterprise
developerWorks 访谈：Taking Web 2.0 into the enterprise
The future of SOA -- A service-based delivery model with Web 2.0 capabilities
Play in the IBM SOA Sandbox


可以将 Web 2.0 描述为一组核心的模式，在属于 Web 2.0 范畴的应用程序中，可以观察到这些核心模式。这些模式分别是服务、简单性和社区（请参见图 1 中对它们的表示）。本文在介绍这些模式之后，还探讨了一些支持它们的技术。

 

图 1. Web 2.0 应用程序展示了这三个模式



服务

要想真正地为 Web 社区（这也是 Web 使用和应用程序开发的新阶段的基础承租者）授权，社区首先必须能够共享对给定应用程序的公共访问方法。为促进这项工作的完成，应用程序正逐步过渡一种服务模型，其中所有的用户都可以对一个实例进行访问。而不是每个用户必须分别下载并安装应用程序。此外，这个共享的服务模型提供了单一沙箱，以保证社区机制的有效性。

简单性

面向开发人员的简单性：对于某些应用程序来说，软件变得越来越容易使用和开发，这得益于开放的行业标准和功能强大的技术的门槛降低。从而增加了开发人员的数量以及可用的 Web 应用程序。从创建社区 的角度而言，这个方面单独就可以发挥很大的作用。

面向用户的简单性：您还可能注意到，现在的 Web 应用程序提供了丰富的内容和用户体验，并且随着 Asynchronous JavaScript + XML (Ajax) 的出现，传统的独立客户端或者瘦客户端与 Web 应用程序之间的界线现在已经变得模糊不清，甚至完全消失了。当前的 Web 应用程序不再需要像 Web 1.0 那样重新加载页面以浏览新的内容，就可以提供丰富的、交互式的用户体验。

由于 feed 相关技术的成功（将在本文后面的内容中对其进行描述），用户现在可以订阅聚合的内容，这些内容提供了他们希望通过行业标准技术和协议得到的特定信息。现在，feed 允许采用特定的格式来包装并交付信息，这使得可以很容易地对信息进行使用和重新混合。有时，软件需要独立于信息而存在，以便信息能够实现它的最大价值，而上述的功能正好可以满足这种趋势（因此，我们将重点关注于信息，而不是功能）。其结果是，服务所有者将会发现，他们所提供的信息正以完全出乎他们预料的方式被高效地使用。

 

社区机制

对于我们组织、访问和使用信息的方式，Web 已经创造了巨大的社会变革。Wikipedia（有关其链接，请参见参考资料）就是其中的一个例子，它允许人们一起工作、以协同的方式捕获并管理信息，并且速度远远超过单个个体完成同一任务所能达到的速度。它允许快速地添加信息，但是会大大地增加可用信息的总量，所以这一点既有好的一面，也有不好的一面。这使得您在查找所需的信息时非常困难，因而需要使用附加的社区机制来帮助筛选相关的信息，以便用户能够使用有意义的、易于搜索的元数据对信息进行标记。del.icio.us（有关其链接，请参见参考资料）就是其中的一个例子，它允许用户联机存储并标记他们的书签。这允许其他用户通过标记来搜索书签列表，从而提供一种在已经由该社区进行了书签标记的（经过筛选的）数据中查找相关结果的方式。

社区数据的完整性：另一个紧迫的问题是，需要检查社区所提供的数据的完整性。可以使用同一个社区来提供有价值的信息。用户可以添加、编辑相关的注释以及建议，并且可以对这些注释和建议进行聚合，以便为给定的资源提供社区的集体观点，从而真实地创建一个既可以读取、又可以写入的 Web。这种模型还可以用于在提供者和使用者之间创建紧密的反馈环节；例如 eBay（有关其链接，请参见参考资料）上买家和卖家的等级系统。您可以利用社区的这种紧密反馈环节来改进软件的开发过程。现在，用户社区可以参与到软件的开发工作中，从而将软件作为一种不断更新的服务（随着越来越多的使用，不断地进行改进）来提供。

 

实现人与人之间的连接：可以更进一步利用社会网络的特性，以定位和管理不同种类的资源，即相关的人员。对于定位共享公共主题的人员来说，社会网络是一种功能很强大的方式。例如，这些网络允许参加了某个特定中学的人或者属于某个特定行业社团的人，在他们自己的 Web“空间”中实现共享、联网、甚至协作。此外，在这些网络中可以实现相当程度的自治，网络中的用户可以添加并邀请其他用户登录到该网络中，从而不断增加它的价值。这与 Web 1.0 是完全不同的，Web 1.0 重点关注计算机之间的连接，而不是人与人之间的连接。

长尾和更宽松的许可协议：关于 Web 2.0 应用程序，还有其他一些值得注意的方面，它们更关注于提供长尾 (The Long Tail)（有关更多的信息，请参见参考资料）而不仅仅只是服务于受众，它们通过使用相关的技术服务更多的受众，并为他们提供高度个性化的产品或服务。此外，因为 Web 1.0 重点关注于可下载的应用程序，所以对于如何使用该应用程序，其许可协议是非常严格的（即“保留所有权利”）；而对于 Web 2.0，它们通常鼓励与其他技术、内容和应用程序进行集成（即“保留某些权利”）。

我们可以在一些常见的 Web 2.0 旗舰网站中看到这些模式，如 Digg，它使用社区机制对信息进行添加、分类和注释；YouTube，它允许用户采用对他们来说有意义的，并且其他用户可以很容易地进行搜索的方式，对多媒体信息进行标记；Facebook，它允许用户构建社会网络，并在其中进行交互。

 

是什么技术促进了 Web 2.0 的模式和概念呢?

　　向基于服务的模型的过渡，暗示了 Web 2.0 应用程序现在的发展程度。现在，Web 基础设施被看作应用程序开发堆栈的最底层(相对于可下载应用程序的服务器)。然后，利用可编程的 Web 作为用于构建 Web 2.0 应用程序的 API。这些 API 的示例都是公开可访问的 Web 服务，如 Flickr、Google Maps 和 Digg。

　　对于创建 Web 应用程序来说，Linux®、Apache、MySQL 和 PHP (LAMP) 应用程序开发堆栈是一种流行的、免费的、快速的并且容易的方法。该方法有助于降低创建有价值的 Web 应用程序的门槛，从而为 Web 开发人员提供了一个更广阔的基础。LAMP 堆栈是当前的新一代技术，它始终运行于大部分 Internet 中。

　　Web 就是您的新平台，这个概念建立在一个前提条件的基础之上，即大部分基础设施已经建立，并且当前存在于 Web 中。新的 Web 2.0 应用程序仅需要利用现有的可用宿主，而无需使用传统的 API 层，如 Java™ 平台、Enterprise Edition (Java EE) 或者 Microsoft® .NET，您现在可以使用由现有 Web 应用程序(如 Flickr 和 Google Map)公开的基于 Web 的 API(或者 Web 服务)来构建应用程序。这些 Web API 的流行使您避免了创建某些特性的工作，从而减轻了您的工作负担，所以您可以更快地构建您的应用程序。

此外，您可以集成两个或者更多的 Web API，以创建某种新的或者独特的特性，这被称为 mashup。例如，您可以使用 www.housingmap.com 在地图(由 Google Maps 提供的)中显示房地产信息(由 Craigslist 提供的)的方式，以便进行可视化导航，并筛选给定位置的房地产信息。　　图 2 和图 3 对 Web 2.0 的基础设施进行了分解。
　　图 2. Web 2.0 堆栈中的关键技术
　　
　　图 3. 传统的应用程序开发堆栈与可编程 Web 的对比
　　

 

然后，可以使用某些技术(如 Ajax)来调用这些基于 Web 的 API，这些技术为浏览器客户端通过 JavaScript(包括同步方式或者异步方式)与服务器进行通信提供了相应的方法。这意味着，应用程序并不需要在客户端每次与服务器通信的时候都重新加载整个页面。

　　您可以使用 JavaScript Object Notation (JSON) 实现对象的序列化和反序列化，使得能够在浏览器客户端和服务器之间，通过 Ajax 来发送它们。与 Ajax 非常相似，您还可以使用 SOAP 规范和代表性状态传输(Representational State Transfer，REST)方法来提供在应用程序之间传输数据的行业标准方式。经常可以看到，现有的服务提供了 SOAP、Ajax 和 REST 接口。

　　REST 是一种设计服务的风格，它使用了针对 URL 可编址实体的简单 HTTP 操作。

　　一些其他的技术，如 Dojo(它是一个可以节约时间的、开放源代码的、跨浏览器的动态 HTML (DHTML) 工具包)和浏览器扩展，如 Greasemonkey 和 Firebug(允许您编写扩展浏览器、定制 Web 页面外观或功能的脚本)，现在都可以利用 Ajax，并提供丰富的用户界面。例如，您可以为 Facebook 安装一个 Greasemonkey 脚本，当您将鼠标指针移动到缩略图上时，完整的图片将自动地出现在浏览器窗口的左侧。这使得查看图像既快速又方便，并且丰富了用户的体验。

 

Microformat 允许您使用 XHTML 在 (X)HTML、Atom、RSS 或者任意 XML 文档中表达语义信息。microformat 是一种机器和人类都可读的应用程序，比如，浏览器可以自动地发现它们，并对它们所描述的信息进行操作。例如，如果您希望在文档中嵌入一张名片，那么您可以使用 hcard microformat(有关更多的信息，请参见参考资料)，它将使用 XHTML 来描述您的名片(请参见图 4)。　　图 4. hcard microformat 的示例
　　
　　最后，RSS 和 Atom feed 现在已经不仅仅用于订阅 Blog 和新闻 feed，我们还将其作为一种潜在的方法，用以简化特定的、以内容为中心的应用程序体系结构。Atom 规范是一种最新的发展(其思想最初来自于 RSS)，并且提供了一些有价值的特性，如 Atom Publishing Protocol (APP)，它允许您发布要添加到 feed 的信息。如果事件驱动的体系结构现在是 SOA 框架中的组成部分，那么可以将 feed 看作是服务范例中的部分，并对其进行充分利用。
　　在本文中，您了解了 Web 2.0 应用程序中包含的核心模式、概念和关键技术。在第 2 部分中，您将了解企业中的 IT，并研究 mashup 生态系统如何允许您构建环境应用程序，以改进当前技术水平。

 

阿蒙神




阿蒙神标志，AMON (Amen, Amun, Ammon, Amoun)

象征：公牛， 牧羊或是鹅，他是底比斯的守护神。通常他具有人的模样，被认为是最原始的创始神。 追溯到埃及第七王朝阿蒙神在底比斯不过是地位一般的神而已。但是当底比斯的王子征服了他的对手成为埃及的统治者，并且把他们的城市变为埃及的新首都时，阿蒙神就成为了埃及最主要的神祗。很可能就是在那个时期他被称为我们后来所说的“众神之王”。 在埃及阿蒙神享有很高的政治地位，同时他也受普通百姓的喜欢。他被认为是穷人的大臣，他保护弱者，主持正义。向阿蒙神请求帮助的人先必须证明自己的价值或是承认自己的罪行。通常，神的力量可以为法老的统治添加光环。然而，当阿蒙神开始普及时，他的祭司却拥有了与日俱增的影响力和财富。因此，他们开始尝试涉足于政治领域。当埃及女王在阿蒙神的祭司中寻找支持者时，她称阿蒙神为她的父亲，并且以阿蒙神的名义为自己修建庙宇。具有讽刺意义的是，这样的政治策略却毁坏了阿蒙神的声望。在萨特摩西思四世时期,埃及皇室开始了一场用更纯净的方式对太阳神表示崇敬的运动。这样的情景在阿克海那顿统治时到达了顶点。 根据后来的传统，阿蒙神是自己创造自己的神。他的妻子是穆特女神，他的儿子是月亮之神空斯。

拉神




拉神标志，RE (Ra)

象征：为凤凰，金字塔，太阳。在第五王朝时期拉神被认为是正式的神祗。传说中，是拉神创造了人类，埃及人称曾自己为拉神的牛犊。拉神(Re)这个名字寓意为"创造的力量",更准确的解释是“创造者”。在埃及早期历史中，拉神和荷鲁斯神是相区别的。荷鲁斯神代表天空的崇高，通常是鹰或是鹰头人身为化身。而拉神则被称为地平线上的荷鲁斯，由此不难看出，二者同样都显示了古埃及人对太阳的崇拜。 太阳代表着火，埃及人认为要想在天堂和冥间游走必须要有一条船，而拉神就乘着这样的一艘船。拉神在旅途中有很多陪伴者，一些神帮助他驾驶船只以确保旅行的顺利。拉神和迈特神站在荷鲁斯神的两边，荷斯掌舵，他是这艘船的船长。在船头，两只领航的鱼分别叫做"Abtu" 和 "Ant".其他的乘客还有：Geb, Hu, Sia 和 Hike . 夜晚的时候，Upuaut神就勇敢的站在船头。 然而，此次旅途并不是一帆风顺的。怪物Sebau, Nak, 和Apep会想方设法的阻止这艘船。其中Apep是最强大的一个，他是黑暗的化身 。拉神必须在每天早上他从东方出现之前打败他。Apep被描绘为毒蛇或是鳄鱼。当Apep得逞时，暴风雨就会来临，当他完全吞没船只时，日食就会出现。 一本名为《打倒Apep》的书中具体介绍了击败Apep的方法和咒幅，在底比斯神庙人们每天都要颂读此书。后来的一段时期，当伊希斯和奥西里斯在声望上超过拉神时，他仍然保留着“伟大的上天之神”的称号。

赛克美特




克美特标志，SEKHMET (Sekhet, Sakhmet, Nesert)

象征：母狮面容、眼镜蛇等。 祭祀中心在孟菲斯。 赛克美特是母狮头的女神，主司战争和破坏。她是普塔哈神的妻子。她被造成拉神眼睛里的火。拉神创造她是作为武器利用男人的软弱去攻击男人。在一次赛克美特释放能量造成的极大破坏之后，埃及人惧怕她再次施行破坏，于是发展了精细的祭祀以期赛克美特平息怒火。在典礼上出现了超过700尊女神的雕像。祭祀活动持续很久，埃及人对赛克美特的祭祀活动似乎没有总结的一天。 赛克美特通常被描述成母狮头的女性，她的名字“Sekhmet”来源于“sekhem”字根，这个字代表强大、有势力和强烈。 赛克美特常被认为是和巴斯泰托女神一样的地位。她们分别称为西方和东方的女神。她俩的头像也常常被描述为狮头。但巴斯泰托穿着绿色衣服，赛克美特身穿红色。

奥西里斯




奥西里斯标志，OSIRIS (Asar, Wesir, Ausar, Unnefer)

象征：手持王杖和连枷、带着假胡子，被描述成木乃伊国王的形象。 他是地下世界之神和复活之神。 丰饶之神，文明的赐予者。冥界之王，执行人死后是否可得永生的审判。一般在壁画中，若脸上涂有绿色颜料，则表示在复活中或已经复活。它的崇拜仪式起于阿拜多斯(Abydos)，因此那里有许多它的神庙。它变得受欢迎是在中王国以后，十八王朝时它可能是最广泛被崇拜的神祇，同时，持续到晚期埃及。奥西里斯，是象征地球和农业的神明，每年的干旱被视为他的死亡，而每年尼罗河的泛滥及谷类的生长则象征着他的重生。他被认为是为埃及带来文明的贤明的君王。 奥西里斯是Nut和Geb神的长子，也是Seth, Nephthys 和依西斯的兄长。他娶了他的妹妹依西斯。他也是Horus 和Anubis的父亲。 最古老的宗教书中提到奥西里斯是冥界之王，还试图让读者理解，他曾经以作为Geb的第一个孩子的形式生活在地球，最独特的埃及之王，奥西里斯在Geb退位后继承了王位。那个时候埃及人还非常野蛮原始，奥西里斯看到这样的情况非常焦虑。于是，他来到人群中并教他们哪些东西可以食用，教他们农艺，如何崇拜神明，并且给了他们法律。Thoth 协助他创造了艺术和科学并为万物命名。因此，奥西里斯被认为是埃及最仁慈、有说服力的国王。奥西里斯周游其他国家，让Isis 成为他的辅政者，传授他的教义。 在奥西里斯离开埃及的时期，Isis被Seth 企图谋权夺位并对她虎视眈眈的双重阴谋所困扰。很快，当奥西里斯返回埃及，在他在位28年，月的第17天时，Seth和72名谋反者杀害了他。并且把他锁进棺材扔进了尼罗河， Isis，在她妹妹的协助下，奇迹般的找到了奥西里斯的尸体，得知奥西里斯的尸体找到后，Seth赶去把奥西里斯的尸体割成14块并分洒在埃及各地。Isis再次寻找并把尸体收集起来，并寻找到他的生殖器（一开始被至今仍被诅咒的尼罗河的鱼吃掉了）。Isis神奇的把奥西里斯重新收集好，并使他复活，但奥西里斯复活的时间只够她怀上儿子Horus公子，未来的国王。 Seth当然不想把埃及王权交给年轻的Horus，因此神的法庭召开会议讨论谁是合法的国王。会议持续了80年，最后还是Isis凭借智慧使自己的儿子赢得了王位。奥西里斯后来成为了冥界之王。由他来执行人死后是否可得永生的审判。他教授人们在地球上以一种正确的生活态度活着，死后要用适当的丧葬仪式埋葬。他的地位被认为在Nun神之下。 作为冥界之王的奥西里斯获得了极大的声望。它的崇拜仪式起于阿拜多斯(Abydos)，因此那里有许多它的神庙。它变得受欢迎是在中王国以后，十八王朝时它可能是最广泛被崇拜的神祇，同时，持续到晚期埃及。 奥西里斯被杀和他的妻子寻找尸体的神话明显的说明埃及人相信有来世。

荷鲁斯神






荷鲁斯神的标志：HORUS (Hor, Heru, Her)

象征物：鹰， 公牛，双桂冠。 荷鲁斯神是长着鹰头的埃及神。埃及的统治者常常把自己与荷鲁斯神联系起来。人们认为法老是荷鲁斯神在世间的化身，所以他成为了埃及最重要的神祗之一。 埃及法老都是拉神（太阳神）的追随者，所以作为法老化身的荷鲁斯神也便与太阳有了联系。 如果你试图解决埃及不同部分之间对神的争议，其结果是你能发现最少有15个荷鲁斯神（Horus）的形态。根据受欢迎程度，他们可以被简单得分为两类：太阳神和Osirian神。如果，他是奥塞里斯神的儿子，那么他就是Osirian；否则，他就是 太阳神。荷鲁斯神的父亲Osiris死后，他的母亲伊希斯神奇迹般的生下了他。他由他母亲在漂浮的小岛上抚养大。他也曾陷入他坏叔叔Seth 制造的一系列危险之中，不过他的妈妈一直保护着他，使他化险为夷。当荷鲁斯还是个孩子的时候就以Harpokrates而闻名，“婴儿荷鲁斯”被描绘成由伊希斯喂养的孩子。据说，他腰部以下都发育不良。这可能是因为他出生时他爸爸就去世了，也可能因为他是个早产儿。Harpokrates被描绘为一个坐着吮吸大拇指的孩子。在他的额头上有皇室的王官和毒蛇的标记。后来，他被人们视为新生的太阳。Harmakhis,“地上的荷鲁斯神”。他代表升起的太阳，是复活和永生的标志。Haroeris，年长的荷鲁斯神，这是荷鲁斯神最早的形态之一，也是南部埃及的守护神。他被认为是太阳的化身，有时，人们也称他为Hathor的丈夫，Osiris和Seth兄弟。他被描绘为鹰头人身的形象，有时还带一顶王冠。

伊西斯




伊西斯的标志：ISIS
象征符号：王冠、鸢、蝎子、sistrum、tiet。信奉中心：Heliopolis。伊西斯（Isis）是奥塞里斯（Osiris）的妹妹，也是她的妻子，是努特（Nut，天空女神）和格伯（Geb，大地之神）的女儿，荷鲁斯（Horus）的母亲。赛思（Seth，谋杀奥塞里斯的凶手）和娜芙提斯（Nephthys，城堡之神）也是她的兄妹。伊西斯被描绘成头戴秃鹰装饰并长有羊角（有时在其羊角下还写有她名字的符号），双角之间还有太阳光盘的形象。偶尔，她也会戴着有羽毛的南北双王冠，或一对公羊角装饰。当伊西斯被描绘成一位普通的女人而非女神形象时，她则佩戴普通头饰，但点缀有蛇形标志。金字塔的铭文上记载有，当这位奥塞里斯的王后还在帮助她的丈夫辅政的时候，就已经预知到她的丈夫将要被谋害。奥塞里斯被谋杀后，伊西斯不屈不挠的寻找着丈夫的遗骸，她找遍了奥塞里斯可能被埋葬或被抛尸的地方。终于，她通过自己的法术使奥塞里斯复活，并怀孕生下了他们的儿子荷鲁斯。伊西斯是神与人之间的使者，起着至关重要的作用。法老王被视为是她的儿子，人间的荷鲁斯神。金字塔上的铭文镌刻着法老王吸吮伊西斯的乳汁的字样，那里有很多伊西斯怀抱荷鲁斯的雕塑和壁画，风格和形象也随着法老的交替而改变。伊西斯在荷鲁斯年幼的时候一直保护他，以防他受到那位一直想斩草除根的舅舅同时也是叔父的赛思的谋害，因为赛思一直害怕长大成人后的荷鲁斯来报杀父之仇。在死亡之书中，伊西斯被看作是生命的赋予者和死者食物的供给者，她也是审判死者的神祇之一。她的另一项任务是，保护伊姆赛特（Imsety），他是荷鲁斯的四个儿子之一，专门负责看管死者的肝脏。伊西斯是一位伟大的魔法师，以擅长使用法术闻名。例如，她创造了眼镜蛇，并利用蛇的毒液来迫使拉神说出自己秘密的名字。在埃及史上，伊西斯一直是最伟大的女神。她是最爱助人的女神，并且是以爱拥抱万物的母亲。伊西斯还是贤妻良母的最佳典范，因此埃及人最尊崇她。她的崇拜范围遍布整个埃及，最远到达英国。古典作家将她与珀尔塞福涅（Persephone，冥后）、特提斯（Tethys）、雅典娜（Athene）等相提并论，就象奥塞里斯与哈德斯（Hades，冥王）、酒神狄厄尼索斯（Dionysos）与其它地方的神等同视之一样。事实上，基督徒将她的一些特质影射在圣母玛莉亚的身上，就像一位充满爱的、坚强的母亲，伊西斯的这些特质吸引了西方的人们也来崇仰她。伊西斯哺育荷鲁斯的形象，毫无疑问地，激发了许多圣母与圣婴画像的灵感。

[ 本帖最后由 阿伟 于 2007-9-19 17:41 编辑 ]

1986年，Susan Lammers采访了计算机行业的先锋，19位著名的程序员和软件设计师，汇集成一本书《Programmers At Work》。这些人中包括了Charles Simonyi，比尔盖茨，Andy Hertzfeld，Ray Ozzie等等。22年后过去了，昔日意气风发的英雄，今日又在干什么？Leonard Richardson整理了一份简单介绍，讲述了他们的近况。

1/Charles Simonyi：当时，微软程序员；现在，亿万富翁，太空旅行家，目前担任Intentional Software公司的CEO。

2/Butler Lampson，图灵奖获得者，当时在PARC，现在在微软。

3/John Warnock，Adobe的共同创始人，现在退休，在董事会就职，很清闲。

4/Gary Kildall，CP/M的作者，1994年去世。

5/Bill Gates，众所周知的微软创始人，处于半退休，未来将投入到慈善工作上。

6/John Page，Software Publishing公司的共同创始人，开发了最早的数据库程序，目前不知所终，应该还活在，但没有在网络上现身。

7/C. Wayne Ratliff，dBase的作者，现在退休。

8/Dan Bricklin：电子表格VisiCalc的共同编写者，目前还活跃在一线。

9/Bob Frankston，VisiCalc的作者之一，后来在微软工作，现已退休。

10/Jonathan Sachs，Lotus 1-2-3的共同作者，现在半退休。

11/Ray Ozzie：Lotus Notes的作者，当时在Lotus Symphony工作，现在则是微软总软件架构师，之前在IBM工作过，后创建了Groove公司，Groove被微软收购后他就进入微软。

12/Peter Roizen：电子表格T/Maker的作者，现在是软件顾问。