• HTML: http://conceptoriented.com/papers/CopInformalIntroduction-ru.html
  
• PDF: http://conceptoriented.com/papers/CopInformalIntroduction-ru.pdf

• HTML: http://conceptoriented.com/papers/csjm_05/csjm05.html
  
• PDF: http://conceptoriented.com/savinov/publicat/csjm_05.pdf
  
• PS: http://conceptoriented.com/savinov/publicat/csjm_05.ps

Определение собственного формата ссылок, который далее приписывается для использования разными целевыми классами объектов с сохранением прозрачности доступа.

myAccount.getBalance()

V>>Может быть, Виндовс совсем бы не глючил и не тормозил, если бы он был написан с использованием опосредованного доступа к объектам Может быть, возможность "вклиниться" в оператор разыменования — это именно то, чего мне так не хватало?

    Set xls = CreateObject("Excel.Application")
    wb = xls.Workbooks.Open "C:\MyFile.xls"

myAccount.getBalance()

1. Невозможно описать свой формат ссылок. Вы можете описать промежуточный объект, который является объектом, а не ссылкой, а потому сам имеет какую-то ссылку и с ним возникают те же проблемы, что и с обычными объектами.
   
2. Прокси заточен под целевой класс, т.е. он явно о нем знает и не может без него существовать. Т.е. первым мы разрабатываем целевой класс (поскольку ему не нужен прокси -- он о нем ничего не знает), а потом уже прокси. Одно очень паршивое следствие состоит в том, что при каждом изменении целевого класса необходимо следить за прокси (откуда ошибки).
   
3. Нельзя использовать один прокси для многих целевых классов. Например, мы хотим разработать прокси ProxyForMarsObjects, а затем использовать его для доступа к объектам на Марсе, имеющих самый разный класс, который заранее не известен. Как это сделать? Я такого способа не знаю. Если знаете, то опишите, пожалуйста (а также см. п.1).
   
4. Ну и в программе мы хотим использовать непосредственно целевые объекты, например, myAccount.getBalance(), тогда как в прокси мы вынуждены работать с посредником: myAccountProxy.getBalance(). Чувствуете разницу? Я ведь знать не хочу сколько и какие там есть посредники. Я хочу иметь ссылку на счет и получить баланс. А прокси предлагает мне использовать какой-то другой объект. А вдруг в будущем этот счет будет представляться по-другому? Тогда в прокси-варианте я должен буду по всей программе поменять MarsProxy на LunaProxy. А в КОП я всегда работаю с целевым классов независимо от способа представления.

Lock(memHandle); 
mem =Resolve(memHandle);
mem->myMethod(); 
Unlock(memHandle);

memHandle->myMethod();

V>До сих пор я думал, что вся программа — это алгоритмы и структуры данных (с) Н.Вирт

myAccount.getBalance();

V>>>Может быть, Виндовс совсем бы не глючил и не тормозил, если бы он был написан с использованием опосредованного доступа к объектам Может быть, возможность "вклиниться" в оператор разыменования — это именно то, чего мне так не хватало?

V>    Set xls = CreateObject("Excel.Application")
V>    wb = xls.Workbooks.Open "C:\MyFile.xls"
V>

V>И всем (и особенно мне) от этого ХОРОШО

S>memHandle->myMethod(); 
S>

memHandle.SetRef(MyWonderfulOID);

CCustomer *memHandle = new CCustomer(MyWonderfulOID); // При инициализации полезет в БД и вытащит кустомера в память
memHandle->myMethod(); // Сделает с кустомером что-то

V>>До сих пор я думал, что вся программа — это алгоритмы и структуры данных (с) Н.Вирт

S>Так можно до Аристотеля добраться Почему бы не определить программу на компьютере как организованный набор атомов? Общее определение – зато никто не докопается.

V>>    Set xls = CreateObject("Excel.Application")
V>>    wb = xls.Workbooks.Open "C:\MyFile.xls"
V>>

V>>И всем (и особенно мне) от этого ХОРОШО

S>Остается только описать суть решения, а то на слово как-то не верится. А то потом окажется, что это вовсе не SQL-сервер был, да и не на Дельфи написано было

class MyObject
{
    public int Id;
    ...
}
interface IDataLayer
{
    MyObject GetMyObject(int id);
}

class SQLDataLayer : IDataLayer
{
    public MyObject GetMyObject(int id)
    {
        ...
    }
    public bool IsAvailable
    {
        get { ... }
    }
}

class DBFDataLayer : IDataLayer
{
    public MyObject GetMyObject(int id)
    {
        ...
    }
}

class SelectiveDataLayer : IDataLayer
{
    readonly SQLDataLayer m_SQLDataLayer;
    readonly DBFDataLayer m_DBFDataLayer;
    public SelectiveDataLayer(SQLDataLayer _SQLDataLayer, DBFDataLayer _DBFDataLayer)
    {
        m_SQLDataLayer = _SQLDataLayer;
        m_DBFDataLayer = _DBFDataLayer;
    }
    
    IDataLayer DataLayer
    {
        get
        {
            if (m_SQLDataLayer.IsAvailable)
                return m_SQLDataLayer;
            else
                return m_DBFDataLayer;
        }
    }
    public MyObject GetMyObject(int id)
    {
        return DataLayer.GetMyObject(id);
    }
}

[Record]
[InterfaceImpl(IDataLayer, DataLayer)]
class SelectiveDataLayer : IDataLayer
{
    m_SQLDataLayer : SQLDataLayer;
    m_DBFDataLayer : DBFDataLayer;
    DataLayer : IDataLayer
    {
        get
        {
            if (m_SQLDataLayer.IsAvailable)
                m_SQLDataLayer;
            else
                m_DBFDataLayer;
        }
    }
}

(!) Кстати, с этой точки зрения твой подход ждет успех. 
Нужно лишь отказаться от ключевого слова "концепт" как
 ключевого слова языка, найти уже имеющиеся элементы 
твоего подхода в других языках, опубликовать и 
популяризовать решения, обеспечивающие поддержку 
концептов в языках, и ярко-ярко вспыхнуть в новостях!

#-*- encoding: cp1251 -*-
#Пример использования:
>>> rgb = RGB( 100, 192, 240 )
>>> rgb.Red()
100
>>> proxy = Proxy( rgb )
>>> proxy.Green()
192
>>> noblue = NoBlueProxy( rgb )
>>> noblue.Green()
192
>>> noblue.Blue()
0

#Сам код:
class Proxy:
    def __init__( self, subject ):
        self.__subject = subject
    def __getattr__( self, name ):
        return getattr( self.__subject, name )      

#Figure 11. Proxy base class

class RGB:
    def __init__( self, red, green, blue ):
        self.__red = red
        self.__green = green
        self.__blue = blue
    def Red( self ):
        return self.__red
    def Green( self ):
        return self.__green
    def Blue( self ):
        return self.__blue    

#Figure 12. Subject class

class NoBlueProxy( Proxy ):
    def Blue( self ):
        return 0    

P.S. Графоманские комментарии - мои.

>>> proxy = Proxy( rgb )
>>> proxy.Green()

>>> rgb = RGB( 100, 192, 240 )
>>> rgb.Red()

>>> proxy = Proxy( rgb )
>>> proxy.Green()

reference {
  String compName;
  int port;
  int objectId;
}

  Customer cust = new Customer(); 
  Account acc = new Account(cust); 
  double acc.setBalance(1000);
}

1. традициооные прокси (замещающие объекты), и
   
2. КОП

>>>>> rgb = RGB( 100, 192, 240 )
>>>>> rgb.Red()
S>>

>>>>> proxy = Proxy( rgb )
>>>>> proxy.Green()
S>>

S>>reference {
S>>  String compName;
S>>  int port;
S>>  int objectId;
S>>}
S>>

S>>  Customer cust = new Customer(); 
S>>  Account acc = new Account(cust); 
S>>  double acc.setBalance(1000);
S>>}
S>>

>>>> proxy = Proxy( rgb )
>>>> proxy.Green()
S>

>>>> rgb = RGB( 100, 192, 240 )
>>>> rgb.Red()
S>

 RGBProxy = lambda *args, **kw: Proxy (RGB(*args, **kw))

 
class Proxy:
    def __init__( self, subject ):
        self.__subject = subject
    def __getattr__( self, name ):
        print "proxying ;)"
        return getattr( self.__subject, name )  

RGBWithoutProxy = RGB
RGB = lambda *args, **kw: Proxy (RGBWithoutProxy(*args, **kw))

rgb = RGB( 100, 192, 240 )
print rgb.Red()

>>>> proxy = Proxy( rgb )
>>>> proxy.Green()
S>

S>Вот тогда как раз было бы уже нечего обсуждать — все и так было бы ясно. Но в целом я согласен конечно, что нужны хорошие примеры. Но поскльку дисер мне не нужен, деньги тоже на этом не заработаешь, то и заниматься рутиной (что и так очевидно) мне нет охоты. Поэтому если все это не совсем ясно, или совсем не ясно, то я вполне могу понять, но изменить ничего не могу. Кроме того, я уверен, что даже пары хороших примеров будет недостаточно, поскольку это связано с религиозными воззрениями граждан, которые так просто не изменить. Так что пусть будет как будет. Пусть КОП сам пробивает себе дорогу в жизнь

На консилиуме ученых и военных...
Входит в кабинет секритарша и гворит:
— Тут к вам рвется какой-то товарищь... я его сдержать немогу, говоит что дело государственной важности...
— Ну, что же впустите.
— Здравствуйте! Я изобретатель! Дайте рассказать про свою идею.
— Ну, что же говорите, раз все равно ворвались.
— Значичь идея такова... Вражеские самалеты подетаютк к нашей границе и вдруг переворачиваются и падают. Здорово?!
— Здорово! И как же это все работеат?!
— Не, ну, вы же ученые? Вам и думать как реализовать. А мое дело идею предложить!!!

Приходят зайцы к мудрой сове с просьбой:
— Нас едят орлы, волки и лисы. Расскажи, что сделать?
— Ну.. Станьте ежиками.
— А как?
— Не знаю, я стратег, а не тактик.

 RGBProxy = lambda *args, **kw: Proxy (RGB(*args, **kw))

 
B>>class Proxy:
B>>    def __init__( self, subject ):
B>>        self.__subject = subject
B>>    def __getattr__( self, name ):
B>>        print "proxying ;)"
B>>        return getattr( self.__subject, name )  

B>>RGBWithoutProxy = RGB
B>>RGB = lambda *args, **kw: Proxy (RGBWithoutProxy(*args, **kw))

B>>rgb = RGB( 100, 192, 240 )
B>>print rgb.Red()
B>>

class AbstractConcept:
    def __init__(self, propagate=True):
        self.propagate=propagate
    def accept(self, object): #which objects should be wrapped
        return type(object) is DOMNode
    def adapt(self, object):
        #навешивает адаптер
        return adapted_object
    def __methodhook__(self, object, method, *args, **kw):
        if self.propagate: 
            adapt_args = map(self.adapt, args)
            adapt_kw = adaptDict(self.adapt, kw)
            return getattr(object, method).__call__(adapt_args, adapt_kw)
        else:
            
            
class MethodHookConcept(AbstractConcept):
    def __init__(self, hooker):
        AbstractConcept.__init__(self, True)
        self.hooker = hooker
    def adapt(self, object):
        AbstractConcept.adapt(self)
    def __methodhook__(self, object, method, *args, **kw):
        AbstractConcept.
        hooker.pre(object, method, *args, **kw)  #пре-хук на вызов метода
        result = AbstractConcept.__methodhook(self, object, method, *args, **kw)
        hooker.post(object, method, result) #пост-хук на вызов метода
        return result

concept = AOPConcept(hooker)
rgb = concept.adapt(htmlDocument)

>>>>>> proxy = Proxy( rgb )
>>>>>> proxy.Green()
S>>>

Objects that reside in a context and are bound to the context rules are called context-bound objects. A context is a set of properties or usage rules that define an environment where a collection of objects resides. The rules are enforced when the objects are entering or leaving a context. Objects that are not context-bound are called agile objects.

AVK>>Так что твое счастье уже осуществилось

S>К сожалению, нет

emp->Salary += ConvertMoney(increase, new Currency("USD"), emp->SalaryCurrency);

emp->Salary += increase;

emp.Salary += Money(increase, new Currency("USD"));

length l=cm(2.54);
length l2=inch(1);
assert(l==l2);

force f=1;
acceleration a=1;
mass m=1;
assert(f==m*a);
//А вот так будет ошибка компиляции.
assert(f==m);

C>length l=cm(2.54);
C>length l2=inch(1);
C>assert(l==l2);

Вновь предложенный механизм можно реализовать так-то. И это будет проще, поскольку такие средства уже имеются и изучены, а для предложенного механизма еще нет.

• Прокси это ширма объекта.
  
• КОП это подход к созданию виртуальной системы доступа к объектам.

AVK>>Так что твое счастье уже осуществилось

• Прокси как ширма объекта, которая реализуется с помощью другого объекта.
  
• Реализация различных "приятностей" на уровне той или иной платформы, например, динамических и прозрачных прокси, удаленных методов, контекстов и др. механизмов.

АХ>Про Nemerle я вообще молчу .

АХ>>>Про Nemerle я вообще молчу .

S>>Вы хотите сказать, что Немерле есть средства описания ссылок? Если нет, тогда это просто проявление эрудиции, а КОП это прост повод.

• объект хранит идентификатор.
  
• для доступа к объекту определяется стандартный интерфейс с методом, который по id возвращает ссылку
  
• метод реализуется в центральном пункте доступа, где собственно решается, откуда его вынуть

• Объект хранит свой идентификатор. Это не просто недостаток — это приговор. Пример, как делать не надо (антипаттерн). Средства идентификации и доступа нельзя совмещать с основной бизнес-логикой. Но в ООП обычно другого выхода нет.
  
• В программе мы получаем ссылку на объект путем разрешения идентификатора. Это тоже антипаттерн, причем имеющий фундаментальное значение. Получать разрешенную ссылку нельзя. Это очень небезопасно. По той же причине, почему агенты спец.служб используют клички, а по записи в БД вы никогда не получите адрес в памяти. Такой подход работает только в игрушечных системах.
  
• Так и не определен нужный формат ссылки.
  
• Мы не можем просто применить метод к идентификатору и получить результат.