常連

注目の的

社会貢献

質問力

自己紹介

例えば、以下のコード
```C
#include<signal.h>

sig_atomic_t interrupted;

void sigint_handler(int signum){
     interrupted = 1;
}

int main(){
     signal(SIGINT, sigint_handler);
     while(!interrupted){
            [何かの処理]
     }
     return 0;
}
```
このコードは sig_atmoic_t interrupted にvolatileが付いていないので最適化するとバグります。

> main()からの読み取りは、コンパイラの最適化によって削除されてしまう可能性がある。

真っ先に思ったこと：「知らねぇぇぇ・・・ & なんで？？」
**最適化によって削除されたり、変更されたりする変数を把握することができません。**
**つまり、volatileが必要、不必要な場面がわからない。**ということです。

> 変数宣言にvolatile修飾子を追加すると、intterruptedはwhileループの繰り返しやシグナルハンドラからアクセスされる際に、必ず元のアドレスからアクセスされることが保証される。
キャッシュできないデータにはvolatileを使う

(キャッシュ？これは・・・CPUに備わっているキャッシュのことですかね？
元のアドレスとはなんのこと？)

**皆さんは、どうやってvolatileが必要な部分を見つけているんでしょうか？**

プログラムを作る -> 最適化するとバグる -> volatileが必要な部分を探す。

しかし、これだと**バグを前提に**volatileを探すことになるので、良い方法とは言えませんが・・・

あるパターンが存在するはずです。
**volatile修飾の規則を教えてください。**
しかし、全パターンを覚えるんですか？？
それは流石に無理ですよね？

__＿**[ここから私の妄想]**_____________
volatileによる最適化抑止機能は、変数に対してに加えて、**関数ごとに抑止できると便利ではないでしょうか？**
```C
volatile int buffer_ready;
char buffer[BUF_SIZE];

void buffer_init(){
     for(size_t i = 0; i < BUF_SIZE; i++)
          buffer[i] = 0;
     buffer_ready = 1;
}
```
簡単な関数の例なのですが、
> volatile宣言がされている場合、コンパイラはそのデータが置かれたメモリに対する読み書きの順序を変更できない。しかし、これらの読み書きと、他のメモリに対する読み書きとの順序を変更してもよい。
したがって、コンパイラはこのループをbuffer_readyへの書き込みの後に移動することができる。これはプログラマの意図に反する。

今回の場合は、buffer_readyが入れ替わっても問題無さそうですが、複雑な関数になると問題になってくるはずです。
そうすると、bufferの方にもvolatileを付ける羽目になり、**volatileがどんどん増えていきます。**

buffer_init()そのものを最適化抑止させる機能があると便利ではないでしょうか？

[ラムダ式って何が便利なのです？？](https://teratail.com/questions/110961)
以前の質問で、main()を内をさらに細かい関数単位で分割できる・・・と言ったんですが、すると関数の中もラムダ式を使って細かく最適化抑止を制御できるのではないか？（ラムダ関数を最適化抑止する）
という想像ができます。
ラムダ式の利便性が向上しそうです。
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

まぁ、私の妄想はどうでもいいんですけど・・・関数全体に対して最適化抑止機能が付いているのはどうかなぁ？？と思っただけの話なのです。

ここでの疑問は「**どうやって、volatile修飾が必要な箇所を見つければ良いんでしょうか？？**」という疑問です。
パターンがあるなら、是非教えてください。

volatileが必要な場面を見つけ出す

"DR," "accepted," "DRWP," "WP," "CD1," "CD2," "CD3," "CD4," "TC1," "Ready," "Tentatively Ready," "NAD" ("Not A Defect"), 

といった略語がC++標準化委員会のCore issue listにかかれているのですが

ex.)http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html

これはそれぞれどういう意味なのでしょう？

C++ core issueのstatusを表す略語がわからない

（元タイトル：イベントハンドラとイベントリスナの違いを教えてください）
Ruby は分かるのですが JS や HTML5 は初心者です。
onclick などで使われる用語「イベントハンドラ」と、addEventListener などで使われる用語「イベントリスナ」との違いを教えてください。
ほぼ同じことだけど「イベントリスナ」だと同じイベントに対して複数登録できる、という理解で良いのでしょうか。
また、これらの用語の用いられている対象は、イベントが生じたときに呼ばれる関数（もしくはオブジェクト）、ということで正しいでしょうか。
参考資料もお示しいただければ幸いです。よろしくお願いします。

---
以下12/5 17:25追記：

Flanagan の JavaScript 第6版 17章イベント処理の注釈には

> HTML5 仕様などでは、登録する方法に応じて、ハンドラとリスナーを技術的に区別している場合もあります。本書では、2つの言葉を同じ意味として扱います。（p.484）

と記載されていました。
ですので質問内容を「 **あなたはこの2つの用語をどのように使い分けていますか** 」に変更します。
よろしくお願いします。

イベントハンドラとイベントリスナの用語の使い分けを教えてください

こんばんは。早速ですが質問させてください。

普通のfor文と拡張for文の違いなのですが、拡張for文では変数の型指定が必須です。
例えば下記のソースコードはコンパイルエラーになります。

```Java
int i;

int[] array=new int[]{1,2,3};

for(i : array){
    //処理文
}
```

正しくは以下になります。

```Java
int[] array=new int[]{1,2,3};

for(int i : array){
    //処理文
}
```

しかしそれが普通のfor文になれば、切り離して記述できます。

```Java
int i;

for(i=0; i<3; i++){
    //処理文
}
```

そういう仕様だと言われるとそれまでなのですが、なぜ拡張for文では切り離して記述できないのか理由を教えていただきたいです。
コレクションだと問題が起きるとか、そういう関係でしょうか？

Java 拡張for文 変数宣言の場所

いつも本当に助かっています。
テーブルの設計についてご意見をお聞かせください。

仕事でデータロガーのシステムというものを実装しました。
そのシステムは外部の機械から何らかのデータを受けとり、保存していくだけの単純なものですが、受け取るデータ構造を可変としています。

---

例：
- 機械Ａは 気温、湿度、気圧
- 機械Ｂは 電圧、電流
- これらのデータが各機械から１０秒毎に（23℃, 30%, 1000hPa というように）送信されるので受信し保存する。


条件：
- 機械毎のデータ定義を画面から設定する。
(何カラムあり、どのカラムが何のデータで、型は何で、有効桁数が何桁で、単位は何か、等）
- 各カラムのデータ型は真偽値、整数値、小数値、文字列がある。
- 機械Ａも機械Ｂも数千台程度接続されている。今後機械Ｃも追加される
- データを元に各機械毎のグラフを描画したり全体で集計したりする。閾値判定も行う。
- データ蓄積後、定義の変更はある程度許容する。（列の追加や単位の変更など）

---

これらを実現するためのテーブル構造の案として、下段に記載した幾つかの案などがあるかと思います。
実はもうこのシステムは「案１」で開発が終了し、問題なく稼働しています。
上記は例ですが、実際に数億レコードのデータが蓄積されています。
ただ、設計実装が私一人で周りに頼れる人もなく、設計に不安があるため、皆様のご意見をお聞かせください。

**質問１．情報が少なくて恐縮ですが、「案１」を採用したのは正解だと思いますか？
質問２．現実的な案として下段以外のものはありますか？
質問３．下段の案の中で、上記条件に対して「ありえない」と考えるものはありますか？
質問４．一般的にこういったもののデザインパターンはありますか？
質問５．他、経験談や参考情報などありましたらご教示ください。**


実際に問題なく稼働しているのだからいいじゃん、という部分もあるかと思いますが、後学のためよろしくお願いいたします。
※できるだけ広くご意見を頂きたいので少し長めに質問をオープンしておくかもしれません。

CentOS7.2, MariaDB10.0, Java8

---

### 案

**１．ID, 機械ID, キー(VARCHAR), 値(VARCHAR), 日時 のカラムを持つテーブルを用意する。**
  ※一旦値をVARCHARで保存し(小数値1.23ならそのままテキストで)、読み出し時に各定義の型に合わせて解釈します。
  ※１カラム（例えば気温）だけで１レコード消費します。
  ※閾値判定時、VARCHARカラムに対して平気で 「値 > 1.23」 のようなことをやります。
  ※１回の送信データを示す集計基準は機械IDと日時です。
  ※この案を採用しました。


**２．「定義ごとに柔軟にテーブルを作る」システムを作る。**
  ※プログラムが CREATE TABLE 文を発行します。
  ※なんだか気持ち悪いという理由と、システムが複雑化しそうという理由で却下しました。
  ※データ量は最も少なくなり運用も楽そうなため、今はこちらの方がよかったかも、と思っています。


**３．ID, 機械ID, c1, c2, c3, c4..., 日時 のようにカラムを予めたくさん用意し、カラムとデータの対応テーブルを別途用意する。**
  ※ダサく感じたので却下しました。なしではなかったなと思っています。


**４．ID, 機械ID, データ(VARCHAR), 日時のカラムを用意し、データにXML, JSON, ハッシュオブジェクトシリアライズなどで保存する。**
  ※集計と運用が厳しくなるかと思い却下しました。


**５．RDBを用いない。**
  ※RDB以外を知らないことと、集計が厳しくなると思い、却下しました。

可変データ構造をRDBに保存する方法について

プログラミングのコード記法のひとつに[ヨーダ記法](https://ja.wikipedia.org/wiki/%E3%83%A8%E3%83%BC%E3%83%80%E8%A8%98%E6%B3%95)と言う物があります。定数を前に持ってくることで、代入になるような記述ミスやヌルポ発生を防ぐという物です。

```C
if (42 == val) {
  // ...
}
```

もし、`42 = val`と記述ミスをしても、コンパイルエラーになるため、そのミスを防ぐことができます。

```Java
if ("42".equals(str)) {
  // ...
}
```

もし、`str`がnullであったとしても、NullPointerExceptionが発生せずに、falseとなるだけです。

しかし、この記法は「SVO」ではなく「OVS」になるため、一般的な言語として考えたときのコードとしては違和感が強く、わかりにくいとされています。

さて、このヨーダ記法について、わかりにくいとか、生理的に受け付けないとか、嫌いだとか、主観的な意見を__求めてはいません__。私が求めるのは**本当にこの記法が必要なのか**という事です。

ほとんどのコンパイラでは、適切なオプションが付いていれば、`if (val = 42) {...}`のような記述に対して警告を発します。また、優れたエディタで適切なlinterを使用していれば、コンパイルすることも無く、おかしな書き方をしていることを警告してくれるでしょう。言語によっては、代入が値を返さない、if文の条件式は真偽値しか受けてつけない、などの動きとすることで防止する物もあります。

しかし、JavaのNullPointerEcextion防止については、そのような防止をしてくれるわけではありません。かといって、毎回次のように書くことも冗長だと思われます。

```Java
if (str != null && str.equals("42")) {
  // ...
}
```

そもそもnull安全では無いJavaを使うのが悪いというもっともな意見もあるかと思いますが、このように言語や使いどころによってはヨーダ記法は未だに有用では無いのでは無いかと思っています。

上記のJavaのNullPointerEcextion防止のように、適当な回避策が無いため、ヨーダ記法が有用になる場面は他にあるのでしょうか？それとも、Javaの書き方も実は他に良い回避策があって、ヨーダ記法が有用になる場面など既に存在しないと言えたりするのでしょうか？ヨーダ記法を使うべきか、使うのであれば、どの言語のどのようなときなのかを教えていただきたいと思います。

---

この質問は、[c - ヨーダスタイルについて - スタック・オーバーフロー](http://ja.stackoverflow.com/questions/32214/)を見かけて、回答を書こうとしたときの疑問からです。該当の質問は主観的とされて閉じられていますが、ヨーダ記法の是非は問うべきとして、今回の質問をしました。なお、私自身の回答は「代入演算子に`=`を使うのが悪い」という斜め下の結論になったため、投稿はしていません。

ヨーダ記法は本当に不要なのか？

タイトルのとおりです。
セキュリティを専攻する学生です。
あくまで主観なのです（大学の先生も同意見でした）が、俗に言うハッカー的な人はPythonを好む傾向にあると思います。
CTFのWriteupなどを読んでいても、Python率が高めな気がします。

なぜなんでしょうか？

たとえば、
RubyとPythonを比べる際に、Pythonのほうが科学技術計算が得意ということが言われますが、それが関係しているのでしょうか？
それとも、インデントが区切り？になっていて必然的にきれいに書けることがいいんでしょうか？

また、自分は今、Rubyを勉強していて、Pythonは使ったことがないのですが、両方やるメリットはありますか？

ハッカー的な人はなぜPython?

Linuxのshutdownコマンドとrebootコマンドについて質問です。

先日、職場で、rebootコマンドを実行するとまずいので、再起動時は"shutdown -r now"を指定するように言われました。
（環境変数や設定が消える？）

しかし、その理由が調べてもわかりません。

rebootコマンドとshutdownコマンドの違いは何なのでしょうか？


---追記 2016/12/17---
皆さん回答ありがとうございます。
質問が放置気味になってしまい、申し訳ありません。

様々な意見があり、とても参考になりました。
回答を見て疑問に思ったのですが、shutdowmコマンドのコードを見ることはできないのでしょうか？
"man page of SHUTDOWN"のページに記述されているファイルを見ても、ファイルが存在しないか、バイナリファイルなので、ソースコードの確認方法が存在するなら知りたいです。

追加の質問となってしまいますが、よろしくお願いいたします。

shutdownコマンドとrebootコマンドの違いについて

`int`や`bool`のような読み込みが原子的だと思われる型について、変更がある場所を全て排他制御されている場合でも、`atomic`を使う必要はあるのでしょうか？

サンプルとして、下記のコードを見てください。

```C++
#include <atomic>
#include <chrono>
#include <iostream>
#include <thread>

int main()
{
	std::atomic_int x(0);
	int y(0);
	std::mutex mw;
	std::mutex mr;
	std::thread thws[1000];
	std::thread thrs[1000];
	for (int i = 0; i < 1000; ++i) {
		thws[i] = std::thread([&]() {
			std::this_thread::sleep_for(std::chrono::seconds(1));
			std::lock_guard<std::mutex> lock(mw);
			x++;
			y++;
		});
		thrs[i] = std::thread([&]() {
			std::this_thread::sleep_for(std::chrono::seconds(1));
			int x_t = x; // ① 安全
			int y_t = y; // ② 危険？？？
			std::lock_guard<std::mutex> lock(mr);
			std::cout << x_t << "," << y_t << std::endl;
		});
	}
	for (int i = 0; i < 1000; ++i) {
		thws[i].join();
		thrs[i].join();
	}
	std::cout << x << "," << y << std::endl;
	return 0;
}
```

`x`は原子的`int`ですが`y`は普通の`int`です。しかし、インクリメントの処理について、mutexによりどちらも排他制御されているため、期待通りに最終的に1000になります(もし、mutexがなければ、`y`は1000で無いときがあります)。

では、読み込み側はどうでしょうか？①は安全でしょう。`x++`の最中に`x`が読み込まれて壊れてしまうことはありません。では②はどうなのでしょうか？`y++`の最中に`y`が読み込まれた場合、おかしな値になることはあるのでしょうか？また、後置インクリメント以外、例えば、前置インクリメントや代入、`+=`などの場合は、うまくいかないとかあるのでしょうか？そして、それらのことは`int`以外の、`bool`や`long long`等の他の整数型についても言えることなのでしょうか？(とりあえず、上のコードを手元で試す限り、`y`がおかしな値を返すことはないようです。)

もし、問題が無ければ、atomicを外して僅かでも処理を速くしたいと考えています(排他制御自体は別の理由で外せないことが前提です)。変更が全て排他制御されていれば、atomicは外しても大丈夫なのかどうかを教えてください。

変更部分が全て排他制御されている場合でもatomicは必要か？

実用的で無い内容なのでここで聞いて良いのか悩みましたが，一応クラスの設計の参考になるだろうと思って質問しました。
自分の普段使いがPythonなので，説明用のコードはPython風ですが，どの言語にも共通する問題だと思います。

先ほど友人と，「鶏肉を5つに切る」にはどうすれば良いかという例えばなしをしていました。
これを実装する場合，

* chicken.cut(5)  # chickenは (Foodクラスを継承した) Meatクラスのインスタンス
* chef.cut("chicken", 5)  # chefはChefクラスのインスタンス。あらかじめset_foodなどで{"chicken": chicken}を内部に保持した状態にしておく

の2通りが考えられるのではないかと思います。

鶏肉の状態が変化するという意味では，「chickenが5つに分割された状態になる」前者の方が自然であるように思えます。それに説明が短くて済みます。おまけに「オブジェクト指向 料理」で検索するとこっちの例え話しか出てきません。議論のきっかけになった第三者の意見も，「鶏肉.cut(5)できたらいいのに」というものでした。

しかし一方，cutするのは料理人であることを踏まえると，「chefがchickenを5つにcutする」方が自然です。しかも，

* 食材chickenとeggを混ぜる → chef.mix("chicken", "egg")
* 手持ちの食材を見せる → chef.show_foods()
* 親子丼のレシピを覚える → chef.learn_menu("oyakodon", [needed_foods])
* 食材chickenとeggを消費して料理oyakodonを完成させる → chef.cook("oyakodon")
* 熟練度システムを加える → 「if self.level >= 10」などを加える
* 「knife」が無いとcutできないことにする → 「if self.has_knife」などを加える

と，後々の拡張が容易です。なので，僕はこちらの案に一票を入れました (とはいえ，Chefクラスを一体どれほど大規模なクラスにするつもりなのでしょうか?)

他にも，料理は料理で別クラスにすべきだ，とか，オブジェクト指向が本当に必要なのか，とか，初心者なりに様々な意見が出ました。

これらについて，オブジェクト指向に慣れた方の意見を聞きたいです。
よろしくお願いします。

---

補足: 僕が想定していた設計例はこんな感じです

```Python
class Food(object):
    def __init__(self, size, hardness):
        self.size = size
        self.hardness = hardness


class Chef(object):
    def __init__(self, level):
        self.level = level
        self.has_knife = False
        self.foods_ = {}

    def set_food(self, food, obj, n):
        self.foods_[food] = [obj, n]
        print('%sを手に入れた!' % (food))

    def show_foods(self):
        foods = self.foods_
        return {i: (foods[i][0].size, foods[i][1]) for i in foods.keys()}

    def cut(self, food, n):
        if food not in self.foods_.keys():
            print('食材がありません')
        elif not self.has_knife:
            print('ナイフがないと切れません')
        elif self.level < self.foods_[food][0].hardness:
            print('レベルがたりません')
        else:
            self.foods_[food][0].size *= 1 / n
            self.foods_[food][1] *= n
            print('%sを%d個に切断しました' % (food, n))

meat = Food(size=10, hardness=3)
chef = Chef(level=1)
chef.cut('meat', 5)  # 食材がありません
chef.show_foods()  # {}
chef.set_food('meat', meat, 3)  # 'meatを手に入れた!'
chef.show_foods()  # {'meat': (10, 3)}
chef.cut('meat', 5)  # ナイフがないと切れません
chef.has_knife = True
chef.cut('meat', 5)  # レベルがたりません
chef.level += 10
chef.cut('meat', 5)  # meatを5個に切断しました
chef.show_foods()  # {'meat': (2.0, 15)}
```

皆さん多くの有用な回答をありがとうございました。
当初の質問「foodが切るかchefが切るか」について，food派の回答で最も納得のいく理由を説明してくださったLLmanさんをベストアンサーとさせていただきました。
(全員へ返信する時間がなかったのでLLmanさんへの返信欄に全員宛のお礼を書かせていただきました)

今回知ったことを実際のコーディングにも活かせていければと思っております。

オブジェクト指向で料理を例える場合，chicken.cut()かchef.cut()か

C言語の勉強をやり始めて二か月の者です。
volatileの意味が分からないのですが、分かりやすい具体例とかありましたら、よろしければ
教えて頂きたいです。
参考書やネットを使って調べているのですが、なかなか理解できません。

以上、宜しくお願い致します。

C言語　volatileの意味がよく分かりません。

現在、Linuxの勉強をしておりまして、その中で、「シェル」、「ターミナル」、「コマンドプロンプト」という言葉が出てきました。検索して調べてみたのですが、いまいち違いがよく分かりません。

Linuxの勉強を初めて初心者のため、「シェル」、「ターミナル」、「コマンドプロンプト」の違いを教えて頂きたいです。宜しくお願い致します。

シェル、ターミナル、コマンドプロンプトの違いを教えてください

**bash、sh、シェルスクリプト、shell、Linuxコマンドの違いが分からないのですが**
・shellはLinuxコマンドの一部？
・bashとshは兄弟みたいな関係でshellの一部？
・シェルスクリプトは、bashやshの組み合わせ？

・下記のような階層でしょうか？
**Linuxコマンド**
┗shell
  ┣bash
  ┗sh


・cpコマンドは、bashで使用できて、shでも使用できて、shellであって、Linuxコマンドでもある、ということですか？
・cpコマンド1つだけでは、シェルスクリプトとは言わない？ あるいはバッチ処理として動かせばそれはもうシェルスクリプト？

cpはbash？ sh? shell？ Linuxコマンド？

C++ 初心者です。
先日、 SFINAE という仕様があると言うことを耳にしました。
面白がっていろいろと試していたのですが、途中で疑問に当たりました。

まず SFINAE について確認させてください。
私は、「テンプレートを型に置き換えるときに文法上のエラーがあった場合は、それをオーバーロード候補から外し（エラーとせず）続行」だと認識しています。
ここで型に置き換えるときのエラーとは、単純には例えば `std::enable_if<false>::type` などと言う型はない、のようなものだと思っています。
もし誤解があれば、お教えください。

ここで次のようなコードについて考えます。

Code 1:

```C++
extern void* enabler;
template <typename T, typename std::enable_if<std::is_same<T, int>::value>::type*& = enabler>
void foo(T) {}
template <typename T, typename std::enable_if<std::is_same<T, long>::value>::type*& = enabler>
void foo(T) {}
```

いわゆる enabler を使うコードです。
上のコードは T が int か long かによって正しく呼び分けられますよね。これは理解できました。

ところが

Code 2:

```C++
template <typename T, typename = typename std::enable_if<std::is_same<T, int>::value>::type>
void foo(T) {}
template <typename T, typename = typename std::enable_if<std::is_same<T, long>::value>::type>
void foo(T) {}
```

このようにするとコンパイラに怒られます。
しかしこのコードは T が int のとき、std::enable_if<std::is_same<int, long>::value>::type が存在しないので、下側の関数がオーバーロード候補から外されるのではと思うのですが、どういうことなのでしょうか。

コンパイラのエラーは

```
error: template parameter redefines default argument
template <typename T, typename = typename std::enable_if<std::is_same<T, long>::value>::type>
```

です（Clang 3.7.1）。
読む限りではきっとシグネチャ？が同じなのでオーバーロードできないということなのでしょうが、そうだと言うのなら enabler を用いた例が通るのが逆に不思議に思えてしまいます。

長くなりましたが、要するにお聞きしたいことは Code 1 が 許されて、 Code 2 が許されない理由です。

###補足情報(言語/FW/ツール等のバージョンなど)
Clang (3.7.1), C++14

SFINAE できるコードとできないコードの違い

c++初学者です.

今は入門的な本は終わって、基本的な概念はつかめたところです.
そこでコードの模写を使用と思うのですが,参考になるコードやサンプルソースを教えていただけると助かります.

C++での綺麗なライブラリやコードを教えて欲しい

###前提・実現したいこと
ブラウザ上で部屋のレイアウトを決めるゲーム？を自作したいと考えております。
ブラウザゲームについてはド素人の為、どのような言語だと実現可能か等の
おすすめやアドバイスを抱けると嬉しいです。
既存のサービスやアプリもあるとは思いますが、自作で作成したいです。

---

###実現したい機能
- ブラウザ上にmacのDockのような家具アイコンから選択
- ブラウザ上の部屋に家具アイコンをドラックで配置
- 配置後の家具アイコンのサイズ変更
- 作成後のレイアウトを画像で保存

ブラウザ上で部屋のレイアウトを決めるゲームを自作するのにおすすめな言語は？

エンジニアならこれは読んでおけ みたいな本を教えてください。
ほかにも読んですごく良かった本などでも知りたいです。

アルゴリズムの本や正規表現、TCP/IPなどなど
お願いします

読んでおいたほうがいい本

Javaの標準ライブラリに含まれるクラスには便利なメソッドが多数存在しますが、「非推奨」のメソッドも多数存在します。
非推奨になってまだ日が浅いものなら、新メソッドへの完全移行までの猶予として非推奨メソッドが残されるのは理解できます。
しかし、java.util.Dateクラスのほとんどのメソッド・コンストラクタは**JDK1.1の段階で非推奨**になっています。WikipediaによればJDK1.1のリリースは**1997年2月19日**、つまり**19年も前**です。
なぜこのようなメソッドが今現在も存在し、「非推奨」メソッドとしてドキュメントにも残り続けているのでしょう？

「非推奨」のメソッドがなくならないのはなぜ？

現在Java言語を学習中の者です。
ifやforなどの基本文法、オブジェクト指向の基礎の勉強が終わったところです。

今後は自分で簡単なソフトウェアを作ってみようかと思っているのですが、そのためにはGUIの知識が必要になります。
JavaでGUIプログラミングを行う場合は何を勉強するべきですか？
最新のJavaFXですか？
それともSwingから勉強したほうが良いでしょうか。
さすがにAWTは古いですよね…

回答よろしくお願いします。

Javaを学習中。今後の方針についての相談です。

参照の配列(例えば`int& bar[10];`)は[C++の規格で禁止されている](http://notmoon.hateblo.jp/entry/2015/05/14/120000)ようです。
実際、コンパイルできません。MinGW(gcc)とmsvcの両方もと下記のようなエラーになります。

> error: declaration of 'bar' as array of references
> error C2234: 'bar': 参照の配列は宣言できません。

[ここ](http://homepage2.nifty.com/well/Reference.html#ARRAY_OF_REFERENCE)によると、参照は単なる別名であり、記憶領域があるわけではないので原理的に不可能と書かれてます。

確かにグローバル領域で定義した参照の場合は、参照先アドレスをコード内に即値として持つするような実装もあり得えそうなので、その説明で納得できます。
しかし、クラス内で定義した参照については、参照先インスタンスのアドレスを自インスタンス内で保持している筈です。（参照先アドレスはコンストラクト時に与えられるのでそれを保持しておかないとアクセスできません。）
そして、グローバル領域で定義した場合でも、参照の配列自身に参照先へのアドレスを保持する実装も可能な筈です。
従って、参照の配列の実装は可能な気がします。

でも禁止されているということは何か理由があると思います。その理由やヒントをご存知の方、いらっしゃいましたら是非、ご教授下さい。

---
下記はMinGWとmsvc両方でコンパイルに通ります。参照の配列、許してくれても良い気がするのです。
```C++
#include <iostream>

struct Foo
{
    int &mIntRef;
    Foo(int& iIntRef) : mIntRef(iIntRef)
    { }
};

int a=100;
int b=200;
Foo foo[]={a, b};

//int& bar[2];    // これはコンパイルエラー

int main()
{
    std::cout << "sizeof(foo) = " << sizeof(foo) << "\n";
    std::cout << "foo[0]=" << foo[0].mIntRef << "\n";
    std::cout << "foo[1]=" << foo[1].mIntRef << "\n";
    a=199;
    b=299;
    std::cout << "foo[0]=" << foo[0].mIntRef << "\n";
    std::cout << "foo[1]=" << foo[1].mIntRef << "\n";

    return 0;
}

64ビットでビルドした時の結果：
sizeof(foo) = 16
foo[0]=100
foo[1]=200
foo[0]=199
foo[1]=299
```