エラーハンドリング (プログラミング)
エラーハンドリング（error handling）とは、プログラムの実行中に発生するエラーを適切に処理するための技術である[1][2][3][4]。エラーハンドリングの重要性は、システムの安定性やユーザーエクスペリエンスの向上に寄与する点にある。
エラーハンドリングの歴史では、初期の手法から現代的な技術に至るまでの進化が見られ、プログラムの信頼性向上に貢献してきた[5][6][7][8]。エラーハンドリングにはコンパイル時、実行時、論理エラーの各種類が存在し、それぞれに適した手法が用いられる。
エラーハンドリングの方法としては、例外処理、戻り値の利用、イベントベースの手法、型システムを活用した手法が挙げられる[9][10][11][12]。さらに、ベストプラクティスとして、エラーロギングやリソース管理、カスタムエラーハンドリングが推奨されている。
各プログラミング言語においてもエラーハンドリングは異なったアプローチが取られており、FortranからSwiftまで、言語毎の特性に応じた手法が存在する[13][14][15][16]。デザインパターンとしては、try-catch構造やリトライパターン、フォールバックパターンが広く用いられている。
エラーハンドリングの実装例としては、各言語における具体的なコードや手法が示されており、今後の技術としては自動化や人工知能（英: Artificial Intelligence、AI）の活用が期待される[17][18][19][20]。
このページでは、エラーハンドリングの概要、歴史、種類、方法、ベストプラクティス、言語毎の比較、デザインパターン、実装例、進化について詳述する。
エラーハンドリングの概要
[編集]エラーハンドリングとは
[編集]エラーハンドリングとは、プログラムやシステムが実行中に発生する予期しないエラーや例外的な状況に対処するための技術である[1][2][3][4]。プログラムが意図通りに動作しない場合や、外部要因によって障害が発生した場合、エラーハンドリングはその影響を最小限に抑え、システムの安定性と信頼性を維持するための重要な役割を果たす。エラーハンドリングの方法は多岐に渡り、具体的には、例外処理、エラーメッセージの表示、ログ情報の記録、リソースの解放、再試行処理などが含まれる。
エラーハンドリングの目的は、ユーザーに対してエラーの発生を通知し、必要に応じて適切な対処を行うことにある[2][21][22][23]。また、システムがエラーから回復できる場合は、プログラムの正常な実行を再開するための処理を提供することも重要である。さらに、エラーハンドリングはデバッグやトラブルシューティングの際にも役立ち、エラーの発生場所や原因を特定するための手がかりを提供する。
エラーハンドリングの重要性
[編集]エラーハンドリングは、システムの安定性とユーザーエクスペリエンスに直結する非常に重要な技術である[24][25][26][27]。適切なエラーハンドリングが実装されていない場合、プログラムは予期しない動作を起こすことがあり、最悪の場合、システム全体がクラッシュする可能性がある。また、エラーハンドリングが不十分であると、エラー発生時にユーザーに対して適切なフィードバックが提供されず、ユーザーが困惑したり、信頼性の低いシステムと判断されるリスクがある。
エラーハンドリングの重要性は、特にミッションクリティカルなシステムや、リアルタイム処理が要求されるシステムにおいて顕著である[5][9][25][27]。これらのシステムでは、エラーが発生した際に迅速かつ確実に対処することが求められ、適切なエラーハンドリングによって、システムのダウンタイムを最小限に抑えることができる。
さらに、エラーハンドリングはソフトウェア開発の全工程において考慮されるべきであり、設計段階から実装、テストに至るまで一貫して適切な対応が求められる[3][11][28][29]。これにより、エラー発生時の影響を最小限に抑え、システム全体の信頼性を高めることができる。
エラーハンドリングの歴史
[編集]初期のエラーハンドリング手法
[編集]エラーハンドリングの概念は、コンピュータプログラミングの初期から存在していたが、その方法やアプローチは時代と共に進化してきた[5][6][7][30]。初期のコンピュータシステムでは、エラーハンドリングは非常に基本的なものであり、プログラムがエラーに遭遇すると、その場で停止するか、単純なエラーメッセージを出力するだけであった。このようなシステムでは、エラー処理がプログラム全体のフローに組み込まれておらず、エラー発生時にプログラムがクラッシュすることが一般的であった。
例えば、FortranやCOBOLなどの初期のプログラミング言語では、エラーハンドリングは非常に限定的で、エラーが発生した場合には、プログラマーが手動でエラーの状態をチェックし、それに応じた処理を記述する必要があった[5][6][30][31]。これらの初期の手法では、エラー処理がプログラムの主要なロジックに深く埋め込まれており、プログラムの可読性や保守性に課題があった。
また、初期のシステムではハードウェアの制約もあり、エラーハンドリングの複雑さや柔軟性が限られていた[5][6][7][30]。これにより、エラー処理の一貫性や効率性が欠如しており、大規模なシステムや複雑なプログラムにおいては、エラーハンドリングが非常に困難であった。
現代的なエラーハンドリング技術
[編集]現代のエラーハンドリング技術は、初期の手法と比較して大きく進化している[1][2][4][12]。特にオブジェクト指向プログラミングや例外処理機構の導入により、エラーハンドリングはより洗練され、柔軟性が高まった。現在では、エラーが発生した際に例外を投げ（スロー）、これを捕捉（キャッチ）するという標準的な方法が広く用いられている。この手法により、エラーハンドリングがプログラムの主要なロジックから分離され、可読性と保守性が向上した。
例外処理機構を備えたプログラミング言語としては、C++やPython、Javaなどが挙げられる[1][10][32][33]。これらの言語では、エラーが発生すると例外オブジェクトが生成され、適切な場所で捕捉（キャッチ）されるまでプログラムの実行が中断される。このアプローチにより、プログラム全体で一貫したエラーハンドリングが可能となり、エラー発生時の影響を最小限に抑えることができる。
また、現代のエラーハンドリング技術では、エラーの発生と処理をログ情報として記録することが一般的となっている[9][25][27][34]。これにより、後から発生したエラーを分析し、システムの改善やバグ修正に役立てることができる。さらに、分散システムやマイクロサービスアーキテクチャが普及する中で、各サービス間の通信エラーやネットワーク障害に対するエラーハンドリングも重要性を増している。
現代的なエラーハンドリングは、単なるエラー処理に留まらず、システム全体の信頼性向上やユーザーエクスペリエンスの向上に寄与する重要な技術として位置付けられている[5][24][25][27]。
現代では、開発者は複雑なシステムにおいても柔軟で効果的なエラーハンドリングを実現できるようになっている[5][25][27][34]。
エラーハンドリングの種類
[編集]コンパイル時のエラーハンドリング
[編集]コンパイル時のエラーハンドリングとは、プログラムが実行される前に、コンパイラがコードを解析して発見するエラーを処理することを指す[1][2][35][36]。これらのエラーには、構文エラー、型の不一致、未定義の変数や関数の参照などが含まれる。コンパイラはソースコードを解析し、問題があればエラーメッセージを生成してプログラマーに通知する。この段階でエラーを修正しなければ、プログラムは実行ファイルとして生成されず、実行が不可能となる。
コンパイル時のエラーハンドリングは、プログラムが意図した通りに動作するための第一段階であり、重大なバグが実行時に発生するのを未然に防ぐ役割を果たす[1][2][35][36]。コンパイル時にエラーを検出することで、プログラマーは早期に問題を修正でき、プログラムの安定性と信頼性を向上させることができる。例えば、C言語やJavaなどの静的型付け言語では、コンパイル時に厳密な型チェックが行われ、型の不一致や構文エラーが検出される。
実行時のエラーハンドリング
[編集]実行時のエラーハンドリングは、プログラムが実際に動作している間に発生するエラーを処理する技術である[1][2][10][37]。実行時エラーには、ゼロ除算、ファイルの存在しない場所へのアクセス、メモリ不足など、実行環境やユーザーの操作に依存する問題が含まれる。これらのエラーはプログラムの実行中に発生するため、プログラムはこれらの状況を適切に処理し、必要に応じて例外を投げる（スロー）ことでエラーに対処する。
現代の多くのプログラミング言語では、例外処理機構が導入されており、例外が発生するとプログラムのフローが中断され、例外を処理するためのコードブロックが実行される[1][2][10][38]。これにより、実行時エラーがプログラム全体に及ぼす影響を最小限に抑え、プログラムが異常終了することを防ぐことができる。例えば、Pythonでは、tryブロック内で発生した例外がexceptブロックで捕捉（キャッチ）され、適切なエラーメッセージの表示やリソースのクリーンアップが行われる。
論理エラーのハンドリング
[編集]論理エラーのハンドリングは、プログラムが期待通りに動作しない場合、すなわちプログラムの論理に問題がある場合にこれを検出し、修正するための技術である[2][4][22][39]。論理エラーは、プログラムが意図した通りの結果を生成しない、または誤った結果を生成する場合に発生する。例えば、計算結果が正しくない、期待した条件分岐が行われない、データ処理が正確に行われないなどが挙げられる。
論理エラーはコンパイル時や実行時には検出されないことが多く、通常、プログラムの動作テストや実行結果の確認を通じて発見される[2][22][28][40]。論理エラーを効果的にハンドリングするためには、デバッグやユニットテストが重要な役割を果たす。テスト駆動開発（英: Test-Driven Development、TDD）やペアプログラミングなどの開発手法は、論理エラーの早期発見と修正に有効である。
論理エラーは、プログラムが予期しない動作を引き起こす可能性があるため、これらのエラーを見逃すことなく検出し、修正することがシステムの信頼性を確保する上で重要である[2][4][9][22]。プログラムの設計段階から論理エラーを最小限に抑えるための対策を講じることが求められる。
エラーハンドリングの方法
[編集]例外処理（Exception Handling）
[編集]例外処理（英: Exception Handling）は、プログラムの実行中に発生するエラーや例外的な状況に対処するための一般的な手法である[1][2][10][38]。例外は、プログラムの通常のフローを中断し、エラーを処理するための特別な処理を実行することを可能にする。多くのプログラミング言語では、try、catch（またはexcept）、finallyといった構文が用意されており、これらを利用してエラー処理を行う。
例外処理の基本的な流れは次の通りである[1][2][10][38]。まず、tryブロック内でコードを実行し、エラーが発生した場合、そのエラーは例外として捕捉（キャッチ）される。次に、catchブロック（言語によってはexceptブロック）が実行され、例外に対する適切な処理が行われる。最後に、finallyブロックが実行され、リソースの解放など、必ず実行する必要のあるコードが記述される。finallyブロックは例外が発生しても必ず実行されるため、リソース管理において重要な役割を果たす。
例外処理を使用することで、プログラムのエラーに対して柔軟かつ安全に対処できる[1][2][10][38]。例えば、ネットワーク接続の失敗やファイルアクセスエラーなど、プログラムの実行環境に依存するエラーを適切に処理することができる。これにより、プログラムの安定性が向上し、ユーザーが予期しないクラッシュに直面することを回避することができる。
戻り値によるエラーハンドリング
[編集]戻り値によるエラーハンドリングは、関数やメソッドがエラーを示す特定の値を返すことで、エラー処理を行う方法である[2][4][38][41]。これは、古典的な手法であり、例外処理が導入される前から広く使用されていた。C言語[42]やGoなどの一部の言語では、例外処理よりも戻り値を利用したエラーハンドリングが推奨されることがある。
この方法では、関数が正常に実行された場合は期待される値を返し、エラーが発生した場合はエラーコードやnull、None、falseといったエラーを示す特別な値を返す[2][4][38][41]。関数の呼び出し側は、戻り値をチェックし、エラーが発生していないかを確認する。エラーが発生している場合は、適切なエラー処理を行う。
戻り値によるエラーハンドリングの利点は、エラー処理が関数のインターフェースの一部として明示的に扱われるため、コードがシンプルで直感的である点にある[2][4][38][41]。しかし、エラー処理が明示的に行われない場合、エラーを見逃す可能性があるというデメリットもある。適切に使用することで、パフォーマンスに優れたエラーハンドリングが可能となる。
イベントベースのエラーハンドリング
[編集]イベントベースのエラーハンドリングは、特にグラフィカルユーザーインターフェース（Graphical User Interface、GUI）アプリケーションやリアクティブプログラミングにおいて用いられる手法である[43][44][45][46]。この方法では、エラーがイベントとして扱われ、イベントリスナーやハンドラーがそのエラーを捕捉（キャッチ）して処理を行う。例えば、ユーザーが操作を行った際に発生するエラーを処理するために、特定のイベントに対するハンドラーを登録しておく。
JavaScriptやC#などのプログラミング言語では、イベント駆動型のアプローチが広く採用されており、エラーハンドリングもイベントの一種として扱われる[43][44][45][46]。これにより、プログラムが非同期で動作する際のエラー処理が容易になる。イベントベースのエラーハンドリングでは、エラーが発生した時点でイベントが発生し、登録されたリスナーが呼び出されるため、非同期処理のエラーに対しても即座に対応できる。
この手法の利点は、複雑な非同期処理においても、エラー処理がプログラムのフローに自然に統合される点にある[43][44][45][46]。一方で、イベント駆動の構造が複雑になると、エラーのトラッキングやデバッグが難しくなることもあるため、設計段階での注意が必要である。
型システムを利用したエラーハンドリング
[編集]型システムを利用したエラーハンドリングは、プログラムの型システムを活用してエラーを表現し、コンパイル時にエラー処理の不備を検出する手法である[12][13][16][47]。これは、静的型付け言語において特に強力であり、コンパイラがエラー処理が適切に行われているかを保証するための一助となる。
例えば、HaskellやRustといった言語では、Result型やEither型など、エラーを含む可能性のある値を表現する型が提供されている[12][13][16][47]。これらの型は、成功時の値とエラー時の値を組み合わせたものであり、プログラマーはこれらの型に対するパターンマッチングを用いてエラー処理を行う。これにより、エラー処理が抜け落ちることを防ぎ、より堅牢なプログラムを実現することができる。
型システムを利用したエラーハンドリングの最大の利点は、コンパイル時にエラー処理の欠如を検出できる点である[12][13][16][47]。これにより、実行時の不意のエラー発生を未然に防ぐことができ、システムの信頼性が向上する。また、型によるエラー処理は、プログラム全体で一貫したエラーハンドリングを実現するための強力なツールであり、特に安全性が重視されるシステムにおいて有用である。
エラーハンドリングのベストプラクティス
[編集]エラーロギングとトレース
[編集]エラーロギングとトレースは、エラーハンドリングにおいて不可欠な要素である[25][26][27][48]。エラーロギングとは、プログラムが実行中に発生したエラーの詳細をログファイルやデータベースに記録するプロセスを指す。これにより、エラーの発生状況、発生場所、発生時のシステム状態などを後から分析することが可能となり、問題の再現や修正に役立つ。また、トレースは、プログラムの実行フローを追跡するための手法であり、エラーが発生するまでの処理の流れを記録する。これにより、エラーの根本原因を特定しやすくなる。
エラーロギングを効果的に行うためには、ログメッセージに可能な限り詳細な情報を含めることが重要である[25][26][27][48]。例えば、エラーの発生日時、エラーが発生した関数やメソッドの名前、スタックトレース、ユーザーの入力データなどが考慮されるべきである。また、ログ情報の重要度に応じて、異なるレベル（例：エラー、警告、情報）で記録することが推奨される。
トレースに関しては、エラーが発生した際に、どのような手順でそのエラーに至ったかを詳細に記録することが求められる[25][26][27][48]。これにより、特定の条件下で発生するエラーを再現しやすくなり、修正が迅速に行えるようになる。エラーロギングとトレースは、特に複雑なシステムや分散システムにおいて、エラーハンドリングの信頼性を高めるための重要なツールである。
エラーハンドリングにおけるリソース管理
[編集]エラーハンドリングにおけるリソース管理は、システムの健全性と効率性を保つために極めて重要である[1][26][49][50]。プログラムがエラーを適切に処理できず、リソース（メモリ、ファイルハンドル、ネットワーク接続など）が解放されないままになると、メモリリークやデッドロック、ファイルの不整合などの問題が発生する可能性がある。これらを防ぐためには、エラーが発生した場合でも、確実にリソースが解放されるようにする必要がある。
多くのプログラミング言語では、finallyブロックやdeferステートメントなど、リソースのクリーンアップを保証する構文が提供されている[1][10][12][51]。例えば、Pythonではwithステートメントを使用することで、リソースの解放を自動的に行うことが可能である。また、Javaではtry-finally構文を使用して、エラーが発生しても必ずファイルを閉じたり、メモリを解放したりすることができる。
リソース管理を確実に行うためには、エラーハンドリングの設計段階からリソースのライフサイクルを考慮することが重要である[1][13][26][50]。各リソースがどの時点で割り当てられ、どの時点で解放されるべきかを明確にし、エラーが発生した際にもリソースが適切に管理されるようにコードを設計することで、システムの安定性を保つことができる。
カスタムエラーハンドリング
[編集]カスタムエラーハンドリングとは、システムやアプリケーションの特定の要件に応じて、独自のエラーハンドリングロジックを設計・実装することである[1][2][10][50]。標準のエラーハンドリング機構に加え、特定のドメインや業務ロジックに特化したエラーハンドリングを行うことで、より適切で意味のあるエラーメッセージや対処方法を提供することができる。
例えば、Webアプリケーションでは、ユーザーが入力したデータのバリデーションエラーに対して、ユーザーに対して分かりやすいエラーメッセージを返すことが求められる[1][2][9][34]。また、金融システムでは、トランザクションの整合性を保つために、特定のエラーが発生した際にはロールバックを行い、データの一貫性を確保するカスタムハンドリングが必要となる。
カスタムエラーハンドリングを設計する際には、エラーの種類を分類し、それぞれに適した処理を設けることが重要である[1][2][10][34]。また、カスタムエラーハンドリングは、他のシステムコンポーネントとの整合性を保つために、標準的なエラーハンドリング機構と併用されるべきである。これにより、エラー発生時の挙動を統一し、予期しない動作を防ぐことができる。
カスタムエラーハンドリングを導入することで、システムが特定の状況に適切に対応できるようになり、エラーが発生した際の影響を最小限に抑えることが可能となる[1][2][9][10]。さらに、ユーザーに対して直感的で有用なフィードバックを提供することで、システム全体のユーザーエクスペリエンスを向上させることができる。
言語毎のエラーハンドリングの比較
[編集]Fortranにおけるエラーハンドリング
[編集]Fortranは、科学技術計算のために設計された初期の高水準プログラミング言語であり、エラーハンドリングの機能は当初非常に限定的であった[52][53][54][55]。初期のFortranプログラムでは、エラーが発生するとプログラムがそのまま停止するか、異常な結果を出力することが一般的であった。エラーハンドリングは主にIFステートメントを用いて手動で行われ、エラー発生時にはユーザーがエラーコードをチェックする必要があった。
後のバージョンでは、ERR引数やI/OステートメントのIOSTATパラメータを使用することで、入出力エラーを検出し処理する方法が導入された[52][53][54][56]。これにより、ファイル処理や計算中に発生するエラーに対して、プログラムの実行を停止せずに特定の処理を行うことが可能になった。ただし、現代的なプログラミング言語に見られるような高度な例外処理機能は提供されていない。
Lispにおけるエラーハンドリング
[編集]Lispは、人工知能研究やリスト処理に特化したプログラミング言語であり、そのエラーハンドリング機構は非常に柔軟である[57][58][59][60]。Lispでは、エラーが発生すると、通常はREPL（Read-Eval-Print Loop）に戻り、エラーをインタラクティブに調査・修正することができる。これにより、プログラマーはエラー発生時にリアルタイムでデバッグを行い、必要に応じてコードを修正して再試行することが可能である。
さらに、Lispにはcatchとthrowによる制御フローがあり、これを用いてエラーハンドリングを実装することができる[57][58][59][60]。また、condition-caseやunwind-protectといった構造を使用して、例外処理やリソース管理を行うこともできる。これにより、エラーが発生してもシステムの安定性を保ちながら、柔軟なエラーハンドリングを実現することが可能である。
COBOLにおけるエラーハンドリング
[編集]COBOLは、ビジネス向けのデータ処理に特化したプログラミング言語であり、特にファイル処理や入出力操作におけるエラーハンドリングが重要である[61][62][63][64]。COBOLでは、FILE STATUSコードを使用してファイル処理中のエラーを検出し、それに応じて適切な処理を行う。各処理に対して、成功したかどうかやエラーが発生した場合の詳細なステータスを確認できる。
また、COBOLにはUSE AFTER EXCEPTIONやON SIZE ERRORなど、特定のエラー発生時に実行されるコードブロックを定義する機能がある[61][62][63][64]。これにより、エラーが発生した際に特定の処理を行うことができ、業務データの整合性を維持するためのエラーハンドリングが可能となる。
COBOLはまた、トランザクション処理におけるエラーハンドリングにも強力な機能を提供しており、データベース処理の途中で発生するエラーを適切に処理し、ロールバックなどの処理を行うことができる[61][62][63][64]。
ALGOL 60におけるエラーハンドリング
[編集]ALGOL 60は、現代の多くのプログラミング言語の基礎を築いた歴史的に重要な言語であるが、エラーハンドリングに関しては非常に基本的な機能しかもたなかった[6][65][66][67]。ALGOL 60では、エラーハンドリング機構は標準化されておらず、エラーが発生した際の対応はプログラムの実装に依存していた。エラー処理は主にIF文を使用して手動で行われ、プログラマーがエラーチェックを組み込む必要があった。
ALGOL 60の設計上、入出力や例外処理に関する標準的なライブラリは存在せず、特定のエラーに対する対応は非常に限られていた[6][65][66][67]。このため、エラーハンドリングは個々のプログラマーの裁量に委ねられており、大規模なプログラムにおいてはエラー処理の一貫性を保つことが困難であった。
Simulaにおけるエラーハンドリング
[編集]Simulaは、オブジェクト指向プログラミングの先駆けとされる言語であり、そのエラーハンドリング機構は当時としては先進的であった[65][68][69][70]。Simulaでは、オブジェクト指向の概念を活用して、エラー処理をカプセル化することができる。例えば、クラスを使用してエラーオブジェクトを定義し、それを使用してエラーの情報を伝播させることができる。
しかし、Simulaには現代的な意味での例外処理機構は存在せず、エラー処理は主に制御フローの操作や、オブジェクトの状態をチェックすることで行われた[65][68][69][70]。また、エラー発生時のリソース管理や後処理についても、プログラマーが手動で実装する必要があった。このため、Simulaにおけるエラーハンドリングは非常に柔軟であるが、同時に慎重な設計が求められた。
BASICにおけるエラーハンドリング
[編集]BASICは、教育用途や初学者向けに設計されたプログラミング言語であり、エラーハンドリング機能もシンプルで理解しやすいものが提供されている[71]。初期のBASICでは、エラーが発生するとプログラムは停止し、エラーメッセージが表示されるだけであった。このため、エラーハンドリングは非常に限定的であり、エラーに対する柔軟な対応は難しかった。
後のバージョンや派生言語では、ON ERROR GOTOステートメントが導入され、エラー発生時に特定のラベルにジャンプして処理を行うことが可能になった[71]。これにより、エラー発生後もプログラムの継続を試みたり、リソースを解放したりするための基本的なエラーハンドリングが実現された。しかし、このアプローチはスパゲッティコードを生みやすく、プログラムの可読性や保守性に問題をもたらすことがあった。
BASICのエラーハンドリングはシンプルであるため、初学者にとっては理解しやすいが、大規模なシステムや複雑なエラー処理を必要とするシステムには適していないとされる[71]。このため、BASICでのエラーハンドリングは、主に小規模なアプリケーションや教育目的のプログラムに限定されることが多い。
PL/Iにおけるエラーハンドリング
[編集]PL/I（Programming Language One）は、ビジネスと科学技術の両方の用途に対応するために設計された強力な言語であり、エラーハンドリング機能も非常に充実している[72]。PL/Iでは、プログラム内で発生する可能性のあるエラーの種類を事前に宣言し、エラーが発生した場合に実行されるコードブロックを定義することができる。この言語は、幅広いエラー条件をサポートし、特定のエラー毎に異なる処理を実行することが可能である。
PL/Iのエラーハンドリングの特徴の一つは、ONステートメントである[72]。これは、エラー条件に応じて特定の処理を実行するために使用される。例えば、ON ERROR、ON ENDFILE、ON OVERFLOWなどのステートメントを使用して、異なるエラーに対するハンドリングを定義できる。また、SIGNALステートメントを使用して、プログラム内で意図的に例外を発生させることも可能である。これにより、PL/Iは柔軟で高度なエラーハンドリング機構を提供している。
Logoにおけるエラーハンドリング
[編集]Logoは、教育目的で開発されたプログラミング言語であり、特に子供たちがプログラミングの概念を学ぶために使用される[73][74][75][76]。そのため、Logoのエラーハンドリング機能は非常にシンプルで、ユーザーにとって理解しやすいものとなっている。エラーが発生した際には、基本的にはエラーメッセージが表示されるか、プログラムが停止する。
Logoでは、エラーが発生する可能性のある処理に対して特別なハンドリングを設けることが難しいため、エラー処理はプログラムの設計段階で慎重に行う必要がある[73][74][75][76]。エラーメッセージが表示された後は、ユーザーが手動でプログラムの修正を行い、再実行することが一般的である。したがって、Logoにおけるエラーハンドリングは主に教育的な観点から、プログラムが予期しない動作をする際の原因を理解するためのツールとして機能している。
Pascalにおけるエラーハンドリング
[編集]Pascalは、教育および構造化プログラミングを支援するために設計された言語であり、エラーハンドリング機能は比較的シンプルであるが効果的である[77][78][79]。Pascalでは、エラーハンドリングに関して明示的な例外処理機構が標準では提供されておらず、代わりにIOResultやEOF（End of File）などの関数や変数を使用して、I/O処理中のエラーを検出する。
Pascalプログラムでエラーをハンドリングする一般的な方法は、関数や手続きの実行結果をチェックし、エラーが発生した場合には適切なエラーメッセージを表示するか、プログラムを安全に終了させることである[77][78][79]。また、後期のPascal派生言語（例：Delphi）では、try-except構文が導入され、例外処理がサポートされるようになった。この構文を使用することで、より洗練されたエラーハンドリングが可能となっている。
C言語におけるエラーハンドリング
[編集]C言語は、システムプログラミングや低レベルのメモリ管理を必要とするアプリケーションに広く使用されている言語であり、エラーハンドリングの手法は非常に手動かつ明示的である[80][81][82][83]。C言語には例外処理機構が組み込まれていないため、エラーハンドリングは主に関数の戻り値やグローバル変数（例：errno）を使用して行われる。
Cにおけるエラーハンドリングの典型的な方法は、関数がエラーを検出した際に、特定のエラーコード（例：-1やNULL）を返し、関数の呼び出し元がその戻り値をチェックしてエラー処理を行うことである[80][81][82][83]。また、errno変数は、ライブラリ関数の実行中に発生したエラーの詳細情報を格納するために使用される。この手法は非常に低レベルであり、開発者がエラーハンドリングを慎重に設計する必要があるが、その分柔軟性に富んでいる。
Prologにおけるエラーハンドリング
[編集]Prologは、論理プログラミング言語であり、エラーハンドリングの方法も他の言語とは異なる[84][85][86][87]。Prologでは、プログラムの実行はバックトラックによる推論に基づいており、失敗することがエラーと同義ではないため、エラーハンドリングは通常の制御フローの一部として扱われる。Prologにおいて、特定のエラーが発生した場合には、catch/3やthrow/1を使用して例外を処理することができる。
catch/3は、例外が発生する可能性のある目標を評価し、例外が発生した場合にその例外を捕捉（キャッチ）して特定の処理を行うために使用される[84][85][86][87]。一方、throw/1は、例外を明示的に発生させるために使用される。このように、Prologでは例外処理が言語の論理的な性質に統合されており、プログラムのロジックに沿った自然なエラーハンドリングが可能である。
MLにおけるエラーハンドリング
[編集]ML（Meta Language）は、関数型プログラミングをサポートする言語であり、エラーハンドリングの機構も関数型プログラミングに適した形で提供されている[88][89][90][91]。MLには、例外処理のための組み込み機能があり、raiseによって例外を発生させ、handle構文によってそれを捕捉（キャッチ）して処理することができる。
MLのエラーハンドリングは、型システムと組み合わせて使用されることが多く、特にoption型やresult型を用いたエラーハンドリングが一般的である[88][89][90][91]。これにより、関数が正常に値を返すか、エラーを返すかを型で表現できるため、コンパイル時にエラーハンドリングの不備を検出できる。MLにおけるエラーハンドリングは、関数型プログラミングの特性を活かし、プログラム全体の堅牢性を高める重要な要素となっている。
Schemeにおけるエラーハンドリング
[編集]Schemeは、Lispの方言であり、シンプルかつ強力なエラーハンドリング機能を備えている[57][92][93][94]。Schemeでは、condition-caseやwith-exception-handlerといった構文を用いて、エラーハンドリングを実装することができる。これらの構文は、例外が発生した際に実行されるコードブロックを指定するために使用される。
Schemeのエラーハンドリングは、その柔軟性と簡潔さが特徴であり、プログラマーはエラー処理のロジックを簡単に追加・変更することができる[57][92][93][94]。また、Schemeは継続（continuation）という高度な制御フロー機構をサポートしており、これを利用して複雑なエラーハンドリングを行うことも可能である。Schemeにおけるエラーハンドリングは、シンプルな構造と強力な機能を兼ね備えており、エラーハンドリングのカスタマイズが容易である。
Adaにおけるエラーハンドリング
[編集]Adaは、安全性と信頼性を重視したプログラミング言語であり、そのエラーハンドリング機構も非常に強力である[95][96][97][98]。Adaでは、例外処理が言語の中心的な機能として組み込まれており、プログラム内で予期しない状況が発生した際に適切に対処することが求められる。Adaの例外処理は、raiseステートメントで例外を発生させ、exceptionブロックでその例外を捕捉（キャッチ）して処理する。
Adaのエラーハンドリングは、プログラムの信頼性を高めるために設計されており、特にミッションクリティカルなシステムやリアルタイムシステムでの使用が推奨されている[95][96][97][98]。プログラム全体のエラー状態を厳密に管理することができ、例外が発生した際には、リソースの解放やロールバックといった後処理を確実に実行することが可能である。また、Adaではカスタム例外を定義することができるため、アプリケーションの特定のニーズに応じたエラーハンドリングが容易に行える。
Smalltalkにおけるエラーハンドリング
[編集]Smalltalkは、完全なオブジェクト指向プログラミング言語として設計されており、エラーハンドリングもオブジェクト指向の原則に基づいて実装されている[99][100][101][102]。Smalltalkでは、例外はオブジェクトとして扱われ、例外処理はメソッドを使用して行われる。Signalクラスを使用して例外を発生させ、その例外を捕捉（キャッチ）して処理するためにrescueメソッドやensureメソッドが用いられる。
Smalltalkのエラーハンドリングは、非常に柔軟であり、例外が発生した際に、プログラムの状態を保持しつつ適切な処理を行うことができる[99][100][101][102]。これにより、プログラムの実行を中断することなく、エラーに対処することが可能である。また、Smalltalkのインタラクティブな開発環境では、エラーが発生した時点でプログラムの実行を停止し、その場でデバッグを行うことができるため、迅速なエラー修正が可能となっている。
Objective-Cにおけるエラーハンドリング
[編集]Objective-Cは、C言語にオブジェクト指向機能を追加した言語であり、AppleのiOSやmacOSでの開発に広く使用されている[103][104][105][106]。Objective-Cのエラーハンドリング機構は、@try、@catch、@finallyブロックを使用した例外処理をサポートしているが、実際のエラーハンドリングでは、例外を使用するよりもエラーオブジェクトを返す方法が一般的である。
Objective-Cでは、エラーを表現するためにNSErrorオブジェクトが広く使用されており、メソッドの戻り値としてエラー情報を返すことで、メソッドの呼び出し元がエラーを検出して処理する仕組みが確立されている[103][104][105][106]。この方法は、例外処理がリソースを多く消費するため、パフォーマンスを重視するアプリケーションで推奨されている。また、NSErrorオブジェクトを使用することで、エラーの種類や発生場所、対応策などの詳細な情報を伝えることができるため、エラーハンドリングが一貫して行われる。
C++におけるエラーハンドリング
[編集]C++は、C言語にオブジェクト指向機能を追加した強力なプログラミング言語であり、エラーハンドリング機能として例外処理が組み込まれている[33][107][108][109]。C++では、tryブロックでエラーが発生する可能性のあるコードを実行し、throwステートメントで例外を発生（スロー）させ、catchブロックでその例外を捕捉（キャッチ）して処理する。これにより、プログラムのエラーハンドリングがコードの主要なロジックから分離され、可読性と保守性が向上する。
C++の例外処理は、特にリソース管理において重要である[33][107][108][109]。C++のデストラクタは、例外が発生した際に自動的に呼び出され、リソースの解放やクリーンアップを行うため、メモリリークやリソース不足を防ぐことができる。この機能をRAII（Resource Acquisition Is Initialization）として知られるパターンと組み合わせることで、C++プログラムにおけるリソース管理が安全かつ効果的に行われる。
ただし、C++の例外処理は他の言語に比べて複雑であり、過度な例外処理はパフォーマンスに影響を与える可能性があるため、慎重に使用する必要がある[33][107][108][109]。
Perlにおけるエラーハンドリング
[編集]Perlは、テキスト処理やシステム管理スクリプトで広く使われる言語であり、そのエラーハンドリング機構も非常に柔軟である[110][111][112][113]。Perlでは、evalブロックを使用して例外処理を行い、エラーが発生した場合には$@変数にエラーメッセージが格納される。これを利用して、エラーが発生した際の処理をカスタマイズすることができる。
Perlのエラーハンドリングは、シンプルでありながら強力で、特にスクリプトの中に簡単にエラー処理を組み込むことができる[110][111][112][113]。また、die関数を使用して、任意の時点でエラーメッセージを出力し、プログラムを終了させることが可能である。さらに、warn関数を使用して、プログラムの実行を継続しながらエラーメッセージを表示することもできる。
Perlでは、例外をオブジェクトとして扱うことが可能であり、オブジェクト指向のエラーハンドリングを行うためのモジュールも提供されている[110][111][112][113]。これにより、複雑なシステムでも柔軟で効果的なエラーハンドリングが実現できる。
Erlangにおけるエラーハンドリング
[編集]Erlangは、並行処理や分散システムの構築に特化したプログラミング言語であり、そのエラーハンドリングのアプローチは非常にユニークである[114][115][116][117]。Erlangのエラーハンドリングの基本的な考え方は「失敗を許容する」（Let it crash）という哲学に基づいており、プロセスが失敗した場合には、そのプロセスを終了させ、監視している別のプロセスがその失敗を検出して対処するという方式を取っている。
Erlangでは、プロセスが独立して動作しているため、一つのプロセスの失敗が他のプロセスに影響を与えることはない[114][115][116][117]。このため、プロセスがクラッシュしても、システム全体が健全な状態を保つことができる。また、Erlangにはtry-catch構文もあり、従来の例外処理と同様のエラーハンドリングも可能であるが、主に使用されるのはプロセス監視と再起動のメカニズムである。
この「失敗を許容する」アプローチは、Erlangを使用したシステムが非常に高い信頼性をもつことを可能にしており、特にミッションクリティカルなシステムや常時稼働が求められるシステムでその真価を発揮する[114][115][116][117]。
Haskellにおけるエラーハンドリング
[編集]Haskellは、関数型プログラミング言語であり、そのエラーハンドリングも関数型プログラミングのパラダイムに基づいている[16][118][119][120]。Haskellでは、エラーハンドリングを行う際に、Maybe型やEither型を使用して、エラーが発生する可能性のある処理の結果を明示的に表現することが一般的である。Maybe型は、値が存在する場合にはJust、存在しない場合にはNothingを返し、Either型は、成功時にはRight、エラー時にはLeftを返す。
Haskellでは例外処理もサポートされており、IOモナド内でthrowIOやcatchを使用して例外を扱うことができる[16][118][119][120]。しかし、Haskellの設計哲学に従い、例外は通常、限られた場面でのみ使用される。関数型プログラミングの特徴を活かして、エラーが発生しない純粋な関数としてプログラムを設計することが推奨される。これにより、エラーがシステム全体に伝播することを防ぎ、堅牢なプログラムを実現することができる。
Pythonにおけるエラーハンドリング
[編集]Pythonは、簡潔で読みやすいコードを書くことを目指したプログラミング言語であり、そのエラーハンドリング機能も非常に使いやすい[32][51][121][122]。Pythonでは、try、except、finallyブロックを使用して例外処理を行う。tryブロック内で発生した例外は、対応するexceptブロックで捕捉（キャッチ）され、finallyブロックは例外の有無にかかわらず必ず実行される。
Pythonの例外処理は、特定の例外タイプに基づいて異なる処理を行うことができるため、非常に柔軟である[32][51][121][122]。また、開発者は独自の例外クラスを定義して、特定のエラーに対してカスタムのエラーハンドリングを実装することができる。Pythonのエラーハンドリングは、プログラムの実行中に発生する様々なエラーに対して、シンプルで直感的な処理を提供する。
Visual Basicにおけるエラーハンドリング
[編集]Visual Basic（VB）は、ユーザーインターフェースやビジネスアプリケーションの開発に広く使用される言語であり、エラーハンドリングにはOn Errorステートメントが用いられる[123][124][125][126]。On Errorは、エラーが発生した場合の処理を指定するもので、エラーが発生した際に、指定されたエラーハンドラーに制御を移すことができる。例えば、On Error Resume Nextはエラーが発生しても次のステートメントを実行し続ける一方で、On Error GoToは指定したラベルにジャンプする。
Visual Basicのエラーハンドリングは、特定のエラーコードを取得して処理を行うことが多く、またErrオブジェクトを使用してエラー情報を取得することができる[123][124][125][126]。Visual Basicは、ユーザーインターフェースをもつアプリケーションで多用されるため、ユーザーにエラーメッセージを分かりやすく表示し、適切な対処を促すエラーハンドリングが重要である。
Luaにおけるエラーハンドリング
[編集]Luaは、組み込みスクリプト言語として設計され、軽量で柔軟なエラーハンドリング機能を提供する[127][128][129][130]。Luaのエラーハンドリングは、pcall（protected call）やxpcall（extended protected call）関数を使用して行われる。pcallは、指定された関数を実行し、その関数内で発生したエラーを捕捉（キャッチ）して、エラーが発生したかどうかをブール値で返す。xpcallは、エラーが発生した場合に指定されたエラーハンドラーを呼び出すことができる。
Luaは、軽量であることを重視しているため、エラーハンドリング機構もシンプルであるが、柔軟性が高く、複雑なエラーハンドリングも実現できる[127][128][129][130]。特に、ゲーム開発やリアルタイムシステムでの使用が多いため、エラーハンドリングのオーバーヘッドを最小限に抑えながら、信頼性の高いスクリプトを実行することが求められる。
Javaにおけるエラーハンドリング
[編集]Javaは、堅牢でスケーラブルなシステム開発に適した言語であり、エラーハンドリングには例外処理が広く使用される[1][50][131][132]。Javaでは、try、catch、finallyブロックを使用して例外を処理し、throwステートメントで例外を明示的に発生させることができる。また、Javaの例外処理は、チェックされる例外（checked exceptions）とチェックされない例外（unchecked exceptions）の区別があり、チェックされる例外はコンパイル時に必ず処理される必要がある。
Javaのエラーハンドリング機構は、特に大規模なエンタープライズアプリケーションにおいて強力であり、例外の種類毎に異なる処理を行うことができる[1][50][131][132]。また、Javaでは独自の例外クラスを作成し、アプリケーション固有のエラーハンドリングを実装することも容易である。これにより、堅牢で保守性の高いコードを実現することができる。
PHPにおけるエラーハンドリング
[編集]PHPは、サーバーサイドのWeb開発に広く使用されているスクリプト言語であり、エラーハンドリングにはエラーレベルを設定するerror_reporting関数や、エラーハンドラーを定義するset_error_handler関数が使用される[133][134][135][136]。また、PHP 5以降では例外処理もサポートされており、try、catch、finallyブロックを使用してエラーを処理することができる。
PHPでは、様々なエラータイプが定義されており、E_WARNING、E_NOTICE、E_ERRORなどのエラーレベルに応じて異なる処理が行われる[133][134][135][136]。set_error_handler関数を使用することで、カスタムエラーハンドラーを設定し、特定のエラーに対して独自の処理を実行することが可能である。
Webアプリケーションでは、ユーザーに対してフレンドリーなエラーメッセージを表示し、デバッグ情報を適切に管理することが求められるため、PHPのエラーハンドリングは特に重要である[133][134][135][136]。
JavaScriptにおけるエラーハンドリング
[編集]JavaScriptは、Webブラウザ上で動作するクライアントサイドのスクリプト言語であり、エラーハンドリングには例外処理が広く使用されている[43][137][138][139]。JavaScriptでは、try、catch、finallyブロックを使用して例外を処理し、throwステートメントで例外を発生（スロー）させることができる。また、Errorオブジェクトを利用して、エラーの詳細情報を扱うことが可能である。
JavaScriptのエラーハンドリングは、ブラウザ環境に依存する動作や、非同期処理（例：Promise、async/await）において重要な役割を果たす[43][137][138][139]。特に、非同期処理においては、エラーが発生した場合にcatchメソッドを使用して例外を捕捉し、適切なエラーメッセージをユーザーに表示することが一般的である。
さらに、window.onerrorやunhandledrejectionイベントを使用して、グローバルなエラーハンドリングを実装することもでき、未処理のエラーを一元管理することが可能である[43][137][138][139]。
Rubyにおけるエラーハンドリング
[編集]Rubyは、シンプルさと生産性を重視したオブジェクト指向スクリプト言語であり、エラーハンドリングの機能も使いやすく設計されている[140][141][142][143]。Rubyでは、例外処理を行うためにbegin-rescue-ensure構文が提供されており、エラーが発生した場合にその例外を捕捉（キャッチ）して処理を行うことができる。raiseメソッドを使用して、意図的に例外を発生（スロー）させることも可能である。
Rubyのエラーハンドリングは、非常に直感的であり、初学者でも簡単にエラー処理を組み込むことができる[140][141][142][143]。rescueステートメントを使用して、特定の例外クラスに対して異なる処理を行うことができ、複数の例外を分けて処理することも容易である。また、ensureステートメントを使用することで、例外が発生しても必ず実行される後処理を記述できるため、リソース管理が確実に行われる。
さらに、Rubyはretry機能も備えており、例外が発生した場合にもう一度ブロック内の処理を再試行することが可能である[140][141][142][143]。このように、Rubyは柔軟で強力なエラーハンドリング機能を提供しており、エラー処理がシンプルかつ効果的に行える。
R言語におけるエラーハンドリング
[編集]R言語は、統計解析やデータ分析のために設計されたプログラミング言語であり、エラーハンドリングの機能もデータ処理に特化している[144][145][146][147]。Rでは、tryCatch関数を使用して例外処理を行い、エラーが発生した場合に特定の処理を行うことができる。try関数を使用して、エラーが発生してもプログラムが停止せずに続行されるようにすることも可能である。
Rのエラーハンドリングは、特にデータ処理のパイプラインにおいて重要である[144][145][146][147]。例えば、大規模なデータセットを処理する際に、部分的なエラーが発生した場合でも、処理全体を停止させずにエラーハンドリングを行い、エラーの原因となるデータを特定して除外することができる。このように、Rのエラーハンドリング機能はデータ解析の信頼性を高めるために設計されている。
また、warnings関数を使用して、エラーメッセージだけでなく警告メッセージも捕捉（キャッチ）して処理することができる[144][145][146][147]。これにより、データの整合性を確保しながら、柔軟なエラーハンドリングが可能となっている。
D言語におけるエラーハンドリング
[編集]D言語は、C++に代わるモダンなシステムプログラミング言語として設計されており、例外処理のための強力な機能を提供している[148][149][150][151]。Dでは、try-catch-finally構文を使用して、エラーハンドリングを行うことができる。throwステートメントを使用して、例外を意図的に発生（スロー）させることも可能である。
Dのエラーハンドリングは、C++と同様に、RAII（Resource Acquisition Is Initialization）と組み合わせて使用することで、リソース管理が確実に行われるよう設計されている[148][149][150][151]。またDは、標準ライブラリ内で様々なカスタム例外を提供しており、これを利用することで、より詳細で文脈に即したエラーハンドリングが可能である。
さらに、Dでは関数契約（Design by Contract）をサポートしており、invariant、precondition、postconditionを定義することで、エラーが発生した際に契約違反を検出し、その処理を行うことができる[148][149][150][151]。これにより、プログラムの健全性を保ちながら、予測可能なエラーハンドリングを実現する。
C#におけるエラーハンドリング
[編集]C#は、Microsoftが開発したオブジェクト指向プログラミング言語であり、例外処理機能はその重要な部分である[152][153][154][155]。C#では、catch-finally構文を使用してエラーハンドリングを行う。throwステートメントを使用して、例外を意図的に発生（スロー）させることができる。C#の例外では、System.Exceptionクラスを基底クラスとして扱い、標準ライブラリには多くの派生クラスが用意されている。
C#のエラーハンドリングは、非常に直感的で、特定の種類の例外に対して異なるcatchブロックを使用することが可能である[152][153][154][155]。これにより、各例外に応じた適切なエラーハンドリングを実装することができる。また、finallyブロックを使用することで、例外が発生しても確実に実行される後処理を記述できるため、リソースの確実な解放が保証される。
C#には、非同期プログラミングのためのasync/await構文があり、非同期処理においても例外処理が適切に行えるよう設計されている[152][153][154][155]。これにより、複雑な非同期処理においてもエラーハンドリングがシンプルかつ効果的に行える。
Groovyにおけるエラーハンドリング
[編集]Groovyは、Javaプラットフォーム上で動作する動的言語であり、Javaと同様の例外処理機能を提供している[156][157][158][159]。Groovyでは、catch-finally構文を使用してエラーハンドリングを行うことができ、throwステートメントを使用して例外を発生（スロー）させることが可能である。Groovyの例外処理は、Javaの例外処理モデルを基礎としており、Throwableクラスを継承したクラスを使用して例外を処理する。
Groovyのエラーハンドリングは、Javaよりも簡潔に記述できる点が特徴であり、オプションとしてwith構文を使用して、リソース管理を自動化することも可能である[156][157][158][159]。さらに、Groovyは動的言語であるため、例外処理においても柔軟に動的なメソッド呼び出しや型チェックを行うことができる。
Groovyのスクリプト言語としての性質により、スクリプトの実行中に発生するエラーをインタラクティブに処理しやすく、迅速なデバッグとエラーハンドリングが可能である[156][157][158][159]。
Scalaにおけるエラーハンドリング
[編集]Scalaは、関数型とオブジェクト指向の両方のパラダイムを統合した言語であり、エラーハンドリングの方法もこれに対応している[160][161][162][163]。Scalaでは、従来のcatch-finally構文を使用して例外処理を行うこともできるが、関数型プログラミングの特性を活かして、Option、Either、Tryなどのモナドを使用したエラーハンドリングが広く使用されている。
Optionは、値が存在するかどうかを表現し、Noneはエラーや無効な状態を示すのに使用される[160][161][162][163]。Tryは、成功（Success）または失敗（Failure）のいずれかの状態をもち、エラーハンドリングを型安全に行うことができる。これにより、例外が発生する可能性のある処理を型で表現し、エラー処理を一貫して行うことができる。
Scalaのエラーハンドリングは、関数型プログラミングの特性と組み合わせることで、プログラムの安全性と堅牢性を高めることができ、特に複雑なシステムにおいてその効果が発揮される[160][161][162][163]。
F#におけるエラーハンドリング
[編集]F#は、関数型プログラミングを強力にサポートする言語であり、エラーハンドリングも関数型のパラダイムに基づいている[164][165][166][167]。F#では、例外処理のためにtry-with-finally構文を提供しており、エラーが発生した際に特定の処理を行うことができる。また、F#では、関数型プログラミングの特性を活かしたエラーハンドリングの手法として、Result型やOption型を使用する。
Result型は、Ok（成功）とError（失敗）の二つの状態をもち、これを使用してエラーハンドリングを明示的かつ型安全に行うことができる[164][165][166][167]。Option型は、値が存在するかどうかを示し、エラーハンドリングに役立てることができる。
また、F#では、パターンマッチングを使用して、エラーの種類に応じた処理を簡潔に記述することができる[164][165][166][167]。このように、F#のエラーハンドリングは、関数型プログラミングの特性と緊密に結びついており、堅牢で安全なプログラムの構築を支援する。
Clojureにおけるエラーハンドリング
[編集]Clojureは、Java仮想マシン（英: Java Virtual Machine、JVM）上で動作する関数型プログラミング言語であり、Lispの方言として設計されている[168][169][170][171]。Clojureでは、エラーハンドリングのためにcatch-finally構文が提供されており、例外処理はJavaのモデルに基づいている。また、Clojureではthrowステートメントを使用して、意図的に例外を発生（スロー）させることができる。
Clojureのエラーハンドリングは、関数型のアプローチを活かして、エラーをデータとして扱うことも可能である[168][169][170][171]。例えば、エラー状態をマップ（辞書）として表現し、それを関数チェーンの中で処理することで、関数型プログラミングのスタイルを維持しつつ、柔軟なエラーハンドリングが行える。
また、Clojureでは、with-open構文を使用してリソース管理を自動化することができ、リソースリークを防ぐためのエラーハンドリングが容易になる[168][169][170][171]。このように、Clojureのエラーハンドリングは、関数型プログラミングの特性を活かしながら、堅牢なシステムを構築するための重要な要素となっている。
Goにおけるエラーハンドリング
[編集]Go（Golang）は、シンプルさと効率性を重視したプログラミング言語であり、そのエラーハンドリングも特徴的である[41][172][173][174]。Goでは、例外処理ではなく、関数の戻り値としてエラーを返すスタイルが採用されている。Goの標準ライブラリのほとんどの関数は、エラーが発生した場合、error型の値を返し、関数の呼び出し元でそのエラーをチェックすることが求められる。
Goにおけるエラーハンドリングの基本的なパターンは、関数が複数の値を返し、そのうちの一つがエラーを示す値である[41][172][173][174]。呼び出し元は、このエラー値をチェックし、適切な処理を行う。if err != nil { ... }というパターンが一般的であり、この手法により、エラー処理がコードの主要なフローに組み込まれる。
さらに、Goにはpanicとrecoverという仕組みがあり、深刻なエラーに対してプログラムのパニック状態を起こし、リカバリー処理でこれを捕捉（キャッチ）して復旧させることが可能である[41][172][173][174]。ただし、これらは特定のケースに限定して使用され、通常のエラーハンドリングには使用されない。
Rustにおけるエラーハンドリング
[編集]Rustは、安全性とパフォーマンスを重視したシステムプログラミング言語であり、エラーハンドリングもこれに基づいて設計されている[13][175][176][177]。Rustでは、例外処理の代わりにResult型とOption型が用いられ、これを使用してエラーハンドリングを行う。Result型は、成功時にはOk、失敗時にはErrをもつ二値型であり、関数がエラーを返すことを明示的に表現できる。
Rustのエラーハンドリングは、パターンマッチングを使用してResult型を扱うのが一般的であり、エラーが発生した場合には、そのエラーを捕捉（キャッチ）して適切な処理を行う[13][175][176][177]。また、?演算子を使用することで、エラーチェックを簡潔に記述することができる。この演算子は、エラーが発生した場合に即座に呼び出し元にエラーを伝播させる。
さらに、Rustではpanic!マクロを使用して、回復不可能なエラーが発生した場合にプログラムを中断することができる[13][175][176][177]。ただし、Rustの設計思想ではpanic!の使用は避け、できるだけResult型を使用した安全なエラーハンドリングを行うことが推奨されている。
Elixirにおけるエラーハンドリング
[編集]Elixirは、Erlang仮想マシン（英: Bogdan/Björn's Erlang Abstract Machine、BEAM）上で動作する関数型プログラミング言語であり、高い並行性と耐障害性をもつシステムを構築するために設計されている[178][179][180][181]。Elixirにおけるエラーハンドリングは、Erlangの「失敗を許容する」哲学を継承しており、プロセスがクラッシュした場合には別のプロセスがその失敗を監視し、適切に対処するというモデルを採用している。
Elixirでは、try-rescue構文を使用して例外処理を行うことができるが、通常のエラーハンドリングは関数の戻り値として{:ok, value}または{:error, reason}といったタプルを返す形で行われることが多い[178][179][180][181]。関数の呼び出し元は、このタプルをパターンマッチングで処理し、エラーが発生した場合にはその理由をチェックして対処する。
また、Elixirでは、Erlangと同様にthrow、catch、exitを使用した例外処理もサポートされているが、これらは特定のケースに限って使用されることが多い[178][179][180][181]。Elixirのエラーハンドリングは、堅牢で分散型のシステムを構築するために、軽量なプロセスと監視機構を活用する点で独特である。
Ceylonにおけるエラーハンドリング
[編集]Ceylonは、Javaと同様の仮想マシン上で動作するモダンなプログラミング言語であり、エラーハンドリングには例外処理が採用されている。Ceylonでは、catch-finally構文を使用して、エラーが発生した際の処理を行うことができる。Ceylonの例外処理モデルは、Javaに非常に似ており、例外がオブジェクトとして扱われる。[要出典]
Ceylonでは、例外クラスは全てThrowableクラスから派生しており、ユーザーがカスタム例外を定義することも可能である。例外が発生すると、catchブロックでその例外を捕捉（キャッチ）し、エラー処理を行う。finallyブロックは、例外の有無にかかわらず必ず実行されるため、リソースのクリーンアップなどに使用される。[要出典]
また、Ceylonでは、関数型プログラミングの要素も取り入れられており、エラー処理を関数型スタイルで行うことも可能である。これにより、コードの再利用性が高まり、エラーハンドリングがより柔軟に行えるようになっている。[要出典]
Kotlinにおけるエラーハンドリング
[編集]Kotlinは、Javaとの互換性を保ちながら、モダンな機能を備えたプログラミング言語であり、エラーハンドリングには例外処理が採用されている[182][183][184][185]。Kotlinでは、catch-finally構文を使用したエラーハンドリングを行うことができ、例外はThrowableクラスから派生したオブジェクトとして扱われる。
Kotlinの特徴の一つは、Javaと異なり、チェック例外が存在しないことである[182][183][185][186]。これにより、コードが簡潔になり、必要に応じて例外処理を自由に設計できる。さらに、Kotlinではnull安全を保証する機能があり、nullによる例外を未然に防ぐことができる。
また、Kotlinは、関数型プログラミングの特性をもつため、Result型やラムダ式を使用して、より表現力豊かなエラーハンドリングが可能である[182][183][185][186]。これにより、エラーハンドリングを関数型スタイルで簡潔に記述し、プログラムの安全性と保守性を高めることができる。
Dartにおけるエラーハンドリング
[編集]Dartは、Googleが開発した、主にWebアプリケーションのフロントエンド開発に使用されるプログラミング言語であり、エラーハンドリングには例外処理が採用されている[187][188][189][190]。Dartでは、catch-finally構文を使用してエラーハンドリングを行うことができ、例外はExceptionやErrorクラスのオブジェクトとして扱われる。
Dartの例外処理は非常にシンプルであり、特定の例外に対して異なるcatchブロックを使用することで、エラーハンドリングを細かく制御することができる[187][188][189][190]。また、Dartにはrethrow機能が備わっており、捕捉（キャッチ）した例外を再度投げる（スロー）ことで、上位の呼び出し元に処理を委ねることが可能である。
Dartは、特に非同期プログラミングをサポートしており、FutureやStreamといった非同期処理に対してもエラーハンドリングを行うことができる[187][188][189][190]。これにより、Webアプリケーションのような複雑な非同期環境でも、効果的にエラー処理を行うことが可能である。
TypeScriptにおけるエラーハンドリング
[編集]TypeScriptは、JavaScriptに静的型付けを加えた言語であり、エラーハンドリングにはJavaScriptと同様に例外処理が使用される[191][192][193][194]。TypeScriptでは、catch-finally構文を使用してエラーを処理することができ、throwステートメントを使用して例外を発生（スロー）させることが可能である。
TypeScriptのエラーハンドリングはJavaScriptに基づいているため、特にWebブラウザやNode.js環境でのエラー処理に適している[191][192][193][194]。TypeScriptの型システムにより、例外処理を型安全に行うことができ、コードの信頼性が向上する。
また、TypeScriptは非同期処理を強力にサポートしており、Promiseやasync/await構文を使用して、非同期処理に対しても直感的なエラーハンドリングを行うことができる[191][192][193][194]。これにより、複雑なWebアプリケーションやサーバーサイドアプリケーションにおいても、エラー処理を効果的に行える。
Swiftにおけるエラーハンドリング
[編集]Swiftは、Appleが開発したプログラミング言語であり、iOSやmacOSのアプリケーション開発に広く使用されている[15][195][196][197]。Swiftでは、do-try-catch構文を使用してエラーハンドリングを行う。throwステートメントを使用して例外を発生（スロー）させることができ、エラーはErrorプロトコルに準拠した型として表現される。
Swiftのエラーハンドリングは、非常に安全であり、エラーが発生する可能性のあるコードにはtryキーワードを明示的に使用しなければならない[15][195][197][198]。この設計により、エラーが無視されることを防ぎ、コードの安全性が向上する。また、Swiftではtry?やtry!といった構文を使用して、エラー処理を柔軟に行うことができる。
さらに、SwiftにはResult型が導入されており、これを使用して関数の戻り値で成功または失敗を明示的に表現することができる[15][195][197][198]。これにより、関数型スタイルのエラーハンドリングも可能となり、コードの可読性と保守性が向上する。また、Swiftは非同期処理のためのasync/await構文をサポートしており、非同期処理に対しても効果的なエラーハンドリングが可能である。
エラーハンドリングとデザインパターン
[編集]エラーハンドリングは、ソフトウェア設計において重要な要素であり、適切なパターンを適用することで、エラーが発生した際のシステムの信頼性と安定性を向上させることができる。以下に、エラーハンドリングに関連する主要なデザインパターンについて詳述する。
try-catch構造のデザインパターン
[編集]try-catch構造は、エラーハンドリングの基本的なパターンであり、エラーが発生する可能性のあるコードをtryブロック内で実行し、発生した例外をcatchブロックで処理する[1][109][131][175]。これにより、プログラムのフローがエラーによって中断されることなく、適切に処理を続けることができる。
このパターンの利点は、例外が発生した際に特定の処理を行うことで、プログラムの健全性を維持できる点にある[1][12][107][131]。例えば、ファイル処理中にファイルが見つからない場合、catchブロックでエラーメッセージを表示し、代替のファイルを使用するなどの処理が可能である。また、finallyブロックを併用することで、リソースの解放やログ情報の記録など、例外の有無にかかわらず必ず実行する必要がある処理を明確にすることができる。
try-catch構造は、シンプルで理解しやすいため、広く採用されている[1][109][131][175]。ただし、乱用するとコードが複雑になりやすく、可読性が低下する可能性があるため、適切な抽象化と設計が求められる。
マルチキャッチブロックの活用
[編集]マルチキャッチブロックは、複数の異なる例外を一つのcatchブロックで処理するパターンである[1][50][131][199]。これにより、同様の処理が必要な異なる種類の例外を一元的に扱うことができ、コードの冗長性を減らし、可読性を向上させることができる。
このパターンは、例えば、ネットワーク接続やファイル処理に関連する異なるエラー（タイムアウト、接続失敗、ファイル読み込みエラーなど）に対して、同じリカバリー処理を適用する場合に有効である[1][50][131][199]。catchブロック内で複数の例外クラスを指定することで、共通の処理を行うことができる。
マルチキャッチブロックの利点は、コードの整理ができる点にあるが、一方で、特定の例外に対して異なる処理を行いたい場合には、適切に分岐を行う設計が必要となる[1][50][131][199]。また、全ての例外を一つのブロックで処理することは避け、例外の性質に応じた適切な処理を考慮することが重要である。
リトライパターン
[編集]リトライパターンは、エラーが発生した際に再試行を行うことで一時的な問題を解決し、処理を成功させることを目的としたパターンである[2][9][25][34]。このパターンは、ネットワーク接続や外部サービスとの通信など、一時的な障害が原因でエラーが発生する場合に特に有効である。
リトライパターンでは、エラーが発生した際に一定の回数だけ再試行を行うロジックを組み込む[2][9][25][34]。再試行の間隔を段階的に増やす「指数バックオフ」などのテクニックを用いることで、過度な再試行による負荷を軽減することができる。また、再試行の限度を設け、最終的に失敗した場合には適切なエラーハンドリングを行う必要がある。
このパターンの実装には、再試行のタイミングや回数、条件を慎重に設定することが求められる[9][25][34][200]。リトライパターンは、特に不安定な外部システムやネットワーク環境で信頼性を高めるために有効であるが、無制限の再試行は避け、システム全体のパフォーマンスやユーザーエクスペリエンスを考慮することが重要である。
失敗の許容とフォールバックパターン
[編集]失敗の許容とフォールバックパターンは、エラーが発生した際にシステム全体の停止を避け、可能な限りサービスを提供し続けることを目的としたパターンである[9][25][34][200]。これは、特に分散システムやマイクロサービスアーキテクチャにおいて、部分的な障害が発生してもシステム全体の可用性を維持するために重要である。
このパターンでは、エラーが発生した際に、代替手段やデフォルト値を使用して処理を続行する[9][25][34][200]。例えば、キャッシュされたデータを利用する、代替のサービスにリクエストを送る、または機能を限定して稼働を続けるといった方法が考えられる。これにより、エラーが発生してもユーザーに対する影響を最小限に抑えることができる。
フォールバックパターンは、特にユーザーエクスペリエンスを重視するアプリケーションや、ミッションクリティカルなシステムにおいて有用である[9][25][34][200]。このパターンの成功には、システムの設計段階から失敗のシナリオを考慮し、適切なフォールバック戦略を組み込むことが不可欠である。
これらのデザインパターンを適切に活用することで、エラーハンドリングが効果的に行われ、システム全体の信頼性と可用性が大幅に向上する。
エラーハンドリングの実装例
[編集]Fortranにおけるエラーハンドリングの実装例
[編集]Fortranでは、ファイルのI/O処理中にエラーが発生することがあり、これに対処するためにIOSTAT変数を使用することが一般的である。以下に、ファイルを開く際のエラーハンドリングの実装例を示す。
PROGRAM HandleError
INTEGER :: IOSTAT, UNIT
UNIT = 10
OPEN(UNIT, FILE='non_existent_file.txt', STATUS='OLD', IOSTAT=IOSTAT)
IF (IOSTAT /= 0) THEN
PRINT *, 'Error opening file. IOSTAT = ', IOSTAT
ELSE
PRINT *, 'File opened successfully.'
END IF
CLOSE(UNIT)
END PROGRAM HandleError
このプログラムでは、IOSTAT変数を使用してファイルを開く際のエラーをチェックし、エラーが発生した場合にエラーメッセージを表示するようにしている。
Lispにおけるエラーハンドリングの実装例
[編集]Lispでは、例外的な状況に対処するためにcondition-case構文を使用する。以下のコード例では、ゼロ除算が発生した場合にエラーメッセージを表示する方法を示している。
(defun divide (x y)
(condition-case nil
(/ x y)
(arith-error (format t "Error: Division by zero."))))
(divide 10 0)
この例では、ゼロ除算が発生した際にarith-errorが捕捉（キャッチ）され、エラーメッセージが表示される。
COBOLにおけるエラーハンドリングの実装例
[編集]COBOLでは、ファイル処理中のエラーを処理するためにFILE STATUSコードを使用する。以下に、ファイルを開く際のエラーハンドリングの実装例を示す。
IDENTIFICATION DIVISION.
PROGRAM-ID. HandleError.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT FILE-IN ASSIGN TO "non_existent_file.txt"
ORGANIZATION IS LINE SEQUENTIAL.
DATA DIVISION.
FILE SECTION.
FD FILE-IN.
01 FILE-IN-RECORD PIC X(100).
WORKING-STORAGE SECTION.
01 FILE-STATUS-CODE PIC XX.
PROCEDURE DIVISION.
OPEN INPUT FILE-IN
IF FILE-STATUS-CODE NOT = "00"
DISPLAY "Error opening file. Status: " FILE-STATUS-CODE
ELSE
DISPLAY "File opened successfully."
END-IF.
CLOSE FILE-IN.
STOP RUN.
このプログラムでは、ファイルを開く際のエラー時に、FILE STATUSコードを使用してエラーメッセージを表示するようにしている。
ALGOL 60におけるエラーハンドリングの実装例
[編集]ALGOL 60では、エラーハンドリングのための標準的な機能がないため、手動でエラーチェックを行う必要がある。以下の例では、ゼロ除算を回避するためのエラーハンドリングを示している。
begin
real procedure divide(x, y);
value x, y;
real x, y;
begin
if y = 0 then
begin
outstring("Error: Division by zero.");
divide := 0
end
else
divide := x / y
end;
real result;
result := divide(10, 0);
endこのコードでは、yがゼロの場合にエラーを検出し、メッセージを表示するようにしている。
Simulaにおけるエラーハンドリングの実装例
[編集]Simulaは、オブジェクト指向の要素をもつ言語であり、エラーハンドリングにクラスを利用することができる。以下の例では、カスタムエラーハンドラーを使用したエラーハンドリングを示している。
begin
class ErrorHandler;
begin
procedure handleError(message); text message;
begin
outtext("Error: ");
outtext(message);
outimage;
end;
end;
ref(ErrorHandler) handler;
handler :- new ErrorHandler;
integer procedure divide(x, y); integer x, y;
begin
if y = 0 then
handler.handleError("Division by zero.")
else
divide := x / y
end;
integer result;
result := divide(10, 0);
end;このプログラムでは、ErrorHandlerクラスを使用して、エラーメッセージを処理している。
BASICにおけるエラーハンドリングの実装例
[編集]BASICでは、ON ERROR GOTOを使用してエラーハンドリングを行うことができる。以下の例では、ファイルを開く際にエラーが発生した場合の処理を示している。
10 ON ERROR GOTO ErrorHandler
20 OPEN "non_existent_file.txt" FOR INPUT AS #1
30 PRINT "File opened successfully."
40 CLOSE #1
50 END
ErrorHandler:
60 PRINT "Error: Unable to open file."
70 RESUME NEXT
このコードでは、ファイルを開く際にエラーが発生すると、ErrorHandlerラベルにジャンプし、エラーメッセージを表示する。
PL/Iにおけるエラーハンドリングの実装例
[編集]PL/Iでは、ONステートメントを使用してエラーハンドリングを行うことができる。以下のコード例では、ゼロ除算が発生した場合のエラーハンドリングを示している。
DECLARE X FIXED DECIMAL(5, 0);
DECLARE Y FIXED DECIMAL(5, 0);
DECLARE Z FIXED DECIMAL(5, 0);
ON ERROR BEGIN;
PUT SKIP LIST('Error: Division by zero.');
STOP;
END;
X = 10;
Y = 0;
Z = X / Y;
PUT SKIP LIST('Result: ', Z);
END;このコードでは、ゼロ除算が発生した場合にON ERRORブロックが実行され、エラーメッセージを表示する。
Logoにおけるエラーハンドリングの実装例
[編集]Logoは教育用プログラミング言語であり、エラーハンドリングは非常に基本的なものに限られている。以下の例では、ゼロ除算に対する単純なエラーチェックを行っている。
TO DIVIDE :X :Y
IF :Y = 0 [PRINT [Error: Division by zero.] STOP]
PRINT :X / :Y
END
DIVIDE 10 0このコードでは、Yがゼロの場合にエラーメッセージを表示し、処理を停止する。
Pascalにおけるエラーハンドリングの実装例
[編集]Pascalでは、I/O処理のエラーハンドリングにIOResultを使用することができる。以下のコード例では、ファイルを開く際にエラーが発生した場合の処理を示している。
program HandleError;
var
F: TextFile;
ErrorCode: Integer;
begin
AssignFile(F, 'non_existent_file.txt');
{$I-}
Reset(F);
ErrorCode := IOResult;
{$I+}
if ErrorCode <> 0 then
Writeln('Error opening file. Error code: ', ErrorCode)
else
Writeln('File opened successfully.');
CloseFile(F);
end.
このプログラムでは、IOResultを使用してファイルを開く際のエラーをチェックし、エラーメッセージを表示する。
C言語におけるエラーハンドリングの実装例
[編集]C言語では、エラーハンドリングに関数の戻り値やerrnoを使用する。以下のコード例では、ファイルを開く際にエラーが発生した場合の処理を示している。
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main() {
FILE *file = fopen("non_existent_file.txt", "r");
if (file == NULL) {
printf("Error opening file: %s\n", strerror(errno));
return 1;
}
printf("File opened successfully.\n");
fclose(file);
return 0;
}
このコードでは、ファイルを開く際にエラーが発生した場合に、errnoを使用してエラーメッセージを表示する。
Prologにおけるエラーハンドリングの実装例
[編集]Prologでは、catch/3とthrow/1を使用してエラーハンドリングを行うことができる。以下の例では、ゼロ除算が発生した場合のエラーハンドリングを示している。
divide(X, Y, Result) :-
( Y =:= 0 ->
throw(division_by_zero)
; Result is X / Y
).
safe_divide(X, Y, Result) :-
catch(divide(X, Y, Result), division_by_zero,
writeln('Error: Division by zero.')).
?- safe_divide(10, 0, Result).
このコードでは、ゼロ除算が発生した場合にthrowで例外を発生（スロー）させ、catchでそれを捕捉（キャッチ）してエラーメッセージを表示する。
MLにおけるエラーハンドリングの実装例
[編集]ML（特にStandard ML）では、例外を使用してエラーハンドリングを行うことができる。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
exception Division_by_zero
fun divide(x, y) =
if y = 0 then raise Division_by_zero
else x div y
val result =
(fn () => divide(10, 0))
handle Division_by_zero => print("Error: Division by zero.\n")
このコードでは、yがゼロの場合にDivision_by_zero例外を発生（スロー）させ、それを捕捉（キャッチ）してエラーメッセージを表示する。
Schemeにおけるエラーハンドリングの実装例
[編集]Schemeでは、condition-caseやwith-exception-handlerを使用してエラーハンドリングを行うことができる。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
(define (divide x y)
(with-exception-handler
(lambda (ex)
(display "Error: Division by zero.\n"))
(lambda ()
(if (= y 0)
(raise 'division-by-zero)
(/ x y)))))
(divide 10 0)
このコードでは、ゼロ除算が発生した場合にwith-exception-handlerを使用して例外を捕捉（キャッチ）し、エラーメッセージを表示する。
Adaにおけるエラーハンドリングの実装例
[編集]Adaでは、例外処理が言語の一部として統合されており、exceptionブロックを使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算が発生した場合の処理を示している。
procedure HandleError is
X, Y, Z : Integer;
begin
X := 10;
Y := 0;
Z := X / Y;
Put_Line("Result: " & Integer'Image(Z));
exception
when Constraint_Error =>
Put_Line("Error: Division by zero.");
end HandleError;
このプログラムでは、Constraint_Errorを捕捉（キャッチ）して、ゼロ除算が発生した際にエラーメッセージを表示する。
Smalltalkにおけるエラーハンドリングの実装例
[編集]Smalltalkでは、例外はオブジェクトとして扱われ、rescue:メッセージを送ることで例外を処理することができる。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
[ 10 / 0 ]
on: ZeroDivide
do: [ :ex | Transcript show: 'Error: Division by zero.'; cr ].
このコードでは、ZeroDivide例外が発生した際に、その例外を捕捉（キャッチ）してエラーメッセージを表示する。
Objective-Cにおけるエラーハンドリングの実装例
[編集]Objective-Cでは、@try-@catch-@finally構文を使用して例外処理を行う。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
@try {
int x = 10;
int y = 0;
int result = x / y;
NSLog(@"Result: %d", result);
}
@catch (NSException *exception) {
NSLog(@"Error: %@", exception.reason);
}
@finally {
NSLog(@"This will always be executed.");
}
このコードでは、ゼロ除算が発生した場合に例外を発生（スロー）させ、それを@catchブロックで処理する。
C++におけるエラーハンドリングの実装例
[編集]C++では、try-catch-throw構文を使用して例外処理を行う。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
#include <iostream>
#include <exception>
int main() {
try {
int x = 10;
int y = 0;
if (y == 0)
throw std::runtime_error("Division by zero.");
int result = x / y;
std::cout << "Result: " << result << std::endl;
} catch (const std::exception &e) {
std::cout << "Error: " << e.what() << std::endl;
}
return 0;
}
このプログラムでは、ゼロ除算が発生した場合にstd::runtime_error例外を発生（スロー）させ、catchブロックで処理する。
Perlにおけるエラーハンドリングの実装例
[編集]Perlでは、evalと$@を使用して例外処理を行う。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
eval {
my $x = 10;
my $y = 0;
my $result = $x / $y;
};
if ($@) {
print "Error: Division by zero.\n";
}
このコードでは、evalブロック内でエラーが発生すると、$@にエラーメッセージが格納され、それをチェックしてエラーメッセージを表示する。
Erlangにおけるエラーハンドリングの実装例
[編集]Erlangでは、try-catch構文を使用して例外処理を行う。また、Erlangの設計哲学として、プロセスが失敗することを許容し、その失敗を監視するというアプローチが取られる。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
try
Result = 10 div 0
catch
error:badarith -> io:format("Error: Division by zero.~n")
end.
このコードでは、ゼロ除算が発生した場合にbadarithエラーが捕捉（キャッチ）され、エラーメッセージが表示される。
Haskellにおけるエラーハンドリングの実装例
[編集]Haskellでは、MaybeやEither型を使用してエラーハンドリングを行うことが一般的である。以下のコード例では、Maybe型を使用したエラーハンドリングを示している。
safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide x y = Just (x `div` y)
main = do
let result = safeDivide 10 0
case result of
Nothing -> putStrLn "Error: Division by zero."
Just value -> putStrLn ("Result: " ++ show value)
このコードでは、safeDivide関数がゼロ除算を検出し、Nothingを返すことでエラーを表現している。
Pythonにおけるエラーハンドリングの実装例
[編集]Pythonでは、try-except-finally構文を使用して例外処理を行う。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
try:
x = 10
y = 0
result = x / y
except ZeroDivisionError:
print("Error: Division by zero.")
finally:
print("This will always be executed.")
このコードでは、ゼロ除算が発生するとZeroDivisionErrorが捕捉（キャッチ）され、エラーメッセージが表示される。また、finallyブロック内の処理は例外の有無にかかわらず実行される。
Visual Basicにおけるエラーハンドリングの実装例
[編集]Visual Basicでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算が発生した場合の処理を示している。
Sub HandleError()
Dim x As Integer = 10
Dim y As Integer = 0
Dim result As Integer
Try
result = x / y
Console.WriteLine("Result: " & result)
Catch ex As DivideByZeroException
Console.WriteLine("Error: Division by zero.")
Finally
Console.WriteLine("This will always be executed.")
End Try
End Sub
このコードでは、ゼロ除算が発生した場合にDivideByZeroExceptionが捕捉（キャッチ）され、エラーメッセージが表示される。
Luaにおけるエラーハンドリングの実装例
[編集]Luaでは、pcall（protected call）を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算が発生した場合の処理を示している。
function divide(x, y)
return x / y
end
local status, result = pcall(divide, 10, 0)
if status then
print("Result: " .. result)
else
print("Error: Division by zero.")
end
このコードでは、pcallを使用してゼロ除算が発生した際のエラーメッセージを表示している。
Javaにおけるエラーハンドリングの実装例
[編集]Javaでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
public class HandleError {
public static void main(String[] args) {
int x = 10;
int y = 0;
try {
int result = x / y;
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Error: Division by zero.");
} finally {
System.out.println("This will always be executed.");
}
}
}
このコードでは、ゼロ除算が発生した場合にArithmeticExceptionが捕捉（キャッチ）され、エラーメッセージが表示される。
PHPにおけるエラーハンドリングの実装例
[編集]PHPでは、catch-finally構文を使用して例外処理を行うことができる。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
<?php
function divide($x, $y) {
if ($y == 0) {
throw new Exception("Division by zero.");
}
return $x / $y;
}
try {
$result = divide(10, 0);
echo "Result: $result";
} catch (Exception $e) {
echo "Error: " . $e->getMessage();
} finally {
echo "\nThis will always be executed.";
}
?>
このコードでは、ゼロ除算が発生した場合にExceptionを発生（スロー）させ、捕捉（キャッチ）することでエラーメッセージを表示する。
JavaScriptにおけるエラーハンドリングの実装例
[編集]JavaScriptでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
try {
let x = 10;
let y = 0;
let result = x / y;
console.log("Result: " + result);
} catch (e) {
console.error("Error: Division by zero.");
} finally {
console.log("This will always be executed.");
}
このコードでは、ゼロ除算が発生した場合にエラーメッセージが表示される。
Rubyにおけるエラーハンドリングの実装例
[編集]Rubyでは、begin-rescue-ensure構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
begin
x = 10
y = 0
result = x / y
puts "Result: #{result}"
rescue ZeroDivisionError
puts "Error: Division by zero."
ensure
puts "This will always be executed."
end
このコードでは、ゼロ除算が発生した際にZeroDivisionErrorが捕捉（キャッチ）され、エラーメッセージが表示される。
R言語におけるエラーハンドリングの実装例
[編集]R言語では、tryCatchを使用してエラーハンドリングを行うことができる。以下のコード例では、ゼロ除算に対するエラーハンドリングを示している。
divide <- function(x, y) {
if (y == 0) stop("Division by zero.")
return(x / y)
}
result <- tryCatch({
divide(10, 0)
}, error = function(e) {
message("Error: ", e$message)
})
print(result)
このコードでは、tryCatchを使用してゼロ除算が発生した場合のエラーメッセージを表示している。
D言語におけるエラーハンドリングの実装例
[編集]D言語では、catch-finally構文を使用してエラーハンドリングを行うことができる。以下のコード例では、ゼロ除算に対する処理を示している。
import std.stdio;
import std.exception;
void main() {
try {
int x = 10;
int y = 0;
enforce(y != 0, "Division by zero.");
int result = x / y;
writeln("Result: ", result);
} catch (Exception e) {
writeln("Error: ", e.msg);
} finally {
writeln("This will always be executed.");
}
}
このコードでは、enforce関数を使用してゼロ除算が発生した場合に例外を発生（スロー）させ、catchブロックで捕捉（キャッチ）することでエラーメッセージを表示する。
C#におけるエラーハンドリングの実装例
[編集]C#では、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
using System;
class Program {
static void Main() {
int x = 10;
int y = 0;
try {
int result = x / y;
Console.WriteLine("Result: " + result);
} catch (DivideByZeroException) {
Console.WriteLine("Error: Division by zero.");
} finally {
Console.WriteLine("This will always be executed.");
}
}
}
このコードでは、DivideByZeroExceptionが発生した場合にエラーメッセージが表示される。
Groovyにおけるエラーハンドリングの実装例
[編集]Groovyでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
try {
int x = 10
int y = 0
int result = x / y
println "Result: $result"
} catch (ArithmeticException e) {
println "Error: Division by zero."
} finally {
println "This will always be executed."
}
このコードでは、ArithmeticExceptionが発生した場合にエラーメッセージが表示される。
Scalaにおけるエラーハンドリングの実装例
[編集]Scalaでは、catch-finally構文を使用してエラーハンドリングを行うことができる。以下のコード例では、ゼロ除算に対する処理を示している。
object HandleError {
def main(args: Array[String]): Unit = {
val x = 10
val y = 0
try {
val result = x / y
println("Result: " + result)
} catch {
case e: ArithmeticException =>
println("Error: Division by zero.")
} finally {
println("This will always be executed.")
}
}
}
このコードでは、ArithmeticExceptionが発生した場合にエラーメッセージが表示される。
F#におけるエラーハンドリングの実装例
[編集]F#では、try-with-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
let divide x y =
try
let result = x / y
printfn "Result: %d" result
with
| :? System.DivideByZeroException ->
printfn "Error: Division by zero."
finally
printfn "This will always be executed."
divide 10 0
このコードでは、System.DivideByZeroExceptionが発生した場合にエラーメッセージが表示される。
Clojureにおけるエラーハンドリングの実装例
[編集]Clojureでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
(defn divide [x y]
(try
(let [result (/ x y)]
(println "Result:" result))
(catch ArithmeticException e
(println "Error: Division by zero."))
(finally
(println "This will always be executed."))))
(divide 10 0)
このコードでは、ArithmeticExceptionが発生した場合にエラーメッセージが表示される。
Goにおけるエラーハンドリングの実装例
[編集]Go（Golang）では、関数の戻り値としてエラーを返す方式を採用している。以下のコード例では、ゼロ除算に対する処理を示している。
package main
import (
"errors"
"fmt"
)
func divide(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}
このコードでは、関数の戻り値としてエラーを返し、ゼロ除算が発生した場合のエラーメッセージを表示する。
Rustにおけるエラーハンドリングの実装例
[編集]Rustでは、Result型とOption型を使用してエラーハンドリングを行うことが一般的である。以下のコード例では、Result型を用いたゼロ除算の処理を示している。
fn divide(x: i32, y: i32) -> Result<i32, String> {
if y == 0 {
Err(String::from("Division by zero"))
} else {
Ok(x / y)
}
}
fn main() {
match divide(10, 0) {
Ok(result) => println!("Result: {}", result),
Err(e) => println!("Error: {}", e),
}
}
このコードでは、ゼロ除算が発生した場合にErrが返され、match式でエラーメッセージが表示される。
Elixirにおけるエラーハンドリングの実装例
[編集]Elixirでは、try-rescue構文を使用して例外処理を行うが、一般的にはタプルを使用したエラーハンドリングが主流である。以下のコード例では、ゼロ除算に対する処理を示している。
defmodule ErrorHandling do
def divide(x, 0), do: {:error, "Division by zero"}
def divide(x, y), do: {:ok, x / y}
end
case ErrorHandling.divide(10, 0) do
{:ok, result} -> IO.puts("Result: #{result}")
{:error, message} -> IO.puts("Error: #{message}")
end
このコードでは、{:ok, result}または{:error, message}の形で結果を返し、case文で処理を分岐させている。
Ceylonにおけるエラーハンドリングの実装例
[編集]Ceylonでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
void divide(Integer x, Integer y) {
try {
Integer result = x/y;
print("Result: ``result``");
} catch (Exception e) {
print("Error: ``e.message``");
} finally {
print("This will always be executed.");
}
}
divide(10, 0);
このコードでは、ゼロ除算が発生した場合に例外を発生（スロー）させ、catchブロックで捕捉（キャッチ）することでエラーメッセージを表示する。
Kotlinにおけるエラーハンドリングの実装例
[編集]Kotlinでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
fun divide(x: Int, y: Int): Int {
return try {
x / y
} catch (e: ArithmeticException) {
println("Error: Division by zero.")
0
} finally {
println("This will always be executed.")
}
}
fun main() {
val result = divide(10, 0)
println("Result: $result")
}
このコードでは、ArithmeticExceptionが発生した場合にエラーメッセージが表示される。
Dartにおけるエラーハンドリングの実装例
[編集]Dartでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
void main() {
try {
int x = 10;
int y = 0;
int result = x ~/ y;
print("Result: $result");
} catch (e) {
print("Error: Division by zero.");
} finally {
print("This will always be executed.");
}
}
このコードでは、~/演算子を使用したゼロ除算が発生すると例外が捕捉（キャッチ）され、エラーメッセージが表示される。
TypeScriptにおけるエラーハンドリングの実装例
[編集]TypeScriptでは、catch-finally構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
function divide(x: number, y: number): number {
try {
if (y === 0) {
throw new Error("Division by zero.");
}
return x / y;
} catch (e) {
console.error(e.message);
return 0;
} finally {
console.log("This will always be executed.");
}
}
const result = divide(10, 0);
console.log("Result:", result);
このコードでは、ゼロ除算が発生した場合にErrorを発生（スロー）させ、catchブロックで捕捉（キャッチ）することでエラーメッセージを表示する。
Swiftにおけるエラーハンドリングの実装例
[編集]Swiftでは、do-try-catch構文を使用してエラーハンドリングを行う。以下のコード例では、ゼロ除算に対する処理を示している。
enum DivisionError: Error {
case divisionByZero
}
func divide(_ x: Int, by y: Int) throws -> Int {
if y == 0 {
throw DivisionError.divisionByZero
}
return x / y
}
do {
let result = try divide(10, by: 0)
print("Result: \(result)")
} catch DivisionError.divisionByZero {
print("Error: Division by zero.")
} finally {
print("This will always be executed.")
}
このコードでは、DivisionError.divisionByZero例外が発生（スロー）した場合、catchブロックで捕捉（キャッチ）することでエラーメッセージが表示される。
エラーハンドリングの進化
[編集]自動化されたエラーハンドリング
[編集]現在、多くのシステムではエラーが発生した際、手動での介入が必要となることが多いが、将来的にはエラーの検出から解決までを自動化する技術が進化すると考えられる[9][25][34][200]。この自動化には、エラーの種類や発生原因を迅速に特定し、適切な対処法を実行するシステムが含まれる。
自動化されたエラーハンドリングでは、エラーが発生した際に事前に設定されたルールやシナリオに基づき、システムが自動的にエラーを処理する[9][25][34][200]。例えば、データベースの接続が失敗した場合、システムが自動的に再試行を行い、それでも解決できない場合はバックアップサーバーに接続するなどの対応が考えられる。また、エラーの傾向を分析し、将来発生する可能性のある問題を予測して事前に対処することも可能となることが考えられる。
このような自動化されたエラーハンドリングは、システムのダウンタイムを大幅に減少させ、運用コストを削減する効果が期待される[9][25][34][200]。しかし、全てのエラーを自動で解決することは難しく、人間の介入が必要な場面も残ることから、自動化システムの設計には慎重な考慮が求められると考えられる。
エラーハンドリングにおける人工知能の役割
[編集]人工知能（英: Artificial Intelligence、AI）は、エラーハンドリングの分野においても重要な役割を果たすようになると考えられる[201][202][203][204]。AIの活用により、エラーの検出、分類、解決策の提案がより高度かつ迅速に行われるようになると考えられる。既に、ChatGPTに代表される生成AIの活用例も存在する[205][206][207]。
AIを用いたエラーハンドリングでは、機械学習モデルが過去のエラーデータを学習し、類似のエラーが発生した際に最適な解決策を提案することが可能となる[19][20][201][208]。これにより、従来のルールベースのシステムよりも柔軟で効果的なエラーハンドリングが実現できる。また、自然言語処理（英: Natural Language Processing、NLP）を活用して、エラーメッセージやログ情報を解析し、エラーの原因を特定することも可能である。
さらに、AIはシステム全体のパフォーマンスを監視し、異常が発生する前に予兆を検知することで、事前にエラーを回避する役割を果たすことも考えられる[20][201][203][204]。これにより、システムの信頼性と安定性が向上し、エラーによる影響を最小限に抑えることができる。
ただし、AIをエラーハンドリングに導入する際には、倫理的な問題やプライバシーの保護にも注意を払う必要がある[201][203][204][209]。AIが自動的に判断を下す場面では、その判断の透明性や公平性を確保することが求められる。エラーハンドリングにおけるAIの役割は今後重要性を増すが、その導入には慎重な設計と運用が必要である。
出典
[編集]- ^ a b c d e f g h i j k l m n o p q r s t u v w x y z Bloch, Joshua『Effective Java』丸善出版、2018年10月。ISBN 978-4-621-30325-2。
- ^ a b c d e f g h i j k l m n o p q r s t u v w Thomas, David; Hunt, Andrew (2019-07-30) (英語). The Pragmatic Programmer: Your journey to mastery, 20th Anniversary Edition. Addison-Wesley Professional. ISBN 978-0-13-595691-5
- ^ a b c Martin, Robert C. (2017-09-09) (英語). Clean Architecture: A Craftsman's Guide to Software Structure and Design. Pearson Technology Group. ISBN 978-0-13-449433-3
- ^ a b c d e f g h Martin, Robert C. (2008-08-01) (英語). Clean Code: A Handbook of Agile Software Craftsmanship. Pearson Education. ISBN 978-0-13-608325-2
- ^ a b c d e f g Adkins, Heather; Beyer, Betsy; Blankinship, Paul; Lewandowski, Piotr; Oprea, Ana; Stubblefield, Adam (2020-03-16) (英語). Building Secure and Reliable Systems: Best Practices for Designing, Implementing, and Maintaining Systems. "O'Reilly Media, Inc.". ISBN 978-1-4920-8309-2
- ^ a b c d e f Knuth, Donald Ervin (1972) (英語). The Art of Computer Programming. Volume 1/Fundamental Algorithms. Addison-Wesley
- ^ a b c Cachin, Christian; Guerraoui, Rachid; Rodrigues, Luís (2011-02-11) (英語). Introduction to Reliable and Secure Distributed Programming. Springer Science & Business Media. ISBN 978-3-642-15260-3
- ^ Sipser, Michael (2012) (英語). Introduction to the Theory of Computation. Cengage Learning. ISBN 978-1-133-18781-3
- ^ a b c d e f g h i j k l m n o Kleppmann, Martin (2017-03-16) (英語). Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems. "O'Reilly Media, Inc.". ISBN 978-1-4919-0311-7
- ^ a b c d e f g h i j k Beazley, David; Jones, Brian K. (2013-05-10) (英語). Python Cookbook: Recipes for Mastering Python 3. "O'Reilly Media, Inc.". ISBN 978-1-4493-5735-1
- ^ a b Winters, Titus; Manshreck, Tom; Wright, Hyrum (2020-02-28) (英語). Software Engineering at Google: Lessons Learned from Programming Over Time. "O'Reilly Media, Inc.". ISBN 978-1-4920-8274-3
- ^ a b c d e f g Odersky, Martin; Spoon, Lex; Venners, Bill (2008) (英語). Programming in Scala. Artima Inc. ISBN 978-0-9815316-0-1
- ^ a b c d e f g h Klabnik, Steve; Nichols, Carol (2019-09-03) (英語). The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0045-7
- ^ Thomas, David『プログラミング Elixir』Kabushiki Kaisha Ōmusha、2016年。ISBN 978-4-274-80296-6。
- ^ a b c d Mathias, Matthew; Gallagher, John (2016-11-23) (英語). Swift Programming: The Big Nerd Ranch Guide. Pearson Technology Group. ISBN 978-0-13-461069-6
- ^ a b c d e f Hutton, Graham (2016-09) (英語). Programming in Haskell. Cambridge University Press. ISBN 978-1-316-62622-1
- ^ Russell, Stuart; Norvig, Peter (2021-04-15) (英語). Artificial Intelligence: A Modern Approach, Global Edition. Pearson Higher Ed. ISBN 978-1-292-40117-1
- ^ Goodfellow, Ian; Bengio, Yoshua; Courville, Aaron (2016-11-18) (英語). Deep Learning. MIT Press. ISBN 978-0-262-03561-3
- ^ a b Chollet, Francois (2017-11-30) (英語). Deep Learning with Python. Simon and Schuster. ISBN 978-1-63835-204-4
- ^ a b c Géron, Aurélien (2019-09-05) (英語). Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems. "O'Reilly Media, Inc.". ISBN 978-1-4920-3261-8
- ^ Spinellis, Diomidis (2016-06-29) (英語). Effective Debugging: 66 Specific Ways to Debug Software and Systems. Addison-Wesley Professional. ISBN 978-0-13-439488-6
- ^ a b c d McConnell, Steve (2004-06-09) (英語). Code Complete: A Practical Handbook of Software Construction. Pearson Education. ISBN 978-0-7356-3697-2
- ^ Russinovich, Mark E.; Margosis, Aaron (2016-10-10) (英語). Troubleshooting with the Windows Sysinternals Tools. Microsoft Press. ISBN 978-0-13-398651-8
- ^ a b Majors, Charity; Fong-Jones, Liz; Miranda, George (2022) (英語). Observability Engineering: Achieving Production Excellence. O'Reilly Media, Incorporated. ISBN 978-1-4920-7644-5
- ^ a b c d e f g h i j k l m n o p q Beyer, Betsy; Jones, Chris; Petoff, Jennifer; Murphy, Niall Richard (2016-03-23) (英語). Site Reliability Engineering: How Google Runs Production Systems. "O'Reilly Media, Inc.". ISBN 978-1-4919-5118-7
- ^ a b c d e f Nygard, Michael T. (2018-01-08) (英語). Release It!: Design and Deploy Production-Ready Software. Pragmatic Bookshelf. ISBN 978-1-68050-452-1
- ^ a b c d e f g h Beyer, Betsy; Murphy, Niall Richard; Rensin, David K.; Kawahara, Kent; Thorne, Stephen (2018-07-25) (英語). The Site Reliability Workbook: Practical Ways to Implement SRE. "O'Reilly Media, Inc.". ISBN 978-1-4920-2945-8
- ^ a b Humble, Jez; Farley, David (2010-07-27) (英語). Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation. Pearson Education. ISBN 978-0-321-67022-9
- ^ Kim, Gene; Humble, Jez; Debois, Patrick; Willis, John (2016-10-06) (英語). The DevOps Handbook: How to Create World-Class Agility, Reliability, and Security in Technology Organizations. IT Revolution. ISBN 978-1-942788-07-2
- ^ a b c Jr, Frederick P. Brooks (1995-08-02) (英語). The Mythical Man-Month: Essays on Software Engineering, Anniversary Edition. Pearson Education. ISBN 978-0-13-211916-0
- ^ Fowler, Martin (2018-11-20) (英語). Refactoring: Improving the Design of Existing Code. Addison-Wesley Professional. ISBN 978-0-13-475770-4
- ^ a b c Lutz, Mark (2013-06-12) (英語). Learning Python: Powerful Object-Oriented Programming. "O'Reilly Media, Inc.". ISBN 978-1-4493-5569-2
- ^ a b c d Meyers, Scott (2005-05-12) (英語). Effective C++: 55 Specific Ways to Improve Your Programs and Designs. Pearson Education. ISBN 978-0-13-270206-5
- ^ a b c d e f g h i j k l m Newman, Sam (2021-07-24) (英語). Building Microservices: Designing Fine-Grained Systems. "O'Reilly Media, Inc.". ISBN 978-1-4920-3399-8
- ^ a b Aho, Alfred V. (2007) (英語). Compilers: Principles, Techniques, and Tools. Pearson/Addison Wesley. ISBN 978-0-321-48681-3
- ^ a b Parr, Terence (2013-01-15) (英語). The Definitive ANTLR 4 Reference. Pragmatic Bookshelf. ISBN 978-1-68050-500-9
- ^ Scott, Michael (2015-11-30) (英語). Programming Language Pragmatics. Elsevier. ISBN 978-0-12-410477-8
- ^ a b c d e f g Slatkin, Brett (2019-10-25) (英語). Effective Python: 90 Specific Ways to Write Better Python. Addison-Wesley Professional. ISBN 978-0-13-485459-5
- ^ Beck, Kent (2005) (英語). Extreme Programming Explained: Embrace Change. Addison-Wesley
- ^ Beck, Kent (2002) (英語). Test-Driven Development. Pearson India. ISBN 978-81-317-4083-5
- ^ a b c d e f Donovan, Alan A. A.; Kernighan, Brian W. (2015-11-16) (英語). The Go Programming Language. Addison-Wesley Professional. ISBN 978-0-13-419056-3
- ^ Stephen G. Kochan (2013) (英語). Programming in C. Addison-Wesley
- ^ a b c d e f Haverbeke, Marijn (2018-12-04) (英語). Eloquent JavaScript, 3rd Edition: A Modern Introduction to Programming. No Starch Press. ISBN 978-1-59327-951-6
- ^ a b c Griffiths, Ian (2019-11-26) (英語). Programming C# 8.0: Build Cloud, Web, and Desktop Applications. "O'Reilly Media, Inc.". ISBN 978-1-4920-5678-2
- ^ a b c Troelsen, Andrew; Japikse, Philip (2017-11-21) (英語). Pro C# 7: With .NET and .NET Core. Apress. ISBN 978-1-4842-3018-3
- ^ a b c Nurkiewicz, Tomasz; Christensen, Ben (2016-10-06) (英語). Reactive Programming with RxJava: Creating Asynchronous, Event-Based Applications. "O'Reilly Media, Inc.". ISBN 978-1-4919-3160-8
- ^ a b c Allen, Christopher; Moronuki, Julie (2016-07) (英語). Haskell Programming from First Principles. Lorepub LLC. ISBN 978-1-945388-03-3
- ^ a b c Sridharan, Cindy (2018) (英語). Distributed Systems Observability: A Guide to Building Robust Systems. O'Reilly Media. ISBN 978-1-4920-3342-4
- ^ Arpaci-Dusseau, Remzi H.; Arpaci-Dusseau, Andrea C. (2018) (英語). Operating Systems: Three Easy Pieces. Arpaci-Dusseau Books, LLC. ISBN 978-1-9850-8659-3
- ^ a b c d e f g h Goetz, Brian (2006) (英語). Java Concurrency in Practice. Addison-Wesley. ISBN 978-0-321-34960-6
- ^ a b c Ramalho, Luciano (2015-07-30) (英語). Fluent Python: Clear, Concise, and Effective Programming. "O'Reilly Media, Inc.". ISBN 978-1-4919-4626-8
- ^ a b Press, William H. (2007-09-06) (英語). Numerical Recipes 3rd Edition: The Art of Scientific Computing. Cambridge University Press. ISBN 978-0-521-88068-8
- ^ a b Metcalf, Michael; Reid, John Ker; Cohen, Malcolm (2004) (英語). Fortran 95/2003 Explained. Oxford University Press. ISBN 978-0-19-852692-6
- ^ a b chivers, ian; Sleightholme, Jane (2012-02-10) (英語). Introduction to Programming with Fortran: With Coverage of Fortran 90, 95, 2003, 2008 and 77. Springer London. ISBN 978-0-85729-232-2
- ^ Metcalf, Michael; Reid, John; Cohen, Malcolm (2011-03-24) (英語). Modern Fortran Explained. Oxford University Press. ISBN 978-0-19-960141-7
- ^ Metcalf, Michael; Reid, John; Cohen, Malcolm; Bader, Reinhold (2024-02-16) (英語). Modern Fortran Explained: Incorporating Fortran 2023. Oxford University Press. ISBN 978-0-19-887659-5
- ^ a b c d Abelson, Harold (1996) (英語). Structure and Interpretation of Computer Programs. MIT Press. ISBN 978-0-262-01153-2
- ^ a b Seibel, Peter (2006-11-01) (英語). Practical Common Lisp. Springer. ISBN 978-1-4302-0017-8
- ^ a b Weitz, Edmund (2015-12-31) (英語). Common Lisp Recipes: A Problem-Solution Approach. Apress. ISBN 978-1-4842-1177-9
- ^ a b Barski, Conrad (2010-10-15) (英語). Land of Lisp: Learn to Program in Lisp, One Game at a Time!. No Starch Press. ISBN 978-1-59327-281-4
- ^ a b c Coughlan, Michael (2014-04-04) (英語). Beginning COBOL for Programmers. Apress. ISBN 978-1-4302-6254-1
- ^ a b c Stern, Nancy B.; Stern, Robert A.; Ley, James P. (2002-10-08) (英語). COBOL for the 21st Century. Wiley. ISBN 978-0-471-07321-5
- ^ a b c Murach, Mike; Prince, Anne; Menendez, Raul (2004) (英語). Murach's Mainframe COBOL. Mike Murach & Associates, Incorporated. ISBN 978-1-890774-24-0
- ^ a b c Stern, Nancy (2004-04) (英語). Structured COBOL Programming. John Wiley & Sons Australia, Limited. ISBN 978-0-471-69058-0
- ^ a b c d Bergin, Thomas J.; Gibson, Richard G. (1996) (英語). History of Programming Languages II. ACM Press. ISBN 978-0-201-89502-5
- ^ a b Dijkstra, Edsger W. (1976) (英語). A Discipline of Programming. Prentice-Hall. ISBN 978-0-13-215871-8
- ^ a b Wexelblat, Richard L. (1981) (英語). History of Programming Languages. Academic Press. ISBN 978-0-12-745040-7
- ^ a b Sebesta, Robert W. (2014) (英語). Concepts of Programming Languages. Dorling Kindersley (India) Pvt. Limited ; [U.S.]. ISBN 978-93-325-1887-2
- ^ a b Scott, Michael (2005-11-21) (英語). Programming Language Pragmatics. Elsevier. ISBN 978-0-08-051516-8
- ^ a b Louden, Kenneth C. (2011) (英語). Programming Languages: Principles and Practice. South-Western. ISBN 978-1-4737-0280-6
- ^ a b c Coan, James S. (1978) (英語). Basic BASIC: An Introduction to Computer Programming in BASIC Language. Hayden Book Company. ISBN 978-0-9618346-0-9
- ^ a b Hughes, Joan K. (1990) (英語). PL/I Structured Programming. Ju Lin
- ^ a b Papert, Seymour (1980-12-04) (英語). Mindstorms: Children, Computers, And Powerful. Basic Books. ISBN 978-0-465-04627-0
- ^ a b Watt, Daniel (1983) (英語). Learning with Logo. McGraw-Hill Book Company. ISBN 978-0-07-068570-3
- ^ a b Harvey, Brian (1985) (英語). Computer Science Logo Style: Intermediate programming. MIT Press. ISBN 978-0-262-58072-4
- ^ a b Muller, Jim (1997) (英語). The Great Logo Adventure: Discovering Logo on and Off the Computer. Doone Publications. ISBN 978-0-9651934-6-7
- ^ a b Jensen, Kathleen; Wirth, Niklaus (1974) (英語). PASCAL: User Manual and Report. Springer-Verlag. ISBN 978-0-387-06950-0
- ^ a b Grogono, Peter (1984) (英語). Programming in Pascal. Addison-Wesley. ISBN 978-0-201-12070-7
- ^ a b Findlay, William (1985) (英語). Pascal: An Introduction to Methodical Programming. Houghton Mifflin. ISBN 978-0-395-38986-7
- ^ a b Kernighan, Brian W.; Ritchie, Dennis M. (1988) (英語). The C Programming Language. Prentice Hall. ISBN 978-0-13-110370-2
- ^ a b King, Kim N. (2008) (英語). C Programming: A Modern Approach. W.W. Norton. ISBN 978-0-393-97950-3
- ^ a b Linden, Peter Van der (1994) (英語). Expert C Programming: Deep C Secrets. Prentice Hall Professional. ISBN 978-0-13-177429-2
- ^ a b Klemens, Ben (2014-09-27) (英語). 21st Century C: C Tips from the New School. "O'Reilly Media, Inc.". ISBN 978-1-4919-0444-2
- ^ a b Bratko, Ivan (2011) (英語). Prolog Programming for Artificial Intelligence. Addison-Wesley. ISBN 978-0-321-41746-6
- ^ a b Clocksin, William F.; Mellish, Christopher S. (1981) (英語). Programming in Prolog. D.A.I. University of Edinburgh. ISBN 978-0-387-11046-2
- ^ a b Sterling, Leon; Shapiro, Ehud Y. (1986-01) (英語). The Art of Prolog: Advanced Programming Techniques. MIT Press. ISBN 978-0-262-69105-5
- ^ a b Clocksin, William F. (1997-10-13) (英語). Clause and Effect: Prolog Programming for the Working Programmer. Springer Science & Business Media. ISBN 978-3-540-62971-9
- ^ a b Paulson, Lawrence C. (1996-06-28) (英語). ML for the Working Programmer. Cambridge University Press. ISBN 978-0-521-56543-1
- ^ a b Ullman, Jeffrey D. (1998) (英語). Elements of ML Programming. Prentice Hall. ISBN 978-0-13-790387-0
- ^ a b Milner, Robin (1997) (英語). The Definition of Standard ML: Revised. MIT Press. ISBN 978-0-262-63181-5
- ^ a b Winskel, Glynn (1993-02-05) (英語). The Formal Semantics of Programming Languages: An Introduction. MIT Press. ISBN 978-0-262-73103-4
- ^ a b Dybvig, R. Kent (2003) (英語). The Scheme Programming Language. MIT Press. ISBN 978-0-262-54148-0
- ^ a b Springer, George; Friedman, Daniel P. (1989) (英語). Scheme and the Art of Programming. MIT Press. ISBN 978-0-262-19288-0
- ^ a b Harvey, Brian; Wright, Matthew (1999) (英語). Simply Scheme: Introducing Computer Science. MIT Press. ISBN 978-0-262-08281-5
- ^ a b Barnes, John Gilbert Presslie (1995) (英語). Programming in Ada 95. Addison-Wesley. ISBN 978-0-201-87700-7
- ^ a b English, John (1997) (英語). Ada 95: The Craft of Object-oriented Programming. Prentice Hall. ISBN 978-0-13-230350-7
- ^ a b Ben-Ari, Mordechai (2009-03-31) (英語). Ada for Software Engineers. Springer Science & Business Media. ISBN 978-1-84882-314-3
- ^ a b Craeynest, Dirk; Strohmeier, Alfred (2001-05-02) (英語). Reliable Software Technologies - Ada-Europe 2001: 6th Ada-Europe International Conference on Reliable Software Technologies Leuven, Belgium, May 14-18, 2001 Proceedings. Springer Berlin Heidelberg. ISBN 978-3-540-42123-8
- ^ a b Goldberg, Adele; Robson, David (1983) (英語). Smalltalk-80: The Language and Its Implementation. Addison-Wesley. ISBN 978-0-201-11371-6
- ^ a b Goldberg, Adele (1984) (英語). Smalltalk-80: The Interactive Programming Environment. Addison-Wesley. ISBN 978-0-201-11372-3
- ^ a b Beck, Kent (1996-10-03) (英語). Smalltalk Best Practice Patterns. Prentice Hall. ISBN 978-0-13-285212-8
- ^ a b Klimas, Edward J.; Thomas, David A.; Skublics, Suzanne (1996) (英語). Smalltalk with Style. Prentice Hall. ISBN 978-0-13-165549-2
- ^ a b Kochan, Stephen G. (2012) (英語). Programming in Objective-C. Addison-Wesley Professional. ISBN 978-0-321-81190-5
- ^ a b Hillegass, Aaron; Ward, Mikey (2013-11-20) (英語). Objective-C Programming: The Big Nerd Ranch Guide. Addison-Wesley Professional. ISBN 978-0-13-349190-6
- ^ a b Bennett, Gary; Fisher, Mitchell; Lees, Brad (2014-03-19) (英語). Objective-C for Absolute Beginners: IPhone, IPad, and Mac Programming Made Easy. Apress L. P.. ISBN 978-1-4302-5755-4
- ^ a b Galloway, Matt (2013-05-17) (英語). Effective Objective-C 2.0: 52 Specific Ways to Improve Your iOS and OS X Programs. Addison-Wesley. ISBN 978-0-13-338694-3
- ^ a b c d Stroustrup, Bjarne (2013-07-10) (英語). The C++ Programming Language. Addison-Wesley. ISBN 978-0-13-352285-3
- ^ a b c Meyers (1996-09) (英語). More Effective C++: 35 New Ways To Improve Your Programs And Designs. Pearson Education. ISBN 978-81-7758-980-1
- ^ a b c d e Lippman, Stanley B.; Lajoie, Josée; Moo, Barbara E. (2012-08-06) (英語). C++ Primer. Addison-Wesley. ISBN 978-0-13-305303-6
- ^ a b c Christiansen, Tom; foy, brian d; Wall, Larry; Orwant, Jon (2012-02-17) (英語). Programming Perl: Unmatched Power for Text Processing and Scripting. "O'Reilly Media, Inc.". ISBN 978-1-4493-2147-5
- ^ a b c Schwartz, Randal; foy, brian; Phoenix, Tom (2012-08-06) (英語). Intermediate Perl. "O'Reilly Media, Inc.". ISBN 978-1-4493-9309-0
- ^ a b c Chromatic (2014) (英語). Modern Perl. Onyx Neon Press. ISBN 978-0-9854519-4-3
- ^ a b c Schwartz, Randal L.; foy, brian d; Phoenix, Tom (2011-06-16) (英語). Learning Perl. "O'Reilly Media, Inc.". ISBN 978-1-4493-1314-2
- ^ a b c Armstrong, Joe (2013-09-23) (英語). Programming Erlang: Software for a Concurrent World. Pragmatic Bookshelf. ISBN 978-1-68050-432-3
- ^ a b c Logan, Martin; Merritt, Eric; Carlsson, Richard (2010-12-08) (英語). Erlang and OTP in Action. Manning. ISBN 978-1-933988-78-8
- ^ a b c Cesarini, Francesco; Vinoski, Steve (2016) (英語). Designing for Scalability with Erlang/OTP: Implementing Robust, Fault-tolerant Systems. O'Reilly Media. ISBN 978-1-4493-6155-6
- ^ a b c Hebert, Fred (2013-01-13) (英語). Learn You Some Erlang for Great Good!: A Beginner's Guide. No Starch Press. ISBN 978-1-59327-504-4
- ^ a b Lipovaca, Miran (2011-04-15) (英語). Learn You a Haskell for Great Good!: A Beginner's Guide. No Starch Press. ISBN 978-1-59327-295-1
- ^ a b O'Sullivan, Bryan; Goerzen, John; Stewart, Donald Bruce (2008-11-15) (英語). Real World Haskell: Code You Can Believe In. "O'Reilly Media, Inc.". ISBN 978-0-596-55430-9
- ^ a b Thompson, Simon (2011) (英語). Haskell: The Craft of Functional Programming. Addison Wesley. ISBN 978-0-201-88295-7
- ^ a b Matthes, Eric (2015-11-20) (英語). Python Crash Course: A Hands-On, Project-Based Introduction to Programming. No Starch Press. ISBN 978-1-59327-603-4
- ^ a b Zelle, John M. (2015) (英語). Python Programming: An Introduction to Computer Science. W. Ross MacDonald School Resource Services Library
- ^ a b Patrick, Tim (2008-05-27) (英語). Programming Visual Basic 2008: Build .NET 3.5 Applications with Microsoft's RAD Tool for Business. "O'Reilly Media, Inc.". ISBN 978-0-596-55518-4
- ^ a b Sole, Alessandro Del (2010-05-07) (英語). Visual Basic 2010 Unleashed. Pearson Education. ISBN 978-0-672-33156-5
- ^ a b Stephens, Rod (2008-02) (英語). Visual Basic 2008 Programmer's Reference. Wiley India Pvt. Limited. ISBN 978-81-265-1596-7
- ^ a b Troelsen, Andrew; Agarwal, Vidya Vrat (2010-10-20) (英語). Pro VB 2010 and the .NET 4.0 Platform. Apress. ISBN 978-1-4302-2985-8
- ^ a b Ierusalimschy, Roberto (2016) (英語). Programming in Lua. Roberto Ierusalimschy. ISBN 978-85-903798-6-7
- ^ a b Figueiredo, Luiz Henrique de; Celes, Waldemar; Ierusalimschy, Roberto (2008) (英語). Lua Programming Gems. Roberto Ierusalimschy. ISBN 978-85-903798-4-3
- ^ a b Jung, Kurt; Brown, Aaron (2007-03) (英語). Beginning Lua Programming. Wiley India Pvt. Limited. ISBN 978-81-265-1177-8
- ^ a b Szauer, Gabor (2018-07-27) (英語). Lua Quick Start Guide: The easiest way to learn Lua programming. Packt Publishing Ltd. ISBN 978-1-78934-013-6
- ^ a b c d e f g h Schildt, Herbert (2018-12-14) (英語). Java: The Complete Reference, Eleventh Edition. McGraw Hill Professional. ISBN 978-1-260-44024-9
- ^ a b Horstmann, Cay S. (2014) (英語). Java SE 8 for the Really Impatient. Addison-Wesley. ISBN 978-0-13-343020-2
- ^ a b c Lockhart, Josh (2015-02-16) (英語). Modern PHP: New Features and Good Practices. "O'Reilly Media, Inc.". ISBN 978-1-4919-0499-2
- ^ a b c Nixon, Robin (2021-07-22) (英語). Learning PHP, MySQL & JavaScript. "O'Reilly Media, Inc.". ISBN 978-1-4920-9377-0
- ^ a b c Bierer, Doug (2016-08-30) (英語). PHP 7 Programming Cookbook. Packt Publishing Ltd. ISBN 978-1-78588-254-8
- ^ a b c Harrell, Robert (2017-09-20) (英語). PHP and MySQL Web Development. CreateSpace Independent Publishing Platform. ISBN 978-1-9841-7313-3
- ^ a b c Crockford, Douglas (2008-05-08) (英語). JavaScript: The Good Parts: The Good Parts. "O'Reilly Media, Inc.". ISBN 978-0-596-55487-3
- ^ a b c Simpson, Kyle (2015-12-17) (英語). You Don't Know JS: ES6 & Beyond. "O'Reilly Media, Inc.". ISBN 978-1-4919-0525-8
- ^ a b c Flanagan, David (2020-05-14) (英語). JavaScript: The Definitive Guide: Master the World's Most-Used Programming Language. "O'Reilly Media, Inc.". ISBN 978-1-4919-5198-9
- ^ a b c Thomas, David (2004) (英語). Programming Ruby: The Pragmatic Programmers' Guide. Pragmatic Bookshelf. ISBN 978-0-9745140-5-5
- ^ a b c Black, David A.; Leo, Joseph (2019-03-15) (英語). The Well-Grounded Rubyist. Manning. ISBN 978-1-61729-521-8
- ^ a b c Olsen, Russ (2011-02-07) (英語). Eloquent Ruby. Addison-Wesley Professional. ISBN 978-0-321-70027-8
- ^ a b c Shaughnessy, Pat (2013) (英語). Ruby Under a Microscope: Learning Ruby Internals Through Experiment. No Starch Press. ISBN 978-1-59327-527-3
- ^ a b c Matloff, Norman (2011-10-11) (英語). The Art of R Programming: A Tour of Statistical Software Design. No Starch Press. ISBN 978-1-59327-410-8
- ^ a b c Wickham, Hadley (2015-09-15) (英語). Advanced R. CRC Press. ISBN 978-1-4987-5980-9
- ^ a b c Wickham, Hadley; Grolemund, Garrett (2017) (英語). R for Data Science: Import, Tidy, Transform, Visualize, and Model Data. O'Reilly Media. ISBN 978-1-4919-1033-7
- ^ a b c Grolemund, Garrett (2014-06-13) (英語). Hands-On Programming with R: Write Your Own Functions and Simulations. "O'Reilly Media, Inc.". ISBN 978-1-4493-5911-9
- ^ a b c Alexandrescu, Andrei (2010-06-02) (英語). The D Programming Language. Addison-Wesley Professional. ISBN 978-0-13-265440-1
- ^ a b c Cehreli, Ali (2015-10-25) (英語). Programming in D: Tutorial and Reference. Ali Cehreli. ISBN 978-0-692-52957-7
- ^ a b c Ruppe, Adam D. (2014-05-26) (英語). D Cookbook. Packt Publishing Ltd. ISBN 978-1-78328-722-2
- ^ a b c Nacke, Kai (2016-01-30) (英語). D Web Development. Packt Publishing Ltd. ISBN 978-1-78528-010-8
- ^ a b c Albahari, Joseph; Albahari, Ben (2017-10-11) (英語). C# 7.0 in a Nutshell: The Definitive Reference. "O'Reilly Media, Inc.". ISBN 978-1-4919-8762-9
- ^ a b c Troelsen, Andrew; Japikse, Phil (2020-09-14) (英語). Pro C# 8 with .NET Core 3: Foundational Principles and Practices in Programming. Apress. ISBN 978-1-4842-5756-2
- ^ a b c Michaelis, Mark (2018-06-17) (英語). Essential C# 7.0. Addison-Wesley Professional. ISBN 978-1-5093-0362-5
- ^ a b c Skeet, Jon (2019-03-23) (英語). C# in Depth: Fourth Edition. Manning Publications. ISBN 978-1-61729-453-2
- ^ a b c Konig, Dierk (2015) (英語). Groovy in Action, Second Edition. Manning Publications
- ^ a b c Kousen, Kenneth (2013-09-18) (英語). Making Java Groovy. Simon and Schuster. ISBN 978-1-63835-226-6
- ^ a b c Subramaniam, Venkat (2013-07-15) (英語). Programming Groovy 2: Dynamic Productivity for the Java Developer. Pragmatic Bookshelf. ISBN 978-1-68050-434-7
- ^ a b c Brown, Jeff Scott; Rocher, Graeme (2013-02-03) (英語). The Definitive Guide to Grails 2. Apress. ISBN 978-1-4302-4378-6
- ^ a b c Chiusano, Paul; Bjarnason, Runar (2014-09-01) (英語). Functional Programming in Scala. Simon and Schuster. ISBN 978-1-63835-395-9
- ^ a b c Horstmann, Cay (2016) (英語). Scala for the Impatient, Second Edition. Addison-Wesley Professional
- ^ a b c Ghosh, Debasish (2016-10-04) (英語). Functional and Reactive Domain Modeling. Simon and Schuster. ISBN 978-1-63835-251-8
- ^ a b c Alexander, Alvin (2013-08-01) (英語). Scala Cookbook: Recipes for Object-Oriented and Functional Programming. "O'Reilly Media, Inc.". ISBN 978-1-4493-4032-2
- ^ a b c Syme, Don; Granicz, Adam; Cisternino, Antonio (2015-12-31) (英語). Expert F# 4.0. Apress. ISBN 978-1-4842-0740-6
- ^ a b c Wlaschin, Scott (2018-01-25) (英語). Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#. Pragmatic Bookshelf. ISBN 978-1-68050-549-8
- ^ a b c Hansen, Michael R.; Rischel, Hans (2017-07-14) (英語). Functional Programming Using F#. CreateSpace Independent Publishing Platform. ISBN 978-1-5488-8955-5
- ^ a b c Petricek, Tomas; Skeet, Jon (2010-01-25) (英語). Real-World Functional Programming: With Examples in F# and C#. Manning. ISBN 978-1-933988-92-4
- ^ a b c Miller, Alex; Halloway, Stuart; Bedra, Aaron (2018-02-23) (英語). Programming Clojure. Pragmatic Bookshelf. ISBN 978-1-68050-572-6
- ^ a b c Emerick, Chas; Carper, Brian; Grand, Christophe (2012-03-30) (英語). Clojure Programming: Practical Lisp for the Java World. "O'Reilly Media, Inc.". ISBN 978-1-4493-3535-9
- ^ a b c Houser, Chris; Fogus, Michael (2014-05-28) (英語). The Joy of Clojure. Simon and Schuster. ISBN 978-1-63835-128-3
- ^ a b c Higginbotham, Daniel (2015) (英語). Clojure for the Brave and True. No Starch Press. ISBN 978-1-4571-9001-8
- ^ a b c Martin, Erik St; Kennedy, William; Ketelsen, Brian (2015-11-04) (英語). Go in Action. Simon and Schuster. ISBN 978-1-63835-202-0
- ^ a b c Ryer, Mat (2016-10-27) (英語). Go Programming Blueprints. Packt Publishing Ltd. ISBN 978-1-78646-247-3
- ^ a b c Doxsey, Caleb (2016-01-07) (英語). Introducing Go: Build Reliable, Scalable Programs. "O'Reilly Media, Inc.". ISBN 978-1-4919-4202-4
- ^ a b c d e Blandy, Jim; Orendorff, Jason; Tindall, Leonora F. S. (2021-06-11) (英語). Programming Rust. "O'Reilly Media, Inc.". ISBN 978-1-4920-5254-8
- ^ a b c McNamara, Tim (2021-09-07) (英語). Rust in Action. Simon and Schuster. ISBN 978-1-63835-622-6
- ^ a b c Sharma, Rahul; Kaihlavirta, Vesa (2019-01-31) (英語). Mastering Rust: Learn about memory safety, type system, concurrency, and the new features of Rust 2018 edition, 2nd Edition. Packt Publishing Ltd. ISBN 978-1-78934-118-8
- ^ a b c Juric, Saa (2018) (英語). Elixir in Action, Second Edition. Manning Publications
- ^ a b c Hao, Benjamin Tan Wei (2016-09-25) (英語). The Little Elixir & OTP Guidebook. Simon and Schuster. ISBN 978-1-63835-345-4
- ^ a b c Gray (II), James Edward; Tate, Bruce A. (2019) (英語). Designing Elixir Systems with OTP: Write Highly Scalable, Self-healing Software with Layers. Pragmatic Bookshelf. ISBN 978-1-68050-736-2
- ^ a b c Laurent, Simon St; Eisenberg, J. David (2014-09-10) (英語). Introducing Elixir: Getting Started in Functional Programming. "O'Reilly Media, Inc.". ISBN 978-1-4493-6997-2
- ^ a b c Jemerov, Dmitry; Isakova, Svetlana (2017-02-03) (英語). Kotlin in Action. Simon and Schuster. ISBN 978-1-63835-369-0
- ^ a b c Greenhalgh, David; Skeen, Josh (2018) (英語). Kotlin Programming: The Big Nerd Ranch Guide. Big Nerd Ranch. ISBN 978-0-13-516518-8
- ^ Leiva, Antonio (2018) (英語). Kotlin for Android Developers: Learn Kotlin the Easy Way While Developing an Android App. Leanpub. ISBN 978-1-5300-7561-4
- ^ a b c Adelekan, Iyanu (2018-03-28) (英語). Kotlin Programming By Example: Build real-world Android and web applications the Kotlin way. Packt Publishing Ltd. ISBN 978-1-78847-978-3
- ^ a b Moskala, Marcin (2019-11-07) (英語). Effective Kotlin: Best Practices. Amazon Digital Services LLC - Kdp. ISBN 978-83-954528-3-3
- ^ a b c Rose, Richard (2022-12-15) (英語). Flutter and Dart Cookbook. "O'Reilly Media, Inc.". ISBN 978-1-0981-1948-5
- ^ a b c Napoli, Marco L. (2019-10-08) (英語). Beginning Flutter: A Hands On Guide to App Development. John Wiley & Sons. ISBN 978-1-119-55082-2
- ^ a b c Zaccagnino, Carmine (2020-02-25) (英語). Programming Flutter: Native, Cross-Platform Apps the Easy Way. Pragmatic Bookshelf. ISBN 978-1-68050-763-8
- ^ a b c Cheng, Fu (2019-10-10) (英語). Flutter Recipes: Mobile Development Solutions for iOS and Android. Apress. ISBN 978-1-4842-4982-6
- ^ a b c Jansen, Remo H. (2018-04-30) (英語). Learning TypeScript 2.x: Develop and maintain captivating web applications with ease, 2nd Edition. Packt Publishing Ltd. ISBN 978-1-78839-660-8
- ^ a b c Rozentals, Nathan (2019-02-28) (英語). Mastering TypeScript 3: Build enterprise-ready, industrial-strength web applications using TypeScript 3 and modern frameworks, 3rd Edition. Packt Publishing Ltd. ISBN 978-1-78953-747-5
- ^ a b c Moiseev, Anton; Fain, Yakov (2020-02-10) (英語). TypeScript Quickly. Simon and Schuster. ISBN 978-1-63835-143-6
- ^ a b c Fenton, Steve (2014-08-20) (英語). Pro TypeScript: Application-Scale JavaScript Development. Apress. ISBN 978-1-4302-6791-1
- ^ a b c Hudson, Paul (2018-02-23) (英語). Pro Swift - Swift 4. 1 Edition. CreateSpace Independent Publishing Platform. ISBN 978-1-9857-7978-5
- ^ Pitre, Boisy G. (2016) (英語). Swift for Beginners: Develop and Design. Peachpit Press. ISBN 978-0-13-428977-9
- ^ a b c Hoffman, Jon (2020) (英語). Mastering Swift 5. 3: Upgrade Your Knowledge and Become an Expert in the Latest Version of the Swift Programming Language, 6th Edition. Packt Publishing, Limited. ISBN 978-1-80056-215-8
- ^ a b Veen, Tjeerd in 't (2018-12-10) (英語). Swift in Depth. Simon and Schuster. ISBN 978-1-63835-616-5
- ^ a b c Spell, Terrill Brett (2015-05-29) (英語). Pro Java 8 Programming. Apress. ISBN 978-1-4842-0641-6
- ^ a b c d e f g Richardson, Chris (2018-10-27) (英語). Microservices Patterns: With examples in Java. Simon and Schuster. ISBN 978-1-63835-632-5
- ^ a b c d Mitchell, Melanie (2020) (英語). Artificial Intelligence: A Guide for Thinking Humans. Penguin Books. ISBN 978-0-241-40483-6
- ^ Lee, Kai-Fu (2018-09-25) (英語). AI Superpowers: China, Silicon Valley, and the New World Order. Houghton Mifflin Harcourt. ISBN 978-1-328-54639-5
- ^ a b c Russell, Stuart (2019-10-08) (英語). Human Compatible: Artificial Intelligence and the Problem of Control. Penguin. ISBN 978-0-525-55862-0
- ^ a b c Marcus, Gary; Davis, Ernest (2019-09-10) (英語). Rebooting AI: Building Artificial Intelligence We Can Trust. Knopf Doubleday Publishing Group. ISBN 978-1-5247-4826-5
- ^ “ChatGPTでコーディングを効率化！活用事例やAI導入のサポートサービスを紹介”. AIsmiley (2023年10月13日). 2024年8月25日閲覧。
- ^ “エンジニアのためのChatGPT活用入門。著者が語るプロンプトの入力例とプログラミングをラクにする方法とは？”. アンドエンジニア. 2024年8月25日閲覧。
- ^ 日経クロステック Active (2024年2月15日). “4割がChatGPTをソフト開発に活用、意外に少ないGitHub Copilotの利用者”. 日経クロステック Active. 2024年8月25日閲覧。
- ^ Jurafsky, Dan; Martin, James H. (2019) (英語). Speech and Language Processing: An Introduction to Natural Language Processing, Computational Linguistics, and Speech Recognition. Els autors
- ^ Coeckelbergh, Mark (2020-02-05) (英語). AI Ethics. MIT Press. ISBN 978-0-262-35707-4