Daniel Jomphe's Public Library

Toshiba

la concurrence s'aiguise avec l'arrivée de nouveaux entrants qui n'étaient pas présents sur ce marché de l'éclairage mais qui y viennent armés de technologies efficientes

Sharp, est de ceux-là. Le responsable de la dégringolade des prix, ne cherchez pas, c'est lui. Il a en effet lancé cet été une gamme d'ampoules basées sur ses propres technologies (secrètes) à un prix deux fois inférieur à celui des modèles concurrents alors en rayon, qui plus est en faisant mieux sur le plan qualitatif.

"Sharp s'est aussi distingué avec ses ampoules en résolvant un problème afférent aux LED qui est que leur lumière est directionnelle. Il a le premier réussi à bien en homogénéiser la répartition"

Toutefois, le fait que lesdites ampoules à LED soient désormais techniquement au point et abordables ne suffit pas, car elles restent quand même 40 fois plus onéreuses à l'achat que les modèles d'antan à filament et 4 fois plus coûteuses que les plus récentes lampes fluorescentes compactes. Elles ne sont de fait rentables qu'à moyen et long termes, offrant une décennie d'utilisation à raison de 10 heures par jour en consommant jusqu'à huit fois moins d'électricité que les autres modèles, fussent-ils étiquetés "basse-consommation".

Pour convaincre les consommateurs, Sharp joue aussi sur l'ambiance. Ainsi, une des nouvelles ampoules proposées est vendue avec une télécommande. Cette dernière permet de changer la nuance sur sept niveaux d'un dégradé allant de l'orangé au blanc parfait. Il est aussi possible d'ajuster à souhait la luminosité de 0 à 100%. Une même télécommande peut contrôler toutes les ampoules d'une même pièce dans un rayon de 5 mètres.

Panasonic tente aussi de s'imposer sur ce marché en insistant sur les vertus écologiques de sa nouvelle gamme

Une firme affiliée au groupe d'électronique nippon Mitsubishi Electric est aussi sur les rangs, de même que NEC qui a dû revoir ses projets initiaux à l'aune de ces rapides changements pour proposer des produits plus compétitifs que ceux qu'il envisageait de lancer

Amérique du Nord afin d'y promouvoir et vendre ces produits

Most of the differences between DDP and SMB2 are small graphical changes,^{[citation needed]} such as animation being added to the POW blocks, bomb fuses, cherries, potions, vegetables, and extra frames of animation for numerous enemies for the SMB2 version. Super Mushrooms replacing large hearts as life-meter increases, the characters shrinking when reduced to only one unit of health, and some music tracks being made longer with more instrumentation were among some other changes.

Super Mario Bros. 2 received a graphical, audio, and gameplay upgrade when it was rereleased five years after its original release as part of the Mario games collection, Super Mario All-Stars (1993, SNES).

Whereas the original NES version of Super Mario Bros. 2 only allowed players to continue twice after losing all of their lives, the All-Stars version enabled players to continue any number of times due to the reintroduction of a save function (as with the original Doki Doki Panic). The ability of players to win lives in the All-Stars version of the Bonus Chance game was also increased from a maximum of 5 to 10. While in the original NES version players were forced to use the same character throughout the duration of the level the character was selected for, the All-Stars version additionally enabled the player to select a different character after losing a life.

Finally, various minor stylistic and aesthetic changes were also made including the changing of Princess Toadstool's hair from brunette to blonde

The deal cancels out Virgin’s $248 million in outstanding debts and will unite Sprint’s Boost service and Virgin Mobile under the same roof.

Sprint says it would keep the Virgin Mobile brand

most new languages (imperative as well as
functional) have implemented garbage collection to remove
resource management from the problem

But imperative languages are based upon the notion of
sequencing - they can never escape it completely. The only way to
raise the level of abstraction in the sequencing area for an
imperative language, is to introduce more keywords or standard
functions, thus cluttering up the language (see Python and Java).

Functions play an important role in functional
programming languages. Functions are considered to be values just
like Int or String. A function can return another function,
it can take a function as a parameter, and it can even be
constructed by composing functions.

This offers a stronger "glue" to combine the modules of your
program. A function that evaluates some expression can take part of
the computation as an argument for instance, thus making the
function more modular.

You could also have a function construct another function.
For instance, you could define a function "differentiate" that
will differentiate a given function numerically. So if you then have
a function "f" you could define f' = differentiate f, and use it
like you would normally do in a mathematic context.

This concept is possible in imperative languages as well. In Java
you often have to provide a Comparator object for trees and other
standard data structures. The difference is that the Haskell way is
a lot more intuitive and elegant (creating a separate type just for
comparing two other types and then passing an object of this type is
hardly an elegant way of doing it), so it's more likely to be used
frequently (and not just in the standard libraries).

Removing side-effects from the equation allows expressions to be
evaluated in any order (although not all functional
languages use this). A function will always return the same
result if passed the same input.

This determinism removes a whole class of bugs found in imperative
programs.

template <typename T>
void qsort (T *result, T *list, int n)
{
    if (n == 0) return;
    T *smallerList, *largerList;
    smallerList = new T[n];
    largerList = new T[n];      
    T pivot = list[0];
    int numSmaller=0, numLarger=0;      
    for (int i = 1; i < n; i++)
        if (list[i] < pivot)
            smallerList[numSmaller++] = list[i];
        else 
            largerList[numLarger++] = list[i];
    
    qsort(smallerList,smallerList,numSmaller); 
    qsort(largerList,largerList,numLarger);
        
    int pos = 0;        
    for ( int i = 0; i < numSmaller; i++)
        result[pos++] = smallerList[i];
        
    result[pos++] = pivot;
                
    for ( int i = 0; i < numLarger; i++)
        result[pos++] = largerList[i];
        
    delete [] smallerList;
    delete [] largerList;
        
    return;
};

qsort []     = []
qsort (x:xs) = qsort less ++ [x] ++ qsort more
     where less = filter (<x)  xs
           more = filter (>=x) xs

Data encapsulation is done in Haskell by declaring each data type
in a separate module, from this module you only export
the interface. Internally there might be a host of functions that
touch the actual data, but the interface is all that's visible from
outside of the module.

Polymorphism is done by using something called type classes.
Now, if you come from a C++ or Java background you might associate
classes with something resembling a template for how to construct an
object, but that's not what they mean in Haskell. A type class in
Haskell is really just what it sounds like. It's a set of rules for
determining whether a type is an instance of that class.

An ideal situation is updating relevant parts of the code without stopping any part of the system at all. In an imperative
world this isn't possible. Consider unloading a Java class at runtime and reloading a new definition. If we were to do
that every instance of a class would become unusable because the state it holds would be lost. We would need to resort to
writing tricky version control code. We'd need to serialize all running instances of the class, destroy them, create
instances of the new class, try to load serialized data into them hoping the loading code properly migrates the data to work
with the new instance. On top of that, every time we change something we'd have to write our migration code manually.
And our migration code would have to take special care not to break relationships between objects.
Nice in theory, but would never work well in practice.

In a functional program all state is stored on the stack in the arguments passed to functions. This makes hot deployment
significantly easier! In fact, all we'd really have to do is run a diff between the code in production and the new version,
and deploy the new code. The rest could be done by language tools automatically! If you think this is science fiction, think
again. Erlang engineers have been upgrading
live systems without stopping them for years.

An interesting property of functional languages is that they can be reasoned about mathematically. Since
a functional language is simply an implementation of a formal system, all mathematical operations that could be done on
paper still apply to the programs written in that language. The compiler could, for example, convert pieces of code into
equivalent but more efficient pieces with a mathematical proof that two pieces of code are equivalent⁷.
Relational databases have been performing these optimizations for years. There is no reason the same techniques can't apply
to regular software.

Additionally, you can use these techniques to prove that parts of your program are correct. It is even possible to create tools
that analyze code and generate edge cases for unit tests automatically! This functionality is invaluable for rock solid systems.
If you are designing pace makers and air traffic control systems such tools are almost always a requirement. If you are writing
an application outside of truly mission critical industries, these tools can give you a tremendous edge over your competitors.

I remember learning about the benefits I outlined above and thinking "that's all very nice but it's useless
if I have to program in a crippled language where everything is final."

Functional
languages offer a different kind of abstraction tools that make you forget you've ever liked modifying variables.

One
such tool is capability to work with higher order functions.

Let's extend our Java compiler to support this notation. When we
type something like this our compiler will convert it to the following Java code (don't forget, everything is final):

class add_function_t {
    int add(int i, int j) {
        return i + j;
    }
}

add_function_t add = new add_function_t();

The symbol add isn't really a function. It is a small class with one function as its member. We can now pass
add around in our code as an argument to other functions. We can assign it to another symbol. We can create instances
of add_function_t at runtime and they will be garbage collected when we no longer need them. This makes functions
first class objects no different from integers or strings. Functions that operate on other functions (accept them
as arguments) are called higher order functions. Don't let this term intimidate you, it's no different from Java
classes that operate on each other (we can pass class instances to other classes). We can call them "higher order classes" but nobody
cares to because there is no strong academic community behind Java.

How, and when, do you use higher order functions? Well, I'm glad you asked. You write your program as a big monolithic
blob of code without worrying about class hierarchies. When you see that a particular piece of code is repeated, you break it
out into a function (fortunately they still teach this in schools). If you see that a piece of logic within your function needs
to behave differently in different situations, you break it out into a higher order function.

An object oriented approach

That's a lot of
code for such a simple modification though.

Now let's do
the same thing in our language that supports higher order functions:

We've created no new types and no class hierarchy. We simply pass appropriate functions as a parameter. We've achieved the same
thing as the object oriented counterpart with a number of advantages. We don't restrict ourselves to class hierarchies: we can pass
new functions at runtime and change them at any time with a much higher degree of granularity with less code. Effectively the compiler
has written object oriented "glue" code for us! In addition we get all the other benefits of FP.

dapter pattern is best known when applied to the "default" abstraction unit in Java - a class. In functional languages the
pattern is applied to functions. The pattern takes an interface and transforms it to another interface someone else expects.
Here's an example of an adapter pattern:

int pow(int i, int j);
int square(int i)
{
    return pow(i, 2);
}

The code above adapts an interface of a function that raises an integer to an integer power to an interface of a function
that squares an integer. In academic circles this trivial technique is called currying (after a logician Haskell Curry who
performed mathematical acrobatics necessary to formalize it). Because in FP functions (as opposed to classes) are passed around
as arguments, currying is used very often to adapt functions to an interface that someone else expects. Since the interface to
functions is its arguments, currying is used to reduce the number of arguments (like in the example above).

As we saw earlier somewhatLongOperation1 and somewhatLongOperation2 can be executed concurrently because we're
guaranteed no function affects or depends on global state. But what if we don't want to run the two concurrently, do we need to run
them in order? The answer is no. We only need to run these operations when another function depends on s1 and s2.
We don't even have to run them before concatenate is called - we can delay their evaluation until they're required within
concatenate. If we replace concatenate with a function that has a conditional and uses only one of its two parameters
we may never evaluate one of the parameters at all!

Lazy evaluation provides a tremendous potential for optimizations. A lazy compiler thinks of functional code exactly as mathematicians
think of an algebra expression - it can cancel things out and completely prevent execution, rearrange pieces of code for higher efficiency,
even arrange code in a way that reduces errors, all guaranteeing optimizations won't break the code.

Lazy evaluation provides a higher order of abstraction that allows implementing things in a way that would otherwise
be impossible.

For example consider implementing the following control structure:

unless(stock.isEuropean()) {
    sendToSEC(stock);
}

We want sendToSEC executed unless the stock is European. How can we implement unless? Without lazy evaluation
we'd need some form of a macro system, but in a language like Haskell that's unnecessary. We can implement unless as a function!

void unless(boolean condition, List code) {
    if(!condition)
        code;
}

Note that code is never evaluated if the condition is true. We cannot reproduce this behavior in a strict language because
the arguments would be evaluated before unless is entered.

Lazy languages allow for definition of infinite data structures, something that's much more complicated in a strict
language.

Because the language is lazy, only the necessary parts of the list that are actually used by the program are ever evaluated. This
allows for abstracting a lot of problems and looking at them from a higher level (for example, we can use list processing functions
on an infinite list).

In a lazy language you have no guarantee that the first line will be executed before the second! This means we can't do IO, can't
use native functions in any meaningful way (because they need to be called in order since they depend on side effects), and can't
interact with the outside world! If we were to introduce
primitives that allow ordered code execution we'd lose the benefits of reasoning about our code mathematically (which would take
all of the benefits of functional programming with it). Fortunately not all is lost. Mathematicians got to work and developed a number
of tricks to ensure code gets executed in particular order in a functional setting. We get the best of both worlds! These techniques
include continuations, monads, and uniqueness typing. In this article we'll only deal with continuations. We'll leave monads and
uniqueness typing for another time. Interestingly, continuations are useful for many things other than enforcing a particular order
of evaluation.

When we learned about functions we only learned half truths based on a faulty assumption that functions must return their
value to the original caller. In this sense continuations are a generalization of functions. A function must not necessarily return to
its caller and may return to any part of the program. A "continuation" is a parameter we may choose to pass to our function that
specifies where the function should return.

The function add returns 15 to be assigned to i, the place where add was originally called.
After that the value of i is used to call square. Note that a lazy compiler can't rearrange these lines of
code because the second line depends on successful evaluation of the first. We can rewrite this code block using Continuation
Passing Style or CPS, where the function add doesn't return to the original caller but instead returns its result to
square.

square

In this case add gets another parameter - a function that add must call with its result upon completion.
In this case square is a continuation of add.

Here lays the first trick to force a lazy language to evaluate two expressions in order.

The two lines don't depend on each other and the compiler is free to rearrange them as it wishes. However, if we rewrite this
code in CPS, there will be a dependency and the compiler will be forced to evaluate the two lines in order!

System.in.readLine

In this case println needs to call readLine with its result and return the result of readLine. This
allows us to ensure that the two lines are executed in order and that readLine is evaluated at all (because the
whole computation expects the last value as a result). In case of Java println returns void
but if it were to return an abstract value (that readLine would accept), we'd solve our problem!

Of course chaining
function calls like that will quickly become unreadable, but it isn't necessary. We could add syntactic sugar to the language that
will allow us to simply type expressions in order, and the compiler would chain the calls for us automatically. We can now
evaluate expressions in any order we wish without losing any of the benefits of FP (including the ability to reason about our
programs mathematically)!

we've only scratched the surface of continuations and their usefulness

treating functions as special cases of continuations (functions that always return to their caller)

Once we convert a program to CPS it becomes clear that every instruction has some continuation, a function it will call with the result,
which in a regular program would be a place it must return to.

If you try to write a compiler for it and think about it long
enough you'll realize that the CPS version needs no stack! No function ever "returns" in the traditional sense, it just calls another
function with the result instead. We don't need to push function arguments on the stack with every call and then pop them back, we can
simply store them in some block of memory and use a jump instruction instead. We'll never need the original arguments - they'll never
be used again since no function ever returns!

So, programs written in CPS style have no stack but have an extra argument with a function to call. Programs not written in CPS
style have no argument with a function to call, but have the stack instead. What does the stack contain? Simply the arguments, and a
pointer to memory where the function should return. Do you see a light bulb? The stack simply contains continuation information! The
pointer to the return instruction in the stack is essentially the same thing as the function to call in CPS programs! If you wanted to find out what
continuation for add(5, 10) is, you'd simply have to examine the stack at the point of its execution!

A continuation and a pointer to the return instruction in the stack are really the same thing, only a continuation
is passed explicitly, so that it doesn't need to be the same place where the function was called from.

This means that at any given point in time in your program you can ask for a current continuation
(which is simply the information on the stack).

Ok, so we know what a current continuation is. What does it mean? When we get a current continuation and store it somewhere, we end up
storing the current state of our program - freezing it in time. This is similar to an OS putting itself into hibernation. A continuation
object contains the information necessary to restart the program from the point where the continuation object was acquired. An operating
system does this to your program all the time when it context switches between the threads. The only difference is that it keeps all
the control. If you ask for a continuation object (in Scheme this is done by calling call-with-current-continuation function)
you'll get an object that contains the current continuation - the stack (or in a CPS case the function to call next). You can store this
object in a variable (or alternatively, on disk). When you choose to "restart" your program with this continuation object you will
"transform" to the state of the program when you grabbed the continuation object. It's the same thing as switching back to a suspended
thread or waking up an OS from hibernation, except you can do it again and again. When an OS wakes up, the hibernation information is
destroyed. If it wasn't, you'd be able to wake up from the same point over and over again, almost like going back in time. You have
that control with continuations!

In what situations are continuations useful? Usually when you're trying to simulate state in an application of inherently stateless
nature to ease your life. A great application of continuations are web applications.

If C#
supported continuations half of ASP.NET's complexity would disappear - you'd simply store a continuation and restart it when a user
makes the web request again. To a programmer of the web application there would be no interruption - the program would simply start
from the next line!

continuations will become more and more important in the future

Pattern matching is not a new or innovative feature. In fact, it has little to do with functional programming. The only
reason why it's usually attributed to FP is that functional languages have had pattern matching for some time, while modern imperative
languages still don't.

What's the difference? The compiler implements branching for us.

Someone noticed that a large number of functions contain very complicated switch statements
(this is particularly true about functional programs) and decided that it's a good idea to abstract that away. We split the function
definition into multiple ones, and put patterns in place of some arguments (sort of like overloading). When the function is called, the
compiler compares the arguments with the definitions at runtime, and picks the correct one. This is usually done by picking the most
specific definition available. For example, int fib(int n) can be called with n equal to 1, but it isn't
because int fib(1) is more specific.

Every time you have a complex structure of nested ifs,
pattern matching can do a better job with less code on your part.

Usually a pattern matching system can
examine collections as well as simple values. For example, if you pass an array to your function you could pick out all arrays in which
the first element is equal to 1 and the third element is greater than 3.

Another benefit of pattern matching is that if you need to add or modify conditions, you don't have to go into one huge function.
You simply add (or modify) appropriate definitions. This eliminates the need for a whole range of design patterns from the GoF book.
The more complex your conditions are, the more pattern matching will help you. Once you're used to it, you
start wondering how you ever got through your day without it.

So far we've discussed features in the context of "pure" functional languages -
languages that are implementations of lambda calculus and don't include features
that conflict with Church's formalism. However, many of the features of functional
languages are useful outside of lambda calculus framework.

Passing functions
around in impure languages is a little bit different than doing it in the confines
of lambda calculus and requires support for an interesting feature often referred
to as lexical closure.

The first observation is that
local variables are no longer limited to simple scope rules and have
an undefined lifetime. The obvious conclusion is that they're no
longer stored on the stack - they must be stored on the heap instead⁸.
A closure, then, is implemented just like a function we discussed
earlier, except that it has an additional reference to the surrounding
variables: