Rubyってかなり良さそう(一通り文法を見た限りでは、少なくとも 対象領域 がもろかぶる Perl よりはかなり良さそう)だけど、実際どんなもん?

もちろん、現行サポート体制がままなっていないけれど、オライリーからも「動物本」が出ているし、今後PHPと平行して、サポートするところが増えてきそう。
(なんといってもマニュアルが全て日本語から先行して出て行くところが、われわれが他の言語で背負いつづけている一種の「ハンデ」が逆転するわけでおもしろい。)

で、Ruby関連の掲示板にとうこうすると、感情的な意見ばかりくるだろうから、ここに投稿したわけなのですが、冷静に見て、将来Rubyはどんなものですかね。

(私の見る限り、「真のオブジェクト指向」「真のスクリプト指向」を実現している唯一の言語だと思うのですけど、文字列系記述はPerlと同等に強力で、オブジェクト指向にいたっては他の言語の追随をゆるさず、スクリプト的柔軟さでも、Perlをも軽く凌駕していると思いました。あくまで文法を一通りみての感想ですが。。。)

なお、Ruby関連サイトは大体見て回ったので、サイト紹介はいらんです。

このQ&Aに関連する最新のQ&A

A 回答 (1件)

「回答」でなく「意見」が求められているようなので意見を書きます。



良い言語ですよ。
少なくとも(開発中といわれる)Perl6が出てくるまでは最高のスクリプト言語でしょう。

もっと普及してもいいはずなんですが「CGIってperlのプログラムのことでしょ?」みたいな風潮があるので何とも言いがたいです。

プログラム言語って「良い言語が使われる」という保証はありません。
歴史的に見てもAIDAはPL/Iに勝てなかったし、JavaはC++に(いまだに)遅れを取っています。
特にJava(NativeJavaを含めて)なんかあらゆる意味でC++を凌駕しているにもかかわらずJavaベースのアプリケーションはほんのわずかです。

現状でサーバサイドプログラミングを考えたら
・速度的にはJavaサーブレット
・記述が楽で速度重視ならPHP
・実行環境の普及率はperl、PHP
・資料/サンプルが多く勉強しやすいのはperl
Rubyの普及は難しいかもしれません。

多分私はrubyやperlは使いません。
コマンドを作るならawkとshellでたいてい書けるし、サーバーサイドスクリプトなら実行が速いPHPを選びます。
    • good
    • 0
この回答へのお礼

さっそくのご意見どうもありがとうございます。

>もっと普及してもいいはずなんですが「CGIってperlのプログラム
>のことでしょ?」みたいな風潮があるので何とも言いがたいです。
そうですね~。レンタルサーバーなども、ある程度枯れているperlを使用させたい、というのもあるでしょうし、「rubyを使う=実験的側面」という色合いが濃くなるため、個人的な趣味を超えると、ちょっと使用には抵抗がありますね~。

>プログラム言語って「良い言語が使われる」という保証はありません。
>歴史的に見てもAIDAはPL/Iに勝てなかったし、JavaはC++に(いまだに)
>遅れを取っています。
そうですね、「高潔さ」や「統一感」にとらわれすぎた言語は、「実践」に要求される「柔軟」さ、に耐えられないため、使用されないですね。Javaなどが「本当の実践」で使用させる機会が非常に少ないのも、この辺に理由があるのでしょうね。
実際にJavaではPS2のゲームプログラムなんぞ到底組めそうにないですね。Javaは型にはめすぎている。

>サーバーサイドスクリプトなら実行が速いPHPを選びます。
>記述が楽で速度重視ならPHP
apacheの組み込みモジュール同士で、PerlとPHPだとPHPの方が実行が速いのですか?(どちらも所詮スクリプトなので、おそいもン同士のどんぐりの背比べなのですが(笑))

>Rubyの普及は難しいかもしれません。
>コマンドを作るならawkとshellでたいてい書けるし、
そうですか~。私は、Windows系なので、awkなどは使わないのですが、(せいぜい、GNUのために、cygwin-BASHが入っているという程度です。)Rubyは面白そうかな~と、思ったのですが、はやんないですかね~。はやんないとむなしいですよね~。

お礼日時:2001/04/01 21:20

このQ&Aに関連する人気のQ&A

お探しのQ&Aが見つからない時は、教えて!gooで質問しましょう!

このQ&Aと関連する良く見られている質問

Qオブジェクト指向言語について

オブジェクト指向言語における、クラス継承の動作について
ご教授ください。

クラスを継承する場合、extendsなどといったキーワードで継承の動きを
実現させるとおもいますが、継承とは、Aというクラスを丸々包含したBというクラスを作成することをいうのでしょうか?
それとも、Aというクラス内にあるpublicやprotectedメンバのみをBというクラスに引き継ぐことをいうのでしょうか?

書籍にやサイトによっては【継承とは継承もとのprivateおよびprotecetd(に準じた)メンバを派生クラスに引き継がせる】という風に解釈できる文面で記述されているものがあります。

継承とは親クラスを拡張した子クラスを作成する

と解釈できるような文面で記述された文献もあります。


伺いたいのは、クラス丸ごとを継承するのかそれともpublicおよびprotectedに準じたメンバのみを
継承するのかです。

OOPの思想や、ちょっと詳しいからといってこまごましたことを
こたえてくるような方はご遠慮ください。

Aベストアンサー

クラスを丸ごと継承します。
その中で、サブクラスからオーバーライドできるのはpublic、protectedといった
スコープのもの、というだけです。

しかしながら、継承とはコピーと同義ではありません。

Qオブジェクト指向言語とは???

初めての言語として今PHPを勉強しているのですが
PHP4をベースにして本格的なオブジェクト指向言語として作られたのが
PHP5だという風に勉強しました。
でも(本格的な)オブジェクト指向言語という言葉がよく分かりません。
自分で調べても難しい言葉ばかりでいまいち理解することが出来ないのです。

Aベストアンサー

「オブジェクト指向」に対して、従来型のプログラミングを「手続き型」と呼んだりしますが、両者の考え方の基本的な違いは、

・手続き型(従来型)――実行する処理の「手順」を組み立てることを重視した考え方。
・オブジェクト指向――操作する「対象」を組み立てることを重視した考え方。

こんな感じになると思います。
 例えば、ある処理を行うプログラムを作成しようと考えたとします。従来型のプログラミングでは、どのようなことをどういう順番に処理していくか、ということを中心にプログラムを作る訳ですね。これは、単機能のものであれば簡単ですが、例えばウィンドウとメニューを持っていて多数の機能を実装した複雑なプログラムなどになるとかなり大変です。
 これに対し、オブジェクト指向は、「それはどういう対象を扱うものか、それにはどのような機能があるか」ということを重視して考えます。これは、単機能のプログラムであればあまり意味をなしませんが、複雑なものになると非常に効果的です。

この「操作する対象」のことを、一般にオブジェクトと呼びます。複雑なプログラムを作成するときには、まず「どのような働きをするオブジェクトが必要か」を考える訳です。そして必要なオブジェクトを設計し、それを組み合わせた形で全体のプログラムを作っていきます。
 これは、実際にそうしたプログラムを作ってみれば、なんとなくわかってくると思います。あんまり、頭の中だけで抽象的に考えてもぴんとこないでしょう。実際にいくつかプログラムを書いてみると、次第にイメージできるようになると思いますよ。

「オブジェクト指向」に対して、従来型のプログラミングを「手続き型」と呼んだりしますが、両者の考え方の基本的な違いは、

・手続き型(従来型)――実行する処理の「手順」を組み立てることを重視した考え方。
・オブジェクト指向――操作する「対象」を組み立てることを重視した考え方。

こんな感じになると思います。
 例えば、ある処理を行うプログラムを作成しようと考えたとします。従来型のプログラミングでは、どのようなことをどういう順番に処理していくか、ということを中心にプログラムを作る...続きを読む

Qオブジェクト指向開発とコンポーネント指向開発の違いに関して

オブジェクト指向開発から派生した開発としてコンポーネント指向開発というのがあると思いますが、それらの違いがあまりはっきりわかりません。粒度がコンポーネントの方が大きい、プラットホームに限定されない、継承などの難しい(?)概念が省かれ簡略化された部品、再利用を前提としたプラグアンドプレイができるような開発とありますが、その他にどのような特徴があるのでしょうか?わかりやすく教えてください。

Aベストアンサー

あなたのお書きになっていることで、オブジェクト指向とコンポーネント指向の違いは十分だと思いますが、まだ何か具体的な疑問点がおありでしょうか?

Q手続き型言語からオブジェクト指向型言語にコンバート

COBOLで書かれたプログラムをC#、JAVAなどのプログラムに書き換えるって簡単ですか?

COBOLは構造化プログラミングと呼ばれ、JAVAなどはオブジェクト指向でタイプが違うのではないかと思うのですがいかがでしょう?

Aベストアンサー

がるです。
このあたりは、「リファクタリング」というものについて調べると、色々と出てくるかと思うのですが。
以下、我流ですが「一つの方法」として捕らえていただけると。

1クラスを「ある意味のあるデータの塊を表す」ものであると仮定します。わかりやすいところですと、DBの1テーブルの1レコードを1インスタンスにするイメージです。
構造体でもよいのですが、後々を考えて、クラスにされるとよろしいかと思います。この場合、構造体に+αしたものがクラスである、程度の認識でよろしいかと。

そうすると「このデータを扱うときはこのクラス」という感じで集約することが出来るので、後々楽に処理をしたりすることが出来るようになります。

以上、参考になれば幸いです。

Qオブジェクト指向における「クラスA have a クラスB」の関係において,クラスBからクラスAのあるメンバ変数だけを触る方法

クラス10~50個の中規模プログラミングに当たって,以下の問題がよく出てきて,
「簡潔な方法はないものか・・・」と悩んでいます.

●前提条件
【・「クラスAに持たれているクラスB( A have a B 関係)において,
  クラスBからクラスAのあるメンバ変数(プロパティ)だけを触りたい」】

この場合,私はよく以下のようにしてしまい,クラス間の独立性を無くしてしまいます.
●方法1:
・クラスBのコンストラクタに「自分の持ち主であるクラスAのオブジェクト」を引数に取り,クラスBの変数(プロパティ)usedClassAとする.

=======
C言語風に書くと,
<code>
public void クラスA{
  クラスB usingClassB = new クラスB(); // 持っているクラスB
  int commonNum = 0;
  public void AddCommonNum(){
      commonNum++;
   }
   ...
   (その他の処理)
   ...
}

public void クラスB{
   class usedClassA;    // 持ち主のクラスA

   // コンストラクタ
   public クラスB(クラスA _usedClassA){
       usedClassA = _usedClassA;
   }
   public void AddCommonNum(){
       _usedClassA.AddCommonNum();
   }
}
<\code>
となります.

この方法の問題点は,クラスAとクラスBに<双方向の依存関係を作っている>ことで,
クラスAの設計(ここではAddCommonNum())が変更されたときに,クラスBの内容を変更しなければならない可能性があることから,拡張性に欠けると考えています.

そこで,他に何かいい実装方法が無いか,
教えていただけないでしょうか?
特に,このような前提条件に汎用的に使える方法だと尚良いです.

クラス10~50個の中規模プログラミングに当たって,以下の問題がよく出てきて,
「簡潔な方法はないものか・・・」と悩んでいます.

●前提条件
【・「クラスAに持たれているクラスB( A have a B 関係)において,
  クラスBからクラスAのあるメンバ変数(プロパティ)だけを触りたい」】

この場合,私はよく以下のようにしてしまい,クラス間の独立性を無くしてしまいます.
●方法1:
・クラスBのコンストラクタに「自分の持ち主であるクラスAのオブジェクト」を引数に取り,クラスBの変数(...続きを読む

Aベストアンサー

 こんにちは。
 簡単な話、共通のプロパティクラスを作成して、ClassAとClassBが其れを参照したり更新したりすれば、ClassAとClassBは左程依存しないのでは。
 一応C++で、其れらしき事をしてみましたので、参考程度に。

#pragma warning(disable : 4786)
#include<map>
#include<string>

//プロパティオブジェクトココから
struct IVariantHolder
{
  virtual ~IVariantHolder(){ }
};

template<class __TP>
struct CVariantHolder : public IVariantHolder
{
  typedef typename __TP variant;

  explicit CVariantHolder(const variant& val) : m_val(val){}
  ~CVariantHolder(){}

  variant& Get(){ return m_val; }
  const variant& Get() const { return m_val; }
  operator variant&(){ return m_val; }
  operator const variant&() const { return m_val; }
private:
  variant m_val;
};

struct CPropertyData
{
  typedef std::map<std::string, IVariantHolder*> map_t;
  template<class __TP>
  bool AddProperty(const __TP& tp, const std::string& sPropertyName)
  {
    if(GetProperty(sPropertyName))return false;
    return m_map.insert(std::make_pair(sPropertyName, new CVariantHolder<__TP>(tp))).second;
  }
  IVariantHolder* GetProperty(const std::string& sPropertyName)
  {
    return const_cast<IVariantHolder*>(
                static_cast<const CPropertyData&>(*this).GetProperty(sPropertyName)
                     );
  }
  const IVariantHolder* GetProperty(const std::string& sPropertyName) const
  {
    map_t::const_iterator it = m_map.find(sPropertyName);
    return it == m_map.end() ? 0 : it->second;
  }
private:
  map_t m_map;
};

template<class __TP>
static __TP* Lock(CPropertyData* property, const std::string& sPropertyName)
{
  CVariantHolder<__TP>* pVal = dynamic_cast<CVariantHolder<__TP>*>(property->GetProperty(sPropertyName));
  return pVal ? &pVal->Get() : 0;
}
//プロパティオブジェクトココまで

//テスト用の構造体
struct CommonStruct
{
  CommonStruct(long _l, short _s, char _c) : l(_l), s(_s), c(_c){}
  longl;
  shorts;
  charc;
};

//クラスAとクラスBココから
struct ClassB;
struct ClassA
{
  ClassA(ClassB* p, CPropertyData* property) : m_useClassB(p), m_property(property)
  {
    //ココでメンバ変数(プロパティ)の領域を動的に作成する
    m_property->AddProperty(int(0), "commonNum");
    m_property->AddProperty(CommonStruct(4, 2, 1), "commonStruct");
  }
  void DisplayProperty()
  {
    ::printf("%s %d %s\n", "[commonNum : ", *::Lock<int>(m_property, "commonNum"), "]");

    CommonStruct* p = ::Lock<CommonStruct>(m_property, "commonStruct");
    ::printf("%s <%d><%d><%d> %s\n", "[commonStruct <l><s><c> : ", p->l, p->s, p->c, "]");
  }
private:
  ClassB*m_useClassB;
  CPropertyData*m_property;
};

struct ClassB
{
  explicit ClassB(CPropertyData* property) : m_property(property){}
  void AddCommonNum()
  {
    int* pi = ::Lock<int>(m_property, "commonNum");
    (*pi)++;
  }
  void SetCommonStruct(long l, short s, char c)
  {
    CommonStruct* pc = ::Lock<CommonStruct>(m_property, "commonStruct");
    new (pc) CommonStruct(l, s, c);
  }
private:
  CPropertyData*m_property;
};
//クラスAとクラスBココまで

//お試し
int main()
{
  //両方に共通なプロパティオブジェクト
  CPropertyData property;

  //クラスBに渡す
  ClassB b(&property);

  //クラスAにクラスBとプロパティオブジェクトを渡す
  ClassA a(&b, &property);

  //クラスBでプロパティを操作する
  b.AddCommonNum();
  b.SetCommonStruct(10, 20, 30);

  //クラスAでプロパティを表示する
  a.DisplayProperty();
  return 0;
}

 こんにちは。
 簡単な話、共通のプロパティクラスを作成して、ClassAとClassBが其れを参照したり更新したりすれば、ClassAとClassBは左程依存しないのでは。
 一応C++で、其れらしき事をしてみましたので、参考程度に。

#pragma warning(disable : 4786)
#include<map>
#include<string>

//プロパティオブジェクトココから
struct IVariantHolder
{
  virtual ~IVariantHolder(){ }
};

template<class __TP>
struct CVariantHolder : public IVariantHolder
{
  typedef typename __T...続きを読む


人気Q&Aランキング

おすすめ情報