a lazy world

From the article "Why functional programming matters" i've been impressed by this consideration

Functional programs contain no assignment statements, so variables, once given a value, never change. More generally, functional programs contain no side-effects at all. A function call can have no effect other than to compute its result. This eliminates a major source of bugs, and also makes the order of execution irrelevant — since no side- effect can change an expression’s value, it can be evaluated at any time .... 

In Program Languages the "type system" is a rules set that provides the ability to determine a type for commands, expressions and other languages constructs. There are many types of languages and everyone could have a different type system but we can summarize them into 2 families:

- Statically Typed: when all types can be defined at compile-time (analyzing the source code) - Dinamically Typed: in the other cases, when the type can't be determined only analyzing the source but it depends on execution state

Example: PHP code

$a = 100; // This instruction defines an integer variable

Afterwards we could re-define the $a variable as array

$a[1] = 100; // The variable must be an array

The latter instruction will run successfully only if $a is an array, for executing this code the PHP engine must do a dynamic type checking. In fact PHP has a dynamic type system that provides a great flexibility to the language however it forces the engine to make continous checking. The statically typed languages are obviously much more efficient than the dynamic ones (all types are binded at compile time and they don't need to redo the checking at runtime), however dynamic typed languages can rely on the flexibility from the dynamic world.

This post are only showing the basics of the type system and is intended to whet the curiosity on the deeper world inside programming stuff.

SYMFONY2-Bundle Simplifies the work of your frontend team.

Bring CSS Inline

All CSS needs to be inline for HTML emails. For ease of editing, we've kept the CSS separate. When you're ready to send your email, you'll want to use a CSS inliner tool, such as MailChimp's or Premailer, among others. Many email campaign tools such as Campaign Monitor will do this for you automatically.

ZURB, Inc

If your are a Symfony2 developer use the "css inliner bundle"

The lazy evaluation is a useful evaluation strategy adopted from different programming languages, it consists on do not evaluate an expression unless its value is needed to the rest of program.

This strategy is used by a lot of functional languages like Haskell, but today some functional behaviours are implemented in modern languages like python, ruby etc.. For example in Python 3.x the range() function returns a special range object which computes elements of the list on demand (lazy or deferred evaluation) Let us see in action the laziness We could define a ‘my_fake_if’ function like that

fun my_fake_if (x , y , z) = if x then y else z;

The “y” term will be evaluated only if the “x” term evaluation returns true, otherwise it will not evaluated at all.

So now we could write a program that uses my_fake_if

my_fake_if (true, 100 , 1 div 0);

and the result of this program “in a lazy world” will be obviously 100.

In depth the third term ( aka “y” ) contains a zero division so an eager evaluation strategy will throws an exception. But not all functional languages are lazy, in fact this is an SML example (Standard ML is an eager functional language) and the execution of my_fake_if(true, 100 , 1 div 0)  throws that uncaught exception Div [divide by zero]

The lazy evaluation can lead a lot of benefits such as

Making potentials infinite data structures

Reducing the memory footprint and execution time provided by the non-evaluation of unused terms

Links