关于面试的一篇老外文章，很agree其说法

面试也可以学习的

Oauth Flowchat

Digg oauth

Key Value Coding

Once you start asking how anything works, you immediately plunge into a gray area. The documentation at least tells us this:

• The default implementation will invoke the -(id)<key> or -(void)set<key> methods, if they exist, to perform the work. There are a few other method names tried if these can't be found.
• If no method is found, any instance variable with the same name as the key will be automatically accessed (unless this feature is explicitly disabled for the class).
• If no matching instance variable is found either, the -(id)valueForUndefinedKey:(NSString *)key method is invoked which raises an NSUndefinedKeyException by default.

Distilling this information down, you can (in most cases) presume that key value coding will work for any "key" on any class that supports the methods -(id)<key> and -(void)set<key>, or has an attribute named "key". Sometimes overrides valueForUndefinedKey: will support other keys too but that is highly implementation specific. Most other key and object combinations will throw an NSUndefinedKeyException.

Source cocoawithlove

Allocate/Free Pair validation

前面学习webkit曾经提过alloc/free校验的问题，当时跳过了，今日看云风大牛的文章<给你的模块设防>，重新想了一下，这种技术，结合gdb简单分析就很明白了，我个人看到的主要是假设有type* ptr,那么ptr+1，取决于type的类型。比如：

struct cookie {

size_t sz;

int tag;

};

那么struct cookie* ptr，ptr+1的地址是&ptr+16，因为sizeof(struct cookie)==16。下面是code和gdb跟踪结果:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

 

#define DOGTAG_VALID 0xbadf00d

#define DOGTAG_FREE 0x900dca7e

#define DOGTAG_TAIL 0xd097a90

 

struct cookie {

size_t sz;

int tag;

};

 

void *

my_malloc(size_t sz)

{

if (sz == 0)

sz = 1;

struct cookie * c = malloc(sizeof(struct cookie)

+ sz + sizeof(int));

assert(c != NULL);

c->sz = sz;

c->tag = DOGTAG_VALID;

int * tail = (int *)((char *)(c+1) + sz);

*tail = DOGTAG_TAIL;

 

memset(c+1, 0xCC, sz);

 

return c+1;

}

 

void

my_free(void *p)

{

if (p==NULL)

return;

struct cookie * c = p;

--c;

assert(c->tag != DOGTAG_FREE);

assert(c->tag == DOGTAG_VALID);

int *tail = (int *)((char *)p + c->sz);

assert(*tail == DOGTAG_TAIL);

c->tag = DOGTAG_FREE;

memset(p, 0xCC , c->sz);

free(c);

}

 

int main() {

int* PtrInt = (int*)my_malloc(10);

*PtrInt = 10;

*(PtrInt+1) = 20;

my_free(PtrInt);

return0;

}

 

//Starting program: /Users/zhilihu/code/memoryManage/customMallocFree

//

//Breakpoint 1, main () at customMallocFree.c:50

//50 int* PtrInt = (int*)my_malloc(10);

//(gdb) n

//

//Breakpoint 2, my_malloc (sz=10) at customMallocFree.c:21

//21 + sz + sizeof(int));

//(gdb) n

//22 assert(c != NULL);

//(gdb) n

//23 c->sz = sz;

//(gdb) p c

//$3 = (struct cookie *) 0x100300080

//(gdb) p c+1

//$4 = (struct cookie *) 0x100300090

//(gdb) p (char*)(c+1)

//$5 = 0x100300090 ""

//(gdb) p sz

//$6 = 10

//(gdb) p (c+2)

//$7 = (struct cookie *) 0x1003000a0

//(gdb) p sizeof(struct cookie)

//$8 = 16

//



 

 

 

Scala Trais

怎么scala的trais和java的interface这么像呢？不过scala的也有奇特的地方，它可以在trait里面进行实现，还有进行堆栈式的接口修改。scala的trait对比class来说有

1.不可以有类型参数

2.class中super是静态绑定的，而在trait中是动态绑定的。
scala的trait也比较有趣，比如定义一个抽象类
abstract class IntQueue {
def get():Int
def put(x:Int)
}
我们可以在trait中覆盖并且调用父类的put方法,而这在普通class中是不行的。
trait Doubing extends IntQueue {
abstract override def put(x:Int) {super.put(2*x)}
}
嗯，当然如果一个trait是继承某个类的，那么只有同是继承了这个类的class可以使用这个trait.

集中精神

刚才集中精神commit那些自学scala的例子的时候很有去年在软件公司实习的时候的感觉，轻快而高效，水到渠成，卧槽。其实scala很灵活，果然是支持多种编程范式的语言，可扩展性十分强。现在人们写代码提倡测试优先，所以也给对照书本写的简单例子找了一个scala的测试工具Specs，其实这个还没有完全弄清楚其内涵特性的，但是既然想快点完成测试以便帮助自己了解scala这门语言的特征，也就快快的下载了lib，然后和sbt组合下来，万幸，果然好使。在短时间了解scala测试framework期间，找到了github的一个twiiter公司出的json scala库，待把那本入门的书看完后，必定要去checkout看看:)

webkit frameloader

再说一次，当前的frameloader确实复杂呀，代码大概的了解了一片，从load一直到构建dom tree，从网络获得的数据html构建dom tree部分没有仔细看，以后回来看，接下来应该是看render tree生成，因为其主页上有很详细的介绍，所以看起来会比较舒服一些。webkit的网络数据获取部分取决于具体平台的实现，相当的独立，这种方式在跨平台程序编写里面应该是十分常见的。以下是webkit主页上的codepath介绍，也就是我今天所了解的内容：

Tokenizing HTML/XML document

From the moment, piece by piece of an HTML document is obtained from the network, this is what happens:

  [HTML,XML]Tokenizer::write(const SegmentedString& str, bool appendData)
  FrameLoader::write(const char* data, int len, bool flush)
  FrameLoader::addData(const char* bytes, int length)
  FrameLoaderClientQt::committedLoad(DocumentLoader* loader, const char* data, int length)
  FrameLoader::committedLoad(DocumentLoader* loader, const char* data, int length)
  DocumentLoader::commitLoad(const char* data, int length)
  DocumentLoader::receivedData(const char* data, int length)
  FrameLoader::receivedData(const char* data, int length)
  MainResourceLoader::addData(const char* data, int length, bool allAtOnce)
  ResourceLoader::didReceivedData(const char* data, int length, long long received, bool allAtOnce)
  ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int len, long long received)

Get data from network

Shown here for the Qt port, might vary a bit for other ports.

  QNetworkReplyHandler::start()
  QNetworkReplyHandler(ResourceHandle* handle, LoadMode loadMode)
  ResourceHandle::start(Frame* frame)
  ResourceHandle::create(const ResourceRequest& request, ResourceHandleClient* client,
      Frame* frame, bool defersLoading, bool shouldContentSniff, bool mightDownloadFromHandle)
  MainResourceLoader::loadNow(ResourceRequest& r)
  MainResourceLoader::load(const ResourceRequest& r, const SubstituteData& substituteData)
  DocumentLoader::startLoadingMainResource(unsigned long identifier)
  FrameLoader::continueLoadAfterWillSubmitForm(PolicyAction)
  FrameLoader::continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState> formState, bool shouldContinue)
  FrameLoader::callContinueLoadAfterNavigationPolicy(void* argument,
      const ResourceRequest& request, PassRefPtr<FormState> formState, bool shouldContinue)
  PolicyCheck::call(bool shouldContinue)
  FrameLoader::continueAfterNavigationPolicy(PolicyAction policy)
  FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
  FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, 
      const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request,
      PassRefPtr<WebCore::FormState>)
  FrameLoader::checkNavigationPolicy(const ResourceRequest& request, DocumentLoader* loader,
      PassRefPtr<FormState> formState, NavigationPolicyDecisionFunction function, void* argument)
  FrameLoader::loadWithDocumentLoader(DocumentLoader* loader, FrameLoadType type, PassRefPtr<FormState> prpFormState)
  FrameLoader::load(DocumentLoader* newDocumentLoader)
  FrameLoader::load(const ResourceRequest& request, const String& frameName, bool lockHistory)
  FrameLoader::load(const ResourceRequest& request, bool lockHistory)
  QWebFrame::load(const QNetworkRequest &req, QNetworkAccessManager::Operation operation,
      const QByteArray &body)
  QWebFrame::load(const QUrl &url)

另外一个很好的参考:http://webkit.org/blog/1188/how-webkit-loads-a-web-page/

这叫做Scala:)

 1 import scala.io.Source
 2
 3 object Hello {
 4   // the length of representing number
 5   def widthOfLength(s: String) = s.length.toString.length
 6
 7   def main(args: Array[String]) {
 8     if (args.length > 0) {
 9       val lines = Source.fromFile(args(0)).getLines.toList
10       val longestLine = lines.reduceLeft(
11         (a, b) => if (a.length > b.length) a else b
12       )
13       val maxWidth = widthOfLength(longestLine)
14       for (line <- lines) {
15         val numSpaces = maxWidth - widthOfLength(line)
16         val padding = " " * numSpaces
17         print(padding + line.length + " ! " + line)
18       }
19     } else
20         Console.err.println("Please enter filename")
21    }
22 }

functional style make you a better geek

"If you come from an imperative background, we believe that learning to program in a functional style will not only make you a better Scala programmer, it will expand your horizons and make you a better programmer in general."

Scala's mutable, immutable object

1.creating, initializing, and using an immutable set:
var jetSet = Set("Boeing", "Airbus")
jetSet += "Lear"
println(jetSet.contains("Cessna"))

2.creating, initializing, and using a mutable set:
import scala.collection.mutable.set
val movieSet = Set("Hitch", "Poltergeist")
movieSet += "Shrek"
println(movieSet)

Because the set in 2 is mutable, there is no need to reassign movieSet,
which is why it can be a val. By contrast, using += with the immutable set
in 1 required reassigning jetSet, which is why it must be a var.

FrameLoader十分臃肿繁杂

这段code做的事情十分多，不是三言两语可以说清楚的。难怪有人想拆分的功能到别的文
件，使得代码的更加简洁，同时增强其readability。比如：
https://bugs.webkit.org/show_bug.cgi?id=36936
这里说了其中一个核心的功能就是在m_documentLoader, m_provisionalDocumentLoader
和m_policyDocumentLoader之中做状态转换。它的实现文件有足足5000多行呢！

Webkit Allocator

Webkit的Allocator使用的是来自google的大神Sanjay Ghemawat的，当然也可以在嵌入式
等系统中根据自己的需要使用custom allocator，webkit在google的allocator加入了类
openCV的allocate/free pair validation，在编译期间做为可选项目。从代码的注释可以
看到端倪：
// Malloc validation is a scheme whereby a tag is attached to an
// allocation which identifies how it was originally allocated.
// This allows us to verify that the freeing operation matches the
// allocation operation. If memory is allocated with operator new[]
// but freed with free or delete, this system would detect that.
// In the implementation here, the tag is an integer prepended to
// the allocation memory which is assigned one of the AllocType
// enumeration values. An alternative implementation of this
// scheme could store the tag somewhere else or ignore it.
// Users of FastMalloc don't need to know or care how this tagging
// is implemented.
再上一小段代码吧，具体在https://bugs.webkit.org/show_bug.cgi?id=20422
// This defines a type which holds an unsigned integer and is the same
// size as the minimally aligned memory allocation.
typedef unsigned long long AllocAlignmentInteger;

namespace Internal {

// Return the AllocType tag associated with the allocated block p.
inline AllocType fastMallocMatchValidationType(const void* p)
{
const AllocAlignmentInteger* type = static_cast(p) - 1;
return static_cast(*type);
}

// Return the address of the AllocType tag associated with the allocated block p.
inline AllocAlignmentInteger* fastMallocMatchValidationValue(void* p)
{
return reinterpret_cast(static_cast(p) - sizeof(AllocAlignmentInteger));
}

// Set the AllocType tag to be associaged with the allocated block p.
inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
{
AllocAlignmentInteger* type = static_cast(p) - 1;
*type = static_cast(allocType);
}

// Handle a detected alloc/free mismatch. By default this calls CRASH().
void fastMallocMatchFailed(void* p);

} // namespace Internal

// This is a higher level function which is used by FastMalloc-using code.
inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
{
if (!p)
return;

Internal::setFastMallocMatchValidationType(p, allocType);
}

// This is a higher level function which is used by FastMalloc-using code.
inline void fastMallocMatchValidateFree(void* p, Internal::AllocType allocType)
{
if (!p)
return;

if (Internal::fastMallocMatchValidationType(p) != allocType)
Internal::fastMallocMatchFailed(p);
Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc); // Set it to this so that fastFree thinks it's OK.
}

#else

inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
{
}

inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
{
}

#endif

About typeStraits

Traits文档boost的写的比较好
http://www.boost.org/doc/libs/1_42_0/libs/type_traits/doc/html/index.html
// GCC's libstdc++ 20070724 and later supports C++ TR1 type_traits in the std namespace.
// VC10 (VS2010) and later support C++ TR1 type_traits in the std::tr1 namespace.
//
// opt::copy
// same semantics as std::copy
// calls memcpy where appropriate.
//

namespace detail{

template
I2 copy_imp(I1 first, I1 last, I2 out, const boost::integral_constant&)
{
while(first != last)
{
*out = *first;
++out;
++first;
}
return out;
}

template
T* copy_imp(const T* first, const T* last, T* out, const boost::true_type&)
{
memcpy(out, first, (last-first)*sizeof(T));
return out+(last-first);
}


}

template
inline I2 copy(I1 first, I1 last, I2 out)
{
//
// We can copy with memcpy if T has a trivial assignment operator,
// and if the iterator arguments are actually pointers (this last
// requirement we detect with overload resolution):
//
typedef typename std::iterator_traits::value_type value_type;
return detail::copy_imp(first, last, out, boost::has_trivial_assign());
}

webkit代码基本目录结构

1.JavaScriptCore，就是其javascript引擎，跨平台的，不同的平台有不同的JIT后端实现。
2.WebCore，包含所有的渲染逻辑，svg支持，图形，网络库等。
3.Webkit，被实际应用的前端，不同的平台有不同的实现，其主要目的就是作为webcore的客户端。
4.Webkit2，类chrome的多进程支持，集成后比chrome的外部方式有明显的优势。
5.JavascriptGlue，为了兼容老的mac平台代码，以后不再进行开发和维护

创新力问题

最近感觉自己少了很多创新力，特别是从春节回来以后，一直感觉自己处在疲倦的状态，
在没有回去前，我看什么都基本没有问题的，能看得个8成以上，而且做也能做出来。当
时，也有跟一些网络课程，比如stanford比较hit的ip或者是一些关于creativity的
但是最近越发难以集中精神了，是不是被一直消磨下去了？希望不是，总之，俺是有点打
算的，现在好像包袱不是很重了，起码在自己心理是这样子的，我或许能够腾出来，而这
一切，我想是需要计划，还有首要的勇气！
其实，有想法的人在世界上不缺乏，缺乏的是那种敢于去实现自己理想的人。
我要做的第一步，肯定是离开，但是，这其中可能需要很大的决心，而且走出第一步后
需要的毅力是难以想象的。
不管怎么样，谁会留在一个对自己的成长无帮助或则阻碍自己发展的地方呢？
plan, plan, plan it!

Property And Synthesize

gratuitousFloat has a dynamic directive—it is supported using direct method implementations;

nameAndAge does not have a dynamic directive, but this is the default value; it is supported using a direct method implementation (since it is read-only, it only requires a getter) with a specified name (nameAndAgeAsString).

@protocol Link
@property id next
@end

@interface MyClass : NSObject {
NSTimeInterval intervalSinceReferenceDate;
CGFloat gratuuitousFloat;
id nextLink;
}

@property (readonly) NSTimeInterval creationTimestamp;
@property (copy) NSString *name;
@property (readonly, getter=nameAndAgeAsString) NSString *nameAndAge;

@implementation MyClass

@synthesize creationTimestamp = intervalSinceReferenceDate, name;
// Synthesizing 'name' is an error in legacy runtimes;
// in modern runtimes, the instance variable is synthesized.

@synthesize next = nextLink;
// Uses instance variable "nextLink" for storage.

@dynamic gratuitousFloat;
// This directive is not strictly necessary.

- (CGFloat)gratuitousFloat {
return gratuitousFloat;
}
- (void)setGratuitousFloat:(CGFloat)aValue {
gratuitousFloat = aValue;
}

- (NSString *)nameAndAgeAsString {
return [NSString stringWithFormat:@"%@ (%fs)", [self name],
[NSDate timeIntervalSinceReferenceDate] - intervalSinceReferenceDate];
}

- (id)init {
if (self = [super init]) {
intervalSinceReferenceDate = [NSDate timeIntervalSinceReferenceDate];
}
return self;
}

- (void)dealloc {
[nextLink release];
[name release];
[super dealloc];
}

@end

about protocols

Protocols declare methods that can be implemented by any class.

To declare methods that others are expected to implement

To declare the interface to an object while concealing its class

To capture similarities among classes that are not hierarchically related

Formal Protocols

@protocol MyProtocol

- (void)requiredMethod;

@optional
- (void)anOptionalMethod;
- (void)anotherOptionalMethod;

@required
- (void)anotherRequiredMethod;

@end

Informal Protocols

@interface NSObject ( MyXMLSupport )
- initFromXMLRepresentation:(NSXMLElement *)XMLElement;
- (NSXMLElement *)XMLRepresentation;
@end

Adopting a Protocol
@interface ClassName : ItsSuperclass < protocol list >
Categories adopt protocols in much the same way:
@interface ClassName ( CategoryName ) < protocol list >

@interface Formatter : NSObject < Formatting, Prettifying >
@end

The Returned Object

Because an init... method might return an object other than the newly allocated receiver, or even return nil, it's important that programs use the value returned by the initialization method, not just that returned by alloc or allocWithZone.

dangerous:
id anObject = [SomeClass alloc];
[anObject init];
[anObject someOtherMessage];
fine:
id anObject = [[SomeClass alloc] init];
[anObject someOtherMessage];
better:
id anObject = [[SomeClass alloc] init];
if ( anObject )
[anObject someOtherMessage];
else
...

cocoa paradigm

A design pattern is a template for a design that solves a general, recurring problem in a particular context.
Cocoa is an object-oriented library of tools that contains many of the objects and methods needed to develop great applications for Mac.
An object consists of both data and methods for manipulating that data. An object is a instance of a class, which means that there is memory allocated for that specific instance of the class. Other objects or external code cannot access the object's data directly, but they request data from the object by sending messages to it.

An Single Object

Model-View-Controller (MVC) is a design pattern that was derived from Smalltalk. It proposes there types of objects in an application, separated by abstract boundaries and communicating with each other across those boundaries

Object relationships in the Model-View-Controller paradigm

Model objects hold data and define the logic that manipulates that data.
A view object represents something visible on the user interface (a window or a button, for example)
Controller Objects Acting as mediators between model objects and view objects in an application are controller objects. Controller objects communicate data back and forth between the model and view objects.
An outlet is an instance variable that identifies an object

Relationships in the target-action paradigm

Create the connection from the object that sends the message to the object that receives the message:

• To make an action connection, create the connection from an element in the user interface, such as a button or a text field, to the custom object you want to send the message to.

• To make an outlet connection, create the connection from the custom object to another object (another custom object or a user interface element) in the application.

一些个人评价

自从还领导以后，室内的管理感觉是在从放羊式逐渐过渡到主动式，但新的leader也不是我
想象那种能激励个人爆发潜力的人，其只求结果，不重视过程的管理模式也让许多人对他微
薄有词，在其眼里，所有的事件都只会对人说很简单，但是自己从来也不会干什么实事，只
在一边做要求，而且做事情没有套路，真怀疑这样子的人究竟有没有管理能力的！
引用 Kevin Kelly, Out of Control里面几句话来讲述我对这里的一些看法：
1.有目标，无计划，有组织，无纪律，无任何的治理概念。
2.讨论者不具备足够基础的背景知识，这就是无效率的会议为何如此众多的原因。
3.进行补丁式管理，任何问题都寄望于通过添加附加流程来小范围解决。
4.管理口号化，流于形式，却不去追究真正的问题根源。
5.主次不分，想到一出是一出，这是一场无序的灾难。

Earns from app store

In order to succeed in the app store. We have to do three things:
Getting noticed
Monetizing
Free
Paid
In-App Purchase
Hold your place

半知半解

人生充满了疑惑，最近尤为如此。很多时候，觉得自己本来能够干的事情不止是这些，而偏
偏有人让你去干琐碎繁杂的事情，这时候心底里总会来几声痛骂。尽管，你还是不得已去完
成这样的任务，可是，完成以后就是困惑，我从这些事情里面学习到了什么东西呢？我个人
的价值体现在哪里呢？为啥我要这样子干些三五九流人都能很顺利完成的工作。我的人生意
义难道就如此低微？

领导总是说这不对，那也不对，这些不用自己亲手去干活的人，是永远也不会知道这些东西
完成的难度的。在说话漂亮，口气极大，而做事情没有筹划的人手里工作，实在是折磨呀。
要我们怎么搞才会满意快活您一次呢！

其实，最近深深体验到的是第一印象的作用，如果人家对你的第一印象是很不错的，那么相
互共事的时候也会很好的对待你，当你遇到麻烦的时候也会很有可能宽容一下，而印象不好
的话，估计你得费个九牛二虎之力才能博得他一次的满意了，当然要是你还不小心犯错误，
那就肯定会狠狠的批评你了。

OpenGL ES Triangles Drawing Modes

There are three drawing modes in opengl es.

这么快就3月了

没有想到，时间过得这么快，春节回来后，一直处于恢复阶段，直到最近才

从懒惰中恢复过来。最近学到得东西还是不多，这个上升曲线也太平坦了，

心底下实在是过意不去呢。当然，已经很难从工作中享受到某种成就快感，

总之，一直处于十分压抑的环境中。后来，就只有搞了几个工具比较有创新

性，诚然，人家也不一定会欣赏你搞这些，比较这不是工作得一部分，不过

，既然对自己有用，就想着和大伙分享一下:)业余时间的生活也越发觉得不

爽，毕竟这里认识的人很少，就连一个同窗也没有，别说亲戚了，也就是说

自己在这里尚无可依靠得人。虽然自己心里是有计划的，但是很多人包括自

己也觉得那样子搞会十分危险，事情的发展可控性太差了，还是再观察一段

时期，再做一个抉择吧。
最近，开始看justice，一个哈佛的课程，以后有空再谈谈个人感受。

丢弃这个blog

本来想毕业以后放弃这个博客的，因为这里主要是记录了一些与技术相关的东西，而自己毕业以后并没有到一线技术公司工作，关于这点我一直感到十分无奈，所以连这里也想放弃算了，留着仅仅是当作一种纪念。
但是，最近突然心血来潮了，不但想重新启用这里，而且想做进一步的改进，包括技术主题和研究范围。所以，开始给这里更换模板主题，并且打算学习一些网页编辑技术来丰富它。
其实，我之前还曾经尝试使用live的blog服务的，因为它有很好离线writer，而且不用翻墙也能在国内访问，比起blogger这种被墙挡在外面的服务优势大着呢。可是作为一个曾经长久使用blogger的人，多多少少有一种感情在其中，经过不同角度的考虑、争扎和故地重游以后，决定重新回到这里。虽然不会有太多(或许是零个)认识的人会访问我这里，但是，就是喜欢这种没有拘束的写blog感觉，我想写什么就是什么。
诚然，我是希望有人会关注一下自己，不论是自己在生活中认识的或是网友都好，有多一些交流才会使得写的博客更有意思。同时，也会促进自己的技术理解，改进不足之处，提高技术造诣，还有当然就是提高写作能力方面之类的东西。如果失去了分享交流，仅仅是记录一些技术问题的话，我认为使用wiki item或者是思维导图的方式会比写blog更具优势，最后，不要忘记写博客也是一种完整过程性备忘的好方法。
我还想重新定位一下这里的方向，除了平时发对工作生活等方面发牢骚(这个方面没有twitter方便)和普通技术介绍以外，我还想学习写一种业界趋势方面的东西，虽然这些普遍都是一些很有经验的人才敢写的，但是我们年轻人也应该有自己的独特的视角的。以jobs的一句名言作为结尾"If you live each day as if it was your last, someday you'll most certainly be right."