ラベル 開発術 の投稿を表示しています。 すべての投稿を表示
ラベル 開発術 の投稿を表示しています。 すべての投稿を表示

2015年7月7日火曜日

ライブラリ化の当面のゴール

このブログで紹介しているように、Swiftで書いた独自ライブラリを少しずつ作り進めています。まだまだ途中の段階ですが、どんなゴールを描いているのか、簡単に紹介したいと思います。

最初に言っておきますが、これから書く話は、ゲームなどのアプリを作るのが前提ではありません。あくまで業務アプリなどの、遊び要素の少ないアプリの開発に関しての話です。ゲームのアプリなら、大規模な開発ツールが既に作られていて、それを使うのが賢い選択でしょうから。

 

新しいOSや開発ツールを使い始めたとき、独自のライブラリ化を進めるのは、開発経験が長い人なら一般的でしょう。ただ、どのようにライブラリ化するのか、どんなゴールを目指して進めるのかは、人によって異なると思います。

私の場合は、開発やメンテの手間を減らすことです。それにより、開発期間が短くなりますし、完成後のメンテの負荷も小さくなります。とにかく幅広く使えるライブラリを増やして、アプリ開発の手間を大きく減らすことが目的です。

ライブラリとして作ったコードは、単独で十分なテストをされているのに加えて、複数のアプリで使われているため、品質は高く保たれがちです。また、OSやツールのバージョンアップで変更が生じたときも、ライブラリ単体で更新してテストを済ませれば、あとはアプリ側のライブラリを入れ替えるだけです。複数アプリを合計した際の作業量は、かなり減るでしょう。

あと、ライブラリの形式として、ソースコードのままで使う方法を重視しています。ソースコードのままアプリに追加する形なので、ライブラリにバグがあっても簡単に見付かりますし、ライブラリを拡張したくなったときも、可能性が簡単に判断できます。ソースコードのまま追加するものの、基本的にはライブラリに手を加えません。ただし、どうしても手を加えなければならないケースでは、ソースの先頭に変更内容を明記する形で、認めてはいます(実際には、めったにやりません)。当然ながら、ライブラリを改良して対応するのが、第一の選択肢です。

以上は、あくまで、目先の目的としての話です(もっと大きな目的は、最後のほうに出てきます)。

 

いろいろなアプリを作っていると、似たようなコードを数多く書いている自分に気付きます。たいていは1から書かず、前に作ったソースコードをコピーしてから修正するでしょう。コピーによって手間は減っていますが、似たようなコードを書いている現状には変わりません。

そんな風に考えていると、似たようなコードを書かなくて済む方法はないか、深く考えるようになります。部分的にコピーして作るのではなく、ソースコード全体をファイル単位でアプリに持って行き、そのままで使える状態に作れないかと。これがライブラリ化の始まりです。おそらく、独自のライブラリを作っている人は、似たような経験や考えがあるはずです。

実際にライブラリ化を進めると、かなりの効果があると実感できます。似たようなコードを書くことが減り、ライブラリで済ませられる範囲が少しずつ増えていきます。もし既存のライブラリで機能が不足する場合も、ライブラリのほうを拡張して、新しいアプリに対応させます。その結果、ライブラリが適用できる範囲が少しずつ増えていきます。

Swiftを使い始めてから、それほど時間が経過していません。1.0の正式版が登場してからですから、まだ1年未満です。それでも、ライブラリを少しずつ作り続けたので、だんだん充実してきました。モデルクラスのライブラリも2つ作り、ライブラリの対象範囲も広がっています。今後の充実が、ますます楽しみです。

 

続いて、別な視点でライブラリを考えてみます。ライブラリ化する機能の種類で考えると、ライブラリ化のゴールが見えやすくなります。

真っ先に作ったのは、どのアプリでも必ず使う機能でした。UI部品の生成、日付と時間、ファイルの閲覧、電子メールの送信、描画機能などです。それらが作り終わると、環境設定など、どのアプリでも作りそうな機能をライブラリ化しました。こうした種類のライブラリ化は今も続けていて、ライブラリによるサポート範囲をさらに広げようとしています。

アプリ独自の要素として作らなければならない機能は、扱うデータを操作するモデルクラス、それを画面に表示して操作するビューとコントローラのクラスでしょう。作る量が大きい順に並べると、ビュー、モデル、コントローラとなります。

このうち、モデルのクラスは、すでにライブラリ化を進めています。まだ種類は少ないですが、少しずつ種類を増やして、ライブラリで済ませる率を向上させる予定です。

ビューは、モデルのように、個々のモデル全体をライブラリで作る形が難しい分野です。ビューの一部をライブラリとして用意し、それらを組み合わせて1つのビューを実現します。つまり、部品として作るのが適している分野です。ただし、機能の種類が多くあるため、ライブラリでカバーできる比率は、なかなか上がらないでしょう。

当面の方向性としては、次のように考えています。ビューを実現するための要素を、幾つかのタイプに分類して、タイプごとにライブラリを増やすつもりです。今までは、部品となる小さなビューだけでした。しかし、モーダルビューのように、動きの実現がメインとなるライブラリも、今後は増えていくでしょう。また、ビュー上にUI部品を繰り返して並べるような機能も、ライブラリとして作りました。これなどは、配置機能に特化したライブラリです。さらには、いろいろなUI部品を生成する関数群、同じUI部品を一気に生成する関数群など、ビューの構成部品の生成もライブラリ化しています。

あと、紹介していませんが、環境設定の専用ビューもライブラリを試作しました。以前に紹介した、環境設定の機能をライブラリ化したものと連動して、環境設定の値を変更するためのビューを生成します。凝った機能には対応できないレベルですが、一般的な設定の範囲であれば、もう使える状態です。以前紹介した環境設定のライブラリを使うと、環境設定の値を定義するだけで、環境設定の機能が作れます。ビューも同様で、環境設定画面の定義を用意するだけで、環境設定を変更するビューが作れてしまいます。これら2つは連動するので、環境設定機能とビュー機能のやり取りは、コーディングする必要がありません。このように、特定の機能を実現するビューなら、ライブラリとして、まだまだ作れる範囲があると思います。

 

アプリ全体として見た場合、ライブラリが適用できなくて、そのアプリ専用にコーディングが必要となる領域は、ビュー関係に一番多く含まれます。つまり、ライブラリ化の一番の肝は、ビューに関する機能のライブラリ化をどれだけ実現できるかです。モデルに関しては、5種類ほど作れれば、半分以上のモデルをライブラリで作れるでしょう。ビューでは、そのような考え方が通用しません。どんな切り口でライブラリ化したら良いのか、どうすれば新しい工夫ができるかが、ビューに関するライブラリ化の度合いを決めます。

今後は、さらにレベルアップできないか検討中です。もう少し違った切り分け方で、ビューの機能を実現できないかと、かなり考えています。まだ結論は出ていないものの、もしかすれば何とかなりそうなヒントだけは思い浮かびました。これを発展させて、新しい種類のライブラリが作れたら、ビューに含まれる機能のライブラリ比率が、かなり向上させられそうです。

 

アプリとして作る機能のうち、モデルとビューでのライブラリ比率が向上できると、アプリ全体でのライブラリ化率がかなり向上できます。

ライブラリなしで開発したときのコード量を10割としたとき、ライブラリの使用により何割減らせるかが、ライブラリの効果を評価する際の数値になると考えています。ライブラリなしで開発したときのコード量というのも、やや大雑把ですね。あえて説明すると、すべての機能をベタで書いたとき(雑誌やウェブでのサンプルのようなコード)のコード量という意味です。

Swiftのライブラリ化を始めた頃は、どの程度まで作れるのか予想が付きませんでした。漠然とですが、遠い将来は5割が目標だけど、当面は3割ぐらいかなと考えていました。

ところが、ライブラリが増えるごとに、それもライブラリの対象範囲が広がるとともに、5割は簡単に実現できると思うようになりました。実際、今まで作ったライブラリの機能だけに限定したアプリを作るなら、5割ぐらいはライブラリで済ませられ、残りの5割をコーディングする形になりそうです。

もし新しい機能を使うアプリを開発する場合は、その新しい機能の部分も、ライブラリとして作ります。そうすると、ライブラリが対応できる機能が増え、似たようなアプリを再び開発する場合は、やはり5割ぐらいがライブラリで対応できる状態になります。

今では、将来的に7割ぐらいも可能じゃないのかと、思い始めています。前述のビュー機能のライブラリ化が、どこまで実現できるかにかかっています。ただし、ライブラリがいくら充実しても、7割強ぐらいが限界ではないかと思います。ライブラリとして作りにくい機能が、ある程度は残りますから。

 

以上の話は、コード量に関してだけです。アプリ開発では、コードを作る以外の作業が多く含まれます。それが減らない限り、開発の負荷は大幅に減りません。その部分に関しては、かなり難しいでしょう。

それとは別に、開発スタイルが大きく変わる可能性はあります。新規に作らなければならないコードの開発量が減ると、とりあえず試しては変更し、異なる仕様を何度も試せます。ライブラリで実現した機能は、使う際の定義データや使い方を変更するだけで、ある程度まで機能を変えられます。もし機能が不足する場合は、ライブラリを拡張して、新しい機能を追加するでしょう。どちらにしても、いろいろと変えながら試せる可能性は、今よりもずっと高まります。

このような開発スタイルが、ライブラリ化を進めている当面のゴールです。それを実現するために、ライブラリで作るコードの割合を7割ぐらいにするのが、別な視点での当面のゴールとなります。

ライブラリを使って作ったアプリは、俗に言うプロトタイプではありません。本番でも使える、実際に動くアプリです。本番用のアプリを、プロトタイプ的に作ろうというのが、ライブラリ化の本当の目的と言えるかもしれません。

 

今回は趣向を変えて、ライプラリが充実したときの状態を、当面のゴールという形で書いてみました。具体的なコードばかり見ていると、大きな目標を見失ったりします。せっかくですから、大きな目標を掲げて、それに向かって努力したほうが、良い結果が得られるでしょう。これを読んだのを良い機会にして、自分なりの当面のゴールを、考えてみてはいかがでしょうか。

2015年5月21日木曜日

iOS実験専用アプリを活用しよう(5)

かなり前になりますが、「iOS実験専用アプリ」の作り方と使いかたを紹介しました。今でも使い続けていますが、以前よりも使い方が上手になっています。というわけで、まだ公開していない新しい使い方を、続編として紹介します。

 

このアプリにはボタンが40個もあり、それぞれに別な機能を割り当てられます。割り当てられた機能の数が増えるほど、画面上に加えるUI部品の数も増えます。そのままでは使いづらいので、使い終わったボタンの機能は、オフする方法も紹介しました。ボタン名の最初に「x」を付けて、ボタンに割り当てた機能をコメント化する方法です。

この方法で問題なく使えるのですが、やはりオンオフが面倒だと感じるようになりました。オフした機能を使う際に、今使っている機能をオフすることも多く、切り替え作業は意外に面倒なのです。

というわけで、いちいちオフしなくても構わない作り方はないのかと、深く考えてみました。やはり真剣に考えると、思い付くものなのですね。今までよりも格段に良い作り方が、できてしまいました。

 

新しい作り方を紹介する前に、以前の作り方を簡単に説明します。

各ボタンには、2つの関数が用意されています。初期化の際に呼ばれるstartBtnXXF関数(XXは2桁の数字)と、ボタンをタップした時に呼ばれるtestBtnXXF関数(XXは2桁の数字)です。

通常の作り方は、初期化のstartBtnXXF関数でUI部品を表示し、ボタン用のtestBtnXXF関数で何かを実行するという形式でした。初期化の際にUI部品を表示してしまうため、複数のボタンをオンすると重ねて表示され、一緒にオンすることができなかったのです。

 

この問題を解決するために、少し発想を変えました。ボタン用のstartBtnXXF関数に初期化の処理も含めたら、オフする必要がないのではないかと。つまり、使い始めるまで何も表示させないという作り方です。

それとともに、使い終わったときの状態も考えなければなりません。使い終わってUI部品が表示されたままだと、別なボタンの機能を使う時に邪魔になります。そうならないようにと、画面上をクリアーする機能も、ボタンの機能に加えることにしました。

ただし、これらの機能を複数のボタンに割り当てたら、ボタンをどんどん消費してしまい、40個もあるボタンがすぐに足りなくなります。そこで、1つのボタンだけ使って、初期化からクリアーまでを実行できる方法を考えました。

解決策は簡単でした。タップされるたびに、順番に実行していけば良いのです。最初のタップで初期化だけします。次のタップでは、1つ目の使い方を実行します。さらに次のタップでは、2つ目の使い方を実行します。このように続けて、一番最後のタップにクリアー処理を割り当て、画面上のUI部品を消します。

クリアー処理が終わると、最初の状態に戻します。そのまま同じボタンをタップすれば、2回目の初期化処理が始まります。このように、初期化からクリアー処理まで何度も繰り返せるように作れば良いのです。

 

以上のような説明だと、難しそうに感じたかもしれませんが、実は意外なほど簡単です。具体的なSwiftコードを紹介しましょう。単純な例のほうが理解しやすいので、2種類の使い方しか含まない例を。

// ======================================== ボタン17:棒グラフ
var graphView17: GraphBarView!
var num17: Int = 0

func startBtn17F() {
    aryButton[17].setTitle("棒グラフ", forState: .Normal)
}
func testBtn17F(rSender:UIButton) {
    setMsgF(1, "タップ17")
    run17F()
}
func run17F() {
    switch num17 {
    case 0:
        setMsgF(2, "生成")
        graphView17 = GraphBarView()
        graphView17.setupF(10, 10, 600, 400)
        graphView17.setLabelF(["SEP 1","SEP 2","SEP 3","SEP 4","SEP 5","SEP 6","SEP 7"])
        graphView17.setDataF([1,24,12,18,30,10,21])
        graphView17.setDataRangeF(0, 40)
        viewBase.addSubview(graphView17)
        graphView17.drawGraphF()
        num17 = 1
    case 1:
        setMsgF(2, "正常1")
        graphView17.setLabelF(["NOV 1","NOV 2","NOV 3","NOV 4","NOV 5","NOV 6","NOV 7"])
        graphView17.setDataF([11,4,22,28,3,20,1])
        graphView17.setApparanceF(1)
        graphView17.drawGraphF()
        num17 = 2
    case 2:
        setMsgF(2, "正常2")
        graphView17.setLabelF(["SEP 1","SEP 2","SEP 3","SEP 4","SEP 5","SEP 6","SEP 7"])
        graphView17.setDataF([1,24,12,18,30,10,21])
        graphView17.setApparanceF(2)
        graphView17.drawGraphF()
        num17 = 999
    case 999:
        setMsgF(2, "終了")
        graphView17.removeFromSuperview()
        num17 = 0
    default:
        break
    }
}

見てのとおり、値ゼロで用意した変数num17を使って、順番に実行させているだけです。要点だけ簡単に説明します。

同じボタンを何度もタップするので、何の処理をしているのか画面上に示す必要があります。この例では、メッセージ欄に短い文字列を表示しています。最初が「生成」で、UI部品を画面上に表示させます。続く「正常1」は、正常系の1番目の実行です。この例には含まれてませんが、エラー系(エラーを含んだ処理)も後に付けるため、通常の使い方を「正常」と表示しています。次の「正常2」も正常系で、別な内容を実行します。最後の「終了」がクリアー処理で、画面上からUI部品を消し、変数num17を初期状態のゼロに戻します。

「終了」してしまうと、メッセージ欄の文字列を除いて、画面上には何も残りません。このボタンの機能を繰り返し実行しても構いませんし、別なボタンの機能を実行することもできます。他のボタンの機能を続いて試す場合は、「終了」で終わらせるのが基本的な使い方です。

 

実行させたい機能は、正常系だけではありません。ほとんどの機能にはエラー処理も含まれているので、正常系に続いて、エラー系の実行もボタンに含めます。前述の例にエラー系の実行を1つだけ加えたSwiftコードは、次のようになります。

// 前述のコードに、エラー系の実行を1つ加えたもの
func run17F() {
    switch num17 {
    case 0:
        setMsgF(2, "生成")
        graphView17 = GraphBarView()
        graphView17.setupF(10, 10, 600, 400)
        graphView17.setLabelF(["SEP 1","SEP 2","SEP 3","SEP 4","SEP 5","SEP 6","SEP 7"])
        graphView17.setDataF([1,24,12,18,30,10,21])
        graphView17.setDataRangeF(0, 40)
        viewBase.addSubview(graphView17)
        graphView17.drawGraphF()
        num17 = 1
    case 1:
        setMsgF(2, "正常1")
        graphView17.setLabelF(["NOV 1","NOV 2","NOV 3","NOV 4","NOV 5","NOV 6","NOV 7"])
        graphView17.setDataF([11,4,22,28,3,20,1])
        graphView17.setApparanceF(1)
        graphView17.drawGraphF()
        num17 = 2
    case 2:
        setMsgF(2, "正常2")
        graphView17.setLabelF(["SEP 1","SEP 2","SEP 3","SEP 4","SEP 5","SEP 6","SEP 7"])
        graphView17.setDataF([1,24,12,18,30,10,21])
        graphView17.setApparanceF(2)
        graphView17.drawGraphF()
        num17 = 101
    case 101:
        setMsgF(2, "エラー1")
        println("----------TEST-ERROR-1:Apparanceが範囲外")  // 区切り行
        graphView17.setLabelF(["NOV 1","NOV 2","NOV 3","NOV 4","NOV 5","NOV 6","NOV 7"])
        graphView17.setDataF([11,4,22,28,3,20,1])
        graphView17.setApparanceF(9)    // エラー
        graphView17.drawGraphF()
        num17 = 999
    case 999:
        setMsgF(2, "終了")
        graphView17.removeFromSuperview()
        num17 = 0
    default:
        break
    }
}

エラー系が正常系と違うのは、メッセージ欄に「エラー1」と出すだけではありません。続くprintln文で、エラーメッセージの区切り行を出力しています。区切り行には、発生が予想されるエラー内容を、短い言葉で書くのが基本です。

エラー系の実行では、処理内容に何らかのエラーを含めるため、実行対象の機能からエラーメッセージが表示されます。そのメッセージが、エラー系のどの実行で出されたメッセージなのか、判別できる必要があります。その判別を容易にするために、区切りのメッセージを出力するわけです。

区切り行だという点を強調するために、先頭にハイフン10個を付けています。エラーメッセージと一緒に並んだとき、区切り行として見えるようにとの配慮です。具体的には、次のように出力されます。

----------TEST-ERROR-1:Apparanceが範囲外
2015/05/20 20:24:50 ERROR:GBV_SA:Apparance番号が範囲外

これだけだと効果を実感できませんが、複数のエラー実行が並んでいて、1つの実行で複数のエラーメッセージが出力されたとき、区切り行のおかげで見やすく整います。

 

ちなみに、変数num17に設定する値ですが、単純な連番ではありません。この例では、正常系は1から始まり、エラー系は101から、終了は999にしてあります。このように作ってあるのは、正常系やエラー系の実行内容を追加したとき、変更する箇所を減らすためです。

もし最初から最後まで連番の場合、修正が大変になります。たとえば、正常系が15個、エラー系が20個あったとき、単純な連番だとエラー系は16番から始まります。そこへ。正常系の処理を1つ追加する場合、エラー系の開始番号が16番から17番へと変更になり、後に続く番号をすべて変えなければなりません。そんな無駄を避けるために、飛び飛びの番号をつけているのです。

この例では正常系の番号を1つずつ増やしていますが、2ずつ増やすとか、10ずつ増やすとかでも構いません。後から追加するとき、間に挿入しやすくなりますから。別な考え方として、正常系の実行を複数グループに分け、最初のグループは1番から始まり、次のグループは21番から、さらに次のグループは41番から、という形で番号を付ける方法もアリです。

 

今回は、「iOS実験専用アプリ」の上手な使い方として、機能をオフしなくて済むような作り方を紹介しました。

この方法が適さない機能もありますから、必要に応じて使い分けたり、別な新しい方法を考え出したりする必要があります。工夫して使うほど、iOS実験専用アプリはどんどん便利になりますね。私の場合、もはや必須ツールとなっています。

 

(使用開発ツール:Xcode 6.3.2, SDK iOS 8.3)

2015年4月21日火曜日

関数名やクラス名の変更と移行の手順

独自ライブラリを作り進めていくと、関数名やメソッド名の命名ルールを思い付くことがあります。でもライブラリとして使っているので、名前を簡単には変えられません。今までに作ったアプリが、それらライブラリを使っているからです。

もし古いライブラリの関数名などを“絶対に変えたい”なら、上手に移行する手順はあります。言われてみれば当たり前の方法ですが、意外に気付かない人もいるようなので、ちょっと紹介します。

 

実は私も最近、新しい命名ルールを採用しました。数回前の投稿で書いたのですが、独自ライブラリの中で、グローバル関数として作ったときの名前は、「z」を付けて始めるルールに決めました。以前なら「createTxtFldF」と付けるところを、今は「zCreateTxtFldF」と付けています。これで新しいアプリは問題ないのですが、古いアプリは「createTxtFldF」が使われています。それも多数の箇所で。そこで次のように、移行作業を進めています。

まず、ライブラリ本体には、両方の名前で関数を作っておきます。どちらを使われても構わないように。具体的には、次のようなSwiftコードになります。

// テキストフィールドを作成
func zCreateTxtFldF(rText:String, rTextSize:CGFloat, rAlign:NSTextAlignment, 
    rX:CGFloat, rY:CGFloat, rWidth:CGFloat, rHeight:CGFloat) -> UITextField {
    let iTextField: UITextField = UITextField(frame:CGRectMake(rX, rY, rWidth, rHeight))
    iTextField.text = rText
    iTextField.font = UIFont(name:FONT_NAME_DEFAULT, size:rTextSize)
    iTextField.textAlignment = rAlign
    iTextField.borderStyle = UITextBorderStyle.RoundedRect
    return iTextField
}
// テキストフィールドを作成(旧タイプ)
func createTxtFldF(rText:String, rTextSize:CGFloat, rAlign:NSTextAlignment, 
    rX:CGFloat, rY:CGFloat, rWidth:CGFloat, rHeight:CGFloat) -> UITextField {
    return zCreateTxtFldF(rText, rTextSize, rAlign, rX, rY, rWidth, rHeight)
}

見てのとおり、同じ関数を2つ作ってはいません。古い関数を新しい名前に変更し、古い名前の関数は、新しい名前の関数を呼び出す形にします。分かりやすく書くと、次のような形で変更してます。

// 関数名の変更前
func 古い関数名(引数) -> 戻り値 { ... }

// 関数名の変更後
func 新しい関数名(引数) -> 戻り値 { ... }
func 古い関数名(引数) -> 戻り値 { return 新しい関数名(引数) }  // 最終的に削除

こうすると、メンテナンスするのは1つだけになり、片方を変更し忘れるミスが発生しません。もちろん、古い名前で呼び出す場合は無駄な処理が発生して少し遅くなりますが、ほとんど影響はないでしょう。もし影響があったら、その箇所を新しい名前に変更すれば済みますので。

どちらが古いのか、他人が見ても判断できるように、コメントで「旧タイプ」と入れておきます。こういった親切は意外に重要なのです。

独自ライブラリの大元は、以上のような形で、当面は両方を残しておきます。ちなみにライブラリの大元は、iOS実験専用アプリの中に作ってあって、テスト用コードも一緒に保存されています。機能拡張する場合も、iOS実験専用アプリの中で行います。アプリで使い始めるか更新する際に、ライブラリをコピーして、アプリ側に持っていきます。

 

ライブラリを使うアプリ側での更新は、どうなるでしょうか。当然ですが、地道な作業で、1つずつ置き換えていくことになります。次のような手順で。

まず最初に、古いアプリで使われているライブラリのソースコード(古い名前だけが含まれる)を、新しいソースコード(新旧両方の名前が含まれる)に入れ替えます。この時点で、念のためにアプリを動かしてみます。全部の機能を試す必要はなく、主な機能だけです。当たり前ですが、正常に動くはずです。

正常動作を確認できたら、いよいよ名前の入れ替えです。アプリ独自のソースコード全部で、古い名前を使っている箇所を見付け、新しい名前に置き換えます。一括置き換えでも大丈夫なはずです。ソースコード全体で古い名前を検索し、ライブラリにしか存在しなければ置き換えは完了です。この状態でも念のために、アプリを動作させて確認します。

いよいよ最後は、ライブラリのソースコードから、古い名前の部分だけを削除します。削除後も正常にビルドでき、正常に動作すれば、移行作業が完了となります。

 

さて、ここで疑問が生じたと思います。アプリ型にコピーしたライブラリのソースコードからは、古い名前が削除されました。でも、ライブラリの大元には、古い名前の関数などが含まれたままです。違う状態のままで構わないのでしょうか。

上手い方法が見つからないので、仕方ないと思っています。他のアプリでもライブラリを使っていて、まだ古い名前が残っている以上、大元のソースコードから古い名前を削除できません。当分の間は、残しておくしか選択肢はないのです。

ただし、ソースコードが違っているため、管理上の工夫は必要です。バージョン管理の代わりとして、アプリ側のソースコードの先頭に、コメントの形でメモを残しています。その内容は、ライブラリをコピーした日付(これがバージョン番号の代用情報となります)、削除した古い名前のグループ名(たとえば「UI部品の生成関数」とか)です。削除した名前を全部羅列するのではなく、分類上のグループ名で代用し、メモの手間を軽減しています。

このようにメモしたライブラリにも、いつか更新の時期がやってきます。改良版のライブラリと入れ替える場合です。その際、せっかくメモした内容が、新しいライブラリのソースコードにも残るように更新します。次のような手順で。

アプリ内のライブラリ入れ替えは、まず古いソースコードのファイル名を少し変更してから、新しいソースコードのファイルを追加します。その後、古いソースコードのメモ部分をコピーし、新しいソースコードの先頭へペーストしてから、日付部分を当日に書き換えます。そのメモ部分を見て、新しいソースコード内の不要な名前の部分を削除するという手順です。少し手間がかかりますが、仕方がないでしょうね。メモ部分のコピーが終わったら、古いソースコードの改名済みファイルを削除して、ライブラリの入れ替えは終了です。

 

以上は、関数名やメソッド名を変更した場合ですが、クラス名を変更する場合も同じ考え方が適用できます。

クラスでも、クラスの記述が1つになるように、古い名前のクラスが、新しい名前のクラスを参照する形で作ります。クラスの場合、参照する方法としてはサブクラスが適しています。分かりやすい形で書くと、次のような形式になります。

// クラス名の変更前
class 古いクラス名 { ... }

// クラス名の変更後
class 新しいクラス名 { ... }
class 古いクラス名: 新しいクラス名 { }  // 最終的に削除

これだと少し分かりにくいですが、古いクラス名の中身は空で、ブロックを示す括弧記号{}で囲まれているだけです。新しい名前のクラスを継承だけして、変更箇所が何もないクラスを作るというわけなのです。

アプリ側の移行方法も、関数の場合と同様です。まずライブラリを入れ替えてから、アプリが正常に動作するから確認します。正常に動いたら、アプリ側のソースコードで、新しい名前のクラス名に置き換えます。ここでもアプリが正常に動くか確認し、正常ならライブラリ内から古いクラス名の部分を削除します。最後にアプリの動作確認をして、正常に動けば移行が終了です。

アプリ側へコピーしたライブラリのソースコードでも、コピーした日付とともに、削除した名前グループの情報を、ソースコードの先頭にメモとして残します。このあたりの考え方は、関数の場合と同じです。

 

今のところ、バージョン番号の代わりとして、コピーした日付を用いています。バージョン番号が好きなら、それを使っても構わないでしょう。ただし、ライブラリの種類が増えると、バージョン番号がそれぞれ違ってしまい、なにかと気分が良くありません。そんな理由もあって、コピーした日付に落ちついたというわけです。もし上手なバージョン番号の命名ルールを思い付いたら、バージョン番号に切り替えるかもしれません。

独自ライブラリとして作ったソースコードの大元は、前述のようにiOS実験専用アプリの中に入れてあります。アプリごとバックアップしていますが、経歴を残したバージョン管理はしていません。何か思い付いたら、機能を拡張したり、内部を改良したりしています。そのため、時間の経過とともに、少しずつ良くなっています。iOS実験専用アプリ内に残っているのは、常に最新状態だけです。好きなときに細かく改良するので、バージョン番号を付けづらいという面もありますね。

逆にアプリのほうは、リリースした全バージョンを、プロジェクトのフォルダごと残してあります。その中に、ライブラリのソースコードも含まれるため、こちらで経歴を残しているのと同じ効果を持ちます。アプリのほうは、アプリ全体にバージョン番号を付けていて、それが管理番号の役割も持っています。リリースするときには、バージョン番号が必要ですし。

 

今回は、関数銘やクラス名を変更する際の話でした。意外に大変なので、めったに変更しないことだけは表明しておきます。でも、Swiftに十分慣れた時点から作り始めたのではなく、だんだんと慣れながら作り進めたので、最初に作ったソースコードの各部名称は、変更したくなるものなのです。自分なりの命名ルールが固まってきたのは、最近ですから。

一番良いのは、過去に作ったものに関して、あまり気にしないことでしょうか。それができれば苦労しないのですけど。

 

(使用開発ツール:Xcode 6.3, SDK iOS 8.3)

2015年2月26日木曜日

言語やAPIの仕様確認がかなり重要

ここまでの何回かの投稿で、Swift言語やiOS APIの仕様確認の話を書きました。良い機会なので、仕様確認に関する話を少し突っ込んで書いてみます。

 

まず、仕様確認という用語から。残念ながら、仕様確認という呼び方は、一般的ではないと思います。おそらく、私が勝手に使っているだけではないでしょうか。つまり、私の個人的な呼び名です。

わざわざ特別な名前をつけて呼んでいる理由ですが、何か名前をつけないと説明しづらいので、とりあえず付けたという感じです。勝手に付けた名前ではありますが、意味は上手に伝わると思っています。

肝心の「仕様確認」の意味を説明しなくてはダメですね。公開されている言語仕様やAPI資料には、細かな部分までは記載されていません。その細かな部分が「実際にはどう動くのか」を、具体的なコードを書いて動かし、調べる行為のことです。より正確に表現するなら「詳細仕様確認」という感じでしょうか。

もちろん、何から何まで調べるわけではありません。自分が気になった箇所、または疑問を感じた箇所だけ、絞り込んで確認するだけです。

 

言語やAPIの資料で、細かな部分まで記載されていないのには理由があります。おそらく一番大きい理由は、作業量が膨大になることでしょう。

例として、is演算子の場合を考えてみましょう。仕様を簡単に書くとしたら、次のようになるでしょうか。データ型を調べるための演算子で、調べる対象となるものを演算子の左側に置いて、データ型を右側に入れます。左側のデータ型が、右側のデータ型と一致すればtrueを、一致しなければfalseを返します。以上のように、非常に簡単に書けて、それなりに意味は伝わります。

しかし、これでは厳密な仕様とは言えません。まず、左側に入れられるものの範囲、同じく右側に入れられる範囲が不明確です。また、データ型が一致するとは、どの範囲まで含まれるかも不明確です。また、左右の組み合わせによって、一致する範囲の説明が異なることも考えられます。これらを明確に規定しないと、厳密な仕様にはなりません。ここまでの説明を読んだだけで、きっちりと説明するのが如何に大変なのか想像できると思います。is演算子だけでこうですから、全部の機能を同じように説明したら、物凄い量の文章量となり、その作業量も膨大になると推測できるでしょう。

もう1つの理由としては、正確に書ける人が非常に少ない点も挙げられます。細かな部分まで正しく理解できるだけでなく、分かりやすく正確に書ける文章力も必要です。おそらく、普通の人には難しいでしょう。

他にも理由はあるでしょうが、結果として、現状のような「簡単な説明だけ」で落ち着いているわけなのです。おそらく「細かな動きは、動かして調べられるから、自分で調べてよ」という考え方なのでしょう。現状の形が「現実的な落としどころ」だと私も思います。

 

現状の資料が細かな仕様まで含まれていない以上、本格的に使う場合は、実際の動作結果を自分で調べるしかありません。「こう動くだろう」と考えてソースコードを書きますが、本当に「こう動く」かどうかは、試してみないと何とも言えません。

今までの経験上、多くの場合は期待した通りに動くものの、たまに期待どおりに動かないこともあると知っています。だからこそ、できるだけ事前に仕様確認して、正確な動きを知っておくようになったわけです。

実際には、何から何まで仕様確認しているわけではありません。大抵の場合は、次のような流れになります。まず最初に、作りたい機能をiOS実験専用アプリ上で作ります。その際に、作った機能をテストするわけですが、正常な動作のほかに、エラーになる動作も含めます。それら両方が期待どおりの結果なら、仕様確認する必要はありません。

ところがまれに、期待どおりの結果が得られないこともあります。当然ながら最初は、自分のプログラムのバグだと思います。でも、いくら直してもバグが消えず、どう考えてもバグがなさそうとだと感じたあたりで、仕様確認を試そうと考え始めます。どの辺の機能が期待どおりに動いてなさそうなのか、バグとして現れている実行結果から予想して、ターゲットとなる機能を絞り込みます。

絞り込めたら、仕様確認のコードを作ります。同じiOS実験専用アプリ内の別な場所(通常は隣の場所)に、仕様確認の機能を割り当てて、そこに作り込みます。作ったコードを実行すれば、API資料に書かれていない仕様を知ることになります。得られた実行結果によって、元のコードを変更するか、別な機能を使って実現するか、今後の方針を決めるわけです。

作りたい機能のコードも、仕様確認のコードも、同じiOS実験専用アプリ内に保存されます。たいていは隣に入れておきますから、APIのバージョンアップなどで細かな仕様が変更された場合でも、連続して実行できて便利です。

期待どおりの実行結果でなかった場合は、その結果を何かの形で残すことも大事です。実行結果は保存されませんから、対象となる仕様確認ソースコードの中に、コメントとして記録しておきます。XcodeやAPIのバージョン番号とともに。

 

以上の例とは違って、仕様確認を先に行なう場合もあります。

作りたい機能を実現するために、どのAPIが使えるか調べているとき、細かな仕様が不明とか、使い方が不明というケースが意外に多くあります。実際に動かしてみないと、本当に使えるかどうか分からない場合は、仕様確認のためにコードを用意して調べます。この場合も、iOS実験専用アプリを使って、その中に作ります。

仕様確認の結果、そのAPIが使えると判断したときは、作りたい機能を同じiOS実験専用アプリ内で作ります。前の例と同じように、仕様確認コードの隣に作って、近くに入っている状態にします。作る順序は逆ですが、作られた状態は似たような形となります。

 

さらには、作りたい機能とは関係なく、仕様確認を行なう場合もあります。

どのような機能でも、特別な条件のときに正しく動作するか、確認してみたくなるケースがあります。特定の機能を並列で複数動かしたときに正しく動くかとか、一般的ではない使い方での動作です。

このような疑問を生じた場合は、やはり仕様確認を行ないます。iOS実験専用アプリ内に確認用コードを追加し、実行させて確かめます。こちらの場合には、作りたい機能のコードはなく、仕様確認のコードだけが保存されます。

 

作りたい機能も仕様確認も、一緒のiOS実験専用アプリに入れるのには、もう1つの理由があります。

一番大きいのは、作る手順でしょう。新しい機能をアプリ内に追加する場合、非常に簡単な機能でない限り、アプリ内で作り始めることはありません。まずiOS実験専用アプリ内で作って、本当に作れるかどうか試します。その後、ライブラリ化できないか考えたり、より共通で使える形に直したりします。そのような過程を経てから、アプリ内にコードをコピーするのが通常の流れです。

結果として、作った機能が再利用しやすく整えられることはもちろん、テストするコードもiOS実験専用アプリに残ります。アプリへ持って行くのは、テストまで終わったコードだけです。

このような手順でアプリを作ると、アプリ内だけで作るコードは、アプリ独自の機能だけに限られます。また、テスト用のコードも、アプリ独自の機能だけに絞られます。

 

Swiftを使い始めた頃は、iOS実験専用アプリを持っていませんでした。そのため、最初に作ったアプリでは、アプリ独自の機能以外のコードも多く含まれています。

Swiftに少し慣れたころ、iOS実験専用アプリを思い付いて用意しました。それからは、新規の機能はiOS実験専用アプリで作り、作り終わったらアプリへ持って行く形にしています。また、過去に作ったアプリの機能のうち、独自ライブラリの形で作れそうなものは、少しずつライブラリ化を進めています。

最初の頃に作ったアプリも、バージョンアップの際に、新しい独自ライブラリに入れ替える予定です。

 

ここまで、仕様確認について色々と書きました。仕様確認の必要性だけでなく、確認用のコードを残すことや、iOS実験専用アプリとの関係まで含まれます。

最初に述べたように、言語やAPIの資料には細かな仕様が書いてありません。自分で実行して確かめ、細かな仕様を調べる必要があります。

細かな仕様を知ることは、APIで提供される機能を正しく理解することになり、気付かないバグを減らすことにも繋がります。アプリの信頼性を向上させるためにも、自分のスキルをアップさせるためにも、疑問に思った点は仕様確認してみてください。

2014年12月30日火曜日

設計しながらコーディングする方法

このブログでは、いくつかの機能を実現する方法を取り上げました。その際には必ず、最初に大まかな設計をしています。その具体的な方法を紹介します。

 

この大まかな設計作業ですが、紙に書いているわけではありません。実は、Xcode上で行なっています。それも、ソースコードを編集するテキストエディタ上でです。「えっ」と思った方が、いるかもしれませんね。でも、いろいろと試した結果、この方法が一番効率的だと判断したわけです。あくまで、私にとって一番効率的ですが。

 

では、具体的な手順を見ていきましょう。

まず最初に行なうのは、入れ物の作成です。そう、Swiftのソースコードを入れるファイルです。Xcode上で新規のSwiftファイルを追加します。

作成時には、これから作成する機能に適したファイル名を付けます。このファイル名も、私なりにルール化していますから、そのルールに合わせた名前を決めます。環境設定の機能を受け持つライブラリのソースコードなら、「BC_Pref.swift」ですね。

そのソースコードを、最初はどこに作るのでしょうか。私の場合は、以前の投稿で紹介した、iOS実験専用アプリを使います。ライブラリ化するソースコードは必ず、このアプリ内で作ります。Xcodeのメニューから、新規Swiftソースコードを追加して、準備は完了です。

 

入れ物が用意できたので、大まかな設計を始めます。思いついた機能や工夫を、テキストとして打ち込みます。ソースコードとして処理されるので、当然、コメントとして入力します。形式としては、箇条書きのメモです。

言葉をひととおり入力したら、今度は全体の構成を考えます。クラスとして仕上げるなら、必要となるクラス変数やメソッドを洗い出して、全体の形を想像します。

全体の形がほぼ決まったら、その内容をコメントの形で入力します。大まかには、次のような感じになります。

// BC_Pref.swift
import Foundation
// ====================================== 検討すべき点
// 環境設定値を入れるデータ型は?
// データ型の一致をどうやって調べる?
// ====================================== 必要な仕様
// 全体を1つのクラスとして作る
// データ型ごとにメソッドを用意する:Int, Float, String, Boolの4種類
// エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
// ====================================== 構成要素
// クラス変数:
// メソッド:初期化
// メソッド:ファイルから読み込み、ファイルへ書き出し
// メソッド:値の取得
// メソッド:値の設定

ここで大事なのが、区切り線です。たくさんの文字を入力しても、どこが区切りなのか明確に示すために、区切り用のコメント行を挿入します。コメント行の最後に、それ以降で入力する内容の見出しを付けます。この見出しが、入力したテキストからはみ出ているように見えると、区切りごとの内容が見やすくなります。

区切りの先頭には、必ず「検討すべき点」を入れます。ここは、解決していない問題点や、疑問に思っていること、機能として含めようか迷っていることなど、決まっていない内容を書きます。今後判断しなければならない内容なら、何でも記述するのが基本です。

 

クラスとして実現する場合は、まず最初にクラスだけ作ります。その中に、構成要素として挙げたコメント行を入れます。この時点で、クラス内の構成要素の並び順も決まります。

このような作業を続けながらも、気付いた点をコメントとして追加していきます。コメントは少しずつ増えていき、それに比例して仕様も細かくなります。ここまでの状態では、次のような感じになっているでしょう。

// BC_Pref.swift
import Foundation
// ====================================== 検討すべき点
// 環境設定値を入れるデータ型は?
// データ型の一致をどうやって調べる?:is演算子で大丈夫か?
// ====================================== 必要な仕様
// データ型ごとにメソッドを用意する:Int, Float, String, Boolの4種類
// エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
// 設定値セットにバージョン番号を含める
// ====================================== 構成要素
class PrefController {
    // クラス変数:設定値セット、保存ファイル名、バージョン番号
    // メソッド:初期化
    // メソッド:ファイルから読み込み(保存ファイルの読み込みも含む)
    // メソッド:ファイルへ書き出し
    // メソッド:値の取得(4種類)
    // メソッド:値の設定(4種類)
}

クラス変数やメソッドのコメントをクラス内へ移動させたので、実際のコードを書き始められる状態となりました。ここからの進め方としては、コメントをさらに追加して仕様を細かく詰めるか、メソッドなどの具体的な入れ物(Swiftコード)を先に作るか、どちらでも好きな形で進められます。

これ以降の作業でも同じなのですが、「検討すべき点」や「必要な仕様」の中に含まれるコメント行は、不要になった時点でどんどんと削除していきます。この段階では、クラスを作ったので、「必要な仕様」に含まれる「全体を1つのクラスとして作る」の行を削除しました。

 

今回は、先にSwiftコードの入れ物を作ってみましょう。おそらくですが、その手順ほうが、動いたときの状態を想像しやすい人が多そうですから。この段階では、メソッド名は決めますが、引数などは最小限しか入れません。その結果、次のようなソースコードになります。

// BC_Pref.swift
import Foundation
// ====================================== 検討すべき点
// 環境設定値を入れるデータ型は?:Dictionaryが使えそう
// データ型の一致をどうやって調べる?:is演算子で大丈夫か?:if letも使えそう
// ====================================== 必要な仕様
// エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
// 設定値セットにバージョン番号を含める
// ====================================== 構成要素
class PrefController {
    // クラス変数:設定値セット、保存ファイル名、バージョン番号
    // メソッド:初期化
    init() {
    }
    // メソッド:ファイルから読み込み(保存ファイルの読み込みも含む)
    func readPrefFileF() {
    }
    // メソッド:ファイルへ書き出し
    func writePrefFileF() {
    }
    // メソッド:値の取得(4種類)
    func getPrefF() -> Int {
        return 1 // dummy
    }
    func getPrefF() -> Float {
        return 1.0 // dummy
    }
    func getPrefF() -> String {
        return "dummy"
    }
    func getPrefF() -> Bool {
        return false // dummy
    }
    // メソッド:値の設定(4種類)
    func setPrefF(rData:Int) {
    }
    func setPrefF(rData:Float) {
    }
    func setPrefF(rData:String) {
    }
    func setPrefF(rData:Bool) {
    }
}

このまま入力を進めると、追加したソースコードやコメント行が増えるほど、メソッドの区切りが見づらくなってしまいます。それを防ぐために、メソッドの種類ごとの境目に、区切り用のコメント行を挿入します。その結果、次のようになります。

// BC_Pref.swift
import Foundation
// ====================================== 検討すべき点
// 環境設定値を入れるデータ型は?:Dictionaryが使えそう
// データ型の一致をどうやって調べる?:is演算子で大丈夫か?:if letも使えそう
// ====================================== 必要な仕様
// エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
// 設定値セットにバージョン番号を含める
// ====================================== 構成要素
class PrefController {
    // クラス変数:設定値セット、保存ファイル名、バージョン番号
    // ==================================== 初期化
    init() {
    }
    // ==================================== ファイルの読み書き
    // ファイルから読み込み(保存ファイルの読み込みも含む)
    func readPrefFileF() {
    }
    // ファイルへ書き出し
    func writePrefFileF() {
    }
    // ==================================== 値の取得(4種類)
    func getPrefF() -> Int {
        return 1 // dummy
    }
    func getPrefF() -> Float {
        return 1.0 // dummy
    }
    func getPrefF() -> String {
        return "dummy"
    }
    func getPrefF() -> Bool {
        return false // dummy
    }
    // ==================================== 値の設定(4種類)
    func setPrefF(rData:Int) {
    }
    func setPrefF(rData:Float) {
    }
    func setPrefF(rData:String) {
    }
    func setPrefF(rData:Bool) {
    }
}

見て分かるように、区切りコメント行の追加によって、前にあったコメント行の内容を吸収している箇所があります。記述する内容は、できるだけ区切り行に含めて、他のコメント行を減らすように心掛けます。

 

ここまでの段階でも、クラス内の大まかな構成が見えてきたと思います。ここからは、実際のコーディングを進める前に、細かな仕様を固める段階に入ります。大事なのは、クラス変数、メソッドの引数と戻り値、エラーチェックの内容、メソッド内に含める処理の4つです。これらを明らかにするように、細かな点を固めていきます。

まず最初に、クラス内の変数を決めます。この例では、キー付きの環境設定値セットを入れるために、データ型を決定しなければなりません。必要なら、簡単な実験を別にすることもあります。いろいろ調べた結果、今回はデータ型Dictionaryで大丈夫と結論付けました。

クラス内の変数が追加できたら、各メソッドに引数や戻り値を追加します。たまたま今回の例では、戻り値が追加済みなので、引数だけを追加することになります。さらに、エラーチェック内容と含める処理を、コメント行として追加します。

ここまでの状態で、次のようなソースコードになりました。

// BC_Pref.swift
import Foundation
// ====================================== 検討すべき点
// 環境設定値を入れるデータ型は?:Dictionaryが使えそう
// データ型の一致をどうやって調べる?:is演算子で大丈夫か?:if letも使えそう
// 上記のデータ型チェックは、全データ型の組み合わせで結果を確認すること
// ====================================== 必要な仕様
// ====================================== 構成要素
class PrefController {
    // クラス変数:設定値セット、保存ファイル名、バージョン番号
    var dictPref : Dictionary<String,AnyObject> = [String:AnyObject]()
    var prefFName : String = "dummy.plist"
    var strVersion : String = ""
    // ==================================== 初期化
    init(_ rDictPref:Dictionary<String,AnyObject>, _ rFName:String, _ rVer:String) {
    }
    // ==================================== ファイルの読み書き
    // ファイルから読み込み(保存ファイルの読み込みも含む)
    // ファイルが存在するか、存在したらバージョン番号を調べる、一致したら値を採用
    func readPrefFileF() {
    }
    // ファイルへ書き出し
    // バージョン番号を追加する
    func writePrefFileF() {
    }
    // ==================================== 値の取得(4種類)
    // 共通エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
    func getPrefF(rKey:String) -> Int {
        return 1 // dummy
    }
    func getPrefF(rKey:String) -> Float {
        return 1.0 // dummy
    }
    func getPrefF(rKey:String) -> String {
        return "dummy"
    }
    func getPrefF(rKey:String) -> Bool {
        return false // dummy
    }
    // ==================================== 値の設定(4種類)
    // 共通エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
    func setPrefF(rKey:String, _ rInt:Int) {
    }
    func setPrefF(rKey:String, _ rFloat:Float) {
    }
    func setPrefF(rKey:String, _ rString:String) {
    }
    func setPrefF(rKey:String, _ rBool:Bool) {
    }
}

ここまで出来上がると、具体的な動きが想像しやすくなります。頭の中でプログラムを動かし、呼び出し側とのやり取りを空想実行してみます。

どの順番でメソッドが呼び出され、それぞれのメソッド内で何が行なわれ、処理結果として何が返されるのか。また、クラス内の変数が、どのように変化していくのか。さらには、間違った使い方をされたとき、クラッシュなどの大きな問題が発生しないのか。などなど様々な点で、仕様に欠点がないかを探します。

もし問題を発見したら、引数を加えたり変更したり、新しいメソッドを追加したり、エラーチェックの内容を書き加えたりします。変更した場合は、再び空想実行してみて、変更の正しさを確認します。これで大丈夫と思えるまで、以上のような検討を続けるわけです。

この段階で細かな仕様を固める理由は、全体を見通しやすいからです。引数や戻り値を含んだメソッド名だけが並び、ほとんどが画面内に収まるか、少しスクロールするだけで全部が見れます。そんな状態なので、相互の関係とかも含めた、全体での整合性などが思考しやすくなっています。

 

いろいろと考えていると、細かな疑問点や不明点が見付かるものです。

たとえば、取得メソッドでエラーが発生した場合、正しい値は返せません。どんな値を返すべきなのか、この段階で決めるのがベストだと思います。nilを返すのか、データ型に該当する何かの値を返すのか。検討して決めた内容を、該当する箇所へコメント行として追加します。次の例のように。

// 取得メソッドにコメント行を追加(該当部分だけ抜粋)

    // ==================================== 値の取得(4種類)
    // 共通エラーチェック:設定値セットが空か、存在するキーか、データ型が正しいか
    // エラー発生時には、nilではなく、ありそうもない値を返す:-99999とか、"ERROR!!!"とか
    func getPrefF(rKey:String) -> Int {
        return 1 // dummy
    }
    func getPrefF(rKey:String) -> Float {
        return 1.0 // dummy
    }
    func getPrefF(rKey:String) -> String {
        return "dummy"
    }
    func getPrefF(rKey:String) -> Bool {
        return false // dummy
    }

具体的な戻り値も、思いついたのならコメント行に記述します。このような形で、細かな仕様を少しずつ明らかにしていきます。

すべての疑問点や不明点が解消され、何もなくなったら、設計段階が終了です。あとは、メソッドの中身をコーディングしていくだけです。

 

ここまでで気付いた疑問点や不明点を解消済みですから、コーディングを開始したら、一気に書いてしまえます。設計段階で深く考えているほど、新しい疑問点や不明点は出てきません。

逆に、設計段階の考えが不十分だと、疑問点や不明点が新たに出てきます。そのような場合には、まず最初に、ソースコードの先頭部分に付けた「検討すべき点」へ、出てきた疑問点や不明点を、コメント行として書き加えます。それから、解消する方法を考え始めます。

基本的には、開始したコーディングを一旦中断して、疑問点や不明点を解消するのが先です。解消方法によっては、メソッドなどの構成が影響を受けるので、無駄な作業を行わないためです。ただし、解消方法がすぐに出そうもないときは、気分転換も兼ねて、コーディングを続けるという選択肢もあります。後から余計な修正が入っても構わないと、割り切りながら。

コーディングしていると、共通の処理が見えてきます。その場合は共通処理を関数として追加し、無駄なコードを書かないように工夫します。また、定義値なども積極的に追加し、間接参照を利用したソースコードに仕上げます。

コーディングが終わった時点のソースコードを、ここに載せても構わないのですが、長いので省略します。そのソースコードは、実際の処理を書き加えたメソッド、メソッドが共通で使う関数、メソッドで使う定義値の変数などが、追記された状態となります。具体的なコードは、数回前の投稿に含まれますから、そちらを参照してください。

 

ひととおりの機能を作り終えたら、本格的な機能確認を行ないます。機能確認というのは、実装した機能が具体的にどう動くのか、確認するための試験実行です。SDKの多くは、細かな仕様を書いておらず、不明確なことが多くて困りものです(書くのが大変なので、気持ちは分からないではないですが)。実際の動きがどうなるか、実装したコードを実行して、確かめるしかありません。

今回の例では、データ型を調べるために、「as演算子」と「if let ... as?」の2つを用いました。それらが実際にはどう動くのか、実行して確かめる必要があります。このような作業を、私は開発ツールの機能確認と呼んでいます。

その結果ですが、機能拡張のライブラリ化の投稿でも書いたとおりです。2つの記述方法とも、データ型が一致しているか調べる動作ではなく、値が代入可能かを調べる動作と判明しました。

期待どおりの動作結果でなかった場合には、そのことをソースコードに残しておく必要があります。今回の例では、該当するソースコードの箇所に、以下のようなコメントを残しました。

// 実際の実行結果などはコメントで残す(コメント部分のみ抜粋)

    // データ型の一致をチェックする機能の、重要な注意点
    // is演算子、if let ... as?のどちらも、代入可能かで判定される実験結果になった
    // Int, Float, Boolの全部の組み合わせで、相互に代入可能。そのため、同じデータ型と判定される
    // 上記2種類の処理は、データ型が同じかではなく、代入可能で判定しているのだろうか?
    // この実行結果は、Xcode 6.1.1、SDK iOS8.1にて確認

このように実行環境まで含め、少し長めのコメントになります。時間が経つと忘れがちな内容なので、細かく書いておくほど、後から助かるでしょう。

 

機能確認が終わり、その動作で問題があれば修正しなければなりません。逆に、その動作でも構わなければ、本格的なテストに移ります。テストの話は、長くなるので省略します。テストが終了すれば、機能的には出来上がりです。

私の場合は、iOS実験専用アプリを使って開発することが多く、テストのソースコードも、そのアプリに含めて保存します。定期的にバックアップしていますから、テストも含めて安全に保存されています。

最後の作業は、ソースコードの整理です。「検討すべき点」などの開発用のコメント行を削除して、仕上がりにふさわしいソースコードとして整えます。余計なコメントは削除して、必要最小限のコメントだけを残します。

私の書き方の特徴でもあるのですが、「ファイルの読み書き」や「値の取得(4種類)」といった、クラス内の区切り用のコメント行は削除しません。それが付いていたほうが、ソースコードの区切りが明確になって、時間が経ってから見たときに、内容を把握しやすくなります。とりあえず残すという位置付けではなく、絶対に必要な区切り線として位置付けていて、全部のソースコードに付けています。ただし、このブログに投稿するときは、ほとんど削除していますが。

 

ここで紹介したのは、ソースコードが1つだけの例です。複数のソースコードを作る場合でも、基本的な考え方は同じで、それぞれに「検討すべき点」などを作ります。

また、全体に関しての「検討すべき点」は、どれか1つのソースコードを選んで、それだけに「検討すべき点(全体編)」を付けます。もちろん使い方は同じです。

 

以上が、私が普段使っている開発方法です。1つのソースコードに、実際の命令ソースコードだけでなく、設計途中のメモをコメントとして加え、それを更新しながら、コーディングもやや並行気味に行ないます。コメントしたメモを命令コードに書き換え、コメントが減りながら命令コードが増えるという形です。最後は、最低限のコメントと、完成した命令コードが残ります。

ソースコードをやや並行気味に書いていますが、一番大事なのは、きっちりと設計すること。命令コードが大枠しかない段階、つまり全体を見渡しやすい段階で、空想実行しながら機能を深く掘り下げて、設計の質を高めることです。この段階で、さまざまな空想実行ができると、良いソースコードが作れます。意地悪な順序で実行させたり、無茶な引数を与えたり、いろいろと空想実行します。ただし、何にでも対応すると、余計なコードが増えますから、対応はほどほどにすべきでしょう。

別な面でも、ソースコードには気を配ります。区切り用のコメントで全体を見やすく整え、開発途中で気付いた注意点などもコメントとして残します。数年後の完全に忘れた頃に見ても、困らないようなソースコードになるようにも配慮します。将来の自分への親切ですね。これは、意外に大事です。

設計や実装の作業は、個人的な好みの部分が大きいでしょう。ここで紹介した方法は、その理由も説明しました。もしヒントとして利用できそうな部分があれば、自分なりのアレンジを加えながら、オリジナルの開発手順を作ってみてください。開発効率の向上だけでなく、出来上がったソースコードの質が上がるかも。

2014年12月13日土曜日

雑誌などのソースコードは再構成して使う

新しい言語や使ったことのない機能などを学ぶ場合、雑誌やウェブにあるサンプルのソースコードを参考にする人は多いと思います。当然ですが、私もその一人です。数多く目にするソースコードですが、「アプリに利用する場合」は、そのまま使ったり、ほぼ真似て作るのはお薦めできません。それには大きな理由があるので説明します。

 

そもそも、雑誌やウェブ、またはメーカーが提供するソースコードの目的は何でしょう。たいていの場合は、作りたい機能を実現することです。つまり、機能の実現を重視したソースコードとして書かれています。

そうした目的のために一番適したコーディング方法は、具体的な命令文をベタで書くことです。説明のためのコメントは加えますが、それ以外では命令文だけをベタに記述します。どのような命令を組み合わせ、どの順序で並べれば確実に動くのか、もっとも理解しやすい方法だからです。

命令文をベタに羅列する書き方は、命令文以外の要素が含まれません。そのため、余計な説明が不要になります。再利用のために何々を工夫したとかいう話は、目的の機能を実現するためには関係ないのです。つまり、機能の実現方法を説明する目的には、命令文をベタに書く方法が最適なわけです。

 

では逆に、アプリを開発するときのソースコードは、どんな点を考えて書かれるのでしょうか。もちろん、人によって考えは違うでしょう。でも、アプリ内の構造を上手に作るとしたら、意見の違いは少ないのではないでしょうか。いろいろな点が考えられますが、実現するのが難しくて、もっとも重視したい点となると、変更への柔軟性です。将来の拡張を十分に考慮し、変更が発生したときの手間が最小限で済むように、いろいろと工夫して書くはずです。

次に挙げる点としては、コードの再利用があります。一度作った機能は、別なアプリで使うときに、手直しせずに使えたら非常に助かります。新しく書くソースコードの量が減るからです。無駄な開発作業を減らす、もっとも有効な手段でしょう。

つまり、ソースコードを作る目的というか、どんな点を重視してソースコードを書くのかが、雑誌のサンプルとアプリ開発では根本的に違っているということです。この点に気付かない人が、意外に多いかもしれません。

 

少し余談になりますが、柔軟性や再利用以外の考慮点として、実行速度が挙げられます。最近は、それほど気にしなくて良くなりましたが、完全になくなったわけではありません。ただし、以前とは状況が違ってます。

実行速度が問題になりそうなアプリを作るときでも、何から何まで速度重視で作るケースは減りました。ツールが発達したことで、ネックになっている処理部分が見付けやすくなったことも大きいです。速度重視の開発でも、手順としては次のように行なうケースが増えていと思います。最初は、スッキリした構造で作り、一応の機能を完成させます。もし遅くて困る機能が発見されたら、解析ツールを使って、遅い原因となっている処理を特定し、その部分に改良を加えます。こうした手順だと、全体として良い構造を確保しながら、速度問題も解決できる可能性が高まります。

もし最初から処理速度が問題になりそうなアプリでも、開発を始める前に大まかな解決方法を考え、その方法に沿いながら、アプリの構造を良くする方法まで検討します。良い構造を抜きにして開発するのは、もう受け付けられない状況になっていますね。

 

話を戻して、変更への柔軟性や再利用を重視した作り方を取り上げましょう。具体的には、どのようなソースコードになるのでしょうか。

まずは、よく使う機能のライブラリ化です。同じ命令コードを繰り返し書かなくて済むように、機能ごとにまとめて、異なるアプリでも共通して使えるように作ります。クラスとして作る場合も、関数群として作る場合もあるでしょう。どちらにするかは、実現する機能の特徴に加え、プログラマーの好みにも関係するでしょうね。いや、本当に好みなんですよ。

さらに考えるのは、機能の切り分けと、切り分けた部分のインターフェースです。たとえば、アプリで作成した内容を、プリンターで印刷したいとします。大きく分けて、印刷内容を生成する処理と、その内容をプリンターに渡して印刷する処理が考えられます。後者の処理は、使用するプリンターに依存し、プリンターごとに作る必要があります。

そうなると一番良い切り分け方は、次のようになります。印刷内容を生成する処理を独立させ、プリンターへ渡す部分のインターフェースを標準化することです。プリンターに渡して印刷する処理は、プリンターごとに作りますが、標準化されたインターフェースに準拠して作るわけです。

こうすると、次のようなメリットが生まれます。印刷内容を生成する処理では、プリンターを切り替えても、修正する箇所が最小限で済みます。同時に、プリンターを扱う処理も独立でき、別なアプリへ持っていきやすくなります。インターフェースを標準化していますから、持っていった別なアプリでも、複数のプリンターを切り替えたとき、呼び出す側の変更が最小限で済みます。

このように見ていくと、機能の切り分けが重要であると理解できます。それぞれの機能が交換しやすく、また他へ持っていきやすくなるように、上手に切り分けることです。さらに、切り分けた部分のインターフェースを標準化して、切り分け後の同種機能を交換可能に作る点も、非常に重要です。上手な切り分けと、切り分けたインターフェースの標準化が、ソフトウェア設計で非常に重要なことなのです。

現在はオブジェクト指向プログラミングが広く普及していますが、これらの切り分けは、オブジェクト指向には依存しません。古くから使われている手続き型のプログラミング言語でも、簡単に実現可能です。その意味で、プログラミング言語の種類に依存せず、もっとも基本的な設計方法と言えるでしょう。

ライブラリ化も含めて、機能を区切る際に一番重要なのが「どこで区切るか」です。上手に区切らないと、メリットを大きくできません。考え方としては、似た機能を交換できるか、そのまま別なアプリへ持っていけるか、という点を重視して決めます。場合によっては、区切りを2段階にして、交換できる可能性を増やすこともあります。何度も試して経験する中で、少しずつ上手になると思います。

 

続いて、広く役立つのが間接参照です。色などの値を定義して、それを参照する使い方が一般的でしょう。上手なプログラミング手法として、C言語などでも古くから使われています。

それ以上に役立つのが、関数などの処理を通した間接参照です。関数を間に入れることで、色々な機能を盛り込めます。たとえば、現在の時刻を得る関数を用意して、アプリに含まれる全部の時刻参照で、その関数を使っているとします。すると、その関数の処理を変更し、通常よりも時間が速く進む機能を加えたり、指定した時間分だけ時刻を早めたり遅らしたりも可能になります。さらには、特定の日付時刻で実行させるといったトリックも、簡単に実現できます。

アプリ上では、メッセージを表示するためのUI部品を付けるでしょう。その場合、UI部品を直接参照するのではなく、UI部品を参照するための関数を用意するのが、間接参照による作り方です。メッセージを表示する個々のソースコードでは、UI部品での代わりに関数を呼び出す形になります。すると、メッセージ表示に特別な機能を追加したいとき(表示時刻を追加するとか)、関数だけを修正して対応できます。

値定義でも関数でも、事前に間接参照を使っておけば、1カ所を変更するだけで、参照している全部の値や機能を変えられます。つまり、変更への柔軟性が高いプログラムになるわけです。

 

以上のような工夫を数多く用いると、どのようなソースコードになるでしょうか。よく使う機能はライブラリ化して、用意した関数やメソッドを呼び出す形になります。間接参照を多用すると、値定義や関数を呼び出す形が増えます。

結果としてソースコードは、関数やメソッドが中心となり、ベタで書いた命令文の率が極端に減ります。雑誌などの見かけるような、命令文をベタで書いたソースコートとは、まったく別物に見えるはずです。アプリ内部の構造を上手に作れる人ほど、その傾向が強いでしょう。

 

ここまでの話を理解すると、ソースコードの作り方が大きく変わると思います。雑誌などのソースコードを参照しても、そのままコピーして使わずに、個々の命令文をプログラム部品として用いながら、アプリ全体の構造に当てはめていくでしょう。まるでソースコードを再構成するような感じで。

よく使う機能をライブラリ化したり、同類の機能と置き換えやすいように処理内容を区分けしたり、そのインターフェースを標準化したり、いろいろな箇所で間接参照を組み込んだり、様々な工夫が思いつくはずです。こうした考え方で、アプリの内部を設計すれば、優れた構造で作れると思います。

 

プログラムの再利用の話になると、オブジェクト指向の話が必ず登場します。でも、オブジェクト指向のプログラムング言語を使い、それを生かしたブログラミング手法(デザインパターンなど)で作ったとしても、再利用しやすいソースコードになるとは限りません。

たとえば、小型プリンターRoltoのサンプルコードは、Objective-C言語を用い、オブジェクト指向の考え方で書かれています。しかし、プリンター処理がアプリ処理と一体化しているため、プリンター処理だけ独立して、他のアプリへコピーしては使えません。また、他のプリンターに切り替えたとき、アプリの処理もかなり変更しなければなりません。最近使ったという理由でRoltoを例に挙げましたが、他のプリンターでもほとんど同じです。

これらのソースコードは、前述したように、ドライバーの使い方を説明するのが目的です。そのため、再利用しやすいコードを目指してはいません。結果として、オブジェクト指向に則って作りながらも、再利用しづらいソースコードの例となってしまいました。

つまり、オブジェクト指向も道具の1つでしかなく、より上位のレベルでのソフトウェア設計において、再利用を考慮することが大事だということです。ここで書いたようなアプリ設計の考え方を採用することで、オブジェクト指向の利点が、さらに有効に活かせるようになります。

 

ここまでの話を、最後に整理しましょう。大事な順に並べると、次のようになります。

変更への柔軟性や、再利用を重視したソースコードを作る視点
1. 機能の切り分け(インターフェースの標準化も含む)
2. 間接参照を多用する
3. オブジェクト指向の利点を利用する(デザインパターンも含めて)

この中では、オブジェクト指向だけが特殊です。他の上位2つは、オブジェクト指向のブログラミング言語でなくても利用できる、ソフトウェア設計術に位置づけられます。

アプリを開発する際には、ここで取り上げたような視点で、アプリの内部構造を考えてみてはいかがでしょう。そうすれば、雑誌などに載っているサンプルのソースコードをそのまま使わず、細かな命令文を部品として再構成するようになり、変更への柔軟性が高くて再利用しやすいソースコードが得られるはずです。

2014年11月27日木曜日

swiftの変数は、積極的に型宣言してます

swiftの変数宣言には、型推論の機能が備わっています。代入する初期値の型により、自動的に変数の型が決められる機能です。これを利用すると、変数宣言のときに、型宣言を付ける必要性が大きく減ります。ソースコードを少しでも短く簡潔に書きたい人には、喜ばれる機能だと思います。

しかし、私は、できるだけ型宣言を付ける方針でコーディングしています。StringやIntのように基本的な型なら省略することもありますが、それ以外の型では、可能な限り型宣言を付けています。その理由を、少し書きます。

 

変数宣言で型も一緒に宣言するのは、iOSのAPIに含まれる様々な型を明示するためです。私の場合は、よく使う機能を独自ライブラリの形で作るので、細かなAPIを覚えることがほとんどありません。もちろん作るときには、おそらく他の人よりも詳しく、ウェブ上のAPI資料を見ます。でも、ライブラリとして作り終わると、ライブラリ内の関数またはメソッドを呼び出すだけなので、個々のAPIの処理内容はすぐに忘れてしまいます。覚える気も最初からありません。だからこそ、忘れても構わないように、後から思い出しやすい形でコーディングしているわけです。

APIに含まれる型を変数宣言に入れると、変数の型で検索しやすくなります。そのため、後で機能を拡張したい時や、バグが発生したときに調べやすくなります。完全に忘れてしまっても大丈夫です。

 

加えて、複数のメソッドを連続して書くのではなく、途中に一時的な変数を挿入するようにもしています。その変数はletで宣言し、変数の型も宣言に含めます。型を指定して途中に変数を使うと、自分が正しく理解しながらコーディングしているかの確認にもなります。swiftは型チェックが厳しい言語なので、間違っているとコンパイラーがエラーを知らせてくれるからです。

APIの中身に詳しくないまま自動変換を使っていると、コンパイルエラーが消えないとか、コンパイルは通ったものの、実行させると正常に動作しないといった状況が生じることもあります。原因を探るために、途中に変数を入れたりするでしょう。

ところが、最初から途中で変数を使い、しかも型宣言までしていると、その変数が何の型なのかは明白です。たいていは実行前にコンパイルエラーとなり、自分の理解が間違っていることを知ることができます。API資料を見直して、正しく理解する作業に移れます。無駄な実行や、遠回りのデバッグを大きく減らせる手段でもあるのです。

最近のコンパイラーは最適化の機能が凄いので、途中に変数を入れても遅くなりません。もし遅くなったとしても、通常の動作に影響するほどは遅くなりません。安心して、途中に変数を入れています。

当たり前のことですが、変数の型が正しいだけでは、処理内容をきちんと理解していることにはなりません。でも、変数の型すら間違っているなら、正しい理解の最低限もクリアーしていないことを意味します。変数の型が正しいのか確認することは、最低限をクリアーしていることの確認でもあります。

途中に変数を入れる目的は、もう1つあります。将来、自分以外の開発者がアプリをメンテする可能性を考慮しての判断です。メンテできる開発者を少しでも増やすには、処理内容が理解しやすいコーディングが欠かせません。途中に変数を入れて、その型を明示することで、APIの内容を解析しやすく仕上げられます。メンテする必要が生じたとき、優秀な開発者を確保できるとは限りませんから。

 

iOSのAPIには、中身は同じなのに型が違うものが数多くあります。StirngとNSString、FloatとCGFloatなどは分かりやすい例でしょう。これらの型は、同じように見えても、使えるメソッドなどが違っています。NSStringにはdoubleValueメソッドがあり、Doubleに変換するのが便利といった具合に。違いを知って、上手に使い分ける必要があります。

これらとは違って、中身が分かりにくい型もあります。NSTimeIntervalの中身がDoubleというのはAPI資料を見ないと知り得ません。きちんと理解してコーディングするためには、NSTimeIntervalの中身がDoubleと知っておくのがベストです。中身の型が違っていると、自動的に変換してくれなかったり、変数の種類による精度の違いからバグが生じたりもします。

余計なトラブルを事前に避けるためには、中身の型を意識しながらコーディングし、中身の型ができるだけ見えるような形で途中の変数を使います。この場合、途中の変数が基本的な型であっても、変数宣言の中に、あえて型宣言を入れます。または、明示的にキャストを使ったりもします。

 

私の勝手な推測ですが、swiftの開発者は、厳密な型宣言や型チェックを重視したかったのではないでしょうか。Optionalなんかも、その一環と思えます。でも、それだけだと、ものぐさな開発者(失礼)に見向きもされないため、仕方なく型推論の機能を付けたのではないかと。それは現実的な解であり、選択肢が多いほうが良いだけに、何の文句もありません。

私のように、どんなに注意深く実行しても人間はミスすると思っている人は、可能な限り多くのことをコンパイラーに頼ります。変数の型を積極的に宣言するコーディング方法は、そのための一番の方法だと考えています。実際に何度も、実行前にミスを見付けてもらっています。今後も、変数宣言に型を入れ続けるでしょう。

 

私の開発スタンスは、APIの細かな名前などは基本的に覚えない(もちろん大まかな仕組みは理解しておく)、忘れても思い出せるようにコーディングするというものです。それを実現するためのコーディングとして、途中で挿入する変数を増やし、その変数宣言で型を明示するようにしています。

このようなスタンスは、覚えるのが苦手な人にも適していると思います。自分に向いているスタンスだと感じた方は、swiftでも積極的に型宣言しましょう。

2014年11月20日木曜日

管理しやすい分類情報付きファイル名を使おう

アプリを開発するとき、ソースコードだけでも何個ものファイルを作るでしょう。その名前(ファイル名のことですが)を、どのように付けていますか。機能を表す言葉を名前に付けるのは当然として、他に何か工夫してますか。

アプリの規模が大きくなるほど、ソースコードのファイル数が増えます。多くなったファイルを管理するために、どのような工夫ができるでしょうか。いろいろな工夫が考えられる中、今回はファイル名を使った工夫を取り上げてみます。

実は今まで、ファイル名の命名ルールに関してだけでも、何度かの改良を加えてきました。使用するOSや言語や開発ツールによっても異なるため、次々に良くしていったわけではなくて、使用環境ごとに合わせながら変えてきたわけです。ここで紹介するのは、Xcode+swiftという開発環境に合わせた工夫です。それでもオブジェクト指向の言語に共通する工夫だと思いますから、考え方は参考になるでしょう。興味のある方は読んでください。

 

ファイル管理のために、ソースコードのファイル名を工夫する方法では、ファイル名に分類情報を含めることで実現します。分類情報といっても、難しいことではありません。私の場合は、大まかな種類を示すために、先頭の2文字に役割を持たせるのが中心です。

具体的には、ファイル名の先頭に2文字の略号を加える方法で実現しています。実際に使っている略号は、今のところ、以下の5種類です。

// ファイル名の先頭に付ける主な分類情報
・AC:特定の条件(装置など)に依存する共通ライブラリのクラス(複数アプリで利用)
・BC:共通ライブラリのクラス(複数アプリで利用)
・BP:共通ライブラリの関数や定義値など(複数アプリで利用)
・MC:アプリで使うモデルのクラス
・VC:アプリで使うビューのクラス

見て分かるように、上から3つが自作の共通ライブラリで、どのアプリにでも使えるように作っています。何かのアプリを開発し始めたとき、必要なものを選んでプロジェクトに追加します。もちろん、開発途中に追加することもあります。

「BC」は、日付処理やファイル処理といった共通機能を、クラスとして実現したライブラリです。続く「BP」は、クラス以外の形で実現した共通ライブラリです。UI部品の生成関数や、目的別の色定義など、どのアプリでも使いそうな内容を入れています。

「AC」は、どのアプリでも共通に使えるライブラリの中でも、特定の装置に依存するとか、特定の環境だけで動くとか、何かの条件があるものが対象です。以前に紹介した、小型プリンタRoltoを制御するクラスなどが、この分類に入ります。

下から2つが、アプリごとに作成するクラスです。「MC」は、扱うモデルごとに作るクラスで、「VC」は、表示する画面ごとに作るクラスです。複数のモデルを使って、印刷用のレイアウト画像を生成するクラスなどは、「MC」に入れます。

5つのうち4つが、クラスとして作成するソースコードです。各ソースコードの中には、大きなクラスだけでなく、関連する小さなクラスも入れます。小さなクラスを独立したファイルとして保存すると、数が急激に増えてしまいます。それが嫌いなので、ファイル数を増やさないようにと、関連するものは一緒に入れています。

 

先頭に略号を付けるという話だけでは、どんな感じなのか想像しづらいでしょう。ということで、実際のファイル名に使った場合の例を挙げてみます。長くならないように、一部を抜粋した感じのファイル名一覧です。

// ファイル名一覧の一例(抜粋版)
・AC_Print_Net.swift
・AC_Print_Rolto.swift
・BC_Date.swift
・BC_DrawCG.swift
・BC_Files.swift
・BP_Base.swift
・MC_Pref.swift
・MC_Products.swift
・MC_Sales.swift
・VC_Env_Brows.swift
・VC_Env_Manag.swift
・VC_Main.swift
・VC_Pref_Edit.swift
・VC_Prod_Edit.swift
・VC_Sales_Brows.swift
・VC_Sales_Edit.swift
・VC_Sales_Graph.swift
・VC_Sales_Input.swift

見てのとおり、ファイル名を並べただけでも、きっちりと分類されている感じに見えます。また、先頭に付けた略号の変わり目では、非常に弱くですが、水平の区切り線があるようにも見えます。もちろん、そのような効果も狙っての命名ルールなのです。

先頭の略号に続けて、半角のアンダースコアを入れています。この1文字が、全体を見やすくするとともに、区切り線が見えるようにもしているのです。ファイル名の中に入れた2番目のアンダースコアも同様で、言葉の区切りを明確に見せています。

 

ファイル名の付け方では、先頭の略号以外にも、いくつかのルールを決めています。まず、名前を長くしないことです。短くて内容が推測できるように、長い言葉は略して付けるように決めています。

先頭の略号以外では、2段階の分類としての役割を持たせています。とくに画面ごとのクラスは、同じデータを扱いながら、入力用や閲覧用やメンテ用などの複数画面を作ります。それらの画面を区別しながら、同じデータを扱うことも表さなければなりません。扱うデータの種類を中分類に、役割の違いを小分類として命名すれば、先頭の略号を大分類として、3段階の分類階層が実現できます。

こうした階層による分類は、Xcode以外でファイルを扱うときにも役立ちます。Xcodeのプロジェクト上では、好きな並び順に動かせますが、Finderなどのファイル管理ソフト上では、ファイル名による並び順に変わります。そんなときも、階層で分類したファイル名なら、きっちりと区分けされた形でファイル名が並ぶのです。オープンダイアログでも同じで、探しているファイルが見付けやすくなります。

3階層の分類を使うのは、おもに「AC」と「VC」です。「AC」では、中分類に「Print」と付けることで、印刷関係のクラスだとが表現できます。「AC」での中分類は、共通ライブラリとして決まった言葉を用いることが大原則です。もう一方の「VC」では、中分類にモデルの種類を付けることで、1つのモデルを扱う複数画面を1つに束ねられます。また、どの「MC」と関係しているのかも明確に表せます。複数のモデルを扱う「VC」の場合は、複数のモデル名を短縮して、中分類に入れることになります。

複数ある「VC」の中でも、「VC_Main」だけは特別です。名前から分かるように、最初に表示される画面です。最初に表示されるわけですから、アプリ全体に関係する初期処理なども入れます。また、アプリで使う共通の定義値なども宣言します。これらを別に分けても構わないのですが、メイン画面に入れることで、初期処理中に何か重大なトラブルがあった場合に、トラブル内容の細かな表示が作りやすいメリットが生まれます。

今までやったことはないのですが、外から持ってきたソースコードのファイルを追加する場合のルールも決めています。そのようなファイルは名前を変えずに、元のまま追加するだけす。先頭の略号が付いていないことで、自分が作成したソースコードではないと区別できます。また、元のままのファイル名を残すことで、どこから来たのか探しやすくもなります。

 

先頭に付ける略号が、今の形に決まるまでは、何度か変更がありました。XcodeとSwiftを使ってアプリを作っていく中で、前に使っていたルールを変更しながら、今は上記の形になりました。つい最近のことです。

少し前までは、「AC」と「BC」の区別はなく、どちらも「ZC」としていました。また「BP」は、「ZZ」としていました。「Z」で始まる言葉が少ないので、ライブラリは「Z」で始めるのは良いかなと考えてのことです。でも、先頭に付ける略号なので、一般の言葉との重複を気にする必要はないと考え始めました。そこで、「Base」の頭文字を使った「B」に落ち着いたという流れです。「B」から分離した「A」は、名前でソートしたときに「B」の近くに並ぶ言葉を探し、思い浮かんだ「Add」の頭文字から取りました(深い意味はありません)。

このブログの何回か前に、「ZZ_Base」という記述が出てきたと思います。今は「BP_Base」に変えています。ようやく今回の形で、一応落ち着いたかなという感じですね。今後は、大きく変えないでしょう。略号の追加はあると思いますが。

 

Xcode上で作るswiftソースコードのファイル名は、クラス名と同一にする必要はありません。それよりも、自分が使いやすい(または管理しやすい)名前をつけることで、間違いを少しでも減らしたり、再利用する際に扱いやすくするほうが大事でしょう。そのような視点でファイル名の付け方を考えると、いろいろなアイデアが出てくるのではないでしょうか。この機会に、ファイル名に加える分類情報を考えて、自分なりに扱いやすい命名方法を見付けてください。

2014年11月17日月曜日

iOS実験専用アプリを活用しよう(4)

iOS実験専用アプリを作って活用する話の続きで、今回が最後です。書き残した話をいくつか追加します。細かい話ですが、意外に重要だったりもします。

 

40個のボタンを持つ実験専用アプリですが、機能をどんどん追加すると使い切ってしまいます。そうなったら、新しい画面を追加して開き、さらに40個のボタンを追加して、などと考える人もいると思います。でも、お勧めしません。機能が増えるほど、コンパイル時間も長くなり、シミュレーターを起動するまで待たされます。軽く使えるのが大事ですから、使い切った場合は、新しい実験専用アプリを用意するというのがお勧めです。

開発経験が豊富な人ほど、こういった実験専用アプリは多く使うと思います。該当する人は、最初から複数の実験専用アプリを用意して、ジャンルごとに使い分ける方法をお勧めします。たとえば、UI部品の実験専用アプリ、グラフィック関係の実験専用アプリ、ファイルの読み書きの実験専用アプリ、日付や文字列などの基本データの実験専用アプリという具合に。どれにも入れられない機能のために、その他の実験専用アプリも追加するとよいでしょう。

ジャンル分けには大きな意味があります。目的の機能が、単に探しやすいだけではありません。過去に作った機能を組み合わせて新機能を作るとか、関連性が強い機能が集まっているだけに、新しい機能を作りやすい環境にもなり得るからです。また、デバッグやテスト用に付加する機能も、共通で使えたりします。

ジャンル分けしたら、各アプリの画面表示にもジャンル分けを明記します。ラベルに入れる文字列で、ジャンルを明確に示しましょう。間違ったジャンルのアプリへ追加しないためにも。

 

複数の実験専用アプリをジャンルごとで作り分けるなら、それぞれの機能に適した細かなアレンジが可能です。文字列を処理する実験が多いなら、ラベルの数を増やすと使い勝手が向上します。今は1行に5個のラベルを入れていますが、あと1行か2行ぐらい増やして、ラベルの数を数倍にすれば、複雑な機能でもラベルを追加する必要がなくなります。

また、文字列を手で入力して実験したい場合もあるでしょう。ラベルとともにテキストフィールドを用意すると、各機能で追加しなくて済みます。テキストフィールドの場合は、入力した値をゲットする関数も必要となります。

このように、ジャンルに適した改良を加えると、より使いやすい実験専用アプリに仕上がります。何が必要かは、機能を作っているうちに明らかになるので、少しずつ改良していくとよいでしょう。

 

実験専用アプリには、40個のボタンがあるわけですが、10個ずつ4行に分かれています。自由に使って構わないのですが、簡単な分類を先に決めておくことをお勧めします。似た機能を並んで配置でき、ばらけて点在するのを避けられるからです。

例えば、文字列や数値などの基本データ用の実験専用アプリを用意したとします。4行のうち、1行目が文字列、2行目が文字列以外のデータ、3行目は文字列と他のデータの両方を使う場合、4行目は未定というように決めます。

分類は、データの種類だけとは限りません。データの扱い方で分類する手もあります。1行目は値の変換、2行目は値の加工、3行目は値のチェック、4行目はその他、というのもアリです。過去の経験から、どのような機能を作ることが多いのか、それらをどんな視点で分類したら整理しやすいのか、などと考えて決めます。

最初に決める分類は、あくまで仮決めです。作っていくうちに、変更しても構わないでしょう。まあ、最終的に点在気味になってしまっても、あまり気にしないことです。少し気持ちが悪いだけで、探せないことはないですから。

 

過去に作った機能を拡張するとか、既存の機能を少し改良したいこともあるでしょう。そんな場合は、前の作成物をそのまま残しておき、拡張版は新しいボタンに追加する作り方がお勧めです。前のままで使いたい場合もあるでしょう。また、拡張してみてダメだったときでも、前の状態に戻す作業は不要です。拡張版や改良版は、前の作成物を残したまま作り始めるのが基本です。

実際の作業では、前に作ったソースコードをそのままコピーして、新しいボタンのところへペーストします。ペースト先はボタン番号が違いますから、注意が必要です。コピーしたコードをそのままペーストした後、古い番号の箇所を新しい番号に書き直します。この作業だけで問題なく動くはずです。

改良を始める前に、必ず行ったほうがよいのが、改良前の状態のままでの動作確認です。コピー&ペーストをミスしている可能性がありますから、最低限の確認をするということです。

動作確認が終わったら、さっそく作り始めましょう。最初の状態での動作確認が終わっているだけに、安心して作り進むことができるはずです。

 

新しい機能の実験を追加して、必ず成功するとは限りません。なかなか成功しないときは、時間が経ってから再開するのが効率的でしょう。しかし、長く時間が経過して開くと、どんな問題が発生していたのか、すぐには思い出せません。

しばらく放置すると決めたら、どんな問題点があったのか、どこまで試したのか、ソースコードのコメントとして説明を残しましょう。短い説明でも残しておくと、状況が短時間で思い出せます。コメントの先頭には、「失敗中」などの未完成だと示す言葉を入れるのを忘れずに。

さらに明確にするために、ボタン名も変えておきます。私の場合は、「x」で始まるのが機能の停止中のルールなので、「xx」で始まるのが失敗中というルールにしています。停止中として「x」を使っているので、さらに別な文字を使わなくて済むようにと「xx」を選びました。こうした命名ルールは、好きな形に決めてください。

ここまで4回に分けて、実験専用アプリを上手に作って使う方法を紹介しました。一番大事なのは考え方で、紹介したアプリは一例に過ぎません。解説した考え方を参考にしながら、どんどんとアレンジして、自分にとって一番使いやすい実験専用アプリを作ってください。実験専用アプリは自分の財産になりますから、バックアップも忘れずにね。

2014年11月15日土曜日

iOS実験専用アプリを活用しよう(3)

iOS実験専用アプリを作って活用する話の続きです。前回は、簡単な機能の実験を取り上げました。続きとして、もう少し複雑な機能を作るときの注意点を解説します。今回のswiftコードも、一部を除いてViewControllerクラスに入れます。

 

各ボタンに用意してある2つの関数のうち、多くのコードを追加するのは、タップされたときに動かすほうの関数(名前がtestで始まる関数)です。行数が多くなると困るのが、機能をオフする場合。全体を囲むコメントで何とかなりますが、2カ所の入力が必要で、使いやすくはありません。やっぱり、オフする際には1行だけコメントに切り替える方法(2つの半角スラッシュ)が一番です。

1行だけでオンオフする方法としては、return文を追加する手も使えます。実行したいコードの先頭にreturn文を入れ、それをコメントにすると以降が実行されるという具合に。逆に、return文をコメントでなくすると、オフの状態という使い方です。ただし、return文が使える状態では、コンパイラーから注意が出てしまいます。return文以降が絶対に実行されないよ、という注意で、例の黄色い表示です。気分が良くないので、使いたくないのが普通でしょう。

これらとは違う方法を採用します。ボタンに追加する機能が2行以上になるときには、それ全体を関数として外に出します。ボタンのタップで起動する関数内では、外に出した関数を呼び出す形にします。こうすると、呼び出す部分が1行になり、、機能のオンオフが簡単になります。具体的なswiftコードは、機能をオフした状態では次のようになります。

// ボタンタップで動作する機能を関数として外に出し、それをオフした状態
// ====================================== ボタン15
func startBtn15F() {
    aryButton[15].setTitle("x総数計算", forState: .Normal)
}
func testBtn15F(rSender:UIButton) {
    setMsgF(1, "タップ15")
    //run15F() // <------------------------ コメントにしてオフ状態
}
func run15F() {
    ...
    getTotal15F()
    ...
}
func getTotal15F() {
    ...
}
// ====================================== ボタン16

ここで大事なのは、追加した関数名です。他の機能と関数名が重複しないように、関数名の一部にボタン番号を必ず入れます。ボタン15に追加する機能の場合なら、関数名を「run15F」や「getTotal15F」にするといった具合に。このようにルール化しておけば、関数名の重複を気にする必要がなくなります。

もちろん、例外もあります。作り終わったとき、関数をそのまま持っていけるように作りたい場合もあるでしょう。そんなときは、最終的に使う関数名を付ます。当然、関数名が重複しないように注意しながらですが。

 

作る機能が複雑になるほど、関数の外に変数を用意する必要性が増します。変数を使う場合も、簡単な注意点があります。まず変数名ですが、関数名と同じように、ボタン番号を必ず含めます。このルールに決めると、変数名の重複を気にする必要がなくなります。

次に変数宣言の挿入場所です。追加する機能だけで使う変数ですから、関係する関数の近くが最適です。これも自分なりのルールを決めたほうがよいでしょう。私の場合は、最初に用意された2つの関数よりも前に置くと決めています。最初に変数宣言があれば「この機能は、関数の外に出した変数を使っている」と気付きやすくなるからです。とにかく、自分の好みのルールで統一することが大事です。

私のルールで作った場合の具体的なswiftコードは、次のようになります。

// 関数の外で変数を使う場合の例
// ====================================== ボタン16
var iAVPlayer16:AVAudioPlayer!

func startBtn16F() {
    aryButton[16].setTitle("AIFF再生", forState: .Normal)
}
func testBtn16F(rSender:UIButton) {
    setMsgF(1, "タップ16")
    iAVPlayer16 = playSoundResF("Yen", "aiff", 1.0)
    iAVPlayer16.play()
}
func playSoundResF(rFName:String, _ rSuffix:String, _ rVol:Float) -> AVAudioPlayer {
    var iAVPlayer:AVAudioPlayer!
    let fileURL:NSURL = NSBundle.mainBundle().URLForResource(rFName, withExtension:rSuffix)!
    iAVPlayer = AVAudioPlayer(contentsOfURL:fileURL, error:nil)
    iAVPlayer.volume = rVol
    return iAVPlayer
}
// ====================================== ボタン17

この例のtestBtn16F関数では、コメント化する場合の対象が2行になっています。連続した2行ならコメントに変更しやすいので、わざと残してみました。実験専用アプリですから、ある程度までなら、緩く作っても構わないと思います。

 

画面上にUI部品を追加し、それに値を入れたり参照する場合も、関数の外に出します。置き場所は、変数と同じルールで構わないでしょう。具体的なSwiftコードは、次のようになります。

// UI部品(ここではUITextField)を追加する例
// ====================================== ボタン17
var txfTimeIntv:UITextField!

func startBtn17F() {
    aryButton[17].setTitle("HandCtrl", forState: .Normal) // <----- ボタン名変更もお忘れなく
    txfTimeIntv = createTxtFldF("12", 16, ALIGN_LEFT, 700, 60, 100, 30)
    viewBase.addSubview(txfTimeIntv!)  // <--------- オフするときは、この行をコメント化
}
func testBtn17F(rSender:UIButton) {
    setMsgF(1, "タップ17")
    run17F()  // <--------- オフするときは、当然ですが、こちらもコメント化
}
func run17F() {
    ...
    let iDouble:Double = Double(txfTimeIntv!.text!.toInt()!)
    ...
}
// ====================================== ボタン18

画面上にUI部品を追加した場合も、機能をオフしたいときがあります。そのときは、UI部品の生成はそのままにしておき、ビューに加えている箇所だけコメントにします。具体的には、addSubviewメソッドの箇所だけコメント化するということです。

この方法の利点は、続くコードへの影響がほとんどないことです。UI部品を生成して設定するところまでは残っていますから、そのUI部品を使うコードがコンパイルエラーになることはありません。

 

作りたい機能が大きくなると、独立したクラスとして作る場合もあるでしょう。その際には、追加するクラスを別なswiftソースコードに入れ、そのクラスを利用するコードだけをViewControllerクラスに入れます。

// クラスを使う側のコード(ViewController.swift)
// ====================================== ボタン18
func startBtn18F() {
    aryButton[18].setTitle("HandCtrl", forState: .Normal)
}
func testBtn18F(rSender:UIButton) {
    setMsgF(1, "タップ18")
    run18F()
}
func run18F() {
    let handCtrl = HandController()
    ...
}
// ====================================== ボタン19
// クラスは別なソースコードに分けて追加(HandController.swift)
class HandController {
    ...
}

クラスとして作る場合は、重複しないクラス名を付けるはずですから、ボタン番号を気にしないで付けても大丈夫でしょう。そのクラスを呼び出す関数だけ、ボタン番号を付けることになります。

 

続いて、デバッグ時に役立つ使い方も紹介しましょう。期待したとおりに動かない場合は、どこを通っているか調べたり、途中での値を表示したり、プログラムが動く様子を探ろうとするでしょう。ブレークポイントを設定して動き止め、途中の状態を調べる方法も、よく使われます。

それとは別に、println文を使って、動きの流れを記録したり、途中の変数を記録する方法もあります。println文で出力した内容は、デバッガで見ることになるため、画面の切り替えが生じます。少し手間ですね。その代わりに使うのが、用意したラベルへのメッセージ表示です。setMsgF関数とaddMsgF関数を組み合わせて、通った箇所を表示させます。

具体的な例を見たほうが分かりやすいでしょう。次のようなswiftコードになります。

// 
// ====================================== ボタン20
func startBtn20F() {
    aryButton[20].setTitle("HandCtrl", forState: .Normal)
}
func testBtn20F(rSender: UIButton) {
    setMsgF(1, "タップ20")
    run20F()
}
func run20F() {
    setMsgF(0, "通過:0,")
    ...
    if flagVX {
        addMsgF(0, "2b,")
        ...
        return
    }
    addMsgF(0, "2a,")
    ...
    addMsgF(0, "4,")
    ...
    switch (n) {
    case 1:
        addMsgF(0, "61,")
        ...
    case 2:
        addMsgF(0, "62,")
        ...
    case 3:
        addMsgF(0, "63,")
        ...
    default:
        addMsgF(0, "69,")
        ...
    }
    ...
    addMsgF(0, "9,")
}
// ====================================== ボタン21

かなり入れ過ぎですね。何種類かの例を含めたので入れ過ぎました。実際に使う場合は、適度な数を入れてください。

使い方の基本としては、最初にsetMsgF関数を使い、前の実行で残っている文字列を消しながら、新しい文字列を入れます。それ以降ではaddMsgF関数を使い、文字列を後ろに追加していきます。if文やswitch文のところでは、両方または見たいほうにaddMsgF関数を付けて、どちらに行ったのかを調べます。タップした直後に、動きがラベルに表示されるので、表示を切り替える必要はありません。もしテキスト入力欄を追加し、そこに文字列を入力してはタップするようなテストだと、値によって通る箇所の違いが容易に見えて助かります。

ちなみに、最初に表示するsetMsgF関数にだけ、先頭に「通過」という文字列を入れています。これは、何年後かにソースコードを見たときや動かしてみたとき、「通過した箇所を表示しているのだな」と理解させるためです。「少しの手間で、数年後の自分へ親切にする」という方針の一環です。

 

デバッグ時の途中の値の表示も、同様に簡単です。表示するラベル番号を選び、setMsgF関数やaddMsgF関数を追加するだけです。

// 実行途中の値もラベルに表示
    ...
    setMsgF(4, "iStr=\(iStr)")
    ...
    if (n > 5) { addMsgF(4, ",iStr2=\(iStr2)") }
    ...
 

値の表示でも、できるだけ1行で書くことが大事です。1行だけだと、先頭に「//」を追加してコメントに変更しやすいですから。

私の場合、コメント化した行は、使い終わっても残すようにしています。後から機能を変更したり、再テストするときに、その行が役立つこともあるからです。本番用のソースコードではないので、コードを綺麗に保つ必要はないでしょう。

 

ここまで、実験専用アプリの使い方を詳しく説明しました。いろいろな注意点も細かく取り上げたので、すべて理解すれば、かなりの使い手になると思います。次の投稿では、書き残した点などを書く予定です。

 

(使用開発ツール:Xcode 6.0.1, SDK iOS 8.0)

2014年11月13日木曜日

iOS実験専用アプリを活用しよう(2)

iOS実験専用アプリを作って活用する話の続きです。この話のキモとなる、ボタンの使い方を紹介します。正確には、ボタンに機能を加えて、テストする方法の紹介ですね。今回のソースコードも、前回と同様にViewControllerクラスに入れます。

 

40個も作ったボタンには、それぞれに2つの関数を用意します。何の実験機能も付けていない、空の状態で用意する関数です。最初の2つ分だけを切り出したswiftコードは、次のようになります。

// ====================================== ボタン0
func startBtn0F() {
    aryButton[0].setTitle("B0", forState: .Normal)
}
func testBtn0F(rSender: UIButton) {
    setMsgF(1, "タップ0")
}
// ====================================== ボタン1
func startBtn1F() {
    aryButton[1].setTitle("B1", forState: .Normal)
}
func testBtn1F(rSender: UIButton) {
    setMsgF(1, "タップ1")
}

それぞれ2つの関数には、ボタン番号(0〜39)が含まれていて、番号で区別されます。名前がstartで始まる関数は、アプリが起動したときに呼ばれるもので、開始前の準備処理を記述します。残りの、名前がtestで始まる関数は、ボタンをタップしたときの処理を記述します。こちらの関数は、前回、ボタンを生成した処理の最後のほうで、各ボタンに割り当てられています。

コメント行が右に長く伸びているのは、実験のソースコードを追加したときでも、ボタンの区切りが明確に見えるようにと考えてのことです。ソースコードを短く切り分ける工夫はしていないので、どうしても長くなります。でも、こうして区切りを明確にしておくと、ぜんぜん使いづらくはなりません。

 

準備処理の関数は、アプリを起動したときに実行しなければなりません。また、前回紹介したボタンやラベルの生成関数も、アプリの起動時に実行しなければなりません。viewDidLoadをオーバーライドする箇所へ入れて、アプリ起動時に実行させます。具体的なswiftコードは次のとおりです。

// 
override func viewDidLoad() {
    super.viewDidLoad()
    zDate = DateController()  // 日付機能の開始
    zFiles = BaseFiles()      // ファイル管理機能を開始

    startBasic1()    // 基本部品1の生成
    startBasic2()    // 基本部品2の生成
    startTestF()      // テスト用ボタンの生成

    // ボタンの前処理(startBtnXXF関数)を順番に実行
    for i in 0...39 {
        let iFuncName = "startBtn" + String(i) + "F"
        let iName = "n" + String(i)
        NSNotificationCenter.defaultCenter().addObserver(self, selector:Selector(iFuncName), name:iName, object:nil)
        let iNotif = NSNotification(name:iName, object:self)
        NSNotificationCenter.defaultCenter().postNotification(iNotif)
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }
}

一番最初に、日付管理やファイル管理といった独自ライブラリーのインスタンスを生成させています。この実験専用アプリにも、いつもの独自ライブラリーを使っているというわけです。

続いて、前回紹介した3つの生成関数を順番に実行します。これが実行し終わった段階で、ラベルやボタンが表示できる状態となります。40個のボタンそれぞれにも、今回紹介した2番目の関数(名前がtestで始まる関数)がリンクされています。

最後に、今回紹介した最初の関数(名前がstartで始まる関数)を、順番に実行しなければなりません。startBtn0F()からstartBtn39f()まで40個すべてを書いても構わないのですが、40行もあると格好が悪いでしょう。また、あまりにも芸がなさ過ぎです。というわけで、別な方法で実行させました。40個の関数名の文字列をfor文で順番に生成し、その文字列を渡して実行してもらう方法です。NSNotificationを使います。関数名の文字列ごとに、名前をつけて登録した後で実行させ、登録を削除するという手順です。もっと簡単な方法があればいいのですが、私が調べた限りでは、この方法しか見付かりませんでした。

以上で、実験専用アプリが出来上がりました。あとは、上手に活用するだけです。

 

では、実際に実験内容を追加してみましょう。最初は簡単な内容ほど理解しやすいと思いますので、ラベルに現在時間を表示する実験を選びます。実験するほどの内容ではないですが、ボタンの使い方を知るには適しています。最初のボタンとなる、ゼロ番のボタンに追加しましょう。

起動時の処理も使いたいので、起動時に現在時刻をラベル5に表示する機能を作ります。startBtn0F関数に1行を追加するだけです。さらには、何の実験をしているのか、画面から見えなければなりません。そのため、ボタンの名前(タイトル)も書き換えます。

続いて、タップしたときの機能も追加します。こちらもラベル5に、現在の時刻を表示しましょう。起動時に表示した時刻を、タップして上書きする動きとなります。以上を実現するswiftコードは、次のようになります。

// ボタン0に、実験機能(現在時刻を表示)を追加
func startBtn0F() {
    aryButton[0].setTitle("現在時刻", forState: .Normal)
    setMsgF(5, zDate.getStrTimeF())
}
func testBtn0F(rSender: UIButton) {
    setMsgF(1, "タップ0")
    setMsgF(5, zDate.getStrTimeF())
}

書き換えたのは3カ所です。startBtn0F関数では、文字列「B0」を「現在時刻」に書き換え、時刻を表示するための1行を追加しました。もう1つのtestBtn0F関数でも、時刻を表示するための1行をしてます。とても簡単ですね。

これを実行すると、ボタン0の表示が「現在時刻」に変わり、何かの実験機能が割り当てられていると知ることができます。そのボタンをタップすれば、ラベル5の現在時刻が更新できます。これで実験は成功に終わりました。

 

実験のために追加したコードのほかに、ラベル1へメッセージを表示する機能が、最初から付いていました。しかも、表示するメッセージの前に、実行時の時刻(時分秒)を加えて表示するようになっています。表示するメッセージは「タップ0」で、タップした操作であること、タップされたボタンの番号がゼロであることを示しています。

実際にタップすると、現在の時刻と一緒に「タップ0」が表示されます。タップする度に時刻が更新され、同じく「タップ0」が表示されます。タップされたことと、その時刻が毎回表示されているのです。

何のために、こんな機能があるのでしょうか。正常に動いてないとき、念のための確認ができる機能なのです。追加した機能を実験したとき、実験用のビュー上に何の変化もなかったとします。タップが正常に受け付けられていれば、その時刻と「タップ0」が表示されいているはずです。再びタップすれば、時刻の表示が更新されるでしょう。この動きから、基本的な機能は動いていると確認できます。逆に、再びタップしたときに時刻が更新されなければ、基本的な動作が停止していると判断できます。

新しい機能を実験するわけですから、最初は何か問題が発生するでしょう。そのとき、基本的な動作が動いているかどうか確認できれば、探す範囲を少しは絞り込めます。調べるために余計な機能の追加をせず、最低限の確認ができるようにと用意した機能なのです。実験専用アプリならではの工夫といえます。

 

最大40個もの実験を付けられますから、早々にラベルの数が足りなくなるでしょう。ラベルの数をどんどん増やす手もありますが、使える画面の面積は限られていますし、賢い方法とも思えません。実験が終わったボタンは、その機能をオフするほうが賢い選択でしょう。

追加した行をコメントにしてしまえば、簡単にオフできます。ただし、ボタン名の変更はオフすることが難しいですね。また、最初の「B0」に戻してしまうと、このボタンに機能が割り当てられていることが伝えられません。そこで、機能を表すボタン名を残しながら、オフしていることも伝えられるボタン名に変更します。たとえば、「現在時刻」から「x現在時刻」に変更するとか。ボタン名の先頭に「x」が付いているものは機能がオフ状態だと、自分なりにルールを決めてしまうのです。

このようにして機能をオフした状態は、次のようなソースコードになります。

// ボタン0に追加した実験機能をオフ状態にする
func startBtn0F() {
    aryButton[0].setTitle("x現在時刻", forState: .Normal)
    //setMsgF(5, zDate.getStrTimeF())
}
func testBtn0F(rSender: UIButton) {
    setMsgF(1, "タップ0")
    //setMsgF(5, zDate.getStrTimeF())
}

実験機能はオフされたので、この状態でボタンをタップすると、ラベル1に時刻付きの「タップ0」が表示されます。当然のことですが、ソースコードを修正して、コメントでない状態に戻せば、いつでも同じ実験を繰り返せます。

 

1つの機能を実験するのに、複数のボタンを使う場合もあります。そんなときは、隣り合ったボタンを利用します。大事なのは、複数のボタンが関係していると、アプリを起動した状態で明確に示すことです。余計な手間をかけないで示す方法としては、ボタン名を利用するのが一番でしょう。小文字のアルファベット1文字を決め、両方のボタン名の最初に付ければ、関係性は明確に伝わります。

具体的な例を見るのが一番でしょう。まだ機能を追加してない状態ですが、swiftのコードは次のようになります。

// ボタン2つをペアで使う場合(ボタン名だけ変更し、機能を加える前の状態)
// ====================================== ボタン8
func startBtn8F() {
    aryButton[8].setTitle("s画動_前", forState: .Normal)
}
func testBtn8F(rSender: UIButton) {
    setMsgF(1, "タップ8")
}
// ==================== ボタン9
func startBtn9F() {
    aryButton[9].setTitle("s画動_次", forState: .Normal)
}
func testBtn9F(rSender: UIButton) {
    setMsgF(1, "タップ9")
}
// ====================================== ボタン10

見て分かるようにソースコード上では、ボタン名だけではなく、区切りコメントの長さでも関係性を示しています。後ろ側の区切りコメントの長さを半分程度に縮めて、2つのボタンがペアで使われていることを表します。この例では、ボタン9の区切り行が短いので、ボタン8とボタン9がペアで使われていると分かります。

ボタン名の先頭に付ける文字ですが、機能停止用として「x」を使っている場合は、それ以外の文字を選ぶことになります。隣り合っていることが条件なので、離れているボタンであれば、同じ文字を2カ所以上で使っても構いません。ボタン8とボタン9のペアで先頭に「s」を付け、これらから離れたボタン21とボタン22のペアでも先頭に「s」を付けるといった具合に。

機能をオフするときの変更は、単独で使っているボタンと同じです。先頭に「x」を付けるルールなら、上記のボタンを「xs画動_前」と「xs画動_次」に変更することになります。このように停止した状態でも、2つのボタンがペアで使われていることが表現できます。

 

予想外に長くなってしまいました。さらなる続きは次の投稿にて。

 

(使用開発ツール:Xcode 6.0.1, SDK iOS 8.0)

2014年11月12日水曜日

iOS実験専用アプリを活用しよう(1)

皆さんは、初めて作る機能などを試すとき、どのような方法を用いてますか。swiftだから、playgroungですか。でも、UI部品を使う機能などは試せませんよね。私の場合は、実験専用のアプリを用意して、その中で様々な機能を作りながら試しています。このアプリを作ってから、playgroungはほとんど使わなくなりました。そんな実験専用アプリも、少しずつ改良したおかげで、どんどん使いやすくなってきました。アプリの中で使っている工夫も面白いのではないかと思い、皆さんにも紹介します。

 

最初に、専用アプリを用意する理由を取り上げます。まず良い点として、アプリ上で機能を作ると、最終的に使う形と非常に近い構造で作れる点が挙げられます。関数の形で作れば、またはクラスとして作れば、ほとんど直さずに目的のアプリへ持っていけます。

2番目の利点は、テスト環境まで含めて、どんどんと蓄積できることです。試しに作った機能を、後から改良したいと思ったとき、テスト環境まで含めて残っていると、すぐに改良を始められます。前の状態がそのまま残っているので、改良する部分だけを作れば済みます。逆に、新しい機能を試す度に新アプリを作っていたのでは、管理できず、必要なときに見付からないこともあり得るでしょう。でも、いくつもの機能をどんどん追加できる実験専用アプリなら、探す必要はありません。

いくつもの実験ソースコードを作ったとき、管理しやすいのも利点です。新しく作りたい機能が見付かったとき、実験専用アプリに追加していきます。すると、どんどんと機能が蓄積され、1つのアプリに様々な機能を保存できていることになります。探している機能が、どこに付いているのかも明確に示せます。もちろん、様々な機能を一緒に追加しても動くように、実験専用アプリを作る必要があります。まあ、その部分こそ、今回のキモなのですが。

新しい機能を簡単に試せることも、非常に重要です。実験専用アプリでは、追加する機能を試すとき、アプリ起動時に実行する処理や、ボタンをタップしたときに実行する処理など、処理を書く場所などの大枠が最初から用意されています。また、メッセージを表示するUILabelも複数用意してあります。機能を試すために、ボタンやラベルを追加する作業はほとんど不要です。こういった工夫をすることで、新しい機能を素早く作って試せます。

 

様々な利点を挙げたけど、どんな形をしたアプリなの?と疑問を持たれたことと思います。簡単に説明すると、ボタンが40個あり、メッセージ欄も6個あり、自由に使えるView領域を持ったアプリです。何の機能も追加していない、まっさら状態の画面表示は、次のようになっています(シミュレーター上のメニュー機能で画像をコピーしたため、余白が少し多めに追加されたようです。実際の画面表示では、中央の大きな長方形が、画面の左右両端に接しています)。同じ理由で、上下の余白も実際より広くなっています。

画面表示だけで全部を説明することは無理ですが、まずは画面表示を知ってもらわないと、説明が始められません。

 

画面の構成要素を、上から順番に紹介しましょう。一番上の左側にアプリのタイトルがあります。その右にはメッセージ用ラベルがあって、メッセージをクリアーするボタンが並びます。

その下には、合計20個のボタンが並んでいて、それぞれに機能を割り当てて使います。使い方が大事なのですが、それは後で解説します。一番下にもボタンが20個あり、使い方は上のボタンと同じです。上下に半分ずつ分けたのには、ちゃんとした理由があります。追加する機能によっては、テキストフィールドなどのUI部品が必要となります。その場合、ボタンが上下に分かれていると、その近い方に追加でき、追加したUI部品が増えたときに、ボタンとの関係性が理解しやすく配置できます。

上側のボタンの直下には、メッセージ用ラベルが5つあります。長さが違うものを用意して、必要な文字量に応じて使い分けます。5つのうち、一番左側のラベルだけは、決まった機能が割り当てられていて、通常は使えません。

中央にある大きな長方形が、自由に使えるUIViewの領域です。この上に様々なUI部品を配置して、テストすることになります。ただし、操作ボタンとメッセージ欄は既にありますから、それ以外のUI部品が対象です。

 

では、具体的な作り方として、swiftのコードを紹介します。実験をサポートする機能の前に、40個のボタンを生成する方法でも。これだけの数のボタンを作るとき、1つ1つをInterface Builderで描いていたら、大きさを揃えるのも含めて、非常に大変ですよね。私の場合は、Interface Builderを使わずに、UI部品の生成関数を使ってます。

実験専用アプリなので、ソースコードが雑です。その辺を気にせずに見てください。また、これから紹介するソースコードは、すべてViewControllerクラスに入れます。

UIButtonのインスタンスを入れる配列を用意して、20個ずつ2回に分けてボタンを生成しています。配置する座標を計算し、UI部品の生成関数に与えながら生成した後、配列に入れています。2回に分けたのは、配置場所が2つに分かれているからです。

// ボタンを入れる配列
var aryButton : [UIButton] = []
// テスト用のボタン生成
func startTestF() {
    // ボタンのサイズの基本値
    let iW : CGFloat = 95.0
    let iH : CGFloat = 30.0
    // ボタンの位置の基本値
    let iX1 : CGFloat = 15.0
    let addX1 : CGFloat = 100.0
    let iY1 : CGFloat = 60.0
    let addY1 : CGFloat = 40.0
    // 上段のボタン生成
    for i in 1...2 {
        let iY = iY1 + (addY1 * CGFloat(i - 1))
        for j in 1...10 {
            let iX = iX1 + (addX1 * CGFloat(j - 1))
            let iButton = createBtnF("Dummy", 14, iX, iY, iW, iH)
            aryButton.append(iButton)
        }
    }
    // 下段のボタン生成
    let iY2 : CGFloat = 690.0 - 80.0
    for i in 3...4 {
        let iY = iY2 + (addY1 * CGFloat(i - 1))
        for j in 1...10 {
            let iX = iX1 + (addX1 * CGFloat(j - 1))
            let iButton = createBtnF("Dummy", 15, iX, iY, iW, iH)
            aryButton.append(iButton)
        }
    }
    // 全部のボタンに設定(タイトル、アクション、表示基盤)
    for i in 0...39 {
        let iTitle = String(i)
        aryButton[i].setTitle(iTitle, forState: .Normal)
        let iStr = "testBtn" + String(i) + "F:"
        aryButton[i].addTarget(self, action:Selector(iStr), forControlEvents: .TouchUpInside)
        self.view.addSubview(aryButton[i])
    }
}

ボタンを生成して配列に入れた後は、40個のボタンをまとめて処理してます。タイトルをつけ、タップしたときに呼ばれる関数をセットし、ビューに加えてます。間接参照となるビューは使ってません。実験専用アプリだから、手抜きでもOKです。

このような場合こそ、UI部品を生成する関数が大活躍します。生成自体は1行でできますから、for文で回して一括生成しても短いソースコードで済みます。それぞれに配置座標を与え、配列に加えていきます。配列に入れてしまえば、同様にfor文で一括処理できます。

for文で一括生成する方法だと、後からの修正も簡単です。ボタンの大きさを変えたり、全体を上に移動したり、間隔を少し広げたり、文字サイズを変えたりが、1つか2つの数値を変更するだけでできます。何度か実行しながら修正すれば、好みの状態を得られるでしょう。ビジュアル系ツールには難しい芸当です。

 

続きとして、ボタンの使い方を書きたいのですが、それが当テーマのキモのため、長くなりそうなので、その前にメッセージ用ラベルを取り上げます。ボタンと同様に、UI部品の生成関数を使って作ってます。次のようなswiftコードです。行数が増えたのは、ラベルにグレーの枠線を付けたからです。ラベルの区切りを見やすくするために必要だと思いました。

// タイトルと最上部ラベルの生成
var lblMsg : UILabel!
var btnClesr : UIButton!
func startBasic1() {
    let lblTitle = createLblF("iOS各種実験アプリ", 30, ALIGN_LEFT, 20, 10, 300, 40)
    self.view.addSubview(lblTitle)
    lblMsg = createLblF("", 18, ALIGN_LEFT, 290, 15, 655, 30)
    lblMsg.layer.borderWidth = 1
    lblMsg.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(lblMsg)
    btnClesr = createBtnF("Clear", 16, 950, 15, 60, 30)
    btnClesr.addTarget(self, action:"clearMsgBF:", forControlEvents: .TouchUpInside)
    self.view.addSubview(btnClesr)
}
func clearMsgBF(rSender: UIButton) {
    clearMsgF(0)
}
// ラベルを生成(一番上のlblMsgラベルの生成は含まず)
var lblMsg1 : UILabel!
var lblMsg2 : UILabel!
var lblMsg3 : UILabel!
var lblMsg4 : UILabel!
var lblMsg5 : UILabel!
var viewBase : UIView!
func startBasic2() {
    lblMsg1 = createLblF("", 14, ALIGN_LEFT, 10, 140, 125, 20)
    lblMsg1.layer.borderWidth = 1
    lblMsg1.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(lblMsg1)
    lblMsg2 = createLblF("", 14, ALIGN_LEFT, 140, 140, 75, 20)
    lblMsg2.layer.borderWidth = 1
    lblMsg2.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(lblMsg2)
    lblMsg3 = createLblF("", 14, ALIGN_LEFT, 220, 140, 125, 20)
    lblMsg3.layer.borderWidth = 1
    lblMsg3.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(lblMsg3)
    lblMsg4 = createLblF("", 14, ALIGN_LEFT, 350, 140, 245, 20)
    lblMsg4.layer.borderWidth = 1
    lblMsg4.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(lblMsg4)
    lblMsg5 = createLblF("", 14, ALIGN_LEFT, 600, 140, 420, 20)
    lblMsg5.layer.borderWidth = 1
    lblMsg5.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(lblMsg5)
    viewBase = createViewF(0, 165, 1024, 515)
    viewBase.layer.borderWidth = 1
    viewBase.layer.borderColor = UIColor.lightGrayColor().CGColor
    self.view.addSubview(viewBase)
}
func setMsgF(rNum:Int, _ rStr:String) {
    switch (rNum) {
    case 0:
        lblMsg.text = rStr
    case 1:
        let strTime = zDate.getStrTimeF()
        lblMsg1.text = strTime + " " + rStr
    case 2:
        lblMsg2.text = rStr
    case 3:
        lblMsg3.text = rStr
    case 4:
        lblMsg4.text = rStr
    case 5:
        lblMsg5.text = rStr
    default:
        lblMsg.text = "ERROR:setMsgF"
    }
}
func addMsgF(rNum:Int, _ rStr:String) {
    switch (rNum) {
    case 0:
        lblMsg.text! += rStr
    case 1:
        lblMsg1.text! += rStr
    case 2:
        lblMsg2.text! += rStr
    case 3:
        lblMsg3.text! += rStr
    case 4:
        lblMsg4.text! += rStr
    case 5:
        lblMsg5.text! += rStr
    default:
        lblMsg.text = "ERROR:addMsgF"
    }
}
func clearMsgF(rNum:Int) {
    switch (rNum) {
    case 0:
        lblMsg.text = " "
    case 1:
        lblMsg1.text = " "
    case 2:
        lblMsg2.text = " "
    case 3:
        lblMsg3.text = " "
    case 4:
        lblMsg4.text = " "
    case 5:
        lblMsg5.text = " "
    default:
        lblMsg.text = "ERROR:clearMsgF"
    }
}

ソースコードの数値を見てわかるように、5つのラベルはどれも長さが違っています。表示する文字列の長さに応じて、適切な長さのラベルを選んで利用します。一応、限られた表示面積をもっとも有効に使えそうな、長さの組み合わせを選びました。なお、テスト途中で手動による内容クリアーが必要な場合は、最上位の消去機能付きラベルを利用します。

ラベル用の関数は共通で3つを付けました。単純に値を入れる、値を追加する、クリアーするの3つです。このうち文字列の最後に文字列を追加する関数は長いラベルで使い、状況の変化を見るのに便利です。

ラベルに値をセットする関数と、クリアーする関数を用意しました。すべてのラベルで共通で使います。ラベルに入れる値ですが、生成時は空の文字列で、クリアーすると空白文字が入ります。クリアーが1度でも実行されていれば、空ではなく空白文字が入るので、空の状態と区別できます。実験アプリなので、空白文字でクリアーする必要もなく、代わりに何かの文字(半角ピリオドとか)を入れる手もありますね。

前述のように、lblMsg1だけが特別で、文字列の前に時刻(時分秒)を追加しています。これが実験のとき、かなり役立つのです。使い方の説明のときに、詳しく解説します。

UIViewのviewBaseを付けた理由も簡単に触れましょう。これがなくてself.viewに付けるとなると、上部のボタンやラベルの分だけ座標位置を計算しなければなりません。縦軸の位置の値がゼロから始められるように、viewBaseを用意しました。また、枠線を表示することで、UI部品を付けられる範囲を示す意味もあります。

 

長くなってきたので、続きは次の投稿にて。

 

(使用開発ツール:Xcode 6.0.1, SDK iOS 8.0)

2014年10月20日月曜日

開発方針:Interface Builderもstoryboardも使わない

ブログのタイトルのとおり、Xcode+swiftでiPad上で動く業務アプリを開発しています。その際に気付いたことなどを、いろいろと書いてみます。一部の人には役に立つのではと思ったからです。これは良いと思った考え方やアイデアは、どんどん使ってください。

 

最初に作ったのは、Titanium mobileで作って運用中の業務アプリの移植でした。swiftとiOS APIを覚えるためにと、試しに移植してみることにしたわけです。このアプリでは、よく使われるUI部品(TableViewやWebViewも含む)、画面切り替え、ファイルの読み書き、オフスクリーンの描画、メール送信、ペーストボード、時間管理など、いろいろな要素が含まれていています。これを移植すれば、たいていの業務アプリが作れるようになると考えたからです。

実際、移植が終わった時点では、自分なりのライブラリが残り、これからのアプリ開発に広く役立つ基礎が整いました。また、移植したアプリは実際の業務で使われることとなり、今後はXcodeで開発することになりました。広い意味でも、移植してよかったです。

 

開発で一番大事なのが、設計方針です。設計方針といっても、何種類かの視点がありますが、まずは開発ツールの使い方です。何を使い、何を使わないかを決めなければなりません。xcodeでは、Interface Builderを使うか使わないか、storyboardを使うか使わないか、この2点が重要でしょう。結論としては、どちらも使わないで作ると決めました。

これらのツールを使うと、一見は作りやすく見えます。でも実際には、開発面では柔軟性が低い、つまり変更に弱いアプリに仕上がってしまいます。たとえば、全部のボタンを違う設定に変更したいとき、Interface Builderで個々に呼び出して変更したのでは、大変な手間になります。しかし、ソースコードでボタン生成の共通処理を作っておけば、その1カ所を変更するだけで、全てのボタンを一発で変えられます。このような柔軟性の高い作り方をするためには、できるだけソースコードで書いて作ることが重要なのです。

トラブル対処でも、できるだけソースコードで書いた方が安心です。ツールを使うと、そのツールの使い方が悪かったり、ツールにバグがあったりして、トラブルの原因が見えづらくなりがちです。ソースコードだけならば、原因は自分の作り方にあり、ソースコードだけを調べて原因追及できます。このほうが、はるかに効率的でしょう。

あと業務アプリでは、同じ種類のボタンや項目を、何個も並べることが多くあります。これもfor文で生成しながら配列に入れる処理が良く、ソースコードだけで作る方法に適しています。業務アプリこそ、ツールを使わない作り方に向いているのかもしれません。

 

ツールを使うと、明らかに良い面もあります。それはGUI設計で、最終的な形を見ながら作れる点です。これは捨てがたい魅力なのですが、なくても何とかなります。画面設計は、専用の空アプリを用意して対応します。1画面だけの中身なしアプリで、ソースコードにより部品を並べていきます。軽いアプリのため、シミュレーターを起動するのも短時間で済みます。ソースコードの表示位置や大きさを変更し、シミュレーターを起動して確認する作業を何回か繰り返すだけです。良いと思ったら、ソースコードを目的のアプリへコピーします。

このアプリのおかげで、GUI設計がだいぶ楽になりました。画面ごとにコピーして、必要な画面分だけ作りました。あとで生じるのは微調整だけなので、大きく困ることはありませんでした。

 

のっけから、あまり一般的ではない作り方だと感じたかもしれません。また、ツールを使わずに作るのは大変だと思うかもしれません。でも試してみると、それほど大変ではありませんでした。余計なトラブルに巻き込まれないためにも、柔軟性の高いアプリを作るためにも、Interface Builderやstoryboardを使わない作り方をお薦めします。

今後は、これらのツールを使わないで作るときのコツや、柔軟性の高い設計方法を書いていければと思っています。Titaniumのブログで書いたのと重複する内容でも、気にせずに書きます。こちらに書かないと、検索で見付からないでしょうから。