石英石台面有3总工艺：
一、单片压制震动去真空成型工艺。这是目前国际和国内最先进的石英石生产工艺。
二、胶注成型工艺。也叫人造石工艺，即跟人造石生产工艺类似。进行浇注压制成型，并经过高温固化后冷却。
三、荒料式生产工艺。也叫岗石工艺，即跟岗石生产工艺类似。采用荒料压制成型，高温固化后进行荒料切割。
当然价格也相差很多，同时，还分进口和国产，价格相差更多。
大品牌的整体橱柜，台面报价都在1K一延米，进口台面。如果国产的，也要在880左右。
在天林装饰问了加工石料的老板，一般国产的石英石价格在300～400一延米，当然，好些的也要500多，也就是说这个台面的赚头还是非常大的。4米的话，就要一千左右的毛利润了。
1000多的台面，还是有点舍不得买的，凯丽的石英石台面报价在370，应该来说是比较便宜了，查询了一下凯丽的网站 （http://www.colorstonecn.com/ ），从这个介绍（http://www.colorstonecn.com/About-5.html）来看，工艺是采用第一种，单片压制震动去真空成型工艺。所以这个价位，看来还是比较实惠的。
在现场，也用硬物刮，的确非常坚硬，没有划痕，现在基本决定买这个台面了。具体效果怎么样，等装完使用后，才能知道了。
南非世界杯主题曲：Waving Flag
今天就这样了
今天就这样了
羽泉-天上没有乌云盖《越光宝盒》
给父母的四个建议 （李开复）
给父母的四个建议
李开复
今年送女儿去读大学的时候，我曾写过一封信给她，后来这封信公布在我的博客上，引起了很大反响。很多人问我为什么喜欢写信，我觉得写信是一个很好的模式，比言语或电话更能清楚地传达自己的理念，而且信可以长久地保留，不断重温。我父亲以前就常写信给我，现在我书房里还有五六十封，每几年我都会把它们拿出来阅读一下，觉得弥足珍贵。虽然今天是电子邮件和电话的时代，但用写信的方式来传达一些深思熟虑的想法，让孩子永久留下珍贵的纪念，是一个很不错的渠道。
给女儿的那封信最开始仅仅感念于有太多话想对她说，但是后来决定把它在博客上发表，是因为我觉得中国的学生和父母读了这封信或许会有所启发。除了给女儿的那些建议，我还以自己为人父母十多年的感受，以及作为父母的孩子四十多年的感受，总结了四个建议跟大家分享。
一、多称赞，少批评；多鼓励，少惩罚
批评中长大的孩子，责难他人 惩罚中长大的孩子，自觉有罪
称赞中长大的孩子，懂得感恩 认可中长大的孩子，喜欢自己
在我给女儿的那封信里，毫无保留地描述了从她的出生到大学我们之间的父女感情，这种正面的情感交流和表达，是对孩子的一种认可和鼓励，在孩子成长时父母应该持有这样的态度。然而也有很多家长，包括我自己过去也忍不住用惩罚、批评甚至威胁、恐吓的方式去教导孩子。
如果一个孩子在批评的环境中长大，就可能会潜移默化地用批评的态度来解决沟通问题；如果孩子做得不好就要受到惩罚或被威胁，就只有压抑自己的恐惧，否定自己的情感，来换取父母的认同。这样的管教之下，孩子可能会很听话，但是也会缺乏自信，好奇心受到压抑，无法体谅他人的情绪，存在很多情感的缺陷和问题。
对小一点的孩子，尤其是涉及到道德或责任方面的问题时可以适当惩罚，但是有一点是千万不可以惩罚的，那就是失败。在人的成长过程中，最多的教训就是从失败中得到的，如果从小就告诉孩子失败很可耻，他就可能不承认失败，或是隐藏自己的失败，甚至做出不诚信的行为，而不会从失败中检讨、学习、成长。
相对来讲，我们应该给予孩子更多的鼓励和肯定。我11岁刚到美国时不会讲英文，几乎没有任何值得夸奖的地方，但是校长却牺牲自己的午餐时间为我补习，有一次数学课老师问1/7是多少，我很快说出了以前背的答案，老师和同学都夸奖我是数学天才，我虽然不是数学天才，但在这样的鼓励下，充满了自信，而且对数学产生了浓厚的兴趣。这就是美国教育的特点，它非常鼓励优点，而不去批评缺点。当时我的数学很好，美国历史却很糟，老师并没有因此打击我，知道我英文不好，甚至允许我考试的时候把试卷带回家去查字典来做，相信我不会去偷看书。这样的信任和鼓励，反而激励了我学好这门功课的决心，这件事给了我学习的勇气，也让我生出责任感和荣誉感。所以我觉得这样一种正面的教育才能够真正帮助孩子。
二、多信任，少严管；多放权，少施压
严管中长大的孩子，无法独立 施压中长大的孩子，常常忧虑
信赖中长大的孩子，信人信己 放权中长大的孩子，深具责任
在严厉管教下长大的孩子，会缺乏独立的能力和管理时间、管理自己的能力，一旦进入大学没有人再帮他策划，就会迷失自我，无所适从。所以家长应该随着孩子的长大而逐渐放权。三五岁的时候告诉他们怎么做，七八岁的时候给他们一些授权，读了大学以后，他们就应该完全做自己的主人。很多父母认为自己是为了孩子好才要去管他，但是我有四个应该放权的理由。
第一，父母不见得懂孩子的这一代，可能并不像孩子那样知道自己想要什么。
第二，如果父母帮孩子做了太多决定，反而会造成他们日后责任心的缺失。
第三，如果父母管教太多，就会淹没孩子自己的声音，他们会找不到自己的兴趣，失去自信。我在大学演讲的时候，常常有学生说你总告诉我们要追随自己的心，可是我不知道自己的心是什么。如果太严管，可能就会把孩子变成这样的机器。
第四，如果施压太多，会给孩子沉重的负担。今天的孩子有很多心理问题，有的甚至严重到自杀、抑郁症，这都是在巨大压力下造成的，父母对孩子一定不要过分施压，而应有解压的责任。
我知道女儿对成绩非常敏感，考虑到各种因素（例如高昂的学费）而对自己要求很高，当感觉到她有太深的责任感和太大的压力时，我在给她的信里说了一句话，很多学生说他们很喜欢，“成绩只是一个很无聊的分数，它是给那些爱慕虚荣的人拿去炫耀的，或者给那些慵懒的人去畏惧的。”这句话可能不适合每一个学生，有些学生还是要培养责任感的，但是我有必要告诉女儿，我永远不会刻意地看她的成绩。
几个月前，女儿问我是学日文还是韩文好，我跟她说两个都没有用。但是后来我很后悔，就告诉她虽然你的父亲说日文韩文都没有用，但是你都可以去选。我告诉她要追随自己的心，去尝试很多事，因为每一件事情都是一个点，在人生未来的某一天，你会有机会把这些点连在一起，画成一条优美的曲线。在我个人成长过程中，有件事意义重大，就是四岁多时我决定不要读幼儿园而去读小学，我的父母答应只要考得上就让我读，最后我考上了。这是我第一个重要的人生决定，我因此意识到自己不是父母的附属品，而是一个有决策权力的人。放权会培养孩子的自信，在信赖中长大的孩子会相信自己，以后也会相信别人。在放权的环境中长大，孩子也会具有独立自主的能力，深具责任感。
三、多授渔，少授鱼；多做，少说
传道中长大的孩子，失去判断 解惑中长大的孩子，仅能记得
互动学习中长大的孩子，才真懂得 以身作则中长大的孩子，言行一致
在中国的环境中，无论是父母还是老师都有一个常犯的错误，就是说教，说教是中国传统的两三千年前的形式，但是在21世纪已经过时了。传道式的教育之下，孩子可能会记住，但不会真的懂得。说教可能产生两种后果，一是孩子不认可你，变得叛逆；二是他记住了父母的说教，同时也失去了自己的判断力。仅仅解惑的孩子同样也不会真正懂得。
要想真正懂得，一方面要试着经过互动的学习，让孩子知道没有事情是绝对的，一个问题可以从很多不同的角度来看；另一方面要“授之以渔”，教孩子思考的能力、学习的能力和解决问题的能力。大学中的学习最重要的就是当你把所有学科的知识全部忘光的时候那些剩下来沉淀在你心中的，那才是教育的本质。
我常鼓励我的女儿参加辩论会时去辩论她不相信的那一方，多想一下她不是自然想出来的那一面，这样才能理解事情是有两面的，没有绝对的是非黑白。当人面对两面的时候，会更深刻地思考问题，另外，这种思考方式也会培养孩子的同理心。
除了这种批判式思维之外，同样重要的是以身作则。有些父母亲会威胁孩子如果再打架就会打他，显而易见这样的教育只会适得其反。父母对孩子的教育，真正沉淀在孩子的心中的是如何做的，而不是如何说的。那些让孩子守时而自己不守时，让孩子讲礼貌而自己不讲礼貌，让孩子讲诚信而自己不讲诚信，让孩子负责而自己不负责的父母都没有做到真正的教育。所以，想让孩子成为什么样的人，就要以身作则，言行一致，为孩子树立一个榜样。我给女儿的信中谈到了以诚待人，多交朋友，无需强求朋友跟自己一样嗜好、一样个性，只要相互真心对待就足够了。我也跟她举了自己的例子，我身边的朋友都个性迥异，但是如果自己都没有做到，我这样说就没有说服力了。
四、多做好朋友，少做严长辈
规矩中长大的孩子，保守胆小 父母附属品的孩子，被动听话
轻松中长大的孩子，乐观快乐 做父母朋友的孩子，爱人爱己
我的父亲是个很好的父亲，他爱国、诚信、非常负责任，但是他从来不跟孩子打成一片，严守着长幼有序的界限。对父母尊敬当然是必要的，但是更重要的是父母要成为孩子的朋友。在这个时代成长，孩子的心中可能会有各种不同的压力，当他们面临问题、困惑和挑战的时候，如果只是觉得父母是高高在上的长辈，就可能避而不谈，慢慢就有了代沟和隔阂。家长也许会觉得孩子太难懂，但其实可能是自己没有放下架子，定了太多规矩。
在太多的规矩和框架之下成长的孩子会胆小、保守、被动，新的时代里这样的人很难达到自己的潜力，也难在优秀的企业或学校脱颖而出。今天我们希望培养的孩子是快乐、乐观的，是能看到一杯水半满而不是半空的，是能够对父母亲有信任彼此倾诉的，是能够爱自己也能爱别人的。
所以我跟孩子在一起时，总告诉自己不要有架子，我的孩子会像朋友那样跟我开玩笑，也有很多话跟我说。以前我都是用电子邮件，但自从要跟女儿沟通之后，我就经常用IM，在IM上，我发现她讲的很多话都是奇奇怪怪的（不管在中国还是美国，都有那么一套九零后的网络语言），我也学着跟她这样讲，刚开始时她觉得很奇怪，但是后来她告诉我我是一个很可爱的爸爸。其实孩子不但愿意，而且非常渴望做我们的朋友，我们也非常需要他们做我们的朋友，得到他们的信任。今天的孩子很多习惯跟我们已经不一样了，让他们来学我们时代的规矩是很困难的，所以我们要学习他们的。
那是不是就完全不要规矩呢？当然不是这样。规矩可以有，然而：（1）定好规矩，但是首先要把规矩的道理讲清楚，不是盲目地服从；（2）在规矩内孩子有完全的自由；（3）违背了规矩孩子将受到讲好的惩罚；（4）规矩越少越好，才能有启发的作用；（5）孩子越大，规矩越少，放权越多。
这是我的四个建议，希望对大家有一些帮助和启发，中国的未来在中国的青年中，而中国的青年都是我们的骨肉、我们的最爱，所以让我们以后能够彼此勉励，把他们培养成他们最好的自己。
————————————————————————————
李先生的话应该时刻铭记。与吾儿一起长大。
test syntaxHighlighter
[scala]
package examples
/** Illustrate the use of pattern matching in Scala.
Like patterns.scala, but uses extractors for representation independence
*/
object extractorPatterns {/** We need an abstract base class for trees. Subclasses with
- the ‘case’ modifier can be used in pattern matching expressions
- to deconstruct trees.
* - Here, we replaced case classes of patterns.scala with objects
- that hide the actual implementation of Branch and Leaf. Note
- that the remaining code does not change. In this way, we
- can change the implementation later without affecting clients,
- which is called representation independence.
*/
abstract class Tree
object Branch {
/ method to contruct branches @see extractorPatterns.tree1 /
def apply(left: Tree, right: Tree): Tree = new BranchImpl(left, right)
/ extractor method referenced in match expressions @see extractorPatterns.sumLeaves /
def unapply(x:Tree): Option[(Tree,Tree)] = x match {
case y:BranchImpl => Some(y.left, y.right)
case => None
}
private class BranchImpl(val left:Tree, val right:Tree) extends Tree
}
object Leaf {
/ method to contruct leaves @see tree1 /
def apply(x:Int): Tree = new LeafImpl(x);
/ extractor method referenced in match expressions @see extractorPatterns.sumLeaves /
def unapply(x:Tree): Option[Int] = x match {
case y:LeafImpl => Some(y.x)
case => None
}
private class LeafImpl(val x: Int) extends Tree
}/** Case classes have an implicit constructor methods which allows
- to create objects withouth the ‘new’ keyword. It saves some typing
- and makes code clearer.
* - Here, the task of the case class constructor is performed by the
- method Branch.apply - the singleton Branch is treated as if it
- were a function value. This trick works with any value that has
- an apply method.
*/
val tree1 = Branch(Branch(Leaf(1), Leaf(2)), Branch(Leaf(3), Leaf(4)))
/** Return the sum of numbers found in leaves.
- ‘match’ is a generalization of ‘switch’ in C-like languages
* - Patterns consist of case class constructors (which can
- be nested), and lower case variables which are
- bound to the values with which the class has been constructed.
* - For extractors, it is not the name of a case class, but the name of
- the singleton object Branch which is used to refer to its extractor method
- Branch.unapply - the pattern is the ‘reverse’ of a method
- call, with the result being matched in the subpatterns. This works
- for any value that has an appropriate extractor method.
*/
def sumLeaves(t: Tree): Int = t match {
case Branch(l, r) => sumLeaves(l) + sumLeaves(r)
case Leaf(x) => x
}
/** This illustrates the use of Option types. Since the
- method is not known in advance to find ‘x’, the
- return type is an Option. Options have two possible
- values, either ‘Some’ or ‘None’. It is a type-safe
- way around ‘null’ values.
*/
def findA, B: Option[B] = {
var result: Option[B] = None
while (it.hasNext && result == None) {
val Pair(x1, y) = it.next;
if (x == x1) result = Some(y)
}
result
}
def printFindsA =
find(xs.elements, x) match {
case Some(y) => println(y)
case None => println(“no match”)
}def main(args: Array[String]) {
println(“sum of leafs=” + sumLeaves(tree1));
printFinds(List(Pair(3, “three”), Pair(4, “four”)), 4)
}
}
package examples
/** Illustrate the use of pattern matching in Scala.
Like patterns.scala, but uses extractors for representation independence
*/
object extractorPatterns {/** We need an abstract base class for trees. Subclasses with
- the ‘case’ modifier can be used in pattern matching expressions
- to deconstruct trees.
* - Here, we replaced case classes of patterns.scala with objects
- that hide the actual implementation of Branch and Leaf. Note
- that the remaining code does not change. In this way, we
- can change the implementation later without affecting clients,
- which is called representation independence.
*/
abstract class Tree
object Branch {
/ method to contruct branches @see extractorPatterns.tree1 /
def apply(left: Tree, right: Tree): Tree = new BranchImpl(left, right)
/ extractor method referenced in match expressions @see extractorPatterns.sumLeaves /
def unapply(x:Tree): Option[(Tree,Tree)] = x match {
case y:BranchImpl => Some(y.left, y.right)
case => None
}
private class BranchImpl(val left:Tree, val right:Tree) extends Tree
}
object Leaf {
/ method to contruct leaves @see tree1 /
def apply(x:Int): Tree = new LeafImpl(x);
/ extractor method referenced in match expressions @see extractorPatterns.sumLeaves /
def unapply(x:Tree): Option[Int] = x match {
case y:LeafImpl => Some(y.x)
case => None
}
private class LeafImpl(val x: Int) extends Tree
}/** Case classes have an implicit constructor methods which allows
- to create objects withouth the ‘new’ keyword. It saves some typing
- and makes code clearer.
* - Here, the task of the case class constructor is performed by the
- method Branch.apply - the singleton Branch is treated as if it
- were a function value. This trick works with any value that has
- an apply method.
*/
val tree1 = Branch(Branch(Leaf(1), Leaf(2)), Branch(Leaf(3), Leaf(4)))
/** Return the sum of numbers found in leaves.
- ‘match’ is a generalization of ‘switch’ in C-like languages
* - Patterns consist of case class constructors (which can
- be nested), and lower case variables which are
- bound to the values with which the class has been constructed.
* - For extractors, it is not the name of a case class, but the name of
- the singleton object Branch which is used to refer to its extractor method
- Branch.unapply - the pattern is the ‘reverse’ of a method
- call, with the result being matched in the subpatterns. This works
- for any value that has an appropriate extractor method.
*/
def sumLeaves(t: Tree): Int = t match {
case Branch(l, r) => sumLeaves(l) + sumLeaves(r)
case Leaf(x) => x
}
/** This illustrates the use of Option types. Since the
- method is not known in advance to find ‘x’, the
- return type is an Option. Options have two possible
- values, either ‘Some’ or ‘None’. It is a type-safe
- way around ‘null’ values.
*/
def findA, B: Option[B] = {
var result: Option[B] = None
while (it.hasNext && result == None) {
val Pair(x1, y) = it.next;
if (x == x1) result = Some(y)
}
result
}
def printFindsA =
find(xs.elements, x) match {
case Some(y) => println(y)
case None => println(“no match”)
}def main(args: Array[String]) {
println(“sum of leafs=” + sumLeaves(tree1));
printFinds(List(Pair(3, “three”), Pair(4, “four”)), 4)
}
}
[/scala]
iPad还可以这样
Twitter推出名为“Gizzard”的分布式数据存储框架
最近Twitter官方博客撰文称，很多现代网站需要更快地访问大量数据，无法通过单一计算机对这些数据进行有效存储。应对措施之一就是对这些信息进行分割，分别存储在不同的计算机上。
作为数据分割的替代方案之一，Twitter已经开发了一个框架，用来代替自定义开发的数据存储系统或未经测试的开源备选方案，然后对外开放代码。
Twitter已经从以往的数据存储开发经验中提出一个名为Gizzard的Scala框架，让用户可以更方便地创建自定义容错、分布式数据库。
Twitter给出了一个名为“Rowz”的示例，方便用户上手。Twitter还公布了Gizzard的完整代码。
有了Gizzard，初创公司和小公司就可以更好更快地处理大量数据，从而利用更少的资源满足用户需求。
源码地址：http://github.com/twitter/gizzard
示例源码：http://github.com/nkallen/Rowz
考验
这几天，天天跑建材市场，红星、月星、石林，高档低档，样样都看。真是体力和脑力的考验，鱼和熊掌真是难以兼得啊。
物联网 Internet of Things
物联网就是把传感器装备到电网、铁路、桥梁、隧道、公路、建筑、供水系 统、大坝、油气管道以 及家用电器等各种真实物体上，通过互联网联接起来，进而运行特定的程序， 达到远程控制或者实现物与物的直接通信。 物联网，即通过装置在各类物体上的射频识别(RFID)，传感器、二维码等，经过接口与无线网络相连，从而给物体赋予“智能”，实现人与物体的沟通和对 话，也可以实现物体与物体互相间的沟通和对话，这种将物体联接起来的网络被称为“物联网”。
物联网一般为无线网，由于每个人周围的设备可以达到一千至五千个，所以物联网可能要包含500亿至一千万亿个物体，在物联网上，每个人都可以 应用电子标签将真实的物体上网联结，从一瓶酸奶到 一架飞机，在物联网上都可以查找出它们的具体位置，即使在地球的 另一边。
通过物联网可以用中心计算机对机器、设备、人员进行集中管理、控制， 也可以对家庭设备、汽车进行遥控，以及查找位置防止物品被盗等各种应用。