やっぱり動的言語では安全なソフトは作れない 4

まだまだ需要がありそうなので立ててみました

前スレ
http://hibari.2ch.net/test/read.cgi/tech/1308499587/

このスレッドは天才チンパンジー「アイちゃん」が
言語訓練のために立てたものです。

アイと研究員とのやり取りに利用するスレッドなので、
関係者以外は書きこまないで下さい。

　　　　　　　　　　　　　　　　　　京都大学霊長類研究所

関連する議論、主張

http://tech.cm55.com/wiki/scala/ruby
http://togetter.com/li/163331
http://blog.practical-scheme.net/shiro/20110719-dynamic-typing
http://twitter.com/#!/yukihiro_matz/status/113795262165680128

　　　　 　　　　　　　　　　　 /.:::::::::::/..::::::::::::::::::::::::::::::::::::::::::::::::::::::::::.‘ .
　　　　　　 　 　 　 　 　 　 /.:::::::::::/.::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::.’.
　 　 　 　 　 　 　 　 　 　 /.:::::::::::/.:::::::::::::::/.::|::l::::::::::::::::::::::::::::::::::::::::::::::.',
　　　　　　　　 　 　 　 　 '.:::::::::::::|::::::::::ｌ::::::{」⊥L_::::{::::::::l:|:::::::::::}::::::::::::::::l
　　　　　　　　　　_　/j　 ｊ :::::::::::::|::::::::l:ｌ::::::|:从_|::::`j|:::::::|ﾘ-┼:::}:::}::::::::::::|
　　　 　 　 　 　 ﾉ.}/./／ﾌ ::::::::::::|ｌ:::::::l:l::::::|rゥzｯﾐ └-┴'‐┴くﾘﾉ::::::::|:::|
　　 　 　 　 　 /　'／, -‐_ｧ :::::::::::l|:::::::l:l:::::{ﾊツ:::] `　　 　'fﾗﾔ>/.:::::|:::|:::|　明日から働く
　　　　　　　 /　　　 ｰ-っ:::::::::::::::ｌ|:::::::l:l::::::l弋'::ｿ　　　 　 {::ｿ ｲ :::::::|从:｣　
　　 　 　 　 /　　　 /~￣::::::::::::::::::ｌ| : ::.!|::::::|　　　　　　丶 ｀　 }:::::::l::/
　　　 　 　 j　　 _,ノ　　 l::::::::::::::::::.!|: : :..|::::::|　　　 ｢`ｰｧ　　　,ﾊ::::::|ｲ
　　　　　　 | 　　！　　 l:::::::::::::::::::.!|: ::: :..::::.| `　._　｀¨　　, イ::::|／::|
. 　 　 　 　 |　　 │　　.|:::::::::::::::::::」|::::::::::.:::|⌒ヽ. ` r-＜:::::::|:::::::::::::|
.　　 　　 　 |　 　│　　|:::::::::::::／ . |:::::::::: ::|＼　 ＼ ヾﾄ ＼::|::::::::::::i|
. 　　　　　　|　　　|　 　!::::::::::/　　..:|::::::::::ｌ::|　r:‐ミﾆヾﾑ. -‐ ト､:::::::ｌ|
　 　 　 　　 |　　 ├ヘ｣-‐＜　　　.:|::::::::::ｌ::|　}　　　 { ｝ 　 / 　`､: :ｌ|
　　 　 　 　│　 　ｌﾊ　}　　　 ヽ. 　 |::::::::::l::}　|　　　 几　 :{ 　 　 い、

このスレの真のタイトルは

    やっぱりRubyでは安全なソフトは作れない

ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
だからJAVAを使い続ける　Rubyは使いこなせないから、わかりにくい、そんなものいらないとか言い始めちゃう。
中学生でもやってるのに･･･。。。


まともな人はRubyを使う　　結論はとっくにでてたね

ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。
↑　これがポイントでーす

>>6
スクリプト(笑)すごいですね＾＾

ゴミはJAVAつかってもRubyつかっても開発速度がおなじ。

だから
スクリプト言語なんていらない（キリッ）

なんてセリフを余裕ではいてくる層がいる

マジ、　じゃあやってみろ　って
お前JAVA使って、
俺Rubyで、コーディング速度で勝負してみますか　って。ｗ



もうさー、　　ひっでーゴミみたいな仕事ばっっっっっかり　やらせてるから

そういう勘違いしたゴミグラマが量産されんだよ
ITに関しては中小企業つぶしたほうが良い気がするなぁ

　　　 　 ,―ヽ＿（（（（（＿、―
　　　,／　　ノ　　　　　　　ヽ　　~＼
　 ／　　 ノ　　　ＩＰＡ　　　　ヽ　　　~＼
／　　　ノ　　　　　　　　　　　ヽ、　　`ヽ
|　　　 ﾉ /￣＼　　　／￣~ヽ　ヽ 　　 i
|　　 ノ　　　　　　　　　　　　　　|　　ノ
＼　 |　　＜●＞　　＜●＞　 （　 ）
　＼ |　　　　　 ｜　|　　　　　　 i /
　 　 |　　　　　 /　　ヽ　 　 　 　ﾚ
　　　i　　　　　（●_●）　 　　　 /　　
　　　 i、　　　 ,-――-、　 　・ /
　　　　i、　　<（EEEEE）>　∵/　　　　IPA Rubyスレにようこそ
　　　 　 i、 　＼　　　.／　　/
　　　 　　 ＼ 　 ーー　　 ,ノ　　　　　　　
　　,,.....イ.ヽヽ、ー-―一ノﾞ-､.
　　:　 　| 　';　＼_____ ノ.| ヽ　i
　　　 　 |　　＼/ﾞ（__)＼,| 　i　|

動的言語の話になると、すぐに型付けの話になりがちだけど

個人的には、動的言語では定義と実行の区別があいまいで（または区別が無くて）
基本的にコードが上から実行されるというスクリプト言語的な所が
拡張性を（ついでに取っ付き易さも）生んでる気がする
定義と実行の区別が無いからこそ、いつでも柔軟に再定義できるわけだし

もう結論でてた

ゴミには扱えないで終了

バカは議論ではなぜか
いかに相手より自分が賢いのか、を証明しょうとする。

>>11
柔軟に再定義できるということは、
どこで定義されるかわからないということ。
どこからでも変更可能ということ。

これはグローバル変数に似ているし、
またgotoにもにている。

Javaにはぬるぽがあるから型安全性は動的言語と変わらんし、
バイトコード操作（javassistとか）使えば再定義も可能

ただ、動的言語に比べて果てしなく冗長なだけ

ただし、実行中に再定義するのはJVMの仕様上難しいので
ロード前に書き換える事になる。つまり一種のプリプロセッサだな

だから、安全性は動的言語と大差ないのに
出来る事は少なく、しかも冗長という

なんのためにカスタマイズしたクラスローダーが実行中に使えるようになってるんだよw

クラスをロードした後に変更するのは難しい

つまり、変なことをしなければ
Javaの方が当然安全ということだ。

javaのぬるぽはscalaで解決済み、互換性のためにnullは残ってるから100%排除は無理だが
scala用に設計されたライブラリ使えばぬるぽ？なにそれな生活が送れる

まあすべてのライブラリにscalaのラッパーがあるわけじゃないが

>>13
何勘違いしてんだか知らないけど　　　お前のことをゴミ　って言ってるだけであって

頭大丈夫か？　もう頭無理っぽいねお前ｗ　　産業廃棄物乙

動的言語の定義は良くわからんが、>>11を定義とすると
SML/OCamlは動的言語だなー
実際、書いてるときの感触がいわゆるP言語と似てるし、
文法チェックが超強力なバージョンって感じで

>>19
Javaでは変なことはしないが、動的言語では変なことをするという前提？
それとも、動的言語では変なことをしなくても安全じゃないってこと？だとしたら何故？

>>23
無駄な柔軟性があるから。

たとえばグローバル変数にしておけばどこからでも値を変えられて便利じゃね？
gotoがあればどこにでもジャンプできて便利じゃね？

動的言語の不必要に高い柔軟性はこれと同じ。安全にするのであれば制限を加えたほうがいい。

どうせ同じ変数に互換性がない型を入れたりしないので変数には型をもたせたほうがいい。
実行時にコードを柔軟に書き換える機能なんて持たせずに
継承とか多態とかそういう名前で制限される方法を使ったほうがいい。

こういう制限を持たせることで、その制限に反すること
（例 ローカル変数を触れない場所から書き換えようとすること）を
静的にチェックできるようになる。

たしかに、変数にnull入れられる（真の意味で）無駄な機能は無い方が良いな
静的にチェックも出来ないしな

動的型の柔軟性は使いこなせれば武器になる
Javaのぬるぽはメリットが存在しないウンコ機能

ぬるぽ以外にも、Object型とキャストを使えばなんでもやり放題とか
抜け道だらけだろ。たいして変わらんわ。

>>24
グローバル変数は名前が長くなる傾向があるから使いたくない。
gotoも行き先に名前をつけなければならない。
whileとか使えば名前いらない。

型の名前を書かないのはこれと同じ。
変な名前を大量に覚えさせるのはやめたほうがいい。

型名を書かないのは型推論で実現できるので、動的言語である必要性はない

>>28
Javaほど沢山のクラス名を付けさせる/覚えさせる言語を他に知らない

>>29
それは、C++0xのコンセプトが実現可能と言っているのと同じ、机上の空論
結局実現できず今でもダックタイピングしてるのが現実

>>28

> 型の名前を書かないのはこれと同じ。
> 変な名前を大量に覚えさせるのはやめたほうがいい。

前後二行が全く繋がってないのだが。

>>25
> たしかに、変数にnull入れられる（真の意味で）無駄な機能は無い方が良いな

そのとおり。たとえばC++にはnullを入れられない”参照"というものがある。
その利点の一つが、nullを入れられないから、"より"安全ということになってる。
（誰も、完璧とはいってないのでくだらないツッコミはしないように）

>>27
> ぬるぽ以外にも、Object型とキャストを使えばなんでもやり放題とか

でも少なくとも、Object型を使っているということと
キャストを使っているということが、コード上にしっかり書いてある。

普通は使わなくていいはずのものを使っている。それが不必要なものならば
コードレビューなどで指摘されるだろう。

>>32
たとえ繋がってなくても、結論しか書かない奴より、前と後を書く奴のほうがまし

そういえば、型宣言にも結論ありきみたいな所があるよね

過程すっとばしたら結論だけ言ってるのと変わらんだろアホ

>>24
お前が不必要という機能がなければ、単体テストで満足にモックも作れないわけだが
（テスト対象コードに強い制限が付く）

>>37
作れる。

いやいや、Javaの最近のモックフレームワークも普通に
バイトコード操作使ってるから
使わないと自在にモック作れないから

Javaのような腐れ言語と比べても仕方ない。
Scala, Haskell, OCaml 辺りと比べようぜ。

>>39
そうなんだよね。作れるから問題ない。

そして実際作れるからといって、
そういうテクニックを普段から使うなと。

厳密に区別するべきだよ。

危険なテクニックはテストだけとか使用する場所を限定すること。

うんうん。高速で走るのは危険だから、高速道路は作らなくていいよね、
サーキットさえあればいいよね、という素晴らしい発想ですね。

>>41
Pythonで危険なことをしようとするときに使う関数やモジュールは
大体決まってるので、危険なテクニックを使ってるかはコード見れば分かるよ

ここでいう危険かことというのは、
変数に入れる値に、本来想定した互換性がない型を
入れられるとか、そういうことだぞ。

>>44
ぬるぽ、ぬるぽ！

>>45
うん。だからNULLが入らないほうがもっと優れてるよね。

何でも入る ＜＜＜＜ 互換性がある方のみ入る ＜ NULLも互換性がないとみなす

こういうこと。より優れているのは言うまでもない。

ああ、Javaでも安全なソフトは組めないってこと？
それなら同意するわ

ぬるぽと動的型で一体どこが違うの？
静的にチェックできないし、メソッドにアクセスしたら例外出るのも一緒じゃん

>>47
いやｗ 当たり前だろ。

どっちがより優れてるかって問題であって
おまえ、銀の弾丸なんて無いんだぜ。

>>48
チェックできる型数が違う。

できないことを上げて反論しているようだが、
反対にできることを上げてみれば、
違いは明らかだろう。

いやいや、Javaと動的言語なら型安全性は同レベル
記述力は動的言語の方が上

つまり 動的言語 >>>>> Java

結局、Javaでも全てのオブジェクト型変数はNullチェックしないと使えないし、
しかもそれは静的チェックではないわけ
Rubyとかでkind_of?してるのと変わらんわ

>>51
根拠が抜けてる。
反論しなおせ。

> 結局、Javaでも全てのオブジェクト型変数はNullチェックしないと使えないし、

ん？ nullチェックしてどうするんだ？
nullですよって例外出すのか？

Null Pointer Exceptionでいいじゃん

>>52
だからnull以外は、実行時にチェックしなくていいから
楽ってことなんじゃないのか？

>>54
え？じゃあ動的型でもNoMethodErrorとか出せばいいわけ？

いやいや、それじゃダメだろwww

>>55
全てのオブジェクト型変数にNullは入るだろ
お前は基本型だけ使ってプログラム組んでるのか？

>>52
Nullチェックなんて書かないよ。
そんなもん書かなくても、ちゃんと例外だしてくれるんだし。

で、Nullは問題だよね。実行時にしかわからないから。
実行時にしかわからないのは、問題だって認識はあるんだよね？
じゃあ、Null以外なら実行前にわかるってことも認識できるよね？

>>56
だから、（Nullも含めて）実行時にわかるよりも
実行前にわかったほうがいい。

実行時に例外だすなんてもってのほか。
ぬるぽももっての他だが、ぬるぽだけですんでる分まだマシ。

動的型にはダックタイピングと実行時型エラーという
メリットとデメリットが存在する

ぬるぽは全ての参照型に実行時型エラーのデメリットがあるが
メリットが何も存在しない

ダックタイピングねぇ。

あれ、意味あるの？
アヒルインターフェースを備えていれば
アヒルであるってだけでしょ？

それって静的型でできることだよね？

Javaは都合が悪くなると、動的言語と同じ事もできるって言うし
C++は都合が悪くなるとCと同じ事もできるって言う。
いざとなれば同じ所に逃げ込めば安全だと思ってる。
危険だと言ってるのは今だけで、持続的な言質を与えるつもりはぜんぜんないのだ。

何言ってんだお前は

Maybeモナド

>>63
そういうお前は何も言っていないじゃないか
つっこむならもっとつっこめよ

同じことができるかどうかは問題ではない。
その言語にとっての一番自然な書き方でどう実現できるかが重要だろう？

>>61
メソッド一つのインターフェースを山ほど作って
インターフェース爆発を起こすわけですねwww

>>67
ん？ それはダックタイピングの欠点かいな？

アヒルのように歩き、アヒルのように鳴くのなら、アヒルだというが、
じゃあ、アヒルように歩くが、アヒルのように鳴かなのなら、それは何なんだ？

結局、アヒルであるためには、アヒルである条件をすべて満たさないといけない。
アヒルである条件は全部満たしてこそアヒルなわけだ。つまりそれがインターフェース。

メソッド一つ一つバラバラにしかできないとしたら、それはさっき書いたように
アヒルのように歩くが、アヒルのように鳴かな中途半端なものができてしまう。

その中途半端な存在をアヒルとして扱って、動作保証は出来るのか？

>>68
なんでインターフェースの無い言語でインターフェース爆発起こすんだよw

インターフェース爆発の例
http://gee.cs.oswego.edu/dl/jsr166/dist/extra166ydocs/extra166y/Ops.html

OCamlを使いたいならOCaml使えばいいじゃない
形式手法で検証したいなら形式的検証ツールを使えばいいじゃない

必死で他言語をdisったところで得るものはないと思うが

>>68
頭大丈夫？ダックタイピングってなんなのかわかってる？
「アヒルのように歩き、アヒルのように鳴くならそれはアヒル」って言葉だけで
ダックタイピングがわかった気にな ってるっしょｗ始末におえねーｗｗ
頭固いんだよオッサン

>>68
動的言語的で、最も自然な形でインターフェースを実現するとダックタイピングになるんだよ。
Javaインターフェースは「Aならば、Bを持つ」という考えで、ダックタイピングは「Bを持つならば、Aである（と考えても構わない）」という考えだ。どちらも目指すところ、実現していることは同等だ。
ただダックタイピングのほうがより柔軟だ。ミックスインや実行時でのメソッド追加が可能な、動的言語には固定化したインターフェースは必要ないどころか邪魔なだけだ。

ただし、Javaのインターフェースと動的言語のダックタイピング。どちらが安全かといえば、パラメータの型まで指定できるJava のほうが安全に決まっている。
例えるなら、Java インターフェースは「100V50Aの二つ穴コンセント」のようにかっちりとした規格を決められるのにたいして、ダックタイピングは「ブタの鼻でも二つ穴だからコンセントになる」みたいな感じ。
でもこれは静的型付けと動的型付けの本質的な差異だからね。ダックタイピング固有の問題ではない。

ちなみにおれはJavaは大嫌いだが、PMとして土方を使う分には便利だと思っている。

ただし、Javaのインターフェースと動的言語のダックタイピング。どちらが安全かといえば、パラメータの型まで指定できるJava のほうが安全に決まっている。
例えるなら、Java インターフェースは「100V50Aの二つ穴コンセント」のようにかっちりとした規格を決められるのにたいして、ダックタイピングは「ブタの鼻でも二つ穴だからコンセントになる」みたいな感じ。
でもこれは静的型付けと動的型付けの本質的な差異だからね。ダックタイピング固有の問題ではない。

ちなみにおれはJavaは大嫌いだが、PMとして土方を使う分には便利だと思っている。

書き込みごときでミスるような使えない奴は、どんだけ偉そうなことを言っててもリアルじゃドカタなんだろうなー

AならばB（アヒルのように振る舞うならばアヒルである）と
BならばA（アヒルならばアヒルのように振る舞う）の区別がつかないとか
プログラマとして大丈夫か？

ダックタイピングは structural subtyping でも出来るし、
nominal subtyping の言語でも type erasure のような技法を
使えば実現可能（C++のboostでは使われてる）

だから動的型だけの特徴じゃないのだが、structural subtyping はまだマイナーだし、
Type erasure は少々ややこしいのが難点だな

>>75
まあ、あれだ。
大事なことだから二回言っただけだw

>>76
公文学習教室で論理数学の講座でも主催しとけ

>>77
>>66を嫁

アヒルのように振る舞うならばアヒルである

これは論理的に言って間違い。
アヒルのように振る舞う、動物モノマネ王はアヒルではない。

馬鹿は無理に論理的って言葉使わない方がいいぞ。

>>80
そんなことより反論したら？　論理的にｗ

>>79>>81
structural subtyping で型安全性を完璧に満たす型システムを構成することが可能

>>79
> アヒルのように振る舞うならばアヒルである

ただの「AならばB」だろ？どこに論理的におかしいところがある？
「論理的に」だぞ？

論理わかんないやつに触るなよ
めんどくさいだけ

特に理由もなく、本物とかモノマネとか、結論がいきなり出てくるのが宣言。
振る舞いを見た上でアヒルだと結論づけるのがダックタイピング。

宣言は論理というより公理に近い。

>>83
いや、お前はAならばBといっただけで何も証明してないだろ。

AならばB 具体的に言えば、りんごならばバナナ。
これが間違っているのは明らかだよな。

AならばBというのはただの命題。お前は命題を言っただけで、
「AならばＢ」が正しいという証明をしてないんだよ。

「アヒルのように振る舞うならばアヒルである 」
この命題を出発点として、正しいかを考えるのが論理学だ。

やってみ。「アヒルのように振る舞うならばアヒルである 」という
”命題” が 正しいか。

>>86
間違ってるって何の根拠も無く言い出したのはお前なんだから、
お前が間違ってるって証明しろよ。

>>86
馬鹿は無理して論理とか証明とかの言葉使わない方がいいぞ。

>>86
で、間違ってたらなんなの？

単なる例えをロンパ(笑)したとして、だからダックタイピングはアンチパターンだって主張しようとしてるの？
それともしょうもない雑談に付き合ってほしいだけ？

例え話だと議論が発散してしまうから、もっと具体的な話しよう

ポリモーフィズムするのに継承関係を必要とするのがインターフェース
メソッドの有無で判断するのがダックタイピング

プログラミングではこれ以上抽象的な議論は必要無いだろうし
その上でメリットとデメリットを語ったほうが生産的だよ

プログラムのいいところは、どんなにえらそうにしてても使えるコードを書かなければ相手にされないところだ

数学的にな話をしていて、やっと気づいたよ。
静的言語のメリット。

ようするに数学的（主に論理学）であること。
数学的であるから、数学のテクニックが使える

数学では定義を厳密に行う。厳密な定義があれば
様々なことを論理的に導出できる。
それは式を簡略化したり、矛盾を見つけることにつながる。

これをプログラム言語に当てはめると、変数、型、インターフェース
様々な定義から、矛盾あるコードを見つけることができる。
この論理学的手法を使えるのが、静的言語のメリットなんだ。

>>90
> ポリモーフィズムするのに継承関係を必要とするのがインターフェース
> メソッドの有無で判断するのがダックタイピング

それは正確ではないな。インターフェースだって結局はメソッドの
有無で判定しているんだよ。○○というメソッドが定義されているか。
定義されていなければ、コンパイルエラーになる。

本質的なのは、○○（アヒル）である。という定義がコンピュータに理解できる
言語（ソースコード）で書いてあるか、それとも人間しか理解出来ない言語（ドキュメント）かの違いだろう。

コンピュータに理解できる言語で書いてあれば、コンピュータが人間に変わって
いろんなことをやってくれる。それが静的言語のメリットだな。

論理学がすきな学生だなw
かなり遠回り＆勘違いしているが、静的言語のいいところは静的（=コード実行前）にプログラムの構造が決まるところだよ。だからコンパイル時にプログラム内の構造バグをチェックできる。
それだけではなく、リファクタリングも１００%問題なく実施できる。
動的言語は実行時にそれが決まるというだけで、数学的に矛盾があるわけではないw

> 静的言語のいいところは静的（=コード実行前）にプログラムの構造が決まるところだよ。
> だからコンパイル時にプログラム内の構造バグをチェックできる。

それは違う。たとえばRubyをコード実行前にコンパイルしたところで
コンパイル時にプログラム内の構造バグは（静的言語よりも）わからない。

コンパイル時にわかるのはわかるのは、静的言語であることも条件の一つだが、
それよりも重要なのはソースコードに定義が書いてあること。
定義があるから論理学的手法によって、自前に矛盾を見つけることができる。

いくら実行前にコンパイルしたからと言って、定義がなければ何も導出できない。

動的言語は実行時にそれが決まるというだけで、数学的に矛盾があるわけではないw
↓
正しくは、動的言語は実行時にそれが決まる仕組みにするために、定義を書くことができくなった。
定義がないために、定義があれば見つけられたようなこと（矛盾など）を見つけることができない。

>>95
静的言語のメリットは>>94で書いた通り。
コンパイルってなんだ？おれは実行前/実行時の話をしたんだが。

>>96
静的言語のほうが安全なのは当たり前だ。誰も反対していない。
その安全を手に入れるための制約（=実行前の構造決定)を捨てることによるメリットの
方が大きいというのが動的言語の主張だ。

ここでスレタイに沿いたいのだが、安全なソフトウェアの定義をしたい。
おれの定義はこれだ。

「数百人 x 数十か月　の開発工程の結果、容易に保守可能なソフトウェアを生産できるか？」

経験上、Javaであれば問題なく可能だ。数百人のうち９割９分はドカタでも構わない。
企業にとったらこんなありがたい言語はない。
Rubyではこうはいかないし、Cも論外だ。優秀な数百人を集めないと、同様の保守性を期待する
ことはできない。
だから、Javaはプログラマとしては唾棄すべき言語だが、管理する側にとってはこれ以上ない
言語なんだ。

> その安全を手に入れるための制約（=実行前の構造決定)を捨てることによるメリットの

ないよそんなもん。

>>98
1万人月を越えるような巨大プロジェクトで保守容易なプログラムを作るってすごいね
お前が設計したの？

>>100
1万人月分の設計を一人でするわけないだろw　面白いやつだな。
適切なフレームワークとアーキテクチャを選べば、Javaの場合コードの影響
を局所限定的にすることができる。
これがメソッドを実行時に書き換えることができるだの、ダックタイピングだの、
ミックスインだの言ってる言語だと数行のコードで全体が破滅しかねない。

・・・でも可能ならばおれは動的言語でこの規模のプロジェクトを成功させて
みたいよ。

こんなゴミみたいな議論してる暇があったら
動的言語使いこなす練習でもしてくれば

>>93
インターフェースがポリモーフィズムするのに継承関係を必要とするのは事実だろ
直接的にメソッドの有無を判定しているわけではない
何故なら全く同じシグネチャのメソッドを持っていても、継承関係が無ければ
ポリモーフィズムできないからだ

>>99
（土方には）ないよそんなもん。

eval可能な言語は全て動的言語の一種?

静的型のメリットはプログラマで無くても分かるが、
動的型のメリットは、その柔軟性を発揮できるプログラマにしか分からない
低能プログラマには「動的型 = 静的型 - 静的型チェック」としか映らないだろう

おまえもいつか石頭になって、わかいひとたちから低能よばわりされるときがくるぞ

謙虚でないひとのいうことは雑音みたい

>>105
ポリモーフィズム可能な言語は
静的な制約の一部または全部を無効化できるから動的言語の一種。

ad-hod polymorphismだけがpolymorphismじゃねー

動的言語って、型を理解できない奴が使う言語だろ。

おまえが何を理解できてるか知らんが、Javaは何も理解してなくても
危険なコードが書けないのが利点なんじゃなかったっけw

>>112
お前そういう勘違いしていたのか？
だから話が噛み合ってないんだな。
なっとくだわーｗ

えとな、世の中完璧なんてものはない。
どちらが優れているかだ。
もちろん優れているのは静的言語。

>>109
lisp なんて多態性なんて言葉かできる前からあるがな。

実行時メタプログラミング=動的言語
実行時型付け言語=動的型付け言語

VB6やPL/SQLも動的言語ではあるよな。
DBの列名を定数の様に扱えるとか。

最も動的と言えば、シェルスクリプトだろ。
ある意味一番安全で一番柔軟。
即時修正可能。

デバッガ使って実行時コード書き換えが一番動的
いまだにこのやり方で解決する事例が結構あるのが笑い話もしくは怪談

メタプログラミングが危険だと言えばいいのに。
メタプログラミングを諦めきれないやつが
静的なメタプログラミングは悪くない、悪いのは動的言語だ、ということにしたいのか。

スペース区切りの文字列を配列アクセス
文字列を結合してコマンド名作成
コマンドの出力をシンボルとして使用
クオートでくくらずSQLを実行
ファイル操作も専用構文があってパターンの補完が行える

CGIとかわざわざ静的言語なんざつかわんでも
シェルスクリプトで事足りる事が多いよな
画面レイアウトもHTMLのテンプレ読み込んで加工する方が楽だし

>>118
冷静になれよ。C++のような
静的なメタプログラミングを備えた言語もある。
悪いのは定義ができないこと。
定義がなければ数学的導出が行えない。

lispは式自体がデータで究極のメタ言語だけど、
OOの型ばっかで関数型の動的性について非難できるやつはいないのな。
程度が知れる。

関数型の動的性ってのは一見柔軟に見えて優れているように思えるが、
gotoはどこにでもジャンプできるから柔軟だ。みたいなもんだよ。

gotoといった汎用的なものから、関数やループといった
特殊化されたものができてコードが理解しやすくなって、
人間もコンパイラも最適化やエラーを見つけられるようになったように、

関数型の動的性も特殊化され、よりわかりやすい静的な方法に
置き換えられていく。

型が弱すぎるんだよ
とっとと依存型使えそうすりゃ誰もコード書けなくなるからｗ

能書きはいいからちゃんと動くもの作れよ。
バグ作り込むとすぐ言語を悪者にしてさぁ。

はいはい使うやつが優秀ならアセンブラでなんでも作れる論ね

アセンブラって、どちらかに分類するとしたら
動的言語だよな。

取り敢えず、これでも各言語で書いて安全性と保守性を検証して見ては？

>>601
＞ちょっと感動したんで書いとく
＞
＞まずはプログラミングhaskellからの引用
＞
＞
＞x^2+y^2=z^2を満たす正の整数をピタゴラス数と呼び、三つ組(x,y,z)で表す。ピタゴラス数のリストを生成する関数pythsを定義せよ。ただし、ピタゴラス数の要素は、与えられた上限以下であるとする。
＞
＞以下に例を示す。
＞
＞>pyths 10
＞[(3,4,5),(4,3,5),(6,8,10),(8,6,10)]
＞
＞引用終わり
＞
＞これ、haskellで書くと(と言うか、リスト内包表記使える言語だと同じ感じ)、こうなるんだけど、
＞
＞pyths n = [(x,y,z) | x <- [1..n], y<-[1..n], z<-[1..n], x^2+y^2 == z^2]
＞
＞リスト内包表記以外の方法だとこんなに短く書け無いんじゃ無かろうか
＞
＞pythonはリスト内包表記あるの知ってるけど、他の言語でも、こんなに短く書けるんだろうか。。。

>>127
実用的な例でお願いします。

>>126
アセンブラはプロセッサ
アセンブリが動的かどうかはアセンブリの種類による

>>129
静的に型が決まらないから
動的って言ってるだけ。

きにすんなｗ

>>130
自己書き換えコードの事いってんのかと思ったがな。

>>128
この程度の例も出来なくて何が実用的な例だよ

大量の組み合わせの中から、条件に合った組み合わせだけを抽出するのは実用でも十分使いまわせるだろ

型＝数値、文字列の内部表現
くらいにしか考えてない奴が多いな。

型＝定義。
定義があれば導出が行える。

型⊇それに属する値全てが満たして欲しい性質　説で
ある性質を満たすことを型チェックで機械的に保障することができるわけだ

>>135
満たして欲しい性質がそのまま満たされることはない
現実を見て落とし所を探す
コンパイルが通った頃には、何を譲歩してこうなったのかわけわからん性質が残るばかり

そりゃ型システムが満たして欲しい性質に関して健全な(欲を言えば完全でもある)型を表現できてないだけだ
型システムによる制約をソフトウェア設計に利用するのは最も軽量な形式手法といえる(TAPL1章より引用)けど
その程度の形式手法すら実用化されてないわけで、形式手法関連の研究が他分野から貶されるのもよくわかる話だよな

型安全厨は動的型付け言語では安全なソフトは作れないスレたてて
そっちでやれよ
このスレはちゃんと動的言語について書け

こっちの方>>127も、動的静的問わず御願いします

どの言語がどの位の長さのコードになるのか気になる

便所の落書きの為に乱立とかあほか

型安全厨ってOO関係のスレにも現れるし、やっぱり隔離スレ立てるか

立てて、どうせすぐ機能せずに落ちると思うけどものは試しだ

さっさと立てろよボケ

しばらく家にいないから帰宅した週末に立てる。

今ネットできるんだから、
今やれよ

ここ自体が隔離スレなんだしｲﾗﾈ

>>127

・Scala

def pyths(n:Int) = for(x <- 1 to n; y <- 1 to n; z <- 1 to n; if x*x+y*y==z*z) yield (x,y,z)


・OCaml

let rec (--) x y = if x > y then [] else x :: (--) (x + 1) y
let pyths n = [ (x,y,z) | x <- 1--n; y <- 1--n; z <- 1--n; x*x + y*y = z*z]


・Python

def pyths(n):
    return [(x, y, z) for x in range(1, n+1) for y in range(1, n+1) for z in
            range(1, n+1) if x*x + y*y == z*z]

>>127

・Java

public static List<Integer[]> pyths (int n) {
    List<Integer[]> list = new ArrayList<Integer[]>();
    for (int x = 1; x <= n; x++) {
        for (int y = 1; y <= n; y++) {
            for (int z = 1; z <= n; z++) {
                if (x * x + y * y == z * z) {
                    Integer[] a = {x, y, z};
                    list.add(a);
                }
            }
        }
    }
    return list;
}

perl的終末感

>>148が一番コードが読みやすいな。

>>150
うっそ、まじでwwww
信じらんねー

こうやってみるとhaskellが一番に綺麗だな

短ければいいってもんじゃないしな。

そこに書いてある意図が
コメント無しでわかるのが一番良い。

このコード説明してみて。と言われて
説明したくなったら、それはそのコードが
コメントを必要としているということだ。

public static List<Integer[]> pyths (int n) {
　　List<Integer[]> list = new ArrayList<Integer[]>();
　　for (int x = 1; x <= n; x++) for (int y = 1; y <= n; y++) for (int z = 1; z <= n; z++) if (x * x + y * y == z * z) list.add({x, y, z});
　　return list;
}

c++11

#include <iostream>
#include <list>
#include <tuple>

template <class T>
std::list<std::tuple<T, T, T>> pyths(int n)
{
std::list<std::tuple<T, T, T>> lst;

for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
for (int z = 1; z <= n; z++)
if (x * x + y * y == z * z)
lst.push_back(std::tuple<T, T, T>(x, y, z));

return lst;
}

int main()
{
std::list<std::tuple<int, int, int>> li;

li = pyths<int>(100);

for (auto pos = li.begin(); pos != li.end(); ++pos)
std::cout << '(' << std::get<0>(*pos) << ", " << std::get<1>(*pos) << ", " << std::get<2>(*pos) << ')' << std::endl;
}

見にくい

>>153に一票追加。

>>149
肝心のparlが無いぞ

>>154
Java7ではそのコードが通るようになったのか？

>>153
リスト内包表記から説明しないといけないとか言われたら
そりゃJavaが一番説明コストが低いだろうなw

>>150
それは関数型で育って無いからだろ。
英語で育った人間が
日本語を読みづらいのは当たり前。

今や色々な高級言語に関数型の考え方は取り入れられてるけどな

>>127は保守性を検証と言ってるから
関数pythsをどれくらい簡単に拡張できるかも評価しては？
例えば、条件式 x^2 + y^2 == z^2 を引数で渡せるように一般化するとか

Pyton

def pyths(f, n):
    return [(x, y, z) for x in range(1, n+1) for y in range(1, n+1) for z in range(1, n+1) if f(x, y, z)]
print( pyths(lambda x,y,z: x*x + y*y == z*z, 10) )

C#が出てなかったので

static List<Tuple<int, int, int>> pyths(int n) {
var a = from x in Enumerable.Range(1, n)
from y in Enumerable.Range(1, n)
from z in Enumerable.Range(1, n)
where x * x + y * y == z * z
select Tuple.Create(x, y, z);
return a.ToList();
}

そもそも、静的な言語ですら安全かどうかって話なのに
動的な言語が安全かどうかなんて、議論して意味あるの？

世間的には、Javaみたいな半分動的型付けの言語でも
安全に組めると思われてんじゃねーの？

>>162を修正

def triple(f, n):
    return [(x, y, z) for x in range(1, n+1) for y in range(1, n+1) for z in range(1, n+1) if f(x, y, z)]
def pyths(n):
    return triple(lambda x,y,z: x*x + y*y == z*z, n)
print pyths(10)

>>127
Perl

sub variation {
my $list = shift;
return map(sub{ map{ [@{$_[0]}, $_] } @{$list} }->($_), @_);
}

sub pyths {
my ($n) = @_;
return [
grep{ $_->[0]**2+$_->[1]**2 == $_->[2]**2 }
variation([1..$n], variation([1..$n], variation([1..$n], [])))
];
}

巨大配列作ってるので、foreachで包んだほうが効率良さそう。つーか色々無理。

流れに便乗 >>127
Prolog


gen(_, End, End) :- !, fail.
gen(N, Beg, End) :- N = Beg; Next is Beg+1, gen(N, Next, End).

?- N is 10+1, findall((X,Y,Z), (gen(X, 1, N), gen(Y, 1, N), gen(Z, 1, N), Z*Z =:= X*X+Y*Y), Result).

質問です。
私は大学一年です。前期、授業でPythonとPrologを習いました。そのPrologの
方ですが、引数に現れるのは、リストかアトムでリストの要素も全部アトムです。
このような言語でも静的か、動的か、というような議論は意味があるのですか？

% 見たらPrologの話がふたつ続いている。うれしくなって、図に乗って。

ピタゴラス数ならび(_要素値上限,_ピタゴラス数ならび) :-
　　　　findall([_x,_y,_z],(
　　　　　　　　　　　　ピタゴラス数(_要素値上限,_x,_y,_z)),
　　　　　　　　_ピタゴラス数ならび).

ピタゴラス数(_要素値上限,_x,_y,_z) :-
　　　　'1から_要素値上限までの整数リストを生成'(_要素値上限,L),
　　　　組合せ(L,3,[X,Y,_z]),
　　　　'X,Y,を三角形の短辺、_zを長辺だとみなすことができる'(X,Y,_z),
　　　　ピタゴラスの定理を適用する(X,Y,_z),
　　　　短辺はひっくり返すことも可能(X,Y,_x,_y).

'1から_要素値上限までの整数リストを生成'(_要素値上限,L) :-
　　　　findall(N,for(1,N,_要素値上限),L).

'X,Y,を三角形の短辺、_zを長辺だとみなすことができる'(X,Y,_z) :-
　　　　_z > X,
　　　　_z > Y,
　　　　_z < X + Y.

ピタゴラスの定理を適用する(X,Y,Z) :-
　　　　Z * Z =:= X * X + Y * Y.

短辺はひっくり返すことも可能(_x,_y,_x,_y).
短辺はひっくり返すことも可能(_y,_x,_x,_y).

本当だ。>>168 と書きこみ時刻がほぼ重なっててワロタ。

ついでに質問に答えとく。Prologの引数に現れるのは項で、項は変数かアトムか複合項。リストは複合項。
ここでいう動的・性的の違いは、プログラム中であるパラメータに適用している演算が正当かどうかが性的に判別可能かどうかなので
そういう意味ではPrologは間違いなく動的。

>>171
Prologってエッチな言語だったんですね

Rubyは？Rubyは無いの？

>>151
な･･･　　しんじらんねーんだよ
本当にJAVAメインにしてるバカは、技術者じゃなくて
なんつったらいいんだゴミグラマか？　そうだな　ゴミだ。

>>150
マジで業界を去れ



「　バカは効率がわからない　」

効率のいいものと　悪いものをみせても　　バカには区別がつかないから、　いいほうを選ぶか悪いほうを選ぶかは2分の1の確率になっちゃうんだよ。。。。
サイコロでも転がしてろｗｗｗｗｗｗｗｗｗｗｗ　　　ゴミグラマは死ね　　　死ねゴミグラマ

>>173
Rubyだとこんな感じ

require "open-uri"
require "cgi"

data = open("http://hibari.2ch.net/test/read.cgi/tech/1316016777/167") {|io| io.read }
data.force_encoding "sjis"
data =~ /Perl(.*?)(?=巨大)/
puts `perl -MData::Dumper -e"#{CGI.unescapeHTML($1).gsub /<br>/, ""}; print Data::Dumper->Dump(pyths(10)), $/"`

Ruby

def pyths(n)
    (1..n).to_a.permutation(3).select {|x| x[0]*x[0] + x[1]*x[1] == x[2]*x[2]}
end


>>175 笑わせるなw

ああ、もっと簡単に書けたわ

def pyths(n)
    (1..n).to_a.permutation(3).select {|x,y,z| x**2 + y**2 == z**2}
end

>>162>>166

import java.util.*;

class Triple
{
  static interface TripleCondition {
    public boolean isCorrect(int x, int y, int z);
  }
  public static List<Integer[]> triple (TripleCondition f, int n) {
    List<Integer[]> list = new ArrayList<Integer[]>();
    for (int x = 1; x <= n; x++) for (int y = 1; y <= n; y++) for (int z = 1; z <= n; z++)
      if (f.isCorrect(x, y, z)) list.add(new Integer[] {x, y, z});
    return list;
  }
}

続き

class Pyths
{
  public static List<Integer[]> pyths (int n) {
    return Triple.triple(new Triple.TripleCondition(){
      public boolean isCorrect(int x, int y, int z) {
        return (x*x + y*y == z*z);
      }
    }, n);
  }
  public static void main(String args[])
  {
    List<Integer[]> list = pyths(10);
    for (Integer[] a : list) System.out.println(String.format("[%d,%d,%d]", a[0], a[1], a[2]));
  }
}

>>98
>ここでスレタイに沿いたいのだが、安全なソフトウェアの定義をしたい。
>おれの定義はこれだ。
>
>「数百人 x 数十か月　の開発工程の結果、容易に保守可能なソフトウェアを生産できるか？」
>
>経験上、Javaであれば問題なく可能だ。数百人のうち９割９分はドカタでも構わない。

同じく経験上、これはウソだと主張する。
ほんとにこれが実現しているなら、Javaを採用したプロジェクトは、100%とまではいかないにしても高い確率で成功するはず。
しかし実際はどうだ。みんな徹夜の連続で、休日返上で働いてるにもかかわらず、納期は守れず、要件は満たせず、セキュリティバグがわんさか出てくる。

じゃあJavaじゃなくて動的言語を使ったらもっとひどいことになるのか？
まったくそんなことないようだ。知り合い数人がPHPとRubyでシステム作ってるけど、
納期前に徹夜が2、3日あるくらいで、それ以外は徹夜しないし、休日出勤もないらしい。
それでいて、納期遅れはしないし、なにより仕事が楽しいといってはばからない。

たぶんね、プロジェクトの成否に、言語はあんまり関係ないんだよ。
プロジェクトを小規模にするとか、仕事の進め方を変えるとか、言語以外のことのほうが、プロジェクトの成否には重要なんだと思う。

>企業にとったらこんなありがたい言語はない。
>Rubyではこうはいかないし、Cも論外だ。優秀な数百人を集めないと、同様の保守性を期待する
>ことはできない。
>だから、Javaはプログラマとしては唾棄すべき言語だが、管理する側にとってはこれ以上ない
>言語なんだ。

こういうふうに、管理する側がそれに気づいてないうちは、Javaの失敗プロジェクトはなくならない。

うう、書いてから気づいた。

>>98
>ここでスレタイに沿いたいのだが、安全なソフトウェアの定義をしたい。
>おれの定義はこれだ。
>
>「数百人 x 数十か月　の開発工程の結果、容易に保守可能なソフトウェアを生産できるか？」
>
>>経験上、Javaであれば問題なく可能だ。数百人のうち９割９分はドカタでも構わない。

これって、「大規模なプロジェクトを（高確率で）成功させるプログラミング言語」の定義であって、
「安全なソフトウェアの定義」じゃないよね。
こんな、日本語ですら破綻したこと書いてる人間相手に、真面目にリプしたのがはずかしい・・・
きっと、この人が書いたコードはもっと破綻しているだろう。

>>162
haskell

pyths p n = [(x,y,z) | x <- [1..n], y <- [1..n], z <-[1..n], p x y z ]

使用例

>pyths (\x y z -> x^2 + y^2 == z^2) 10
[(3,4,5),(4,3,5),(6,8,10),(8,6,10)]

関数型言語は大体似た感じになるな
OCaml

let pyths p n = [ (x,y,z) | x <- 1--n; y <- 1--n; z <- 1--n; p x y z]
let _ = Std.print @@ pyths (fun x y z -> x*x + y*y = z*z) 10

>>181
なにがリプだよ、きもちわりい奴だな

リプ〜？
リップー！！
プリプ〜♪

twitterではレスの事をreplyっていうんだっけ

ぶっちゃけJavaの冗長さはIDEでもカバー出来ないレベル

その冗長さが安心感を生むとのこと

この議論にも飽きたなー

>>174
この人ねえ...多分、こういう言動続けているとクビになって業界去ると思うよ。
仮に、ここで罵倒しているのが現在あるいは未来の仲間、上司や取引先だとしたらって考えが無いんだねえ。
ま、お前の人生だから俺にはどうでもいいしあぼーんしておくだけだがな。

>>189
どちらの方式も使える言語や解決策は探すと大抵あるしなあ。
結局は怪我しまくって上達するか、あるいは適材適所っていうのが戯論系スレのオチ。

結局は、コードの長さに違いはあれど、
考える時間を入れたら、殆ど差がないんじゃないか？
少なくともこの例では。

考える時間は使う人が多少習熟してればどの言語も一定
誰もが内包の方がループで考えるより時間掛かるなんてことはない

>>184
本人降臨〜
間違いを指摘されたからってキレるな〜ｗｗｗ　落ち着け〜ｗｗｗ

>>192
いや、その時間が誤差レベルの差しかないのではないかってことなんだが。

数学になれてれば直感的でむしろ自然に書けるが。

数式は必ずしも読みやすいってわけじゃないんだよね。

多重ループになってる内包表記はちゃんと改行しないと読みにくいな

>>194
関数型言語の機能や考え方が受け入れられて来たからで有って、手続き型言語の機能だけ、考え方だけだとjavaのコードみたいなのばかりだったと思う

人間の頭の中って
たいがい手続き型で考えてね？

出遅れたけど Common Lisp で、

(defun pyths (f n)
(loop for x from 1 to n
append (loop for y from 1 to n
append (loop for z from 1 to n
if (funcall f x y z)
collect (list x y z)))))

ネットで拾ったマクロを使えば

(defun pyths (f n)
(collect-list (list x y z)
(for x from 1 to n)
(for y from 1 to n)
(for z from 1 to n)
(funcall f x y z)))

となるけど、こんなのライブラリ使えばどの言語でもどうとでもなりそう。

裸の王様
昔oo今関数型

>>199
そうでもない
人間、楽に考えられたら楽に考えられる方に流れてく
関数型言語の機能が入って来てるのも、その兆候

Ted Newardが言ってたことだけど、昔なぜObject Orientedがもてはやされたかというと、
C++に始まる静的型付けオブジェクト言語を使って、様々な高速フレームワークを構築す
る必要があったからにすぎず、今はそういうのはほぼ完成されているので、仕事の内容
が、動的関数型言語を必要とするようなものにシフトしている。関数型言語の流行は、人
間の頭の適性とか趣味の問題とは全く関係なくて、単純に全世界で行われているプログ
ラミングの仕事の総量内のパーセンテージの問題であるのだと思います。

>>203
意味がわかりません。

>>197
pyths n = [(x,y,z) | x <- [1..n],
                         y <- [1..n],
                         z <- [1..n],
                         x^2 + y^2 == z^2]

改行するだけで随分読みやすくなるな

forにはbreakが、ifにはelseがある
mapとfilterにはない
機能が少ない分、読みやすくなってもらわないと困る

データの制約は反感を買うのにコードの制約はすんなり受け入れられるのはなぜなのか

>>169
質問は 型 = 構造体の形式 と解釈しているようですが、

1) Prologの引数にはリスト以外の複合項(構造体)がこないというのは「作法」であって、
　Prologの規則ではない。プログラマによっては、あるいはアプリケーションの要請で
　引数として複合項を渡すことはないわけではありません。
2) リスト以外の複合項が引数として現れず、すべてアトムまたは変数だとしても、
　a) foo(四季:X)
　b) foo(X) :- member(X,[春,夏,秋,冬]), ...
　　a)は、Xがアトミックなデータしか取ることがなくても、型付することが可能なことを示しています。
　　Prologはb)を採用している訳で、このことが動的で型付けなしの意味です。
ただし、Prologの単一化を安全で強い型付けと解釈する向きもあります。これは上の「作法」には
反しますが、呼び出され側の引数に構造体を置いた場合、呼び出し側の引数の構造体の細部まで
形式検査を完全に行うことになるからです。

>>208
説明が適切でありませんでした。2) の a) ですが、これはProlog以外の
言語の例です。
現在のPrologでこのように記述すると ':'(四季,X) という複合項が呼び出され側の引数に
記述されたことになってしまいます。

>>170
ニ等辺三角形は現れないと勝手に思い込んでいた。
組合せではだめで、重複組合せになるのかな。
最後の述語も、

短辺はひっくり返すことも可能(_x,_x,_x,_x) :- !.
短辺はひっくり返すことも可能(_x,_y,_x,_y).
短辺はひっくり返すことも可能(_y,_x,_x,_y).

になりますか。

リスト内包表記は低能にはウケが悪い

ループに慣れすぎなんだよ

>>191
読むのにかかる時間は大違い

ttp://twitter.com/#!/yukihiro_matz/status/113795262165680128
> 私が理解している限り、「良いソフトウェア」を開発するためには「小さいチーム」と「優秀な開発者」が最重要で、
> それらの欠如をIDEやら静的型言語やらで埋めることはできるというのは幻想。
> 動的型言語は最初からそんな幻想を提供しない

そのとおりだよな

ttp://twitter.com/#!/yoshiki_shibata/status/114440801949462528
> 日本のメーカーは、ソフトウェア開発を労働集約型だと思っている人が多いのではないでしょか(仮説)。
> だから、「単価」だけしか話題にしなかったり、やたら経験の浅い人をろくな教育もせずに大量投入する。

ttp://twitter.com/#!/yoshiki_shibata/status/114442273743314944
> その結果、プロジェクトが障害だらけになって火を吹くと、担当者のスキルが低いのが原因だと分析したりします。
> そんなのは、最初から分かていること。
> 分からないで、プロジェクトを進めているとしたら、それは、スキルの低い開発者の問題ではなく、マネジメントの問題です。

まあ、言語が静的になったからといって解決できるような問題ではない。

無脳なんだな

つうか、なんでツイッターのURLとかはってるやつがいるんだよ

バカじゃないの
まともに議論する気がないなら失せろ

お前みたいなゴミが業界を腐らせているんだろうな
知的障害者スレスレの人間
ゴミグラマ

>>200
既にライブラリの有無では埋められない程の差が
一部の言語間には現れてると思うけどね
まあ、>>162が簡単すぎるなら更に一般化して任意のn項の条件式を取れるようにしてみるとか

Python

from itertools import product
def pyths(f, m, n):
    return [x for x in product(range(1, n+1), repeat=m) if f(*x)]


使用例

> pyths(lambda x,y,z: x*x + y*y == z*z, 3, 10)
[(3, 4, 5), (4, 3, 5), (6, 8, 10), (8, 6, 10)]

> pyths(lambda w,x,y,z: w*w + x*x + y*y == z*z, 4, 6)
[(1, 2, 2, 3), (2, 1, 2, 3), (2, 2, 1, 3), (2, 4, 4, 6), (4, 2, 4, 6), (4, 4, 2, 6)]

C++03の方がまだC++11より見通しがいいな
boost使えばtupleも使えるし

#include <iostream>
#include <vector>

template <class T>
struct Tri {
T x, y, z;
Tri(int xx, int yy, int zz) : x(xx), y(yy), z(zz) {}
};
template <class T>
std::vector<Tri<T> > pyths(int n)
{
std::vector<Tri<T> > v;

for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
for (int z = 1; z <= n; z++)
if (x * x + y * y == z * z)
v.push_back(Tri<T>(x, y, z));

return v;
}
int main()
{
std::vector<Tri<int> > v(pyths<int>(100));

for (std::vector<Tri<int> >::const_iterator pos = v.begin(); pos != v.end(); ++pos)
std::cout << '(' << pos->x << ", " << pos->y << ", " << pos->z << ')' << std::endl;
}

このスレでは関数型言語は動的言語扱い？

>>220
両刀使い。。。かな

ハスケルはよく知らんけど性的じゃないっけ

動的型付け ≠ 動的言語？

言葉の定義も曖昧なまま４スレも議論してたのかw

議論じゃないよ真剣n代喋り場だろう
こういうのは白黒付けるとすぐ結論が出てつまらない

>>223
当然。シェルだってPrologだってストアドだって動的言語なんだから。
実行時にメタ処理ができれば動的言語。

また変なオレオレ用語が出てきた

>>218
OCamlには product にあたる関数が標準で無いけど自作はラクチン

let rec product lst n =
  let rec p x = function
      [] -> []
    | h :: t -> (List.map (fun x -> x::h) x) @ p x t
  in match n with
      1 -> List.map (fun x -> [x]) lst
    | _ when n > 1 -> p lst (product lst (n - 1))
    | _ -> [[]]
let rec (--) x y = if x > y then [] else x :: (--) (x + 1) y
let pyths p m n = List.filter p (product (1--n) m)

使用例

pyths (function [x;y;z] -> x*x + y*y = z*z | _ -> false) 3 10
pyths (function [w;x;y;z] -> w*w + x*x + y*y = z*z | _ -> false) 4 6

>>226
メタ処理って何よ

>>218
Perl
多重ループを抽象化できるライブラリがあれば解決でしょ。

use Algorithm::Loops qw(NestedLoops);

sub pyths {
my ($f, $m, $n) = @_;
return [
NestedLoops(
[ ([1..$n]) x $m ],
{ OnlyWhen => sub{ @_ == $m and $f->(@_) } },
sub{ [@_] }
)
];
}

use Data::Dumper;
local $Data::Dumper::Indent;
print Dumper(pyths(
sub{
my ($x, $y, $z) = @_;
return ($x**2+$y**2 == $z**2);
}, 3, 10
)), "\n";
print Dumper(pyths(
sub{
my ($w, $x, $y, $z) = @_;
return ($w**2+$x**2+$y**2 == $z**2);
}, 4, 6
)), "\n";

>>229
メタってついてんだからふつーに処理のための処理とか解釈すりゃよくね

>>231
問題はそれが書けない汎用言語のほうが少ない事だ

真面目に議論してる奴とかまってもらえなくて泣いてる奴が居る件について

めんどくせーから静的型付けオブジェクト指向言語以外は
全て動的言語ってことにしとくか？

まあ乱暴。ラクでいいけどw

Haskell

lproduct lst 1 = [[x]| x<-lst]
lproduct lst m = [x++y| i<-[div m 2], x<-lproduct lst (m-i), y<-lproduct lst i]
pyths f m n = [x| x<-lproduct [1..n] m, f x]

おれはlproductがm重ループだと思ったらいつのまにか2重ループだった

>>236
そう書けば良かったのか。気がつかなかったorz

let rec lproduct lst = function
    1 -> [[x] | x <- lst]
  | n -> [ x @ y | i <- [n / 2]; x <- lproduct lst (n - i); y <- lproduct lst i]
let rec (--) x y = if x > y then [] else x :: (--) (x + 1) y
let pyths p m n = [x | x <- lproduct (1--n) m; p x]

何でもかんでも動的言語に含めたら
型安全厨を隔離するスレとして機能しなくなるだろ

>>127に飽きた人はこれもやってみて

> じゃあ、Dumpクラスを継承したクラスの全ての公開メソッドに
> 引数と戻り値を出力する処理を追加するようなDumpクラスを
> Scalaで書いてみてよ
> 動的言語なら10行くらいで書けるから

安全なプログラムを作成・保守するにはソースコードは簡潔であるべき。
そして、このスレ見ても分かるように、変数の型は書かないほうが
アルゴリズムに関係無い情報（ノイズ）が無くて読みやすい。

そもそも、変数の型みたいな処理系が知ってる情報を
わざわざ人間様に打たせるというのが時代にそぐわないんだよ。

>>239 Rubyならよっちゃんだな・・・

def Tracer(target)
　　new = Class.new target
　　new.instance_methods.each {|method|
　　　　new.__send__(:define_method, method) {|*args|
　　　　　　value = super(*args)
　　　　　　puts "trace: #{target.name}##{method}(#{args.map(&:to_s).join ", "}) ==> #{value}"
　　　　　　value }}
　　new
end

class Dumper
　　def fuck(you)
　　　　puts "fuck #{you}!"; "fuck me!"
　　end
end
class Danpei < Tracer(Dumper); end

d = Danpei.new
d.fuck "Hinata"
d.to_s

あ、「Dumpクラスを継承したクラス」か。よく読んでなかった

>>240
>安全なプログラムを作成・保守するにはソースコードは簡潔であるべき。
>そして、このスレ見ても分かるように、変数の型は書かないほうが
>アルゴリズムに関係無い情報（ノイズ）が無くて読みやすい。

それは変数の型がノイズになってしまうような言語が悪いのであって
静的型付き言語の一般的な欠点ではない。
240はたぶんJavaやC++やC#しか知らないと思う。
HaskellやOCamlなどもっと他の言語を勉強すべし。

型の重要性を理解するためだけならHaskellや普通のML系よりAgdaとかCoqみたいな依存型言語をちょっと触ればいい

> 安全なプログラムを作成・保守するにはソースコードは簡潔であるべき。
> そして、このスレ見ても分かるように、変数の型は書かないほうが
> アルゴリズムに関係無い情報（ノイズ）が無くて読みやすい。

それは数行で終わるような処理の話であって、
普通は1ファイル1000行ぐらいにはなるし、
別のファイルからの呼び出しも発生する。

その場合に、コードを読むための必要な情報（型など）が
近くにないとコードを理解するのに、いろんなことを
考えないといけなくなる。

そのため、このスレに書ける程度の短いコードを例に出すこと自体が
動的言語有意になってる。全くもって現実的ではない証明方法だ。

>>245
普通は1ファイル1000行・・・　なんてあるのかい。
私の中央値は4行くらいだな。

アルゴリズム以外ノイズてｗ

主語を省略出来て、肯定か否定かが文末の一文字で決まる言語使いのおまいらが、なに言っても説得力ねえか？

中央値4くらい、はおかしかった。ファイル行数を小さい順並べた上での中央値の意味だから。
append/3の定義を、

append([],L,L).
append([U|X],Y,[U|Z]) :- append(X,Y,Z).
を2行に表記するルールならば、多分、中央値は4.

append([],L,L).
append([U|X],Y,[U|Z]) :-
append(X,Y,Z).
で3行に表記するルールだと、多分、中央値は6だと思う。

述語は下請け述語も含めてファイル名を　concat_atom([_述語名,#,_引数の数,'.pro'],_ファイル名), で
1述語1ファイルに管理されるから、行数は上記のようになる。上の例は"append#3.pro"である。
>>245 の1000行はIDEが呼び出される可能性のある全部の述語をソースでロードしてきた時に
相当すると思うが、そんなことは絶対にしない。
中央値が6と妙に大きいのはCOBOLのように100行以上IF文が続くなどというエラーチェックは
しないが、数十節のものは少し発生するから、1-2行は大きくなる。

ファイルの行数が1000でも6でもそんなことはプログラムの管理手法に
よる差異でどうでもいい。大事な点は動的型付け言語のProlog が
節の本体に定義された述語の一部をまさに動的に部分的に参照するだけで、
プログラムが管理できるということだ。
どこかに型情報が管理されていることもないから、1000行の「一覧ソース」など
必要がない。

すみません。日本語が変だったので書きなおし。
・・・
大事な点は、動的型付け言語のPrologの場合、述語の定義節の本体から
呼び出される述語を、必要に応じてまさに動的に参照することを繰り返すだけで、
全体のプログラムを管理できるということだ。
どこかに型情報が管理されていることもないから、1000行の「一覧ソース」など必要がない。

このスレ見てる奴のために俺が代弁してやるよ


>>249-251

ハァ???????？？？？？？？？？？？？？？？???？？？？？？？？？？？？？？？
すみませんじゃねーよ
Prologの話題は隔離所でやれ

P言語でこの話題に入っていいのはPerl,Python,PHPだけ
そんなHSP以下のゴミ言語なんて誰も興味ないし、マジで何言ってるかわからないし

お前の言ってることはPrologじゃなくてもできる事だろ、
初心者がこの話題に入ってくるな　レスを消費するな

知識をひけらかすのではなく、「「「「「「「「相手を納得」」」」」」」」」」」」」」させることを考えて文章を書け
学生か子供なんですか？　つうかまず初心者だろ
いきなりなんで「中央値」なんていう言葉がでてくるんだよ

今は行数の話してんだよｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ　オンドォウールルラギッタンディスカー？？？ｗｗｗｗｗｗｗｗｗｗｗ
お前Prolog以外の言語何ができんの？　もしPrologしか「できる」って人に言えるレベルに到達してないなら、もう二度とこのスレに書き込むな　

>>252
この前はどうも。

変数/関数の型なんてコードに書かなくても、動的型言語ならデバッガで実行中に、
静的型言語なら編集中にエディタに表示できる環境があるじゃん

>>251
初カキコ･･･すみません･･･日本語が変だったので書きなおし。

俺みたいなProlog使いで中央値なんて言葉使ってる腐れ野郎、他にいますかていねーか、はは

今日のム板の様子
JAVA最強！！ JAVAはなんでもできる！！ この世はJAVAだけでいい！
ま、それが普通ですわな

かたや俺は電子の砂漠でProlog使って、呟くんすわ
it'a true Programing. BUGってる？　それ、仕様ね。

好きな中央値　4
尊敬する中央値　6　（ 7までいくとNO ）

なんつってる間に時代遅れっすよ（笑） あ〜あ、Prolog使いの辛いとこね、これ

普通は1ファイル1000行・・・　なんてあるのかい。 （キリッ）（キリッ）（キリッ）（キリッ）
私の中央値は4行くらいだな。 （キリッ）（キリッ）（キリッ）（キリッ）（キリッ）

行で話してんのにｗｗｗｗｗｗｗｗｗ単位かえやがったｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ
ワイルドキャットと零戦52型くらい違うｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ

uyにゃん可愛いにゃん(*´Q｀*)

>>250
マジレスすると
＞節の本体に定義された述語の一部をまさに動的に部分的に参照するだけで、

お前の言ってるこれは、
おそらく、「初期化情報」や初期値代入さえも、その「部分」に収まってるって事言っているんだろう

俺もそれやったことあるよ　Rubyでだけど
けど限界は知っている
その限界は、型情報と実コードを別々の場所に分離して書くよりもさらに低い場所に限界がある
大局的に見れず小さな場所でしかプログラミングやってない奴は、黙ってればいいと思うよ

>>234
COBOLやFORTRAN、Cも静的言語だろ。
動的型付けと動的言語の区別が付かないやつは書き込むなよ。

なんで限界が来るかっていうと、
その「部分」の一箇所に実行コードから初期値代入やら初期化処理やらすべてを詰め込むため
ソースコードが必要以上に冗長した場合、
そのコードの上下にかかれてるコードまでのエディタをスクロール等をして
見に行く為の時間が長くなる、

つまり常に、"ある程度"精錬されたコードをかかなければやっていけない
ゴミコードをかくと、後からきつくなってくる
で、実際俺でさえ面倒なときはゴミコードを書くときはあるので、
その書き方は、ソースコードを最初から最後まで一環して芸術作品にするくらいの気持ちで書いていかないと
とても大規模なものをかいていけるレベルではない　ようは、完成したものは完璧でも、
読みやすさを捨てざるをえなくなるか、読みやすさも捨てずにいこうとしたら、時間がかかる
素人には小規模なプログラムでさえきついし、それを扱って、C#,Rubyで普通にかいていくコードよりも
開発効率をだそうとしたら、本気で天使にならない限り無理

よくある動的型付け言語って動的言語とはちょと違わね
静的型付け言語でもGoみたいなクラス非結合な
インターフェースの仕組みをもってて、
常にインターフェースにキャストしてりゃ
動的型付け言語と挙動は変わらない訳だしね

逆に文字列から関数を生成するような動的言語の機能を
静的言語で真似ることは無理

今ある言語にそういう機能が付いてないだけで
普通に作れるだろ

そういう機能がついた時点で動的言語になるだろ。

実行中に環境から受け取った文字列から関数を作ると仮定すると、
その関数の型付けは実行時に行うしかない
だからその部分だけは動的型付けにならざるを得ない

動的言語ならjsonみたいな事できてなんぼのもんでしよ

関数作成時に型チェックできるでしょ

型宣言があろうと実行時に型チェックするなら動的型だろうに

C++もRTTIに限って言えば動的だな

関数を実行する前にチェックするだろ

じゃあ動的型言語でも関数実行前に引数の型チェックしたら
静的型付けなのか？笑わせんなw

チェック可能な関数すべてチェックすれば静的型付けだろ

*使わないAS3みたいな感じか

関数の入り口でチェックしても、式を評価する直前にチェックしても
型の齟齬があったとき実行時例外が出るのは同じだけどな。

ま、こんなコード

Object[] x = new Integer[1];
x[0] = new String();

が通る言語でも平気で静的型を名乗ってるから何でも良いか。

>>271
※コンパイル時に
だろ

>>268
微妙じゃね。非常に非力な動的機能ではあるかも知れないけど。
dynamic_castしてもシグニチャが同じだけのクラスにキャスト出来ないし。
名前の割に大して動的じゃない。

文字列から関数作るときに
コンパイルするじゃん

>>273
それのどこが動的?そのコードに実行時チェックが必要な
ところなんてないだろ

動的言語がこの世から消え去っても大した影響はないけど
静的言語がこの世から消えたら大変なことになる

この世について無知披露乙wwwwwwwww

>>239
流れ読まずに投下

class Dump(object):
    def __init__(self):
        for funname in [x for x in dir(self) if not x.startswith('_')]:
            def _(f=getattr(self, funname)):
                def __(*args, **kw):
                    res = f(*args, **kw)
                    print args, kw, res
                    return res
                return __
            setattr(self, funname, _())

class X(Dump):
    def foo(self, x):
        return "foo:" + x
    def bar(self, x, y):
        return x + y

x = X()
x.foo(x.bar("a", y="b"))

>>276
その理屈じゃインタプリタだってコンパイルしてるよねって話に
なるだろうが。

>>281
だから何？
だれもそんな話してないけど

おいJavaさんをdisるのはヤメロ

>>282
じゃ何が言いたかったんだよ

動的言語のインタプリタもコンパイルしているけど
コンパイル時には型チェックはしないだろ

そうだね。
なんかインタプリタもコンパイルするから静的だと主張してんのかと思った。

実行時に識別子を検索しない (例えばハッシュテーブルを使わない) 等
実行時の処理を減らす言語は評価できる。
最適化だけやってりゃいいのに
なぜ安全をチェックする (ただし実行時はチェックしない) 事に拘るのか理解できない。

実行時型エラーが出ても静的型付けかー面白いなー

B言語でも使ってみたら?
あれは本当の意味で型がないから。

>>288
C++以降の言語は皆出るんじゃなかったっけ？

実行時型エラーが出ない静的型言語の方が珍しいだろ。

型エラーやらセグメントエラーやらってのは、
機械語レベルで設定できらものであって全然動的じゃねぇ。
VCですらコンパイルオプションで設定できる。

自分と同じ言語で書いた、設定情報を取り込んでそのままプログラムの一部として実行できなきゃ
動的とは言えないよねぇ

>>251
初カキコ･･･すみません･･･日本語が変だったので書きなおし。

俺みたいなProlog使いで中央値なんて言葉使ってる腐れ野郎、他にいますかていねーか、はは

今日のム板の様子
JAVA最強！！ JAVAはなんでもできる！！ この世はJAVAだけでいい！
ま、それが普通ですわな

かたや俺は電子の砂漠でProlog使って、呟くんすわ
it'a true Programing. BUGってる？　それ、仕様ね。

好きな中央値　4
尊敬する中央値　6　（ 7までいくとNO ）

なんつってる間に時代遅れっすよ（笑） あ〜あ、Prolog使いの辛いとこね、これ

Meta-circular evaluatorか

>>293
急にハードル上がったな。反対はしないけど。

インタプリタ系だと実行時にコードをインクルードして
クラスやら変数やら一斉に追加できるものは割とあるよね
静的言語で似たようなことしようとするのでは手間が全然違う

あぁHaskelのことか

そりゃ言語の特徴というより処理系の特徴だな
REPLで実行するとそういうことが出来る

原理的に出来ないのと
処理系に実装されてないだけってのは
分けて考えてくれ

静的言語と動的言語の違いが分からないので外延的に定義してください

インタプリタのCで遅延includeとか許されたっけ？
規格上許されてんのは動的言語だけでしょ。
確かにC++もJavaも動的リンクは可能だけど、
インターフェースのルールを無視した読み込みは不可能。
関数単位を無視したコード読み込みなんてのも出来ない。

ソケットから受け取ったコードを同一プロセスで実行するとかってのは、
全然処理依存の問題じゃないと思うぞ。

>>301

動的言語：Perl, Python, Ruby, Prolog
静的言語：C, C++, Java

残り埋めて

>>304
この辺も動的だわ

PHP ECMAScript全般 lisp sh系全般
PostScript Objective-C Smalltalk
Haskel

>>305
なんでHaskellが動的言語なの？

インタプリタがあるから

C言語にもインタープリタあるじゃん

>>306
実行時に型を判定して分岐とかできるからでしょ。
実行時にメタ処理するから動的という話では。

>>309
スレタイ解釈のレスの応酬は前にあったけど、頭がまとまらなかった。
「動的型付けでは安全なソフトを作れない」なら主張として解る(賛同しているのではない)けど、
文字通りの「動的」だと、「使わなけりゃいいじゃない」という感想にどうしてもなってしまう。

Forthも実行中にワードを組み込むことができるから動的言語か
Objective-Cみたいな動的型付け言語を動的型を動的に含めると、
APL も動的言語なんだけどどうなんだろうね。

動的=実行時にメタ処理を行う
静的=コンパイル時しかメタ処理が出来ないし

Haskellは一度関数宣言したら同じスコープで再定義は出来ないはず
どこが動的なんだ？

>>309
JavaもC++も動的言語じゃん

じゃhaskellは静的言語だな
Evalも標準じゃないし

実行時でも、コンパイル時でも、メタ処理は黒魔術
コンパイル時なら許されるという考えは甘すぎる

効率が上がるんなら使わないだけバカ。
広域にバグをもたらすマクロとは違う。

流石に字句置換ではのぅ

json型グラフDBとかS式グラフDBとか有れば面白いのにな。
静的言語+ORMappingより格段に生産性が有るだろうに。

>>319
それやるぐらいなら
ODBのほうが生産性上がるよ。

Haskellはメタプログラミングの枠組みがあるから動的

非正格で動的な部分を全てランタイムに追い出したHaskellのどこが動的だ
馬鹿も休み休み言え
メタプログラミングは出来るが「静的に」だ

あーいや、ギャグのつもりだってばw

昔、Haskell には型がない、とか主張してた奴がいてさw

wwwそいつは頭オカシイわw


現状はこんな感じか？

動的言語：Perl, Python, Ruby, Prolog, PHP, ECMAScript全般, Common Lisp, Scheme,
          sh系全般, AWK, PostScript, Objective-C, Smalltalk
静的言語：C, C++, Java, COBOL, Fortran, Haskell

はいはいeval eval

let _ = Toploop.initialize_toplevel_env()
let eval txt =
  let lb = (Lexing.from_string txt) in
  let phr = !Toploop.parse_toplevel_phrase lb in
    Toploop.execute_phrase true Format.std_formatter phr

let f x = x + 1
let _ = Toploop.setvalue "f" (Obj.repr f);
        eval "let f x = string_of_int (2 * f x);;"
let f : int -> string = Obj.obj (Toploop.getvalue "f")
let _ = print_string (f 0)

動的言語に対する批判一覧

・静的型検査が無い => 対象：動的型言語
・型宣言が無いから読み難い => 対象：動的型言語、型推論のある言語
・メタプログラミングは黒魔術
    ・字句解析フェーズ => 対象：Cマクロ 等
    ・構文解析フェーズ => 対象：Lispマクロ、Camlp4(OCaml) 等
    ・意味解析フェーズ => 対象：型レベルプログラミングできる言語全般（C++/D テンプレート、Haskell、Scala 等）
    ・実行フェーズ => 対象：evalがある言語全般

メタプログラミングは、C++のように
型がしっかりしてれば、使って良い。

メタプログラミングに型なんてどうでもいいだろ

>>320
DB上のオブジェクトに変換が必要で
素直に取り込める訳じゃないでしょ
めんどくさい

>>329
RDBはそうだね。
DBのオブジェクトに変換が必要。

>>326
まあ、低能が扱うと怪我しそうな特徴ばかりではある

>>325
evalと動的な名前束縛があるのでOCamlは動的言語？

>>326
>>310も言ってるけど、静的型検査以外は「使わなければ良い」だな。

>>332
そりゃそうだ

>>327
はぁ？？？？？？？？？？？？ｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ

まさかお前、Ｃ＋＋　テンプレートが　効率上げるとか思ってないだろうな


やってないなら教えてやるけど
あれ違うよ　あれただの研究材料だよ


実際にＣ＋＋で開発するときもテンプレートは使わないほうがいいよ


int　でも　doubleでも　大丈夫ですｗｗｗｗｗｗｗ　とか。やめたほうがいいよ　やめたほうがいいよおおおおおおｗｗｗｗｗｗｗｗｗｗｗｗ

ｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ

やめたほうがいいよおwwwwww

動的言語では安全なソフトは作れない、じゃなくて
動的言語では低能はソフトを作れない（使いこなせない）が正しい事が分かったね

低能を売り払い少数精鋭にするか、見下しながら買い叩くか

少数精鋭（）にできる会社なんて限られる
個人に頼りすぎると、
そいつがいなくなったときのダメージが大きい

だから雑魚が大量にいるほうが会社にとって良い日本のＩＴ社会

ＪＡＶＡでも使ってろごみかす

>>335
STL使ったこと無いの？

能力ない人（自分も含む）にとって、
変数の型宣言をするかしないかって
それほど大きく影響するもんか？

むしろ動的言語での開発って
単体テストをあまり書かないってところが問題な気はする。
適当に走らせて動きをみるとかそんな感じでやっちまう。

とりあえずアホみたいに関数をオーバーロードさせといて、
もう読むのが嫌になった頃合いにテンプレート使うのが素人（俺）のやり方

>>330
RDBじゃなくてオブジェクトデータベースの事だよ。
ODBは言語上のオブジェクトそのものは解釈出来ないから、
どうしても言語側とDB側での変換が必要となる。
最もORマッピングよりはマシだけど。

>>341
型宣言が必須だと高階関数が面倒くさい
あと動的言語のほうがテストを書く文化あるだろ（テストを過信しすぎる程に）

>>344
テストについては、動的とか静的とかより、性格とか文化とか、社風とか、環境の方が影響多い気がするな

国内企業も、外資系企業もテスター経験したが、外資系企業は最低限のテストしかしたがらない

通常の手順とは別にショートカット機能付けといて、「我々は通常の手順しかサポートしないから、テストは通常の手順しかしなくて良い」とか、平気で言うもん

客からクレーム入って初めてテストするとか、普通
だったら最初からショートカット機能付けるなよ。と思った

怖くて辞めちゃったよ

> 型宣言が必須だと高階関数が面倒くさい
別にめんどくさくない。

>>346
あ、別に高階関数を使った事無い人には聞いてないです

もう何度も言われてる事だろうが、静的な型付けの言語ならする必要のないテストまで動的型付けの言語はする必要がある。

たとえば？

ベクトルの内積

let ( *- ) a b = List.fold_left2 (fun x a b -> x +. a *. b) 0. a b

もし型注釈が必須だとこうなる

let ( *- ) (a : float list) (b : float list) : float =
  List.fold_left2 ((fun x a b -> x +. a *. b) : float -> float -> float -> float) 0. a b

動的型付け言語と静的型付け言語なんてどうでもいいわ
スレタイ通り動的言語と静的言語の問題を書け

>>350
多少文字数が減る程度微々たる問題過ぎる
継承関係無視とかメッセージ転送とかもっとマトモなネタを出せよ

可読性は上がってるな

OCamlは型推論した結果をコンパイラに出力させられる（そのまま型宣言として使える）わ、
型推論の結果を使ってカーソルが当たってる変数/関数の型を表示できるわ（Emacs, Vim, Eclipse）、
型推論に対する環境が充実し過ぎ。
こんな特殊な言語の話を一般化するのはどうかと。

>>348
詳しく

>>340
本当に理解してないゴミなんだな･･･
バカか？

テンプレートを直に触るって事は、「ＳＴＬを作る」って事になるんだけど
お前はまさか、自分でゼロからかいてＳＴＬ並のものを全くバグを混入せず作れるとか思ってるわけか

　じ　ゃ　あ　や　っ　て　み　ろ　ゴ　ミ

それで開発効率（）が、上がると思っているなら　や　っ　て　み　ろ

つうか一人でやってろ（笑）ｗｗｗｗｗｗｗ

>>352
> 多少文字数が減る程度
倍以上減っててワロスwww

>>352
破壊的代入を使わずに処理と状態を持ち回るため（破壊的代入は可能なら避けたい）、

let rec cps f init x =
  let y = f init x in `T (y, cps f y)
let f = cps (fun x y -> なにかの処理) init

のような関数を定義したり、この関数をネットワーク越しにsend/receiveしたりする


で、型を書くとこんな感じ（あれ？意外と読めるw）

let rec cps (f : 'a -> 'b -> 'a) (init : 'a) (x : 'b) : [> `T of 'a * 'c ] =
  let (y : 'a) = f init x in `T (y, cps f y)
let (f : 'a -> [> `T of 'a * 'b ] as 'b) = cps ((fun x y -> なにかの処理) : 'a -> 'c -> 'a) init

>>348
もう何度も言われてる事だろうが、こういうことを書いて具体例を挙げられたやつを見た事が無い。
おそらく今回も逃げるだろう。

>>359
返り値の内部表現型をチェックするテストでも日々書かされまくってんじゃない

やっぱり動的型付け言語では安全なソフトは作れない
http://hibari.2ch.net/test/read.cgi/tech/1316887046/

>OO関連及び動的言語関連で事あるごとに争っている
>静的型付け厨と動的型付け厨が、思う存分飽きるまで仲良く
>罵り合う為のスレです。

>スレの進行を妨げる型安全議論を見かけた場合は、
>こちらへの誘導をお願いします。

>>350
名前付きの関数作るんだったら、最初から名前付き関数作れば？
代入するだけ無駄だろ。何のための無名関数だよ。

>>359
Alexに言われるまでもない。

http://www.artima.com/scalazine/articles/twitter_on_scala.html

Alex Payne: I’d definitely want to hammer home what Steve said about typing.
As our system has grown, a lot of the logic in our Ruby system sort of replicates a type system, either in our unit tests or as validations on models.
I think it may just be a property of large systems in dynamic languages, that eventually you end up rewriting your own type system, and you sort of do it badly.
You’re checking for null values all over the place.
There’s lots of calls to Ruby’s kind_of? method, which asks, “Is this a kind of User object? Because that’s what we’re expecting. If we don’t get that, this is going to explode.”
It is a shame to have to write all that when there is a solution that has existed in the world of programming languages for decades now.

>>357
3分の1も減ってなくて笑えねぇ
同じ記述を2どと書かないとか、常に10分の1ぐらいまで減らせるとかできないのか

>>364
ハッスル気味なところ悪いんだが、お前さん何と戦おうとしてるんだ？
ろくでもないすれ違いにいちいちカッカしてちゃ疲れるだけだぜ

Steve曰く、Rubyはreliableじゃない。

Steve Jenson: Another thing we really like about Scala is static typing that’s not painful.
Sometimes it would be really nice in Ruby to say things like, here’s an optional type annotation.
This is the type we really expect to see here.
And we find that really useful in Scala, to be able to specify the type information.

どうでもいい、型安全語りたきゃ隔離スレの方に書け

分けて考えるのは不自然。

OO系のスレと内容が重複するんだから隔離へ行け

危険危険とは言うものの、2000年代に登場した言語にもevalが搭載されてんのは何でだ？

>>362
は？ベクトル内積演算子をfold_left2で実装してるんだろ
こうやって新しく関数を作るのは高階関数とカリー化がある言語では当たり前
馬鹿は黙ってろよ

>>365
ぷ

正しく使ったら正しく動くっていうテストは動的型でも問題ないと思う
問題は、間違った使い方に対する正しいエラーメッセージ
これを気にすると動的型だけでなくC++やHaskellでも満足できなくなる

>>361
このスレ自体が隔離スレなのに、さらに隔離するとか鬼か

メタプログラミングで型を副作用付きで拡張する（モンキーパッチ）には動的型が必要だし、
動的言語と動的型言語がイコールでなくても、わざわざ別スレ立てるほどじゃない

>>363
自分の知識や経験から「動的言語では安全なプログラムは組めない」って結論に至ったんじゃなくて
誰かの受け売りですかwwwうけるwww

「Alexに言われるまでもない（キリッ」www

実際、ＬＬ支持者って、安全かどうかじゃなくて
自分が楽できるかどうかで物言ってるんだろ
でもそれでいいと思うよ

静的言語とか今更バカらしい
一度動的言語のよさを知っちゃうと、二度と静的言語なんて触りたくなくなるからね
趣味のプログラミングで、動的言語でも速度的に間に合うようなソフトを
静的言語で作ってるゴミカスってバカじゃないの？ｗ
そのゴミカスが学生とかならいいんだけど、良い年いっていたり、（キリッ）としながらブログかいてたりすると
周りも教えてやるに教えてやれないんだよね＾＾；

動的言語でやっていくことが大前提で、その上でどうすればよいかを考えるべき

>趣味のプログラミングで、動的言語でも速度的に間に合うようなソフトを
>静的言語で作ってるゴミカスってバカじゃないの？ｗ
>そのゴミカスが学生とかならいいんだけど、良い年いっていたり、（キリッ）としながらブログかいてたりすると
>周りも教えてやるに教えてやれないんだよね＾＾；

教えるも何も・・・
どうでも良いんじゃないの？ 趣味なんだから

数行で収まる関数を作るなら動的言語が作るの早いけど
関数やクラスの集まりであるシステムを作ると
逆に静的言語のほうが早く作れるんだよね。

それはコーディング以外占める量が大きくなるからだろう。
コーディング以外っていうのは、設計したり、コードを読んだり
修正の時の影響範囲を調べたりとかそういうことね。

動的言語だと、どうしても影響範囲の把握に時間がかかる。

>>376
静的言語をつかう理由を
動作速度だと思っている時点で
お前はまだまだだ。ってわかるよ。
まだまだな人間が言う言葉、誰も信じない。

>>378
動的型付けと静的型付けの差異ならそんなこともあるだろうけど、
このスレで対象にしている動的、静的の差異ではちょっと考えられないな。

あれ、そもそも動的、静的の差異で
動作速度に差なんてできたっけ？

そもそも>>376が言っていることが意味不明なんじゃ？

>>371
代入してる事にかわりないだろ。
あと静的型付けでも推論規則で文字数は減らせるが、
それは知らんのだろうな。

>>382
おいおい、>>350のコードはOCamlだぞ？
もちろん静的型付けで型推論だ
あと代入じゃなくて束縛
無知はお前

>>380
動的、静的って言ったら普通は型の話で、
>>2見る限りこのスレも型の話だと思ったんだけど、
このスレが対象にしてる動的、静的ってなんなの？
evalができるとかそういう奴？

>>383
OCamelに限らず静的型付け技術一般の話

>>384
技術文書じゃちょっと前は大抵動的静的ってのは自己書き換え(メタ操作)系の動作を指すことが多かった。
PerlやVBなんて動的型付けは昔から出来たけど、その辺を掘り下げて動的言語と書いてるのは見たことはない。

>>382
>>362は>>350をどう書くべきだと言ってるの？
「代入するだけ無駄だろ」「何のための無名関数だよ」の意味が分からない
たぶん382は関数型言語をまったく理解してないと思われる

ちなみに、>>350はeta-expansionする必要が無いから
カリー化でもっと短く書けて

let ( *- ) = List.fold_left2 (fun x a b -> x +. a *. b) 0.

になる。それで内積を a *- b で計算できるようになる

List.fold_left2 (fun x a b -> x +. a *. b) 0. a b
List.fold_left2 ((fun x a b -> x +. a *. b) : float -> float -> float -> float) 0. a b

使う関数の引数にコレをそのままぶち込めばいいんじゃないか。

>>389
えーと、まずそれは関数になってない（ただのfloat）のだけどね
まあ、ML系言語は知らないんだろうから（知ってたら>>382は無い）、それは見逃そう

まず第一に、お前はおそらく「高階関数を使う = 関数に関数を引数渡しする」
これ意外の用途が思い浮かんでいない、これが間違い

まあ、手続き型言語（例えばC言語のqsort）ではそうかもしれんけど、
関数型言語では、より一般的な高階関数（>>350の場合はList.fold_left2、>>358ではcps）を使って
具体的な関数を定義するのは普通のスタイルなんだ

俺は>>382じゃないんだけど・・・。まぁいいか。

let ( *- ) a b = 本体
で引数を2つとる関数定義しとんのとちゃうの？

そうだよ
val List.fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a 
という一般的な型の関数から
val ( *- ) : float list -> float list -> float
という具体的な関数を作ってる

カリー化

fold_left2 (fun x a b -> x +. a *. b) 0.      (* 二つの引数の内積を計算する関数 *)
fold_left2 (fun x a b -> x +. a *. b) 0. a    (* ベクトルaと、一つの引数との内積を計算する関数 *)
fold_left2 (fun x a b -> x +. a *. b) 0. a b  (* ベクトルaとbの内積 *)

>>374
そうか？オブジェクト指向系のスレにも型安全の話題が散発するし、
こっちのスレに書いても、動的処理の話題で型安全の話が中断して
なんども振り戻しに戻るし、型安全の話だけに集中できるスレがあっても
いいんじゃなかろうか

[](int x){return x == 10;}; C++のこれと同じだろ

>>395
俺は>>374を書いたときは動的型スレいらんと思ってたけど、
>>361のスレ見ると型安全派がじつにイキイキしてる（笑)ので
今ではこれで良かったと思ってる

>>396
何が同じなの？

>>384
>>324前後の話だと思う。

>>398
カリー化

安全かどうかはともかく静的なシェルスクリプトとか使いたくねぇ

>>400
カリー化は、例えば f : (a,b,c) -> 'd という型の関数を
f : 'a -> ('b -> ('c -> 'd)) に変換する操作を指す
また f : 'a -> ('b -> ('c -> 'd)) のような関数をカリー化された関数という

で、何がどう同じなの？

カリー化の議論はやめろーもめるぞー
http://togetter.com/li/183700

==という引数を2個とる関数を1つの引数を取る関数に変換してる。

>>404
それは部分適用

f(n)(m,l)(o);のような形はダメで
f(n)(m)(l)(o);の形でないとカリー化ではないと？

>>405
ああ10と書いたのが悪かったかyぐらいにしとけば納得したか。

>>407
カリー化はこんな感じ（C++0xでこう書けるかは知らないけど）

[](int x){return [](int y) {return x == y;};};

わかったよ。あんまり考えてなかった。カリー化議論は終わり。

結構凄腕のプログラマでも部分適用とカリー化を区別してなかったりする
プログラマとしての技量とは関係ないから、気にしなくて良いと思うぞ

>>384
動的言語は、わざわざ自分で書かなきゃならない仕組みを
言語側が用意してくれているだけの話だからね。
静的言語を使って同じ仕組みを用意しても結局速度的には同じか
寧ろ遅くなるだろう。

>>381
にレスしたつもりが間違えた

>>411 メタプログラミングのできるフレームワークがあれば自分で書かなくてもいいんじゃない？

そのメタプログラミングのフレームワークが違う言語で書かれてるってこと？

フレームワークってなに？

フレームワークというバズワードに踊る人々
http://hibari.2ch.net/test/read.cgi/prog/1309712805/

>>413
ライブラリか、ミドルウェアか、ツールキットか。
フレームワークが何をさしてるのか解からんが、
メタ情報の追加だけは、ソースをプリプロセスしない限り手書きになる。

まぁ、それはともかく、そんな周辺ツールを集めてまで
動的処理なんか書きたくないわ。言語が機能を持ってりゃ使うし、もってなきゃ諦める。

Lispみたいに、ソースコードを文字列としてでなく操作対象にできればいいんじゃね？
それでいてHaskellみたいな静的な言語ってまだ有名なのは存在してないような気もするが。

なあ
どうしてお前たちって>>381
こういうレス放置してんの？
面倒くさいから？
それともレス見逃してんの？

黄色じゃなくて赤信号だよ　完全ＡＵＴＯ　誰か教えてやって　俺忙しいわ･･･　これ煽りじゃなくてマジレスなの　まじれす。

本当にさぁ･･･どうっでもいいことばっかり躍起になって、
こういう間違いレスが放置されるから
「あれそうなのかな？」って勘違いするやつが出てくる悪循環だよね

大体ほとんどのやつはさ、自分で実践して身に着けた知識じゃなくて
誰かが言ってたそう言ってたって知識しかないんだよ、自分で実践するには、
小さなことでもたいてい１〜２時間はかかるもんだ　環境そろえたりサンプル探したりね･･･

はい　まじれすでしたよ　　動的言語も、いつかは静的言語と同じ速度まで上がりそうな機がするけどね、、、
まだ、そのアルゴリズム発見されてないです

418 あぼ〜ん
あぼ〜ん

419 あぼ〜ん
あぼ〜ん

どさくさまぎれて オブジェクト指向総合スレに変えてやったのに 藁
またこんなスレ作りやがって。

このスレは別にOO関係ないだろ
uyみたいなマジキチさんがそっちに持って行こうとするだけで

>>417
ASTにアクセスできる静的言語ってこと？あるよ

>>422
それをあの手この手を使って誘導したんだよ。 藁 当時の
ログを見れば分かる。

eval(笑)

>>381
ああ･･･お前は勉強しなおしたほうがよい

>>426
説明できないならレスしなくて良い

速度で勝てるならそれに専念すればいいのに
安全なんて言うから、速度はあきらめたのかなって勘違いするやつが出てくる

安全を言うなら形式手法ぐらいぶっとばないと
単に強めの静的型付けなだけの中途半端な関数型で安全とか片腹痛し

> 片腹痛し
病気じゃね？

scalaモヒカンが混じってるな？このすれ

ScalaやHaskellなんかPerlと変わらんぐらいの安全性しか無いし
Functorだってあの定義で保障できるのはForgetfull Functorまでだ

ここは動的型スレじゃないので、メタプログラミング可能なHaskellやScalaやMLは
どっちかというと動的言語側なんだわ

Haskellは型にうるさいじゃん
型推論のおかげで意識せずにすむ場面が多いけど

C++やJavaはHaskellやScalaよか安全性は低い
よって静的言語で安全性云々というのはナンセンス

だから型付けで分類してるんじゃないんだって（>>361のスレが動的型スレ）
つーても、俺にも動的言語の正確な定義は分からんが、
このスレじゃメタプログラミングのやり易い言語を動的言語と呼ぶらしいよ

http://ja.wikipedia.org/wiki/%E5%8B%95%E7%9A%84%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E
この説明では高階関数も動的言語の特徴に入ってる

>>3で挙げられてる内容も型についての事ばかりけど？

静的型付けとはいえ、Scalaのimplicit conversionとかは
安全厨から攻撃されるネタだね
プログラマの意図しない型変換が起こっていてもコードから分かり難いという理由で

>>437
そうだね。で、君は型の話がしたいの？
わざわざ専用のスレがあるのに、ここで？

ここは型の話をするスレ。

http://hibari.2ch.net/test/read.cgi/tech/1316887046/33
> 何故、変数の型宣言みたいなレベルの低い話になるのだろう。
>
> せめてオープンクラスは柔軟な変更が可能になるけど
> 影響範囲がグローバルになるからClassbox的な機構が必要
> みたいな議論にならんものか。

高レベルな話がいいなら、そういうスレを作ればいいんじゃないかな。

基本的にこのスレは以下のパターンを繰り返してる

(1)静的厨（Java厨）が型安全性について勘違いした主張をする
(2)誰かがその間違いを訂正する
(3)ついでに動的言語のテクニックに言及する
(4)しばらく(3)のネタで議論（このときJava厨は議論に参加できない。可哀想w）
(5)一段落ついたところで、また(1)に戻る

だから型の話を禁止するとスレ自体が過疎化する

>>436
あなたにというコメントではないけど
せめて必要条件と十分条件、必要十分条件くらい分けて考える癖を
つけたほうがいいよ。＜後悔関数と動的言語

このスレって、ちょっとした想像を適当にふくらませてコメント
してるだけだろう？だから>>443 のループをやるんだろう？
JavaにしてもScalaにしても原理主義者がいっぱいいる言語で有名だからな
かれらのオナニーのためのスレってことだから放置で医院ではないか？

>>427
だからさぁ････
こんな初歩的なこともわからないなら・・・

多分おまえ、俺に巻き込まれて透明削除されてんだよ

どうして静的言語と動的言語で実行速度に差がないとか勘違いしちゃうのか
ちょっとインタプリタかいてみろよ

どうせかけないレベルなんだろうけど　勉強になると思うよ　そういう勘違い発言を二度としないためにね
それすらやらないならゴミグラマだから死ね

動的言語がインタプリタで動くとは限らんけどな。
lispなんて元々コンパイル方式だし。
逆にCもインタプリタで動くしな。

>>440
スレ違い

>>445
> どうして静的言語と動的言語で実行速度に差がないとか勘違いしちゃうのか
> ちょっとインタプリタかいてみろよ

インタプリタと動的言語は違うでしょ。
それからJITって知ってる？

C系の動的言語では、Objective-CはAppleの力ずくで普及しつつあるけど、
Open C++やDynaceはさっぱりだな。実行時にメタ操作しようとするとどうしても、
ある種のインタプリタを内蔵することになってバイナリーがでかくなるから、
基本構文が複雑な言語じゃ普及しづらいんだろうな。

動的言語といってもさ、
実際には実行時にメソッド定義したいとか
いろんな型を変数に入れたいとか無いよね。

たいていはプログラミング時に決めるでしょ？
そう考えると、必要なのは動的であることではなくて
新しい型を定義する、簡単な記法だと思うわ。

いやモンキーパッチが活躍する場は多々あるよ。
それは別としてJsonみたいなもんはしょっちゅう使える。

だから、モンキーパッチを当てたい時って
本当はプログラム実行時に当てたいんじゃなくて
プログラム実行前にパッチ当てるので十分でしょ？

JSONはハッシュと配列の組み合わせで作れる。

作れても作りたくはない。パース処理を自前で用意したり、
外部のライブラリ借りてくるのもめんどい。
そういうとき手軽に使える。

スクリプト言語にどんな優れたコンパイラーが備わってても、型が動的であれば最適化に限界がある。

>>453
なんの話してるの？

JSON？ ライブラリを使わずに、
手軽に使えるのはJavaScriptだけだけど、
JavaScriptはJSONを解釈したらメソッドを持たない
ただのハッシュと配列の組み合わせになるよね。

>>452
C++のテンプレートを実行時に使えたら便利って時は多いでしょ。
実行時の分岐の結果や演算結果でテンプレートを展開できれば、
複雑怪奇なテンプレートメタプログラミングをせずに済む。
また、実行時の条件により型を生成できないというテンプレートの
限界を突破できる。

>>455
動的言語が直接取り込めるデータは同じ言語のデータだけなんだから
別にJavascriptでしか読み込めなくたって問題はないでしょ。
lisp用なら、lispの構文で書いたデータを読み込めれば十分。

ただのハッシュと、配列って事は全然重要じゃない。
一番は、evalだけですぐ読み込めること。

つーか、プラグインがあるアプリケーションを
開発はもちろん使った事すら無いのだろうか

Load後に速攻でプラグイン用インターフェースにキャストして使います

以下は典型的なPrologのプログラム。atom_to_termとintegerの辺りが「動的」の
所以だが。(get_lineという述語が定義済みとする)

整数を得る(_整数) :-
　　　　write('整数を入力してください : '),
　　　　get_line(Line),
　　　　整数入力検査(Line,_整数),!.
整数を得る(_整数) :- 整数を得る(_整数).

整数入力検査(Line,_整数) :-
　　　　atom_to_term(Line,_整数,VarNameList),
　　　　integer(_整数),!.
整数入力検査(Line,_) :-
　　　　writef('入力された %t からは整数が得られません。再入力をお願いします。\n',[Line]),
　　　　fail.

>>458
> つーか、プラグインがあるアプリケーションを
> 開発はもちろん使った事すら無いのだろうか

静的言語でならプラグイン開発したことあるが、
それが何か関係あるのか？

プラグイン開発は静的言語がいいよ。
インターフェースがきっちり決まってるから
わかりやすい。

>>461
プラグインは遅延バインディングの機構によって
プログラムを動的に変更/拡張するものだ

お前、動的なプログラムの変更は必要無いとか言ってなかったか？

動的言語でプラグインうんぬんは、インターフェースの問題じゃないと思うが。
静的型付けとか動的型付けは、専用スレのネタだからね。
ここでのミソは、インターフェースが元々無くてもプログラム自体にメタに介入でき
パッチの形でプラグイン化できるって所だろ。
静的言語でやると、機械語やバイトコードレベルで介入することになるからやってられん。

バイナリ互換性はソース互換性よりもずっと維持し難い。
バイナリレベルで外部モジュールとのリンクを行うと
バージョンアップでバイナリ非互換が発生して
これまでのプラグインが使えなくなったとか良くある話。

>>450
動的言語では
実行時=プログラミング時
なんだが？

動的言語はインタプリタどから重くて遅いと信じ込んでいる貴方、
「smalltalk-mt」でググるといい。
世の中には色々な変態さんがいることがわかる。

lispはC++の次に早いぐらいで、java なんかよりは早い。

>>467 ほとんどの処理系が native compile 可能だしね...

Stalinのように多大なコンパイル時間という代償を払ってる例もある。

同士スターリン

native compileしても遅いもんは遅い

実際速いんだから仕方ねえべ。
それは良いとして動的言語はバイナリー書き換えることなく、
デバッグログを仕込んだり、一度しか分岐しない分岐の削除ができる。
この辺で最適化もやれなくは無いんだよな。
小手先だけど。

lispがjavaより早いって何の冗談だよw

測ればいいじゃん。
javaのどんくささが解るだろ。

>>448
だからさぁ･･･
ほんっとになんどいっても理解しねーゴミだな

本当に、根本的な場所の知識がまったくないから
そんな勘違いしてんだよ･･･　ドヤ顔でｗ　全力で間違えてｗ　コテハンに指摘されてｗ
でも認めないとかｗｗｗｗｗｗ　バーカｗｗｗｗｗｗｗ　一生勘違いしてろよｗｗｗ
　

>>454
そういうこと

こういうゴミってさ、自分では判断出来ないから
どこかの誰かの受け売りをかたくなに信じてるんでしょ

"""どこの誰が"""　静的言語と動的言語の実行速度が　"""同じ"""　だと言っていたのか
　そ　い　つ　の　名　前　を　こ　こ　に　出　せ　


そろそろごめんなさいすれば？ｗ　　そんなにuyに指摘されて意見曲げるのがイヤかよｗ　お前のほうが技術力低いんだからしょうがないじゃん
くやしかった勉強すればーｗｗｗ

lispなんて頭がパーの奴しかもう使ってない

CommonLispが速いことも知らない"ごみかす"は黙ってろよ
なんで無知はすぐこうやって憶測でギャーギャーいってんだよ　死ね

CommonLispのやっている関数ごとのコンパイルだの、
型を明示的につけてCと同等かそれ以上の速度にまで高速化するのは、どのスクリプト言語でも理論的に可能なことではあるが
Rubyなんかじゃやってないし、やるつもりもないんだろう。
誰がどこで使うor使っているor使っていくつもり　なのかはしらないけど
CommonLispの実装自体は、キチガイみたいなハイレベルなことやってるから、舐めないほうがいいとおもうよ　無知は死ね

CommonLispとかダサ
型明示したらCと同等になる（ｷﾘｯ

あほくさ
馬鹿しか使わんわCommonLispなんて

CommonLispで書かれたコードが今すぐ全消滅しても
この世界で誰も困らない

馬鹿Lisper「型明示すればCと同等かそれ以上まで高速化する(ｷﾘｯ」

どんだけCommonLisp嫌いなんだよw

CommonLispでわざわざ型指定なんかするくらいなら
最初からまともな静的型な言語使う罠

まともな静的言語Java(ｷﾘｯ

型指定したら速くなるのは当たり前なことだし
そんなんでいばられてもな

レス乞食にレスする奴って頭おかしいの？
かわいそうに、煽ればレスしてもらえるって学習しちゃって、馬鹿の一つ覚えみたいに煽り続けてるじゃない

今時のLISP系は型推論するしw
Javaが速いと思ってるなんて…

uyよりバカって、マジ笑えるw

>>488
確かに、バカの巣窟になってるねここ。まともに論議する気にもならんし
フレーマーの暇つぶしの場所でしょ。

確かに早くなる書き方をすれば早くなるけど、
その部分は C とかの静的な言語と同等のソースになるらしい。
その手続き型なところを一関数なりマクロなりにしておけば、あとはその汚いところは見なくてすむ。
Python と C 併用するのとどっちが楽かは知らない。

AutoCADでもメインのマクロ言語としてLispが使われてるけど、
3Dグラフィックすらプログラミングできない低能には無縁だわな。

autolispはelisp未満の最悪のlispとして悪名高い

AutoCADのLispは顧客からクレームつきまくりで
別なのと置き換えられたよ

いまどきのLISP系って何のこといってんだ？

今は置き換えられた？評判が悪い？
だからどうした、現役で稼動してた実績から目を背けるなよ。

>その部分は C とかの静的な言語と同等のソースになるらしい。
Cと同等どころかうんこ以下のゲロコードだよ
全部静的言語で書いた方がはるかにまし

過去形か・・・

>>496
> Cと同等どころかうんこ以下のゲロコードだよ

速度の話と可読性の話を混同するなよ
そうやってマトモな思考能力が無いから
クダラナイ言語しか使えないんだよ

>>498
アホはおまえだ
同等なソースと書いてあるだろ

>>499
ホントだ。アホは俺だった

まぁ、速度の話はどうでもいいわな。
やろうと思えば出せますよというだけの話で、
そもそも速度を求めて動的言語を使うわけじゃないし。
プログラムのボトルネックはおよそコード全体の3/10
あとの7/10は楽に作れるに越したことはない。

規模が大きくなると残りの７／１０も静的言語の方が楽だわな

動的型付けを語り方は専用スレへどうぞ

>>502
せめて根拠を言えよ

動的が楽な根拠は？

自前で書かなきゃならない処理を、動的言語がやってくれる。
既に書いた大量のコードの管理とか特に楽。

自前で書かなきゃならない処理ってどんなん
全体のコード量はどれくらいで
動的言語がやってくれるのはどれくらいあんの？

条件に一致する関数を集めてリストに放り込んだり。
一定のルールで命名づけした関数とデータのバインディングをしたり。
データの中に関数の呼び出しを混ぜておいて、簡単なスクリプトを作ったり。
ソケットで処理方法を送り付けたり。
その他色々。

で、静的言語が動的言語より楽になる点って何処？

動的言語で実行時にならないとエラーにならないものを
静的言語なら実行しないでもエラーにすることが出来る。
これは実行する時間というコストの大幅な削減になる。

静的言語でも動的言語と同じ事を書くなら実行時にすることになるから、
チェックが働いて安全というのは意味がない。それは静的型付け、動的型付けの問題。

スクリプト内の関数呼び出しや、ソケットで新しい処理方法を送りつけるなんて処理を
どうやって静的言語でチェックすんの？

これを静的言語で書いたらどれだけ効率良く書けるんでしょうねぇ。

var functionCall = node.innerText(); //XMLから"function Method(1,2,'20')"を取得
eval(functionCall);

動的言語だと大規模プロジェクトの7/10がそういうコードなのか？

これだけで、1/10ぐらいは済む事もあるな。
パーサーいらねぇもん。でも、静的言語でコレを書こうとしたら、1/10以前に
(1/10) * 14ぐらいになるだろうな。パーサー自分で書くか、Beanみたいな仕組みを
使ってシコシコ組み立てる必要がある。

間違えた。7/10が(7/10)*14ぐらいに膨れ上がるか。

その大規模プロジェクトの規模はどんくらいよ

evalなんて危ないモンを出すなよ

静的言語でも自前で実装すれば動的言語と同じことが可能だけど、
車輪の再発明だし、処理系の実装よりも洗練されてないし、
実行時エラー処理をキチンと作り込まないと安全じゃないしでデメリットが多い

本当に大規模だと、サーバー間でプライベートなチャンネルを作って、
その中に関数を流すなんて事があった。
指示を受ける側のサーバーは、おくられてくる関数の事をしらなくていいんで
サーバープログラム自体を機能追加の度に修正する必要がなくて非常に捗った。
特に別業者が機能追加するときサーバーを直接弄られずに済んだのは助かる。

evalが危険だとか言っても、ネットに公開したりしないならどういうこともない

>>510
安全かどうかには直接関係ない。

実行時にならないとわからないエラーが
実行前に分かるという点に
時間的なコストというメリットがある。

そのぶんの時間を他のテストに回せるという点で
間接的に安全にはなる。

だからどうやって実行前にエラーだと解るんだよ。

>>522
実行時に分かるエラーの一部は、実行前に分かる。

そもそも実行前に分かるはずのエラーが
実行時にならないとわからないってのがありえない。

たとえばコンパイルエラーの類は実行前に分かるエラーだ。

じゃ静的言語でどうやって >>512 の処理で実行前にエラーを出す？

>>523
どうせ型付けの事を言いたいだけなんだろ？
そういうのは専用スレに書き込んできな
こっちより盛り上がるだろうよ

実行前にエラーにわかるようにするためには、
コード上に論理的な制約を書けばいい。

このクラスは必ず○というインターフェースを実装している。
この変数には○というインターフェースを持っているものしか代入できない。

通常これらは宣言などというが、
見方を変えれば、論理的制約でもある。

コード上にコンパイラが理解できる形で制約を書いておくことで
実行前に解るようになる。

当然何も情報がない所から、実行前に解るようになるわけではない。成約情報を入れるのは人間。
そして静的に判定可能な形で制約情報を入れられる構文を持っているのが静的言語。

>>524
誰も全てもエラーが静的に判断可能だとは言っていない。

静的に判断可能な、”量”が多いのが静的言語。

たまに完璧じゃないなら意味が無いというやつがいるが、
完璧に安全じゃないなら、エアバッグいらんのかと聞きたくなる。

>>526
だ・か・ら 型付けを言いたいだけなんだろお前は

ユーザーが書き換え可能なXMLをプログラムが読み込んで
XML内に書きこまれたメソッド呼び出すという仕様なのに、
コンパイルエラーを出せるのか？ユーザーはコンパイルしないぞ

>>527
今、動的型付けや静的片付けや、静的リンクが安全だとかの話はしてないわけだけど解ってる？

大規模プログラムの話してるつもりなんだが

大規模プログラムの話なら余計に関係ないよな。
静的言語で数千行かけて書いた処理を動的言語ならevalや
メタ構文で1行前後で済ませられる。それについての何の反論にもなってない。
1、2行で書いた処理と、安全安全といいながら数千行書いた処理
どっちがボロがでやすいかすぐ解るだろ。

>>501-502から大規模プログラムの話だったんだけどな
まあどうでもいいや

>>530
あんたが静的言語でシコシコ書いたうん1000行のevalと、
言語ユーザーによって世界中でテストされてる
動的言語機能のevalどっちが安全だよ

大体大規模開発で、evalと同等の機能作成に無駄に
費やせる時間なんてあるのかよ。ユーザーがXML中に
関数呼び出しを書かなきゃならないほど規模がデカイんだぞ。

なぜevalにこだわるw

静的に解決できる無駄な機能の話なんてしてないから

てかこののスレは

実行時メタプログラミング = 動的言語
動的型付け ≒ 動的言語

って認識だから専用スレができたんだろ

そもそも静的言語の100行程度しか短く書けないなら動的言語なんて使わんわ
静的言語の3倍以上短く書けてこそだ

evalが無いならコンパイラ呼び出しちまえばいいんじゃね

コンパイラあったら実行時メタプログラミングできるのかい

>>526
動的言語でも、静的型付けできる言語は結構あるぞ
ActionScript, lisp, Objective-C とかね

lispなんてゴミと
ActionScriptとObjective-Cを
一緒にするなよ

Lispで擬似AIすら書けないヤツがほざきおる

このスレLisp嫌いなやつ多すぎるだろ
なんか論文とか理解できなくてLisperに
バカにされたトラウマとかあるんだろうか

アラン・ケイとかAmazonの創始者とか有名プログラマーは
Lispこそ至高とか言ってんのにやっぱ底辺とは思考が違うのな

アランケイってもう過去の人でしょ

そうだねガロアも、ガウスも、オイラーも昔の人だから、お前等以下だよな

LispはSmalltalkよりはましだしな

あったりめぇじゃん、このスレに書き込んでるパソコン大先生は天才ばっかだよ。
でも、あれ・・・? 何を作った人たちなんだろ?

Lispは慣れると信者になる。
Obj-Cは慣れてもC++使いたくなってくる。

Lispはカスだとわかるけど
ガロアはわからんだろ

粕だ屑だというけどどこが不満なんだよ

Lispで作られたソフトとかろくなもんないのに
Lisperの態度のでかさとLispマンセーが目に余る

もっぱら使い捨てだが、素晴らしい成果を残したソフトなら大量にあるだろ。
いろんな研究論文で使われてんじゃん。日銭を稼ぐためにの事務処理ばっか
書いてる言語よりはよっぽど有効利用されてると思うけど。

トポロジーを解き明かすLisp
片やDBの中身を取り出して画面に表示してるだけの・・・

昔の資源がごく限られたマシンでLisp使うのは仕方ないけど
今使う奴はアホ

Lispで凄いソフト作っている人が登場
↓

ML系やHaskellができてからは研究論文においては完全に立場奪われてるじゃん>lisp

資源が大量にあったらLispよりよくなる言語があるの？
まぁHaskellとかMLはいいよね。やっぱそういう言語の事言ってんでしょ。

もちろんJavaだろ

Lispとかカス過ぎてなんのソフトもないから
RubyはLispだのJavascriptはLispだの言いだす始末

LispをScalaに言い換えて、Scalaスレで言って来てみ。お前たちに合う仕事だ 笑

Scala使っている人間は
Lisperほど横柄じゃないし

Javaとか頭が沸いてるとしか思えねぇ仕事じゃなかったら絶対使わないわ

別にJava使わない仕事してもいいんだよ？

>>560
お前がしらんだけだろ
MaximaやらEmacsやらAmazonやら非Windows系は多い

あのー 即レスくれる人がいるみたいだけど、uyみたいにコテハン
名乗ってくんない？そのほうが面白い。

>>565
古いソフトばかりやん
新しいの書いてくれないと死んじゃうわ

とりあえずJavaの内部クラスの有用性を教えてくれ。

Vim死ね

まぁ、今の時代JavaよりC++の方が儲かるしな。
CAD関連だとJavaの業務製品の7倍ぐらいの値で売れてうはうは

>>568
ない

>>560
使いどころが難しいのは確かだけど、
少なくともここ最近はみんな関数型言語の機能を取り込んできてるだろ。

だからこそJavaScriptなんかを使ってる奴が、
Lispや源流のC/C++を馬鹿にしてるのを見ると滑稽に見えるわけで。
もちろんJava厨も。

まあそういう奴らがいるから俺みたいなゴミでも食えるんだが。

>>567
最新ならOneSpace DesignerというCAD
コイツ自体がLispじゃないだろうがLispが使われてる
Lispはフルに動的言語だからプラグイン向きの位置づけが多いわな

いまどきは副作用がない言語を関数型言語というと思うんだけど
いまどきの定義だとLispは関数型じゃないでしょ

誰だよAutoCADでLispなくなったとか書いたヤツは、
AutoCAD 2011ならVisual LISPが使えるじゃねぇか。

>>574
素直にHaskellが一番って言えばよろしい。

>>573
>LispはMEマクロに代わり採用されたが、プログラマが日本では少ないのが難点とも言える。
>同様の理由でサードパーティ製のプラグインの専門モジュールが少ない。

プラグイン少なくて死んでしまいそうだわ

日本ではね

>>574
XSLTでも使えば？

Lispでマクロなんて開発者のオナニー
ユーザにとっては迷惑でしかない

なんで困るんだよ

根拠もなく感情論で言うようになったら終わりだな

圧倒的なシェアを誇るAutoCADですら
ユーザの苦情を受けて他の言語でも拡張できるようにした
無名のソフトがLispなんて採用したら自殺もんよ

Yahooを初めViawebで作られたサイトは結構あるけど
Lispの名前はあんま表に出ないな

>>583
C系上がりのプログラマにゃキツイもん
Lispでスタッフ募集しても頭数が揃わん

大学だとわりとあちこちでLisp教えてるじゃん
なんで集まらないの？

大学でLispが使えるようになったマジメな子がプログラマなんかするかいな
どうせ人をアゴで使うような職に付いてるだろうよ

Lispが優れていると思うなら
給料高くしてでも雇えばいい

>>574
今も昔も変わらないから頭に純粋を付けろ

優秀な子は2000万出すと言っても来ないだろ
電力会社や財閥系の管理職になるのがオチ

Lispが出来る優秀な子は管理職になるから
Lispのソフトが出来ないとかw

いまLispやってる奴2000万で誘えばほとんど皆来るだろ

プロコンで優勝するヤツは関数型言語が多いけど、
海外のコンテストなんかじゃ、あんまり純粋なプログラマは見かけないな。
数学関係とか物理とかが多い、変わったトコじゃ医学系がいる。

>>588
純粋じゃないやつでも
なるべく副作用なくそうとしているやつと
まったく気にしてないのがあるよな

>>485
んー・・・その"""当たり前"""のことが　PerlやRuby、
多くのスクリプト言語が出来ないんだよね

だからはっきりいってCommonLispは現在一般普及してる言語実装処理系より２歩は前を進んでいるよ

なくなっても困らない？　そりゃそうだ　誰も使ってねーし
ただ、「こういうことも出来るよ。　こうするといいんじゃね？」　というITでもっとも先進的な空間が、Lisp
ゴミバカアホプログラマは無縁の領域だから、こなくていいと思うけど、勘違いはよくないよ

別にCで拡張すればいいだけだし
出来ないのと単にやらないのを一緒にすんなよ

LispはGreat、でも俺はもう別なの使っているよみたいな人ばかり
まともな人はもうLispなんて使ってない

アレだなー
大学でLispやってるって言ってるけど

ぜんぜん理解してない奴が多すぎる
Ｓ式の有用性に気づけるかどうかって、プログラミングの経験年数じゃなくて
まさにセンスって感じがするんだよな　俺は初見で「何か」に気づいて、
その「何か」、とても異質な「何か」に、出会えたことに喜びを覚えたレベル

土方仕事じゃ、こんな知識いらんし、 Lispはプログラミング言語っていうより、
C++と同じカテゴリーの、研究用言語って立ち位置だな

アホな煽りにムキになって無理にLispで何か作ることもないと思うよ
そういう言語じゃないから

C++は研究用言語じゃないし、
研究者はもうLispからHaskellに移ってるよ

>>595
おいｗｗｗｗｗｗｗｗｗｗ
何このバカ・・・？　え？ｗｗｗｗｗｗｗｗｗ　もう一回いって
拡張？？・　Ｃで拡張ってｗｗｗｗ　何を拡張するつもりだｗｗｗｗｗｗｗｗｗｗｗｗｗ


とんでもねースレになった････　とんでもねーな････　

お前は何にも出来ないから、自分の出来ないことでも誰かは楽ーに出来ると思って言ったんだと思うけど
それ、もうやめたほうがいいよ。　次からは「自分の出来ること・やったことのあること」だけで語れ　二度も恥をかくことはない

Lisper2000万で雇いたいなら
TopLisperみたいなサイト作って
上位の奴採用したらいい

>>598
また理解してない奴が。

Ｃ＋＋　→　静的メタ
Ｌｉｓｐ　→　Ｓ式

な。

よくわかってないと思うけど、そういうこと。　説明したってどうせお前じゃ無理だ

Haskellなんつうゴミ言語はいらない

あー・・・・　やっぱこのスレ、特定の初心者が名無し粘着してんのかなー
面倒だからコテつけろよカス　バカみたいに論外な低スキルの"ごみかす"に１レス消費するのがもったいない

おれはuyみたいな低能アホ天使でもウェルカムだ

まじでごみみたいなすれだな

>>601
まあS式の研究頑張れや

>>598
流行りモノが好きな研究者モドキは、でしょう？
ついこないだまでジャバジャバ言ってた連中w

>>600
ろくなのがあつまらんって
まともなやつは、物理だの専攻してる部門に進む
奴等にとってあくまでLispは研究を進めるための道具であって
飯を食う道具じゃない

gimpも最近はpythonの拡張の方が多いぐらいだしな
昔の組み込み言語としてのlispの立ち位置の一部はpyhthonになってるのかも

一般に専門知識なしに直感的に書ける言語は普及しやすい
関数型のユーザーはいつまでたっても研究者ばっかなんだろうな

>>608
ではなぜPrologが流行らないのだ？

一般に専門知識なしに直感的に書ける言語は、結果としてBASICのように
ゴミを量産して悪評まみれになって終わる。

「新しい技術」のユーザーはいつまでたっても研究者ばっかなんだろうな、
などと言ってる奴は時代にとり残されて自滅してきた。過去、山のように。

C++は歴史的にも現状もバリバリの実践向けだろ…。
いくらなんでも知ったかしすぎ。

Lisp知っててHaskell否定する意味が分からん

C++はboostを「作る」連中は研究に片足突っ込んでる感じ
使うだけならただのライブラリ

>>608
直感的な言語は関数型のほうが直感的なんだけど・・・
どっちかというと、入門書が多い言語が普及しやすいんじゃないかと思う。

いまLispやってる奴は
まともなやつじゃないそうで

他にLisp並みのマクロがある言語があれば肯定するけど

Haskellは環境じゃないからな
Lisperからみりゃ死体の言語だ

ghci?
笑わせんな

リスパーいわくリスプはさいきょうのげんご

最強の武器を持っていながら他の言語を駆逐できないなんて、リスパーって雑魚の集まりなんですねー

誰かを傷付けることは強さじゃないのさ

Lisperは自分の作ったプログラムを他人に配ったりしない
グレアムみたく自分だけ金儲けに使う

>>604
理解してないなぁ・・・
ほんとよくそんなレベルで何年も停滞できるよ

おそろしい

uyってなんなの
気持ち悪いおっさんだな

Lisperはすべからく気持ち悪いけどな

すべからくの誤用と言ってほしいのか？

∀

Lisperはすべからくすべて気持ち悪いべきだけどな。

Lisperが気持ち悪いかどうかなど知らんし興味も無いが、
Lispのコードは気持ち悪い

Lispで書かれた有用なコード自体ないしな
大昔のがいくつかあるだけ

>>628
こういう知ったかぶるゴミって。。。



その「大昔」の「いくつか」

↑
　さ　っ　さ　と　ア　プ　リ　ケ　ー　シ　ョ　ン　名　を　出　せ　

逃げんなよ？　ゴミ

じゃあ一つもなしでいいよ
Lisperが有用だって言っているだけだし

>>629
支離滅裂になってるぞ…。
一回ガチで精神科行ってきたほうがいい。

そこで emacs ですよ。

>>630
そうだよ　「ひとつもねーだろｗｗｗｗｗｗｗ」　って事いってんだ

あるかどうかもわからないのに、お前何いってんだ？？？？ってマジで心配になった

>>631
いやそれ、狙ってやってる

>>632
誰でも知ってるアプリ名はあげなくていい　ウザい

つうか、このスレのやつらって
XMLをS式に変換出来ることもわかってなさそうなんだよ

Lispイラネとはいってても、XMLイラネとは思ってないんだろう
記述法の問題で、概念は似たようなものなのに

教養がないやつとしゃべるのは疲れる　さっさと死ねよ　雑魚


>>630こいつも逃げちゃうしさぁ　そこで何か名前だしてくれば　スレが面白い流れになるというのに、
ハッタリだから、すぐ逃げちゃう

いやXMLいらねーし

今はVimの時代
Emacs使うくらいならIDE使った方が軽いし便利

S式でそんなに感動できるならJSONで発狂するんじゃないか。
uyは見てると可哀想にはなるが、助けてやりたいとも思わないわ。

使用者だからこそわかるけど、
標準エディタとしてのviはとっくに死んでるし、
vimはemacsと同じような位置づけになってるという…。

viは俺が3歳のときに4時間で作ったけどな。

すごいでちゅね

有用がどういうことか知らないけど
そこそこ有名なあるデジタル家電のファームの一部がLispで書かれてるな。
実務で使われてるのはそれしか知らない。

vimも編集機能は慣れれば高速な作業が可能だけど、プログラミング支援って意味じゃEclipseとかVSとかのIDEには遠く及ばないな。
omni補完とか無理矢理だからな。
ま、スクリプト言語の場合、どっちみち補完効かないから、構わないけど。

＞ま、スクリプト言語の場合、どっちみち補完効かないから、構わないけど。
と思っていた時期が俺にもありました。

IDEの補完はクソ重過ぎて笑える
PCがしょぼいとかそういうレベルじゃねーだろ

$foo = new Foo;
して、$foo->でメソッド補完出来るIDEあるの？

おま何時の時代の人間だ。
foo->
foo.
abd::
asd:abc::foo->
色々補完有るし、説明も出るぞ。
なおかつ
foo->sub001( でパラメータリストも関数分出るぞ

引数やメンバ変数の補完はでんの？

メンバー変数出るぞ、enumもでる
パラメータリストは、説明が出るだけで、補完とはいえんな。
説明が出るから、それ見て入れるだけだが

補完に頼り過ぎたら阿呆なるよ。

プログラミング言語の研究は半世紀前から停滞しているのに対して
IDEは最近出たばかりだからなpython rubyよりも新しい
言語機能をいくつか追加するよりも高度なIDEの方が開発効率に貢献しているから
IDEと相性の良い言語の方が効率はいい
つまり型宣言のない言語の普及はすぐに頭打ちになるし
言語仕様をバカみたいに追加すると開発環境が対応できなくなって効率が落ちる
コード書く時間よりリファレンス引く時間が長いとうんざりしてやる気なくなる

>>650
は？IDEなんざSmalltalkの頃からあるのに何言ってんの？
Java最強って言いたいなら理論武装くらいちゃんとして下さいよwww

>>651
お前から何者にもなれない雑魚の匂いがぷんぷんしてくる

>プログラミング言語の研究は半世紀前から停滞しているのに対して
あれあれ

どっちもお盛んね

プログラミングに必要なことは使いやすく便利な道具ではなくて、細心で丁寧な姿勢。

プログラミング言語の研究は半世紀前から停滞しているのに対して
IDEは最近出たばかりだからな（キリッ

半世紀前の言語研究しか知らん、ってw
半世紀前の最先端というとGCか。Java1厨かな？

いや、半世紀前の言語研究も知らんだろ

そもそも、なぜ土方や低能は
変数の型宣言を好むのだろうか？

それが分かればこの不毛な論争にも
解決の糸口が見えるかもしれん

IDE使いにハッカーはいるんだろうか？ 疑問に思ってる。
古臭くってもvim/emacs使いなんじゃなかろうか？

eclipseなハカーは居そうじゃね？

>>659
文字列が嫌いなんじゃないの
CUIやプロトコルのような中小零細言語が嫌い

>>659
> そもそも、なぜ土方や低能は
> 変数の型宣言を好むのだろうか？

コーディングというめんどくさくて
つまらない作業を楽にできるから。

>>660
> IDE使いにハッカーはいるんだろうか？ 疑問に思ってる。

IDEかどうかは関係なく
C言語などの静的言語を使うよ。ハッカーは。

そういや、動的言語でハッカーとか聞いたこと無いな。

え？

え？ の意訳

「今から反論してやる、まっとれ。」


まってるよんｗ

>>662>>663
煽りではなく、マジでどう繋がるのか分からないんだけど

>>668
くだらないスペルミスとか、引数の順番内容とか
そんなのを覚えなくてすむんだよ。

>>665
lisp は駄目なの？

>>670
ハッカーの名前がでないなら、ダメなんだろうな。

>>669
引数の順番はキーワード引数のほうが覚えなくて良いじゃん
くだらないスペルミスはスコープがしっかりした言語や、
それこそ型推論があれば良い

言っとくが、言語開発者はダメだぞ。

言語開発者の自作言語宣伝は
ただのマーケッティングだからｗ

型安全の煽り合いは隔離スレでどうぞ

>>672
> 引数の順番はキーワード引数のほうが覚えなくて良いじゃん

そのキーワードが何かわからんだろう。
定義がなければ。

> くだらないスペルミスはスコープがしっかりした言語や、
> それこそ型推論があれば良い

スコープじゃスペルミスは防げないぞ。
型推論は型宣言のシンタックスシュガーだから。

LispハッカーといえばPaul Grahamだけど（露出的に）
俺こいつ嫌いなんだよねw

>>675
> そのキーワードが何かわからんだろう。
> 定義がなければ。

関数/メソッドの定義はあるだろ。アホすぎねお前？
キーワード引数付きの動的型言語使った事無いのかよ

ハッカーの定義はなんだよ。
リーナスやら、ストールマンか？
まさか、ケビン・ミトニックみたいなヤツとか下らない事言うなよ

>>677
だから、定義あったほうがいいってことだろ？

うん。定義があると一度書くだけで
その他の行でいろいろコーディングを楽する
サポートを得られるんだ。まともなエディタを使っていれば。

定義と宣言は違う。例えばアセンブリ言語でも定義は書ける。
ま、型安全の話は他所でやれ。

> スコープじゃスペルミスは防げないぞ。

LispやSchemeは変数宣言があるから、スペルミスして未宣言の変数/関数を書いたら
分かると思うけど、気のせいか？

そういや、定義と宣言の違いが分からないアホが居るんだったね

まあ分かるといっても実行時にならないとわからないなら、
ミスを修正するのに時間がかかるけどね。

ミスは分かるのが早いほど、修正も早くなる。

Ｃでの話ですが、たぶん他の言語でも同じだと思います。

定義 ---- 中身を書いて、名前を付ける。
宣言 ---- 名前や引数の型等だけをコンパイラに教える。

定義は、その実体を書いて、それを名前と結びつけています。
宣言は、実体はよその場所にあるけれども、こういう名前でこういうものだよ、とコンパイラに教えています。

宣言はそのソースファイルにないものを使う（例えばライブラリの使用や、ソースファイルを分割しての開発）ために必要な仕組みです。

関連事項として、間違った宣言を書いたとき、宣言とソースファイルの記述が合致していても、実際に結合するライブラリなどと食い違いがあると、コンパイル時ではエラーが出ず、結合時にエラーが出るというちょっとわかりにくいエラーが出ます。
今の開発環境ではあまりでないと思いますが。

>>676
今、給湯室で
美人の新人OLにイチャモンをつける
お局さんの姿が目に浮かんだよ。

「私、あの子嫌いなのよねw」

JIS X3014:2003の3.1 宣言及び定義では、次のように規定されています。

宣言は, 次の場合を除いて, 定義という。
　− 関数本体を指定せずに関数を宣言している場合
　− extern指定子又は<<結合指定>>を含んでいて, <<初期化子>>も<<関数本体>>も含んでいない場合
　− クラス宣言の中で静的データメンバを宣言している場合
　− 型定義宣言, <<using宣言>>又は<<using指令>>の場合

すなわち、クラス指定子は上記の例外に該当しませんので、常に定義ということになります。しかも、不完全型の場合も上記に挙がっていませんが、その後に定義でない例として記述されていますので、定義ではありません。また、定義というのは宣言の一種です。

簡単にいうと、クラスの宣言というのは、

class CSubClass;

であり、定義というのは、

class CSubCalss : public CSuperClass
{
public:
};

のことになります。

CSubClass a;

というのは、オブジェクトaの定義であって、クラスCSubClassの宣言でも定義でもありません。

だから、静的型付け動的型付けは専門スレでやれよ。
実行時メタプログラミングについて語れないヤツは来るな。

一般的な使い分けとしては、「宣言 (declaration)」はある識別子を言語処理系が認識できるようにすること(*)、
「定義(definition)」はその識別子に正確な意味を与えること、となると思います。
言語によってこれらは別々であることもありますし、同時に行われることもあります。同じ言語内でも識別子の種類によって、
宣言と定義が常に一緒のものと別々でも良いものが混在していたりします。
複数の言語に渡って一般的な説明をする場合は、どちらの動作を説明しているかによって使い分ければ良いと思います。
一方、Javaの文法の説明をしている場合は「宣言」とするのが良いでしょう。なぜなら言語仕様でDeclarationとなっているからです。
http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html

>>684
どこに対してのレスだよ

とっとと巣に帰れ　シッシッ

やっぱり動的型付け言語では安全なソフトは作れない
http://hibari.2ch.net/test/read.cgi/tech/1316887046/

>>688
これって型付けの話だったのかな？

宣言だのってのは動的言語、静的言語とは関係ないだろ、
宣言の行く末はどうせ型安全云々の下らん話だ。

定義だの云々を動的言語、静的言語に結び付けたいなら
モンキーパッチとかもっとマトモな話を出せ。

「津波に耐えられる堤防を建てよう」と宣言する
「津波に耐えられる堤防を建るとはどういうこと？」と定義(計画内容)を尋ねる

くだらねぇ話だな・・・。

モンキーパッチのどこがまともな話なのかｗ
それこそ下らないだろ。

まあモンキーパッチを実行前に適用する
言語拡張が必要だ。みたいな話なら面白いかもね。

たとえばここに、Stringクラスにmy_funcメソッドを追加するモンキーパッチングの例があるけど、
http://mahata.net/pukiwiki/index.php?%E3%83%A2%E3%83%B3%E3%82%AD%E3%83%BC%E3%83%91%E3%83%83%E3%83%81%E3%83%B3%E3%82%B0

これって別に実行時にやらなくても、
C#のように、拡張メソッドで実装することが出来る。
http://www.atmarkit.co.jp/fdotnet/bookpreview/kisokaracs_1101/kisokaracs_1101_01.html

モンキーパッチングの大半はこのように
実行前にパッチをあてることが可能だろう。

本来モンキーパッチは、オリジナルのコードにパッチを当てる行為なわけで
ソースコードに本当にパッチをあてる方法でも実装できるんだよね。

だから殆どの場合は実行前にパッチを当てられるんだよね。
それを行う構文をどうするかは別の話だけど。

実行時メタプログラミングつってんのに、
何、実行前にパッチをあてることが可能だろう(ｷﾘｯ
とか言ってんだよ。

モンキーパッチは本当は動的言語でやるのは危険なんだよ。

たとえばモンキーパッチであるメソッドを置き換える。
そうすると、その置き換えを知っているものは問題なく使用できるけど、
置き換えを知らないもの。たとえば、そのメソッドが定義された
オブジェクト自身とかの場合に問題が起きる可能性がある。

オブジェクト自身はメソッドが置き換えられていない前提でメソッドを使用している。
でもメソッドが変わってしまうために想定外の動作をしてしまう可能性がある。

だから安全に行うのであればモンキーパッチ専用の構文が必要になる。
パッチをあてる対象クラス自身からの呼び出しならオリジナルが呼び出されるとか
置き換わったメソッドの方を呼び出す範囲を決めるための構文とか。

事前にパッチを当てられるとか静的言語で出来ること例に上げて何の意味があんだよ
実行時じゃないと出来無い課題に対して実行時にパッチできるから意味があるんだろバカじゃねぇの

>>698
だから、たまたまモンキーパッチを動的言語でやれるからといって、
それは実行時メタプログラミングの範疇にするべき問題ではないということ。
だから下らない話。

動的言語がOOPLであるなんて决まりはない
C++系統の構文の問題が動的言語にあるとは限らん

>>700
モンキーパッチは動的言語の意味を示す例としては
適切ではないということだよ。

>>703
動的言語でググってきたら？

つまりモンキーパッチは邪道なんだな。

動的言語って究極には、プログラム自体がデータなんだよ。
データに近づけば近づくほど動的になる。
逆にプログラムという概念に差別化して距離を置けば置くほど静的になる。

動的言語の代表的機能がeval(モンキーパッチ)なんだけど？

ttp://ja.wikipedia.org/wiki/%E5%8B%95%E7%9A%84%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E

>>706
で、その究極の例がアセンブラ
コードもデータも全く同じ。

実行時にコード書き換えなんて当たり前。

>>707
evalとモンキーパッチは全く別物。

お前の持ってきたリンクにモンキーパッチなんてのってないし、
http://ja.wikipedia.org/wiki/%E3%83%A2%E3%83%B3%E3%82%AD%E3%83%BC%E3%83%91%E3%83%83%E3%83%81

逆にモンキーパッチのページにもevalはでていない。
http://ja.wikipedia.org/wiki/%E3%83%A2%E3%83%B3%E3%82%AD%E3%83%BC%E3%83%91%E3%83%83%E3%83%81

動的言語のアンチにマトモに動的言語の意味を知ってるヤツって少ないよな
更に言えば、動的言語の用途を知ってるヤツは極僅か
そのザマでなんでアンチになろうとするのか？

>>710
そんな内容のレスをすることは、お前にとって重要なことだったのか？

>>710
それよりも、何か具体的な自分の主張なり
反論をして欲しいところだｗ

>>709
文盲かよ

>>713
盲目も何も、書いてないものは見えんよｗ

パケットデータ自体を動的言語で組んで指定のネットワークで作業をさせる。
はたしてこれを、静的言語で安全にかつ短く書けるか？

wikipediaなんだから誰でも書き換えられる。
evalのあとに（モンキーパッチとも言う）ってネタで追加してみたらｗ

>>707のリンク先の文章でいえば、
「オブジェクトシステムや型システムの実行時変更」
が動的言語におけるモンキーパッチに該当する

>>715
それやったら、スクリプトインジェクション起こされて
脆弱性になったぞ。

どうしてくれる！ｗ

>>717
あれ？ evalは？ｗ

>>719

>709が
> お前の持ってきたリンクにモンキーパッチなんてのってないし、
って書いてたから

モンキーパッチは、やってることの形容であって、具体的な手法論じゃない。
evalはあくまで具体的な手法。
モンキーパッチをevalで実装してる例はぐぐれば大量に出てくる。
http://www.google.co.jp/search?gcx=c&sourceid=chrome&ie=UTF-8&q=Monkey+patching+eval

>>717
少し論理学を勉強したほうがいいのではないか？

「オブジェクトシステムや型システムの実行時変更」が
モンキーパッチなのではなく

「オブジェクトシステムや型システムの実行時変更」の
適用例の一つがモンキーパッチ。


だが、モンキーパッチは本来に実行時に変更する必要はなく動的にやる意味も少ないから
「オブジェクトシステムや型システムの実行時変更」の適用例としては
ふさわしくないというのが話の流れだ。

>>721
それただの検索クエリーじゃないかｗ
自分で探してこいよ。まったく行動が糞ガキ全開だなｗ

>>718
単にチューリング完全で、指定外のデータや関数へのアクセス権が無けりゃ簡単にできるわな。
SQLでOS自体のカーネルを消せれるか？それと同じだ。

> SQLでOS自体のカーネルを消せれるか？それと同じだ。

SQLインジェクション起こされちゃったｗ

>>722
だから>>717では「動的言語における」って枕詞付けたのに

つけたから何なんだろう？

>>723
1ページづつ表示して、これがモンキーパッチを使った〜プログラムです
これはモンキーパッチを使った〜プログラムですと紹介して欲しいのか？

現実にコレだけ掲載されてることが重要だろうが。

>>725
SQLインジェクション起こして攻撃されるのはDBの中だけだよな。
まぁ、攻撃されたDBのデータを表示すれば被害が起きるかもしれないが、
破壊されるのはDBという砂場だけだ。

>>727
だから静的言語におけるモンキーパッチはまた別の話ってこと
なのに>>722みたいなのを得意顔で書くお前は
論理学どころか日本語を学び直した方が良い

>>728
モンキーパッチをconstで実装してる例はぐぐれば大量に出てくる。
evalで実装している例よりも多くでてくるぞ。
http://www.google.co.jp/search?gcx=c&sourceid=chrome&ie=UTF-8&q=Monkey+patching+const

何が言いたいのか分かる？
evalで検索して出てきたからって、
モンキーパッチとは全く関係ない話かもしれないってことだよ。

>>731
intが付いてれば全てオブジェクト指向言語か笑わせる

>>731
> モンキーパッチをconstで実装してる例はぐぐれば大量に出てくる。

え？

evalが付いてれば全てモンキーパッチか笑わせる

>>733
最後までちゃんと読めよｗ

「evalでモンキーパッチを実装している」と「evalが付いている」の区別ができない人が・・・

モンキーパッチをconstで実装してる例はぐぐれば大量に出てくる(ｷﾘｯ

モンキーパッチは他所でやってくれ

簡単な文章なんだから英語ぐらいよんだら？

http://giorgiosironi.blogspot.com/2010/09/monkey-patching-in-php.html

PHPでeval使ってモンキーパッチを実現する例だが、これ読んでて「eval」が
「付いてる」だけとか言ってたらもう話すことはないわ。とりあえず自閉症の養護学校行ってくれ

それより　>>729　についてどうなった
音沙汰がないが

sandboxという概念を知らなかったとかだったりして

サンドボックス上では動的言語は問題にならんわな

同スコープでそのままパッチしないでeval使う意味がわからない。

スクリプト実行時にeval使うって意味だと、
MonkeyPatchingの実装じゃなくて、前段階の話になっちゃうし。

お前の言っている意味も解からんわ
evalはダイナミックリンクじゃないから、呼び出し元の変数を変更できるんだけど。
evalはそれができないと言いたいのか？まぁ、言語によるだろうけど。

js> var x=10;
js> eval("x=20");
20.0
js> java.lang.System.out.println( "x:" + x );
x:20

javascriptなんかは自由にプログラム内の変数にアクセスできるな。

>>744
そのままコードを書けばいいだけで、evalする意味ないだろ。
動的言語の話ししてるのになんでダイナミックリンクが出てくるの？

>>745
rhino？

プログラムが完全に閉じてて実行時に外部からメモリ空間書き換えなきゃならんとかってルールはないだろ
自由に作業できる入口を一個だけ用意しとけばいい
あとは、その入口からメタ機能を利用してプログラム全域を書き換えるだけだ

>>747
yeah

なんだ。eval（モンキーパッチ）とか言っていたのは
PHP厨房だったのか？通りでレベルの低さを感じるわけだｗ

>>739
それ、モンキーパッチに相当するコードは、
function strlen〜の部分であってevalは単に読み込んだファイルを実行するのに使ってるだけじゃん。

しかもモンキーパッチ（既存の関数の置き換え）ではなく、それはただの名前空間に追いやってるだけ。
> This isn't "monkey patching". This is just namespaces.
ってリンク先のリンク先のコメントで指摘されてるよな。

requireは実行前に読み込まれるから論外として、実行時に読み込まれるincludeでも、
名前空間は独立するものになるのだろう。
だからファイルとして読み込んでevalで実行しているんだ。

あー、本当にレベルが低い。

「evalを実行するコード」を読み込みできるなら、
わざわざevalを使う必要ないじゃないの。
MonkeyPatchを実行時生成するならevalもわかるけど、趣旨とは違うし。

本当のモンキーパッチは名前空間に追いやるなんてことは必要ないため
名前空間に追いやるために使っているだけのevalは不要。
モンキーパッチとは無関係であることが自滅によって証明されてしまったようだｗ

ごめんあと一言いいたい。
eval使ってグローバルが書き換わってるのを見て喜んでるのは馬鹿だからな？
外部から読み込むならsandbox使えボケ。

>>750
機械翻訳ご苦労さん。
それはそうとrunkitはどう思ってる。

>>754
話しそらそうとしても無駄だぞｗ

いい加減evalはモンキーパッチとは無関係だと
認めろよ。

つか、機械翻訳なんて使ってないしｗ

自分じゃねーの？ レベル低いPHP厨房さん。

グローバル変数が書き換わることなんて重要じゃないんだがね
ましてやモンキーパッチも大して重要じゃない

動的言語の話としてわな

>>745
REPLが既にeval（笑)

>>757
だから、俺は>>695の時点でモンキーパッチは動的言語の
話題としては下らないとさっさと切り捨てたんだがｗ

>>758
常識じゃね？なんかウケることが？

>>759
じゃ動的言語らしい話題を出せ

あ、>>452の時点で指摘してたわｗ

>>756　そのわりにかなり間があいたな

>>760
js> eval("x=20");

>>764
何がおかしいのかさっぱり

>>761
俺は動的言語？ ぷｗｗｗの立場だから
出すつもり無いわｗ

それよりか、現在動的言語でしかできないようなことを
静的言語として実行前に行う言語仕様を考えるほうが興味あるな。

本当に動的言語でやるべきことなんて
実際はかなり少ないと思ってる。

eval("eval(\"eval(\"eval(\"10\")\")\")\");

インタプリタを含めていくらでも再起できるけど笑いのツボが解からん

>>765
eval(eval(eval(eval(eval(eval("x=20"))))));

>>763
ずっと２ちゃんねる見てたわけじゃないし
機械翻訳なら逆にすぐにレスできるだろ。

時間見てみ、30分ちょいあるだろ？



アニメ1話見てただけだｗｗｗ

時空を超えた

>>769
いやバカだから日本語にしても読めないだけかと思ったよ

eval("eval('eval')")("eval('eval')")("eval('eval')")("x=20")

>>771
馬鹿ってのは、evalをどう使っているのか、
ただのPHPという貧弱な言語仕様の制限をかいくぐるためにに使っていて
モンキーパッチとは直接関係ないことを見抜けなかった奴のことかな？ｗ

>>766
じゃ「現在動的言語でしかできないようなことを
静的言語として実行前に行う言語仕様」とやらを教えてくれ
妄想でいいから

>>774
すでに書いたけど。

> 696 名前：デフォルトの名無しさん[sage] 投稿日：2011/10/01(土) 00:36:42.61
> たとえばここに、Stringクラスにmy_funcメソッドを追加するモンキーパッチングの例があるけど、
> http://mahata.net/pukiwiki/index.php?%E3%83%A2%E3%83%B3%E3%82%AD%E3%83%BC%E3%83%91%E3%83%83%E3%83%81%E3%83%B3%E3%82%B0
>
> これって別に実行時にやらなくても、
> C#のように、拡張メソッドで実装することが出来る。
> http://www.atmarkit.co.jp/fdotnet/bookpreview/kisokaracs_1101/kisokaracs_1101_01.html
>
> モンキーパッチングの大半はこのように
> 実行前にパッチをあてることが可能だろう。

>>767
evalのメリットを語るのにeval前提であるという矛盾。
喩え下手の馬鹿を見るのは微笑ましいなぁと。

件の記事は名前空間を使った非侵襲的な動作。
本質はsandboxの使い方というオチ。

>>775
そんな下らないことはいいから、ユーザーが書いたプログラムを制御するスクリプトを、
実行中のプログラムが、片安全に読み込んで実行する例とか書いてくれ。

型安全である必要はないわ、それはあっちのスレのネタ出し

>>778
散々でてますけど。

>>776 ますます意味が解からん

話の途中だけど、風呂入ってくるわ。
２ちゃんねらに俺の生活のリズム合わせるつもり無いんでｗ

ちゃんと書いてないとまたレスするまで間があいたと言われそうだからな。
風呂入りながらネギま！4巻ほど読むから、
それなりに時間は空くしレスしないで寝るかもな。

じゃｗ

>>778
それは動的言語とは全く関係ない。

>>780
どこに？

>>784
evalとsandbox
例外受け取ればもう十分だろ。

>>783
動的言語なら簡単に書けるじゃん。
文字列をそのままプログラムとして同じプロセス空間で実行できるし。

静的言語でも同じぐらい簡単に書けるのか？

>>781
そっか。
なんだかごめんね。

>>785
eval ができた時点で動的言語じゃん。
実行時メタプログラミングができたら動的言語だろ。

http://www.infoq.com/jp/news/2011/09/twitter-storm-real-time-hadoop
>ほとんどが Clojureで書かれている。

>>788
JavaでJavaScript動かしたらどうなるの…と。

>>790
"やっぱり動的言語では安全なソフトは作れない"と言う資格を失う

まぁ実行時にソースレベルで書き換えができりゃいいだけで、
evalだけが動的言語でもないけどな。
構文木を外部から取り込んだ情報を
元に書き換えるってのも動的だ。

>>790
Rihnoでも呼び出し元のプログラムに介入はできなかった。
操作できるのはJava のライブラリの表面だけ。
現実にはjavascriptでJavaのメタプログラミングは不可能なのかもね。

>>793
それはリフレクション使えばいいんじゃないか。

>>789
このスレが終焉に向かう。

>>794
リフレクションは表面だけでしょ

すれ違い気味な話だが、Rhinoで動的な機能も使わず普通にコード書ても
Javaのリフレクションと同じことがスゲー簡単に書ける。

var pack = java.util;
とか
object["sub" + "string"]( 10 );
とかね。

>>796
コンパイラもつければいっちょ上がり！

>>797
http://java.sun.com/javase/ja/6/docs/ja/technotes/guides/scripting/programmer_guide/index.html#jsengine

RhinoとかSpiderMonkeyなんかのブラウザ以外の実装使ってしみじみ思うのは、
SleepとThreadがあるだけでJavaScriptがどれだけ便利になるか…ってことだな。

>>799
スタンドアロンというかデスクトップでも結構使えるよな

夜中の間に変な感じで議論が進んだんだな

モンキーパッチがもっとも活躍するのは
ユニットテストでモック/スタブを作るとき

まあ、テストしない土方には関係無いんですけどね

パッチを当てたコードは
パッチをあてる前のコードと同じなの？
つまりちゃんとしたテストになっているのか？

>>802
それはdllでもjarでも同じ問題があるね
バイナリファイルは中身を見るのがむずかしい
テキストは最高だぜ

ユニットテストでモック/スタブを作るときに
モンキーパッチをするのは間違い。

モック/スタブを作るならば、同じインターフェースを
備えたラッパーを作るべき。

中身を見れることに依存すると、中身が見れない、
つまりソースコード非公開ライブラリでは使えない
汎用性のないテクニックになる。

>>804
なんでホワイトボックステストができる対象まで
ブラックボックステストに限定せないかんの？アホなの？

>>805
そういう話ではない。モンキーパッチはパッチ。
つまりオリジナルのソースコードの書き換えそのものなのだから、
モックやスタブの場合のみにパッチをあてるやり方では同じ動きにならない。
適用箇所を間違っている。

つーか、なんでもモンキーパッチという奴ってなんなの？
やってることをちゃんとわかってるのか。

>>806
は？パッチって言葉から想像だけで書いてるだろ

>>804
そのインターフェースとやらの方法で
privateなオブジェクトやメソッドローカルなオブジェクトを
オリジナルのソースコードに変更を加えずにモック化してみろ

>>807
モンキーにそれほど重要なことが含まれてるのかｗ

つか、反論あるならちゃんと中身を言えよ。

>>808
それはモンキーパッチでもできないじゃんｗ

>>810
できる。余裕

モンキーパッチはもともとゲリラパッチと呼ばれていたことからも解るように、
本当ならやらないほうがいいパッチなんだよ。

もちろん意味が無いテクニックくとは言わない。
だがそれは”普通のコード”で実現できなく、
外部のコードを自分の開発の制御下に
持ってこれない場合に行うもの。

テストなんてのは、自分が開発したコードに対して行うもので、
当然自分の開発の制御下に置くものだし、置けるはずのものなんだから、
そんなどうしようもない場合に用いるテクニックを多用する時点で、
自分が開発したコードがテストがしにくいコードになってると言わざるを得ない。

落とし穴 [編集]

丁寧に作られていなかったり、ドキュメントが貧弱だったりするモンキーパッチからは、以下のような問題が引き起こされることがある:

状況が変わり、そのパッチが、変更される対象のオブジェクトに対して仮定していることがもう正しくなくなってしまった場合に、
アップグレードにまつわる問題が引きおこされる。もしもパッチを適用したプロダクトが新バージョンになって変更されると、
パッチが壊れて動作しなくなる可能性が高い。このような理由からほとんどの場合において、モンキーパッチは、条件をチェックして、適切な時だけ適用するように作られる。

もしも、同じメソッドに対して、2つのモジュールが同時にモンキーパッチを適用しようとすると、
それがalias_method_chainのようなパターンを使用して書かれていない限りは後から実行した方が"勝ち"、
もう片方のパッチは動作しない[4]。

モンキーパッチを適用すると、ディスク上の元のソースコードと、見た目の振る舞いが異なるため、
パッチの存在に気づかなかった人を混乱させる可能性がある。

例え使用されていなかったとしても、プログラミング言語内でモンキーパッチを適用できるということは、
強いカプセル化を強制することと両立しないため、モンキーパッチの機能の有用性は問題である、
と見る人も中にはいる。このオブジェクト間のカプセル化は、Object-capability_modelで必要とされる。

モンキーパッチの落とし穴を知っている人、気づいている人なら
信頼性を担保するべきテストコードで
テスト時にだけモンキーパッチをあてる方法は
使えないとわかるはずなんだがな。

>>801
> モンキーパッチがもっとも活躍するのは
> ユニットテストでモック/スタブを作るとき

お前、昨日 「eval（モンキーパッチ）」と
言っていたやつだろ？

お前はもう喋るなｗ
お前が喋るとどんどんふりになる。

なんでもモンキーパッチでやろうとすんなハゲｗ

ひどいな。叩かれまくりだな。




俺も仲間に入れろやｗｗｗ

>>808に反論できなくて発狂してんのか？w

>>806
>そういう話ではない。モンキーパッチはパッチ。
>つまりオリジナルのソースコードの書き換えそのものなのだから、

根本のスタートが間違ってるから、Wikipwdiaで急遽調べたわけでも無さそうだな。

書き込みから漂う圧倒的な土方臭から
>>812-817が同一人物だと分かる。

>>820
それを言うことは、お前にとって重要だったのか？

本当にお前たちって、知能低いんだなって思う

ここ１００レスでやたら同じ単語が連呼されてるけど

お前らがサルに見えるよ
同じ単語を何度も連呼してるのは頭が悪そうに見えるからやめたほうがいいよ
実際に悪いいんだろうけど

悪いいって結局いいのか悪いのか

>>775
拡張メソッドなんて、Objective-CのCategoryと同じで、
全然動的言語の代用にならねぇじゃねぇか。
拡張性のある言語デザインの話であって
動的静的の問題点とは完全に別物

>>824
どうも、理解能力が足りないみたいだね。

ほんとうの意味で動的言語が必要な場面は少ない。
例えばオブジェクトにメソッドを付け加えるのは
動的言語である必然性はないってことだよ。

君はどうしても動的言語でなければいけない例を上げればいい。
俺はそれを静的に解決する方法を考えるだけの話。
拡張メソッドのように静的言語で解決する方法はあるはずだ。

オブジェクトにメソッドを追加したり、クラスを拡張したり
するだけなら動的処理必要ないだろ。テンプレートで十分だ。
そもそもOO関係で動的機構が必要になる機械は無い。
動的言語機能が必要になるのは、もっと原始的なレベルの話。

そう。たとえば動的言語はアセンブラのようなもの。

コードを実行時に書き換えたいと思ったのは
何十にも暗号化されたプロテクトコードが
自分自身の暗号を解除している処理の途中に割り込んで
動的にパッチあてていった時ぐらいだよな。

いいえ

動的に書き換えなきゃならないケースってのは

起動に時間のかかるようなプログラムや
頻繁に小さな変更を与えて行かなくちゃならないようなやつだよ

お前たちみたいなゴミッカスが触れる機会はないと思うから気にしなくていいよ

>>830
具体的に、どの製品の話をしているのですか？

例えばプラグイン的な仕組みを作った静的言語・・・C言語とかは
静的言語でいいんだよな？

ソースレベルで操作できることが動的言語の最低条件だろ。
動的言語で作成したバイナリーは、それ自身が動的言語の
インタプリタとして動作するように作れなきゃならない。

無論動的言語でも、外部からソースを読み込ませて動的機能に掛ける
コードを書いてなけりゃ無理だがそれは別の話。

ミッションクリティカルなところじゃ再起動みたいなことやってれば
オワコンじゃろ？
そんな時は動的書き換えができることって重要じゃよ。
たった数秒のリセットのお陰で、宇宙空間のどこかに飛んでいったとか
たった数秒のリセットで相手のミサイルから逃げられなくぶち落とされた
じゃどうなる？

>>834
あほか。

ミッションクリティカルなら、動的に書き換えるなんて
馬鹿やるわけがないだろ。元に戻せないだろうが。

本当にミッションクリティカルなら
待機系サーバを用意して切り替えとか
そういうふうにして修正を行うんだよ。

やっぱり素人かよ。

俺は動的言語も使うけど、これは>>835の言う通りだと思う

>>834
だからお前はしゃべるなって言われただろ？ｗ

ミサイルから逃げるなにかを制御するプログラムを動的にパッチ当てるってどういう状況

べつにいいんじゃよ煽りを相手にしてるからじゃ

>>838
素人の考えることだからなｗｗｗ

ミサイルハッキングされました！
なに？ 正常プログラムで上書きするんだ！
書き換え完了、再起動命令送信！・・・再起動、間に合いません！
ちくしょーちくしょー動的言語に、動的言語にさえなればー！

とかそういうアニメでも妄想してんだろｗ

そんなのどうでも良いから>>808を静的にやってみろって

>>841
例として動的言語でどうやるのか
書いてみて。

>>831
こういう勘違いゴミカスっているよな
ここは「ム板」であって、仕事の話ならマ板にいけよゴミ
製品だぁ？


たとえば動的にコード書き換えたいと思うのは2chBOTだな
荒らしやってると、結構すぐに対策してくるんだよ

まぁミサイルの話もでたけど、
「目標」が、動的にプログラムを変えてくるなら、
こっちも動的にソースコードを変えていきたいわけだよ

何らかの「イレギュラー」が発生する可能性の高い場面では動的に書き換えられないで再起動なんてお話にならない

低俗な話がしたいなら、C++ならマクロでアクセス指定子書き換え、
オフセット調べて書き換え、JavaならsetProperty

まともに答えると、普通は動的書き換えなんて考える前に再設計
依存部分を抽象化(インターフェイスに)して分割、後から注入
メソッド変更したいなら継承

不可能ならそれが設計
テスト内容自体が間違ってるわけで、動的、静的関係ない

>>843
動的に設定変えられればいいだけで、もはや言語すら関係ないな
プログラミングすらできるか疑わしい

>>838
えーと…ガンダムSEEDとか？

>>845
うわぁ･････････　本日の一番の恥さらし決定

あのさぁ、そこまですべてのコードを洗練させれるなら
動的にコード変更したい！　なんて誰も思わないわけよ

イレギュラーって言葉の意味わかってないな　ゴミッカスには早い話だって最初から言ってたけどね　俺は。
下手に噛み付くから、そうやって恥ずかしいことをかいちゃう

初心者にありがちなのは
「すべてのコードを完璧に」なんだよ

そりゃ、全部完璧に、いつも完璧にかけるなら　それでいいさ
しかし、実際には「　本　番　は　そ　こ　ま　で　甘　く　な　い　」
クラックにしても相手が対応してくる前にスクリプト完成させて攻撃するんだよ
オブジェクト指向が・・・えーと・・・クラス？
なんてやってる間に対策される

最低限読める程度のコードで、さっさと作るんだよ　外部ファイル読みだし？　そんなことやってる暇はない

仕事もそこまでシビアではないにしても、時間との勝負って面では同じだね。いくらでも時間かけていいなら
完璧にできるさ。　学校は卒業しろよ？

おまえも就職しろよ。アーキテクチャーを自然に考えられないと、猿にタイプライター叩かせてるのと変わらんからな。

うむ同意

結局安全性の話は何処へ行ったんだ？

それは動的型付け言語スレへ行ったんじゃね
こっちのスレのほうが隔離スレっぽ

uyは最高に使えない奴
技術的な話になるとすぐ逃げ出すし

時間かけたらできるって言う奴はまずできない。

>>854
じゃあお前はテトリス作れるか？ 1時間で。

じゃあって

>>855
なんで俺に聞くの？

>>857
「時間かけたら出来るっていう奴はまずできない」と言ったから
お前はこの質問になんて答えるか知りたかったからさ、

>>858
「それだけじゃ見積もりできませーん」

>>853
たとえば？

もしかしてお前さ、
俺がいろんな場所にレスしてるの知らなくて

uyはこのスレしか見てないとか思ってないよね？

悪いけど、俺マ板ム板の99%のスレッドに書き込んでると思うお

そんなのをいちいち全スレのレスチェックしにこねーから　ゴミか？　バカか？

何か言いたいことあるなら早めに言ったほうが良いよ

99%は言い過ぎって分かってて言ってるでしょおまいさん
別に常に自分の書き込みがおもろいとでも自負してんなら良いのよ、他人が云々するこっちゃない

本当の問題はおまいさんの書き込みが日々つまんなくなってる点だよ
なんか悪いのか？
クズでも言える煽りはクズに任せとけばいんじゃね

今も昔も無能である事は変わんないけど
恥知らずだったのが恥を知りはじめちゃったのが
つまらなくなった原因じゃないかな
きっと、ちん毛が生え始めたんでしょう。

恥ん毛？

>>861
リアルに99%のスレに書き込んでるよ
毎回コテなわけじゃないし

煽りがつまらなくなってるって感じるならお前は観察力が高い
なんか最近めんどーになってきたから、すげー勢いまかせでかいてる
以前は「あ、これ投下したら10人中8人相手をイラつかせることができるな」って文章を考えてたけど
最近は10人中5人程度をイラつかせるような　ワード　を文章に入れ
あとは適当に文字数を稼ぐために駄文詰め込んでるだけ

俺が言うのもなんだけど、こんな適当にかいてるレスを読んでる奴って、物好きだなと思う

時代はc#とruby。

>>865
俺もこれからの時代のドカタ言語はその２つになるんじゃないかと思ってる

ドカタ言語とか言って差別する奴ほどろくなコードを書かないよな。何を使ってもw

時代はjavaとjavascript

差別っつうか
単純に使いたくない　触れたくないない　だけかな

ドカタ言語ってまだやさしい表現でさ

真実を言っちゃうと　ゴミ言語　ってことだよ　でもそれだと
言葉が少しきついから、譲歩してドカタ言語って言っているだけなのに

jsとPHP、Rubyあたりはウェブドカタ言語だね

え？土方言語って給料のためにコード書く場に適した言語のことじゃないのか
一概に馬鹿にしてるとは言えん気もしてたんだが

いのなかのかわず

田舎の川の図

つか、言語で土方とかきまんねーよｗ
どういう理屈で決まるんだよ。

>>874
少なくとも言語で「土方ではない」は決まるよ
決まるよ

単に、俺が使いたくない言語ってだけだろ。

はたから見れば、好き嫌いにすぎないのに、
自分のわがままであることを認めたくないから
土方言語なんてのがあるかのように言い張る。

結局は、土方言語なんて言っている人の
心の弱さの現れなんだよ。

「お前の母ちゃんデベソ」みたいなもんだよな。

好んで使いたい訳じゃないがちょくちょくphp案件回ってくる。
こればかりは好み関係なく土方言語だと思うわ。

>>876
うまくまとめに入ってるｗｗｗｗ

お前ほんと心弱いな
もしかしてJAVAが折れたらお前も折れちゃうの？

そりゃあ悪いことをした











折れろゴミｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ

その必死さが、心が弱いと・・・

頭良い奴はプログラマーにならないよな普通。

>>881
全力同意

せやな

反論できんわ

土方A　「やっぱスコップ最強だよなー」
土方B　「あ！？ツルハシが使いやすくて良いに決まってるだろ」
土方C　「複式ショベルが早くていいとおもうんだけど」

現場監督「アホかこの現場にあるもんでやるしかなかろうが手え動かせ手え」

土方は考えなんてないからね

真っ直ぐにしか走れない


真っ直ぐにしか走れない頭の悪い土方をどうやって使うかが上の仕事
生かすも殺すもさじ加減

優秀な人が
道具に拘るのは
極普通のこと。

○的言語みたいな大雑把な特徴では拘りが足りない。

>>887
それは間違ってるよw

>>889
なんで間違ってるの？
お前が道具に拘ってないのは、お前が優秀じゃないだけのことだろ？

>>890
きみは否定されるとテンション上げて反論してくる典型的なダメプログラマーだね。
疲れるプログラマーの相手は現場だけにしたいところw

まさか土方でさえ分かることを反論されるとはw

道具に拘らない優秀な人って誰？例くらい挙げられるでしょ？

日本人で本当に優秀なプログラマーだったら、アメリカ行ってるだろうからな。
ゲームすら通用しなくなった日本企業に世界的なソフトウェアは存在しないし、
プログラマーじゃ収入もたかが知れてる。

道具に拘らないなら動的言語でも静的言語でもどっちでも良いってことか
このスレ要らんな

その発想はなかった

どっちも良いという考えは駄目なの？
拘りなんて捨てて、状況に応じて使う奴のが優秀だと思うんだが。

状況に応じて使い分ける奴は「道具に拘ってる」

一つの道具に拘るだけが拘りじゃないからな
使い分けることに拘るのも道具、手段に対する拘りといえるな

手段に拘るというメタ手段への拘り

>>881-882
それでも、数学者や理論物理学者は狭き門なので、それに成り得なかった様な
人がプログラマーになったりはすると思う。そういう人は、他の分野の研究者
には、もっと成りたくないから。

>>896
そんなのみんなわかってるわけで

暇潰しのスレでなに言ってんの？

さて、今日は動的厨でもやるかなw
かかってこいよ静的厨

「弘法筆を選ばず」の空海は状況に応じて筆を使い分けたそうな
そして「良工は先ずその刀を利くし、能書は必ず好筆を用う」という言葉を残してる

まあ、散髪屋でも多種類のはさみを使い分け、名職人も独自の自作の
道具を使うことは事実。

でも、プログラミングに置いては、さて、どうかなと疑問に思う
な・・・。

今までに自分で作った関数群の蓄積が役に立つこともあるので、
言語をころころと変えるのは非効率と言うこともあるかな。
その辺が、ハサミやノミなどとは違う理由かも。

>>881-882
Googleに入社するためのIQは、あらゆる企業の中で最も高いそうだ。
他の調査でも、プログラマより頭がいいと思われるのは、
理論物理学者と数学者くらいらしい。

給料の高さと頭の良さは必ずしも関係ない。やりたい職業をやっている
人も多いから。

「拘る」が肯定的な意味だと勘違いする
のが多いのは、マスゴミ脳って奴だな。

システム手帳極薄カード型電卓とか、極端にニッチな道具も面白いものよ。

>>905
このスレで言う「プログラマ」ってGoogleのエンジニアのようなひとのことなんだ
知らなかったよ

>>908
「Googleのエンジニア==プログラマ」

でないとしたら何なんですか？

ネットワークエンジニアとか自然言語処理研究者とか、研究者はエンジニアじゃないか。
いずれにしろGoogleで技術系の仕事をしてるからといってプログラマとは限るまい。

>>910
研究者は研究者であって、一般医「エンジニア」とは言わない。
また、ネットワークエンジニアが、プログラマに比べて優秀だとは
全く思えない。創造性がなく、事務処理やっている様に思える。

>>908
プログラマと区別するために"IT土方"という用語があるんじゃないか

職人とライン工の違いみたいなものか

>>910
優秀でも頭が良くても、ネットワークにも、自然言語にも興味が
ない人は、他のソフトを作りたいと思うと思うけど。

Google以外のプログラマは全部ドカタか。
恐ろしい世界だ。

>>904
言語間で相互運用できる場合も多々あるので、一概に非効率とは言えない

スター俳優だけで舞台が成り立ってるわけでもなしに

土方がいないとビルだってできないんだからお前ら胸はってプログラマーですって言っても良いんだよ。

ハードからソフト(プログラム)へ重要性が高まっているのに、日本は旧態依然
としたハード重視だと言われている。今後ソフトの重要性はますます高まると
考えられているのに、「プログラマに頭のいい人はならない」なんて思う人
がいるのは非常に問題。パソコンに触ったことが多い日本では、プログラマが
何をやっているのか分からない人が多いので、馬鹿にされる。そして、優秀な
人からやめていく。それで、日本のソフトは弱いまま。

日本には舞台そのものがないからな
日本でプログラマといえばドカタに決まっとる

>>920
学校での成績も良くて、医者でも何でも慣れたが、ソフトが作りたくて
プログラマになりたい人もいるんだよ。実際に舞台が少なくても。
そういうレッテル張りは、今後の若手にも、日本の将来にとっても
マイナスになる。優秀な学校、優秀な成績で学校を卒業しても、
いざ就職しようとすると、良いソフト会社がない、なんて状況が
実際に起こっているが。

日本にいる天才プログラマは
アフリカにいるイチローみたいなもん

東大東工大京大阪大で、世界に通用するクラスのコンピュータサイエンスやって、
そういった連中をごっそり獲ってくメーカーが、しかしそこに入ってみたら下請けを
マネジメントするお仕事。

これじゃあIT3流国まっしぐらになるのも当然です。

世界に通用するクラスのコンピュータサイエンスやっている人間が
ごっそり獲るほどいるのかねえ

イチローがアフリカで生まれたら
いまごろ裸で洞穴で住んでたんじゃないかな

>>923
色んなケースがあるとは思うが、IBMなんて、ソフト作りを止めてしま
い、企業のサポート役(何でも屋に近いと思われ)に徹するようになって
しまったらしいが。オープンソースの台頭でソフトで儲けるのは難しく
なってきている。

FireFoxも、成果をごっそりGoogle Choromeに持って行かれてしまい、
倒産する恐れ有り。オープンソースは設計図をいつでも盗まれるので
予想できたことだが。そもそも、FireFoxの収益は、Google検索を
使うとFireFox陣営に還元される仕組みによっており、Googleが
金を出さなくなったらFireFoxは倒産するので、非常に危険性の
高いやり方。

それは何か関係ある話なの？
オープンソースが台頭する前から
日本の企業はカスなわけだけど

>>927
ますます参入しにくくなったと思う。

下請を安くこきつかって儲ける仕組みにしたのは経産省
原発もそうなってる

誰かが舞台を用意してくれるのを待てないなら、自分の力試しから始めたら良い。

舞台で演じるのと舞台を作るのとでは大変さが違う

人任せじゃいつ迄も止まったままだけどな。

「政治家には優秀な人がなるわけなんてない」と思いがちだが、
片山さつき は、全国模試で1番、1番、1番だったらしいし、
鳩山邦夫 は、全国模試で1番、3番、3番だったらしい。
このように、成りたい職業は、人それぞれ。

chromeがfirefoxから何を持ってったんだというのだろう

>>934
Mozillaの成果は全て持って行ったのでは？

HTMLパーサや、JavaScriptエンジンなどは、Mozilla由来じゃないの？
FireFoxの成果は全く入ってないのかな？

FirefoxはNetScape=Mozilla由来、GoogleはWebkit (KDE)
JavaScript自体、NetScapeが作ったものだから全く入ってない事はないが、
そもそもFirefoxなんてお手本になるほどきれいな仕様じゃないだろ。
互換性ぐちゃぐちゃなんだから。

つってもECMA仕様になったもんだし
V8は新規開発でしょ
接点無いな