Вышел Boo 0.9

>Я не представляю джангу на Java

Джава это не язык ;) Я сказал "хорошая декларотивная система". Я даже не имел ввиду языков программирования. Уж тем более, такой неповоротливый как Java.

Для меня в динамической типизации есть один плюс, об остальных можно даже не вспоминать. Плюс очень простой - она позволяет мне за меньшее время писать больше кода с меньшей головной болью. Я знаю, что далеко не каждый кодер сможет вникнуть в это дело и показывать хороший результат. В наш отдел новичков берут на порядок реже, чем в другие отделы, хотя собеседований столько же. Но у нас и текучка меньше.

> А ты сравни Питон с Boo ;)

Ну хорошо. Бу - это питон со статической типизацией, насколько я понял. Зачем она мне - я даже не знаю. Как пятое колесо.

Я бы не сказал, что Scala тянет на язык промышленной разработки, но пусть будет. Может быть там всё шоколадно и статическая типизация только помогает решать проблемы, а не рождает новые. Не знаю, честно. Был бы только рад, если такой язык существует.

> Бу - это питон со статической типизацией, насколько я понял. Зачем она мне - я даже не знаю.

http://www.artima.com/weblogs/viewpost.jsp?thread=86641

<Ъ>

I like many of the reasons for type declarations that were given by various proponents: they can be useful for documentation, for runtime introspection (including adaptation), to help intelligent IDEs do their magic (name completion, find uses, refactoring, etc.), and to help find certain bugs earlier. Indeed, my original motivation was mostly the latter: I've been thinking about integrating the functionality of PyChecker in the core, and I feel that sometimes the type inferencing used there needs a little help. Someone pointed me to a blog entry by Oliver Steele arguing that type declarations are a good tool because they serve several purposes at once reasonably well.

<Ъ>

>декларотивная

Что такое декларОция?

Так в чем конкретно плюс? Что в динамичекой типизации тебе так помогает? В Vala и C# ты тоже можешь не указывать типы: есть ключевое слово var.

var a = new Stuff();

>var a = new Stuff();

В этом конкретном случае типизация может быть статической.

Вот если:

method test(var x) { var y = x.result(); y.print(); }

test(new Stuff());
test(new AnotherStuff());

Тогда _скорее всего_ типизация будет и динамической :)

В динамической типизации можно убрать интерфейсы, - duck typing более гибкий. И методы получаются более полимрофные def min(x, y) : return x if x < y else y

Быстрая, удобная, не порождающая багов разработка достигает немного другими путями. Чем тебе не нравится грамотное проектирование с хорошей документацией? Или если речь зашла об автодополнении и рефакторинге, чем плох PyDev? В последних версиях он дополняет практически всё, что нужно. И эта дополнялка у него основана не на парсинге исходников, поэтому синтаксис, включая объявление переменных и параметров функций, здесь никакой роли не играет.

>а глобально - не нужен. допиливайте лучше F# и Nemerle. А чего жалко что ли? под mono/.net уже такой зоопарк развели, что ещё одним монстром больше ничего не изменит. Наоборот, чем больше дерьма по .net плавает, тем быстрее оно всё фтопку пойдёт.

> достигается

фикс

>а глобально - не нужен. допиливайте лучше F# и Nemerle.

А чего жалко что ли? под mono/.net уже такой зоопарк развели, что ещё одним монстром больше ничего не изменит. Наоборот, чем больше дерьма по .net плавает, тем быстрее оно всё фтопку пойдёт.

>Что такое декларОция?

В моём сегодняшнем кошмаре меня Шома покусал ;)

>Ты даже не понимаешь, что реализовать динамическую типизацию ГОРАЗДО сложнее, чем статическую.

И давно? И где - в изнаночном мире?

Динамическая типизация - это гораздо больше, чем просто возможность не указывать тип при объявлении. Она помогает смещать внимание кодера с деталей на конструкцию в целом. О технической стороне я рассказывать не буду, так как это огромное поле для холивара и откушает у меня кучу времени. Лучше просто не начинать.

> Быстрая, удобная, не порождающая багов разработка достигает немного другими путями.

Она достигается всеми возможными путями, один из них - статическая типизация.

> Чем тебе не нравится грамотное проектирование с хорошей документацией?

Всем нравится. Но причем тут динамическая типизация? Она мало мешает на этапе разработки, но когда начинается переделка/рефакторинг, начинаешь сильно жалеть об отсуствии статики. Думаешь, PyChecker, PyLint и PyFlakes написали от нечего делать?

> Или если речь зашла об автодополнении и рефакторинге, чем плох PyDev? В последних версиях он дополняет практически всё, что нужно.

Как гордый пользователь PyDev начиная с версии 0.9.8, скажу - рефакторинг там говно^Wпросто никакой, автодополнение - тоже (по крайней мере, в поздних 1.3.2x, версии 1.4.x еше не смотрел) %) Или у тебя PyDev с PyDev Extensions? Говорят, там лучше, но я сам не смотрел.

> И эта дополнялка у него основана не на парсинге исходников

Именно на парсинге исходинков :) Это легко проверить дополнением self.

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

В данном случае разговор уже не о языке, а о платформе .net и десятое дело какой язык использовался для конкретного набора логики, главное что все в целом будет жужжать и основано на единых технологиях. Кстати есть прекрасная тулза, называется Reflector - дисассемблит .net код и преобразует в язык по выбору (тот же C#). Весьма читабельный код на выходе.

>def min(x, y) : return x if x < y else y 

А где гарантия, что x и y сравнимы?

оО. При чём здесь это?

На этапе компиляции проверяется. Посмотри, как это работает в haskell ;)

Ололо. Смотришь в этот документ http://reports-archive.adm.cs.cmu.edu/anon/1996/CMU-CS-96-136R.ps A Type Theoretic Account of Standard Ml 96.

У тебя 5 лет уйдёт чтоб хотя бы понять про что там написано...

>Динамическая типизация - это гораздо больше, чем просто возможность не указывать тип при объявлении.

Технически это оно и есть. Авторитетно заявляю. В то время как статическая типизация это доказательство теорем о коде.

> Она достигается всеми возможными путями, один из них - статическая типизация.

Это конечно путь, но в ту ли сторону - очень сомнительно.

> Всем нравится. Но причем тут динамическая типизация? Она мало мешает на этапе разработки, но когда начинается переделка/рефакторинг, начинаешь сильно жалеть об отсуствии статики. Думаешь, PyChecker, PyLint и PyFlakes написали от нечего делать?

Если честно, за те четыре года, что я профессионально пишу код в команде, глобальным рефакторингом я занимался раз пять и то не потому, что так надо было, а просто сказали сделать. Ничего особенно сложного в этом не было. Кстати, полностью автоматический рефакторинг - это миф. Так мне тут подсказывают.

> Именно на парсинге исходинков :) Это легко проверить дополнением self.

Может текущий файл он таки парсит, но в основном это не так. Угадай, почему вместе с PyDev всегда висит процесс python.

Кстати, именно с 1.4 автокомплит стал если не идеальным, то уж точно удовлетворяющим мои запросы на 100%. Раньше действительно было по-хуже. Рефакторингом PyDev я не пользовался, ничего сказать не могу.

> Технически это оно и есть. Авторитетно заявляю.

очень сомнительный у тебя авторитет

>> Она достигается всеми возможными путями, один из них - статическая типизация.

> Это конечно путь, но в ту ли сторону - очень сомнительно.

Если учесть, что статическая и динамическая типизации существуют уж лет 50, можно точно сказать, что динамическая статическую не превосходит (при том, что статическая типизация - активное поле исследований, а динамическая - только инженерных разработок, т.е. с ней уже давно всё ясно).

> Кстати, полностью автоматический рефакторинг - это миф. Так мне тут подсказывают.

Передавай подсказывающим привет :) Автоматического рефакторинга, конечно, не существует, но язык может оказывать и подолше помощи, чем Питон.

> Угадай, почему вместе с PyDev всегда висит процесс python.

Он в нем программы запускает, да? :)

>только инженерных разработок, т.е. с ней уже давно всё ясно

неправда. Есть много исследований по soft-typing gradual typing. И немало по статическому анализу динамически типизированного кода для эффективной компиляции.

>> только инженерных разработок, т.е. с ней уже давно всё ясно

> неправда. Есть много исследований по soft-typing gradual typing.

Это работа по извлечению неявной статической типизации из динамически типизированных программ.

> И немало по статическому анализу динамически типизированного кода для эффективной компиляции.

Линки? Всё, что я читал о компиляции динамических языков, основывалось на run-time specialization.

> Если учесть, что статическая и динамическая типизации существуют уж лет 50, можно точно сказать, что динамическая статическую не превосходит

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

> И никто не умирает

Я знал, что ты не с нашей планеты ;)

>> Если учесть, что статическая и динамическая типизации существуют уж лет 50, можно точно сказать, что динамическая статическую не превосходит

> У каждой есть плюсы.

Поэтому и хочется поиметь профит от статической в динамическом языке.

>Динамическая типизация - это гораздо больше, чем просто возможность не указывать тип при объявлении. Она помогает смещать внимание кодера с деталей на конструкцию в целом. О технической стороне я рассказывать не буду, так как это огромное поле для холивара и откушает у меня кучу времени. Лучше просто не начинать.

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

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

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

+1 ) Полностью согласен. тут даже не взывается не какое исключение =)

У меня в каталоге 800 pdf'ок с названиями типа:
lucassen88effects.pdf

effectstocl.pdf

monadsdeclare.pdf

huet98constructive.pdf

felleisen.djvu

sulzmann97proofs.pdf

thesis-part3.pdf

thesis-part1and2.pdf

1991commentaryBody.pdf


Так что я нешёл только www.cs.ucla.edu/~palsberg/paper/surveys96.pdf (он у меня назывался type-inference-surveys96.pdf)Только за 96 год. Но когда я этим делом занимался (потом забросил) для написания компилятора, я нашёл не меньше 10 статей + 2-3 диссертации на эту тему.

>Это работа по извлечению неявной статической типизации из динамически типизированных программ.

Ну и ? из динамически типизированных же. Предполагаемый язык в результате имеет и то и другое. + эффективную компиляцию в местах где типы определились.

А это точно о динамических языках?

>> Это работа по извлечению неявной статической типизации из динамически типизированных программ.

> Ну и ? из динамически типизированных же.

И каким образом это засчитывается как исследование в области динамической типизации? На систему типов динамических языков эти исследования не влияют никак.

type inference идёт с "динамического состояния" разумеется.

>Сравни читабельность С/С++ с питоновским кодом. Ни разу она сама по себе не увеличивает читабельность.

Сравни окамл (или F#) с питоном - так лучше будет.

>Только ты забыл рассказать о плюсах динамической типизации.

Ты несомненно их продемонстрируешь. Кроме динамических прокси которые в рантайме генеририруются оно нафиг не нужно. Но как показывает практика среди рубиводов они со всей мегадинамикой своего языка этого сделать не в состоянии. Достаточно посмотреть как они ручками пишут суперлибы типа ebay4r, которые на самом деле должны налету строиться из wsdl.

ТАк что я таки соглашусь с тайлганнером - динмический язык совсем не обозначает что пишутся динамические программы.

>И каким образом это засчитывается как исследование в области динамической типизации?

Тем что результатом будет динамически типизированный язык с опциональной статической типизацией. Ключевое слово _опциональной_. Такие исследования не относятся к статической типизации, ибо по определению при ней, для всего должен определиться тип. И разрешимость type чекера в этом завершении, это ключевая особенность статических type чекеров. А для sort/gradual typing это обязательное завершение не нужно. Так что это совсем другая область.

>На систему типов динамических языков эти исследования не влияют никак.

Динамические языки это по сути отсутствие _системы_ типов.

>Пардон, но где объекты? 

ocaml:

class fib n =
        object
          val v = n
          method value = match v with
                         1 | 2 -> 1
                         | i -> (new fib(i-1))#value + (new fib(i-2))#value
        end;;

>method test(var x) { var y = x.result(); y.print(); }

> test(new Stuff());
> test(new AnotherStuff());

> Тогда _скорее всего_ типизация будет и динамической :)

Ша!

Objective Caml version 3.10.0

# let f x = let y = x#m in y#m;;
val f : < m : < m : 'a; .. >; .. > -> 'a = <fun>

# class a = object method m = "aaa" end;;
class a : object method m : string end

# class b = object method m = new a end;;
class b : object method m : a end

# f new b;;
- : string = "aaa"


статическая типизация.

>В динамической типизации можно убрать интерфейсы, - duck typing более гибкий.

В нормальной статической тоже их можно убрать. См предидущий пример на окамле.

>И методы получаются более полимрофные def min(x, y) : return x if x < y else y


# let min x y = if (x > y) then x else y;;
val min : 'a -> 'a -> 'a = <fun>

статическая.

Хардкор.

жабакодер подождал, пока все уйдут, и тихонько начал "ставить всех на место" :)

Прикольно. ООП часть окамля я знаю очень плохо.

> Тебе следовало размышлять в таком ключе ещё до того, как ты начал нести бред о том, чего абсолютно не понимаешь и, подозреваю, не знаешь вообще.

Анонимус, здесь бредишь ты. Динамическая типизация намного проще статической, особенно если требуются generics.

def min(x, y) : return x if x < y else y

и что в итоге вернет min("мало",2) ?

>Динамические языки это по сути отсутствие _системы_ типов.

анонимус, это диагноз.

>Ша!

Я же сказал - _скорее всего_ :) А так, умный компилятор и из этого статику сделает.

Чистая гарантированная динамика, наверное, только с рефлексией возможна. Типа:

input(&class_name);
var obj = class_load_by_name(class_name);
test(obj);

Вот тут test с автоматическими типами может быть только динамическим...