早春梅
花开枝头几朵梅，
几树梅花度寒冬。
不知梅花何时开？
应在早春竟绽放!
(2009 七岁生日 于郑州 瑶瑶第1次写诗)

夏荷
烈日炎炎荷花放，
亭亭玉立铺满塘。
笑忍酷暑独自开，
唯有莲藕淤泥藏。
2010 瑶瑶于郑州

偶游紫薇
清清溪潭水，
处处花草香。
仰望蔚蓝天，
回首紫薇芳。
(2010 瑶瑶于张江紫薇公园 和老燕)

如梦令
雨丝细如松叶，
塘中河水清澈。
枝头蝉声鸣，
碧岩如此清秀。
溪头，溪头，
多少鱼儿畅游。
(2010 于世纪公园 瑶瑶第1次填词 和李清照)

如梦令
奇峰怪石依旧，
石鹤立水永久。
独坐孤亭旁，
望远碧柳青秀。
莲藕，莲藕，
深藏淤泥不露。
（2010 瑶瑶再游紫薇公园）

南乡子
何处风景优，
满城秀色金山楼。
绿叶明年飞又去，
匆匆，
碧波荡漾天尽头。

夏韵美胜收，
且乘凉风亭边休。
古今多少佳作传，
回首，
楼台十里望瓜洲。

(2010 瑶瑶 于镇江金山寺 和辛弃疾)

(2010) 马飞涛

落英飞尽，

仰天处， 慷慨悲歌尤现。

妩媚青山，常惋忆，

壮士马革血染。

豪气穿空，

挺身赴难，

敢对千夫剑。

阳关酒美，

一杯沙场征战。

长忆似水流年，

梅花零落了，

红飘香散。

秋雨秋风，回首看，

不见百娇千艳。

寒夜窗烛，

孤独应笑，

我泪襟沾满。

瑶琴弦断，

一读青史还叹。

出处：

仰天：
岳飞《满江红》: “仰天长啸，壮怀激烈”

马革：
东汉名将马援：“男儿要当死于边野，以马革裹尸还葬耳”
龚自珍《已亥杂诗》：“青山处处埋忠骨，何须马革裹尸还”

千夫：
鲁迅《自嘲》：“横眉冷对千夫指，俯首甘为孺子牛”

阳关：在今甘肃省敦煌西南
王维 《渭城曲》：“劝君更尽一杯酒，西出阳关无故人”

征战：
王翰《凉州词》：“醉卧沙场君莫笑，古来征战几人回。”

梅花：
陆游《卜算子 咏梅》：“零落成泥碾作尘，只有香如故”

秋雨秋风
秋瑾： “一叶落而知秋深,秋风秋雨愁煞人”

窗烛：
李商隐《夜雨寄北》：“君问归期未有期，巴山夜雨涨秋池。何当共剪西窗烛，却话巴山夜雨时。”

泪沾襟：
杜甫《蜀相》： “出师未捷身先死， 长使英雄泪满襟。”

瑶琴：
岳飞《小重山》：“欲将心事付瑶琴，知音少，弦断有谁听”

今天早晨，我一个人静静地走在上班的小路上，经过沉思，发现昨天大家讨论的立足点都是错误的，
包括我自己。

我们根本就不应该有"管理"这个概念。应该把传统意义上的"管理"这个词汇从创新院人的思维里抠掉。

我总结一些新的心得，与大家分享。

项目管理之马氏原则：
"管理倒置原则"， 即：
项目成员自我管理，项目经理服务于大家；

角色定位：
项目经理：
不是管理者，
而是：组织者+协调者+服务者+开发者；

项目成员：
不是被管理者，
而是：自我管理者+参加者+决策者+开发者

心态调整：
项目经理：
一定要忘掉“管理”这个词
一定要牢记“服务”这个词
一定要拉低自己的身段，姿态放平或者更低
无为而治
上善若水
海纳百川

项目成员：
一定要摆脱“被管理者”的心态
一定要时刻提醒自己也是决策者一员，在集体决策时积极发言；

借用网络模型：
项目经理类似于服务器
项目成员类似于客户端，
客户端可以自我管理，自己处理过载，自己重新启动

工作流程：
1 开发进度：集体讨论并决策，制定里程碑和各个子节点
2 任务分配：项目成员自己认领

遇到问题：
1 项目经理发现问题后，首先要扪心自省，先从自己身上找问题；
2 开会集体讨论决策问题的解决方法

团队建设之终极目标：
王道乐土
每个项目成员能感觉到：工作==娱乐
(这句话不是我在唱高调，我确实在编程中能感受到类似于传说中吸毒之后的飘飘然的快乐，现在可能是毒瘾大了，快乐就少了，所以，我会找更难做的方向来开发)

娱乐反倒是工作
(我不吸烟不喝酒不玩游戏不打牌，现在开始玩玩“三国杀”和wii, 当成自己的"工作"来体验一下)

工作==娱乐的公司，无敌于天下！
想想google吧。

项目管理的最高境界应该是不管，管他干嘛？

是否我写的是“漫纸荒唐言”？ 欢迎大家拍砖，欢迎推墙。

马飞涛

#include "stdafx.h"
#include <iostream>

#include <string>

#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include < boost/date_time/posix_time/posix_time.hpp>
#include < windows.h>

using boost::asio::ip::tcp;

#include <windows.h>
void * GetMainFiber(void)
{
static bool ini=false;
static void * mainFiber=NULL;

if(ini==false)
{
ini=true;
mainFiber= ConvertThreadToFiber(NULL);
}

assert(mainFiber !=NULL);
return mainFiber;
};

class CFiberSocket
{
private:
tcp::socket * pSocket_;
enum { max_length = 1024 };
char data_[max_length];

bool ok_;
int bytes_transferred_;
void * meFiber_;

public:

CFiberSocket(tcp::socket * socket)
:pSocket_(socket),
ok_(false)
{
bytes_transferred_=0;
meFiber_=::GetCurrentFiber();

};

~CFiberSocket(void)
{
pSocket_->close();
delete pSocket_;
::SwitchToFiber(GetMainFiber());

};

void close(void)
{
pSocket_->close();
};

std::string read_some(int max_length, int timeout)
{

pSocket_->async_read_some(boost::asio::buffer(data_, max_length),
boost::bind(&CFiberSocket::handle_read, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));

SwitchToFiber(GetMainFiber());

if(ok_)
{
std::string str(data_, bytes_transferred_);
return str;
}
else
return "";

};

void handle_read(const boost::system::error_code& error,
size_t bytes_transferred)
{
bytes_transferred_ =bytes_transferred;

if (!error)
{
//没有错误
ok_=true;

}
else
{
//有错误
ok_=false;
}
SwitchToFiber(meFiber_);
};

bool write(const char * buf, int size)
{

boost::asio::async_write(*pSocket_,
boost::asio::buffer(buf, size),
boost::bind(&CFiberSocket::handle_write, this,
boost::asio::placeholders::error));

SwitchToFiber(GetMainFiber());

return ok_;

}

void handle_write(const boost::system::error_code& error)
{
if (!error)
{
ok_=true;
}
else
{
ok_=false;
}

SwitchToFiber(meFiber_);
};
};

//纤程内部，同步等待
void WINAPI sessionProc(void * pSocket)
{
CFiberSocket socket( (tcp::socket *) pSocket);

std::string str;
while(true)
{
str=socket.read_some(100,1);
printf("%s\n", str.c_str());
if(str.size()==0)
{
return;
};

char buf[100];
int * fiber=(int *) GetCurrentFiber();
sprintf(buf,"[%x]\r\n",  fiber );
str.append(buf);
socket.write(str.c_str(), str.size());

};

};

class server
{
public:
server(boost::asio::io_service& io_service, short port)
: io_service_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
{
tcp::socket * pSocket = new tcp::socket(io_service_);

acceptor_.async_accept(*pSocket,
boost::bind(&server::handle_accept, this, pSocket,
boost::asio::placeholders::error));
}

void handle_accept(tcp::socket * pSocket,
const boost::system::error_code& error)
{
if (!error)
{

void * me   = CreateFiber(4096, sessionProc, pSocket);
::SwitchToFiber(me);

tcp::socket * pNewSocket = new tcp::socket(io_service_);

acceptor_.async_accept(*pNewSocket,
boost::bind(&server::handle_accept, this, pNewSocket,
boost::asio::placeholders::error));
}
else
{
assert(true==false);
}
}

private:
boost::asio::io_service& io_service_;
tcp::acceptor acceptor_;
};

int main(int argc, char* argv[])
{
try
{

char* pPort="1235";

if (argc != 2)
{
std::cerr << "Usage: echo_server

\n";}
else
{
pPort=argv[1];
}

boost::asio::io_service io_service;

GetMainFiber();

using namespace std; // For atoi.
server s(io_service, atoi(pPort));

io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}

return 0;
}

asio fiber 例子， 把asio异步非阻塞的调用，借助fiber 纤程[协程]， 构造语法糖，包装为同步阻塞的写法。

注意这个函数
//纤程内部，同步等待
void WINAPI sessionProc(void * pSocket)

函数里面是阻塞调用的写法，但是通过纤程跳到主纤程里面，在主纤程的回调函数里，又跳回到该会话的纤程。

客户端一个连接，对应于服务器端的一个socket, 每个socket新开一个纤程， 每个线程是一个会话，纤程sessionProc里收发是同步的写法。
有时间再把异步accept包装为同步写法，为linux也做一个asio + 纤程的版本

以下是一个asio和fiber结合的最简单的小例子。

Asio+fiber+单线程的内存池, 效率无敌,纤程内部，同步等待，写法优美。

// test_timer.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <boost/asio.hpp>
#include < boost/date_time/posix_time/posix_time.hpp>
#include < windows.h>

void *fiber_context[2];

void print(const boost::system::error_code& /*e*/)
{
std::cout << "Hello, world!\n";
}

boost::asio::io_service io;
void WINAPI fiberProc(void *fiber_nbr);
void callback(const boost::system::error_code& /*e*/);

void wait(int second)
{

boost::asio::deadline_timer t(io, boost::posix_time::seconds(second));
t.async_wait(callback);
SwitchToFiber(fiber_context[0]);

};

void callback(const boost::system::error_code& /*e*/)
{
std::cout << "callback!\n";
SwitchToFiber(fiber_context[1]);
};

//纤程内部，同步等待
void WINAPI fiberProc(void *fiber_nbr)

{
wait(1);
printf("step1\n\n");

wait(1);
printf("step2\n\n");

wait(1);
printf("step3\n\n");

wait(1);
printf("step4\n\n");

SwitchToFiber(fiber_context[0]);

}

int main()
{
fiber_context[0] = ConvertThreadToFiber(NULL);
fiber_context[1] = CreateFiber(4096, fiberProc,0);

boost::asio::deadline_timer tLong(io, boost::posix_time::seconds(8));
tLong.async_wait(print);

SwitchToFiber(fiber_context[1]);

io.run();

return 0;
}