代理模式

1986年，竹内弘高和野中郁次郎阐述了一种新的整体性的方法，该方法能够提高商业新产品开发的速度和灵活性：
他们将这种新的整体性方法与橄榄球相比较，前者各阶段相互重叠，并且由一个跨职能团队在不同的阶段完成整个过程，而团队“作为一个整体前进，把球传来传去”。
他们对来自汽车，照片机器，计算机和打印机等产业的案例进行了研究。
1991年，DeGrace和Stahl在《Wicked Problems, Righteous Solutions》一书中将这种方法称为scrum，在竹内弘高和野中郁次郎的文章中提到的橄榄球术语。
1990年代初，Ken Schwaber在其公司使用了一种方法Advanced Development Methods（先进开发方法），这种方法后来发展为Scrum。
1993，Jeff Sutherland 在Easel公司开发了一种类似的方法，并首次称之为Scrum。
1995年，在奥斯汀举办的OOPSLA ’95上，Jeff Sutherland 和Ken Schwaber联合发表了论文首次提出了Scrum概念。Ken Schwaber和Jeff Sutherland 在接下的几年里合作，将上述的文章，他们的经验，以及业界的最佳实践融合起来，形成我们现在所知的Scrum。
2001年，Ken Schwaber与Mike Beedle合著了《敏捷软件开发-使用Scrum过程》一书，介绍了Scrum方法。
2001年，Jeff Sutherland和Ken Schwaber参与了犹他州的17人聚会，参与发布了《敏捷宣言和十二原则》。
2002年，Ken Schwaber和Mike Cohn创办了Scrum Alliance。

SCRUM框架

Scrum框架包括3个角色、3个工件、5个事件、5个价值：

3个角色

产品负责人（Product Owner）：
Scrum Master
开发团队

3个工件

产品Backlog（Product Backlog）
SprintBacklog
产品增量（Increment）

5个事件

Sprint（Sprint本身是一个事件，包括了如下4个事件）
Sprint计划会议（Sprint Planning Meeting）
每日站会（Daily Scrum Meeting）
Sprint评审会议（Sprint Review Meeting）
Sprint回顾会议（Sprint Retrospective Meeting）

5个价值

承诺 – 愿意对目标做出承诺
专注– 把你的心思和能力都用到你承诺的工作上去
开放– Scrum 把项目中的一切开放给每个人看
尊重– 每个人都有他独特的背景和经验
勇气– 有勇气做出承诺，履行承诺，接受别人的尊重

SCRUM理论基础

Scrum以经验性过程控制理论（经验主义）做为理论基础的过程。经验主义主张知识源于经验, 以及基于已知的东西做决定。Scrum 采用迭代、增量的方法来优化可预见性并控制风险。
Scrum 的三大支柱支撑起每个经验性过程控制的实现:透明性、检验和适应。Scrum的三大支柱如下：

第一：透明性（Transparency）

透明度是指，在软件开发过程的各个环节保持高度的可见性，影响交付成果的各个方面对于参与交付的所有人、管理生产结果的人保持透明。管理生产成果的人不仅要能够看到过程的这些方面，而且必须理解他们看到的内容。也就是说，当某个人在检验一个过程，并确信某一个任务已经完成时，这个完成必须等同于他们对完成的定义。

第二：检验（Inspection）

开发过程中的各方面必须做到足够频繁地检验，确保能够及时发现过程中的重大偏差。在确定检验频率时，需要考虑到检验会引起所有过程发生变化。当规定的检验频率超出了过程检验所能容许的程度，那么就会出现问题。幸运的是，软件开发并不会出现这种情况。另一个因素就是检验工作成果人员的技能水平和积极性。

第三：适应（Adaptation）

如果检验人员检验的时候发现过程中的一个或多个方面不满足验收标准，并且最终产品是不合格的，那么便需要对过程或是材料进行调整。调整工作必须尽快实施，以减少进一步的偏差。

Scrum中通过三个活动进行检验和适应：

每日例会检验Sprint目标的进展，做出调整，从而优化次日的工作价值；
Sprint评审和计划会议检验发布目标的进展，做出调整，从而优化下一个Sprint的工作价值；
Sprint回顾会议是用来回顾已经完成的Sprint，并且确定做出什么样的改善可以使接下来的Sprint更加高效、更加令人满意，并且工作更快乐。

协作平台-调研

发表于 2019-06-07 分类于效率
本文字数： 1.4k 阅读时长 ≈ 1 分钟

概览

协作，让企业和团队实现目标

本文所讲“协作平台”并非传统项目管理系统也不是其的延续，协作平台最初的模型是 TODO List的目的是使使用者提高效率，使事情井井有序远离杂乱，最为典型的是它的看板模式的存在。然而有它的交互的确非常棒（相比原有的项目管理软件足够简单），使用者想将所有的需求都转移到此上面，进而使其功能得到延展，从而具备了：OA系统功能、销售系统功能、敏捷项目管理流程、等等。

调研对象

tower
- 任务看板
  * 在线讨论
  * 在线文档、协作
  * 文件共享
  * 团队日历
  * 汇报功能
  * 角色控制
teambition
- 账号
  * 项目
  * 任务
  * 文件
- 日程
  * 分享
  * 插件中心（wiki、PRD一览、项目概览、敏捷、okr、时间视图、测试用例）
码云企业版
- 代码托管
  * 项目全过程管理（需求、缺陷、规划迭代）（任务、看板、燃尽图）
  * 协作文档（md、多人协作、树形目录、git管理）
worktile
- 任务
  * 沟通（IM)
  * 日历
  * 网盘
  * 简报（日报、周报、销售日报、研发周报、产品月报）
  * 办公（招聘、离职、请假、出差、绩效、用印、采购、仓库储存）
  * 开放平台（API)
- SSO
  * 服务集成（印象笔记、zendesk）

核心功能

项目

顶级结点，用来聚合有关联的任务、文件、日历、测试用例等等。一个系统、一个部门、一件事情都可以当做一个项目。

任务

一个任务一般包含：人、时间、事件三要素。它可以是独立存在的，也可以属于某一个项目下的。协作平台几乎所有的东西都是围绕它展开的，它应该是系统里面的最小单元了。

日历

从时间角度去排列任务，从而更清晰的了解人、项目、的时间表。

用户权限

控制力度细致到，任何一个单位（项目、文件、日程）的读、写操作。

文件共享

一般具备功能：在线文档(富文本、md文档)、上传附件、预览、在线编辑、版本管理。

延展功能

OA（办公自动化）是面向组织的日常运作和管理，英文全称Office Automation System。

流程管理
考勤
人事（招聘、入职、培训、晋升、离职、绩效）

资产管理（消耗品、使用权）

公车、办公室、办公用品等资源利用情况，避免丢失、冲突，明确改进方向。

知识库

经验的沉淀，避免同一个错误两次发生，成功经验快速共享。

复杂项目管理

okr绩效管理，scrum敏捷项目管理。

其它

财务、IM

总结

协作平台应该围绕：安全、人、资产、钱、业务（产品、市场、运营）进行的，沟通是协作的核弹设计图，协作平台是核弹组装厂，以下是的核弹：

安全
- 权限管理
  * 备份
  * 加密
用户管理
- 组织结构
  * 职责划分
  * 人才的选用育留（招聘、入职、考核、转正、晋升、转岗、离职）
  * 团队建设
  * 成长路线图费
资产管理
- 固定资产
  * 独享
  * 工位
  * 电脑
  * 共享
  * 打印机
  * 会议室
  * 餐吧
  * 健身器材
  * 虚拟资产
  * 知识库
  * 销售经验
  * 技术经验
  * 人事管理经验
  * 产品技术文档
  * 公司文化（制度、办法）
  * 培训资料
  * 合作公司库
财务
- 对内管理
  * 对外合规
业务
- 方法论
  * 一件事总可以分解为树形图的任务
  * 一个任务总明确人、时间、预期结果
  * scrum管理
  * 看板
  * 一览（人、时间、进度、资金）
  * 计划&实际的对比
  * 任务与任务以及其他财务、资产、用户的关联性、依赖性、先后性。
  * 前置条件
  * 流程化
  * 一件事情总有明确的目的
  * 过去的事情必须是可以复盘的
  * 前置标价化：事前就告知任务以及对应奖罚，而非事后。
沟通
- 可基于任何一个元素有效沟通（打印机、文件、会议室、制度、产品、任务、项目、等等）
  * 沟通可以进行归档为复盘核心数据

主流协作平台功能脑图

国家职业资格证

发表于 2019-05-29
本文字数： 276 阅读时长 ≈ 1 分钟

概述

职业资格证分为准入类、水平评价类。其中准入类时从事相关职业必须要取得的证书，水平评价类某些职位会有要去，同时作为国家认可的能力。可以享受很多福利待遇。
我们常见的职业资格证有：

教师资格证
注册会计师
法律职业资格证，律师
注册建筑工程师
护士职业资格证
记者
导游
…

计算机技术与软件专业技术资格

说明

工作非必须、一般工作无用
在北京可以以此办理《工作居住证》(工作居住证正常是必须本科及以上学历才可以办理的)，大专生的福音。
待补充

证件模版

资格设置

岗位设置介绍

报考时间

3月份
8月份

考试时间

5月份
11月份

网站

职业资格证目录

，

Java语法糖

发表于 2019-05-28 分类于 java
本文字数： 8.6k 阅读时长 ≈ 8 分钟

概述

几乎所有语法都有语法糖；
无实质性的功能，方便开发者；
或能提高编码效率，或能提供可读性、严谨性；

常见语法糖

泛型与类型擦除

泛型思想最早出现在C++，JDK1.5引进，本质是参数化类型（Parametersized Type)。包含泛型接口、泛型类、泛型方法。Java无泛型时，经常需要开发者强制转换Object类型，运行期间必须对这些风险做处理。泛型出现后将这些风险前置到编译期间。

代码示例：

//不使用泛型
List array=new ArrayList();
array.add(“abc”);
array.add(123);//编译通过
String v=(String)array.get(0);//处理ClassCastException异常

//使用泛型
List<String> array2=new ArrayList();
array2.add("abc");
array.add(123);//编译不通过
String v2=array2.get(0);

自动装箱、拆箱与遍历循环

包装类的"=="运算在不遇到算数运算的情况下不会自动拆箱
equals方法不处理数据类型转换的关系。

示例代码：

/**
     * 自动装箱、拆箱
     * <p>
     * a==a1 : true
     * c.equals(c1) : false
     * d.equals(a1 + b1) : false
     * d==a1+b1 : true
     */
    @Test
    public void boxOrUnbox() {
        int a = 1;
        Integer a1 = 1;
        int b = 2;
        Integer b1 = 2;
        Integer c = 300;
        Long c1 = 300l;
        Long d = 3L;

        System.out.println("a==a1 : " + (a == a1));
        System.out.println("c.equals(c1) : " + (c.equals(c1)));
        System.out.println("d.equals(a1 + b1) : " + (d.equals(a1 + b1)));
        System.out.println("d==a1+b1 : " + (d == (a1 + b1)));

    }

条件编译

通过推理可以预测到用于不会执行的代码会在编译时丢掉。

/**
    * 条件编译
    * <p>
    */
   @Test
   public void conditionCompile() {

       if (false) {
           System.out.println("222222");
       }
       System.out.println("33333");

   }
   
 //编译后字节码
 // access flags 0x1
 public conditionCompile()V
 @Lorg/junit/Test;()
  L0
   LINENUMBER 85 L0
   GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
   LDC "33333"
   INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
  L1
   LINENUMBER 87 L1
   RETURN
  L2
   LOCALVARIABLE this Lcom/hardydou/lang/GrammarSugarTest; L0 L2 0
   MAXSTACK = 2
   MAXLOCALS = 1

此语法糖只针对if有效，其它条件语(while、for、switch)句会提醒无法编译提示：Unreachable statement

示例代码：

1
2
3

for (; false; ) {}
while (false) {}

内部类

枚举

是一个类
集成enum类
是一个final 类

enum EType {
    A,
    B,
    C;
}

编译后

// class version 52.0 (52)
// access flags 0x4030
// signature Ljava/lang/Enum<Lcom/hardydou/lang/EType;>;
// declaration: com/hardydou/lang/EType extends java.lang.Enum<com.hardydou.lang.EType>
final enum com/hardydou/lang/EType extends java/lang/Enum {

  // compiled from: GrammarSugarTest.java

  // access flags 0x4019
  public final static enum Lcom/hardydou/lang/EType; A

  // access flags 0x4019
  public final static enum Lcom/hardydou/lang/EType; B

  // access flags 0x4019
  public final static enum Lcom/hardydou/lang/EType; C

  // access flags 0x101A
  private final static synthetic [Lcom/hardydou/lang/EType; $VALUES

  // access flags 0x9
  public static values()[Lcom/hardydou/lang/EType;
   L0
    LINENUMBER 131 L0
    GETSTATIC com/hardydou/lang/EType.$VALUES : [Lcom/hardydou/lang/EType;
    INVOKEVIRTUAL [Lcom/hardydou/lang/EType;.clone ()Ljava/lang/Object;
    CHECKCAST [Lcom/hardydou/lang/EType;
    ARETURN
    MAXSTACK = 1
    MAXLOCALS = 0

  // access flags 0x9
  public static valueOf(Ljava/lang/String;)Lcom/hardydou/lang/EType;
   L0
    LINENUMBER 131 L0
    LDC Lcom/hardydou/lang/EType;.class
    ALOAD 0
    INVOKESTATIC java/lang/Enum.valueOf (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
    CHECKCAST com/hardydou/lang/EType
    ARETURN
   L1
    LOCALVARIABLE name Ljava/lang/String; L0 L1 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x2
  // signature ()V
  // declaration: void <init>()
  private <init>(Ljava/lang/String;I)V
   L0
    LINENUMBER 131 L0
    ALOAD 0
    ALOAD 1
    ILOAD 2
    INVOKESPECIAL java/lang/Enum.<init> (Ljava/lang/String;I)V
    RETURN
   L1
    LOCALVARIABLE this Lcom/hardydou/lang/EType; L0 L1 0
    MAXSTACK = 3
    MAXLOCALS = 3

  // access flags 0x8
  static <clinit>()V
   L0
    LINENUMBER 132 L0
    NEW com/hardydou/lang/EType
    DUP
    LDC "A"
    ICONST_0
    INVOKESPECIAL com/hardydou/lang/EType.<init> (Ljava/lang/String;I)V
    PUTSTATIC com/hardydou/lang/EType.A : Lcom/hardydou/lang/EType;
   L1
    LINENUMBER 133 L1
    NEW com/hardydou/lang/EType
    DUP
    LDC "B"
    ICONST_1
    INVOKESPECIAL com/hardydou/lang/EType.<init> (Ljava/lang/String;I)V
    PUTSTATIC com/hardydou/lang/EType.B : Lcom/hardydou/lang/EType;
   L2
    LINENUMBER 134 L2
    NEW com/hardydou/lang/EType
    DUP
    LDC "C"
    ICONST_2
    INVOKESPECIAL com/hardydou/lang/EType.<init> (Ljava/lang/String;I)V
    PUTSTATIC com/hardydou/lang/EType.C : Lcom/hardydou/lang/EType;
   L3
    LINENUMBER 131 L3
    ICONST_3
    ANEWARRAY com/hardydou/lang/EType
    DUP
    ICONST_0
    GETSTATIC com/hardydou/lang/EType.A : Lcom/hardydou/lang/EType;
    AASTORE
    DUP
    ICONST_1
    GETSTATIC com/hardydou/lang/EType.B : Lcom/hardydou/lang/EType;
    AASTORE
    DUP
    ICONST_2
    GETSTATIC com/hardydou/lang/EType.C : Lcom/hardydou/lang/EType;
    AASTORE
    PUTSTATIC com/hardydou/lang/EType.$VALUES : [Lcom/hardydou/lang/EType;
    RETURN
    MAXSTACK = 4
    MAXLOCALS = 0
}

断言语句

在Java中，assert关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了assert关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略！）。如果要开启断言检查，则需要用开关-enableassertions或-ea来开启。

/**
    * 测试断言语法糖
    */
   @Test
   public void assertTest() {
       int c = 2;
       assert c != 1 + 1;
       System.out.println("1111");

   }

编译后

// access flags 0x1
  public assertTest()V
  @Lorg/junit/Test;()
   L0
    LINENUMBER 140 L0
    ICONST_2
    ISTORE 1
   L1
    LINENUMBER 141 L1
    GETSTATIC com/hardydou/lang/GrammarSugarTest.$assertionsDisabled : Z
    IFNE L2
    ILOAD 1
    ICONST_2
    IF_ICMPNE L2
    NEW java/lang/AssertionError
    DUP
    INVOKESPECIAL java/lang/AssertionError.<init> ()V
    ATHROW
   L2
    LINENUMBER 142 L2
   FRAME APPEND [I]
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "1111"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L3
    LINENUMBER 144 L3
    RETURN

switch对字符串的支持

jdk1.7 switch开始支持String类型，其实switch并未修改。只是在String编译的时候通过hashcode转换为long类型而已。
示例代码：

@Test
   public void switchAndStr() {
       switch ("abc") {
           case "abc":
               System.out.println("abc");
       }

   }

反编译后

@Test
    public void switchAndStr() {
        String var1 = "abc";
        byte var2 = -1;
        switch(var1.hashCode()) {
        case 96354:
            if (var1.equals("abc")) {
                var2 = 0;
            }
        default:
            switch(var2) {
            case 0:
                System.out.println("abc");
            default:
            }
        }
    }

try语句中定义和关闭资源

Java 7开始，jdk提供了一种更好的方式关闭资源，使用try-with-resources语句
示例代码：

/**
    * 资源关闭语法糖
    */
   @Test
   public void try_with_resource() {

       try (BufferedReader br = new BufferedReader(new FileReader(""))) {

           br.readLine();

       } catch (Exception e) {

       }

   }

反编译后

@Test
    public void try_with_resource() {
        try {
            BufferedReader br = new BufferedReader(new FileReader(""));
            Throwable var2 = null;
            try {
                br.readLine();
            } catch (Throwable var12) {
                var2 = var12;
                throw var12;
            } finally {
                if (br != null) {
                    if (var2 != null) {
                        try {
                            br.close();
                        } catch (Throwable var11) {
                            var2.addSuppressed(var11);
                        }
                    } else {
                        br.close();
                    }
                }

            }
        } catch (Exception var14) {
        }

    }

for-each

示例代码

/**
     * for-each语法糖
     */
    @Test
    public void forEach() {
        String[] ss = new String[]{"a", "b", "c"};
        for (String s : ss) {
            System.out.println(s);
        }
        for (String s : Arrays.asList(ss)) {
            System.out.println(s);
        }
    }

反编译后

@Test
    public void forEach() {
        String[] ss = new String[]{"a", "b", "c"};
        String[] var2 = ss;
        int var3 = ss.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String s = var2[var4];
            System.out.println(s);
        }

        Iterator var6 = Arrays.asList(ss).iterator();

        while(var6.hasNext()) {
            String s = (String)var6.next();
            System.out.println(s);
        }

    }

字面量

示例代码

/**
  * 字面量
  */
 @Test
 public void zimianliang() {
     int a = 10_00;
     int b = 1000;
     System.out.println(a == b);
 }

反编译后

@Test
   public void zimianliang() {
       int a = 1000;
       int b = 1000;
       System.out.println(a == b);
   }

方法变长参数

示例代码：

@Test
    public void classTest() {
        build("a", "c", "b");
    }

    public static String build(String... strs) {
        String r = "";
        for (String s : strs) {
            r += s;
        }
        return r;
    }

反编译后

@Test
   public void classTest() {
       build("a", "c", "b");
   }

   public static String build(String... strs) {
       String r = "";
       String[] var2 = strs;
       int var3 = strs.length;

       for(int var4 = 0; var4 < var3; ++var4) {
           String s = var2[var4];
           r = r + s;
       }
       return r;
   }

语法糖坑

泛型重载

//无法通过编译
public static void m1(List<String> list) { 
   }
   public static void m1(List<Integer> list) {  
   }

泛型不可用于exception

//以下代码是错误示例
//被擦除后 两个都是MyException 无法分开。
try{
...
}catch(MyException<Integer> e){
...
}catch(MyException<String> f){
....
}

泛型的静态变量

class O<T>{
public static var=0;
}

O<String> o1=new O();
o1.var=1;
O<Intger> o2=new O();
o2.var=2;

//此时，o1.var 跟 o2.var 是同一个。

自动拆箱-对象相等容易混淆

适用于整数值区间-128 至 +127。
只适用于自动装箱。使用构造函数创建对象不适用。

Integer a2 = 1000;
Integer b2 = 1000;
System.out.println("a2==b2 is " + (a2 == b2));//false
Integer a3 = 127;
Integer b3 = 127;
System.out.println("a3==b3 is " + (a3 == b3));//true