Features:

15 inventive and puzzling levels
Unique drawing control in a truly dynamic physics environment 3 beautiful worlds inspired by childrens drawings
Death traps, monsters, and challenging puzzles Unlockable challenges, secrets and rewards
Original and awesome soundtrack by Analogik

Release Name: Max.and.the.Magic.Marker.RIP-Unleashed
Size: 72.6 MB

Download:
 
http://hotfile.com/dl/27346440/9595a86/MaMMarker-Unleashed.zip.html
or
http://ugotfile.com/file/817972/MaMMarker-Unleashed.zip
or
http://rapidshare.com/files/346517951/MaMMarker-Unleashed.zip

下载：Joe Celko's.Trees and Hierarchies in SQL for Smarties.pdf

其它资源：http://www.itpub.net/thread-1233846-1-1.html

Introduction

Most users at one time or another have dealt with hierarchical data in a SQL database and no doubt learned that the management of hierarchical data is not what a relational database is intended for. The tables of a relational database are not hierarchical (like XML), but are simply a flat list. Hierarchical data has a parent-child relationship that is not naturally represented in a relational database table.

For our purposes, hierarchical data is a collection of data where each item has a single parent and zero or more children (with the exception of the root item, which has no parent). Hierarchical data can be found in a variety of database applications, including forum and mailing list threads, business organization charts, content management categories, and product categories. For our purposes we will use the following product category hierarchy from an fictional electronics store:

These categories form a hierarchy in much the same way as the other examples cited above. In this article we will examine two models for dealing with hierarchical data in MySQL, starting with the traditional adjacency list model.

The Adjacency List Model

Typically the example categories shown above will be stored in a table like the following (I'm including full Create and Insert statements so you can follow along):

Create TABLE category(
category_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(20) NOT NULL,
parent INT DEFAULT NULL);
Insert INTO category
VALUES(1,'ELECTRONICS',NULL),(2,'TELEVISIONS',1),(3,'TUBE',2),
(4,'LCD',2),(5,'PLASMA',2),(6,'PORTABLE ELECTRONICS',1),
(7,'MP3 PLAYERS',6),(8,'FLASH',7),
(9,'CD PLAYERS',6),(10,'2 WAY RADIOS',6);
Select * FROM category orDER BY category_id;
+-------------+----------------------+--------+
| category_id | name                 | parent |
+-------------+----------------------+--------+
|           1 | ELECTRONICS          |   NULL |
|           2 | TELEVISIONS          |      1 |
|           3 | TUBE                 |      2 |
|           4 | LCD                  |      2 |
|           5 | PLASMA               |      2 |
|           6 | PORTABLE ELECTRONICS |      1 |
|           7 | MP3 PLAYERS          |      6 |
|           8 | FLASH                |      7 |
|           9 | CD PLAYERS           |      6 |
|          10 | 2 WAY RADIOS         |      6 |
+-------------+----------------------+--------+
10 rows in set (0.00 sec)

In the adjacency list model, each item in the table contains a pointer to its parent. The topmost element, in this case electronics, has a NULL value for its parent. The adjacency list model has the advantage of being quite simple, it is easy to see that FLASH is a child of mp3 players, which is a child of portable electronics, which is a child of electronics. While the adjacency list model can be dealt with fairly easily in client-side code, working with the model can be more problematic in pure SQL.

Retrieving a Full Tree

The first common task when dealing with hierarchical data is the display of the entire tree, usually with some form of indentation. The most common way of doing this is in pure SQL is through the use of a self-join:

Select t1.name AS lev1, t2.name as lev2, t3.name as lev3, t4.name as lev4
FROM category AS t1
LEFT JOIN category AS t2 ON t2.parent = t1.category_id
LEFT JOIN category AS t3 ON t3.parent = t2.category_id
LEFT JOIN category AS t4 ON t4.parent = t3.category_id
Where t1.name = 'ELECTRONICS';
+-------------+----------------------+--------------+-------+
| lev1        | lev2                 | lev3         | lev4  |
+-------------+----------------------+--------------+-------+
| ELECTRONICS | TELEVISIONS          | TUBE         | NULL  |
| ELECTRONICS | TELEVISIONS          | LCD          | NULL  |
| ELECTRONICS | TELEVISIONS          | PLASMA       | NULL  |
| ELECTRONICS | PORTABLE ELECTRONICS | MP3 PLAYERS  | FLASH |
| ELECTRONICS | PORTABLE ELECTRONICS | CD PLAYERS   | NULL  |
| ELECTRONICS | PORTABLE ELECTRONICS | 2 WAY RADIOS | NULL  |
+-------------+----------------------+--------------+-------+
6 rows in set (0.00 sec)

Finding all the Leaf Nodes

We can find all the leaf nodes in our tree (those with no children) by using a LEFT JOIN query:

Select t1.name FROM
category AS t1 LEFT JOIN category as t2
ON t1.category_id = t2.parent
Where t2.category_id IS NULL;
+--------------+
| name         |
+--------------+
| TUBE         |
| LCD          |
| PLASMA       |
| FLASH        |
| CD PLAYERS   |
| 2 WAY RADIOS |
+--------------+

Retrieving a Single Path

The self-join also allows us to see the full path through our hierarchies:

Select t1.name AS lev1, t2.name as lev2, t3.name as lev3, t4.name as lev4
FROM category AS t1
LEFT JOIN category AS t2 ON t2.parent = t1.category_id
LEFT JOIN category AS t3 ON t3.parent = t2.category_id
LEFT JOIN category AS t4 ON t4.parent = t3.category_id
Where t1.name = 'ELECTRONICS' AND t4.name = 'FLASH';
+-------------+----------------------+-------------+-------+
| lev1        | lev2                 | lev3        | lev4  |
+-------------+----------------------+-------------+-------+
| ELECTRONICS | PORTABLE ELECTRONICS | MP3 PLAYERS | FLASH |
+-------------+----------------------+-------------+-------+
1 row in set (0.01 sec)

The main limitation of such an approach is that you need one self-join for every level in the hierarchy, and performance will naturally degrade with each level added as the joining grows in complexity.

Limitations of the Adjacency List Model

Working with the adjacency list model in pure SQL can be difficult at best. Before being able to see the full path of a category we have to know the level at which it resides. In addition, special care must be taken when deleting nodes because of the potential for orphaning an entire sub-tree in the process (delete the portable electronics category and all of its children are orphaned). Some of these limitations can be addressed through the use of client-side code or stored procedures. With a procedural language we can start at the bottom of the tree and iterate upwards to return the full tree or a single path. We can also use procedural programming to delete nodes without orphaning entire sub-trees by promoting one child element and re-ordering the remaining children to point to the new parent.

The Nested Set Model

What I would like to focus on in this article is a different approach, commonly referred to as the Nested Set Model. In the Nested Set Model, we can look at our hierarchy in a new way, not as nodes and lines, but as nested containers. Try picturing our electronics categories this way:

Notice how our hierarchy is still maintained, as parent categories envelop their children.We represent this form of hierarchy in a table through the use of left and right values to represent the nesting of our nodes:

Create TABLE nested_category (
category_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(20) NOT NULL,
lft INT NOT NULL,
rgt INT NOT NULL
);
Insert INTO nested_category
VALUES(1,'ELECTRONICS',1,20),(2,'TELEVISIONS',2,9),(3,'TUBE',3,4),
(4,'LCD',5,6),(5,'PLASMA',7,8),(6,'PORTABLE ELECTRONICS',10,19),
(7,'MP3 PLAYERS',11,14),(8,'FLASH',12,13),
(9,'CD PLAYERS',15,16),(10,'2 WAY RADIOS',17,18);
Select * FROM nested_category orDER BY category_id;
+-------------+----------------------+-----+-----+
| category_id | name                 | lft | rgt |
+-------------+----------------------+-----+-----+
|           1 | ELECTRONICS          |   1 |  20 |
|           2 | TELEVISIONS          |   2 |   9 |
|           3 | TUBE                 |   3 |   4 |
|           4 | LCD                  |   5 |   6 |
|           5 | PLASMA               |   7 |   8 |
|           6 | PORTABLE ELECTRONICS |  10 |  19 |
|           7 | MP3 PLAYERS          |  11 |  14 |
|           8 | FLASH                |  12 |  13 |
|           9 | CD PLAYERS           |  15 |  16 |
|          10 | 2 WAY RADIOS         |  17 |  18 |
+-------------+----------------------+-----+-----+

We use lft and rgt because left and right are reserved words in MySQL, see http://dev.mysql.com/doc/mysql/en/reserved-words.html for the full list of reserved words.

So how do we determine left and right values? We start numbering at the leftmost side of the outer node and continue to the right:

This design can be applied to a typical tree as well:

When working with a tree, we work from left to right, one layer at a time, descending to each node's children before assigning a right-hand number and moving on to the right. This approach is called the modified preorder tree traversal algorithm.

Retrieving a Full Tree

We can retrieve the full tree through the use of a self-join that links parents with nodes on the basis that a node's lft value will always appear between its parent's lft and rgt values:

Select node.name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
AND parent.name = 'ELECTRONICS'
orDER BY node.lft;
+----------------------+
| name                 |
+----------------------+
| ELECTRONICS          |
| TELEVISIONS          |
| TUBE                 |
| LCD                  |
| PLASMA               |
| PORTABLE ELECTRONICS |
| MP3 PLAYERS          |
| FLASH                |
| CD PLAYERS           |
| 2 WAY RADIOS         |
+----------------------+

Unlike our previous examples with the adjacency list model, this query will work regardless of the depth of the tree. We do not concern ourselves with the rgt value of the node in our BETWEEN clause because the rgt value will always fall within the same parent as the lft values.

Finding all the Leaf Nodes

Finding all leaf nodes in the nested set model even simpler than the LEFT JOIN method used in the adjacency list model. If you look at the nested_category table, you may notice that the lft and rgt values for leaf nodes are consecutive numbers. To find the leaf nodes, we look for nodes where rgt = lft + 1:

Select name
FROM nested_category
Where rgt = lft + 1;
+--------------+
| name         |
+--------------+
| TUBE         |
| LCD          |
| PLASMA       |
| FLASH        |
| CD PLAYERS   |
| 2 WAY RADIOS |
+--------------+

Retrieving a Single Path

With the nested set model, we can retrieve a single path without having multiple self-joins:

Select parent.name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
AND node.name = 'FLASH'
orDER BY parent.lft;
+----------------------+
| name                 |
+----------------------+
| ELECTRONICS          |
| PORTABLE ELECTRONICS |
| MP3 PLAYERS          |
| FLASH                |
+----------------------+

Finding the Depth of the Nodes

We have already looked at how to show the entire tree, but what if we want to also show the depth of each node in the tree, to better identify how each node fits in the hierarchy? This can be done by adding a COUNT function and a GROUP BY clause to our existing query for showing the entire tree:

Select node.name, (COUNT(parent.name) - 1) AS depth
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+----------------------+-------+
| name                 | depth |
+----------------------+-------+
| ELECTRONICS          |     0 |
| TELEVISIONS          |     1 |
| TUBE                 |     2 |
| LCD                  |     2 |
| PLASMA               |     2 |
| PORTABLE ELECTRONICS |     1 |
| MP3 PLAYERS          |     2 |
| FLASH                |     3 |
| CD PLAYERS           |     2 |
| 2 WAY RADIOS         |     2 |
+----------------------+-------+

We can use the depth value to indent our category names with the CONCAT and REPEAT string functions:

Select CONCAT( REPEAT(' ', COUNT(parent.name) - 1), node.name) AS name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+-----------------------+
| name                  |
+-----------------------+
| ELECTRONICS           |
|  TELEVISIONS          |
|   TUBE                |
|   LCD                 |
|   PLASMA              |
|  PORTABLE ELECTRONICS |
|   MP3 PLAYERS         |
|    FLASH              |
|   CD PLAYERS          |
|   2 WAY RADIOS        |
+-----------------------+

Of course, in a client-side application you will be more likely to use the depth value directly to display your hierarchy. Web developers could loop through the tree, adding <li></li> and <ul></ul> tags as the depth number increases and decreases.

Depth of a Sub-Tree

When we need depth information for a sub-tree, we cannot limit either the node or parent tables in our self-join because it will corrupt our results. Instead, we add a third self-join, along with a sub-query to determine the depth that will be the new starting point for our sub-tree:

Select node.name, (COUNT(parent.name) - (sub_tree.depth + 1)) AS depth
FROM nested_category AS node,
nested_category AS parent,
nested_category AS sub_parent,
(
Select node.name, (COUNT(parent.name) - 1) AS depth
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
AND node.name = 'PORTABLE ELECTRONICS'
GROUP BY node.name
orDER BY node.lft
)AS sub_tree
Where node.lft BETWEEN parent.lft AND parent.rgt
AND node.lft BETWEEN sub_parent.lft AND sub_parent.rgt
AND sub_parent.name = sub_tree.name
GROUP BY node.name
orDER BY node.lft;
+----------------------+-------+
| name                 | depth |
+----------------------+-------+
| PORTABLE ELECTRONICS |     0 |
| MP3 PLAYERS          |     1 |
| FLASH                |     2 |
| CD PLAYERS           |     1 |
| 2 WAY RADIOS         |     1 |
+----------------------+-------+

This function can be used with any node name, including the root node. The depth values are always relative to the named node.

Find the Immediate Subordinates of a Node

Imagine you are showing a category of electronics products on a retailer web site. When a user clicks on a category, you would want to show the products of that category, as well as list its immediate sub-categories, but not the entire tree of categories beneath it. For this, we need to show the node and its immediate sub-nodes, but no further down the tree. For example, when showing the PORTABLE ELECTRONICS category, we will want to show MP3 PLAYERS, CD PLAYERS, and 2 WAY RADIOS, but not FLASH.

This can be easily accomplished by adding a HAVING clause to our previous query:

Select node.name, (COUNT(parent.name) - (sub_tree.depth + 1)) AS depth
FROM nested_category AS node,
nested_category AS parent,
nested_category AS sub_parent,
(
Select node.name, (COUNT(parent.name) - 1) AS depth
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
AND node.name = 'PORTABLE ELECTRONICS'
GROUP BY node.name
orDER BY node.lft
)AS sub_tree
Where node.lft BETWEEN parent.lft AND parent.rgt
AND node.lft BETWEEN sub_parent.lft AND sub_parent.rgt
AND sub_parent.name = sub_tree.name
GROUP BY node.name
HAVING depth <= 1
orDER BY node.lft;
+----------------------+-------+
| name                 | depth |
+----------------------+-------+
| PORTABLE ELECTRONICS |     0 |
| MP3 PLAYERS          |     1 |
| CD PLAYERS           |     1 |
| 2 WAY RADIOS         |     1 |
+----------------------+-------+

If you do not wish to show the parent node, change the HAVING depth <= 1 line to HAVING depth = 1.

Aggregate Functions in a Nested Set

Let's add a table of products that we can use to demonstrate aggregate functions with:

Create TABLE product(
product_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(40),
category_id INT NOT NULL
);
Insert INTO product(name, category_id) VALUES('20" TV',3),('36" TV',3),
('Super-LCD 42"',4),('Ultra-Plasma 62"',5),('Value Plasma 38"',5),
('Power-MP3 5gb',7),('Super-Player 1gb',8),('Porta CD',9),('CD To go!',9),
('Family Talk 360',10);
Select * FROM product;
+------------+-------------------+-------------+
| product_id | name              | category_id |
+------------+-------------------+-------------+
|          1 | 20" TV            |           3 |
|          2 | 36" TV            |           3 |
|          3 | Super-LCD 42"     |           4 |
|          4 | Ultra-Plasma 62"  |           5 |
|          5 | Value Plasma 38"  |           5 |
|          6 | Power-MP3 128mb   |           7 |
|          7 | Super-Shuffle 1gb |           8 |
|          8 | Porta CD          |           9 |
|          9 | CD To go!         |           9 |
|         10 | Family Talk 360   |          10 |
+------------+-------------------+-------------+

Now let's produce a query that can retrieve our category tree, along with a product count for each category:

Select parent.name, COUNT(product.name)
FROM nested_category AS node ,
nested_category AS parent,
product
Where node.lft BETWEEN parent.lft AND parent.rgt
AND node.category_id = product.category_id
GROUP BY parent.name
orDER BY node.lft;
+----------------------+---------------------+
| name                 | COUNT(product.name) |
+----------------------+---------------------+
| ELECTRONICS          |                  10 |
| TELEVISIONS          |                   5 |
| TUBE                 |                   2 |
| LCD                  |                   1 |
| PLASMA               |                   2 |
| PORTABLE ELECTRONICS |                   5 |
| MP3 PLAYERS          |                   2 |
| FLASH                |                   1 |
| CD PLAYERS           |                   2 |
| 2 WAY RADIOS         |                   1 |
+----------------------+---------------------+

This is our typical whole tree query with a COUNT and GROUP BY added, along with a reference to the product table and a join between the node and product table in the Where clause. As you can see, there is a count for each category and the count of subcategories is reflected in the parent categories.

Adding New Nodes

Now that we have learned how to query our tree, we should take a look at how to update our tree by adding a new node. Let's look at our nested set diagram again:

If we wanted to add a new node between the TELEVISIONS and PORTABLE ELECTRONICS nodes, the new node would have lft and rgt values of 10 and 11, and all nodes to its right would have their lft and rgt values increased by two. We would then add the new node with the appropriate lft and rgt values. While this can be done with a stored procedure in MySQL 5, I will assume for the moment that most readers are using 4.1, as it is the latest stable version, and I will isolate my queries with a LOCK TABLES statement instead:

LOCK TABLE nested_category WRITE;
Select @myRight := rgt FROM nested_category
Where name = 'TELEVISIONS';
Update nested_category SET rgt = rgt + 2 Where rgt > @myRight;
Update nested_category SET lft = lft + 2 Where lft > @myRight;
Insert INTO nested_category(name, lft, rgt) VALUES('GAME CONSOLES', @myRight + 1, @myRight + 2);
UNLOCK TABLES;
We can then check our nesting with our indented tree query:
Select CONCAT( REPEAT( ' ', (COUNT(parent.name) - 1) ), node.name) AS name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+-----------------------+
| name                  |
+-----------------------+
| ELECTRONICS           |
|  TELEVISIONS          |
|   TUBE                |
|   LCD                 |
|   PLASMA              |
|  GAME CONSOLES        |
|  PORTABLE ELECTRONICS |
|   MP3 PLAYERS         |
|    FLASH              |
|   CD PLAYERS          |
|   2 WAY RADIOS        |
+-----------------------+

If we instead want to add a node as a child of a node that has no existing children, we need to modify our procedure slightly. Let's add a new FRS node below the 2 WAY RADIOS node:

LOCK TABLE nested_category WRITE;
Select @myLeft := lft FROM nested_category
Where name = '2 WAY RADIOS';
Update nested_category SET rgt = rgt + 2 Where rgt > @myLeft;
Update nested_category SET lft = lft + 2 Where lft > @myLeft;
Insert INTO nested_category(name, lft, rgt) VALUES('FRS', @myLeft + 1, @myLeft + 2);
UNLOCK TABLES;

In this example we expand everything to the right of the left-hand number of our proud new parent node, then place the node to the right of the left-hand value. As you can see, our new node is now properly nested:

Select CONCAT( REPEAT( ' ', (COUNT(parent.name) - 1) ), node.name) AS name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+-----------------------+
| name                  |
+-----------------------+
| ELECTRONICS           |
|  TELEVISIONS          |
|   TUBE                |
|   LCD                 |
|   PLASMA              |
|  GAME CONSOLES        |
|  PORTABLE ELECTRONICS |
|   MP3 PLAYERS         |
|    FLASH              |
|   CD PLAYERS          |
|   2 WAY RADIOS        |
|    FRS                |
+-----------------------+

Deleting Nodes

The last basic task involved in working with nested sets is the removal of nodes. The course of action you take when deleting a node depends on the node's position in the hierarchy; deleting leaf nodes is easier than deleting nodes with children because we have to handle the orphaned nodes.

When deleting a leaf node, the process if just the opposite of adding a new node, we delete the node and its width from every node to its right:

LOCK TABLE nested_category WRITE;
Select @myLeft := lft, @myRight := rgt, @myWidth := rgt - lft + 1
FROM nested_category
Where name = 'GAME CONSOLES';
Delete FROM nested_category Where lft BETWEEN @myLeft AND @myRight;
Update nested_category SET rgt = rgt - @myWidth Where rgt > @myRight;
Update nested_category SET lft = lft - @myWidth Where lft > @myRight;
UNLOCK TABLES;

And once again, we execute our indented tree query to confirm that our node has been deleted without corrupting the hierarchy:

Select CONCAT( REPEAT( ' ', (COUNT(parent.name) - 1) ), node.name) AS name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+-----------------------+
| name                  |
+-----------------------+
| ELECTRONICS           |
|  TELEVISIONS          |
|   TUBE                |
|   LCD                 |
|   PLASMA              |
|  PORTABLE ELECTRONICS |
|   MP3 PLAYERS         |
|    FLASH              |
|   CD PLAYERS          |
|   2 WAY RADIOS        |
|    FRS                |
+-----------------------+

This approach works equally well to delete a node and all its children:

LOCK TABLE nested_category WRITE;
Select @myLeft := lft, @myRight := rgt, @myWidth := rgt - lft + 1
FROM nested_category
Where name = 'MP3 PLAYERS';
Delete FROM nested_category Where lft BETWEEN @myLeft AND @myRight;
Update nested_category SET rgt = rgt - @myWidth Where rgt > @myRight;
Update nested_category SET lft = lft - @myWidth Where lft > @myRight;
UNLOCK TABLES;

And once again, we query to see that we have successfully deleted an entire sub-tree:

Select CONCAT( REPEAT( ' ', (COUNT(parent.name) - 1) ), node.name) AS name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+-----------------------+
| name                  |
+-----------------------+
| ELECTRONICS           |
|  TELEVISIONS          |
|   TUBE                |
|   LCD                 |
|   PLASMA              |
|  PORTABLE ELECTRONICS |
|   CD PLAYERS          |
|   2 WAY RADIOS        |
|    FRS                |
+-----------------------+

The other scenario we have to deal with is the deletion of a parent node but not the children. In some cases you may wish to just change the name to a placeholder until a replacement is presented, such as when a supervisor is fired. In other cases, the child nodes should all be moved up to the level of the deleted parent:

LOCK TABLE nested_category WRITE;
Select @myLeft := lft, @myRight := rgt, @myWidth := rgt - lft + 1
FROM nested_category
Where name = 'PORTABLE ELECTRONICS';
Delete FROM nested_category Where lft = @myLeft;
Update nested_category SET rgt = rgt - 1, lft = lft - 1 Where lft BETWEEN @myLeft AND @myRight;
Update nested_category SET rgt = rgt - 2 Where rgt > @myRight;
Update nested_category SET lft = lft - 2 Where lft > @myRight;
UNLOCK TABLES;

In this case we subtract two from all elements to the right of the node (since without children it would have a width of two), and one from the nodes that are its children (to close the gap created by the loss of the parent's left value). Once again, we can confirm our elements have been promoted:

Select CONCAT( REPEAT( ' ', (COUNT(parent.name) - 1) ), node.name) AS name
FROM nested_category AS node,
nested_category AS parent
Where node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
orDER BY node.lft;
+---------------+
| name          |
+---------------+
| ELECTRONICS   |
|  TELEVISIONS  |
|   TUBE        |
|   LCD         |
|   PLASMA      |
|  CD PLAYERS   |
|  2 WAY RADIOS |
|   FRS         |
+---------------+

Other scenarios when deleting nodes would include promoting one of the children to the parent position and moving the child nodes under a sibling of the parent node, but for the sake of space these scenarios will not be covered in this article.

Final Thoughts

While I hope the information within this article will be of use to you, the concept of nested sets in SQL has been around for over a decade, and there is a lot of additional information available in books and on the Internet. In my opinion the most comprehensive source of information on managing hierarchical information is a book called Joe Celko's Trees and Hierarchies in SQL for Smarties, written by a very respected author in the field of advanced SQL, Joe Celko. Joe Celko is often credited with the nested sets model and is by far the most prolific author on the subject. I have found Celko's book to be an invaluable resource in my own studies and highly recommend it. The book covers advanced topics which I have not covered in this article, and provides additional methods for managing hierarchical data in addition to the Adjacency List and Nested Set models.

In the References / Resources section that follows I have listed some web resources that may be of use in your research of managing hierarchal data, including a pair of PHP related resources that include pre-built PHP libraries for handling nested sets in MySQL. Those of you who currently use the adjacency list model and would like to experiment with the nested set model will find sample code for converting between the two in the Storing Hierarchical Data in a Database resource listed below.

1. 为优化MSSQL加了N多垃圾代码，提高百万数据量时的速度。
2. 添加CreateIndex()方法，可以在DEBUG模式下帮助数据库新手创建简单索引。
3. 添加GetRows()方法。
4. 临时删除Oracle相关代码。
5. 生成分页列表时不再采用字符串串联，改用数组。
6. 其他小修改。

建一个ASP函数:
http://jorkin.reallydo.com/article.asp?id=653

ASP代码:
<%
sNewOrder = NewID("id") '这里的ID是数据类型为数字(最好用自动编号列)
Set ors = Exec("Select Top 20 id,compname,fund,foundyear," & sNewOrder & " AS NewID From company where fund>100 order By " & sNewOrder)
Trace(oRs)
%>

说明：这个方法如果在记录集过大的时候也会很费时间，所以请先通过Where条件筛选后再随机排序。

实例下载

jqGrid

HOME | DEMO | Last Update: May 2009

• paging functions
• sortable column headers
• add, edit, delete & search records
• accepts XML, JSON, array or user data as input
• multiple selection of rows
• sub grid & grid details
• support UI themes
• UI Datepicker integration
• API
• big size

Flexigrid

HOME | Last Update: July 2008

• paging functions
• sortable column headers
• add, edit, delete & search records
• accepts XML, JSON, array or user data as input
• nice design
• API
• don't support last jQuery version

Ingrid

HOME | Last Update: November 2007

• paging functions
• sortable column headers
• nice design
• project is die

jTPS

HOME | DEMO | Last Update: August 2008

• paging functions
• sortable column headers
• animate sorting and page navigation
• don't support AJAX

FireScope Grid

HOME | Last Update: February 2009

• paging functions
• sortable column headers
• search records
• support only HTML data source

tgrid

HOME | DEMO | Last Update: May 2009

• paging functions
• sortable column headers
• update & search records
• young
• young
• young

Datacontrol

HOME | Last Update: February 2009

• paging functions
• sortable column headers
• add, edit, delete & search records
• support only XML data source (but with XLS)
• don't allow source

DataTables

HOME | DEMO | Last Update: February 2009

• paging functions
• sortable column headers
• add, edit, delete & search records
• accepts only JSON as input
• API
• fast data search

Snowcore Datagrid

HOME | DEMO | Last Update: December 2008

• add, edit & delete records
• young

JGridEditor

Plugin aviable only on jQuery homepage.

Sigma Grid

HomePage | Demo | Download

http://matthiasschuetz.com/javascript-framework-matrix/en/

目前支持的库:

• jQuery
• MooTools
• The Dojo Toolkit
• Prototype
• Script.aculo.us
• Ext.JS
• Adobe Spry
• BBC Glow
• Yahoo UI! Library

2
高中的时候住校，有同学回家让他帮我捎点东西，便发短信：给我烧点衣服和钱。

3
昨晚煮螃蟹，水开后，我把螃蟹一个个扔进锅里。蟹子很新鲜，在锅里乱动。
老婆打小心善，就见不得这个，遂躲在我身后捂着眼睛不敢看。
我宽慰道：佳佳，我们是不是太残忍了？
老婆：嗯…………放盐了吗？

4
我们那个教化学的老头近视800度，一次上课在黑板上板书后转过身来突然指着我大喊：你站着干什么！！给我坐下！！
我当时正坐在最后一排的座位上，而我身后的墙上挂着我的大衣……

5
上大学时急救课上，心肺复苏急救，教授边说边演示：
教授：双手按压胸部，不能使劲儿太大，压下2~3cm即可，劲儿太大容易把病人肋骨压断！
教授：下面请看示范（双手使劲儿一压），咔嚓一声！模型的肋骨断了。
尴尬的说，下课~

6
大学去深圳写生，
跟同学在马路上逛，突然一男同学往马路一边走去，
拍了一个人肩膀问：“大哥，，请问”，
是不是他脑子被门挤了，竟然问的是银行的押钞员！！
押钞员可能也没听清。
回过头来，
神经紧张的拿着枪（大喷）指着他：“你要干嘛！要干嘛！”，
我同学一看枪口对着自己，
吓的带着哭腔说：“大哥，没别的意思，我就问问几点了”。。。。。
爆瀑汗。。。。。。。

7
我在小学毕业时买了一本万恶的毕业册，因为上面说1月20日－2月18日的星座是 ----
水缸座
后来在很长一段时间内别人问我你是什么星座，我都说是水缸座！

8
跟以前同事一起下班，在公司对面马路往车站走，对面走来一个男人，盯着我看了一会，我刚想问他认识我吗。那人看了我一眼，接着吐了！那个囧啊！~~
那人是个醉汉！
我很无语，，同事笑喷了，从此此事流传千古开来。。。
同事逢人就说，***那个丑啊，那人看了她一眼就吐了。。。

9
我朋友有次喝醉了,据他妈说,他在厕所,右手拿电话状,左手按着镜子,和镜子中的"入狱者"深情对视道:吃得好不好啊?最近监狱管得严吗?争取早日出来啊...

10
有一次，因为有事要联系一个同学，但是手机里没存他的号码，于是给另外一个和他很熟的同学发短信，“请问有 XXX 的电话号码吗？”
然后耐心等候回复，5分钟后，终于收到回复了，迫不及待打开短信，赫然写着，“有啊”两个大字。
无奈之下，只能又再发短信给这位大哥，“那么，请告诉我好吗？”又继续等了五分钟，收到了回复，再次迫不及待地打开来看，赫然写着另外两个字，“好啊”！

11
我刚上大学的那会儿，特土，又一次课上老师让做ppt展示，以前从来没用过，正好那次我第一个上去讲，开了电脑半天投影仪没反应。
下面几个哥们喊按F2，按F2！
于是我犹豫了一下，问道：是俩键同时按吗？

12
一个小女孩跑到柜台前,对我说:’阿姨,给我一包蕃茄酱.’
我是男生,起码身份证上是这样写的.
于是我笑了笑,一边递给她一边对她说:’没问题,小弟弟.’
小女孩楞了一下:’我不是小弟弟啊!’
我:’那我是阿姨吗?’
小女孩接过蕃茄酱匆匆跑开了!

13
研究生毕业的时候，班上一个女生两个男生帮她从七楼将五大箱东西搬到一楼，累的那两个男生差点断气，看楼的阿姨看不
过去，说了一句让我感慨至今的话“自己的男朋友不舍得用，别人的男朋友用得倒起劲”。

14
某天出门时给好友打了一个电话，让她和我一起出来，然后我上公交车，顺便拨个电话给她：“小M你到了吗？现在出门了吗？”然后好友小M曰：“我正做公交车呢！”
我说：“我坐的10X路公车，你坐哪个？”好友大喜：“我也是诶！”
我感觉不对劲，看到对面的人看神经病一样看着我，下意识往后一看，发现好友小M坐在我身后的座位上：“你到了吗？你到了吗？怎么不说话，喂.......”

15
有一次乘坐45路去钟楼，中途上了位中年妇女。车上当时人不多，可她就是靠着我和另一个MM站着，我下意识地将自己的包包放在了身前，可旁边的MM却浑然不觉地
看着窗外。不久，那位中年妇女一只手伸进了MM的包包，说时迟那时快，我突然放了一个响屁，又臭又响啊，惹得满车人看我，羞得我恨不得找个洞钻啊。不过，熏
得中年妇女赶紧缩回了手去捂鼻子!哈哈!”

16
大一时整个寝室的女生都很单纯，我们八个人都没见过安全套的实物长什么样。
某天晚上聊起来，就聚在电脑前搜图片，结果只搜到了包装盒和小包装没开封的那种图片，没有展开的那种，于是我们决定集体去路边那种投币机里买一个。
结果那些机器都是锈迹斑斑的，我们一堆人就围着那个箱子议论到底里面有没有东西、浪费一个硬币值不值之类，路人见了我们估计都很汗……
后来终于买到一个，其中一女生大惊：“这么小！”我们都鄙视之，说带回寝室拆了再说。
打开后，我们中大多数都觉得跟自己想象的差不多，但是那个女生还是说：“怎么这么小！那怎么把人罩起来？”我们都被雷翻了，原来她以为安全套是要把整个人罩起来的……
后来我们在超市看见一次性雨衣，都会对她说“你的TT”

17
俺们高中学校的德育主任，说话非常之强悍。
经典段落：现在我们学校有很不文明的现象，很多同学光着膀子打篮球，而且大部分是男生！
难道还有一小部分光着膀子的女生么？

18
高中一个同学近千度近视,没眼镜做不了人...
一次打球把眼镜给砸了还继续打,继续头三分...
结果还进了个空心...
全场都静了...
然后我(我和他不同队)捡起球扔给他开球...
然后他把球扔回给我,说:不是出界吗,你们开球...

19
视频：【电视剧】狙击手 第23集
评论：
酷6网友 IP:58.57.7.* 2009-08-16 22:08 发表
看了很多抗日题材的片子,怎么汉奸都是中国人.

20
一起练车的一个阿姨~~有天她老公骑摩托车载她回家~~在路上，有个男的想要拦住他们，对他们说~~我的车被前面的人偷走了，借你的车给我去追他~阿姨老公没理
他，继续开~那个阿姨坐在后面说了句~~~~我把我的车借给你了，我等下拿什么车去追你- -.....

21
一次和朋友喝酒，从下午喝到晚上，白的喝不动就全换成红酒了，最后我一手举着杯中酒一手拍着他的肩膀，刚要说掏心窝的话，他把嘴里以及为吸收的红酒全吐身
上了，他愣了一秒，抱头大哭，那就一个惨心裂肺，我无奈的说：“不就吐了我一身吗，没事，咱谁跟谁，别哭”，他抬起头对我说：“X，我吐的是血，一定是得了
绝症了……”，我当时就无语了……

22
小A公司近日发工资，小A高高兴兴的跑去了财务室去领工资，然后……
会计说：“你晚点来领工资吧，我这没零钱。”

23
我一高中同学（MM）上大学后被学校派去宣传艾滋病日
顺便去跟着社团的人参加一个预防艾滋病的讲座
那天他们搬了凳子围教室坐一圈等老师来做演讲
这时候进来个人给每人轮流发了一根香蕉
我同学那个叫开心啊 嘿~听讲座还能吃水果 8错8错··
她和旁边的人一边有说有笑的讲话 一边剥了香蕉皮吃的开心
这时候老师走进来 每人发了一个TT
原来那个香蕉是用来套TT用的 可是我同学手里只剩下一个香蕉皮。。

24
高一的时候,也快高考了,我们学校的高三肯定紧张的.周一升旗,有个高二女同学上屏幕演说:...各位学姐学长要认真面对高考,发挥自己最好的水平,不要再重复中考的失误...

25
化学老师 做稀盐酸和锌的实验 他把试管什么的准备好了 倒了点盐酸下去
等了半天没有反应 很纳闷 遂叫一同学回答 ：这位同学 你讲讲看为什么没有气泡产生呢？ 同学：老师，你没有放锌！ 老师：这位同学回答的很好！

26
中学的时候,开始流行文曲星,我同学有钱,就买了一个,98年的200块.
我想借他的玩会儿,玩到一个地方要求输密码,我就问他密码是多少.
他不说,他说不要看啦,个人资料.
于是,我就放弃了,但是我的好奇心一直没有消失过.
有一天,我看到他把文曲星拿出来玩,我无意中偷看到他在输密码,我看到他输了6个相同字符,心中窃喜,原来密码这么简单,于是找机会去翻来偷看.
于是,我一天趁他出去了,就把他的文曲星翻出来,赶紧输我看到那6个米字符******....

27
北京的公交车上，一男人带一四、五岁男孩。
等红绿灯时，公交车旁边有辆警车。
男人不知为什么那么恨pol.ice，跟男孩说：“儿子，你看，他们是pol.ice。pol.ice知道么，他们都是人民的儿子。我就是人民，pol.ice就是我儿子！”
1秒钟后，男孩大喊：“那我是pol.ice他姥爷！”
我们坐旁边的都没忍住，笑出声了。

28
我买了个乘车卡套
上面有个图案貌似是鸡
但我们又不确定是小鸡
他们就嘲笑我说我没有品位 买了个这么丑的东西
我很不服气 大声说 怎么了 鸡怎么了 鸡也是有尊严的（当时我正热衷于说xx也是有尊严的）
说完发现整个大厅的人都在看我...

29
一日。
死黨：“我这是小蛮腰。”
我不屑：“你丫那是猪腰。”
死黨不悦，反问：“那你是什么腰？”
答曰：“人腰。”

30
初中的时候，是两套独立的桌椅贴在一起放，和同桌（男）吵架了，然后我气呼呼的埋头把作业本写上名字，然后呼一下站起身来准备交作业，就看到我的
同桌坐在他的小凳子上，然后抱着他的小桌子。。整个朝外翻了下去。。。我惊呆了，不知道为什么，他缓缓挣扎着从自己的桌椅中爬起来，可怜巴巴地
说：我以为你要站起来打我T.T……

31
前几天终于和从初中暗恋的帅哥哥出去约会了
我那个打扮呀~由于穿了很大领子的衣服，于是贴了胸贴...
很甜蜜的吃完饭,就在商业街散步.
突然,帅哥哥停下问我,你衣服下粘的是什么呀?
我茫茫然低头一看,OMG!胸贴居然滑掉了!并且粘在了衣服的下摆~
我很镇静地把它取下,扔进了垃圾桶:"不知道是什么~估计是在哪儿粘的吧."
于是我们俩继续散步
而我的手,抱在胸前就再没有放下来... ...

32
在寝室聊八卦，一同学一边和我们聊天，一边用手剥手机充值卡的密码，越聊越起劲，等她回过神来，充值卡的密码那一条已经被她剥穿了，后来她用巧夺天工的手艺把废纸屑里密码刮了出来，还充值了。

33
有一次上体育课，老师一上来就板着脸严肃地宣布：今天，我要批评两位同学，是一男一女。站我后面的一男生嘀咕：狗男女！一对狗男女！老师大声说，我
说得就是你，你和XX（另一个女的）~~全班哄堂大笑~~

34
前几天手机上网看到一个新闻:歌手含笑吸毒被捕...
我就纳闷了...
吸毒就吸毒呗,为什么要含笑吸毒呢?
为什么新闻又要特别指出吸毒者含笑吸毒呢?
后来才知道,原来含笑是个歌手...

35
数年前，在公司做文秘，内急，慌忙冲向厕所，发现女厕所门虚掩着，因厕所为单坑，不敢贸然进入，遂敲门试探，只闻一女声从容答道：请进~~！！

36
我掏口袋的 时候，一把钥匙掉了，当时没有发现，后来回去找！
在路边有对小情侣在那里，男的 突然激动的说：是 谁的？到底是 谁的？
我当时以为是钥匙连忙说：我 的，我的！是我的
后来才知道，原来那女的怀孕了。。。。
可怜我的脸啊 。。。疼�几天

37
小时候年幼无知，只看过我妈穿胸罩，便以为胸罩是我妈专属的东西。于是有一段时间，我每天抱着撑衣竿子去院子里把所有的胸罩都收回家。邻居女人们日日来我家索要胸罩，我每天执着的守护着家门口，朝她们大喊，全是我妈的!~

38
我是一个搓澡的，我今天不小心把一个B社会老大的纹身搓没了

39
上学的时候学校是平房，九月份开学，来了好多新生。一天一个新生好像是课代表捧着一堆作业，问我：“数学办公室在哪？”
“男厕边上。”数学办公室确实在男厕边上，不过是左边。
那位老兄走到了男厕右边对着们喊“报告”
停顿了一下，里面传出 个声音“不许进”！
......

40
上小学的时候，晚上睡觉做梦，梦见和爸爸吵架，很气很气，居然气醒了。醒了之后看见旁边的爸爸，还是很火，上去啪啪两个嘴巴= =

41
一次数学晨练，全班都没做完。数学老师面露疑惑的说：我昨天晚上用广告时间就做完了，你们的速度也太慢了。有一同学当场不服，大叫道：老师看的是湖南台的广告
吧！全班笑倒。

42
新闻：佟大为妻子生下一女
评论：这个佟大真了不起

43
有一次去朋友家取东西 走到楼下 3人准备上楼 见楼下几个小孩在玩葵花点穴手
朋友多事 上去 说:看我的葵花点穴手 点到其中一个小孩
我们便上楼了 我们最少在楼上磨蹭了半个小时 下楼时 只见那个小孩仍在原地
一动不动 朋友上去 来了个葵花解穴手 小孩 便又活蹦乱跳
我狂汗.........................

44
早晨刚起床，在阳台上看到对面楼一女的只穿着文胸在做早饭。就喊老公过来看，老公铁青着脸，无语的把****的我拎回了屋里。

Salesforce的三驾马车

先说多租户模型，这可以说是SaaS最标准的理念核心。由于在SaaS模式下，厂商提供的是各种各样的资源，包括计算、存储、业务应用等不同资源，这对整个架构设计提出了要求。其中关键的问题在于要让每一个用户都不受任何干扰地使用自己的应用，因此，Salesforce需要在全球各地建立数据中心。David说，这些数据中心被看作是一个密集的小计算群，或者称之为一个SaaS的实例（Instance）。全球各地的用户根据不同的位置访问Salesforce部署在全球的10个实例中，最适合自己的数据中心，从而加速他们访问各自需要的服务。 

而自由的付费模式，其实与传统的比喻——用电或者用水，有一些不同。David打了一个比方，这好像就一个自由的婚姻协议，男人和女人通过协议生活在一起，为期一般为一年。在这一年当中，如果你觉得有任何不满意的地方，都可以随时解除协议。而当你对过去一年的生活比较满意的时候，则可以考虑在下一年度继续签订协议。这种付费的模式与传统的企业应用最大的区别在于，你不用一次投入过多的资源在自己的企业IT建设上，而是逐年建立不同的预算（可度量的），从而动态地控制自己的IT和业务。 

当然，系统的弹性是整个Salesforce在技术上的要点。由于对用户的计算需求是未知的，因此一个固定计算量的实例是无法接受的。David曾经做过一个和美国政府相关的项目，这是一个由星巴克和奥巴马政府一同推动的项目，项目鼓励人们为社区提供服务，每当一个人为社区做5个小时的工作，他们将获得一杯免费的咖啡，整个过程在一个注册为pledge5.com的站点上进行。这个系统最初的设计希望在30天内有一百万次点击——这并非一个大项目。然而仅仅过去一周时间，整个系统的访问量就突破了一千万，如果按照传统的设计，网站也许很早以前就崩溃了，而在具备很大系统弹性的SaaS模式下，随时可以通过对实例增加计算资源来满足计算需求（增加Linux服务器的数量），因此整个项目的运行非常良好。 

为什么SaaS能省钱？

从某种意义上说，SaaS模式对传统的软件使用授权模式进行了很大调整。David在解释SaaS的商业模式与传统模式区别时提到，在传统状况下，人们使用软件所花费的成本可以拆分成很多部分。一个软件最上层的价值是其知识产权，因此用户必须为这部分开发商自己的投入付费；接下来则是各种各样的软件运行库程序；再接下来则是支撑整个软件的运行环境，这其中还包括大量的基础设施，同时也包括开发商使用的开发工具等。因此，看起来简单的客户端软件许可证，其中包含了大量组成要素。这些要素的成本都由软件用户来承担，而且多数时候，除知识产权部分的费用外，用户的每一款软件都在重复投资。SaaS模式之所以能存在，就是将知识产权之下的费用一次性付清了，从而让用户只需支付知识产权的费用，这样成本自然更低。 

三驾马车加上对业务模型的精密分析，让Salesforce找到了自己的发展道路。事实上，SaaS满足用户的另外一个需求是强大的定制化能力。不过Salesforce最初仅仅只能提供CRM应用，而涉及到更多与业务相关的应用时，根本无法满足。其实CRM作为企业应用，其中已经包含了很多企业级技术的要素，这些要素完全可以抽象出来作为平台，并略加补充，形成更加强大的平台，以支撑更多可定制化的应用。到2005年，Salesforce开始提出另外一个基于SaaS的概念，那就是PaaS，同时发布了其心的force.com站点。 

从SaaS到PaaS 

SaaS虽然在定制化上有一定的能力，但主要还是基于Salesforce本身的CRM应用，一旦涉及到更多不同的应用类型，就需要Salesforce一个一个去进行独立的开发。这一点是Salesforce不愿意看到的，因为事实上David本人的经历就发现这样不行。 

2001年，David是Salesforce的合作伙伴，那个时候SaaS本身的概念还没有被广泛认同，大家围绕起来讨论的核心问题在于，如何将简单的事情变得更容易，让那些很复杂的事情在SaaS上变得可能。尤其是对那些软件用户，希望他们通过SaaS来实用软件更多是点击，而并非编程。这样，Salesforce最早实现了80%通过点击，20%编码来完善和定制化用户的应用程序。 

到2002年，David摇身一变，成了Salesforce的客户。他们希望在这套CRM上实现销售的自动化，并同时需要SaaS里每一个服务的客制化。这不是一件很容易的事情，整个软件的体系结构都需要进行大规模的调整。因此，Salesforce这套系统也经历了演变，从最早的一大块写在一起的系统，开始逐步抽象，将其中的很多部分独立成平台，作为公共资源供不同的应用访问。 

这个时期经历了很长时间，平台终于建立起来了。那是2005年，也就是David加入Salesforce的那一年，整个Salesforce的软件体系结构发生了巨大变化。force.com上线带来了更多不同的应用。David本人所负责的AppExchange也在随后的一两年时间里，开始赢得更多的用户，帮助他们将已部署在Salesforce上的应用整合起来。PaaS的理念，在这段时期开始变得成熟起来。 

迈向云计算

由于通过互联网为企业级客户提供服务，因此PaaS在很多方面要比传统的互联网服务高得多。此时，Amazon建立的AWS（Amazon Web Services）开始被很多中小型的企业采用。而其提供的存储、计算等基本功能被认为是云计算最初的雏形。然而，如何在这个基础上更进一步地将计算资源抽象得更加贴近业务呢？基于这样的考虑，Force.com开始考虑如何将更多企业级应用搬到他们的运营平台上来。在企业级云计算领域，Salesforce拔得了头筹。 

借助此前几年时间的不懈经营，Salesforce的CRM业务得到了市场上很多客户的认同。David承认，如果没有此前的努力，用户根本无法认可这种在线的企业应用模式。他甚至认为，作为一家SaaS或者PaaS运营商，最开始的5年是最为艰难的，因为要赢得客户的认同和信任实在是太难了！这一点甚至可以看成是从SaaS和PaaS迈向云计算的一道门槛。 

与Amazon和Google提供的云计算不同的是，前两者提供的云计算主要是以计算资源和编程模型为主，这意味着企业客户仍然需要进行大量的开发工作，这一点仍然会包含整个企业应用的设计和开发，不同之处只在于是否需要运营硬件、操作系统、数据库等相关的软硬件基础设施。而force.com则提供了企业级的计算环境。由于此前Salesforce本身的CRM经历了企业级平台的开发，因此force.com云计算的主要工作是将原有的CRM计算环境中，与企业级运行环境相关的平台层逐步抽象出来。 

为此，David和他的团队在Java的基础上开发了一套新的语言：APEX，并基于Eclipse插件设计了开发工具。由于Java本身依赖于虚拟机的存在，因此在进行很多业务逻辑处理的时候，一旦要访问数据库或者其他资源，往往需要嵌入很多不同的组件，这样对于整个系统而言，其复杂度依然很高，APEX的核心目标就是则是希望在服务器端统一控制所有工作，这不仅仅让你不必担心在你的Java程序中出现大量SQL代码，同样还可以非常轻松地完成对其他平台资源上的统一调度，例如Amazon和Google的服务等。 

未来的市场在中国

云计算平台的建立，让除了CRM之外的更多企业应用运行在互联网上。而成熟的企业级计算平台，也同样可以让更多的开发商基于平台开发企业应用。这些开发商，甚至可以来自中国。 

尽管David对中国的了解比一般外国人要多得多，但是对于中国的企业级技术市场，David承认他所知还是很有限的。这一点上，通过Salesforce在中国的策略就可以看出来。“我们并不了解中国的市场，尽管20多年前，我就来过这里，并且看到这20年来中国在不断的变化，但我们更希望那些了解中国商业规则的人帮助我们一起开拓这里的市场。” 

目前Salesforce在中国仅仅通过分销商来协助销售其在线服务，真正参与到Salesforce平台进行应用开发和使用其提供服务的企业仍然很少。David在采访的最后也寄予了希望：“今天在中国已经有一个巨大的市场了，希望中国的开发者们也能参与到这个平台的应用开发上来。Salesforce也正在努力为开发者提供更好的环境，目前已经有完整的开发工具和文档免费提供给开发者了，如果有兴趣在这个平台上进行应用开发的程序员，可以以0成本的代价在我们的平台上开发应用，也为自己创造新的机会。”

注：本文已发表在《程序员》杂志2009年9月刊上。

世界上最神奇的数字是： 142857
看似平凡的数字，为什么说他最神奇呢？
我们把它从1乘到6看看
142857 X 1 = 142857
142857 X 2 = 285714
142857 X 3 = 428571
142857 X 4 = 571428
142857 X 5 = 714285
142857 X 6 = 857142
同样的数字，只是调换了位置，反复的出现。
那么把它乘与7是多少呢？
我们会惊人的发现是 999999
而
142 + 857 = 999
14 + 28 + 57 = 99
最后，我们用 142857 乘与 142857
答案是：20408122449 前五位+上后五位的得数是多少呢？
20408 + 122449 = 142857
关于其中神奇的解答
“142857”
它发现于埃及金字塔内， 它是一组神奇数字， 它证明一星期有7天， 它自我累加一次，就由它的6个数字，依顺序轮值一次， 到了第7天，它们就放假，由999999去代班， 数字越加越大，每超过一星期轮回，每个数字需要分身一次， 你不需要计算机，只要知道它的分身方法，就可以知道继续累加的答案， 它还有更神奇的地方等待你去发掘！ 也许，它就是宇宙的密码， 如果您发现了它的真正神奇秘密┅┅
请与大家分享！
142857×1＝142857（原数字）
142857×2＝285714（轮值）
142857×3＝428571（轮值）
142857×4＝571428（轮值）
142857×5＝714285（轮值）
142857×6＝857142（轮值）
142857×7＝999999（放假由9代班）
142857×8＝1142856（7分身，即分为头一个数字1与尾数6，数列内少了7）
142857×9＝1285713（4分身）
142857×10＝1428570（1分身）
142857×11＝1571427（8分身）
142857×12＝1714284（5分身）
142857×13＝1857141（2分身）
142857×14＝1999998（9也需要分身变大）
继续算下去……
以上各数的单数和都是“9”。有可能藏着一个大秘密。
以上面的金字塔神秘数字举例：1＋4＋2＋8＋5＋7＝27＝2＋7＝9；您瞧瞧，它们的单数和竟然都是“9”。依此类推，上面各个神秘数，它们的单数和 都是“9”；怪也不怪！(它的双数和27还是3的三次方)无数巧合中必有概率，无数吻合中必有规律。 何谓规律？大自然规定的纪律！科学就是总结事实，从中找出规律。
任意取一个数字，例如取48965，将这个数字的各个数字进行求和，结果为4+8+9+6+5=32，再将结果求和，得3+2=5。我将这种求和的方法称为求一个数字的众数和。
所有数字都有以下规律：
[1]众数和为9的数字与任意数相乘，其结果的众数和都为9。例如306的众数和为9，而306*22=6732，数字6732的众数和也为9（6+7+3+2=18，1+8=9）。
[2]众数和为1的数字与任意数相乘，其结果的众数与被乘数的众数和相等。例如13的众数和为4，325的众数和为1，而325*13=4225，数字4225的众数和也为4（4+2+2+5=13，1+3=4）。
[3]总结得出一个普遍的规律，如果A*B=C，则众数和为A的数字与众数和为B的数字相乘，其结果的众数和亦与C的众数和相等。例如3*4=12。取一个众数和为3的数字，如201，再取一个众数和为4的数字，如112，两数相乘，结果为201*112=22512，22512的众数和为3（2+2+5+1+2=12，1+2=3），可见3*4=12，数字12的众数和亦为3。
[4]另外，数字相加亦遵守此规律。例如3+4=7。求数字201和112的和，结果为313，求313的众数和，得数字7（3+1+3=7），刚好3与4相加的结果亦为7。
令人奇怪的是，中国古人早就知道此数学规律。我们看看“河图”与“洛书”数字图就知道了。以下是“洛书”数字图。
4 9 2
3 5 7
8 1 6 ( 洛书)
世人都知道，“洛书”数字图之所以出名，是因为它是世界上最早的幻方图，它的特点是任意一组数字进行相加，其结果都为15。其实用数字众数和的规律去分析此图，就会发现，任意一组数字的随机组合互相相乘，其结果的众数和都为9，例如第一排数字的一个随机组合数字为924，第二行的一个随机组合数字为159，两者相乘，其结果为146916，求其众数和，得1+4+6+9+1+6=27，2+7=9，可见，结果的众数和都为9。
这种巧合不能说明什么问题，让我们再看看“河图”数字图。
    7
    2
8 3 5 4 9
    1
    6 (河图)
“河图”的数字图没有“洛书”数字图出名，这是因为人们未能动发现其数学规律，但是用众数和的规律去分析它，就能发现它的奇妙之处。
“河图”数字图中，任意一组数字互相进行相乘，其结果的众数和都为6。例如27165*38495=1045716675，求结果的众数和，1+4+5+7+1+6+6+7+5=42，4+2=6，可见，结果的众数和为6。
由此可见，“河图”的数字图亦不可能是随意摆设，否则，其结果的众数和不可能都为6。从上述两个数字图可知，古人十分重视数字6与数字9。无独有偶，太极图的就由数字6与数字9组合而成。
太极图的左边部分为数字6，太极图的右边部分为数字9。
“太极图”﹑“河图”﹑“洛书”通过种种手段暗示数字6与数字9的重要性，其中“河图”与“洛书”更是在熟悉数字众数和规律的前提下编制而成。但是，据我们所知，数字众数和的规律刚刚被本人发现，同时也没有任何证据显示古人已经知道这数学规律。
还有一个很有趣的数学现象，凡是众数和为9的数字除以36，其余数必为9或18或27或0（36）。
一个物体从数字36（0）的位置出发，运行一圈（转过360度）就能回到原位。在运行过程中，物体的运动方向经过四次转变，每次都发生在数字9或18或27或是36（0）的位置上，可见，处于这四个数字上面的物体，其性质面临着改变。这即是说，众数和为9的数字往往代表着物质性质的完全改变。
巧合的是，《周易》之中最流行九九归一的说法，数字9亦被称为老阳，即是说，数字9代表了一个物质阳气的终结，新一轮的周期又要开始了。这种说法刚好和上述数字现象不谋而合，从上图可知，一个物体一旦经过数字9而处于数字10的位置，其众数和就变为1，刚好处于数字10的物体，其运动方向与处于数字8位置的物体的运动方向相反，一个是向上运动，一个是向下运动。
总之，古代中国人的智慧远比现代人想象中的聪明，《周易》看来是一本超出现代人智慧水平的书籍，“太极图”的创造人更是聪明绝顶。

http://www.mediafire.com/?9tjiicsbggd

最喜欢用的一个版本，不需要注册机，不需要破解补丁，可在Vista下使用。

以下就是可以死亡的十一种方法指导
1）帖子里发病毒（死无可救）
2）帖子里发广告（死无可救）
3）签名里发广告（死无可救）
4）辱骂我站管理人员（死无可救）
5）思过崖复制他人回复（死无可救）
6）刷屏灌水,字图灌水,囬貼不滿10個字.
7）乱开主题，一稿多投，分批发送
8）白痴回复，乱敲键盘，胡言乱语
9）留QQ，留电话，留联络
10）盗链
11）本站各版不许发布的内容

PS:因为叫《不完全自殺手冊》，
那么就是說我们还将根据情况继续增加本手册的条目，
所以请大家有空多来看看，温故知新对自己是有好处的，
但我觉得还有一个办法可以用不着这样，那就是你别在本站注册，
我想，只要你能做到这点，那么，这本《不完全自殺手冊》也没有必要存在了，
但是如果你注册了,就给我遵守这里的一点一滴.我是不在乎删除任何ID,整个管理团队也一样的态度.

二、该项目的许可说明。
由公司什么机构在什么时间决定干什么，由谁批核，由谁负责。做事之前先正名。

三、项目的实施规划
1、总纲
公司计划通过ERP加强哪几个方面的工作，加强这方面工作的目的是什么。比如说提高采购的交货及时性，提高生产效率等等。需要注意的是，这里必须明确老板的意图，弄错了可就……(我会为你默哀！)。
2、项目实施的范围
公司计划在哪些部门的哪些模块进行实施。如工程部门的BOM管理、生产物料部门的MRP等等，在这里需要详细列出(可以参考我在BBS中贴出的那份文件，再结合你们的具体工作)。
3、项目的费用计划
公司目前的软硬件情况如何，上ERP系统以后，哪些可以继续使用的，哪些需要改进的、哪些需要淘汰的。这里也需要考虑到打印机和纸张的问题：手写通过复写纸就可以了，通过电脑打印就需要多联纸和针式打印机，这也是一笔投资。
公司计划投资多少，其中硬件多少(硬件要达到什么样的要求：硬盘、内存、网路速度)、软件多少(服务器软件、WEB软件、客户端软件)、实施费用多少、调研费用计划多少(按10%计算)、服务费用多少(每年的服务费用另收，约软件费用的10%~15%)，另外有一个极容易忽视的费用：系统内部的维护费用。系统资料是需要备份的，每天备份一次和每周备份一次(最低要求) 是不同的，在这里需要考虑到这一点，尤其是还没有做过系统备份的公司。
4、进度计划
公司计划在哪个时间完成什么工作，以及完成的标志(里程碑/报告是什么)。
该步骤由谁统筹负责，计划的范围包括什么(寻找软件、硬件、咨询供应商等等)。
A、项目选型阶段
a、初步选型阶段(十数家)
在该阶段需要进行的准备工作包括哪些(参考我在BBS中贴出的文件)
该步骤完成的标志是：寻找XX家软件供应商，每家的公司概况、软件功能介绍、系统报价、服务条款等等，并将其编制成册。
b、精细选型阶段(三至四家)
精选的公司ERP系统实施计划方案、每套方案的评价、详细的实施进度及进度控制方法。
在这里要提出：考虑到公司已实施了RF-MIS，在挑选软件供应商的时候应该如何保障公司的利益，软件供应商必须提供接口程序保障现有资源不会浪费等等(这也属于风险计划的一部份)。
c、项目确认阶段(一至两家)
确认的公司(一家，以及候选一家)，该公司的项目项目计划交老总批核。
B、项目调研阶段
承接项目确认阶段，主要是由已初步确认的软件供应商来进行市场调研。在这里应该规定调研的时间安排，计划哪个部门需要多长时间(每个部门两天，合计数加二)，编写报告需要多长时间(两个礼拜) 。
承接项目单位需要做到的大概方面(整理公司的业务流程、目前存在的问题及分析对策、如何通过ERP系统达到加强管理的目标等等)
C、合同谈判期
需要就合同细节进行谈判，谈判的时间应该予以计算(一般为一周时间)
合同谈判需要由谁负责，由谁批核，付款条件(项目调研付百分比、预付百分比、项目培训过程支付百分比、试用付百分比、验收完成付百分比)
需要注明的是，这里只是计划的情况，具体的情况还需要具体去谈(先给老板一个大概的付款方式----需要保障老板的权益)
D、项目培训期
计划ERP实施培训需要多长的时间，一般为每个部门三天，另集中培训两周。
应该由部门什么人参加，培训的内容是什么(参考前面的范围计划，一般是部门主管为KEY USER) 、培训的结果是什么、如何考评结果。
这里也可以提一下：由于顾问人员的流动，常导致项目实施的混乱，故建议公司跟具体的实施人员签订项目跟踪协议，由其个人保证项目的顺利进行，系统实施完成后再给予奖励(预算外费用)。
培训完毕需要参与培训的人员对教师的培训结果予以评价，并作为支付培训费用的依据。
E、项目试用期
项目试用期至少需要三个月，这三个月里一般需要软件公司有专人给予指导(一人) ，试用期过短用户难以体会系统中存在的问题----肯定会有的，也难以习惯系统的运作方式。
试用期每个月需要对仓库库存进行盘点，盘点数据的准确率要按50%、75%、90%的准确率递增(还有生产率、加班减少率具体如何自己考虑。不过千万注意：不要定得太高！！！)。
该期间必须由KEY USER编写本部门的ERP实施运作流程(*作手册) ，同时需要由KEY USER对本部门的ERP项目进行具体验收。
F、正常使用期
目前有两种方式由旧系统切换到新系统。
a、一次性切换。
b、并行后逐步切换
项目计划中应该明确两种切换方式的优点和缺点，并建议采用哪种方式切换。
从什么时间开始正常运行。计划从切换到正常运行的过程为XXX天(至少150天，否则……)
合计：从选型到系统正常运行需要XXX天，预计总费用XXX万。

四、项目的风险规避和质量保证
目前公司的运作状况如何(哪个部门负责什么工作) ，实施ERP可能会需要影响到哪些部门的哪些工作，具体*作时应该如何避免。
实施ERP系统可能会遇到的问题(如果对公司的管理有任何意见，就让顾问公司来提)
对于进度的控制应该达到一个什么样的程度，在这里需要将数据量化：实施前仓务部需要提供什么样的资料(平均库存总量、总金额)、财务部需要提供什么样的参考数据(财务管理的数据) 、采购部需要提供什么资料(平均应收货物数量，总价格、交货准时率、料件的采购提前期)。
有两点需要注意：
1、这里我提的数据适用于未实施ERP系统的公司，由手工向电脑化的转变，对你们不一定适用。
2、贵公司需要提及的主要是现有MIS系统存在的问题，以及如何通过新的ERP对这些这些问题进行改进。

五、人力资源安排
除开始项目规划中提及的人员以外，这里还需要继续阐述ERP系统的人力安排，并以表格的形式体现：
人员 职务 阶段 职责
魏治 项目经理 项目初选 寻找十家基本符合公司要求的ERP软件供应商，并整理XXX报告。
项目精选 判定3家符合公司要求的软件供应商，并完成……工作
这里尤其需要说明的是：什么时间需要管理层的什么协助！！！

六、实施ERP系统需要注意的问题
这里添写实施ERP系统需要注意哪些，以及ERP系统不能完成哪些管理上的要求----比较理性客观的评价ERP系统。部份内容可以附加XXX报或杂志对实施ERP系统的评价。
同时也应该申明对ERP系统的哪些期待是不合理或者达到会有困难的。
把丑话说在前面，有利于以后的进度控制。老板如果把ERP系统想得太美好反倒对ERP系统实施不利！

七、附件
实施目前比较流行服务器系统需要达到的配置(给老板建议)。
服务器(型号、规格、功能)
如果是开发软件的话还包括软件的开发规范。
这一部份东西太多，具体情况具体考虑，不写了。

总之，整份文件需要让老板明白：实施ERP系统会遇到的主要问题，包括费用、时间以及对现有工作的影响。让老板做到心中有数！
这里也讲一句废话：计划与实际的总有些差别！在计划书中也必须让老板明白，差异部份如果多出的话也必须得到老板的书面批示。

PS：我也是初学者，很多理解显然有点幼稚，并没有涉及到较深的层面，大家就凑合着瞧
瞧吧^_^

1.怎样建立asp.net运行环境？
asp有了IIS就可以了，而asp.net也很简单，只要在IIS基础上装一个.net Framework。那
么想要运行asp.net就会和运行asp同样简单，参照问题2。
底下是.net Framework1.1的下载地址，直接按照向导安装好就ok了！
http://download.microsoft.com/download/7/b/9/7b90644d-1af0-42b9-b76d-a2770319a
568/dotnetfx.exe

2.asp直接放在虚拟目录下运行就可以了，那aspx呢？
答案很简单：完全一样：）
如果你有一个aspx的示例网站，那么直接把它拷贝到你建立的一个虚拟目录下就可以了。
唯一要注意的可能就是如果有webconig文件，一定要直接放到虚拟目录之下，否则会出错
。当然微软对于运行asp.net的解释可能会涉及到更深层面，包括私有，共有程序集，权限
之类，所以他会用“部署”这样一个庞大的词汇，我倒认为对于初学者来说实在有点小题
大作。
而咱们的目标不过是让它先运行起来再说：）

3.vs.net是怎样建立一个asp.net应用程序的？
我使用vs.net开发的，所以只针对这个开发环境：P。vs.net把aspx之类的“网页”集称之
为应用程序，多少有点让初学者迷惑（我一开始就是这样：P），这很容易让人觉得这与a
sp几乎完全不一样，其实不然（尽管实现思想上有很大差异），各个网页其实还是相互独
立的，和asp中一样，所以我宁愿还称之为“网页”。vs.net建立一个asp.net程序其实就
是帮你建立一个虚拟目录，然后在这个虚拟目录下建立项目文件（管理多个aspx)。这与D
reamwaver或Frontpage中建立一个站点的性质完全一样，建立这样的项目只是为了方便开
发环境来识别出当前项目包括哪些文件，实际运行时项目的概念其实是不存在的。

4.aspx中的代码究竟是怎样阻止的？与asp中有什么区别？
按照微软的定义，aspx中的代码在第一次运行是要经过编译的，这与asp中的程序解释执行
有着本质的区别。然而，从运行结果来看，这些区别可以说是完全透明的。理解aspx中的
代码的关键其实是要看的懂代码的结构。和asp结构相同的嵌入式代码我就不说了，那个在
理解了代码隐藏之后很容易明白。
你现在是否对类似这样的aspx开头感到不解？：P
<%@ Page CodeBehind="myDatum.aspx.cs" Language="c#" AutoEventWireup="false" In
herits="njuJob.myDatum" %>
这是用vs.net建立aspx的典型开头，我想从快速入门的角度看只要了解这几个属性：
@ Page就不用说了，就是一个标志来说明底下是对页面的属性描述
Language:使用的语言

CodeBehind：此页面对应的代码存储在哪个文件中
Inherits:页面从哪个类继承，此例子中表示是njuJob命名空间中的myDatum类
后两个属性是必须要理解的
代码隐藏是vs.net独有的功能（好像其它环境不支持），它允许把对应于一个页面的程序
逻辑和表示逻辑作为两个文件分离开来（这是不同于asp的一个明显区别），通常是这样的
结构：sample.aspx对应的代码文件是sample.aspx.cs（使用的c#语言），codebehind中会
自动指明。vs.net在编译时可以将所有的代码隐藏文件编译到一个dll中（所谓的程序集）
，当aspx页面被处理时，处理程序可以从Inherits中找到所继承的类，然后从dll中找到这
个类，并实例化从而执行程序得到输出的html。
可能现在大家对这样的解释没有一个整体的认识，所以请看下面的问题：

5.用asp的思路理解asp.net－－代码文件中的代码怎样控制页面的显示？
考虑一个简单的例子，在asp中，如果你想要动态生成一个表格插入到页面中，那么做法通
常是在需要插入的地方加入一段程序和Response.Write语句来实现，稍微变一下，有人可
能会在插入的地方仅加一条语句<%=strTheTalbe%>，而strTheTable的值可能在这之前已经
计算好了，可能是通过一个函数实现的，但这种计算肯定还是包含在这个asp页面中。
现在考虑怎样在asp.net中实现这个过程，我们先引入最简单的一种控件，Literal控件（
关于控件大家应该有个大概的认识，就是一个通用的程序模块之类的意思），这个控件的
功能就是在页面中插入一段字符串，它具有一个text属性，你指定这个属性为一个字符串
，那么这个字符串就会在生成的html文件的相应位置。这应该很好理解，就跟asp中的<%=
strTheTalbe%>的功能几乎完全一样。这个Literal控件在aspx中的声明方式如下：
<asp:Literal id="ltlTable"></asp:Literal>
当要使用代码控制这个Literal时，就用下面的语句：
ltlTable.Text="<table><tr>……";
这样就实现了和asp中一样的功能。代码实际上是在隐藏文件中的，在隐藏文件的类中会有
一个声明来包含这样的控件，这种声明通常都是由vs.net自动完成的，即：你在页面中添
加一个控件，vs.net就会为你在代码隐藏文件中加入相应的声明。隐藏文件的结构分析可
以见下一个问题.
相信通过这样的例子大家应该能对asp.net用控件实现文本输出的功能有了一定的了解，其
实更多更复杂的控件的实现原理完全一样，只是它们提供了更多自动话的功能，例如一个
表格控件可以让你直接输出一个表格，而不用自己去写html代码，至于怎样精确的控制生
成的html代码就要靠自己去经验积累和技术提升了。

6.隐藏代码文件的结构是怎样的？
我们来实际分析一个文件：

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
以上是说明引用了哪些程序集，这和asp中的包含文件应该类似，只有包含了某个文件才能
使用其中的函数，而这边只用引用了某个程序集，才能使用它提供的控件。

namespace njuJob //说明你的程序集的命名空间（这暂时不必理解）
{
public class myDatum : System.Web.UI.Page //这是asp.net页面对象模型（暂时不必
理解）
             ~~~~~~~~这个就是aspx头中的继承属性
{
System.Web.UI.WebControls.Literal ltlTable; //对aspx页面中的控件的声明
private void Page_Load(object sender, System.EventArgs e)
{
// 程序实际上是从这里开始执行
ltlTable.Text="……";
MyFunction();
}

private void MyFunction() //可以声明你自己的函数以供本页面使用
{
}
}
}
这个隐藏文件会被vs.net编译进dll，当aspx被处理时会执行。

好了，暂时先写这些东西吧，这几个问题都是我刚着手asp.net所感到困惑的，如果你恰好
也有同样的困惑，那我很高兴我写的东西能有所价值，如果有什么理解上的严重错误，还
请高手不吝赐教：）

1. 麦当劳和肯德基，无论食品本身多垃圾，但满足了人性中饥饿 + 懒惰，不成功都难。

2. 六月天，满足了性，无需多说。需要补充的是，饥饿 > 性 > 懒惰。比如六月天再麻烦，依旧能吸引大批会员赴汤蹈火。

3. jQuery的成功，是因为在满足人性懒惰的需求上下了很大功夫：容易上手，方便使用。至于代码，绝大部分使用者是不会去看jQuery源码的，就如绝大部分家庭主妇不会去研究冰箱的运作机理一样。至于性能，大部分情况下也是遇不到的，即便遇到了，大部分用户也不会在意慢个0.1秒。而且网页的打开速度也并不是越快越好。

4. 为何BS模式兴起？为何各种RIA方案中，目前只有Ajax如日中天？为何云计算一夜之间腾云驾雾？懒啊懒。

5. Twitter为何流行？两个字：简单。简单是表象，隐藏的是懒惰。我爱Twitter，就像我爱加菲猫一样。140字，不是限制，是自由。只能输入文字？很好，我本就这么懒。懒对于用户体验来说，就如五弦琴的第六弦，看不见但却至关重要。

6. 再说淘宝网的崛起。我觉得主要因素不是价格便宜，而是满足了人性中的懒。在家里点点鼠标，就能省去现实购物的烦恼，实在太好。至于比价，特别是年轻的网购族，我不信会有多少人去自找麻烦（不愁麻烦去比价的，是因为第一人性：饥饿。随着人类生活水平的再进一步提高，饥饿不那么重要后，比价的作用将更小）。

7. 对于用户体验研究来说，就得疯狂的去想怎样方便用户能更懒地使用产品。很佩服Apple, 推出iPod, iPhone等产品，锲而不舍地让用户能更懒。Windows 7也开始加入这一潮流，这不，还没RC呢，就火爆得不行。《The Laws of Simplicity》，《Don’t Make Me Think》等书籍，贯穿的一个核心理念，也就是一个字：懒。

最后归纳成著名的射雕终极定律：

1. 人性定律：凡是不能迎合三大人性的技术，势必衰竭。凡是能够满足三大人性的软件，终究流行。
2. 懒懒定律：凡是优秀的用户体验，必定是满足人性懒惰的。