奇幻物语

摘自微信号十三手记

引言

定时睡眠和睡眠时长时一个人精神饱满的关键吗？
你以为是，其实不是。
为什么？ 因为你没有真正懂得人的能量消耗和补充的原理，所以被某些单边的睡眠观念影响纠结，进而降低了睡眠质量。

• 人的系统能量是怎么消耗的？
  眼耳鼻舌身的功能运行和头脑里的各种念想。

• 系统能量是怎么补充的？
  适当的时候，主动放松降低眼耳鼻舌身意的运行频率，生命本源会自动补充你的精神能量；适度的饮食支持会提供身体所需要的物质能量。

要你深深明白

二元有相世界，任何时候，当你放松敞开不纠结，系统能量便会自动减少消耗，补充便会自动提高。所以，定时睡眠以及睡眠时长并不是一个人精神饱满的关键，关键的问题是人的系统能量消耗和补充的原理，当你明白了这个原理，你便打破了睡眠是你能量补充的必须形式的局限认知，你便打破了你对睡眠的依赖性。

如此，反而你何时睡眠以及睡眠时长就可以根据你的意愿而主动安排；如此，你便不会因所谓的失眠而形成恐惧，便不会被恐惧纠结而形成反复消耗，反而能量补充会更加顺畅；如此，你的睡眠质量反而得到提高，你的生命自由度便会随着你心境的提升而逐步提升，身心健康和自由便走上了可期的道路。

附赠

失眠是什么？
是你先给自己定个睡觉时间，再把睡不着当成失眠吗？失眠是没睡觉的样子？还是说在特定时间没睡觉？为什么要特定？谁特定的？谁能除了定自己还能定别人？难道你不可以睡得着就睡，睡不着就不睡吗？

个人感悟

人类对自己的认知是那么的不足，对睡眠也几乎是一无所知。十三手记表达了令人惊奇的观点，人恢复能量和元气并不完完全全依赖于睡眠。虽然大部分时候睡眠质量很重要，但同时也没有必要一直纠结于自身的睡眠质量。能量的恢复是自然而然的，而人的感官意识都是无时无刻在耗费精力的，但当你关闭了这些感官和意识时，其实你就已经在休整，你的能量就已经是呈现上升的态势。所以，关于休息，我们应该更少焦虑的纠结于睡眠，更多关注我们感官意识的状态。这就是所谓的闭目养神，同时冥想可能可带来注意力的自主调整和加快能量恢复，以致于很多人推荐。

线程管理

多线程的执行函数尽量用传引用，以减少不必要资源开销；根据hardware_concurrency得到核心数来决定开多线程的数量；

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

#include <iostream>
#include <thread>
#include <unistd.h>
using namespace std;

// 传入操作类，重载运算符()
class Fctor{
  public:    // 参数使用引用减少多线程资源拷贝
    void operator()(string& msg)     // opt: string msg
    {
      cout <<"from f1:" << msg<<endl;
      msg = "changed";
    }
};

int main()
{
  string s = "not changed";
  cout << this_thread::get_id()<<endl;
  thread t1((Fctor()), ref(s));    // move(s),此时最后输出的s为空。
  t1.join();

  cout << s << endl;
  cout << thread::hardware_concurrency() << endl; //当前设备核心数

  return 0;
}

// output
// thread_id
// from f1:not changed
// not changed

数据竞争及互斥对象

避免数据竞争,用lock_guard解决抛出异常的问题;lock_guard保证线程独占资源而安全

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
43
44
45
46
47
48
49
50
51
52
53

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <fstream>
using namespace std;

// lock_guard构建f单例，保证独占fout资源，从而保证线程安全
class LofFile
{
    public:
    LofFile(){
        f.open("log.txt");
    }
    void shared_print(string id, int value)
    {
        lock_guard<mutex> locker(m_mutex);
        f<< "From" << id <<": " << value << endl;
    }

    private:
        mutex m_mutex;
        ofstream f;
};
/*  cout资源为全局所有，即使加入互斥对象依然不能完全保护
mutex mu;
void shared_print(string msg, int id)
{
    lock_guard<mutex> guard(mu);
    // mu.lock();
    cout << msg << id << endl;
    // mu.unlock();
}
*/


void function_1(LofFile& log)
{
    for(int i=0; i>-100; i--)
        log.shared_print("From t1:",i);
}
int main()
{
    LofFile log;
    thread t1(function_1, ref(log));

    for(int i=0; i< 100; i++)
        log.shared_print("from main: ", i);

    t1.join();
    return 0;
}

死锁

避免死锁：

• 评估线程是否需要两个或以上的互斥对象
• 避免在锁住资源的同时去调用一些不熟悉的函数
• 使用lock函数帮助mutex顺序一致

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
43
44
45
46
47
48
49
50
51
52

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <fstream>
using namespace std;

// 循环依赖产生的死锁
class LofFile
{
public:
    LofFile() {}

    void shared_print(string id, int value)
    {
        lock(m_mutex, m_mutex2);  
        lock_guard<mutex> locker(m_mutex, adopt_lock);
        lock_guard<mutex> locker2(m_mutex2, adopt_lock);
        cout << "From" << id << ": " << value << endl;
    }
    void shared_print2(string id, int value)
    {
        lock(m_mutex, m_mutex2); // 用lock确保互斥顺序一致

        lock_guard<mutex> locker2(m_mutex2, adopt_lock); // 若调换，则可避免
        lock_guard<mutex> locker(m_mutex, adopt_lock);
        cout << "From" << id << ": " << value << endl;
    }

private:
    mutex m_mutex;
    mutex m_mutex2;
    ofstream f; // 被m_mutex保护的对象
};

void function_1(LofFile &log)
{
    for (int i = 0; i > -100; i--)
        log.shared_print("From t1:", i);
}
int main()
{
    LofFile log;
    thread t1(function_1, ref(log));

    for (int i = 0; i < 100; i++)
        log.shared_print2("from main: ", i);

    t1.join();
    return 0;
}

Unique Lock和lazy Initialization

加锁的方式：

1. lock_guard
2. mutex.lock
3. unique_lock(推荐，但占用更多系统资源)

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <fstream>
using namespace std;

// 所占用的资源
class LofFile
{
    public:
    LofFile(){
        f.open("log.txt");
    }
    void shared_print(string id, int value)
    {
        // lock_guard<mutex> locker(m_mutex);  
        unique_lock<mutex> locker(m_mutex, defer_lock); // unique_lock占用更多系统资源
        // do_sth()  unlock
        // ...        

        locker.lock();
        f << id <<": " << value << endl;
        locker.unlock();
        // ...


        locker.lock(); // another unique_lock

        unique_lock<mutex> locker2 = move(locker);
    
    }

    private:
        mutex m_mutex;
        ofstream f;
};


void function_1(LofFile& log)
{
    for(int i=0; i>-100; i--)
        log.shared_print("From t1:",i);
}
int main()
{
    LofFile log;
    thread t1(function_1, ref(log));

    for(int i=0; i< 100; i++)
        log.shared_print("From main: ", i);

    t1.join();
    return 0;
}

生产者和消费者问题

结合unique_lock和lambda，让线程之间高效相互响应执行

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <functional>
#include <iostream>
#include <fstream>
#include <string>
#include <mutex>
#include <thread>
#include <deque>
#include <condition_variable>

using namespace std;

deque<int> q;
mutex mu;
condition_variable cond;  // 条件变量
// 生产者
void function_1()
{
    int count = 10;
    while(count > 0)
    {
        unique_lock<mutex> locker(mu);
        q.push_front(count);
        locker.unlock();
        cond.notify_one();
        this_thread::sleep_for(chrono::seconds(1));
        count--;
    }
}

// 消费者：条件变量
void function_2()
{
    int data = 0;
    while(data!=1)
    {
        unique_lock<mutex> locker(mu);
        cond.wait(locker, [](){ return !q.empty(); }); // 只能搭配unique_lock使用，用Lambda函数避免自解锁
        data = q.back();
        q.pop_back();
        locker.unlock();
        cout <<"t2 got a value from t1: " << data<<endl;
    }
}

/* 不优雅
void function_2()
{
    int data = 0;
    while(data!=1)
    {
        unique_lock<mutex> locker(mu);
        if(!q.empty())
        {
            data = q.back();
            q.pop_back();
            locker.unlock();
            cout <<"t2 got a value from t1: " << data<<endl;
        }
        else {
            locker.unlock();
            // this_thread::sleep_for(chrono::milliseconds(10));  若无数据，一直解锁locker;此时加入sleep缓解不停释放的行为
        }
    }
}
*/

int main()
{
    thread t1(function_1);
    thread t2(function_2);
    t1.join();
    t2.join();
    return 0;

}

chap1 c++并发世界

C++98的13年后，2011的C++11成为新的规范，同时确认了每三年发布新的扩展技术规范。
在C++11中，c++ standard第一次承认多线程存在于C++语言中，意味CPP编写与平台无关的多线程程序成为可能。以往编写多线程并发需要针对运行平台部署依赖扩展库，如今可移植性成为可能。

何谓并发和多线程？
单核的并发存在切换上下文的不必要损耗。
多线程：一个进程下，多个小单元共用数据资源，单机并发较常用，实际上CPP支持的是多线程。
多进程：开辟多个共用数据资源，多个进程并行，占用大量资源，通讯成本加大，适用于多机。

并行：关注性能； 并发：关注任务分离；

为什么要并发?

1. 关注分离：将相关代码与无关代码分离，使得程序更容易理解和测试。
2. 关注性能：将任务并行以及可以将数据并行
   不使用并发的原因：收益比不上成本，一方面脑力以及代码维护成本，一方面是线程资源。尤其32位地址的架构，
   对于4G(32bit)的架构，每个线程占用1MB，那么开4096个就用尽所有地址，运行太多会出问题。对于现用的板子有1GB的内存可用。对于现用的64位PC，开一个线程ulimit -s可知为8MB;ulimit -u可以看当前可开多少个线程上限，64GB可开约26万个上限。
   由于多线程使代码复杂且难以理解，只有显著提升性能才值得一干。

chap2 线程管理

• 线程启动：std::thread对象用函数或者类初始化的同时，开始自动启动线程。
• 线程等待与分离：join为等待线程执行完成；detach则让线程分离自主执行，此时访问已销毁的变量会引起错误。如果线程已使用过join,则不可再次join。joinable()返回false。
  解决方法：将数据复制到线程中，可以总结用一个访问局部变量的函数创建线程是危险行为。
• 分离线程：通常又称守护线程，没有任何显式的用户接口并在后台运行的线程，通常长时间运行。
• 转移线程： thread2 = std::move(thread1);若thread2已有线程，则系统直接调用terminate结束错误。

摘自微信公众号十三手记

自古以来，在团队、组织及家庭教育等人际关系管理中，奖惩都是当事人的必修课，凡能善用者，都能收获到相当的人生成就，可是真正能把奖惩落实到位乃至出神入化的人凤毛麟角，究其原因，其实都是没能真正明白奖惩的核心精髓，甚至因为错用奖惩而受到惩罚。

首先，奖惩时为了更好的控制别人吗？

你以为是，但必定不是。若是为了更好的控制别人，为何那么多人用了奖惩手段并未真正收到真正控制别人的真正效果？

那么，奖惩到底是为了什么？

那是为了促进对方强大的同时与其交心。

何时奖惩？

尽快，及时

何处奖惩？

公开的要公开，私下的要私下，否则就是反效果。

此刻，十三先生要你深深的明白：在你的人际关系管理中，若是你的奖惩只是你控制别人的手段，那你的手段最多只是临时效果，最终必定不能如你所愿，甚至受到反效果；若是你的奖惩是在用心反馈你对别人行为有效性的重视，是为了及时给予对方诚意的肯定或是改进提醒，那你就是在用奖惩的办法促进对方强大的同时与其交心，假以时日，你必定能收获到奖惩给你的人际关系处理的真实力量和价值。

Unix和Linux的基本指令
http://www.ee.surrey.ac.uk/Teaching/Unix/

Introduction

内核(Kernel): 分配时钟和内存给程序和处理文件存储以及系统交互
Shell:用户和内核的命令交互
UNIX中要么时文件，要么是程序

Tutorial One & Two

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

ls -a
pwd

// search sci in file.txt
// Method 1
less file.txt
/sci  

// Method 2
grep sci file.txt //-i mean 'ignore up/low case'

wc -l file.txt  // count line in file.txt

clear // clean monitor

Tutorial Three & Four

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

cat > list1  // output to list1
cat >> list1 // append to list1
cat list1 list2 > biglist // concat list1 and list2 to biglist

sort < biglist > slist // sort biglist and output to slist
command1 | command2  // pipe the output of command1 to the input of command2

ls list*
ls ?list

// getting help
man wc

Tutorial Five & Six

1
2
3
4
5
6
7
8

ls -l

-rwxrw-r-- 1 ee51ab beng95 2450 Sept29 11:52 file1

// read/write/execute rights in owner/group/everyone
// file_size time file_name

chmod a+x ex // add permission to execute ex to all

summary of process control

foreground: terminal suspend and wait
background: terminal can go on

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

df .  // report space left on the file system
ls -lh
gzip
gunzip  // unzip
tar -xvf .tar // extract
diff file1 file2  // < denotes file1, > denotes file2

history // terminal history
!! // recall last command
!-3 // recall third most recent command
!grep // recall last command starting with grep

Tutorial Seven & Eight

Install software:

1. Locate and download the source code(which is usually compressed)
2. Unpack the source code
3. Compile the code(Most difficult)
4. Install the resulting executable
5. Set paths to the installation directory

make:manage large programs and only compiling those parts changed
Makefile: record the related make rules, contains information on how to compile the software.

Some simplest way to compile a package:

1. cd to the directory containing the packages’ source code.
2. Type ./configure to configure the package for your system
3. Type make to compile the package
4. Optionally, type make check to run any self0tests that come with the package.
5. Type make install to install the programs and any data files and documentation.
6. Optionally, type make clean to remove the program binaries and object files from the source code directory.

UNIX variables

two categories: Environment variables, Shell variables
Shell variables: apply only to the current instance of shell and set short-term working conditions.
Environment variables: system environment with UPPER CASE name

1
2
3

echo $PATH // print system environment
set PATH=($PATH ~/new_path/)  // add path to PATH

摘自十三手记

若是认真观察自己过往对金钱的感受，必定发现一个现象：钱来得容易的时候，也花得容易；钱来得艰难，也就比较耐用。

但大多数时候，我们不愿面对这样的真相：金钱实际价值的背后有自己投机取巧的小心思。

此时，十三先生要你深深的明白：二元有相世界，金钱的实际价值必定等于你诚意付出之时创造出的相应实际价值，但是你却一直有种想付出更少收获更多金钱的想法，所以你不自知的不愿搞清楚。因为一旦你搞清楚了这个核心原理，你就无法继续投机取巧，就无法继续偷懒了。但是，只要你真正诚意看懂并接纳了这个关键点，你就能更加务实的面对自己所面对的一切人和事，你才能因此而尽可能减少多余的动作，你才能因减少多余动作而减少障碍环节，你才能因减少障碍环节而减少不必要的消耗，如此，你整体的行动才能更加高效，反而你才能走上人生各种成功的捷径。

个人感悟

回忆过去，确有种种如此的感觉。上高中和大学的时候，每一分钱都来自父母，舍不得多花乱花。出来工作后，可能得益于名校光环，匹配一些不太核心的岗位时候，工作的艰辛就远不及当初，于是感觉金钱就来得容易了，殊不知金钱其实也流入并不富裕，只因个人消费比较简单，只花该花的钱，只享受该享受的事。于是渐渐，也失去了赚大钱的欲望，虽说不能没有，但明显不及年少时的强烈，花钱也比较随意，一直没有大的积蓄，理财也是三天打鱼四天撒网的状态。希望认真对待工作中的每一件事，认清金钱来之不易，努力增长自己的财富，也能合理地用度。

另外，而立之年，却没有多余的精力和财产赡养父母，更多的是让父母为自己忧心忡忡，目前为止，依然算不上才社会能游刃有余，立足四方。此后，应挖掘自己的兴趣目标，提升个人在社会中的价值。

具体学习于 https://github.com/andyzeng/tsdf-fusion

Why TSDF

三维重建首当其冲的问题是如何保存以及如何表示模型，通常而言会有点云，mesh等；
但是对于室内三维重建，TSDF是一个不错的选择，其优点是

• 非常适合CUDA并行运算，从而达到实时。
• 开辟固定的内存/显存，模型大小相对可控
• 模型大小不随数据量变化，网格的细节比较好
  缺点：CPU计算耗时，在边缘以及前后景交界出现拖尾现象（体素g在像素坐标系投影有一定的误差）

How TSDF

1.建立长方体包围盒（能包住房间，一般预设参数：可通过设定划分网格以及网格大小得到)
2.将每个体素v转化成三维座标点g(根据模型起点和网格推算)
3.对于新来的每一帧深度图：
遍历每一个体素g：
3.1.根据相机外参，将g在世界坐标系转换到相机坐标系的点c,再由相机内参转换到像素坐标系x;
3.2.深度相机像素深度为value(x),点c到相机坐标原点的距离为distance(v)
3.3.sdf(g) = value(x) - distance(v).
3.4.求tsdf(g).预设截断距离t = voxel_size * t_n, 则t以内，tsdf(g) = sdf(p)/|u|;在t以外时，if sdf(p)>1, tsdf(p) = 1;if sdf(p)<-1, tsdf(p)=-1;
3.5.权重w(p) = cos(theta)/distance(v), theta为投影光线与表面法向的夹角
至此，得到当前帧所有体素的tsdf值以及权重值
4.当前帧与全局模型融合
4.1 若当前帧为第一帧，即为融合结果；否则与之前的模型融合,公式如下，其中W(p)为融合权重，w(p)为当前帧权重

Detail and Analysis

处理可能出现异常的方法

• 调用abort()或exit()结束程序
• 返回错误码
• 异常机制：1.使用try块执行可能出现异常的代码段 2.throw引发异常 3.catch捕获并处理对应情况

throw机制

若throw引发异常后，匹配对应catch。而后不是将控制权返回调用程序，而是引导程序沿着函数调用序列后退，直到找到try块中的函数
若没有throw出异常，则catch被跳过.
一般而言后退多步，再在main()中寻找与引发异常类型匹配的处理程序作处理。

通常用对象作为异常类型处理

好处是：直接根据类型区分异常，另外对象可以携带信息确定原因，catch根据信息来执行对应的操作

堆栈解退（unwinding the stack）

假设函数出现异常，而不是正确返回而终止。程序释放堆栈中的内存，但不会在释放堆栈的第一个返回地址后停止，而是继续释放堆栈，直到找到位于try块的返回地质。程序进行堆栈解退以回到能够捕获异常的地方时，将释放堆栈中的自动存储型变量。

文件IO

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

#include<iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream inFile;
    inFile.open("file.txt");
    if(!inFile.is_open())
    {
        cerr <<"Failed open file.txt\n";
        exit(0);
    }
    char ch;
    int cnt=0;
    while(inFile>>ch)
    {
        cnt++;
    }
    cout << cnt <<endl;
    inFile.close();
    return 0;
}

下面程序为harmony mean的除0错误，抛出const char *类型，匹配输出错误信息的代码。一般抛出错误类型通常为类。

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

#include <iostream>
#include <cstdlib>

using namespace std;

double hmean(double a, double b)
{
    if (a == -b)
        throw "bad hmean() arguments: a = -b not allowed";
    return 2.0 * a * b / (a + b);
}
int main()
{
    double x, y, z;
    cout << "Enter two numbers:";
    while (cin >> x >> y)
    {
        try
        {
            z = hmean(x, y);
        }
        catch(const char * s)
        {
            cout << s << endl;
            cout <<"Enter a new pair of numbers: ";
            continue;
        }
        
        cout << "Harmonic mean of " << x << " and " << y << ". is " << z << endl;
        cout << "Enter next set of numbers <q to quit>:";
    }
    cout << "Bye!" << endl;
    return 0;
}

throw-catch机制和函数参数以及函数返回机制的区别

1.函数控制权返回到调用函数的函数，throw语句控制权向上返回到第一个包含能够捕获相应异常的try-catch组合
2.引发异常时，编译器总是创建一个临时拷贝，彻底避免了函数机制指向不存在的临时变量的问题。
3.经常可见catch(problem & p)，使用了引用，主要是针对通过继承关联起来的异常类型；此时使用基类引用即可执行派生类对象。此时层次结构最下面的异常类的catch语句应当放在最前面。

catch (…)表示捕获任何异常

异常处理的注意事项

1.使用异常，应在设计程序时就加入，而不是以后才添加。
2.使用异常会增加程序代码，降低程序运行速度。
3.异常规范不适用于模板，异常和动态内存分配不能总是协同工作
因此，虽然异常处理对于某些项目极为重要，但也会增加编程的工作量、增大程序以及降低程序的速度。另外编译器对异常的支持以及用户的经验还没有达到成熟的程度，应有节制地使用这一特性。

如无堆栈解退，则会出现内存泄漏，如下

1
2
3
4
5
6
7
8
9

void test(int n)
{
    double * ar = new double[n];
    if(oh_no)
        throw exception();
    
    delete [] ar;
    return ;
}

throw了，则delete[]被忽略，ar指针消失了，内存块未释放且不可访问。

RTTI（RunTime Type Identification)

三个支持RTTI的元素：

• dynamic_cast操作符将基类指针生成派生指针：回答是否可以安全将对象的地址赋给特定类型的指针？如可，返回对象地址；否则，返回空指针。这对比“指向哪个类型的对象”，这更通用且有用。
• typeid操作符返回对象的类型
• type_info存储特定类型的信息
  注意：RTTI只适用于包含虚函数的类

与通用转换机制相比，dynamic_cast、static_cast、const_cast、reinterpret_cast提供了更安全和明确的类型转换。

STL

通用编程技术，迭代器概念。
操作复杂度：固定时间、线性时间、随机时间
线性容器以及联合容器(set、map、multiset、multimap)
()函数符functor的概念,STL使用模板让for_each原型看上去像

1
2

template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f);

STL算法库

分为四大类

• 非修改式序列操作
• 修改式序列操作
• 排序和相关操作
• 通用数字运算
  就地算法：在原始数据位置上操作；复制算法：在新的位置操作

IO

cout不会截断数据，会尽量全部打印内容。

1
2
3
4

cout.width(int n); // 单次有效
cout.fill(char c); // 一直有效
cout.precision(int n); // 一直有效

摘自微信号十三手记

金钱只是金钱的样子吗？
你以为是，但必定不是。

首先明白，金钱的有形或无形形式为什么存在？
是为了运行金钱背后的实际价值

对于金钱而言，一般有三种状态：获取，存储，使用
三种状态在一起就是你金钱的留存路径，也是金钱存在的整体。

此时，十三先生要你深深的明白：只要你对待金钱的这三种状态不平衡，只偏向执着于其一或其二，被你忽略掉的部分都必定会让你体验到金钱的匮乏，你都必定会经历金钱的反复障碍，无论金钱多少，你都是被金钱牵制捆绑的奴才；若是你懂得了今天讲的金钱整体性，在金钱对境中，把这三部分中你当时所处的部分运作出最大的价值和质感，并透过自己的障碍和痛苦主动去发现自己的单边局限，并及时主动透过逆袭自己的小气和不尊重金钱之粗糙的行为来扩大自己的金钱进出通道和格局，如此，假以时日，你便不会被金钱三部分中任何一部分障碍，你便会逐步成为内心富足的金钱主人。

一条手记：二元有相世界，金钱是你自己其中一个相，你对待金钱的状态就是你对待自己和对待世界的状态。

个人感悟

这边十三先生提到关于金钱从获得，存储和使用三个维度分析，从提升个人金钱观上升提高个人世界观。

• 关于获得：没有人会嫌钱多，在尽个人最大努力以及精力下，应最高效提升金钱的获得效率。
• 关于存储：有了上一步，存储才有意义，如何有效理财，提升金钱的有效价值；另外，足够的存储才能带给个人底气和自信。
• 关于使用：根据上两步的情况，具体规划用度，及时安抚自我，时刻让自己充满斗志与动力。

格林先生说

1.yes and 法则
通常交流容易别人提一个观点，我们不认同会yes,but. 这样别人容易产生“那就这样吧，你说什么就是什么吧”

正常回复应该尽量接纳对方一部分的内容，然后才一点点引出冲突。
e.g. …确实会…,不过有时候…

2.即兴表达框架-PREP
Point->Reason->Example->Point

3.SCQ-A
提出问题，寻求帮助。Situation->Conflict->Question->Answer
常用于工作汇报，包括问题背景，问题原因，主要问题，如何解决。

4.FFC 赞美法则
Feel->Fact->Compare
（Feel）我觉得今天你搭配很有气质
（Fact）因为腰线能突出身形
(Compare) 这是我今年见到的最潮的连衣裙

5.引导选择
模板：是…还是…/ 是否…/ 要不要…,好处是这样
提问封闭，只需选择，无需开放式思考

6.万能表达：观察+感受+需求+请求
（观察）珊珊，你最近每晚都是凌晨才睡觉
（感受）我觉得有干扰
（需求）而且我希望你能身体健康，这样白天才精神
（请求）所以希望明天开始，能不能11点准时关灯

7.汇报FFA法则
Fact->Feeling->Action
最近工作如何，我感觉主要是跟不上进度，接下来一周我会如何做。

蛋蛋碎嘴子

1.工作汇报老手
新项目砸了=进行了积极的试错，吸收了宝贵的经验
数据不好看=有较大的增长空间
啥也没干=稳定发展
接下来依旧打算啥也不干=保持现有成绩，稳定成果
数据稍微好看一点=取得了较大增长

2.一个人一直墨迹跟你说话不好意思打断，可以尝试：
“好的”，“那确实不错”，“的确是这样”，“嗯你说的对”

3.接到不想做的任务可以说
“领导，我仔细看了一下这个需求，我这里可能存在XXX方面的短板”
“想要推进这个事情的话，我可能需要XXX方面的支持”
暗含“我可说清楚了，办砸了可不赖我”

4.当想刺探秘密时，先说结论，然后观察对方的反应
“我们公司下个月要发奖金你”

5.汇报模板：
【日常在做什么】+【做这件事的目的】+【做这件事有什么困难】+【怎么做得更好】

6.当别人布置杂活，不想做就死死的抠细节
“你说的这件事大概什么时候需要？”
“这个时间点具体到几点？”
“我是微信给你还是邮箱给你？”
“那我需要先出一个计划，你帮我看看安排合不合适？”
如此一来，极大增加之间的沟通成本，让对方崩溃而不想给你安排了。

清闲的九夏

1.别人求你办事，如果想要资源置换，就说：“这事儿不太好办阿”

2.拒绝借钱：“你知道的，我最近XX，也没钱。”

3.汇报话术：”这边，我们做了A，B两种方案，各有优势，希望给点意见，看选哪个做比较佳“

4.经常使用分点叙述
我是这么认为的，第一，X；第二，X；第三，X。

5.请求帮忙时，先提出自己的办法
”经过了解，遇到一些问题，我的解决办法是XX，大家看看还有没有更好的办法?”
不论多平庸都要提一个。

6.请求帮忙“不好意思，可以插一下队吗？因为我真的很急”

7.聊天想聊下去：揪住对方的关键词+延伸过往彼此交流过的信息

“今天又加班，很烦”
“怎么又加班，又是上次那个领导吗”

“我爱豆塌房子了”
“哪个，上回说的那个吗，我去”

8.不想聊下去
“今天又加班”
“怎么又加班，这算啥事”

“我爱豆塌房子了”
“又他”

9.领导说“辛苦了”
你：“从中学到很多，很有收获。”

10.领导的节日问候（也可不发，上班的时候再热情问候即可）：
尊称+感谢+互动+祝福

11.说服别人，改变一个人的想法
认同立场，替换观点。

自嘲： 是阿…而且…