История изменений
Исправление den73, (текущая версия) :
Всегда ржу над такими темами и мудрыми комментариями. В Паскале это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
interface
...
implementation uses a;
...
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс и переменная, содержащая экземпляр интерфейса, а в модуле B - реализация интерфейса и инициализация переменной, находящейся в модуле A. Вроде как всё красиво и как будто бы A не зависит от B, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит, и для выражения этого не нужно плодить лишних сущностей. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза, или от чтения этого указателя до его заполнения чем надо.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскале это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
interface
...
implementation uses a;
...
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс и переменная, содержащая экземпляр интерфейса, а в модуле B - реализация интерфейса и инициализация переменной, находящейся в модуле A. Вроде как всё красиво и как будто бы A не зависит от B, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза, или от чтения этого указателя до его заполнения чем надо.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскале это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
interface
...
implementation uses a;
...
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс и переменная, содержащая экземпляр интерфейса, а в модуле B - реализация интерфейса и инициализация переменной, находящейся в модуле A. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза, или от чтения этого указателя до его заполнения чем надо.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскале это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
interface
...
implementation uses a;
...
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза, или от чтения этого указателя до его заполнения чем надо.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскале это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза, или от чтения этого указателя до его заполнения чем надо.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза, или от чтения этого указателя до его заполнения чем надо.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей. Кроме того, в таком способе нет защиты, например, от того, чтобы этот указатель был назначен 0 раз или более одного раза.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B. И до момента, когда мы нашли место инициализации указателя, мы вообще не можем понять иерархию модулей.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
end.
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Ещё более плохой способ реализации - это когда есть указатель на функцию в модуле A, который инициализируется в модуле B. При этом уже нужно изучать не структуру кода, а порядок его выполнения, чтобы определить наличие циклической взаимосвязи между A и B.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Притом, в Паскале чётко написано, кто от кого и как зависит. А в «правильных языках», у тебя есть интерфейс в модуле A, а кто и как его воплощает - неизвестно без знания процесса сборки и загрузки. Т.е. вместо того, чтобы создать инструмент, отражающий реальность, запретили эту реальность и потом выразили её эзоповым языком.
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
Но потом люди придумали BDSM и заставили всех им заниматься. В реальности, взаимозависимые подсистемы встречаются сплошь и рядом. В языках, где их как бы нет, это решается с помощью разных костылей, например, в модуле A объявляется интерфейс, а в модуле B - реализация. Вроде как всё красиво, но в реальности оба модуля зависят друг от друга и до загрузки модуля B модуль A всё равно работать не будет. Но лицемерие побеждает :)
Исправление den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
module a;
interface uses b;
...
implementation
...
end.
module b;
implementation uses a;
Но потом люди придумали BDSM и заставили всех им заниматься.
Исходная версия den73, :
Всегда ржу над такими темами и мудрыми комментариями. В Паскле это делается так:
[code] module a; interface uses b; … implementation … end.
module b; implementation uses a; [/code]