Before coming to Mesosphere as an intern, I read the mesos paper and have a general understanding of it’s architecture, well none of these understanding is based on actual code. After 1.5 month in Mesosphere, contributing some code to the project, it’s necessary to connect both the general flow and code logic together.

Background

Mesos Architecture

There has been a pretty well explanation of different roles and relationships between these important components in Mesos.

In brief, we have several important concepts: Master, Agent/Slave, Framework (consisting of Scheduler and Executor). Master and Agent nodes are physical or virtual machines in datacenter. Master node is responsible for scheduling tasks (this “task” is our general understanding of task, meaning “a specific work to do, such as running a Spark job”, which is different from the definition of “task” in Mesos project), Agent node is responsible for running task. In order to scheduler and execute tasks in this distributed system, it’s necessary to have corresponding parts on both Master and Agent doing scheduling and executing work respectively. We call it Framework as a whole. The part that’s working on the Master node is called scheduler, the other part working on the Agent node is called executor. From this perspective, it’s pretty easy to understand how do these two names come from.

Since there might be multiple kind of tasks to run, we sometimes need to run multiple Frameworks (thus multiple schedulers, executors components) on Mesos, thus on the Master node, there might multiple schedulers, on Agent node, there might be multiple executors.

A Little Bit Further

What we have explained is general overview of Mesos architecture, having no relationship with actual implementation. If we look into the actual implementation, we need to know more background.

Libprocess

Inside the distributed system, one of the most important component we need is the communication mechanism between nodes or even processes running on nodes. Libprocess is what we implement and use inside Mesos. It abstracts the communication and event flow through actor programming style . In Libprocess, the fundamental entity is “Process”, which is an “actor” in actor programming style, no matter if two Processes are on the same node or different nodes, Libprocess provide asynchronous event handling between them. Thus it’s much easier for us to write logic, transfer information without worrying about which node the process is running. More specific programmer guide for Libprocess can be found here and here (in Chinese).

In our case we don’t have to know much detail about how Libprocess is implemented or used, we only need to know that in order to communicate inside Mesos, we can register handlers for certain message type and then handle them.

Flow

Then, let’s take a look at how Mesos makes it possible for a single task to be executed on the cluster with our given resource requirement.

Here is a diagram about how resource are offered and finally allocated for a specific task. In brief, there are 4 steps:

• Agent report resource (how many CPU, Memory you have) to Master
• Master offer the resource as resource Offers to Framework (specifically the scheduler running on Master)
• The Framework either reject (then the resource will be offered to other Frameworks) or accept the resource (then it should reply how many resource it will use, that task it wants to run)
• Given the accepted offer and related tasks (this is the “task” definition inside Mesos, it’s simpler, meaning a work that’s run on a node), the Master will send the task to the Agent from whom the resource is offered, specifically, the executor running on that Agent will execute the task and manage the status of the task.

With these 4 steps, we can have a general overview of how the whole procedure is managed. Let’s look into the code, finding the actual implementation.

In the section below, I’ll use function signature or short explanation instead of line numbers to represent the critical logic for the procedure, since line numbers might be changed. You can directly find these code by searching the function signature. And the hierarchical structure of these function signature means which logic is inside another or the inner logic is called by the function outside.

Critical Steps

• Agent report/register resources to Master

  * Master launch: void Master::initialize()
          * Master register message handlers: install<RegisterSlaveMessage>(
  * Slave launch: void Slave::initialize()
          * detect resource: Try<Resources> resources = Containerizer::resources(flags);
  * Slave detected master: void Slave::detected(
          * Slave::doReliableRegistration
                  * send RegisterSlaveMessage
  * Master receive and handle SlaveRegisterMessage: void Master::registerSlave(
          * void Master::__registerSlave(
                  * add SlaveInfo to current slave list
  

• Master send resource offer to framework (specifically the scheduler)

  * Master::offer(
          * send ResourceOffersMessage
  

• Framework accept the offer

  * sched process receive the OFFER event (ResourceOffersMessage can be translated into OFFER event)
          * src/sched/sched.cpp: case Event::OFFERS: {
                  * call   void resourceOffers(
                  * scheduler->resourceOffers(
                          * this function is to be implemented by specific scheduler, here we use test_http_framework.cpp as example
                          * launch task that’s inside staging list
                          * send ACCEPT Call
  * Master receive Accept Call: Master::accept(
          * validation
          * authorization
          * send RunTaskMessage: void Master::_accept(
  

• Slave launch the task on it’s executor

  * Slave receive RunTaskMessage
          * Slave::runTask(
          * Slave::run(
  * Executor launch the task
          * Executor::addTask(
          * Executor::launchTask(
                  * this is to be implemented by specific executor
  

From the analysis above, it’s pretty easy to know the whole procedure for proposing offers, generating tasks and finally get them executed on the node. And we can notice that two parts (scheduler, executor) contains code that can be implemented by the user. These two parts are what we should do if we want to implement a Framework that make it possible for own distributed application to run on Mesos. With Mesos, it abstract all these resource management, task scheduling work for us, then we don’t have to worry about these aspect when we are developing or using new distributed applications.

And I am not sure if you can find, it’s pretty easy to follow the logic or find certain logic by first looking at the function definition in .hpp file of master or slave, and then search for it’s reference, most of times, it will be pointing to a message handler, then we can search for that message type name and find where the message is generated. This will almost give us a complete view of the logic flow.

Rvalue reference:

• An rvalue reference is a reference that will bind only to a temporary object.

std::move, std::forward

• std::move

  * takes an object and allows you to treat it as a temporary (an rvalue)
  

• std::forward

  * has a single use case: to cast a templated function parameter (inside the function) to the value category (lvalue or rvalue) the caller used to pass it. 
  * This allows rvalue arguments to be passed on as rvalues, and lvalues to be passed on as lvalues, a scheme called "perfect forwarding."
  

operator =

• default implementation for operator= is copy

  * it copies each member, it’s calling the constructor that accepting the type on the right of the operator=
  * for example for base_string, the 7th constructor:
          * basic_string( const basic_string& other );
          * Copy constructor. Constructs the string with the copy of the contents of other.
  

• Thus in order for the the class type to accept rvalue reference, it should also have a constructor accepting a rvalue reference

  * and the constructor should be implemented by std::move
  * see the 8th constructor
  

move constructor

• Move constructors typically “steal” the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc.) rather than make copies of them

Incentive

Move semantics allows you to avoid unnecessary copies when working with temporary objects that are about to evaporate, and whose resources can safely be taken from that temporary object and used by another

If we are creating a temporary objects, and we know that it will only be used for the constructor, specifically it will be passed into the constructor as a class member. Then it’s better for the constructor to directly make the class member pointing to the value of that temporary objects.

class Type{
public Type(string str){
str = str; // it will definitely be copied
}

public Type(string& str_){
    str = str_; // it will also be copied, see the reference constructor (7th constructor) of base_string
}

public Type(string&& str_){
    str = std::move(str_); // first, std::move will ensure that str_ is accepted as a rvalue. Then this will call the rvalue constructor (also called move constructor) of base_string
}
    public string& str;

}

But if we are passing in the parameter as an object or reference.

• in object’s case, we know that it will be copied
• in reference’s case, we also know that it’s a copy constructor (explained above in the operator=)

thus in either case, it will be copied, this is not good for performance.

With rvalue reference as a parameter, and std::move/forward, we can let the class member directly pointing to the temporary object.

class Type{

public Type(string&& str_){
    // first, std::move will ensure that str_ is accepted as a rvalue. 
    // Then this will call the rvalue constructor (also called move constructor) of base_string
    str = std::move(str_);
}
    public string& str;

}

Case Study

Case 1

In Mesos project, we have this usage:

template
inline mesos::v1::Resource::DiskInfo createDiskInfo(Args&&… args)
{
return common::createDiskInfo(
std::forward(args)…);
}

It’s accepting Args, the parameter pack as a rvalue reference. The reason is that: our usage for these functions looks like this

Resource volume1 = Resources::parse(“disk”, “128”, “role1”).get();
volume1.mutable_disk()->CopyFrom(createDiskInfo(“id1”, “path1”));

where the parameters are strings and they are created specifically for the construction of the DiskInfo, thus in order to avoid copying the value, we accept rvalue reference for the parameter of the DiskInfo constructor, then it will call the move constructor of base_string, thus copies are avoided

Case 2

In the case below, the authorizer.get()->getObjectApprover return a Owned, and this is only used to construct the AuthorizationAcceptor. In the use of Owned, we don’t want to use to copy the value inside, since T is a shared pointer. To avoid that, we can either use Owned’s swap method, which swap the value inside the object. Or we can use rvalue reference to directly make the class member pointing to the original value.

Future> AuthorizationAcceptor::create(
const Option& principal,
const Option& authorizer,
const authorization::Action& action)
{
if (authorizer.isNone()) {
return Owned(
new AuthorizationAcceptor(Owned(
new AcceptingObjectApprover())));
}

const Option subject =
authorization::createSubject(principal);

return authorizer.get()->getObjectApprover(subject, action)
.then(= {
return Owned(
new AuthorizationAcceptor(approver));
});
}

References

• http://www.cprogramming.com/c++11/rvalue-references-and-move-semantics-in-c++11.html
• http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2027.html
• http://en.cppreference.com/w/cpp/string/basic_string/basic_string
• https://www.chromium.org/rvalue-references
• http://thbecker.net/articles/rvalue_references/section_04.html

Incentive

• Convolutional Neural Networks (CNN) are biologically-inspired variants of MLPs.
• Two basic cell types have been identified: Simple cells respond maximally to specific edge-like patterns within their receptive field. Complex cells have larger receptive fields and are locally invariant to the exact position of the pattern.

  Sparse Connectivity

• the inputs of hidden units in layer m are from a subset of units in layer m-1, units that have spatially contiguous receptive fields.

Local Receptive Field

• it’ll help to think instead of the inputs as a 28×28 square of neurons, whose values correspond to the 28×2828×28 pixel intensities we’re using as inputs
• we’ll connect the input pixels to a layer of hidden neurons. But we won’t connect every input pixel to every hidden neuron. Instead, we only make connections in small, localized regions of the input image.
• each neuron in the first hidden layer will be connected to a small region of the input neurons, say, for example, a 5×5 region
• if we have a 28×28 input image, and 5×5 local receptive fields, then there will be 24×24 neurons in the hidden layer.

Shared weights

• we’re going to use the same weights and bias for each of the 24×24 hidden neurons
• This means that all the neurons in the first hidden layer detect exactly the same feature, just at different locations in the input image
• We call the weights defining the feature map the shared weights, we call the bias defining the feature map in this way the shared bias
• A big advantage of sharing weights and biases is that it greatly reduces the number of parameters involved in a convolutional network.

Reference

• http://deeplearning.net/tutorial/lenet.html#sparse-connectivity
• http://neuralnetworksanddeeplearning.com/chap6.html

Max Pooling

• This is done to in part to help over-fitting by providing an abstracted form of the representation.
• As well, it reduces the computational cost by reducing the number of parameters to learn and provides basic translation invariance to the internal representation.

Different Gradient Descent Algorithms

Three variants of gradient descent

Batch gradient descent

• compute the gradient for the whole training dataset
• Cons: slow, may not be able to fit the whole memory

Stochastic gradient descent (SGD)

• performs a parameter update for each training example, and label
• Pros: (because of flutuation) can jump out of local minima
• Almost same convergence behavior as batch gradient

Mini-batch gradient descent

• performs an update for every mini-batch of n training examples

However, there are some challenges:

• Learning rate is difficult to choose
• There should be a schedule of learning rate, for example, decreasing the learning rate can help to converge
• Different features might need different learning rate, because some might be sparse, some might be dense
• Avoid being trapped in local minima

Optimized Solutions

Momentum

• Momentum is a method that helps accelerate SGD in the relevant direction
• This can help to overcome the problem of sparse feature updates
• But it might flutuate in and out of minima

Nesterov accelerated gradient

• Since momentum gives us a idea about where we are going to be
• We can look ahead at this future position and calculate the gradient, and then use this gradient to update current gradient

Adagrad

• adapts the learning rate to the parameters, performing larger updates for infrequent and smaller updates for frequent parameters.

Adadelta

• Instead of accumulating all past squared gradients, Adadelta restricts the window of accumulated past gradients to some fixed size w.

Adam

• Adaptive Moment Estimation (Adam) is another method that computes adaptive learning rates for each parameter. In addition to storing an exponentially decaying average of past squared gradients vtvt like Adadelta and RMSprop, Adam also keeps an exponentially decaying average of past gradients mtmt, similar to momentum:

Reference:

• http://sebastianruder.com/optimizing-gradient-descent/

Dropout

Incentive:

• Accomplish the effect of ‘combining prediction of many different models’, which can reduce test errors
• But this requires many neural networks or one neural network to be trained in different ways

Method:

• Randomly set 50% of output of each hidden neuron to be zero
• Thus these neurons do not participated in forward pass and back-propagation

Effect

• This effect is just like each time a different architecture, but all these architectures share same weights

Advantage

• Because neurons can not rely on the prescence of particular other neurons, so it reduces co-adaptation of neurons
• It forces neurons to learn more robust features

The LeNet5 architecture was fundamental because of several core concepts:

• image features are distributed across the entire image
• convolutions with learnable parameters are an effective way to extract similar features at multiple location with few parameters
• This is in contrast to using each pixel as a separate input of a large multi-layer neural network. LeNet5 explained that those should not be used in the first layer, because images are highly spatially correlated, and using individual pixel of the image as separate input features would not take advantage of these correlations.

Modeling the Learning Problem:

There are several approaches to automatic machine learning, but one of the most successful approaches can be called “numerical” or gradient-based learning. The learning machine computes a function where is the th input pattern, and W represents the collection of adjustable parameters in the system.
In our case, the pattern recognition problem, the output is the recognized label of patterns, or we can use probability associated with these labels as the output.

Then we should define the loss function, to measure the discrepancy between predicted pattern and the ground truth.

Then the learning process can be generalized as finding the value of W that minimize loss.

Relationship between error rate on test set and training set:

Generally, there is a equqation to represent the relationship between these variables:

the gap between the expected error rate on the test set and the error rate on the training set decreases with the number of training samples. P is the number of training samples, h is the measure of “efficient capacity” or complexity of the machine. is a number between 0.5 and 1.0, and is a constant. This gap always decreases when the number of training samples increases. Furthermore, as the capacity increases, decreases. Therefore, when increasing the capacity there is a tradeoff between the decrease of training error rate and the increase of the gap, with an optimal value of the capacity that achieves the lowest generalization error. Most learning algorithms attempt to minimize training error rate as well as some estimate of the gap.

Gradient-Based Learning

Since our goal is to minize the loss function. Gradient-based learning draws on the fact that it is generally much easier to minimize a reasonably smooth, continuous function than a discrete (combinatorial) function.

A simple way of updating the parameter W is to update it towards the gradient of minimizing the loss:

And there are several choices that we can make when we are updating the gradient, for example we can update the weight every time with one training data, or a batch of data.

Gradient Back Propagation

Gradient-based learning procedures have been used since the late 1950’s, but they were mostly limited to linear systems. The surprising usefulness of such simple gradient descent techniques for complex machine learning tasks was not widely realized until the following three events occurred.

• Realization that, despite early warnings to the contrary [12], the presence of local minima in the loss function does not seem to be a major problem in practice
• Popularization of a simple and efficient procedure to compute the gradient in a nonlinear system composed of several layers of processing, i.e., the back-propagation algorithm.
• Demonstration that the back-propagation procedure applied to multilayer NN’s with sigmoidal units can solve complicated learning tasks

Continuous Back Propagation

For NN of many layers, we can make back propagation through the network.
If the partial derivative of Ep with respect to Xn is known, then the partial derivatives of Ep with respect to Wn and Xn-1 can be computed through backward recurrence

Fully Connected Layer vs Convolutional Layer

Problem of using only fully connected layer:

• Using FC in the first layer with large number of hidden units can generate very large parameter set, which requires a lot of training data.
• FC have no built-in varience to deal with translations or local distortion of the input.
• Even if it can produce output that are invariant with respect to these variations, it would result in multiple units with similar weights pattern in various location

• this is the incentive for shared weights in conv layer

• Topology of the input is ignored, since any order of input are invariant to the FC layer

• this is also the incentive for conv layer

• While convolutional layer can deal with this problem

Core Ideas in Convolutional layer

Local receptive fields

• The idea of connecting units to local receptive fields on the input goes back to the perceptron in the early 1960’s, and it was almost simultaneous with Hubel and Wiesel’s discovery of locally sensitive,
• With local receptive fields neurons can extract elementary visual features such as oriented edges, endpoints, corners (or similar features in other signals such as speech spectrograms). These features are then combined by the subsequent layers in order to detect higher order features

Shared weights

• Units in a layer are organized in planes within which all the units share the same set of weights
• A complete convolutional layer is composed of several feature maps (with different weight vectors), so that multiple features can be extracted at each location
• As stated earlier, all the units in a feature map share the same set of 25 weights and the same bias, so they detect the same feature at all possible locations on the input

Spatial/temporal subsampling

• (Incentive) Not only is the precise position of each of those features irrelevant for identifying the pattern, it is potentially harmful because the positions are likely to vary for different instances of the character.
• A simple way to reduce the precision with which the position of distinctive features are encoded in a feature map is to reduce the spatial resolution of the feature map. This can be achieved with a so-called subsampling layer

Reference

• http://deeplearning.net/tutorial/lenet.html
• http://yann.lecun.com/exdb/lenet/
• http://blog.csdn.net/qiaofangjie/article/details/16826849

Layer Construction:

• Layer 0: Input image

  * Size: 227 x 227 x 3
  * Note that in the paper referenced above, the network diagram has 224x224x3 printed which appears to be a typo.
  

• Layer 1: Convolution with 96 filters, size 11×11, stride 4, padding 0

  * Size: 55 x 55 x 96
  * (227-11)/4 + 1 = 55 is the size of the outcome
  * 96 depth because 1 set denotes 1 filter and there are 96 filters
  

• Layer 2: Max-Pooling with 3×3 filter, stride 2

  * Size: 27 x 27 x 96
  * (55 – 3)/2 + 1 = 27 is size of outcome
  * depth is same as before, i.e. 96 because pooling is done independently on each layer
  

• Layer 3: Convolution with 256 filters, size 5×5, stride 1, padding 2

  * Size: 27 x 27 x 256
  * Because of padding of (5-1)/2=2, the original size is restored
  * 256 depth because of 256 filters
  

• Layer 4: Max-Pooling with 3×3 filter, stride 2

  * Size: 13 x 13 x 256
  * (27 – 3)/2 + 1 = 13 is size of outcome
  * Depth is same as before, i.e. 256 because pooling is done independently on each layer
  

  * Layer 5: Convolution with 384 filters, size 3×3, stride 1, padding 1

  * Size: 13 x 13 x 384
  * Because of padding of (3-1)/2=1, the original size is restored
  * 384 depth because of 384 filters
  

• Layer 6: Convolution with 384 filters, size 3×3, stride 1, padding 1

  * Size: 13 x 13 x 384
  * Because of padding of (3-1)/2=1, the original size is restored
  * 384 depth because of 384 filters
  

• Layer 7: Convolution with 256 filters, size 3×3, stride 1, padding 1

  * Size: 13 x 13 x 256
  * Because of padding of (3-1)/2=1, the original size is restored
  * 256 depth because of 256 filters
  

• Layer 8: Max-Pooling with 3×3 filter, stride 2

  * Size: 6 x 6 x 256
  * (13 – 3)/2 + 1 = 6 is size of outcome
  * Depth is same as before, i.e. 256 because pooling is done independently on each layer
  

• Layer 9: Fully Connected with 4096 neuron

  * In this later, each of the 6x6x256=9216 pixels are fed into each of the 4096 neurons and weights determined by back-propagation.
  

• Layer 10: Fully Connected with 4096 neuron

  * Similar to layer #9
  

• Layer 11: Fully Connected with 1000 neurons

  * This is the last layer and has 1000 neurons because IMAGENET data has 1000 classes to be predicted.
  

Parameter size:

Layer 0:

• Memory: 227 x 227 x 3

Layer 1: (conv + ReLU + LRN)

• Memory: 55 x 55 x 96 x 3 (because of ReLU and LRN)
• Weights: 11 x 11 x 3 x 96

Layer 2: (pooling)

• Memory: 27 x 27 x 96

Layer 3: (conv + ReLU + LRN)

• Memory: 27 x 27 x 256 x 3 (because of ReLU and LRN)
• Weights: 5 x 5 x 96 x 256

Layer 4: (pooling)

• Memory: 13 x 13 x 256

Layer 5: (conv + ReLU)

• Memory: 13 x 13 x 384 x 2 (because of ReLU)
• Weights: 3 x 3 x 256 x 384

Layer 6: (conv + ReLU)

• Memory: 13 x 13 x 384 x 2 (because of ReLU)
• Weights: 3 x 3 x 384 x 384

Layer 7: (conv + ReLU)

• Memory: 13 x 13 x 256 x 2 (because of ReLU)
• Weights: 3 x 3 x 384 x 256

Layer 8: (pooling)

• Memory: 6 x 6 x 256

Layer 9: (FC + ReLU + Dropout)

• Memory: 4096 x 3 (because of ReLU and Dropout)
• Weights: 4096 x (6 x 6 x 256)

Layer 9: (FC + ReLU + Dropout)

• Memory: 4096 x 3 (because of ReLU and Dropout)
• Weights: 4096 x 4096

Layer 10: (FC)

• Memory: 1000
• Weights: 4096 x 1000

Total (label and softmax not included)

• Memory: 2.24 million
• Weights: 62.37 million

Reference:

• https://www.analyticsvidhya.com/blog/2016/04/deep-learning-computer-vision-introduction-convolution-neural-networks/
• http://www.cs.toronto.edu/~guerzhoy/tf_alexnet/myalexnet_forward.py
• http://hacker.duanshishi.com/?p=1661
• https://github.com/tflearn/tflearn/blob/master/examples/images/alexnet.py
• http://www.jeyzhang.com/tensorflow-learning-notes-2.html

Visualization

• https://dgschwend.github.io/netscope/#/preset/alexnet

Analysis

ReLU layer for activation

• ReLUs have the desirable property that they do not require input normalization to prevent them from saturating
• this make the network converges faster than original tanh activation function

LRN

• But with ReLU, the output of that layer is not normalized as tanh or sigmoid. So we need a normalization layer to make the output normalized

There are two ways utilized to reduce overfitting: more data; more robust network structure.

Data Augmentation (more data)

• Translation and horizontal reflection
• later the intensities of RGB channels

Dropout (more robust network structure)

Incentive:

• Accomplish the effect of ‘combining prediction of many different models’, which can reduce test errors
• But this requires many neural networks or one neural network to be trained in different ways

Method:

• Randomly set 50% of output of each hidden neuron to be zero
• Thus these neurons do not participated in forward pass and back-propagation

Effect

• This effect is just like each time a different architecture, but all these architectures share same weights

Advantage

• Because neurons can not rely on the prescence of particular other neurons, so it reduces co-adaptation of neurons
• It forces neurons to learn more robust features

This is a Google-Doc-like online document collaboration web application. Instead of supporting complicated Word document formating or simple plaint text format, we chose to implement a flexible, widely-used format: Markdown. In order to make it fully customized, I decided to implement all syntax by myself, this left room for more customized syntax. In this project, I am mainly responsible for the websocket communication, Markdown syntax parse and data synchronization. Thanks for efficient and funny collaboration with Jiupeng, Lu and Shiyue :)

Project Brief

• Description: A online collaborative markdown editor that support real-time synchornized edit of multiple users
• Related Techques: Javascript, Python, Websocket, Syntax tree, Django
• Features & Markdown Parse: real-time, line-based parse without referencing any other libraries. supported syntax include: heading, code block, list, nested list, bold, hyper text, underline, image.
• Feature & Collaborative Editing: edit operation synchronize with all other users, utilize different types of operations to represent operations. Restore cursor position to avoid cursor conflict
• Feature & File Management: Support document create, update, delete and access control
• Duration: 2016.09 - 2016.12
• Team member: Hongkun Leng, Rui Lu, Jiupeng Sun, Shiyue Liu
• Project Url: 52.87.188.28/login.html

Features:

Markdown Edit & Display

• The editing page is mainly splited into two parts, the left part is the editing area, the right is the display area.
• User can edit markdown text in the left area, while the translated markdown text will be displayed in the right area

Realtime Editing

• There would be multiple users viewing one document and one (or multiple) user writing a document (the first milestone is to develop single-writer multiple-users mode)
• When the writer is editing the document, the edited content would be displayed realtime on all viewers’ display area

Create, List, Delete Documents

• There is a personal page where the user can see all his documents (documents created by him and shared with him)
• The user can create a new document by clicking on the “Add” button
• For every document listed under the page, there would be a “Delete” button, user can delete the button to remove the document from his documents. (When the owner of the documents delete the document, all users the owner shared with would also have the document removed from their list)

Access Control

• At any time, there would be only one user who has the writing control of the document
• The user can share his document with other users by clicking the “Edit” button on each document and add the target user in the poping up dialog
• A viewing user of a document can request the writing permission of a document by clicking the “Request” button on document editing page. Then, there would be a notification requesting the document writer-permission on current writer’s editing page, if the current writer accepts the request, then the writing control is transferred to the requesting user.
• After all users go offline, the write control is taken back to server. And the control will be given to the first user who access the document next time.

Design & Wireframe

Design & Visual Design

Data Flow & Server-Client Communication

Development & Markdown Parse

Supported Genetic Notations:

• Heading
• Bold
• List
• Quote
• Paragraph

Supported Nested Notations:

• Bold in paragraph, quote, list
• Nested List

Single Line Notations

• Heading
• Paragraph

Multiple Line Notations

• List
• Quote

Process procedure

• after every line, put current element into stack
• if current depth is deeper than the stack >> into the stack
• if current depth is smaller or equal to the stack depth >> pop out (the poped out element end), add the element into the

Supported Structure

• Cross-line element: quote, table
• In-line nested element: li,
• In-line genetic element: bold, italic, hypertext, image, @time

Basic Procedure

Pre-line parse

• since quote is a cross-line element and it violate the structure of line parsing (although in same line, it still consider next line as it’s children)

  we need pre-process the depth first (add depth to every line after quote start)

Line parse

• Give each line it’s basic element type

  since genetic inline-element such as bold, italic are not basic line element, it should be replaced with paragraph element

In-line parse

• inside some line element (paragraph, li), we should parse inside these element

IO for Each Step

1. Pre-line parse

• input: lines
• output: lineObject(raw_text, depth, content_start)

1. Line parse

• input: lineObject
• output: element(raw_text[excerpt_the heading], depth, )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ElementObject{
     type:
     name:
     depth: //only useful for line-element and cross-line element
     raw_text:
     children:[]
     display_text: “”//if the element has this, this means it does not has children
     parsed:true //flag for whether this element is parsed


     function:parse_inside(){
          
     }
     function:get_html(){
          //return the jQuery node
     }
}

This is a brief tutorial for Django setup, only critical steps are noted, it aims serve as a quick reference when you want to setup a Django project or when yo forget some part of it. For more detailed information, please see official tutorial

Create a Project

• $ django-admin startproject [project name]

Project Structure

1
2
3
4
5
6
7

mysite/
    manage.py
    mysite/
        __init__.py(empty file, indicates it’s a package)
        settings.py(configuration for this project)
        urls.py(url declarations)
        wsgi.py

Run Server

• python manage.py runserver ([port]/[url:port])

Projects vs App

• App is a web application (blog system, database)
• Project is a collection of apps for a particular website
• Project can contains multiple apps, an app can be in multiple projects

Create App

• python manage.py startapp [app name]

App Structure

1
2
3
4
5
6
7
8
9

polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py

Here, we should write the view part first

Step 1:

• Create urls.py in your app
• Map the url (in urls.py)
  e.g.: url(r’^$’, views.index, name=‘index’)
• Include that in project urls
  e.g.: url(r’calculator/‘, include(‘calculator.urls’))

URL routing with parameters

• url(r’^delete_item/(?P\d+)$’, shared_todo_list.views.delete_item)

Creating Models

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class PostModel(models.Model):
    content = models.CharField(max_length=100)
    id = models.AutoField(null=False, primary_key=True)
    TYPE_CHOICE = (
        ("IMG", "image"),
        ("TEXT", "text"),
    )
    type = models.CharField(max_length=100, choices=TYPE_CHOICE)
    img = models.ImageField(upload_to="grumblr/static/", max_length=500, blank=True)
    author = models.ForeignKey(UserModel, default="")
    update_date = models.DateTimeField(auto_now=True)
    create_date = models.DateTimeField(auto_now_add=True)
    likes = models.IntegerField(default=0)
    dislikes = models.IntegerField(default=0)
    comments = models.ManyToManyField("CommentModel")

Creating Form and form Validation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class RegistrationForm(forms.Form):
    username = forms.CharField(max_length=20)
    first_name = forms.CharField(max_length=20)
    last_name = forms.CharField(max_length=20)
    email = forms.CharField(max_length=40, label='Email')
    password = forms.CharField(max_length=20,
                               label='Password',
                               widget=forms.PasswordInput())
    password_confirm = forms.CharField(max_length=20,
                                       label='Confirm password',
                                       widget=forms.PasswordInput())
    age = forms.IntegerField(label="Age")
    bio = forms.CharField(label="Short Bio", max_length=200)
    avatar = forms.ImageField(required=False)

    def clean(self):
        cleaned_data = super(RegistrationForm, self).clean()

        username = cleaned_data.get('username')
        password = cleaned_data.get('password')
        password_confirm = cleaned_data.get('password_confirm')
        if password and password_confirm and password != password_confirm:
            raise forms.ValidationError("Passwords did not match.")
        if len(User.objects.filter(username=username)) > 0:
            raise forms.ValidationError("User already exist")

Form validation and Model Referencing

1
2
3
4
5
6
7
8
9

form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
    avatar = form.cleaned_data['avatar']
    new_user = User(username=form.cleaned_data['username'], last_name=form.cleaned_data['last_name'],
                    first_name=form.cleaned_data['first_name'], email=form.cleaned_data['email'],
                    password=form.cleaned_data['password'],
                    avatar=avatar, bio=form.cleaned_data['bio'], age=form.cleaned_data['age'])
    new_user.set_password(form.cleaned_data['password'])
    new_user.save()

Basic Template Usage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

\{\% extends "profile_base.html" %}
\{\% load staticfiles %}
\{\% block headers %}
    <title>Follow</title>
    <link href="\{\% static "css/bootstrap.min.css" %}" rel="stylesheet">
    <link href="\{\% static "css/nav.css" %}" rel="stylesheet">
    <link href="\{\% static "css/profile.css" %}" rel="stylesheet">
    <link href="\{\% static "css/feed.css" %}" rel="stylesheet">
    <link href="\{\% static "css/follow.css" %}" rel="stylesheet">
    <script src="\{\% static "js/jquery-3.1.0.min.js" %}"></script>
    <script src="\{\% static "js/bootstrap.min.js" %}"></script>
    <script src="\{\% static "js/feed.js" %}"></script>

\{\% endblock %}
\{\% block content %}
    <ol id="follow-list">
        \{\% for u in data.list %}
            <li class="follow-item">
                <div>
                    <a class="follow-avatar-container" href="\{\% url 'user' user_id=u.id %}">
                        \{\% if u.avatar %}
                            <img class="follow-avatar" src="../../../">
                        \{\% else %}
                            <img class="follow-avatar" src="\{\% static "img/avatar.jpg" %}">
                        \{\% endif %}
                    </a>
                    <div class="follow-content-container">
                        <div class="follow-first-line">
                            <a class="follow-author" href="\{\% url 'user' user_id=u.id %}">
                                </a>
                        </div>
                        <div class="follow-second-line">
                            <p class="feed-content-text">Age:  &nbsp; Bio: </p>
                        </div>
                    </div>
                </div>
            </li>

        \{\% endfor %}

    </ol>
\{\% endblock %}

安全感和生活方式

这一个月里对生活质量的容忍程度让自己都感到惊讶。曾经每天晒太阳喝咖啡的自己突然开始每天八点半起床一天学习十四个小时，曾经为了吃一餐饭纠结一上午的自己突然将就着炒个饭凑合一天，也不记得活动范围多久没有超出过学校和住所一公里了，然而每天的重复和重复并没有让自己感到厌倦，这份执着像是无尽的油井，支撑着整个人的运转。在找到安全感之前，我的生活是保守的，几乎没有娱乐，没有休息，没有工作和生存必须之外的任何事情。我不确定这种生活方式是否可持续，但我可以确信的是目标不远了。

平凡和不平凡

这地方看上去和其他地方并没有什么明显的不同，和其他地方一样难吃的餐馆，街上一样不时有乞讨的人，虽然和自己过马路的行人里可能有某个顶级实验室的教授，但他们的穿着并不会有什么不同。身份的不同在这里并不能非常明显地被区分出来，在我们能看到的那部分里，院长和前台职员的不同可能主要是他们进了不同的办公室。言语，自信，穿着，收入这些在国内会是非常明显的身份标识在美国被弱化，尤其在这个很喜欢把平等摆到台面上的国家。学生从中最大的收益莫过于平等的交流机会，同样的课堂里，教授被摆在和学生平等的位置上（甚至很多教室里学生的座位比老师高，哈哈哈哈）同时每个学生也拥有平等的学习机会，经常出现的是在国内可能会被批评为蠢的问题也被很和蔼地详细地解答。这些看似平常的事情在国内却不太容易发生，不平凡也体现在这里。

态度

对待学习这个过程的态度让人印象深刻。首先是授课者对教学的态度，我没有了解过教授们备课的过程，但是从课堂表现上可以明显感觉到，他们对自己教的内容有非常深刻的理解。Search Engine 课程里老师能够很自信地说课上讲到的哪些策略被哪些公司使用着；学生提到的任何代码问题，老师都能很快分析原因并做出改正。对于不懂的地方他们可以很自信地说 “Sorry, I don’t know, but I am sure that can be figured out soon”。一手创办几个国际顶级会议的教授每节课都主动问学生的反馈并每学期修改课程计划。Piazza 里也几乎有问必答，这种勤恳和自信出现一个学术界有很高地位的人身上让人尤为印象深刻。

同样端正的是学生对待学习的态度。或是迫于严格的课程要求，或是被身边紧张的学习氛围感染，几乎每个人都很卖力地学习。并不是因为他们不厉害，而是他们身边有更厉害的人，这种显性或是隐性的差距感时刻驱动着人们投入更多的时间和精力。

环境

借用 “Mobile Pervasive Computing” 里的一句话：“真正的科技是无处不在却又无法明显被感知的”，真正有效率的学习环境也是无处不在却又不容易感知的。学校里各种各样职业的人们忙碌着，只为了能够提供一个舒适的学习环境。除了怎样把作业做好（对中国学生来说还有食物的口味）之外，几乎没有什么需要担心的。为了避免影响行人，校园警卫大部分都骑自行车，校园卡坐市内公交免费，晚上回家有巴士接送，各处的打印机，直饮水，绝大部分地方靠校园卡都可以自助出入，这些都不特别，但没了其中任何一样都会多很多不便。这一切都努力地运行着，只为了我们能更少的注意到他们的存在。

自信

另一方面的收获是自信，作为一个非 CS 专业，尝试过各种开发方式但很少深入研究底层原理的开发者，能够在这里补足一直缺失的 CS 知识，更充分地理解整个系统的运行原理，开发过程中会多很多自信。除此之外这里高压环境下锻炼出来的技能也是自信的来源。一周看十篇论文的同时从零写一个基本的搜索框架和一个微博网站，经历过这些之后在大多数技术问题面前自己变得更加从容。在这里，任何方面的技术问题都可以找到对应的学习途径或是寻求到帮助，足够的关注度投入下，绝大部分问题最终都只是时间或是方式问题。

———— 2016. 9. 22 夜

虽然文章内容是我整理出来的，但最主要的工作是和可爱的室友们一起完成的，非常感谢这样一群可爱的室友~。如果你觉得指南里有不够完善或者不够准确的地方请指出，也欢迎加入我们一起完善这份文档，给以后的学弟学妹（尤其是学妹）提供有价值的信息~

BTW，我们通过这套指南里的方法找到了性价比超高的一套房子，现在刚好却一个室友（五缺一），如果你是一个有生活态度的人，一个有责任感的人，或者一个有趣的人，欢迎加入~

合作编辑：冷宏坤（蒜苗白菜-INI-Mobility）、丁晓都（胖胖胖丁）、姚逸云（姚托尼）、陈同广等等

前置知识

1）房子的分类及区别

• Apartment
• House
• Studio

美国的房子一般可分为下列几种: house 是独栋的房子，通常有好几个房间，车库，还有独立的草坪和院子。condominium (常简称为 condo)，是指一栋建筑分属不同的住户，而住户通常拥有该公寓的产权。townhouse 则是指相连的透天住户，通常只有很小的院子，但房子本身都有二到三层楼，空间可以得到充分地利用。一般刚来美国的人住的都是 apartment。美国的 apartment 通常是由专门的租赁公司来经营管理的。如果公寓再细分的话，通常有 studio (或称 efficiency，中文则可翻成是套房)、one-bedroom (一房一厅) 跟 two-bedroom apartment (二房一厅) 这几种。差别在于 studio 的客厅、厨房和卧房是连在一起的，它除了浴室之外没有其它任何隔间。

好的 Apartment 和 Studio 会贵一些，House 则相对便宜，但需要自己支付 全部 Utility（水电气费）。

• Studio：指工作室，也有种叫efficiency的也差不多，就是只有一个房间，bedroom和living room是混在一起的，有厨房有卫生间。其他房型都有一个living room，一般都是一个很大的客厅，和厨房连通，有的能住两个人。类似国内的单间公寓；环境相对较好，不用跟其他人共用设施；
• House，包含厨房，地下室，房子一般是普通人家的住房，所以房型包括日常家居用到的大部分方面：客厅、厨房、（1-8间）卧室、洗手间、地下室（possible）、院子（possible）、阳台（possible）
• Apartment， 就是公寓啦，整栋楼都是由一个公司管理，有一个统一的leasing office，水电费他们也可以代收（VA的相当于是每月除房租外还要交水电费，但是都放在一起交；而学校附近的公寓一般都是utility included，就是房价包含水电费），维修什么的都很方便。

中华人民共和国外务司，你知道么？在国外租房子时应该说什么？

GWU学生租房的一些注意事项

2）能够普遍接受的价格

关于价钱及舒适度，这个得具体情况具体分析，房子质量，附带设施，离学校远近，所在区域及是哪家公司管理等等因素都会影响房价，所以没有一个房价的大概范围。经过不完整统计，房租（不包含 Utility 费用）在 400-800 之间浮动。

如果想详细了解房租，建议通过下一节提供的房源网站上去瞄一眼，基本就能有个概念了。

3) Utility 价格

在签协议之前，需要确认房租是否包含 Utility (水电气费)。一般 Apartment 水费都包含，而 House 的水费需要自己出，水费里还包含垃圾处理费，大约 ；电费每月大概50/month；电费每月大概 20-；匹兹堡的冬天很长，冬季取暖是个重要的问题，如果气费只是厨房炉灶，大概50/month；匹兹堡的冬天很长，冬季取暖是 个重要的问题，如果气费只是厨房炉灶，大概20-，但如果包含暖气费则需40/month，但如果包含 暖气费则需100-$200/month。

4）哪里找房子（房源）

这里列出几个常用的网站

• Craigslist (https://pittsburgh.craigslist.org/)。这里有些类似国内的 58 和赶集，上面不仅可以租到房子，还可以买卖各种二手物品。因为商品来源比较混杂，所以商品的质量不够稳定，买之前需要仔细评估是否靠谱。
• Zillow（https://www.zillow.com），专门的房租租赁平台，上面的房源质量相对较高，对应的价格也会比 craigslist 上的普遍价格高一些。
• Walkscore (https://www.walkscore.com/)

使用建议：

• 使用地图来判断距离，同时对于 craigslist 上的房源，容易出现重复的状况，所以可以通过地图去掉重复的。
• ​

（需要完善：几个平台的 1. 具体介绍；2. 优劣； 3. 使用技巧）

5）看房需要注意的几个方面

• 价格（可以参考普遍价格以及具体地段）

• 位置（基本遵从就近原则，具体的“距离”和“方便程度”的关系后面会具体讲）
• 犯罪率
• 采光（optional）
• 周边设施（公交站、超市、餐馆）
• 供暖方式（gas, electricity）/价格
• 房间大小

6）餐馆、超市等生活服务的重要程度

超市最多一周去一次，所以对距离不敏感。

对于餐馆，不同人的评价不一，所以具体看个人的口味儿来决定重要程度。

7）公交的便利程度

大部分同学使用公交。大多数地区（具体包括哪些？），二十分钟以内可以到达，所以有公交之后距离可以不用太在意

需要在意的是：地方远但是没有公交的情况

8）地域介绍

9）房源搜集

内容较多，请查看对应的 Google Doc 文档 - CMU 租房指南的最后一章~

有幸以学员、分享者、实习生的身份体验并参与到这家公司的的服务流程中。从最开始对这家公司一无所知，到听朋友推荐这家公司，到目前与这家公司的员工共事，走过了比较典型的几个阶段。这样几个角色给了我相对全面的角度评价这个公司。
但在思考和评价时难免受到利益相关的影响，不一定能够做到足够客观，如果同学们发现有不实或者需要完善的地方欢迎指出。

实际体验

因为申请节奏很紧，我是在开始写文书的前十天左右才知道这家公司。在那时，一起申请的小伙伴相比我对这个公司有更多关注。“这家公司的风格看上去不一样，你可以感受一下他们的官网”，同为 IT 爱好者的他是这么介绍给我的，“你可以关注他们的微信公众号，里面经常有各种微信讲座”。从一开始我就决定选择 DIY 为主的申请策略，所以当时已经确定只在文书这唯一一个无法独立完成的环节使用留学中介服务。当时的备选项还有身边同学（我 GAP 一年所以他们已经申请结束）使用过的文书服务、校内学长学姐组织的文书服务团队以及传统的留学中介公司（某道，某通，某傻，某德等等）；当时直接否定了传统留学服务，一方面是在准备 GT 过程中长期收到来自他们的各类电话、短信骚扰，聊天内容大多是无脑的寒暄、机械的背景分析或是某某某成功案例，感受不到任何诚意。另一方面让人产生反感的是这类公司在推荐服务时几乎不会推荐单独的文书服务，只要发现你离申请截止还有一段时间就开始极力推荐整套服务，我个人对这种行为有强烈的反感。排除这些服务提供商之后我又搜集了身边人的口碑传播的服务商，排除一些评价都不够全面的文书服务（一部分原因是他们的背景中文书比重较低，另一部分原因是服务本身原因），剩下包括棕榈在内的三家服务提供商。

真正让我决定用这家公司服务的是它的“试聊”环节，和棕榈大道负责市场的学长联系上之后发现可以免费最多和三位学长/导师进行十五分钟的试聊，这样一个很有诚意的环节吸引了我。第一次试聊对象是一个斯坦福的博士学长，学长的背景很厉害，但是和我要申请的主要项目（CMU 部分项目以及 MEng 项目等）以及我的背景优劣（我的背景优势在于经历丰富，而斯坦福学长的优势在于学术能力和学习成绩）有一定差异，所以决定尝试第二次试聊。第二次试聊的对象是一位来自 CMU 的学长，目前在 Uber 工作。简要同步双方的信息之后（建议尝试试聊前提前准备好自己的背景信息，最好提前能发给试聊对象看一遍，提高 15 分钟的利用率），一方面觉得学长的背景和我相近，另一方面发现学长提出的申请思路和我自己的想法类似，所以决定选择这位学长当我的文书导师。几次沟通之后， 和学长越来越熟悉，开始称他“超哥”。超哥的背景经历丰富，看过他的简历之后深感自己活在一片荒芜中，更重要的是超哥懂得自我包装自我展示的价值（这里的“包装”没有贬义，更多的是“选择合适的角度进行展示”，“选择合适的描述方式将自己经历的价值最大化”）。虽然从聊天里能感觉出他是一个不喜欢啰嗦的人，没多久他便主动提出免费帮我修改简历，他的“实诚”和热情让人在苦恼的申请过程中多了不少安全感。

文书服务的具体内容包括：背景分析，素材挖掘，提纲建立，内容指导，语言润色服务。因为服务合同里有明确的时间限制，所以我在每次服务之前都提前准备好了所有可能用到的材料，同时超哥也比较爽快，每次环节本来一个小时的服务一般都超出了二十分钟他也主动抹去超出的部分。因为是他的专业和我的申请方向几乎是一样的，所以每个阶段的内容准备都进行得很顺利，我的哪些经历适合拿出来说，经历里的哪些侧面适合单独列出来等等他都根据自己的专业背景以及文书经验很快做出决定。所以选择一个了解自己的背景和申请项目的导师是非常重要的。同时一个专业的文书导师会有较高的职业素养，他们会要求把文书内容不断完善，一旦有新的想法和新的描述方式都会积极跟进修改，超哥的每次文书 review ，即便 review 的内容是他已经修改过一次的都能对内容有新的要求。

这里我提到的“导师”主要基本都是专业对应的学长学姐，他们能够在文书里帮助确定基本素材，素材的描述侧面，素材的描述方式，大致的用词。更加精确的语言层面修饰是由专门的 Native Speaker 负责的，文书服务的倒数第二个环节是交给 Native Speaker 做修改，我一共用到了两次语言修改（一次是破例争取到的），每次修改都几乎全篇 40% 以上的词语都被优化调整到更加符合歪果仁表述习惯的表达。抱着好奇的心态，我搜了一下修改稿的署名，发现一个 Native Speaker 是斯坦福毕业的从事语言/编辑工作的歪果仁学姐，一个是哥大心理学院的会各种乐器的歪果仁小哥。整体来讲修改的效果很不错（另一个利益不相关的有多年文书服务经验的学姐也给了积极评价）。

这里需要单独给同学的建议有两点：

1. 注重效率。真正有价值的服务都是有严格时间限制的，一分钱一分货，所以建议不管是使用谁家的服务，都尽力提高服务效率。一方面在服务前准备好资料并让双方都了解必要信息；另一方面服务过程中尽量把控服务效率，出现响应速度慢的时候及时指出并纠正。为了提高信息同步效率，我每次服务用到的信息都列在文档里提前发过去，同时我也特地选择了 Google Doc 进行文书修改，提高文书协作的效率。
2. 主动争取。留学行业的一大特点就是目前所有环节几乎都由人来操作，同时服务人群和被服务人群的素质普遍较高。只要是人来执行的服务，都是可以通过主动争取来换取更高的服务质量或者更多服务机会的。例如我当时申请的项目有十七个，文书至少有五个不同方向（这里的方向指的是 CS 的领域细分以及项目要求的细分），棕榈服务囊括的只有其中两个方向，其他几篇文书虽然大部分相同，但是仍然有明显区别，通过主动协调，超哥也帮我 review 了其他几个方向的文书。这样的效率是比较高的，避免了再找其他导师重新了解背景，分析背景等等步骤。

这家公司与传统留学服务公司的区别

私以为评价留学服务的最重要准则是给你提供服务的这群人是否真正了解并在乎你的专业和背景

1. 传统公司的强运营

传统留学中介的运作是典型的强运营模式。公司的大部分投入都在营销上，关于留学机构华丽效果的包装广告布满校园和地铁公交站；各类”成功学长/学姐“的讲座铺天盖地；市场和销售人员非常能说，过分夸大/断章取义的成功案例描述让刚接触留学服务的同学无所适从。为什么会产生这样一个现象呢？一方面是因为留学行业是典型的信息不对称行业。（虽然大部分有用信息都是可以通过互联网获取到的）国内外招生流程的巨大差别以及国外录取评判标准的多样化和不确定性造成了同一个标准/现象有不同的解释；强势的营销力量让各类渠道充斥着不实甚至相互矛盾的描述；这样的场景下虽然信息”多“，但学生能够确信的信息是极其有限的；对于信息检索和处理能力不足的同学很容易造成困惑，这时候如果有一个人/机构能够站在”专业的角度“给一个确切的结论会极大地提升安全感；而留学中介一方有着相对丰富的信息获取渠道以及较多的历史案例。他们就能站在”专业的角度“凭借这种信息不对称，利用、夸大、甚至捏造最终效果。另一方面，国人严重的”花钱买安全感“的理念加剧了这种现象。大部分同学天真地以为相比自己 DIY，多付钱留学服务的这份钱能够买到更好的效果，其实不然。

与强运营形成典型对比的是”弱实力“，大部分传统留学中介公司的主要精力放在市场营销上。那些市场/营销人员除了口头禅一样的几个成功案例，几个常用申请步骤，几个公式一样的背景分析之外根本谈不上理解留学申请。经过”拉人头“（市场营销）这一步之后学生就被分配到导师辅导阶段，这里的导师除了倒背如流的申请硬技巧（申请流程、背景和项目的一一对应，文书模版等等），很少真正了解你所申请的专业，甚至大部分负责某个专业申请的导师根本没有过相关专业的任何留学、工作经历，他们懂的是在学生的背景和申请项目之间划上一个等号，这个等号的意义在于最大程度保证学生”不失学“以及他们最小的投入和最大的收入之间的平衡。从我的个人接触以及身边同学的实际体验来看，”弱实力“绝对是对大部分传统留学中介公司的准确评价。

说到这里，大部分同学也可以明白为什么考完 G/T 或者参加完讲座之后来自各种留学机构持续不断的骚扰。他们打电话来时”机械的礼貌用语“之后甚至都读不全我们的姓名和专业，造成的效果只能叫”骚扰“了。

2. 类C2C模式

就像之前说的，留学中介行业最重要的评价标准是服务你的人真正了解并看中你做的事情。哪里能够找到这样一群人呢？所有群体里，在商业化(scalability, management) 和服务质量之间能够达到最好平衡的群体就是已经在读或者读过对应专业的学长学姐了，他们以过来人的身份，不仅以第一人称走过你要申请的项目的全部流程，能够更加深刻地体会你的感受以及解决你遇到的问题，同时他们贴近或者仍然是学生身份，和学生的沟通效率更高。

找到了这样一群人，怎样把他们组织起来，让更多的人能够享受到他们的服务呢？我们见到的很多本专业出国 QQ/微信群其实是一种组织形式。这些微信群提供了我们获知的大部分“靠谱信息”，但是这种组织形式比较松散，同时也缺乏全面性。松散是因为对于服务提供者和服务接受者之间只有一层松散的学籍关系，无法完成更深入的工作（简单讲，不是很熟的学长不会帮你改文书的）。缺乏全面性是因为学长学姐仅局限于本专业或者本校，但国外一个项目招生面覆盖多个国家多个大学，仅凭本校的参考样本无法做一个完善的预估并获取全面的服务。当然，有一种简单粗暴的解决方式是跟学长学姐之间达成利益关系，这也是很多校内文书/留学服务机构存在的一个理论依据。但是这种形式仍然无法完全摆脱上述提到的两大弊端。

回到正题，棕榈大道解决了这样一个问题。他们通过自身影响力以及利益关系构建了这样一个更加系统性的体系。这样一个平台让学生和学长学姐能够达成有效的服务与被服务关系，同时补充完善这个关系（用系统化的管理让服务更加高效，提供背景提升的机会，文书内容把控等等辅助服务），让之前提到的这样一群合适的人的价值最大化。从结构上我更想把这个平台看成 Customer to Customer （C2C）而非 Business to Customer，因为服务提供端也是由一群用户（学长学姐）组成。

这里已经可以很明显地看出这种模式和传统中介模式的巨大差异。在我看来，通过合理的管理，这种新体系的势能是足以颠覆传统模式的。

需要单独说的是，单看棕榈本身提供的服务（背景提升，信息获取，文书内容把控），是比较接近传统留学服务公司的服务内容的，这部分服务的价值也是非常巨大的，但是它的巨大价值是基于我前面提到的那群真正了解并看中你的专业和背景的人的。

3. 新媒体和口碑传播

传统中介给人最直接的烦恼是频繁持续的骚扰。其原因是之前讲到过的留学行业里营销的重要性。营销的价值是无可替代的，尤其对于这个信息不对称的行业，但是需要找到合适的方式。传统留学行业的营销重点仍然停留在”增大受众面（通过各种合法/非法手段获取更多预备留学生的联系方式）“和”提高转化率（挖苦同行，鼓吹、断章取义甚至捏造成功案例）“上。而新媒体的产生给营销提供了一个更高效，人性化的渠道。看过黎万强的《参与感》的同学能够理解在新互联网形式下口碑传播的重要程度，基于微信，微博，知乎等新媒体的传播比传统的地毯式盲扫来得更有效果同时给受众带来更小负面影响。

棕榈是一家运行在微信上的公司。公司的几乎所有运营活动都基于微信，微信群讲座，公众号文章分享，甚至连文书的修改审核都是通过微信发送的（更不谈公司内部沟通几乎只用微信，公司人均微信号个数超过 1.5 等等）。同时棕榈也很注重其他新媒体渠道的传播（比如他们催这篇知乎回答催了半个月（却不给稿费））。

新媒体和口碑传播带来的优势在哪里呢？首先，人机工程学上，预备留学生群体的计算机熟练水平是远高于普遍水平的，对新媒体的融入程度也远高于普遍水平。简单讲就是这群人用得更多也更相信新媒体上获取的信息。另一方面，基于新媒体的口碑传播自然地过滤了无用信息，自然地对信息做了筛选和有用性区分，降低了对受众的负面影响并提升了信息性价比。基于这样一个传统渠道无法比拟的优势，新媒体在未来会成为整个留学服务行业的普遍传播方式。

4. 人员普遍素质较高

这是我不太喜欢提到的一点，尤其是每次看到一堆学历/学校排名的罗列，但它的普遍价值仍然不能忽视。虽然我们不能以学位/学校/社会地位区分人的实际能力。但是这家公司员工以及聘请的导师的普遍学历/学校排名都看起来很华丽，一定程度上保证了服务提供者的基本素质和服务质量。

5. 重视技术

这也是一家很重视技术的公司，相信目前没有其他一家留学服务公司的 CTO 能够有这家公司 CTO 的位置重要性（可能其他家都不一定有 CTO ）。作为一个 IT 从业者，最开始让我对这家公司产生好感的其实是他家的网站，和那一堆上世纪门户网站风格或是诈骗网站风格的传统留学公司网站产生了鲜明对比。同时他们对技术的使用不仅仅局限于公司形象上。公司的服务也一定程度上依托于技术带来的优势：文书流程的几个重要步骤都可以使用到棕榈开发的文书工具，讲座分享活动也通过棕榈开发的 app 进行。作为一个开发实习生，我也感受到了公司在技术上的自由和追求（这里就不细讲了），整体来讲，这是一家认识到并发挥技术力量的公司。这也是我赞同的一点，从我对整个行业（不完整但足够典型）的观察，技术是可以极大程度上革新这个行业的，目前这个阶段，除了组织形式，技术也是帮助这家公司破局的一大支点。

然而存在的问题仍然很明显

前面看似夸奖了这么多，背后真正的原因是这个行业亟待革新而棕榈在这个风口上走得相对靠前，但这绝对不意味着这个公司是完善的。从我不多的接触里，已经发现一些明显并且会有长远影响的问题。

这里我从 服务接受者（学员），服务提供者（导师）和服务参与者（实习生）来阐述我发现的几个侧面的问题。这里的对比标准是我最熟悉的也是所有行业里效率最高的 IT 行业，看似标准严苛，在我看来是这个行业未来的合理要求也是让公司在行业 stand out 不得不考虑的地方。

1. 服务流程的低效和组织松散

前面讲过，棕榈的 C2C 模式让最适合的一群人给学生提供服务，和传统的 B2C 模式（公司来提供留学、文书服务）对比，质量优势明显。但是管理这样一群人并让整个系统可拓展（scale up）不是一件容易的事情。棕榈雇佣的导师（学长学姐）大都身处国外，文书服务只是他们学习/生活里很小的一部分，雇佣的束缚力有限，同时加上时差的问题，造成了服务响应的不及时，经常出现服务请求长时间无响应或者沟通效率低下的状态。

另一方面，棕榈本身偏向员工的自我管理，但对应的任务/时间分配不够科学导致在导师和学员中间协调的员工也会出现响应不及时的状态，直接的例子是第一次决定使用棕榈服务时我在官方微信号留言无果，三次主动打电话才有员工帮助协调服务。后期的文书流程也出现不同程度的进度协调问题，如果不是主动推动进度，整体效率会明显降低。

不论是导师的角色、时区这样的外部因素还是公司管理内部因素造成了这样的问题，用户都会降低对这家公司的评价，也不可能因为这些原因容忍服务中出现的问题。

2. 反馈流程不通畅/执行力不足

这里更多的是以实习生和导师的角度来阐述，希望给同学们的评估提供一定的参考。

在我以不同身份的接触过程中，遇到过多次来自自己或者身边人的反馈被长期搁置没有回复的情况。以 IT 行业的视角，用户体验是一个公司维持服务质量，公司形象的重要侧面，而对反馈的响应是优化用户体验的重要环节，如果没办法及时得到响应，再多的反馈也没有意义。

基于微信的纯线上运作带来了众多好处，但是多方面（营销、沟通协调、内部管理、服务提供）的事务混淆在一起会让任务和时间的管理变得混乱。微信作为一个通用的生活化的通信工具，没有针对不同类型事务做适配，时间/任务管理意识不强的人难以在多个角色中高效切换，造成了一定程度上的效率底下。

以上内容希望能够给同学们在评估这家公司的服务质量或者高效使用这家公司服务的过程中提供一些帮助。效果或褒或贬，我能做到的是尽量接近客观观点。

Life is a box of chocolate, you will never know what you are going to get.

记得大二时曾有一个学姐跟我说：“你不要觉得现在你生活中看到的种种限制，生活中的种种妥协都无法接受，等到你到这个时候你也不得不考虑这些方方面面，你会觉得这些是正常的”。然而到现在，我仍然不接受她的“正常”。我更坚信的是文章前的那句阿甘的妈妈曾经说过的话。

不可思议

Gap，一年从零开始准备，GPA 81，EE 申请 CS，第一眼看到这样的背景，对比目前收到来自 CMU 的四个 offer (MSIT-Mobility, MSIT-SE, MSIT-ESE, Ebiz)，很多人会觉得不可思议。

回顾这一年，我曾经很多次想过我收到满意的 offer 的时候会是怎样的表情。当我准备英语的时候，当我向朋友们解释我为什么要出国的时候，当我考试前一天临晨的三点无法入睡的时候，当我每天晚上十点从图书馆骑着死飞经过寒风和月光的时候。然而，但我真正拿到 offer 的时候，我的心情却出奇地平静。我脑海里浮现的是 Augustana 的 《Boston》，那是我无数次面对的景象，站在满是人群的都市里，眼前看到的却是反射出耀眼阳光的无垠冰原。”I think that I’ll go to Boston, I think that I’m just tired … no one knows my name”

痛苦

我曾经放弃了非常有价值的实习机会，那里有一群我一生也不会忘记的有意思的人；曾经因为出国而不得不跟前女友分手，因为我无法接受两个人身处异国的状态；曾经放弃很好的一群创业伙伴；也因为出国错过了可能是我人生中唯一的一次的毕业活动；临近毕业，因为和学术会议的时间冲突，我计划了半年甚至连机票、旅馆、海洋馆都订好的台湾行也不得不放弃；然而比起这些，独自奋斗在一条自己都无法预料结果的路上产生的强烈犹豫状态是最让人痛苦的。当一个人长时间面对无法预知的未来的时候，当现实一次次敲打着自己的选择时，理性会被重重怀疑所包围。我曾经怀疑过自己的大学是否应该这样过。如果我和大多数人一样从大一就开始为出国做准备，大二开始准备英语，大三开始写论文，现在的结果是不是会更好？曾经怀疑自己是否应该加入团队，团队的时间对自己的意义在哪里？这是一个非常糟糕的状态，一旦一个人开始怀疑自己的过去，开始否定自己曾经坚信的选择，他的意志世界也会开始坍塌。所幸我是一个非常乐观的人，本能让我能够很快忘记经历里绝大部分不愉快的经历。在无数次拿着筷子的思考，躺在床上的思考，洗手间里的思考之后，我终于找到和合适的角度看待自己的过去。这就是我的过去，一切我经历的，选择的，同时也包括我做错的。这些让我成为现在的自己，成就了一个 GPA 很差但却经历丰富的我，成就了一个经历曲折但却越来越乐观的我。大部分人通过某种方式成功并不意味着用其他方式是不能成功的。虽然坎坷，但这条成功之路是可行的。

念念不忘，必有回响

既然出国之路这么痛苦，当初为什么要做这个选择呢？为什么要顶着家里的压力，朋友的质疑选择出国这条路呢？这也是我一直在思考的问题，对于每个历经千辛万苦出国的人，这个问题的答案对于他们也一定有着特殊的意义。

我的答案植根在我的特质里：我是一个不接受妥协的人。如果我认定一件事情重要而且是对的，它一定会被完成，可能中间会因为某些原因把计划搁置，但是我一定会在某个时间想起这件事情并把它完成。说到这里，其实我大二就想过出国，然而当时给自己的答案是”一定会出国，但是貌似现在时间不太够，别人都是大一就开始准备的，现在开始准备太晚了(大二还嫌晚，当时是怎么想的啊！)”。然而，但是的这样一个答复不仅没有打消自己的念头，反而像牛皮纸一样包住了火苗，随着时间的推移，随着经历的丰富，出国的念头越烧越大，终于在实习快要结束那几天爆发，我终于再也无法控制住冲动，在房间里踱步了整个下午，第二天就把想法告诉了同事。

尽管我出生在一个出处都是妥协的家庭里，小到生活的细节，大到人生决定，我却不愿意妥协于任何事情。I want to go abroad, because I want to find a place where I can influence the world with the biggest impact. 在我的出国准备过程不断深入时，我也发现大多数有想法的人出国的目的和我是一致的。我对于自己所处环境的某些侧面很敏感，国内的环境直接或者间接地带来非常多的限制，人际关系、世俗观念等等让我没法纯粹地做一件事情，我需要到国外寻找更大的可能性。我不想妥协于这些限制，也不想把自己的时间浪费在这些我觉得不重要的地方(当然，如果有一天环境变了或者我的关注点变了，我也会回来)。我非常反感的一种论调：”现在的环境你仍然可以 xxx 啊”。对，即便是在受限制的环境下我是可以 xxx，但是为什么不把自己放到更自由的环境里，让自己有限的时间去关注一些更加重要的事情呢？我想到国外更自由的环境去培养我的兴趣，寻找自己的潜力，同时让自己的能力最大化。

对，那里并没有保证会有我想要的环境，那里并不是每个人的天堂，但是山的那头有光亮照进来，至于那是一颗太阳还是一场火灾，我更相信那是太阳，与生俱来的直觉告诉我那是太阳，从小到大我就是寻着这股光亮走到了现在这里，我也要靠着这股直觉走到山的那头。“而且你还这么年轻，有什么好怕的呢”

收获

最大的收获：当你认定要做一件事情时，你的潜力是无法估量的

这句话听起来非常抽象，非常平常，但是生活中最有价值的事情往往都可以用一两句无比平常的话概括。

我准备出国时，除了一个想法什么都没有。经济上、成绩上一片惨淡。没有收入，大二开始就没有正经上过课，三年没有学过英语，甚至因为变量的命名拼错单词被批评好几次，没有任何研究经历。最大的压力来自身边的人，他们或出于关心，或出于对自己能力的不确信，最终都不约而同地劝阻我出国的想法。抱着这个想法，我在和整个世界战斗，找实验室，创业，丰富自己的经历，从零开始学英语，早上距离闹钟声两分钟时自动爬起来，中午不敢睡超过二十分钟，我从未想到过自己可以做到这些。然而我确实做到了，当你认定一件事情足够重要，即便难度再大，也是绝对可以完成的。

Be Critical

在申请过程中我们会听到各种声音，他们可能来自跟我们差不多背景的申请者，或者来自更厉害项目的申请者。”加权没过 85 就别考虑这个项目了”，”xxx 学校不会看文书的”，”你这样不行的”，各种 No No No, 对于一个刚开始了解这个领域的人来说无疑是巨大的打击或者阻挠。其实他们这么说是可以理解的，他们并没有编造任何内容，只是说出了自己通过 general path 成功的经验而已。而作为有劣势的我们，为了避免不必要的打击，也为了形成自己的独立观点，就需要用 critical 的态度去看待这些”过来人”的经验。当你批判性地看很多观点时，你会尝试质疑很多大多数人接受的观点，会开始思考这些观点背后的成因。比如说，为什么要写 personal statement。很多人把这个当做申请过程中的一个必要文件，把自己的经历罗列在上面就行。但是我们批判性地思考这个问题是我们会发现 personal statement 的最终目的是帮助 professor 更好地评估申请者的信息，他们需要知道的不只是一些 static figures，同时也需要你更加丰满的经历以及这些经历背后的推动力和自己的独立思考。当思考到这里时我们就很容易想清楚，哪些项目看重 personal statement 以及有些项目为什么不看重 personal statement。看重 personal statement 的项目大都是很 practical 的学校以及对实际能力有较高要求的项目，因为他们没法只通过 static figures 看出一个人的实际能力。一些项目不看重 personal statement 是因为一方面申请者的数量太多而通过分数筛选申请者的素质已经都很高了，他们的 personal statement 区别并没有很大；另一方面，由于长期的在 personal statement 中充斥夸大的、俗套的内容行业做法降低了 personal statement 的可信度。再深入一层，如果一个项目看重 personal statement，我可以怎样增加自己的申请对 professor 的吸引力：尝试找到 professor 看重的那些没法用 static figures 展示的侧面(technical details, diversity)，用各种方式强调自己的这些侧面(比如 portforlio，personal website 等，在 experience 背后传达出自己对行业的思考)。

The Power of Friend

不管是自己身边的朋友们，那些在申请中和自己身处同样环境，愿意提供力所能及帮助的人们。生活方面，因为没有任何经济来源，同时我决定后面自己负担生活费用，所以提前找好基友借了一笔钱，这笔钱支撑着我这半年的生活所需，没有他的帮助，整个过程会崎岖很多。同样重要的是来自朋友们的慰问和照顾，虽然没有选择跟我一样的人生道路，但是伙伴们都很努力地站在我的角度给我提供来自同龄人的建议和安慰，这些对于一个正在和未知战斗的人来说是莫大的动力。另一方面的帮助来自申请过程中具体的环节。选择项目过程中来自室友和校友的亲身经历和建议，写文书过程中认识的 seventeen, 超哥。有趣的是我发现了留学服务这个行业的一些独特现象，也和 seventeen 有过很多有意思的探讨，从她的个人经历和坚韧乐观性格里获取到源源不断的动力，she is a really persistent, opitmistic and unique girl。出国的这个人群是一个非常独特的人群，他们比大多数人更加努力，更加愿意分享自己的经验成果，更加懂得”未来”和”想法”的价值。在这个群体里我也有幸认识了很多让我深受折服的人们，谢谢你们。

—— 2016 年 3 月 24 日

三个月前埋下的知乎彩蛋：收到心仪的 offer 是怎样的体验

For one thing, excessive information has been one of the most wide-spread and significant problem people are faced with.

For the other, I am a person who care much about efficiency. With a limited amount time, we can not extend the whole length of our time but to make the best use of useful time.

What’s more, reading is an important habit in my daily life. (Although it was always sacrificed for other insignificant things)

Get back to the point.

What should a efficient-reading app looks like?

In my opinion, there are two important rules/goals for us to follow when we are designing such a application.

• Efficient information organization. (For instance, important/highly-used information should be displayed in high priority)
• Abundant, clear, fast user interactions. (For instance, a key should appear when and only when I am in front of a door)

Here is my solution for one simple case: news reading.
This app was originally designed for a RSS reading application, while I did not have enough time to finish the development. But I think some ideas behind this design is important and inspiring for design in other application.

Overview

This app is made up of only two main pages: article list page and article content page (I also call it “article consumption page”)

Then I will explain how I apply two fundamental rules I mentioned above in my design.

Information Organization

Let me take the article list page as an example. In this page, there is no any decorative, complex or useless information. Every information, from icons to titles to images, have clear and direct meaning.

Before designing this page, I wrote down all necessary information that might appear in this page. And then arranged them according to their content-importance, appearing-frequence and content length/size.

After doing this preparation, I can evaluate importance for every information and design it’s appropriate appearance. For each design entity, there are several important characteristics which influence it’s “weight” in information structure: position, size, color, weight(for fonts).

Information in this page are organized in a hierarchy structure:

After making this information structure, we can organize information into specific section/layout. Then, in specific section, information are arranged according to their “weight”

As you can notice, the only decorative effect used in this design is shadow. Shadow is one of the fundamental effect for idendifying depth for each layer. In addition, it has little influence on information structure.

Same rules are also followed by article page:

In this page, information are organized according to their weight.

Apparently, article content is the heaviest information in this page. When this page is scrolled and navigation bar will disappear. I made full use of translucent mode in mobile device, this mode makes the whole page immersive.

Efficient User Interaction

1. Easy way to find useful information

Because of the efficient organization of information, users can find useful information in a short time: the most useful information is placed in the most noticable position with the most noticable style (Big size, bold font).

2. Easy way to accomplish some operations

There is always a contradiction between interaction instruction and simplicity/clearity of the design. If you want to tell users “you can do this by clicking this button”, you have to make extra visual effort on this button.

While considering the user base of this application (people of high knowledge level and mobile device interaction experience). I make many easy-to-understand interaction invisible. While users can learn these interactions easily after their first useage.

For example, fast operation for marking a article read is accomplished by swiping the article item left. There will be both visual and physical instructions during their operation: ticking icon will appear when user swipe left to a distance; the device will vibrate slightly when “read” operation is accomplished.

There is similar interaction in article page:

Users can swipe up to leave current article page when they are at bottom of the article. Without this interaction, they have to click on the left corner of this page to close current page.

The most important thing: I found myself a cooking talent!

Last month, my trial in western dishes was pretty successful (although these dishes are quite basic). This time, I experimented some dishes with more skills, such as the control of temperature, degree of salt, and the use of pot (rolling and shifting).

Here are some outcomes:

Baked potatoes (with cheese)

Cheese can be cooked with anything!
A old Chinese saying: Cheese is Power

Braised ribs

It tasted really sweet and juicy
Cooking that dishes require extraordinary patience and skill in stir frying

Anpan

It’s my first trial in baking grain food. Without a blender, I knead the grain compound for a hour. While I can only gave it 7/10 point since a blender could knead the compound more completely.

Fired pho with eggs and vegetables

Simple as it looks, this food is the touchstone of one’s cooking skills. Because it requires not only the skill in temperature management (expecially difficult on a gas furnace) but also the skill in rolling pans, both of these skills are quite difficult for amateur.

Here are some recent dishes I cooked.

Crispy strawberry

Pizza (with pineapple, peppers and cheese on it)

Fried potatoes (the second looks like fried chicken)

I can state with confidence that it’s the best fried potato I have eaten.

Fired Golden Rice Cakes

This food is of Chinese tradition. Actually, it’s not even familiar for most Chinese. It has cellular structure, just like beehive, but tastes like rice cakes

I am particularly interested in mobile industry. On a broad side, “mobile industry” include not only mobile phones but also wearable devices such as Google glasses/Holo Lens and VR devices. I care not only about current problems facing the industry such as energy consumption, excessive information overload, but also the future development of this industry: The ultimate form of mobile, I think, is a wearable “Personal Assistant”, an adaptable, open platform which could help people handle daily tasks and information. We are not talking about imagination or scenes in some movies, but an appropriate deduction from current trends, and there have been some trials towards this direction:

Infrastructure Side

On the infrastructure side, platforms should be able to get all informations a user has to handle. These information contains not only information from open, accessible internet sites, but also user information inside applications. For example, a helpful Personal Assistant could not only alert you of the upcoming rain, but also recommend appropriate schedules according to your personal preferences (if you can not go out today, maybe you can try your favorite new game in your Xbox). To solve this problem, “Deep Linking” and “In-App Search/App Indexing” technologies enable some platforms to gather and organize informations not only in network but also in isolated applications.

Existing Trials and Ultimate Goal

There have been some successful trials towards organizing information on some platforms. For example, Global Search in iOS and Google Now are examples are able to search information from all sources (the internet, information inside your applications). On the “assistant” side, however, this is not enough, we still have to handle excessive, repeated, useless information by ourselves. For the future development, “personal assistant” powered by big data and artificial intelligence could gather, tag, merge all these informations and even judge people’s needs through their previous behaviors and current condition.

My Trials

And I have made some trials: I developed three applications which focus on different stages of “handling and consuming excessive information”. During my internship in SnapPea, I developed the notification management feature which could manage notification information in mobiles according to their priorities and contents. During my startup experience in Nightingale, I developed web crawlers and an application to gather and screen useful information for users. In addition, my personal project “Weio”, a Weibo (Chinese Twitter) client, tried to provide better user experience when people are “consuming” information of different type such as website inside tweet, long image inside tweet.

A book about how to build companies that create new things

The challenge of the future

Critical question: what important truth do very few people agree with you?

1.Globalization and technology

Globalization: copy from somewhere to everywhere
Technology: zero to one progress, not automatic
Startup, where new technology comes from

Party like it’s 1999

Prosperous
Malaise: 92-94
Dot-com mania: 98-00
Paypal mania: 99

1.Lesson of dogma

• Make incremental advance: suspect and humble
• Stay lean and flexible: try things out and be experimental
• Improve on competition: start with existing customer
• Focus on product, not sales: technology is primarily about product development

2.Opposite principles

• It’s better to risk boldness than triviality
• A bad plan is better than no plan
• Competitive markets destroy profits
• Sales matters just as much as product

All happy companies are different (monopoly)

Competition and monopoly

Lies people tell

• Monopoly companies show their competition
• Competitive companies show their monopoly

Competitive ecosystem pushes people toward ruthlessness or death

Monopoly is bad only in static world, world in dynamic enable companies to invent new and better things, creative monopolists give customer more choice

Because of historical relic, economists are obsessed with competition

The ideology of competition

Competition is an ideology that pervades our society and distorts our thinking

Competition causes us to overemphasize old opportunities and slavishly copy what has worked in the past, people are obsessed with honor and pride

Last mover advantage

Cash flow, importance of futher profits

1.Characteristics of Monopoly

• Proprietary Technology: brings in 10 time improvement
• Network Effects: start with small, significant spread
• Economies of Sale: potential for great scale built into its first design
• Branding, but not begin with brand rather than substance

2.Building a Monopoly

• Start Small and Monopolize
• Scaling Up
• Don’t Disrupt, disruption: use new tech to introduce a low-end product at low prices. Disruption distorts self-understanding, attract attention from big companies

The Last Will be First

You are not a lottery ticket

Success is not luck not accidental

1.Control your future

• Indefinite Pessimism: wait for it to happen
• Definite Pessimism: future can be known, must prepare for it
• Definite Optimism: future will be better if he plans and works to make it
• Indefinite Optimism: future will be better, doesn’t know how

2.Our indefinite optimisim world

• Indefinite Finance
• Indefinite Politics
• Indefinite Philosophy
• Indefinite Life

Is it possible to be indefinite optimisim?
Darwin’s theory is not suitable for startup

We should make long-term planning

Follow the money

Power law: 80% & 20%
VC get profits from a small handful of companies, however every single company in a good venture portfolio must have the potential to succeed at vast scale
Why they oversee power law? it is clear only over time
What to do with the power law? One market can be better than all others,

Secrets

It seems that there has been no secret left in the world.

1.Why people believe that there are no hard secrets left?

• Geography secrets are explored, we are taught to proceeds one very small step a time
• Risk aversion, scared of being wrong
• Complacency, comfortable enough
• Flatness, high competitive market make the world “flat”

2.What if there is no secret?

• No injustice
• Economics, faith in efficient markets, HP stop innovative movement

Actually still many secrets left

3.How to find secrets?

Secrets about nature and secrets about people

Best place to look for secrets is where no one else is looking

4.What to do with secrets?

Only tell to specific people

Foundation

Beginnings are special, a startup messed up its foundation can not be fixed

1.Founding matrimony

Good co-founder

2.ownership, possession, control

Small board as possible

Everyone involved in your company should be full-time

Low CEO pay

Equity is a powerful tool, be careful with it
extending the founding

Company Culture

1.Beyond professionalism

Be tightly knit instead of transactional

2.Recruiting Conspirators

Give a good answer that is specific to your company to talented people

Everyone in your company should be different in the same way
be obsessed with same thing

3.Do One Thing

Everyone’s responsibility is unique

4.Like a Cult

Extreme dedication

Sales

Nerds are skeptical of advertising, while advertising is necessary
sale is hidden

1.How to Sell a Product

Different sales(according to price)

• Complex sales, few each year, every detail requires close persoanl attention
• Personal sales

Distribution Doldrums
Marketing and Advertising

2.Vital Marketing

in Paypal growth

3.The Power Law of Distribution

Even one working distribution channel is ok

Man and Machine
will machine replace human?

4.Substitution & Complementarity

• Globalization means Substitution, compete for same resource
• Technology means Complementarity, computer compete for none, human and computer are categorically different

5.Complementary Business

Example of Palantir

6.The ideology of Computer Science

People are enchanted by big data, however, computer can not solve problems alone

Green technology (Failure and example)

Mania and bust for green technology
Why fail?

• The Engineer Question: can you create breakthrough technology instead of incremental improvements?
• The Timing Question: is now the right time to start your particular business?
• The Monopoly Question: are you starting with a big share of a small market?
• The People Question: do you have the right team
• The Distribution Question: do you have a way to not just create but deliver your product?
• The Durability Question: will your market possible be defensible 10 and 20 years into the future?
• The Secret Question: have you identified a unique opportunity that others don’t see?

The Founder’s Paradox

1.Distribution of Traits

Founder have extreme combination of traits

Same condition or even worse condition than other groups, while they had lower heart disease rate.

Not physical factors such as exercise, gene, location
But social group habit

Opportunity (some prerequisite knowledge)

1.The Matthew Effect:

• These have abundance should be given, while these have not should be taken away

• Success in hockey game: birth date

• These birth between January and March have more time to practice and to become physical maturity, these advantage can accumulate

2.The 10,000 Hour Rule (Accumulation makes for success):

• Joy and Beatles’s success: opportunities to practice for 10,000 hours

• Same work for other celebrities

3.The Trouble with Geniuses (Genius guarantee no success):

• Christopher Langan, highest IQ ever, however he lived in misery

• Lewis Terman’s study of Genetic Studies of Genius. And he found that people with highest IQ were not these most successful

• So, extraordinary is less about talent but opportunities

• To be Nobel Prize winner, you have to be smart enough, but smart is not everything.

• Oppenheimer’s example: also met some similar obstacles, while he succeed in the end.

• In higher level, practical intelligence, the ability to convince, to judge appropriate chance, play more important role.

The Three Lessons from Joe Flom

Joe Flom’s story: Brilliant immigrant kid overcomes poverty and the Depression and finally got his success.

However, after close investigation, we can find a series of stories behind his success and then draw a different conclusion.

1.Lesson One: The Importance of Being Jewish ( Provide them chances )

• Although Joe had excellent ability, he was rejected for his background: being Jewish

• And traditional law firms did not touch proxy fights, so they had enough chance for further development

2.Lesson Two: Demographic Luck

• Although Joe’s father was as same intillegent as Joe, while he had no such demogaphic advantage: At Joe’s time, after the
  Depression there were more opportunities and less competitions.

3.Lesson Three: The Garment Industry and Meaningful Work

• Business behind little girls’ aprons

• Jewish immigrants were different: they had city business experiences. Came with business or professional skills such as dressmaking or sewing was a stroke of extraordinary good fortune

• Three things make meaningful: atonomy, complexity and connection between effort and reward

• Growing in environment with “meaningful” work prepare children for upper reaches

• Tailor/Garment Maker >> Garment Maker >> Lawyer/Doctor

Legacy

1.Harlan, Kentucky

• Continuous fights between families

• Cultures of honor behind these behaviors: their ancestors lived in highlands and other marginally fertile areas. Thus their survival depended on aggressiveness

• A survey showed that this legacy went on and on, even after they left their homeland

2.The Ethnic Theory of Plane Crashes

• Continuous crashes for Korea Airline
  Plane crashes are much more likely to result from an accumulation of minor difficulties

• Low-power distance culture and high-power distance culture

• Culture’s Consequences: difference in culture background make comunication between people less effective, less clear

Rice Paddies and Math Tests

Cultivating rice requires diligence, patience

Counting number and arithmetic operations are easier in Chinese

Advantages could accumulate, and math require no higher IQ but diligence

Rice paddies have exactly these advantages

A investigation on solving a math problem: diligence bring in better math capability

Marita’s Bargain

KIPP had higher academic performance, especially in mathematics, although they had physical disadvantages

More time for study instead of more time for respite

Research in high school about different social classes: Although they grew the same in school, but child in lower social classes grew little during their vacations.

A Jamaican Story

My mother’s path to success isn’t true. We should know its background

Color game: the whiter you are, the better life you have

This culture brought in success in their child.

在写文书之前我们需要对文书的目的有一个明确的目的，虽然这个目的可能很概括很抽象，但是它可以在必要的时候给我们方向上的引导和一些有价值的提示。
Statement of Purpose。 从名字上可以看出，这是一篇表明目的的文章：1.你需要说明你为什么选这个项目（your side）；2.你为什么符合这个项目的要求（admission officers’ side）。所以你可以看出这不是一个简单地说“我有多厉害”而且要说明你的经历背后的逻辑以及你对于自己未来发展的思考。从这些价值来看，文书是评价一个申请者非常重要的方面，它不是简单的成绩和数字，而是一个更加生动更加完整的申请者的面貌。所以很多招生官会将文书作为首先看的一个部分，用这个来串联你的硬件条件和经历。CMU 的 eBusiness 项目据说最看重的是文书部分而不是三围。

很悲惨的现实

理想状态上来看，文书是最能体现一个申请者真实能力和想法的部分，所以应该是申请中非常重要的部分，然而很多学校却越来越不重视文书，有些学校甚至是不看文书的。在我看来，两个原因决定了这样的局面：

• 看文书是非常费时费力的事情，同时申请数量急剧增加。平均看一封文书的时间是两分钟，而且招生官需要关注到你的整体经历以及内在联系，虽然两分钟很短，但是和直接比较三围比起来，还是有明显的劣势。所以对于很多热门项目来说根本没有足够的时间来阅读和审理这些文书。最后他们都不得不寻找更便捷的方式：比较三围。
• 文书里面水分太严重。文书是所有材料里面最能够反应申请者能力但也是最难去验证的部分。中国不断盛行的文书机以及日益严重的竞争让文书里面充满各种吹嘘成分，试想作为一个歪果仁，对于中国申请者文书里提到的内容不够了解的情况下发现很多人的文书都把自己描述得天花乱坠，显然有很多内容是虚假的。最终他们选择不去相信文书里的内容。

我一直坚信文书是也应该是申请中最重要的部分，不重视文书而一味强调硬件条件是招生官的愚昧也是对申请者的不尊重。但是朝着这个方向努力需要我们申请时都亲自，真实地写自己的文书。

下面开始写文书的几个步骤

步骤一：搜寻素材（认识自己）

写文书的第一步是知道自己有什么素材可写。这个过程也是我们了解自己并且客观评价自己的非常重要的步骤。这个阶段我们需要把自己的所有经历，或大或小都写下来，每个经历需要包含的具体内容：

• 做了什么
• 背后的动机（optional）
• 你做了什么（重要步骤）
• 最终成果（项目，获奖，论文等等）

需要注意的两点：

1. 写的时候不需要注意遣词造句，重点是要完整地表达出来。除非你有非常强烈的意愿用一个表达除外，这种情况下可以在旁边批注一下，不要影响自己的回忆和思绪的流动。
2. 把有价值的内容尽量都写出来，不论大小。对于很多人来说，一些内容自己觉得不是很重要，但是这些内容可能恰好是对方看重的点。这时就需要全面地记录下来等到后面自己或者有经验的人来选择。

下面以我的经历来做一个简单例子：

1

Trying to solve the energy consumption problem, I joined “eTrain,” a team in the Key Laboratory of Service Computing Technology and System at the Ministry of Education. By aggregating and piggybacking irregular data packets on periodical heartbeat packets, we successfully reduced energy consumption by 12%-30%. I was in charge of the design of the delay cost model and the system implementation. To compensate for sacrifices in the user experience, I chose the Lyapunov optimization framework as the basic system model. However, there was no system interface for us to manage data packets directly. With my knowledge of mobile systems, I found the Xposed framework to provide this functionality. Our work was valuable because we were the first to prove the feasibility and efficiency of turning heartbeats energy wastage into useful data transmission. Our paper "eTrain: Making Wasted Energy Useful by Utilizing Heartbeats for Mobile Data Transmissions" was accepted by IEEE ICDCS.

背后的动机：

1

Trying to solve the energy consumption problem, I joined “eTrain,” a team in the .....

（提前强调）成果同时说明基本原理，帮助一个没有相关背景的人更好地理解（你有多厉害）

1

By aggregating and piggybacking irregular data packets on periodical heartbeat packets, we successfully reduced energy consumption by 12%-30%.

我负责的工作

1

I was in charge of the design of the delay cost model and the system implementation. To compensate for sacrifices in the user experience, I chose the Lyapunov optimization framework as the basic system model. However, there was no system interface for us to manage data packets directly. With my knowledge of mobile systems, I found the Xposed framework to provide this functionality.

最终成果

1

Our work was valuable because we were the first to prove the feasibility and efficiency of turning heartbeats energy wastage into useful data transmission. Our paper "eTrain: Making Wasted Energy Useful by Utilizing Heartbeats for Mobile Data Transmissions" was accepted by IEEE ICDCS.

步骤二：调查你的对手需要什么

可以入手的方面：

• 项目介绍
• 项目要求
• 项目课程
• 其他资料（开学 PPT，论坛等等）

这并不是一个容易的步骤，很多地方需要注意

以 MSIT-se 为例：
从调查可以找到的有这么几个
http://mse.isri.cmu.edu/software-engineering/web1-why/index.html

不注意的人可能会漏掉这些信息：

• 在这个项目的介绍里CS 和 SE 是有本质区别的；页面上花了很大篇幅强调了 SE 和 CS 的不同，CS 更侧重 foundations, 而 SE 更侧重 real-world problems, teamwork, management。所以不要以为 CMU 这些项目都当 CS 来申就行了。
• 他们看重 team work。首先在介绍里面就讲到 team-centered projects，在 SoP 的要求中也明确说到你需要说出 project 的 team 以及你的 role，所以他们是非常在意 team work 的，强调这个会给自己一定程度加分。

步骤三：用逻辑将你选择的内容串联起来

了解过对手需要什么之后，你基本能知道自己第一个步骤里面搜集的经历里面哪些是对方看重的。找到这些素材之后你需要做更深层次的事情：赋予这些零散经历以灵魂。如果你本身就有非常明确的人生目标同时你申请的项目就是你人生目标的一部分，这时你脑海里马上就有清晰的逻辑将这些经历串联起来了。对于更大的一部分人，没有明确思路时，你需要找到这样一个逻辑来将你的经历关联成一个整体。这也是你明确人生目标的一个机会，看完这些经历之后你可以发现那些你无意识的背后其实是有关联的，你会更明确地发现想要什么。

怎样去找这样一个逻辑呢？有这么几个思路：

1. 经过不断地审视自己的经历，很多人都可以找到自己这些年到底在无意识地寻觅什么，某方面的认同感？某方面更强的能力？
2. 实在找不到，你可以看看对方需要什么，对方看重什么逻辑思想层面的想法。比如 CMU MSIT 的 software engineering 项目看重解决现实问题的能力，eBusiness 项目看重 learning by doing 的能力。

步骤四：内容优化

我在探索文书怎么写时曾经有一个问题，做完前三个部分之后我只花了五天左右，除了语言上的细节问题，我找不到自己文书的其他问题。所以我非常不理解那些文书改了二三十次的人。确实有些人只是为了寻找安全感，发给各种不相干的学长学姐，改改语法错误，这并不算真正意义上的修改。所以我一度非常鄙视那些人：“不行就是不行，一周做完的事情非要改一个月”。直到后来我仔细研究发现针对每个项目确实有非常多可以做优化的地方。我总结的主要有这么几个：

1. 该强调的地方强调了吗？
   对方的要求可以很概括也可以很具体，看官网上的信息可能觉得只是强调一下 research 或者 solve real-world problem 等等，但仔细检查他们的课程和研究方向以及结合自己的特长会发现总有可以更好地强调的地方。

2. 段内串联方式是怎样的？
   我看到了Quora 上这样一个回答，里面非常重要的内容是“Now let me get to the exceptions. Yes, there are ways to stand out amongst the piles and piles of applications and make a faculty member remember you. How? Simple: talk research. The best way to convince the admissions committee you’re ready for a phd is to talk research. Tell us your ideas, what’s your vision for your area, what big inevitable trends do you see in the future, and how do you capitalize on them? What are hard problems you’ve already tried to tackle, and how did you succeed/fail? This is where an applicant can show that they have the clarity of thought to think hard about a real problem, and show the reasoning skills (and intuition for identifying tricky or interesting problems).”。这是非常典型的 research 思维，vision >> problem >> solution >> results >> thoughts. 然后我想到了看我们文书的那些人基本都是搞研究的，所以更加坚定了我的想法：我们应该按照 research 的方式来写经历。怎么表现自己工作的重要性： two critical in our project were xxxx。怎么表现自己除了解决问题之外还非常厉害：clarify your thoughts beneath the project。

3. 某个部分是否可以再浓缩以便给更重要的地方留下空间？
   这是在准备 Duke-MEng 文书时发现的。DDL 的前一天才发现这个项目要求文书的篇幅在一页纸，那天晚上先是骂了自己“你个傻x，怎么不提前看一下，还剩一晚上搞个x啊”，后来冷静下来觉得是可以搞定的：素材，逻辑，目的都有了。需要的只是精简篇幅。但实际做起来也是很痛苦，吹自己多厉害很容易，但是删掉吹捧自己的内容就像一根根拔毛一样痛苦。也是这样的经历之后我发现：再丰富的经历也是可以精简到一页的，而且你会更加了解自己哪些方面更重要。当只有一页纸可以发挥的时候我们不得不选择最重要的内容最直接地展示出来。虽然很直接，不符合中国人的表达方式，但这恰好是歪果仁最喜欢的行文逻辑：show me the fucking goods。这样精简一番之后你会发现很多地方一段可以缩短成两句，两行可以缩短成一行，扭扭捏捏的表达可以更直接。然后省下很多篇幅可以去满足那些狗娘养的的胃口了。

1. 不断改写原来的内容，试试用不同的角度描写，试试用不同的篇幅描述。这样你会发现原来的内容是可以优化的。

步骤五：语言修改

语言润色到底有多重要？
并不是那么重要

步骤六：On and On

继续回想素材、串联素材、优化素材、优化语言，你会发现自己原来有这么丰富的经历。

####需要注意的问题

1. 是否是重点，亮点；这个是内容上最重要的要求；

2. Grounded，在有了内容之后需要让人信服，所有内容都需要有依据，不要抽象地说”I want to contribute to the world”，

3. Concise, 这个是内容上的进一步需求，其实是可以缩减的

• Description: Android based tower defense game, self-developed game engine
• Platform: Android
• Attribution: over 10,000 lines code, First Prize in Campus Mobile Application Competition, Complete engine with drawing management, touch event management, collision detection, resource management systems
• Relating Techniques: Java, Android View hierarchy structure, DFS(Depth First Search) algorithm, LRU(Least Recent Used) Resource Caching Algorithm
• Duration: 2012.8 - 2012.10
• Team member: Hongkun Leng(Developer), Bin Fan(Product Designer)

Background:

• This was my first independent mobile game project. Before that, I learned Java and Android development by myself and developed several applications such as Android based calculator, Android based weather application.
• This was also the first teamwork project for me. Its the first time that I found an appropriate product designer to collaborate with. We used Evernote to share documents, used QQ to transfer sketches and icons. In later period, we switch to collaboration tools such as Tower and Trello

Description

This is a Android based mobile game. Different from other games on Android platform, this game was developed without using existing game engine. I wanted to develop a basic, complete game engine myself, this would help me to understand mechanisms beneath the mobile game engine.

There were several features for this game:

• Tower defense game, you can install, upgrade, sell different kinds of towers. Specially, towers of different kinds and different levels were upgraded from one basic tower, you can chose different direction for its upgrade
• Map selection. You can chose different maps for your game.
• Level and Mode selection. Three different level: easy, normal, hard. Two different modes: normal, infinity.

Option Page

Game Page

Process

1.Building view drawing and animation system

View Drawing system

Although Android system provides API for me to draw images on the screen, images with excessive size should be processed before being drawn. Additionally, there were so many spites and items in one game, all of which might be added to current screen dynamically. So I had to design and implement a image management and drawing system.

According to basic structure of a game, there were three kinds of images to be drawn:

• background image and relating items such as grasses, stones
• spites(monsters and towers)
• effects(flames, lights)

In order to manage them efficiently, I used tree structure to organize them:

There was one parent for all images, this parent had three sons, who were responsible for three kinds of images exclusively. Each sons contains all images under its category. For each image object, there several properties with them:

• Visibility. Whether this image was visible, when it was transparent or out of screen, we could ignore them in order to increase efficiency.
• Scale. Each image was able to be scaled in order to show specific animations and movements.
• Position. Position for this image on the screen.

Accordingly, images should be set into different layers:
background image and relating items should be drawn first because they appear below monsters and towers, thus there were on the lowest level of the view hierarchy. Spites were on the middle layer, effects were on the highest layer.

While drawing, my algorithm would travel the whole tree to manage each image.
I used DFS (depth first search) to travel all objects effectively. On the one hand, DFS is easier to be implemented than WFS (width first search), on the other hand, these two algorithms were in same efficiency under this condition.

Animation

Animations system was necessary if I wanted to display movements of monsters and towers. One method was using frame animation: draw pictures for each frame and display 20-30 frames in one seconds. Then, due to special properties of our eyes, we would consider these discrete images as continuous animation.

Animation resource

Explosion effects

2.Building touch event management system

One advantage and useful user interface for Android smartphones was the touch screen. With this touch screen, uses were able to interact with phones through gestures such as click, long click and drag.

In our tower defense game, we used two touch gestures: click and drag. Users used click to chose specific options and they used drag to set position for each tower.

So, I should develop a touch event management system in order to manage user gestures effectively.

First, I should know which kinds of items on the screen were interactive:

• menu layouts. Before starting each game, users could config their games on menu layouts
• towers and its relating options
• monsters

Then there were several properties related to each interactive items:

• position of the item
• size of the item
• whether it’s interactive now

Just like managing images, I also chose tree structure as the basic structure for touch event management system.

3.Building collision detection system

In a tower defense game, bullets from towers should be able to interact with monsters and cause some effects on these monsters. So a collision detection system was necessary.

Collisions between different items should be classified from their shapes. For example, detecting collisions between two round objects was quite easy, we should only judge the distance between centers of different round objects and compare these distances with their radius. However, detecting collisions for square objects were not so simple.

4.Resource management system

There were so many resources in one game that they could not be loaded into memory at once. In order to make use of limited memory space, I should manage these resources according to their usage and using frequency. Fortunately, there was one algorithm for this work: LRU (Lease recent used) caching algorithm. According to this algorithm, resources were arranged according to their using frequency and time of each use record.