• 问三个为什么？为什么这么做？解决什么问题？对业务有什么影响？
• 确保理解需求得目标目的和价值；

• 整体技术方案思路产出
• 和前端的交互方案，是spa还是mpa？是否前后端分离；
• 和后端系统的交互方案；

• 先产出接口文档，保证其他团队使用；
• 先产出假接口；
• 方案设计（db，缓存，cdn）；

• 代码分层建设，mvc分层开发；

• 提测之前确保自测通过
• 自测通过以后，读prd，确保一致；

• 首先，geohash用一个字符串表示经度和纬度两个坐标。某些情况下无法在两列上同时应用索引 （例如MySQL 4之前的版本，Google App Engine的数据层等），利用geohash，只需在一列上应用索引即可。
• 其次，geohash表示的并不是一个点，而是一个矩形区域。比如编码wx4g0ec19，它表示的是一个矩形区域。 使用者可以发布地址编码，既能表明自己位于北海公园附近，又不至于暴露自己的精确坐标，有助于隐私保护。
• 第三，编码的前缀可以表示更大的区域。例如wx4g0ec1，它的前缀wx4g0e表示包含编码wx4g0ec1在内的更大范围。 这个特性可以用于附近地点搜索。首先根据用户当前坐标计算geohash（例如wx4g0ec1）然后取其前缀进行查询 （SELECT * FROM place WHERE geohash LIKE 'wx4g0e%'），即可查询附近的所有地点。

<?php

/**

 * Geohash generation class

 * http://blog.dixo.net/downloads/

 *

 * This file copyright (C) 2008 Paul Dixon (paul@elphin.com)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */







/**

* Encode and decode geohashes

*

*/

class Geohash

{

    private $coding="0123456789bcdefghjkmnpqrstuvwxyz";

    private $codingMap=array();

    

    public function Geohash()

    {

        //build map from encoding char to 0 padded bitfield

        for($i=0; $i<32; $i++)

        {

            $this->codingMap[substr($this->coding,$i,1)]=str_pad(decbin($i), 5, "0", STR_PAD_LEFT);

        }

        

    }

    

    /**

    * Decode a geohash and return an array with decimal lat,long in it

    */

    public function decode($hash)

    {

        //decode hash into binary string

        $binary="";

        $hl=strlen($hash);

        for($i=0; $i<$hl; $i++)

        {

            $binary.=$this->codingMap[substr($hash,$i,1)];

        }

        

        //split the binary into lat and log binary strings

        $bl=strlen($binary);

        $blat="";

        $blong="";

        for ($i=0; $i<$bl; $i++)

        {

            if ($i%2)

                $blat=$blat.substr($binary,$i,1);

            else

                $blong=$blong.substr($binary,$i,1);

            

        }

        

        //now concert to decimal

        $lat=$this->binDecode($blat,-90,90);

        $long=$this->binDecode($blong,-180,180);

        

        //figure out how precise the bit count makes this calculation

        $latErr=$this->calcError(strlen($blat),-90,90);

        $longErr=$this->calcError(strlen($blong),-180,180);

                

        //how many decimal places should we use? There's a little art to

        //this to ensure I get the same roundings as geohash.org

        $latPlaces=max(1, -round(log10($latErr))) - 1;

        $longPlaces=max(1, -round(log10($longErr))) - 1;

        

        //round it

        $lat=round($lat, $latPlaces);

        $long=round($long, $longPlaces);

        

        return array($lat,$long);

    }



    

    /**

    * Encode a hash from given lat and long

    */

    public function encode($lat,$long)

    {

        //how many bits does latitude need?    

        $plat=$this->precision($lat);

        $latbits=1;

        $err=45;

        while($err>$plat)

        {

            $latbits++;

            $err/=2;

        }

        

        //how many bits does longitude need?

        $plong=$this->precision($long);

        $longbits=1;

        $err=90;

        while($err>$plong)

        {

            $longbits++;

            $err/=2;

        }

        

        //bit counts need to be equal

        $bits=max($latbits,$longbits);

        

        //as the hash create bits in groups of 5, lets not

        //waste any bits - lets bulk it up to a multiple of 5

        //and favour the longitude for any odd bits

        $longbits=$bits;

        $latbits=$bits;

        $addlong=1;

        while (($longbits+$latbits)%5 != 0)

        {

            $longbits+=$addlong;

            $latbits+=!$addlong;

            $addlong=!$addlong;

        }

        

        

        //encode each as binary string

        $blat=$this->binEncode($lat,-90,90, $latbits);

        $blong=$this->binEncode($long,-180,180,$longbits);

        

        //merge lat and long together

        $binary="";

        $uselong=1;

        while (strlen($blat)+strlen($blong))

        {

            if ($uselong)

            {

                $binary=$binary.substr($blong,0,1);

                $blong=substr($blong,1);

            }

            else

            {

                $binary=$binary.substr($blat,0,1);

                $blat=substr($blat,1);

            }

            $uselong=!$uselong;

        }

        

        //convert binary string to hash

        $hash="";

        for ($i=0; $i<strlen($binary); $i+=5)

        {

            $n=bindec(substr($binary,$i,5));

            $hash=$hash.$this->coding[$n];

        }

        

        

        return $hash;

    }

    

    /**

    * What's the maximum error for $bits bits covering a range $min to $max

    */

    private function calcError($bits,$min,$max)

    {

        $err=($max-$min)/2;

        while ($bits--)

            $err/=2;

        return $err;

    }

    

    /*

    * returns precision of number

    * precision of 42 is 0.5

    * precision of 42.4 is 0.05

    * precision of 42.41 is 0.005 etc

    */

    private function precision($number)

    {

        $precision=0;

        $pt=strpos($number,'.');

        if ($pt!==false)

        {

            $precision=-(strlen($number)-$pt-1);

        }

        

        return pow(10,$precision)/2;

    }

    

    

    /**

    * create binary encoding of number as detailed in http://en.wikipedia.org/wiki/Geohash#Example

    * removing the tail recursion is left an exercise for the reader

    */

    private function binEncode($number, $min, $max, $bitcount)

    {

        if ($bitcount==0)

            return "";

        

        #echo "$bitcount: $min $max<br>";

            

        //this is our mid point - we will produce a bit to say

        //whether $number is above or below this mid point

        $mid=($min+$max)/2;

        if ($number>$mid)

            return "1".$this->binEncode($number, $mid, $max,$bitcount-1);

        else

            return "0".$this->binEncode($number, $min, $mid,$bitcount-1);

    }

    



    /**

    * decodes binary encoding of number as detailed in http://en.wikipedia.org/wiki/Geohash#Example

    * removing the tail recursion is left an exercise for the reader

    */

    private function binDecode($binary, $min, $max)

    {

        $mid=($min+$max)/2;

        

        if (strlen($binary)==0)

            return $mid;

            

        $bit=substr($binary,0,1);

        $binary=substr($binary,1);

        

        if ($bit==1)

            return $this->binDecode($binary, $mid, $max);

        else

            return $this->binDecode($binary, $min, $mid);

    }

}





?>

1）一个番茄时间（25分钟）不可分割，不存在半个或一个半番茄时间。
2）一个番茄时间内如果做与任务无关的事情，则该番茄时间作废。
3）永远不要在非工作时间内使用《番茄工作法》。（例如：用3个番茄时间陪儿子下的棋、用5个番茄时间钓鱼，等等。）
4）不要拿自己的番茄数据与他人的番茄数据比较。
5）番茄的数量不可能决定任务最终的成败。
6）必须有一份适合自己的作息时间表。

1、每天开始的时候规划今天要完成的几项任务，将任务逐项写在列表里（或记在软件的清单里）
2、设定你的番茄钟（定时器、软件、闹钟等），时间是25分钟。
3、开始完成第一项任务，直到番茄钟响铃或提醒（25分钟到）。
4、停止工作，并在列表里该项任务后画个X。
5、休息3~5分钟，活动、喝水、方便等等。
6、开始下一个番茄钟，继续该任务。一直循环下去，直到完成该任务，并在列表里将该任务划掉。
7、每四个番茄钟后，休息25分钟。

a.非得马上做不可的话，停止这个番茄钟并宣告它作废（哪怕还剩5分钟就结束了），去完成这件事情，之后再重新开始同一个番茄钟；
b.不是必须马上去做的话，在列表里该项任务后面标记一个逗号（表示打扰），并将这件事记在另一个列表里（比如叫“计划外事件”），然后接着完成这个番茄钟。

1、减轻时间焦虑
2、提升集中力和注意力，减少中断
3、增强决策意识
4、唤醒激励和持久激励
5、巩固达成目标的决心
6、完善预估流程，精确地保质保量
7、改进工作学习流程
8、强化决断力，快刀斩乱麻

test1.php

<?php

namespace MyProject;



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

?>



test2.php

<html>

<?php

namespace MyProject; // 致命错误 -　命名空间必须是程序脚本的第一条语句

?>

<?php

namespace MyProject\Sub\Level;



const CONNECT_OK = 1;             //常量MyProject\Sub\Level\CONNECT_OK

class Connection { /* ... */ }    //类 MyProject\Sub\Level\Connection

function connect() { /* ... */  } //函数MyProject\Sub\Level\connect

?>

<?php

namespace MyProject;



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }



namespace AnotherProject;



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

?>



//不建议使用这种语法在单个文件中定义多个命名空间。建议使用下面的大括号形式的语法



//定义多个命名空间，大括号语法

<?php

namespace MyProject {



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

}



namespace AnotherProject {



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

}

?>

//定义多个命名空间和不包含在命名空间中的代码

<?php

declare(encoding='UTF-8'); //除了开始的declare语句外，命名空间的括号外不得有任何PHP代码。

namespace MyProject {



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

}



namespace { // global 



codesession_start();

$a = MyProject\connect();

echo MyProject\Connection::start();

}

?>

1. 相对文件名形式如foo.txt。它会被解析为currentdirectory/foo.txt，其中 currentdirectory表示当前目录。因此如果当前目录是/home/foo，则该文件名被解析为/home/foo/foo.txt。
2. 相对路径名形式如subdirectory/foo.txt。它会被解析为currentdirectory/subdirectory/foo.txt。
3. 绝对路径名形式如/main/foo.txt。它会被解析为/main/foo.txt。

1. 非限定名称，或不包含前缀的类名称，例如 $a=new foo(); 或foo::staticmethod();。如果当前命名空间是currentnamespace，foo 将被解析为currentnamespace\foo。如果使用 foo的代码是全局的，不包含在任何命名空间中的代码，则 foo 会被解析为foo。警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。
2. 限定名称,或包含前缀的名称，例如$a = new subnamespace\foo(); 或subnamespace\foo::staticmethod();。如果当前的命名空间是currentnamespace，则 foo 会被解析为currentnamespace\subnamespace\foo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo会被解析为subnamespace\foo。
3. 完全限定名称，或包含了全局前缀操作符的名称，例如，$a = new \currentnamespace\foo(); 或 \currentnamespace\foo::staticmethod();。在这种情况下，foo 总是被解析为代码中的文字名(literal name)currentnamespace\foo。

file1.php



<?php

namespace Foo\Bar\subnamespace;



const FOO = 1;

function foo() {}

class foo{    

    static function staticmethod() {}

}

?>



file2.php



<?php

namespace Foo\Bar;

include 'file1.php';



const FOO = 2;

function foo() {}

class foo{    

    static function staticmethod() {}

}



/* 非限定名称 */

foo(); // 解析为 Foo\Bar\foo resolves to function Foo\Bar\foo

foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod。resolves to class Foo\Bar\foo, method staticmethod

echo FOO; // resolves to constant Foo\Bar\FOO



/* 限定名称 */

subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo

subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,                                  

                                  // 以及类的方法 staticmethod

echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO                                  



/* 完全限定名称 */

\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo

\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod

echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO

?>

<?php

namespace Foo;



function strlen() {}

const INI_ALL = 3;

class Exception {}



$a = \strlen('hi'); // 调用全局函数

strlen $b = \INI_ALL; // 访问全局常量

INI_ALL $c = new \Exception('error'); // 实例化全局类 Exception

?>

//__NAMESPACE__ 示例, 在命名空间中的代码

<?php

namespace MyProject;



echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"

?>



//__NAMESPACE__ 示例，全局代码

<?php



echo '"', __NAMESPACE__, '"'; // 输出 " "

?>



//使用__NAMESPACE__动态创建名称

<?php

namespace MyProject;

function get($classname){    

    $a = __NAMESPACE__ . '\\' . $classname;    

    return new $a;

}

?>



//namespace操作符，命名空间中的代码

<?php

namespace MyProject;



use blah\blah as mine;          // see "Using namespaces: importing/aliasing"

blah\mine();                    // calls function MyProject\blah\mine()

namespace\blah\mine();          // calls function MyProject\blah\mine()

namespace\func();               // calls function MyProject\func()

namespace\sub\func();           // calls function MyProject\sub\func()

namespace\cname::method();      // calls static method "method" of class MyProject\cname

$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname

$b = namespace\CONSTANT;        // assigns value of constant MyProject\CONSTANT to $b



?>



//namespace操作符, 全局代码

<?php

namespace\func();            // calls function func()

namespace\sub\func();        // calls function sub\func()

namespace\cname::method();   // calls static method "method" of class cname



$a = new namespace\sub\cname(); // instantiates object of class sub\cname

$b = namespace\CONSTANT;        // assigns value of constant CONSTANT to $b

?>

//使用use操作符导入/使用别名

<?php

namespace foo;



use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同

use My\Full\NSname;



// 导入一个全局类

use ArrayObject;



// importing a function (PHP 5.6+)

use function My\Full\functionName;



// aliasing a function (PHP 5.6+)

use function My\Full\functionName as func;



// importing a constant (PHP 5.6+)

use const My\Full\CONSTANT;



$obj = new namespace\Another; // 实例化 foo\Another 对象

$obj = new Another; // 实例化 My\Full\Classname　对象

NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func

$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象

// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象

func(); // calls function My\Full\functionName

echo CONSTANT; // echoes the value of My\Full\CONSTANT

?>

//通过use操作符导入/使用别名，一行中包含多个use语句

<?php

use My\Full\Classname as Another, My\Full\NSname;



$obj = new Another; // 实例化 My\Full\Classname 对象

NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func

?>



//导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是。 

<?php

use My\Full\Classname as Another, My\Full\NSname;



$obj = new Another; // 实例化一个 My\Full\Classname 对象

$a = 'Another';

$obj = new $a;      // 实际化一个 Another 对象

?>



//另外，导入操作只影响非限定名称和限定名称。完全限定名称由于是确定的，故不受导入的影响。

<?php

use My\Full\Classname as Another, My\Full\NSname;



$obj = new Another; // instantiates object of class My\Full\Classname

$obj = new \Another; // instantiates object of class Another

$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing

$obj = new \Another\thing; // instantiates object of class Another\thing

?>

<?php

namespace A\B\C;



/* 这个函数是 A\B\C\fopen */

function fopen() {      

    /* ... */     

    $f = \fopen(...); // 调用全局的fopen函数     

    return $f;

} 

?>

• 非限定名称Unqualified name：名称中不包含命名空间分隔符的标识符，例如 Foo
• 限定名称Qualified name：名称中含有命名空间分隔符的标识符，例如 Foo\Bar
• 完全限定名称Fully qualified name：称中包含命名空间分隔符，并以命名空间分隔符开始的标识符，例如 \Foo\Bar。 namespace\Foo 也是一个完全限定名称。

<?php

namespace A;

use B\D, C\E as F;



// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()            

            // 再尝试调用全局函数 "foo"



\foo();     // 调用全局空间函数 "foo" 



my\foo();   // 调用定义在命名空间"A\my"中函数 "foo"



F();        // 首先尝试调用定义在命名空间"A"中的函数 "F"             

            // 再尝试调用全局函数 "F"



// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象            

            // 如果未找到，则尝试自动装载类 "A\B"



new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象            

            // 如果未找到，则尝试自动装载类 "B\D"



new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象            

            // 如果未找到，则尝试自动装载类 "C\E"



new \B();   // 创建定义在全局空间中的类 "B" 的一个对象            

            // 如果未发现，则尝试自动装载类 "B"



new \D();   // 创建定义在全局空间中的类 "D" 的一个对象            

            // 如果未发现，则尝试自动装载类 "D"



new \F();   // 创建定义在全局空间中的类 "F" 的一个对象            

            // 如果未发现，则尝试自动装载类 "F"



// 调用另一个命名空间中的静态方法或命名空间函数



B\foo();    // 调用命名空间 "A\B" 中函数 "foo"



B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法            

            // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"



D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法            

            // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"



\B\foo();   // 调用命名空间 "B" 中的函数 "foo" 



\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法            

            // 如果类 "B" 未找到，则尝试自动装载类 "B"



// 当前命名空间中的静态方法或函数



A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法              

              // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"



\A\B::foo();  // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法              

              // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"

?>

fastcgi_connect_timeout ：  后端链接时间

fastcgi_send_timeout  ：  数据发送时间，两次成功发送时间差，不是整个发送时间

fastcgi_read_timeout  ：  数据接收时间，两次成功接收时间差，不是整个接收时间

fastcgi_buffer_size 存放fastcgi传过来的响应头，一般设置为分页大小

fastcgi_buffers 存放fastcgi传过来的相应内容，一般设置分页的倍数，格式例如 8  4k|8k

pm = static | dynamic | ondemand ：静态池、服务优先、内存优先

pm.max_children = 256  ： 开启的最大php进程数

pm.max_requests = 1024  ： 在执行了1024个请求后重启worker进程

php.ini中默认30s：max_execution_time =

php-fpm中：request_terminate_timeout =

fastcgi_connect_timeout

fastcgi_send_timeout

fastcgi_read_timeout

$num1 = array(3, 5, 4, 3);

$num2 = array(27, 50, 44, 78);

array_multisort($num1, SORT_ASC, $num2, SORT_DESC);



print_r($num1);

print_r($num2);

//result: Array ( [0] => 3 [1] => 3 [2] => 4 [3] => 5 ) Array ( [0] => 78 [1] => 27 [2] => 44 [3] => 50 )

$arr = array(

    '0' => array(

        'num1' => 3,

        'num2' => 27 

    ),

    

    '1' => array(

        'num1' => 5,

        'num2' => 50

    ),

    

    '2' => array(

        'num1' => 4,

        'num2' => 44

    ),

    

    '3' => array(

        'num1' => 3,

        'num2' => 78

    ) 

);



foreach ( $arr as $key => $row ){

    $num1[$key] = $row ['num1'];

    $num2[$key] = $row ['num2'];

}



array_multisort($num1, SORT_ASC, $num2, SORT_DESC, $arr);



print_r($arr);

//result:Array([0]=>Array([num1]=>3 [num2]=>78) [1]=>Array([num1]=>3 [num2]=>27) [2]=>Array([num1]=>4 [num2]=>44) [3]=>Array([num1]=>5 [num2]=>50))

• 能够保证严格的消息顺序
• 提供丰富的消息拉取模式
• 高效的订阅者水平扩展能力
• 实时的消息订阅机制
• 亿级消息堆积能力
• Metaq3.0 版本改名，产品名称改为RocketMQ

• 消息的顺序问题
• 消息的重复问题