Index of /geocities/c_zelos

	Name	L	S
	in/	0	-
	bbs/	0	-
	os/	0	-
	onruby/	0	-
	/	0	-
	/	0	-
	Login	0	-

10:55 2011/06/26


http://www.geocities.jp/c_zelos/soto/mikomiu2011_06_26_00_07_32.zip 

http://www.geocities.jp/c_zelos/soto/mikomiu2011_05_09_00_58_09.zip


http://www.geocities.jp/c_zelos/soto/tensi_no_aori.zip



5:33 2011/06/21

一応･･･、漏れと同じ質を持つ、奴が
ここへこないようにかいておく

世界の、環境やプログラム言語を「統一」することは
一見素晴らしいことに見える
きっとＩＴの世界効率はおそろしく高まるよ
現在の比じゃない
･･･けど、それはたぶんならないし、なっちゃいけない

プログラムの完璧さは、1であり、世界の完璧さは0、
なので、あんまり「小さいほう」、いわばＳｃｈｅｍｅ、Ｄｅｂｉａｎの方面にいくと、世界は崩壊する
ＣｏｍｍｏｎＬｉｓｐ、ＲｅｄＨａｔの方面へ･･･
冗長に、冗長を重ねた方面へ、世界は歩むべきだ

これは、ＩＴの世界だけではなく、ＩＴの外の世界
外の世界の健全性を保つ為に、プログラミングは非効率的で
冗長してなくちゃならないんだ

人類が、完璧じゃない以上、
完璧なんて･･･触った日には、死ぬぞ

個人が死ぬわけじゃない
世界が死ぬぞ


･････だから、最小ソースコードへ走ってる者、
あまりこっちまで来るなよ
俺は･･･真理まで、見てるよ
ひとつ言う、最小ソースコード方面の、　1と0　にたどり着いてる奴は
ここに、いる
だから、もういいよこっちは、
オブジェクト指向･･･でもなんでもいい
マクロ以外の、ソースコードを小さくすることでプログラムを管理する術ではなく
大きなソースコードを扱う術、または扱う頭脳、
そっちの方面へ･･･人類は歩め


完璧には、限界があって、

非完璧には、限界がない

だから･･･限界のない方角へ、進め


ノードプログラミングは、完璧だよ

けど･･･これは後世に伝える技術じゃないや
読む奴は、ひとつの考えとして読んでくれ、決して
それを真に受けたりせず、こちら側に未来はないことを知ってくれ
10年先の未来よりも、さらにずっと先を･･･
俺は今みてる･･･

非完璧へ･･･走れ、人よ


つまり、この世界の進むべき方角を教えると

「　最も冗長したプログラミング言語　」　こそが最強、、

というか、人の潜在的な何かが、それにひかれ
その冗長したプログラミング言語を、人は使おうとする
ゆえに冗長したプログラミング言語のライブラリは充実し、
冗長した方向へ進化していく

Ｃ＋＋、　Ｄ言語が、　これに相当する


世界効率は･･･　現状のまま、突っ走れ

世界中のあらゆる因果関係を考えた結果･･･
世界で効率の良いプログラミング言語を使う意味もないし
何か、俺個人が特別言及する意味もない･･･
俺がＩＴ世界にとって「効率的」なことを言及したとて
この世界全体にとっては、「非効率的」な因果になるかもしれない

だから･･･漏れはこの世界を去る

世界リファクタリングは、やらない事にする


アホ同士で･･･アホなプログラム作りあって、
それを礎にして･･･、せいぜい

上だか下だか向かってる先もわからん世界で
保存されていく情報、データ容量だけを重ねていけよ


電子上の生物は･･･そろそろ発生する
生物っていうのは、大量の情報の蓄積から、偶発的に生まれるんだ
人に害を及ぼす生き物じゃなければいいな･････






4:28 2011/06/20


まず、プログラミングの効率に限界がなくて、
進んだ理論を展開しようとすると、言語の限界にあたり
それでも、無理やりに実装は可能、
けど、どうみてもこれは言語処理系レベルで実装されるべきもので、
いずれこの概念が言語処理系に入る、そうなると、最初の1歩を作った漏れが
数年かけた理論でも、言語処理系に実装された概念を、後続の奴が覚えるのには3日とかからないだろう

知らず知らずにうちに、漏れの一人の礎となっているのが、いただけない

とりあえず、Cをなくしたいかな
最低限のプログラミングができて、安定している言語なら、たぶん世界は、何でもいいんだろうけど
ちょっとこんな言語を世界でまだ使ってるなんて思うと、どうもな･･･まぁそれは、
Cをはじめとした殆どの言語に言える事だけど、Cが諸悪の根源だと思うので、まずこいつから

Cは、もはやハードウェア関連の記述にしか使われていないはずだから
たいしてややこしいアルゴリズムにもなってなく、
ただの値代入と、関数CALLだと思うから
そこはLispでかけばいいと思うんだよ
Cよりはマシで、しかも言語仕様に限界がないから
世界が新しい概念を作っても、Lispだったらそれを吸収出来る

なので、Cで今かいてるハードウェア、ミドルウェアはLispでの書き直しが
世界にとって正しい選択に思う
S式はややこしいよね、ソフトウェアをこれでかくのは、少し厳しい
だからこそのハードウェア面でのLispの利用

今はRuby使ってるけど、ツリー構造に弱い･･･
配列操作系のメソッドは充実してるけど、ツリー操作系メソッドがひとつもないから
自分でかいてる始末
あと･･･色々と、いいたいことも山ほどあるけど、今はやめとく

Rubyにはそこまで期待してない
ツリー操作に長けた言語が、いずれでてくる･･･かな、と・・・・　世界の誰かが、
漏れと同じものをみていて、それでいて言語処理系作りに目覚めない限り、でてこないとは思うんだけど
でてきてほしいな、そうしないと漏れが作る羽目になる、かもしれない、面倒くさい
俺以外の誰かが全力で、突っ走ればいいんだよ、漏れは考えの提唱をして、
世界にヒントを与えてあげるから、実装して起業とか賞をとるとかお金を稼ぐとか、
そういうのも、名声も、いらないから、全部他人にやる、もってっていいんだよ
誰でもいいからさっさともってって作れ
まずツリー構造のソースかくとendの嵐だから、もうそこからRubyじゃやっていけないのが目に見えてる
他の言語使うよりは十分やっていけるけど、完璧がほしい
endがある時点で完璧とは、遠い･･･　贅沢を言ってるよ

世界がやっていくべき事は、あと　三つ　くらい

１　ツリー構造に長けた言語を作る事
２　メタ方面のアルゴリズムの研究をする事
３　超巨大容量のハードディスクを作る事　、理想は無限

この三つを突破できたら、
たぶんコンピュータサイエンスはおしまい
次のステージに人類は進める



漏れは他人のために、頑張るのが大嫌いなんだよ
けれど、効率について考え出すと、とまらない
やりたくはないけど、いつかやり始めてしまうかもな
あと、1,2年は待ってみて、それでもでてこない場合は、
細々と言語を作り始めるの、かもしれない



---------




6:42 2011/06/01
科学がついてこないですね



puts "-------step 1-------"
$t = nil
10.times do
  if $t.nil? && ($t=true)
    i  = 0
    i += 1
    print i
   end
end
puts
puts "-------step 2-------"

$t = nil
10.times do
  if $t.nil? && ($t=true)
     lambda do
       i  = 0
       lambda do
         i += 1
         print i
       end
     end
   end
end
puts
puts "-------step 3-------"
10.times do
  task ||=  
     lambda do
       i  = 0
       lambda do
         i += 1
         print i
       end
     end
  task.call.call
end
puts
puts "-------step 4-------"
task = nil
10.times do
  task ||=  
     lambda do
       i  = 0
       lambda do
         i += 1
         print i
       end
     end
  miyu = task.call
  if miyu.class == Proc
    task = miyu
  end
end


puts
puts "-------step 6-------"
task = nil
task2 = nil
10.times do
  task ||=  
     lambda do
       i  = 0
       lambda do
         i += 1
         print "i=#{i} "
         task2 ||=
         lambda do
           k  = 5
           lambda do
             k += 5
             print "k=#{k} "
             nil
           end
         end
         miu = task2.call
         if miu.class == Proc
           task2 = miu
         end
         nil
       end
     end
  miyu = task.call
  if miyu.class == Proc
    task = miyu
  end
end


puts
puts "-------step 7-------"
class O
  attr_accessor :task
  attr_accessor :lm
  attr_accessor :n
  def initialize
#    @task = Hash.new
    @lm = lambda do|o| yield o end
  end
    o = self.new
    10.times do
      o.task ||=  
         lambda do |o|
           o.n  = 0
           lambda do |dummy|
             o.n += 1
             print "miumiu #{o.n} "
             exit if o.n > 15

             o.task ||=
             lambda do|o|
               o.n  = 5
               lambda do|dummy|
                 o.n += 5
                 print "test #{o.n} "
                 nil
               end
             end
             miu = o.task.call self.new
             if miu.class == Proc
               o.task = miu
             end
             nil
           end
         end
      miyu = o.task.call self.new
      if miyu.class == Proc
        o.task = miyu
      end
    end
end



puts
puts "-------step 8-------"
class O
  attr_accessor :task
  attr_accessor :lm
  attr_accessor :n
  def initialize
    @task = Hash.new
    @lm = lambda do|o| yield o end
  end
    o = self.new
    10.times do
      o.task[:default] ||=  
         lambda do |o|
           o.n  = 0
           lambda do |dummy|
             o.n += 1
             print "miumiu #{o.n} "

             o.task[:default] ||=
             lambda do|o|
               o.n  = 5
               lambda do|dummy|
                 o.n += 5
                 print "test #{o.n} "
                 nil
               end
             end
             o.task.each do |key,mm|
               miyu = mm.call self.new
               if miyu.class == Proc
                 o.task[key] = miyu
               end
             end
             nil
           end
         end
      o.task.each do |key,mm|
        miyu = mm.call self.new
        if miyu.class == Proc
          o.task[key] = miyu
        end
      end
    end
end

puts
puts "-------step 9-------"
class O
  attr_accessor :task
  attr_accessor :lm
  attr_accessor :n
  def initialize
    @task = Hash.new
    @lm = lambda do|o| yield o end
  end
  def taskcode_run
    o = self
    o.task.each do |key,mm|
      miyu = mm.call O.new
      if miyu.class == Proc
        o.task[key] = miyu
      end
    end
    nil
  end
    o = self.new
    10.times do
      o.task[:default] ||=  
         lambda do |o|
           o.n  = 0
           lambda do |dummy|
             o.n += 1
             print "miumiu #{o.n} "

             o.task[:default] ||=
               lambda do|o|
                 o.n  = 5
                 lambda do|dummy|
                   o.n += 5
                   print "test #{o.n} "

                   o.taskcode_run
                 end
               end
             o.taskcode_run
           end
         end
      o.taskcode_run
    end
end