yqq's blog

甲对乙说：“如果我送你一只鸟笼，并且挂在你家中最显眼的地方，我保证你过不了多久就会去买一只鸟回来。”乙不以为然地说：“养只鸟多麻烦啊，我是不会去做这种傻事的。”于是，甲就去买了一只漂亮的鸟笼挂在乙的家中。接下来，只要有人看见那只鸟笼，就会问乙：“你的鸟什么时候死的，为什么死了啊？”不管乙怎么解释，客人还是很奇怪，如果不养鸟，挂个鸟笼干什么。最后人们开始怀疑乙的脑子是不是出了问题，乙只好去买了一只鸟放进鸟笼里，这样比无休止地向大家解释要简单得多。

霍桑效应

——监督和被监督的意义所在

指的是在行为现场实验（Field Experiment）中，由于研究对象意识到自己正在被研究，而带来的方法上的人为效应。

习得性无助效应

“一朝被蛇咬，十年怕井绳”

简单地说，很多实验表明，经过训练，狗可以越过屏障或从事其他的行为来逃避实验者加于它的电击。但是，如果狗以前受到不可预期（不知道什么时候到来）且不可控制的电击（如电击的中断与否不依赖于狗的行为），当狗后来有机会逃离电击时，他们也变得无力逃离。而且，狗还表现出其他方面的缺陷，如感到沮丧和压抑，主动性降低等等。

证人的记忆效应

证人，在我们的认识里，通常都是提供一些客观的证据的人，就是把自己亲眼看到、亲耳听到的东西如实地讲出来的人。然而，心理学研究证明，很多证人提供的证词都不太准确，或者说是具有个人倾向性，带着个人的观点和意识。

晕轮效应

注意“投射倾向”: 人对他人的知觉包含着自己的东西，人在反映别人的时候常常也在反映着自己、而这种反映又往往是不自觉的。
注意“第一印象”: 第一印象一旦形成，以后的信息常常只扮演补充和解释的角色，这就是产生晕轮效应的“温床”了。因此，冷静、客观地对待第一印象，思想上具有改造甚至否定第一印象的准备非常重要
注意“刻板印象”(“贴标签”): 我们要对他人产生确切、深刻的认识，千万别忘了人的丰富多样性，并不断地修正头脑中由于刻板印象所造成的假象
避免“以貌取人”：只要我们在认识他人的问题上，确立不满足于表象，而注重了解对方心理、行为等深层结构，我们就能有效地摆脱外貌晕轮效应的影响
避免“循环证实”：心理学研究证明，一个人对他人的偏见，常会得到自动的“证实”。

罗森塔尔效应

指的是教师对学生的殷切希望能戏剧性地收到预期效果的现象。

实验过程：

1968年的一天，美国心理学家罗森塔尔和L.雅各布森来到一所小学，说要进行7项实验。他们从一至六年级各选了3个班，对这18个班的学生进行了“未来发展趋势测验”。之后，罗森塔尔以赞许的口吻将一份“最有发展前途者”的名单交给了校长和相关老师，并叮嘱他们务必要保密，以免影响实验的正确性。其实，罗森塔尔撒了一个“权威性谎言”，因为名单上的学生是随便挑选出来的。8个月后，罗森塔尔和助手们对那18个班级的学生进行复试，结果奇迹出现了：凡是上了名单的学生，个个成绩有了较大的进步，且性格活泼开朗，自信心强，求知欲旺盛，更乐于和别人打交道。

虚假同感偏差

又叫作虚假一致性偏差，是指人们常常高估或夸大自己的信念、判断及行为的普遍性，它是人们坚信自己信念、判断正确性的一种方式。

当遇到与此相冲突的信息时，这种偏差使人坚持自己的社会知觉。人们在认知他人时总好把自己的特性赋予他人身上，假定自己与他人是相同的，例如自己疑心重重，也认为他人疑心重重；自己好交际也认为别人好交际。

寓言故事：

以前，在一个寒冷的冬天，有一个木匠带着孩子在地主家干活，木匠干活干得大汗淋漓，就一件一件把自己的衣服脱掉了。这时他想起了孩子，生怕他热着，也一件一件把孩子的衣服给脱掉了。后来孩子被冻死了。

帕金森定律

2022-12-23

学习

帕金森十大定律

来源：百度百科

定律1——冗员增加原理：

官员数量增加与工作量并无关系，而是由两个源动因造成的。每一个官员都希望增加部属而不是对手（如“投票”）；
官员们彼此为对方制造工作

定律2——中间派决定原理：

中间派是指对决定的内容不十分清楚的、意志薄弱、耳朵不大灵光的人，他们在组织的“票决制”议程中具有举足轻重的作用。为了争取中间派的支持，双方颇费心机进行争取，特别是双方势均力敌的情况下。所以，不是竞争对手而是中间派成了主角。

定律3——鸡毛蒜皮定律：

大部分官员由不懂得百万、千万元而只懂得千元的人组成，以至于讨论各种财政议案所费的时间与涉及的金额呈反比，即涉及的金额越大，讨论的时间越短，反之时间则越长，越是鸡毛蒜皮的事情越花费很多时间。

定律4——无效率系数：

由于复杂的利益关系，决策性委员会多的非必要成员愈来愈多，以至于会议开始变质，变得效率低下。于是，不得不在委员会重新设立核心决策委员会或核心决策团体。

定律5——人事遴选庸才：

人们设计了许多的人事遴选方法，但大部分测试都是徒劳无功的，最终不得不靠偶然性标准遴选。

定律6——办公场合的豪华程度与机关的事业和效率呈反比：

事业处于成长期的机关一般没有足够的兴趣和时间设计完美无缺的总部。所以，“设计完美乃是凋零的象征”，“完美就是结局，结局就是死亡”。

定律7——鸡尾酒会公式：

会议与鸡尾酒会（饭局）同在，不同重要性的人物参加鸡尾酒会，会在不同的时间出现，并站在不同的位置上。把会场从左到右分为A-F六段，从进门处到最远端分为1-8八段，则可划分出48个区域；在假定酒会开始的时间为H，且最后一名客人离开的时间是最初一名客人进场后2小时20分钟，则，重要人物都会在H+75至H+90的时间在E/7区域集合，最重要的人物自然会在其中。

定律8——嫉妒症（分三个时期）：

在嫉妒症流行的机关里，高级主管辛苦而迟钝，中层干部勾心斗角，底层人员垂头丧气而不务正业。

第一阶段，出现了既无能又好嫉妒的人物，即患上了“庸妒症（平庸而嫉妒）”；
第二阶段，这些庸妒症患者不幸进入或原本就在高层，尽一切可能手段排斥比自己强的人，拒绝提升能力强的人；“愚蠢比赛”；
第三阶段，机关仿佛被喷了DDT，凡才智者一概不得入内，机关病入膏肓，此时的机关已经无药可救了。

定律9——财不外露

财不外露

定律10——延迟退休：

一般退休的年龄是R，在前3年（R-3）人的精力会开始减退；问题在于如何挑选合适的接替者，工作表现越优秀，任职时间越长，越难寻得合适的接替者，而在位者总会设法阻止职位较低的人接近自己的职位，以至不得不延长自己的退休时间。

如何预防？

建立学习型的组织，持续学习新东西
招聘人员要公开透明，不能全权交由直接上级，防止招聘能力低下的人
建立人才培养计划
定期考核

分析可升级智能合约

2022-12-15

技术

准备

为了理解可升级合约，必须理解proxy机制，要理解proxy机制，必须理解solidity的sstore和sload,以及关于以太坊架构和存储结构（数据结构）。

关于Solidity中的sstore和sload深入理解：

非常好的一篇剖析： https://learnblockchain.cn/article/4172

简单概括一下：

sstore将一对key-value存入storage
sload按照key取出storage中的value
一笔交易中可以多次sstore和sload
key一般用slot（槽）代替，是32bytes的哈希
以上的storage是某一个合约下面的storage

合约代码分析

基于solidity ^0.4.24

openzeppelin的实现： https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Proxy.sol
USDC合约代码： https://etherscan.io/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#code

其中Proxy：

// 抽象合约
contract Proxy {

    // fallback函数
    function () payable external {
        _fallback();
    }

    // 虚函数，需要子类实现
    function _implementation() internal view returns (address);

    // 以下是proxy合约通用代码，
    function _delegate(address implementation) internal {
        assembly {
            // 将msg.data，即交易的所有数据，复制到内存
            calldatacopy(0, 0, calldatasize)

            // 调用实现合约
            let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)

            // 将返回数据拷贝到内存
            returndatacopy(0, 0, returndatasize)

            switch result
            case 0 { revert(0, returndatasize) } // 0，失败
            default { return(0, returndatasize) } // 1, 成功
        }
    }

  // 子类可以重写次函数
  function _willFallback() internal {
  }

  // fallback函数实现
  function _fallback() internal {
    _willFallback();
    _delegate(_implementation());
  }
}

calldatacopy(t, f, s)：将calldata（输入数据）从位置f开始复制s字节到mem（内存）的位置t。
delegatecall(g, a, in, insize, out, outsize)：调用地址a的合约，输入为mem[in..(in+insize)) ，输出为mem[out..(out+outsize))，提供g的gas 和v wei的以太坊。这个操作码在错误时返回0，在成功时返回1。
returndatacopy(t, f, s)：将returndata（输出数据）从位置f开始复制s字节到mem（内存）的位置t。
switch：基础版if/else，不同的情况case返回不同值。可以有一个默认的default情况。
return(p, s)：终止函数执行, 返回数据mem[p..(p+s))。
revert(p, s)：终止函数执行, 回滚状态，返回数据mem[p..(p+s))。

参考代理合约： https://blog.csdn.net/weixin_30230009/article/details/127312438

示例

理解了代理（可升级）合约机制之后，我们动手实践一下

实现合约(implement)：

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Storage {

    uint256 number;

    function store(uint256 num) public {
        number = num;
    }

    function retrieve() public view returns (uint256){
        return number;
    }
}

代理合约：

// SPDX-License-Identifier: None

pragma solidity ^0.8.0;

library AddressUtils {

  /**
   * Returns whether the target address is a contract
   * @dev This function will return false if invoked during the constructor of a contract,
   * as the code is not actually created until after the constructor finishes.
   * @param addr address to check
   * @return whether the target address is a contract
   */
  function isContract(address addr) internal view returns (bool) {
    uint256 size;
    // XXX Currently there is no better way to check if there is a contract in an address
    // than to check the size of the code at that address.
    // See https://ethereum.stackexchange.com/a/14016/36603
    // for more details about how this works.
    // TODO Check this again before the Serenity release, because all addresses will be
    // contracts then.
    // solium-disable-next-line security/no-inline-assembly
    assembly { size := extcodesize(addr) }
    return size > 0;
  }

}
abstract contract Proxy {
  /**
   * @dev Fallback function.
   * Implemented entirely in `_fallback`.
   */
   fallback() payable external {
    _fallback();
  }

  receive() payable external {

  }

  /**
   * @return The Address of the implementation.
   */
  function _implementation() public virtual view returns (address);

  /**
   * @dev Delegates execution to an implementation contract.
   * This is a low level function that doesn't return to its internal call site.
   * It will return to the external caller whatever the implementation returns.
   * @param implementation Address to delegate.
   */
  function _delegate(address implementation) internal {
    assembly {
      // Copy msg.data. We take full control of memory in this inline assembly
      // block because it will not return to Solidity code. We overwrite the
      // Solidity scratch pad at memory position 0.
      calldatacopy(0, 0, calldatasize())

      // Call the implementation.
      // out and outsize are 0 because we don't know the size yet.
      let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

      // Copy the returned data.
      returndatacopy(0, 0, returndatasize())

      switch result
      // delegatecall returns 0 on error.
      case 0 { revert(0, returndatasize()) }
      default { return(0, returndatasize()) }
    }
  }

  /**
   * @dev Function that is run as the first thing in the fallback function.
   * Can be redefined in derived contracts to add functionality.
   * Redefinitions must call super._willFallback().
   */
  function _willFallback() internal {
  }

  /**
   * @dev fallback implementation.
   * Extracted to enable manual triggering.
   */
  function _fallback() internal {
    _willFallback();
    _delegate(_implementation());
  }
}

contract TestSstore is Proxy {

    bytes32 private constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;

     constructor(address implementation_)  {
        assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));

        setImplementation(implementation_);
    }

    function _implementation() public override view returns (address impl) {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            impl := sload(slot)
        }
    }


    function setImplementation(address newImplementation) public {
        require(AddressUtils.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");

        bytes32 slot = IMPLEMENTATION_SLOT;

        assembly {
            sstore(slot, newImplementation)
        }
    }

}

部署代理合约(Proxy)时候，需要填写实现合约(implement)的地址
为了获得调用代理合约的数据，可以先在remix里面调用实现合约，在Metamask中拿到数据，然后粘贴到代理合约调用处

示例：

部署实现合约： https://goerli.etherscan.io/tx/0x6a26cf6ff348bc32831d8dbd00ed4aae807591613e48435407fa41cb73b78c02
部署代理合约： https://goerli.etherscan.io/tx/0xcba8a55c22a31285185190170cf6d2a150a84b87f0c31d041023e64da3a5d83c
通过代理合约调用实现合约的store函数，写入12345：https://goerli.etherscan.io/tx/0x3ac401e00f917898d6d47765132667414b4a5f290e599df7e5af537297fba78b
直接读取实现合约，结果是0：https://goerli.etherscan.io/address/0x33ef59987eaa6776617f79673d5452849197778c#readContract
读取代理合约, 结果是 12345

我们再“升级”一下实现合约：

contract Storage {

 uint256 public number;
 uint256 public nb;

/**
 * @dev Store value in variable
 * @param num value to store
 */
function store(uint256 num) public {
    number = num ;
    nb  = number * 2;
}

/**
 * @dev Return value
 * @return value of 'number'
 */
function retrieve() public view returns (uint256){
    return number;
}
}

部署新的实现合约：https://goerli.etherscan.io/tx/0x4b5287ac0fd8756ac70cf50d4b66565310467f53c931489eaf6cf65014da116b
设置新实现合约地址: https://goerli.etherscan.io/tx/0x1f074c4a25f46fa7d6010a9e169847706aece07107b5a889918c20e84ea5d876
调用代理写入12345
读取代理合约，

总结

通过delegatecall进行调用实现合约，数据是存放在代理合约中，因此当“升级”实现合约合约后，不会影响现有的数据。

delegatecall很像“动态库”

关于delegatecall和 call的对比：

Rust借用分析

2022-11-13

技术

可以把Rust中的借用，理解为C语言中的指针， mut, &, 可变借用、不可变借用这些比较绕的概念，可以理解为C语言中的const修饰符(尽管，C语言中的const只是做一个“约定”, 这里只是为了方便理解，不必纠结)。

例如 let b = 1; let a = &b; , a是指向不可变变量b的不可变借用。

我们用C语言的可以表示为： const int b = 1; const int const *a = &b;

第1种


let b = 1;
let a = b;

println!("a = {} ", a);
println!("b = {}", b);
// println!("*a = {}", *a); // error:  type `{integer}` cannot be dereferenced

let c = 2;
// a = c; // error: cannot assign twice to immutable variable

let a = b; 是将b的值拷贝给a。注意，不是移动！
a 和 b一样，也是不可变的整型变量， a不是b引用，也不是b的move

第2种

let b = 2;
let a = &b;
println!("a = {}, b = {}", a, b);
println!("a = {}, b = {}", *a, b);

// *a = 99; // `a` is a `&` reference, so the data it refers to cannot be written

b是不可变整型变量
a是b的不可变引用, 因此*a(即a所引用的内容)不能被修改

第3种

let b = 2;
let mut a = &b;
println!("a = {}, b = {}", a, b); //  ok， 自动解引用
println!("*a = {}, b = {}", *a, b); // ok，手动解引用

let c = 3;
a = &c;  // 修改 a 的指向
println!("a = {}", a);

可以将引用理解为C语言中的指针, 很像 const修饰的原理

let mut a = &b; 其中 a是指向不可变变量b的可变引用，即b的内容不能被改变，但是，a本身的“指向”可以变
a = &c; 即改变了 a的指向， a指向了c

第4种

1 2	let b = 1; let a = &mut b; // error: cannot borrow `b` as mutable, as it is not declared as mutable

不能对不可变变量进行可变借用


let mut b = 1;
let a = &mut b;
println!("xxx===> a = {}", a);
// println!("xxx===> a = {}, b = {}", a, b); // error, 不能同时可变引用和不可引用
// println!("b = {}", b); //error, 不能同时可变引用和不可引用
*a = 99;
// println!("xxx===> a = {}, b = {}", a, b); // error，  不能同时可变引用和不可引用
println!("xxx===> a = {}", a);
println!("b = {}", b); // 可变引用用完了， 原来的不可变引用可以继续使用了

let mut c = 1;
// a = &mut c;  // error, cannot assign twice to immutable variable `a`

a是指向可变变量b的不可变引用，即a的指向不能变，所指向的内容（值）*a是可以变的

第5种

let b = 1;
let mut a = b; // 将b的值进行了拷贝
println!("===> a = {}, b = {}", a, b);
a = 2;
println!("===> a = {}, b = {}", a, b);

let mut a = b; 是将b的值拷贝到a，不是move！因此，互不影响
a是可变整型变量

第6种

let b = 1;
let &(mut a) = &b;
println!("+++ a = {}, b = {}", a, b);
a  = 999;
println!("+++ a = {}, b = {}", a, b);
// println!("+++ a = {}, b = {}", *a, b); // type `{integer}` cannot be dereferenced

let &(mut a) = &b; 可以“约”多余符号，等效于 let mut a = b;, 因此效果同上例(第5种), 不赘述

第7种


let mut c = 1;
let mut a = &mut c;
*a = 99;
println!("a = {}", *a);

let mut d = 33;
a = &mut d; // ok
println!("a = {}", *a);

如果理解上面提到集中情况，很容易理解此种变化
a 是指向 可变整型变量c的可变整型变量的可变引用
两个“可变”即代表， a所指向内容(*a)是可以修改的；同时，a本身的“指向”也是可以修改的

第8种

let b = 1;
// let ref mut a  = b;  // 错，同 let a = &mut b;
let mut c = 1;
let ref mut a = c; // 等效于   let a = &mut c;
*a = 99;
// println!("a = {}, c = {}", *a, c); // error,  c已经被可变借用了，不能和可变借用同时存在
println!("a = {}", *a);
println!("c = {}", c); // 可变借用用完之后，  c不可变引用又可以使用了

let mut d = 777;
// a = &mut d; // error, cannot assign twice to immutable variable `a`
// println!("a = {}", a);

let ref mut a = c; 等效于 let a = &mut c;