juan_gandhi: (Default)
Juan-Carlos Gandhi ([personal profile] juan_gandhi) wrote2008-05-14 12:56 pm

dynamic vs static

Я не собираюсь вступать в эту нонешнюю дискуссию. Просто хочу заметить, что речь идёт о "гарвардской архитектуре" супротив "архитектуры фон Неймана".

В первой данные отделены от кода, и задача программиста состоит в том, чтобы состыковать, хоть и через посредников, данные и код, который их обрабатывает; вот и приходится катать всякие конфигурации, эксэмэли, ентити бинзы; всё для того, чтобы уберечь код от данных. Тогда код можно статически проверить и отлить в бронзе. Чтоб не сломался.

Во второй что данные, что код, без разницы; код - это вид данных, а данные могут на определённом уровне интерпретироваться как код, или строить код, который эти данные сынтепретирует (как, помню, была какая-то база, которая строила классы для доступа прямо при открытии таблицы: взял таблицу - вот и классы загрузились; естественно, что динамически.

Ну а так, наверное, стоит почитать, конечно: Егге устраивает разгром в столице статической типизации
nine_k: A stream of colors expanding from brain (Default)

[personal profile] nine_k 2008-05-18 06:49 pm (UTC)(link)
Не вижу, что в этом удивительного. Всё вполне предсказуемо и не противоречит идее, что import есть оператор, исполнимый в runtime. Более того, код типа
try:
  import x.y.z as X
except ImportError:
  import a.b.c as X
тоже вполне себе широко используется для обеспечения version compatibility.

Чудное открытие становится сделать легче, если дважды подряд позвать import b. Функция импорта умная и кэширует импортированные модули, а повторно импорт того же самого не исполняет (что кажется естественным). Потому и в вашем примере, кстати, не возникает бесконечной рекурсии импорта.

[identity profile] faceted-jacinth.livejournal.com 2008-05-18 07:08 pm (UTC)(link)
Вы опять наступаете на те же грабли. Если я показываю кусок кода и говорю "Зацените", это означает, что, скорее всего, нужно его скормить интерпретатору. Ну, если мы оба вроде понимаем язык, то есть когда я показываю код, я имею в виду, что его исполнение даст результат, отличный от ожидаемого. От того, который вы получили, исполнив код на своём внутримозговом интерпретаторе питона. Потому что я как раз утверждаю, что ваш внутренний интерпретатор неправильно работает.

Ну вот и тут. Реально получаемый результат весьма забавен и заставляет задуматься о том, что же всё-таки кэшируется и как это всё работает.
nine_k: A stream of colors expanding from brain (Default)

[personal profile] nine_k 2008-05-18 07:43 pm (UTC)(link)
Почтеннейший, не надо думать обо мне так плохо. Разумеется, я скормил интерпретатору предложенный вам кусок, и только затем взялся писать объяснения.

Не вижу, где получается результат, отличный от ожидаемого.
$ python
Python 2.4.5 (#2, Apr 17 2008, 13:00:52) 
[GCC 4.2.3 (Debian 4.2.3-3)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import b
a
b
>>> _

Мы видим, как сначала исполнился импорт модуля a, идущий первой строчкой в модуле b. Он (a) занялся импортом модуля b. Но так как мы прямо вот сейчас уже заняты импортом модуля b, повторно (рекурсивно) его импортировать не надо. Осталось напечатать "a". На этом импорт модуля a завершился, и продолжился импорт (т.е исполнение) модуля b; исполнилась его вторая строчка, напечатавшая "b".

Не вижу, что тут неинтуитивного.

Второй пример разобрать? :) Или что я упускаю?

[identity profile] faceted-jacinth.livejournal.com 2008-05-18 07:46 pm (UTC)(link)
да, именно второй. Очень интересно послушать, потому что я сам этого не понимаю.
nine_k: A stream of colors expanding from brain (Default)

[personal profile] nine_k 2008-05-18 08:34 pm (UTC)(link)
Всегда пожалуйста.

$ python b.py
b
a
b
$ _
Картина та же самая. Будем писать имя файла и строку с комментарием.
b.py:1 — import a, поехали исполнять a.py и записали себе что импортируем a.
a.py:1 — import b, поехали исполнять b.py, ведь мы ни разу не пробовали его импортировать.
b.py:1 — import a, но у нас записано, что мы уже исполняем импорт a, потому второй раз не надо, едем дальше
b.py:2 — print "b", напечатали на экране первое "b".
Тут кончился b.py, который мы исполняли по просьбе import b из a.py, едем по нему дальше.
a.py:2 — print "a", напечатали "a".
Тут кончился a.py, который мы звали по просьбе import a, продолжился b.py, который мы звали из командной строки.
b.py:2 — print "b", напечатали вторую "b".
Тут кончился самый внешний b.py, сказочке конец, интерпретатор вышел.

Как-то так я себе это представляю. Может быть, я где-то серьёзно ошибаюсь, я ещё пороюсь в этом (тем более, надо по работе), но по крайней мере мне моя версия кажется правдоподобной :)