个人总结有四点：

一、Money是万恶之源，生活所逼，我要赚钱啊！！

二、觉得自己技术还不够好，需要通过不断的开发来巩固知识。

三、接项目做，其实是个精简版项目开发的流程，从业务需求、系统分析与设计、编码、测试，需要的是一个team的相互沟通、合作。在team中实现自我价值，创造价值，获得个人精神升华（这个赞啊！^_^！）。

四、业务多了，认识的人也会多起来，圈子自然而然就会越滚越大，各行各业的人都有打交道，这个行业，人脉也是相当重要的。

OK！讲了那么多，理所当然，兼职开发是不是必要的？我们又应该如何去做正确的做出选择？作为一个未出社会的菜鸟，从自己的兼职经历出发，谈谈自己的想法！

2011年暑假得到一个机会去了某间公司当PHP开发的实习生，当时应聘的是ASP.NET开发，因公司要求，去搞PHP了，IT行业的第一份工作，过得还算愉快！！当时BOSS对我还是挺好的，教了我很多东西，不仅仅是在技术方面，在为人处事方面也有收获。

实习结束后，下定决心搞好自己的专业方向.NET开发，因为觉得自己什么都会点，但是却没能把一种技术学得熟练点。一个偶然的机会，BOSS介绍了一份兼职给我，大致跟那位客户沟通过后，主要是为已经上线的网站修改页面和增减功能，应该算是技术支持，技术支持？好吧！基本上要全能型，前端知识，div，css，js要会点，php的joomla开发也要会。这就和我自己的计划冲突了，左思右想，抵挡不住金钱的诱惑，走上了这条忐忑不安的路。

由2011年12月份开始，正式合作，支付方式是每月基本任务，固定工资。

刚开始，主要是做页面的修改，前端基础还算可以，吃着老本，感觉也挺轻松的，客户也很好沟通，就是每天耗的时间比以前多了，逐渐地把精力都放到工作上了。

寒假过后，回校了，发现工作量越来越大，量大是指小问题越来越多，自己没接触过的功能点也越来越多，由于我的客户是负责统筹运营这方面，对code不是很熟悉，于是我只能自己找资料，去QQ群，论坛求助，无形间自己花费的时间就越来越多，往往一个很简单的小问题，却要绕了一个很大的圈才能解决，工作效率低了，自然任务就越积越多，客户也越来越不满意。关键一点，影响自己学习！此时，已经有打算不做的念头，可是付出汗水后，出粮的那一刻，我又淡定了，咳咳！Money作怪啊！我就这样深深地陷入这个死循环中。。。。

后来因为想开始准备自己的毕设，加上课程设计要开发电子商务网站，最后，决定不干了，2012年4月份底，The Ending！ 

一轮流水账后，究竟问题出在哪里呢？

1.支付方式以每月基本任务，固定工资的方式作为兼职开发的合作形式不妥。客户的立场是以最少的资金来榨取更多的利润，当你快速完成了每个任务后，接着新的任务继续来，没有喘息的时间。所以，遵循多劳多得的原则，以每个模块，任务形式处理更佳，但就需要开发人员能够估算好任务时间，把握进度。

2.历时5个月，周期太长。任何一份工作开始时总是热情高涨，但是随着时间的推移，渐渐的变得越来越懒散，不负责任，只求完成，不求质量。但更可悲的是，企鹅开始隐身，防止客户打扰。额，这种服务态度是不行的，切忌效仿。

3.时间不够，无法兼顾学习。上课时间4~5个小时，睡眠时间包括午休10个小时，吃饭时间2个小时，体育运动时间1个小时，额！剩下的时间挤吧！

4.沟通能力是非常重要。因为不能和客户面对面沟通，难免有些需求会说不清，此时，请不要敷衍，一定要先把完整的需求弄出来，他想要的功能，想要的效果，在自己的能力范围尽量满足他。当自己遇到某些棘手的问题时，不要怕，尽量说出来，虽然他不是很懂code，但是他给的建议，意见可能帮助到你。

5.单干很累，拥有team是很幸福的事情。往往一个人开发的时候，遇到问题停滞不前，身边有伙伴提点下，事半功倍。等我以后出去工作了，希望能遇到好team。

6.做重复的工作，浪费时间，也无法从中学到更多的知识。

最后，来个大杂烩！

作为一名学生，兼职开发可以巩固技术，增加开发经验，加强沟通能力。但是要分析利弊，大学四年可以说是学习的黄金时间，在这四年里面，打好基础是非常重要的。

如果你有好的团队，方可大战拳脚，自己扛不住还有伙伴的帮忙。

如果业务太多了，接项目就需要有针对性，对那些周期比较短的，项目难度能在自己可控范围内，又能提高自己技术的优先选择。

如果因为学习时间与做项目冲突了，这时候就要考虑做项目是否对自己提高技术有帮助了？？

程序员们，不要总埋怨公司给的工资太少，而耗费自己大量时间去做私活，眼光放长远点，不要总向Money看，与其获取一丁点的钱，倒不如花更多的时间去增值自己，学无止境啊！只有慢慢积累到一定的程度后，技术可以过得了关，加薪没问题，以后大把的钞票接着来！

SO，自己也开始找工作了，之前学的知识太散了，现在要专一点。

明天要去广州红帆电脑科技公司笔试面试，公司用VB.NET开发，自己没接触过，加上对这公司不是很了解，有点犹豫了，哎！找工作就是烦！！

现在你可以看到，上面的图像类似一个噪声图像，但它实际上是一个由124K的 prototype 框架代码转化成的30K的8位PNG图像（压缩比还不错吧）。

其实，要将代码转化为图像的格式存储，可以转化成GIF和PNG格式。PNG格式的图像有24位和8位，用24位的RGB图像，每个像素可以存储3字节的数据，如果是用8位的RGB图像，每个像素可以存储1字节的数据。

在PHOTOSHOP中做测试发现：一个300x100的纯色杂点8位图像可以压缩到5K，而同样的纯色杂点图像，如果是100x100的24位图像只能压缩到20K。如果是同样图案的8位GIF图像，压缩效果比PNG要差一些。所以，我们选择用8位的PNG图像作为压缩和解压缩的存储格式。

现在，我们就需要开始压缩图像了，下面是用PHP写的压缩文件地址。
http://www.cleanthem.com/code/20120620/js-to-png.txt

它读取JS文件并创建一个PNG图像，图像中的每个像素中是一个0-255之间的值，而这个值对应的是JS字符的ascII的值。

当然，除了压缩，还要有解压缩，也就是将图像读取为JS文件的过程。这个函数是用JS写的，可以从下面的位置下载这个文件。
http://www.cleanthem.com/code/20120620/pngdata.txt

最后给出在线测试地址，在这个网页上，您可以在列表中选择一个PNG图像文件，点击 load file 按钮可以在网页上看到这个图像，在图像的下面是由这个图像所读出来的代码文件。

http://www.nihilogic.dk/labs/canvascompress/

注：转载请注明出处，觉得有用就推荐一下吧~

• 长度限制
• Url 是否隐藏数据

在我看来这两者都不是重点，特写此文予以讨论。

我们先来看些基本概念：

HTTP 基本概念

HTTP Request Methods

GET、POST 专业名称是 HTTP Request Methods。但 HTTP Request Methods 不只是 GET 和 POST，完整列表如下：

• GET
• POST
• PUT
• DELETE
• HEAD
• OPTIONS
• TRACE
• CONNECT
• PATCH

REST 使用前四个：GET、POST、PUT、DELETE。因些这四个也是经常被一块提及的，将这四个作为关键字进行搜索，你会得到更深入的结果。

在一般的 Web 开发中，GET 和 POST 用得最多，网上对这两的讨论也是最多，往往又很肤浅的。

更多信息请查看：

    http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html

    http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol

    http://zh.wikipedia.org/wiki/REST

Safe Methods（安全方法）

RFC 2616 中定义如下（后面有翻译）：

Implementors should be aware that the software represents the user in their interactions over the Internet, and should be careful to allow the user to be aware of any actions they might take which may have an unexpected significance to themselves or others.

In particular, the convention has been established that the GET and HEAD methods SHOULD NOT have the significance of taking an action other than retrieval. These methods ought to be considered "safe". This allows user agents to represent other methods, such as POST, PUT and DELETE, in a special way, so that the user is made aware of the fact that a possibly unsafe action is being requested.

Naturally, it is not possible to ensure that the server does not generate side-effects as a result of performing a GET request; in fact, some dynamic resources consider that a feature. The important distinction here is that the user did not request the side-effects, so therefore cannot be held accountable for them.

网址：http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.1

维基百科中的说明（对 RFC 2616翻译）：

开发者应当意识到他们的软件代表了用户在因特网上进行交互，并且应当告知用户，他们正在进行的操作可能对他们自身或者其他人有未曾预料的重要影响。

特别地，对于GET和HEAD方法而言，除了进行获取资源信息外，这些请求不应当再有任何其他意义。也就是说，这些方法应当被认为是“安全的”。客户端应当使用其他“非安全”方法，例如POST，PUT及DELETE来以特殊的方式（通常是按钮而不是超链接）使得客户能够意识到可能要负的责任（例如一个按钮带来的资金交易）或者被告知正在请求的操作可能是不安全的（例如某个文件将被上传或删除）。

但是，不能想当然地认为服务器在处理某个GET请求时不会产生任何副作用。事实上，很多动态资源会把这作为其特性。这里重要的区别在于用户并没有请求这一副作用，因此不应由用户为这些副作用承担责任。

来源网址：http://zh.wikipedia.org/wiki/超文本传输协议#.E5.AE.89.E5.85.A8.E6.96.B9.E6.B3.95

这部分读起来比较晦涩，不要着急，读完后面的再回头看就好理解了。

GET 与 POST 的区别

综上所述，可总结如下：

• GET 仅用来获取查看信息，不能改变服务器信息。
• POST 用来改变服务器信息。

这里说的改变，包括增加、修改和删除。

这是 HTTP 协议中的要求，众多浏览器和浏览器插件都遵守这些约定。如果你的代码不按照这约定来，可能会出现严重的后果。

使用 GET 改变服务器信息的严重后果

假定你编写的 Web 程序或网站允许 GET 提交的修改，比如允许用户通过以下 Url 直接删除编写为 1024 的订单：

   ~/orders/delete/1024

那么在订单的管理（或列表）页面，你可能会定义一个删除连接如下：

    <a href="/orders/delete/1024">删除</a>

当然不会这么简单，一般都会在删除之前会提示用户一下，加上确认提示脚本：

    <a href="/orders/delete/1024" onclick="return confirm('确实要删除吗？')">删除</a>

（说明：我在这里只是示简单例下，添加确认删除还是建议使用 Unobtrusive JavaScript 方式，可以使用 jQuery。）

很多开发人员以为这样就万事大吉了，有了确认提示，也不怕误删。但问题就恰恰出在这里，2005年时，谷歌发布了一款浏览器加速插件：Google Web Accelerator（以下简称 GWA），让这种问题严重的暴露了出来。

GWA 通过多种技术来加速，其中一种就是页面预先加载：比如你在查看我这篇文章的时候，GWA 可能把我前一篇或其它文章预先在后台下载，这样你在点击时，就节省了时间，起到了加速的效果。

GWA 的预先加载是根据当前页面中的链接来的，根据 HTTP 的协议，点击链接时使用 GET 方法获取信息，因些不会对服务器造成影响。因此 GWA 会放心的加载当前页面链接对应的网页。当然也可能会加速上面提到的订单删除链接，GWA 会无视你的确认删除脚本，直接从后台把 "/orders/delete/1024" 载入，也就意味着 1024 订单已经被删除了。

GWA 发布后，很多网站出现了很多莫名其妙的问题，数据无故丢失，商品自动加入了用户的购物车，用户无端地被扣款…

一时问题很严重，后来发现的原因的所在，就是网站开发者没有遵守 HTTP 约定，没有弄明白 GET 和 POST 的区别。

可以查看以下文章深入了解这段历史：

   http://blogs.adobe.com/cantrell/archives/2005/06/what_have_we_le.html

   http://blog.moertel.com/articles/2005/05/06/google-web-accelerator-offers-web-developers-an-important-opportunity

而如今，谷歌发布的 Chrome 浏览器，类似的加速功能集成了进去，你可以在 设置 - 显示高级设置 里面看得到：

所以，对服务器有改变的一定要用 POST，GWA 和类似的插件不会提交 POST 表单加速的。

删除、查看用户信息收费（比如人才网、婚恋网）、加入购物车等操作还是放在 POST 表单中用 Button 来吧。

再回头读维基百科中对 Safe Methods 的说明，相信你会明白很多。

注意：但也不是所有对服务器有改变的都要用 POST，比如你点击本文下面的 前一篇博文链接 ，我的文章访问量可能+1，对服务器有所改变，但这种改变是轻微的，影响不大（相对删除、扣款来说），可以放心的使用链接（GET 方式）。

基它一些区别：

• 使用 GET 表单查询，查询结果页面可以收藏；POST 表单不行。
• 向服务器发送文件只能使用 POST 表单。

能想到的大致这些吧。

感言

之前，我曾学习 ASP.NET 多年，但对 HTTP 几乎一无所知，WebForm 封装了一切：

• 不用去考虑 POST、GET，只需知道 Postback；
• 不用多考虑值来回传递，因为有 ViewState；
• 不用关心 Html，因为有服务端控件。

更悲哀的是，我有很长一段时间都认为一个页面上只能有一个 Form。

后来做了一段时间 WinForm 后，开始学习 ASP.NET MVC，开始逐步了解 Html、Http 等等，也开始知道了 Post-Redirect-Get 模式等等。

看到很多人浅浅讨论 GET 和 POST，感到很无奈，WebForm 误人啊。要想进步，还是学学 ASP.NET MVC 吧！

即每隔一段时间向服务器异步请求更新，用四个字母代替之就是AJAX。

其实我们转念想想，我们使用AJAX的目的就是使页面能实时地更新，倘若我们的动态页面能够实时地更新，我们干嘛还费这些周折？

先看一个小试验：

1 <?php 2 while(true){ 3         echo 'Hello'; 4         sleep (1000); 5 } 6 ?>

如果如我们所愿，则页面将每隔一秒都会显示一个‘hello’

看到这，也许知道我们聊天室的消息显示页面该怎么写了，请看伪代码。

 1 <?php  2 $currentData = getData();  3 while (true){  4       $differences=getData();  5       if ($differences!=$currentData){  6                    echo $differences;  7                    }  8       sleep (10000);  9 } 10 ?>

可惜光是这样是不能成功滴，因为我们还没考虑到php的缓存和缓冲问题。

php默认会缓存内容，防止http报文的Header和Data分离。且php会缓冲页面内容直至程序结束再将页面输出。

知道原因就好办了。好在php提供了关闭缓冲和缓存的方法。

直接在前面加上

1 output_buffering=0 2 ob_end_flush(); 3 set_time_limit(0);

则变为:

 1 <?php  2 output_buffering=0;  3 ob_end_flush();  4   5 while(true){  6         echo 'Hello';  7         sleep (1000);  8         flush(); //强制使PHP输出  9 } 10 ?>

你会发现第一个显示hello的已经成功了！

我们的消息页面就变为

 1 <?php  2 output_buffering=0;  3 ob_end_flush();  4   5 $currentData = getData();  6 while (true){  7       $differences=getData();  8       if ($differences!=$currentData){  9                    echo $differences; 10                    flush(); 11                    } 12       sleep (10000); 13 } 14 ?>

但是在项目最终的实现上，客户端也存在问题：

有些浏览器也会在显示之前，缓存接收到的内容。例如 Netscape 浏览器会在接受到换行或 html 标记的开头之前缓存内容，并且在接受到 </table> 标记之前，不会显示出整个表格。 

IE甚至只有当接受到的256个字节以后才开始显示该页面，所以必须发送一些额外的空格来让这些浏览器显示页面内容。

至此我们已经用”服务器推“解决了的实时更新的问题。其他框架也与普通思路无异，就不再累述了。

有兴趣的同学可以着手写一个了。呵呵。

欢迎大家一起交流。

增加对结果的处理：

1、修改Job，实现Callable接口

Java代码  

1. public abstract class Job implements Callable<Object> {  
2.   
3.     @Override  
4.     public Object call() throws Exception {  
5.         Object result = this.execute();//执行子类具体任务  
6.         synchronized (Executer.LOCK) {  
7.             //处理完业务后，任务结束，递减线程数，同时唤醒主线程  
8.             Executer.THREAD_COUNT--;  
9.             Executer.LOCK.notifyAll();  
10.         }  
11.         return result;  
12.     }  
13.     /** 
14.      * 业务处理函数 
15.      */  
16.     public abstract Object execute();  
17.   
18. }  

2、修改Executer，增加对结果的处理

Java代码  

1. public class Executer {  
2.     //计算已经派发的任务数(条件谓词)  
3.     public static int THREAD_COUNT = 0;  
4.     //存储任务的执行结果  
5.     private List<Future<Object>> futres = new ArrayList<Future<Object>>();   
6.     //条件队列锁  
7.     public static final Object LOCK = new Object();  
8.     //线程池  
9.     private ExecutorService pool = null;  
10.     public Executer() {  
11.         this(1);  
12.     }  
13.     public Executer(int threadPoolSize) {  
14.         pool = Executors.newFixedThreadPool(threadPoolSize);  
15.     }  
16.     /** 
17.      * 任务派发 
18.      * @param job 
19.      */  
20.     public void fork(Job job){  
21.         //将任务派发给线程池去执行  
22.         futres.add(pool.submit(job));  
23.         //增加线程数  
24.         synchronized (LOCK) {  
25.             THREAD_COUNT++;  
26.         }  
27.     }  
28.     /** 
29.      * 统计任务结果 
30.      */  
31.     public List<Object> join(){  
32.         synchronized (LOCK) {  
33.             while(THREAD_COUNT > 0){//检查线程数，如果为0，则表示所有任务处理完成  
34.                 System.out.println("threadCount: "+THREAD_COUNT);  
35.                 try {  
36.                     LOCK.wait();//如果任务没有全部完成，则挂起。等待完成的任务给予通知  
37.                 } catch (InterruptedException e) {  
38.                     e.printStackTrace();  
39.                 }  
40.             }  
41.         }  
42.         List<Object> list = new ArrayList<Object>();  
43.         //取出每个任务的处理结果，汇总后返回  
44.         for (Future<Object> future : futres) {  
45.             try {  
46.                 Object result = future.get();//因为任务都已经完成，这里直接get  
47.                 list.add(result);  
48.             } catch (Exception e) {  
49.                 e.printStackTrace();  
50.             }   
51.         }  
52.         return list;  
53.     }  
54. }  

 3、测试：

Java代码  

1. public static void main(String[] args) {  
2.         //初始化任务池  
3.         Executer exe = new Executer(5);  
4.         //初始化任务  
5.         long time = System.currentTimeMillis();  
6.         for (int i = 0; i < 10; i++) {  
7.             MyJob job = new MyJob();  
8.             exe.fork(job);//派发任务  
9.         }  
10.         //汇总任务结果  
11.         List<Object> list = exe.join();  
12.         System.out.println("Result: "+list);  
13.         System.out.println("time: "+(System.currentTimeMillis() - time));  
14.     }  

4、执行结果：

Java代码  

1. threadCount: 10  
2. running thread id = 9  
3. running thread id = 11  
4. running thread id = 8  
5. running thread id = 10  
6. running thread id = 12  
7. threadCount: 5  
8. running thread id = 9  
9. running thread id = 8  
10. running thread id = 11  
11. running thread id = 12  
12. running thread id = 10  
13. Result: [8, 9, 10, 11, 12, 8, 11, 12, 9, 10]  
14. time: 2000  

5、附件是完整代码

Executer代码如下：

Java代码  

1. public class Executer {  
2.     //计算已经派发的任务数(条件谓词)  
3.     public static int THREAD_COUNT = 0;  
4.     //存储任务的执行结果  
5.     private List<Future<Object>> futres = new ArrayList<Future<Object>>();   
6.     //条件队列锁  
7.     public final Object lock = new Object();  
8.     //线程池  
9.     private ExecutorService pool = null;  
10.     public Executer() {  
11.         this(1);  
12.     }  
13.     public Executer(int threadPoolSize) {  
14.         pool = Executors.newFixedThreadPool(threadPoolSize);  
15.     }  
16.     /** 
17.      * 任务派发 
18.      * @param job 
19.      */  
20.     public void fork(Job job){  
21.         //设置同步锁  
22.         job.setLock(lock);  
23.         //将任务派发给线程池去执行  
24.         futres.add(pool.submit(job));  
25.         //增加线程数  
26.         synchronized (lock) {  
27.             THREAD_COUNT++;  
28.         }  
29.     }  
30.     /** 
31.      * 统计任务结果 
32.      */  
33.     public List<Object> join(){  
34.         synchronized (lock) {  
35.             while(THREAD_COUNT > 0){//检查线程数，如果为0，则表示所有任务处理完成  
36.                 System.out.println("threadCount: "+THREAD_COUNT);  
37.                 try {  
38.                     lock.wait();//如果任务没有全部完成，则挂起。等待完成的任务给予通知  
39.                 } catch (InterruptedException e) {  
40.                     e.printStackTrace();  
41.                 }  
42.             }  
43.         }  
44.         List<Object> list = new ArrayList<Object>();  
45.         //取出每个任务的处理结果，汇总后返回  
46.         for (Future<Object> future : futres) {  
47.             try {  
48.                 Object result = future.get();//因为任务都已经完成，这里直接get  
49.                 list.add(result);  
50.             } catch (Exception e) {  
51.                 e.printStackTrace();  
52.             }   
53.         }  
54.         return list;  
55.     }  
56. }  

 Job类:

Java代码  

1. public abstract class Job implements Callable<Object> {  
2.   
3.     //锁  
4.     private Object lock = null;  
5.   
6.     void setLock(Object lock) {  
7.         this.lock = lock;  
8.     }  
9.   
10.     @Override  
11.     public Object call() throws Exception {  
12.         Object result = this.execute();//执行子类具体任务  
13.         synchronized (lock) {  
14.             //处理完业务后，任务结束，递减线程数，同时唤醒主线程  
15.             Executer.THREAD_COUNT--;  
16.             lock.notifyAll();  
17.         }  
18.         return result;  
19.     }  
20.     /** 
21.      * 业务处理函数 
22.      */  
23.     public abstract Object execute();  
24.       
25. }  

 测试结果：

Java代码  

1. threadCount: 10  
2. running thread id = 8  
3. running thread id = 10  
4. running thread id = 9  
5. running thread id = 12  
6. running thread id = 11  
7. threadCount: 8  
8. threadCount: 7  
9. threadCount: 6  
10. threadCount: 5  
11. running thread id = 12  
12. running thread id = 8  
13. running thread id = 11  
14. threadCount: 2  
15. running thread id = 10  
16. threadCount: 1  
17. running thread id = 9  
18. ResultSize: 10  
19. time: 2001  

 OK！

这样每个Executer就可以使用自己的lock，而相互不受同步的影响