New slides about Go

[retard]

Tue, 19 Oct 2010 21:30:44 +0100, div0 wrote:

> On 19/10/2010 21:24, Paulo Pinto wrote:
>> Am 18.10.2010 22:49, schrieb bearophile:
>>> Nick Sabalausky:
>>>
>>>> It's amazing how many software houses/departments don't do that. But
>>>> of course, if they don't it's their own damn problem.
>>>
>>> They want low-salary programmers, so they will avoid languages that
>>> may lead to higher salaries. This means uncommon languages (where
>>> programmers are more rare) or languages that may need the ability to
>>> read (or even write) "harder code" (like inline assembly).
>>>
>>> Bye,
>>> bearophile
>>
>> This is one of the reasons why Java has become such a huge language in
>> the IT world.
> 
> yeah but to be fair, I work in a fully C++ shop and only 3 (maybe 4) of
> us out of 18 will *ever* write template code.
> 
> even for really trival stuff.
> 
> In my xp, most c++ programmers just don't/can't get templates and I very
> much doubt that awkward syntax is the root cause.
> 
> if you are one of those people why whould you chose a language with
> templates? they are off no dam use to you.

Templates are used for at least two different purposes - to provide 1) 
(generic) parametric polymorphism and 2) (generative) metaprogramming 
code. Often the parametric version is enough (e.g. simple uses of 
collections).

The first case is "optimized" in many modern language. For instance in 
Scala polymorphic collections are rather simple to use:

// using namespace std;

val l = List(1,2,3)
// list<int> l(1,2,3);

println("The contents are: ")
// cout << "The contents are: ";

println(l.mkString(" "))
//  for (list<int>::iterator it = l.begin(); it != l.end(); it++)
//    cout << *it << " ";
//  cout << endl;

println("Squared: ")
// cout << "Squared: ";

println(l.map(2 *).mkString(" "))
//  for (list<int>::iterator it = l.begin(); it != l.end(); it++)
//    cout << (*it)*(*it) << " ";
//  cout << endl;

Typical use cases don't require type annotations anywhere. The only 
problem with high level languages is that they may in some cases put more 
pressure to the optimizations in the compiler.

What's funny is that the Scala developer here "implicitly" used terribly 
complex templates behind the scenes. And it's as simple as writing in 
some toy language.

Overall, even the novice developers are so expensive that you can often 
replace the lost effiency with bigger hardware, which is cheaper than the 
extra development time would have been. This is many times the situation 
*now*, it might change when the large cloud servers run out of resources.