The Differences Between Kernighan, Ritchie, and Thompson
I read,

Looks like folks are now beginning to credit the development of UNIX to Kernighan and Ritchie, but I thought the principal investigators were *Thompson* and Ritchie. Did something change?
The differences between Kernighan Ritchie Thompson are real but very subtle. We all look alike (middle aged with scruffy graying beards). Note these distinctions:

Kernighan is slimmest, Ritchie middlest, Thompson heaviest in body build
Ritchie got contacts a couple of years ago and so is the only current non-glasses wearer
Thompson wouldn't touch netnews with a pole, Kernighan secretly gets misc.invest and misc.taxes mailed to him, Ritchie reads it more than is good for him and occasionally contributes
Ritchie is the only one who has met five people who have appeared on David Letterman (Penn, Teller, Rob Pike, Mayor Koch, and the guy who raised the biggest hog in Ohio)
Kernighan has written ten times as much readable prose as has Ritchie, Ritchie ten times as much as Thompson. It's tempting to say that the reverse proportions hold for code, but in fact Kernighan and Ritchie are more nearly tied and Thompson wipes us both out.
Dennis

--------------------------------------------------------------------------------

4 March 1991 / dmr@alice.att.com (Dennis Ritchie)
Back to Humor Index

"Многие вещи нам непонятны не потому, что наши понятия слабы; но потому, что сии вещи не входят в круг наших понятий "

Если вы все такие умные, чего же вы строем не ходите?

> ПК>std::vector<int> v( 10 );
> ПК>for (std::vector<int>::iterator i = v.begin(), e = v.end(); i != e; ++i)
> ПК>   *i = e - i;
> ПК>

Metaprogramming is the writing of programs that write or manipulate other programs (or themselves) as their data or that do part of the work that is otherwise done at runtime during compile time.

• writing of programs that write other programs (or themselves)
  
• writing of programs that manipulate other programs (or themselves) as their data
  
• writing of programs that do part of the work that is otherwise done at runtime during compile time

template<class T>
Vector3<T> operator *( Vector3<T> const& v, T const& s )
{
   return Vector3<T>( v1.x * s, v1.y * s, v1.z * s );
}

> Значит операторы уже мовитон?

>>>         return (Adder<T>)Delegate.CreateDelegate(
>>>                 typeof(Adder<T>), typeof(T), "op_Addition");
> ПК>

Metaprogramming is the writing of programs that write or manipulate other programs (or themselves) as their data or that do part of the work that is otherwise done at runtime during compile time. This allows programmers to produce a larger amount of code and get more done in the same amount of time as they would take to write all the code manually.

In computer science, generics is a technique that allows one value to take different datatypes (so-called polymorphism) as long as certain contracts such as subtypes and signature are kept. The programming style emphasizing use of this technique is called generic programming.

template<class ValueT, class Order, int Shift> class pixel_formats_rgba
{
   enum { Shift2 = Shift * 2 };
   . . .
            do
            {
               p[Order::R] = (ValueT)((((c.r - r) * alpha) + (r << Shift2)) >> Shift2);
               p[Order::G] = (ValueT)((((c.g - g) * alpha) + (g << Shift2)) >> Shift2);
               p[Order::B] = (ValueT)((((c.b - b) * alpha) + (b << Shift2)) >> Shift2);
               p[Order::A] = (ValueT)(((alpha + (a << Shift)) - ((alpha * Shift) >> 8)) >> 8);
               p += 4;
            }
            while(--len);
   . . .
};

VD>Дык, не ты ли говорил, что если что мы по бырому генератор кода сварганим?

VD>О как. А значит препроцессор у нас религия для Явы или Шарпа запрещает использовать?

template<int N> void copy(. . .)
{
   repeat<N> { *p++ = *s++; }
}

ПК>template<class T>
ПК>static T Add(T x, T y) { return x + y; }
ПК>

    static Adder<T> GetAdditionOperator<T>()
    {
        return (Adder<T>)Delegate.CreateDelegate(
            typeof(Adder<T>), typeof(T), "op_Addition");
    }
    ...
    TimeSpan timeSpanValue = Accumulate<TimeSpan>(
    GetAdditionOperator<TimeSpan>(),
    new TimeSpan[]
    {
        new TimeSpan(10, 0, 0), new TimeSpan(10000),
        new TimeSpan(1, 12, 10), new TimeSpan(20000)
    });
    Console.WriteLine("timeSpanValue is " + timeSpanValue);

Xxx(delegate(int i) { return new Yyy(i) });

std::vector<int> v( 10 );
for (std::vector<int>::iterator i = v.begin(), e = v.end(); i != e; ++i)
   *i = e - i;

Object obj = __box(123);

template<int N> void copy(. . .)
{
   repeat<N> { *p++ = *s++ }
}

/* Sum() */ 

template <class T,class Ptr>
void T Sum(Ptr ptr,Ptr lim)
 {
  T ret=T();
  
  for(; ptr!=lim ;++ptr) ret+=(*ptr);
  
  return ret;
 }
 
/* struct NodeList<T> */  

template <class T>
struct NodeList
 {
  NodeList<T> *next;
  T object;
 };
 
/* struct ListPtr<T> */  

template <class T>
struct ListPtr
 {
  NodeList<T> *ptr;
  
  void operator ++ () { ptr=ptr->next; }
  
  const T & operator * () const { return ptr->object; }
 };
 
/* main() */ 

int main()
 {
  ...
  
  int *ptr1=...,*lim1=...;
  
  Sum<int>(ptr1,lim1);
  
  ...
  
  ListPtr<int> ptr2=...,lim2=...;
  
  Sum<int>(ptr2,lim2);
  
  ...
 
  return 0;
 }

public abstract class BizEntity<IdentiferType> 
         where IdentiferType : struct, IComparable<IdentiferType>
{
  //...
  // По сути всё, что внешний мир должен о нём знать
  public IdentiferType EntityID {
    get {
    }
  }
  //...
}

public class BizEntityManager<IdentiferType> where IdentiferType : struct, IComparable<IdentiferType>
{
  //...

  E Load<E, IdentiferType>(IdentiferType ID) 
                 where E : BizEntity<IdentiferType>
                 where IdentiferType : struct, IComparable<IdentiferType>
  {
  }

  //...
}

using constraint IdentiferTypeC = struct, IComparable<IdentiferType>

public abstract class BizEntity<IdentiferType> where IdentiferType : IdentiferTypeC
{
  //...
  // По сути всё, что внешний мир должен о нём знать
  public IdentiferType EntityID {
    get {
    }
  }
  //...
}

ПК>std::vector<int> v( 10 );
ПК>for (std::vector<int>::iterator i = v.begin(), e = v.end(); i != e; ++i)
ПК>   *i = e - i;
ПК>

public interface IEnumerator
{
    bool MoveNext();
    object Current { get; }
    void Reset();
}

public interface IEnumerator<T> : IDisposable, IEnumerator
{
    T Current { get; }
}

...

int sum = 0;

foreach (int elem in new int[]{ 2, 3, 5, 7, 9 })
    sum += elem;

int[] array = new int[] { 2, 4, 5, 8 };
int sum = 0;
Array.ForEach(array, delegate(int elem) { sum += elem; })

using System;
using System.Collections.Generic;

class Program
{
    delegate T Adder<T>(T x, T y);

    static T Sum<T>(Adder<T> adder, IEnumerable<T> list)
    {
        return Sum<T>(adder, list, default(T));
    }

    static T Sum<T>(Adder<T> adder, IEnumerable<T> list, T init)
    {
        T value = default(T);
        foreach (T elem in list)
            value = adder(value, elem);

        return value;
    }

    // Реализация абстрактных операций для целых и временных
    // отрезков. Для строк ничего писать не нужно, так как можно воспользоваться
    // функцией string.Concat. Заметь! Статической. :)
    static int IntAdd(int x, int y) { return x + y; }
    static TimeSpan TimeSpanAdd(TimeSpan x, TimeSpan y) { return x + y; }

    static void Main()
    {
        // Сумируем целые.
        int intValue = Sum<int>(IntAdd, new int[] { 1, 3, 5, 7, 8, 9 });
        Console.WriteLine("intValue is " + intValue);

        // Сумируем временные промежутки.
        TimeSpan timeSpanValue = Sum<TimeSpan>(
            TimeSpanAdd,
            new TimeSpan[]
            {
                new TimeSpan(10, 0, 0), new TimeSpan(10000),
                new TimeSpan(1, 12, 10), new TimeSpan(20000)
            });
        Console.WriteLine("timeSpanValue is " + timeSpanValue);

        // Сумируем строки. Кстати, функция уже есть, так что писать ее не нужно.
        string strValue = Sum<string>(
            string.Concat, 
            new string[] { "the ", "power ", "of ", "generic ", "programing! :)" }
            );
        Console.WriteLine("strValue is " + strValue);
    }
}

delegate T ClassMethod<T, X>(int i, string s, X x);

>     static int IntAdd(int x, int y) { return x + y; }
>     static TimeSpan TimeSpanAdd(TimeSpan x, TimeSpan y) { return x + y; }
>

template<class T>
static T Add(T x, T y) { return x + y; }

> delegate T ClassMethod<T, X>(int i, string s, X x);
>

> О как? А я сверху не то же самое сотварил? Нет?

> Ты случаем не обратил внимания на две мелочи? Нет? Такие незаметнинькие...

But in Java (and apparently C#), you can't seem to say "any type."

C# also doesn't support latent typing, and although it has a better generics model than Java (since they went ahead and changed the underlying IL so that, for example, a static field in a class will be different between class and class). So if you want latent typing you'll have to use C++ or D (or Python, Smalltalk, Ruby, etc.).

> 2. Они забыл разобраться в дэенериках.