急需一份《防懒散》主题班会的演讲稿

有什么方法可以消除你在工作中的懒惰和拖延习惯呢？最好的途径就是拒绝任何借口，养成主动工作的习惯。

一个永远勤奋而且乐于主动工作的人，将会得到老板甚至每个人的赞许和器重，同时，你也会为自己赢得一份重要的财产——自信，你会发现自己的才能足够可以赢得他人甚至一个机构的器重。

懒惰会让人的心灵变得灰暗，会让你对勤奋的人产生嫉妒，一个懒惰的人只会看到事物的表面现象，看到别人获得了财富，他会认为这不过是别人比自己更幸运罢了。看到别人比自己更有常识和才智，则说那是因为自己的天分不如别人。这样的人不明白没有努力是难以成功的。事实上，每一个成功者的成就都是靠自己的不懈努力的，这其中不会有机缘的巧合。

懒惰的人最大的恶习就是拖沓。把头一天的工作拖延到第二天，这种工作习惯实在让任何人都无法对他产生信任。对一个渴望取得成功的人来说，拖延是一个危险的恶习，它将让你裹足不前。

拖延简直就是对我们宝贵生命的一种无端浪费。但是此行为却在我们的工作和生活中不断发生，如果把你一天的时间记录下来，你会发现，拖延不知不觉地消耗了你大部分的时间。

有许多这样的人，他们大清早就被闹钟从睡梦中惊醒了，他一边想着自己的计划，一边又在怀念被窝里的温暖，一边告诉自己该起床了，一边又在对自己说——再睡一会吧！就这样，五分钟过去了，十分钟过去了……

人们找借口总是那么理由充分，然而却难以把工作做好，这实在是件十分奇怪的事情。其实，一个人只要把他那些整天想着如何欺瞒他人的时间和精力用到正事上来，他们是肯定能取得一番成绩的。

你必须要把拖延这一恶习从你的个性中连根拔除，这种把你应该在一周，甚至一月和一年前早该完成的工作拖延到明天再做习惯，正在一点一点地吞噬你的生命，如果你不把这一习惯彻底铲除，你要取得任何成就都是十分困难的。

古罗马皇帝在临终时给罗马人留下这样一句遗言：“懒惰是一种借口，勤奋工作吧！”当时，他的周围聚满了士兵。

罗马人有两条伟大的箴言，那就是勤奋与功绩，这也是罗马人征服世界的秘诀。那时，任何一个从战场上胜利归来的将军都要走向田间。那时的罗马最受人尊敬的工作就是农业生产，正是整个罗马人的勤奋与品质，终于使这个国家逐渐变得富强。

但是，当财富和奴隶慢慢增多时，罗马人开始觉得劳动变得不再必要了，于是，这个国家开始走向衰败，懒散导致罪犯增多、腐败滋生，一个高尚而伟大的民族就这样消失了。许多似乎立刻就要成功的人——在别人眼里，他们似乎应该成为一个非凡的成功者，但事实上他们都没有做到。这是什么原因呢？就是因为他们为成功付出相应的代价。他们渴望抵达辉煌的硕峰，但却不愿跨过艰难的山路，他们不愿参加战斗，却又想获得胜利，他们不愿遇到阻力，却又希望一切顺利。

懒惰的人总是抱怨自己无能，连自己家人的温饱问题都解决不了。而勤奋的人却说：“我没有什么天资，只会拼命干活换取面包。”

勤奋工作吧！只有勤奋工作，你才可能获得成功、财富与荣誉。不要因为遇到困难就打退堂鼓，更不要因为就此敷衍了事，勤奋将指引你越过所有的艰难险阻，直到成功！

勤奋工作将给你机会，任何一个老板都会赏识勤奋工作的员工，这是一种值得任何人尊敬的美德，走到哪里，它都会为你增光添彩。

不要贪图安逸，这只会让你变得堕落，整日游手好闲只会让你退化，只有勤奋工作才是高尚的，它将带给你人生真正的乐趣与幸福。当你明白这一点时，请立刻改掉你身上的所有恶习，努力去找一份适合你的工作，你的境况将因此而改变。

要克服这种恶习，你就应该拒绝任何借口，养成主动工作的习惯，你可以这样去做：

每天确定一项明确的工作任务，在你的上司尚未指示之前你就主动去把它做好。
每天至少做一件对他人有价值的事情，不要去在乎是否有报酬。
每天告诉别人养成主动工作习惯的意义，至少告诉一个人以上。 英文版:Lazy evaluation

In computer programming, lazy evaluation is the technique of delaying a computation until the result is required.

The benefits of lazy evaluation include: performance increases due to avoiding unnecessary calculations, avoiding error conditions in the evaluation of compound expressions, the ability to construct infinite data structures, and the ability to define control structures as regular functions rather than built-in primitives.

Languages that use lazy actions can be further subdivided into those that use a call-by-name evaluation strategy and those that use call-by-need. Most realistic lazy languages, such as Haskell, use call-by-need for performance reasons, but theoretical presentations of lazy evaluation often use call-by-name for simplicity.

The opposite of lazy actions is eager evaluation, also known as strict evaluation. Eager evaluation is the evaluation behavior used in most programming languages.

Lazy evaluation refers to how expressions are evaluated when they are passed as arguments to functions and entails the following three points:[1]

The expression is only evaluated if the result is required by the calling function, called delayed evaluation.[2]
The expression is only evaluated to the extent that is required by the calling function, called Short-circuit evaluation.
the expression is never evaluated more than once, called applicative-order evaluation.[3]

Delayed evaluation

Delayed evaluation is used particularly in functional languages. When using delayed evaluation, an expression is not evaluated as soon as it gets bound to a variable, but when the evaluator is forced to produce the expression's value. That is, a statement such as x:=expression; (i.e. the assignment of the result of an expression to a variable) clearly calls for the expression to be evaluated and the result placed in x, but what actually is in x is irrelevant until there is a need for its value via a reference to x in some later expression whose evaluation could itself be deferred, though eventually the rapidly-growing tree of dependencies would be pruned in order to produce some symbol rather than another for the outside world to see.

Some programming languages delay evaluation of expressions by default, and some others provide functions or special syntax to delay evaluation. In Miranda and Haskell, evaluation of function arguments is delayed by default. In many other languages, evaluation can be delayed by explicitly suspending the computation using special syntax (as with Scheme's "delay" and "force" and OCaml's "lazy" and "Lazy.force") or, more generally, by wrapping the expression in a thunk. The object representing such an explicitly delayed evaluation is called a future or promise.

Delayed evaluation has the advantage of being able to create calculable infinite lists without infinite loops or size matters interfering in computation. For example, one could create a function that creates an infinite list (often called a stream) of Fibonacci numbers. The calculation of the n-th Fibonacci number would be merely the extraction of that element from the infinite list, forcing the evaluation of only the first n members of the list.

For example, in Haskell, the list of all Fibonacci numbers can be written as

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
In Haskell syntax, ":" prepends an element to a list, tail returns a list without its first element, and zipWith uses a specified function (in this case addition) to combine corresponding elements of two lists to produce a third.

Provided the programmer is careful, only the values that are required to produce a particular result are evaluated. However, certain calculations may result in the program attempting to evaluate an infinite number of elements; for example, requesting the length of the list or trying to sum the elements of the list with a fold operation would result in the program either failing to terminate or running out of memory.

Control structures
Even in most eager languages if statements evaluate in a lazy fashion.

if a then b else c
evaluates (a), then if and only if (a) evaluates to true does it evaluate (b), otherwise it evaluates (c). That is, either (b) or (c) will not be evaluated. Conversely, in an eager language

define f(x,y) = 2*x
set k = f(e,f)
will still evaluate (e) and (f) when computing (k). However, user-defined control structures depend on exact syntax, so for example

define g(a,b,c) = if a then b else c
l = g(h,i,j)
(i) and (j) would both be evaluated in an eager language.

l' = if h then i else j
(i) or (j) would be evaluated, but never both.

Lazy evaluation allows control structures to be defined normally, and not as primitives or compile-time techniques. If (i) or (j) had side effects or introduced run time errors the subtle differences between (l) and (l') can be complex. As most programming languages are Turing-complete, it is of course possible to have developers introduce their own lazy control structures in eager languages, either as built-ins like C's ternary operator ?: or by other techniques such as clever use of lambdas, or macros.

Controlling eagerness in lazy languages

In lazy programming languages such as Haskell, although the default is to evaluate expressions only when they are demanded, it is possible in some cases to make code more eager - or conversely, to make it more lazy again after it has been made more eager. This can be done by explicitly coding something which forces evaluation (which may make the code more eager) or avoiding such code (which may make the code more lazy). Eagerness is also known as strictness.

However, there is an optimisation implemented in some compilers called strictness analysis, which, in some cases, allows the compiler to infer that a value will always be used. In such cases, this may render the programmer's choice of whether to force that particular value or not, irrelevant, because strictness analysis will force strict evaluation.

In Haskell, marking constructor fields strict means that their values will always be demanded immediately. The seq function can also be used to demand a value immediately and then pass it on, which is useful if a constructor field should generally be lazy. However, neither of these techniques implements recursive strictness - for that, a function called deepSeq was invented.

Also, pattern matching in Haskell 98 is strict by default, so the ~ qualifier has to be used to make it lazy.

Other uses

In computer windowing systems, the painting of information to the screen is driven by "expose events" which drive the display code at the last possible moment. By doing this, they avoid the computation of unnecessary display content.

Another example of laziness in modern computer systems is copy-on-write page allocation or demand paging, where memory is allocated only when a value stored in that memory is changed.

Laziness can be useful for high performance scenarios. An example is the Unix mmap functionality. mmap provides "demand driven" loading of pages from disk, so that only those pages actually touched are loaded into memory, and unnecessary memory is not allocated