プログラミング言語（プログラミングげんご、）とは、プログラムを記述するための人工言語ISO 5127—Information and documentation—Vocabulary, clause 01.05.10 で、プログラミング言語は「プログラムを記述するための人工言語」と定義されている。。コンピュータプログラムを書くために考案された、正確に定義された記号と規則のしくみLexico, definition of programming language. A system of precisely defined symbols and rules devised for writing computer programs.。以前はしばしばプログラム言語と表記された。

 概要
プログラミング言語は、情報を組織し処理するタスクについての理解を容易にし、アルゴリズムを正確に表現することができる。特に、チューリング完全であることが特徴である。

言語仕様とプログラムとその入力データの組合せで、そのプログラムを実行したときの結果（外部から観測される振る舞い）が完全に指定できなければならない。

プログラミング言語は構文規則（自然言語に関する言語学で言う統語論の規則に類似したもの）と意味規則（自然言語の意味論に類似した規則）で定義される。形式的ないし非形式的（自然言語による）な仕様が（構文規則は形式的で、意味規則はそうでない、というものが多い）実装とは独立した文書で示される言語もあれば、実装のみの言語もある。

多くの言語は、新たなニーズを満たすべく設計され、他の言語と組み合わされ、最終的に使われなくなる。あらゆる用途に使える万能言語を設計しようという試みはいくつかあったが、そういう意味で成功した言語は存在しない
IBMは PL/I をリリースしたとき、やや野心的にマニュアルを The universal programming language PL/I (IBM Library; 1966) と名づけている。このタイトルはIBMが目標としていた無制限のサブセット化機能を反映している「PL/I は特定の応用に必要な部分を抜き出し、サブセットを分離可能なように設計されている」 ().  AdaとUNCOLも同様の初期目標を持っていた。。

プログラミング言語の開発の大きな流れに共通する傾向として、より高いレベルの抽象化によってより高い問題解決能力を得ようとしてきた、ということが指摘されることがある。初期のプログラミング言語はコンピュータのハードウェアのレベルと極めて近かった。新たなプログラミング言語が開発される度に機能が追加され、プログラマはハードウェアの命令からより遠い形でアイデアを表現できるようになっていった。プログラミングをハードウェアから分離することで、プログラマの生産性は向上する Frederick P. Brooks, Jr.:  The Mythical Man-Month, Addison-Wesley, 1982, pp. 93-94 。

毎年のように新たなプログラミング言語が作り出されている。2008年2月時点で、「コンピュータ言語辞典The Encyclopedia of Computer Languages  （Murdoch University、オーストラリア）」には8,152種のプログラミング言語が記載されていた。

過去のプログラミング言語のなかの欠点と見なされた部分を解消するために、新たなプログラミング言語が構想され、作られてきた歴史がある。また多様なプログラミング言語が生み出される背景には、さまざまな事情があり、ハードウェアが時代とともに変化してきたことや、プログラミング言語というテクノロジーやコンピュータサイエンスの発展も影響しており、下のような諸事情もある。
 プログラムと言っても、個人が自分だけのために趣味で書く数行から数十行程度の短いプログラム（やスクリプト）から、数百人のプログラマが協働して企業の大規模なシステムのために書く長大なプログラムまで、様々なプログラムがある。
 プログラミング言語の記述に 簡潔さを求め、可読性が高いことを求め、バグが入り込みにくい記述を好むプログラマの方が多く、世の中では一般的である（特に、業務として、ミスの少ないプロの仕事としてプログラミングを行わなければいけない職業的プログラマで多い）一方で、ごちゃごちゃして難読で、一名で書くならともかく複数名でプログラムを書くと高頻度で誤読やバグを招きがちな記述でもあまり気にしなかったり面白がる趣味的なプログラマも一部にいる。
 プログラムが搭載されるシステムも多様で、マイクロコントローラ、組み込みシステムから汎用デスクトップPC、GPUそしてスーパーコンピュータまで様々あり、それぞれのシステムのハードウェアの特性や制約に合ったプログラムやプログラミング言語がある。
 もともとプログラミング言語はもっぱら大学のコンピュータサイエンスの研究室や大手企業の研究所などの奥深くばかりで開発されていたのだが、ここ数十年では個人が趣味的に新しいプログラミング言語を構想しそのコンパイラを自分で書くための書籍なども時折出版されるようになり、つまり世の中の普通の人が新たなプログラミング言語を独自に作成するためのノウハウも広まってハードルが次第に下がってきている。

ウィキペディアに記事が掲載されているプログラミング言語を知りたい場合はプログラミング言語一覧を参照のこと。

 分類・種類
プログラミング言語の分類法は多数ある。

ひとつの分類法としては（そして計算機科学の教科書や情報処理技術者の教科書などで、まっさきに一種の定番のように挙げてある分類方法としては）、機械寄り（CPU寄り）か人間（の思考）寄りか、で分類する方法であり、低水準言語 / 高水準言語 と分類する方法である。（" 低級言語 / 高級言語 " とも）
低水準言語の例としては、機械語の「命令コード」CPUの命令コードというのは、本当のCPUレベルではたとえば「00101011」のようにただの2進数の羅列であり、人間には意味不明である。と1対1に対応する「命令語」数文字のアルファベットや数字を組み合わせて、CPUに対する命令やCPUが操作すべきレジスタなどを表記したもの。を用いてプログラミングを行うアセンブリ言語がある。（機械語も低水準言語のひとつに数える場合もある。）対比される高水準言語の例としてはPerl、Visual Basic、LISP、PHP、Java、Pythonなどを挙げることができる。（なお、境界はやや曖昧で、C言語はかつては「高水準言語」と見なされていたが、その後それよりもレベルの高い高水準言語が多数登場したので、今日ではメモリ管理もしないC言語は「低水準言語」に分類されることもある。）

他の分類法としては、実行方法によってプログラミング言語を分類する方法もあり、インタープリタ方式言語 / コンパイラ方式言語（コンパイル方式言語）と分類する方法である。
インタープリタ方式言語の例としてはPHPやRubyを挙げることができる。コンパイラ方式言語の例としてはC言語、C++、Erlang、Haskell、Rust、Go、FORTRAN、COBOLなどを挙げることができる。なお言語によってはインタープリタ方式で実行でき、かつコンパイル方式で実行することができるものもある。そして「一応、どちらの方法でも実行できるが、基本はコンパイル方式」などという場合もあるので、やや分類が曖昧になる場合がある。コンパイル方式でしか実行できない言語をわざわざ指さなければならない場合に「純コンパイル方式言語」などと分類する人もいる。なおJavaはバイトコードにコンパイルをしてから実行するので、一応「コンパイル方式」に分類することも可能ではある言語だが、実行時コンパイラ（JIT）とJava仮想マシンを使うので、「Javaは、コンパイル方式とインタープリタ方式の中間的な方式」としばしば指摘され、曖昧な位置づけである。

かつては人間側の用途で分類する方法もしばしば用いられたことがある。たとえば、汎用プログラミング言語 / 事務計算用プログラミング言語/ 科学技術計算用プログラミング言語 などと分類する方法である。1970年代-1980年代などは「事務計算用プログラミング言語の例はCOBOLで、科学技術計算用プログラミング言語の例はFORTRAN」などと書かれたが、近年ではそのような分類はあまりされなくなった。なお「汎用プログラミング言語」に分類されるのはJava、C#、Python、Visual Basic、Rubyなどである。

手続き型言語かそうでないかで、手続き型言語 / 非手続き型言語 と分類する方法もある。手続き型言語の例としてはFORTRAN、ALGOL、C言語、COBOL、BASIC、Pascalなどを挙げることができる。

オブジェクト指向プログラミングに適したしくみを備えているか否かで、オブジェクト指向言語 / 非オブジェクト指向言語 と分類されることもある。

構造化プログラミングに適した仕様になっているか否かで判断して、適したものだけを構造化プログラミング言語と分類する方法もある。

スレッドを複数個生成・管理できるか否か、で並行言語 / 非並行言語 と分類する方法もある。

なお1950年代（や1960年代）計算理論をチョムスキー階層という構想や理論が発表された時代には、計算表現能力に基づいてコンピュータの言語を、抽象的に、「タイプ0 / タイプ1 / タイプ2 / タイプ3」などに分類しようとしていたこともあった。ただし近年ではそのような分類法は滅多に持ち出されない。世の中のプログラミング言語のユーザーたちや言語開発者たちの関心は、すでに別のレベルに移っているからであるなおチューリング完全な言語ならば、同じアルゴリズム群を表現可能である。。

（他の分野でもありがちなことなのだが）プログラミング言語も分類法があまりに多数あるので、混乱しがちな分類法を整理整頓しようと「分類法の分類」をする人も出てくる。たとえば高級言語の分類方法について「プログラミングパラダイムによる分類法 / そうでない分類法」という分類ができる、などと言う人も出てくる。

以上のようにプログラミング言語の分類法は多数あるので、各プログラミング言語は複数のカテゴリに分類可能である。たとえばアセンブリ言語は「低水準言語」に分類され、かつ「非オブジェクト指向言語」に分類される。Javaは「高級言語」に分類され、かつ「オブジェクト指向言語」に分類され、かつ「並行性言語」に分類される。Pythonは「オブジェクト指向言語」であり「スクリプト言語」である。LISPは「マルチパラダイム言語」で「関数型言語」で「手続き型言語」である。

それ以外に、コンピュータがプリンター（やモニタ）などを制御するために使うプログラミング言語を分類するための「ページ記述言語」という分類法もある。
ページ記述言語の代表的な例としては、PostScriptを挙げることができる。たとえば、プリンターで美麗な印字をする場合、画面上のボタンやメニューで「印刷」という命令を選ぶわけだが、その時点でPC内のプリンター制御用プログラムがPostScript言語でプログラムを自動生成し、そのプログラムをケーブルやWifi経由でプリンターに向けて送り出し、それを受け取ったプリンターの側でそれを実行するということで美麗な印字、繊細な曲線に満ちたフォントの印字を実現している。

その他に、あまり真面目な分類ではないが、わざわざ理解が難しくなるように作られた（冗談のような）プログラミング言語を特に「難解プログラミング言語」と分類することもある。

 歴史

 初期の発展
「コンピュータ」（という語）の定義次第ではあるが、それを「コンピュータ・プログラムによって駆動される機械」とするならば、コンピュータ・プログラムはコンピュータとともに生まれ、育ったということになり、そのプログラムの記法としてプログラミング言語があった、ということになる。チャールズ・バベッジが階差機関に続いて計画した解析機関は、パンチカードの先祖と言えるような穴の開いた厚紙の列によって制御されるという機構を持っていたため、その特徴から「19世紀のコンピュータ」「蒸気動力のコンピュータ」などと呼ばれることがある。

20世紀初頭には、タビュレーティングマシンによってパンチカードを使ったデータの機械処理が始まっている。そういった実際面ばかりではなく計算理論としても、1930年代から1940年代にかけて、アルゴリズムを表現する数学的抽象表現を提供するラムダ計算（アロンゾ・チャーチ）とチューリングマシン（アラン・チューリング）が考案された。ラムダ計算はその後の言語設計にも影響を与えているBenjamin C. Pierce は次のように書いている。
". . . the lambda calculus has seen widespread use in the specification of programming language features, in language design and implementation, and in the study of type systems."（訳:ラムダ計算はプログラミング言語の仕様記述、言語設計と実装、型システムの研究に広く使われている）。

1940年代、世界初の電子式デジタルコンピュータ群が製作された。1950年代初期のコンピュータであるUNIVAC IやIBM 701では機械語を使っていた。機械語によるプログラミングは、間もなくアセンブリ言語によるプログラミングに取って代わられた。1950年代後半になると、アセンブリ言語でマクロ命令が使われるようになり、その後 FORTRAN、LISP、COBOLという3つの高水準言語が開発された。これらは改良を加えられ現在でも使われており、その後の言語開発に重大な影響を与えた。1950年代末、ALGOLが登場し、その後の言語に様々な影響を与えている。初期のプログラミング言語の仕様と使い方は、当時のプログラミング環境の制約（パンチカードによるプログラム入力など）にも大きく影響されているFrank da Cruz. IBM Punch Cards Columbia University Computing History.。

 改良
1960年代から1970年代末ごろまでに、現在使われている主な言語パラダイムが開発されたが、その多くはごく初期の第三世代プログラミング言語のアイデアの改良である。
APL - 配列プログラミングを導入した言語。関数型プログラミングにも影響を与えたRichard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV.。
PL/I (NPL) - FORTRANとCOBOLの長所を取り入れて1960年代初期に設計された。
Simula - 世界初（1960年代）のオブジェクト指向プログラミングを採用した言語。1970年代中頃には純粋なオブジェクト指向言語であるSmalltalkが登場した。
C言語 - 1969年から1973年にかけてシステムプログラミング言語として開発され、現在でもよく使われている.  Sorceforge でのプロジェクト群で使われている言語の統計をとった結果である。C言語はよく使われているが、2006年には Java に抜かれている。ただし、C++を含めると一番多く使われていることになる。。
Prolog - 1972年に設計された論理プログラミング言語。
ML - 1978年に開発された言語で、LISPをベースとした静的型付け関数型言語の先駆けとなった。

これらの言語のアイデアは様々な言語に引き継がれており、現在の言語の多くは、これらのいずれかの系統に属する。

1960年代と1970年代は、構造化プログラミングに関する論争が盛んに行われた時期でもある。この論争で特に有名なものは、1968年にCommunications of the ACMに掲載されたエドガー・ダイクストラのレターGo To Statement Considered Harmfulであろう。その後の反論と指針としてはクヌースのStructured Programming with go to Statementsがある。

1960年代と1970年代は、プログラムのメモリ使用量を削減し、プログラマやユーザーの生産性を向上させる技法も進展した時期である。初期の4GL（第四世代プログラミング言語）は、同じプログラムを第三世代プログラミング言語で書いたときよりもソースコードの量を劇的に削減した。

 統合と成長
1980年代は、相対的な統合の時代であった。C++は、オブジェクト指向とシステムプログラミングの統合である。アメリカでは、軍需に使うことを目的としてAdaというシステムプログラミング言語が標準化された。日本などでは、論理プログラミングを応用した第五世代言語の研究に資源を費やした Tetsuro Fujise, Takashi Chikayama, Kazuaki Rokusawa, Akihiko Nakase (December 1994). "KLIC: A Portable Implementation of KL1" Proc. of FGCS '94, ICOT Tokyo, December 1994. 第五世代コンピュータ・プロジェクト・アーカイブ。関数型言語コミュニティではMLとLISPの標準化の動きがあった。これらはいずれも新たなパラダイムを生み出そうというものではなく、それまでに生み出されたアイデアに改良を加える動きであった。

1980年代の重要な言語設計傾向の1つとして、大規模システムのためのプログラミングを目的としてモジュールの概念を採り入れた点が挙げられる。1980年代にモジュールシステムを採り入れた言語として、Modula-2、Ada、MLがあるが、それ以前には、既にPL/Iがモジュラープログラミングをサポートしていた。モジュールシステムはジェネリックプログラミングの構成要素とされることが多い。

1990年代中頃には、インターネットの急激な成長によって新たな言語が生み出される機会が生じた。Perlは1987年にリリースされたUNIX上のスクリプト言語だったが、ウェブサイトの動的コンテンツ作成に使われるようになった。Javaはサーバ側のプログラミングに使われるようになった。

 要素
 構文
thumb|right|292px|シンタックスハイライトによりソースコードの構造や文法ミスを認識しやすくなる。ここでの言語はPython。
プログラミング言語の見た目は、その構文（syntax・統語論）で決定される。図形などを使うグラフィカルなプログラミング言語もあるが、たいていのプログラミング言語のソースコードは文字列である。ファイル形式ではプレーンテキストすなわちテキストファイルが用いられる。

また、たいていのプログラミング言語では、まず、（英語では lexical syntax などと呼ぶ）ソースの文字列から空白類を取り除き最小の意味のあるカタマリを取り出した「字句（トークン）」があり、構文は字句の並びである、という扱いのことが多い。字句を切り出して分類する処理を字句解析、その並びを調べる処理を構文解析という。

（字句解析のために）字句規則を示すのには正規表現が、そして（構文解析のために）構文規則を示すのにはバッカス・ナウア記法が使われることが多い。

下記はLISPの構文の一部分である。

expression ::= atom | list
atom ::= number | symbol
number ::= ['+''-']?['0'-'9']+
symbol ::= ['A'-'Z''a'-'z'][^' ']*
list ::= '(' expression* ')'

これは、次のような規則である。
 expression は atom または list である。
 atom は number または symbol である。
 number は1文字以上の数字列であり、オプションとして符号が前置される（空白は含まない）。
 symbol はアルファベットで始まる任意の文字列である（空白は含まない）。
 list は括弧記号の対であり、その間に0個以上の expression がある。

これに従う例として、12345、()、(a b c232 (1)) などがある。

構文上正しいプログラムが全て意味的に整合しているとは限らない、という設計の言語も多い自然言語では Colorless green ideas sleep furiously. という例文がある。その言語の設計次第である。構文的に正しければ必ず整合した意味を持つような設計というものもありうる。。また、意味的に整合していても、それを書いた人が、自分の意図を正しく反映できていない場合もある。

以下のLISPのコード断片は構文上は正しいが、意味的には問題がある。変数 employees には従業員データのリストを入れるべきものであるが、employees は実際には空（nil）なので、employees がリストであることを前提に、employees の後続部分を求める式 (cdr employees) は評価できずエラーになる。

(let ((employees nil))
  (cdr employees))

 意味
自然言語の言語学に構文論（統語論）と意味論があるように、そのプログラムが表現しているものは何か、というのが、プログラミング言語の「意味」である。たとえば「a + b という式の値は、aの値とbの値を加算した値である」といったような規則の集まりであり、プログラム意味論という分野で形式的な意味論（形式意味論、）も研究されているが、C言語の標準規格など、自然言語で意味を与えている言語や、形式的でない擬似言語のようなもので与えている言語もある。

 型システム

型システムは、プログラミング言語において式の値となるデータ型について、型理論にもとづいて分類しどう扱うかを示すものである。

また、内部的には、ディジタルコンピュータでは全てのデータはバイナリ（二進法）で保持される。

 型のある言語とない言語
型のある言語は、型システムによって、それぞれの値のデータ型に応じて、定義されていない操作が実行されないよう（多かれ少なかれ）チェックされる機構を持つ。

例えば、"this text between the quotes" は文字列型の値である。ふつう、数を文字列で割る操作には意味がない。そのため、そのようなプログラムは拒絶する。言語によっては、コンパイル時に検出し（静的型検査）コンパイルを失敗とする。言語によっては、実行時に検出し（動的型検査）、例外とするものもあればなんらかのコアーション（型の強制）を行うものもある。（理論的には、静的なシステムのみを指して「型システム」とすることもある）

（型のある言語の特殊例として、単一型言語がある。REXXといったスクリプト言語やSGMLといったマークアップ言語は、単一のデータ型しか扱わない。多くの場合、そのときのデータ型は文字列型である。

アセンブリ言語などの型のない言語は、任意のデータに任意の操作を実行可能であり、データは単にある長さのビット列として扱われる。ある程度高い機能を持ちつつも型が無い（あるいは単一型の）プログラミング言語の例としては、BCPLやForthなどがある（型という概念自体が無いわけではない。例えば「浮動小数点に対する加算」という演算子といったものは存在する。ただしその演算子により、オペランドが何であれそのワードのビットパターンが浮動小数点数を表現しているものとみなされて加算される、といったようなことになる）。

「多かれ少なかれ」と書いたように、「強い」型システムの言語は少なく、多くの言語はそれなりの型システムを採用している。多くの実用的な言語には、型システムを迂回または打倒するような手段が用意されている。

 静的型付けと動的型付け
静的型付け（静的型付き言語）では、全ての式の型はそのプログラムを実行する前（一般にコンパイル時）に決定される。例えば、1とか(2+2)という式は整数型であり、文字列を期待している関数には渡せず、日付（型）を格納するよう定義された変数には代入できない。

静的型付けでは、型を明記する場合と型推論を行う場合がある。前者ではプログラマは適切な位置に型を明記しなければならないたとえば変数の宣言などでは、その名前の直前ないし直後といったことが多い。ただしC言語では「void (*signal(int sig, void (*func)(int)))(int);」などといったように、いったいどこにあるのが名前なのか型なのか、全くわからないことになることがある。。後者では、コンパイラが式の型を文脈から推論する。C++やJavaなどの主な静的型付き言語では、型を明記する。完全な型推論は主流でない言語に使われている（HaskellやML）。ただし、型を明記する言語でも部分的な型推論をサポートしていることが多い。たとえば、JavaやC#では限定された状況で型推論を行う。

動的型付け（動的型付き言語）では、型の安全性は実行時に検査される。言い換えれば、型はソース上の式ではなく、実行時の値に対して付与される。型推論言語と同様、動的型付き言語でも式や変数の型を明記する必要はない。また、ある1つの変数がプログラム実行中に異なる型の値を格納することも可能である。しかし、コードを実際に実行してみるまで型の間違いを自動的に検出することができず、デバッグがやや難しい。動的型付き言語としては、Ruby、LISP、JavaScript、Pythonなどがある。

 強い型付けと弱い型付け

 実行意味論
データを入力されれば、コンピュータはそのデータに対して何らかの処理を実行する。「実行意味論()」とは、プログラミング言語の構成要素がどの時点でどのようにして、そのプログラムの振る舞いを生成するのかを定義するものである。

例えば、式の評価戦略（先行評価、部分評価、遅延評価、短絡評価など）は実行意味論の一部である。また、制御構造における条件付実行の作法も実行意味論の一部である。

 標準ライブラリ

「ライブラリ」は、プログラムを書いたり使用する上での、補助的なルーチン群である。多くのプログラミング言語には、言語仕様の一部、あるいは言語本体の仕様とは独立していることもあるが、標準ライブラリの仕様もほぼ必ず存在し、その言語の実装には標準ライブラリの実装もほぼ必ず付属する。標準ライブラリには、典型的なアルゴリズム、データ構造、入出力機構などが含まれることが多い。

ユーザーから見れば、標準ライブラリも言語の一部だが、設計者から見れば別の実体である。言語仕様には必ず実装しなければならない部分が定義されており、標準化された言語の場合、それには標準ライブラリも含まれる。言語とその標準ライブラリの境界は、言語によって様々である。実際、言語によっては一部の言語機能が標準ライブラリなしでは使えないこともある（たとえば累乗の演算子がある言語があるが、それのコンパイル結果はその言語の多くの処理系で関数呼出であろう。それが、言語仕様として標準ライブラリの該当する関数を呼び出すよう決められているような場合は「一部の言語機能が標準ライブラリなしでは使えない」ということになる）。

マクロもライブラリに含まれることも多い。たとえばC言語の標準には、いくつかの名前が関数ではなくマクロで提供されるかもしれない、といったような規定などがある。またLisp系の言語では、いわゆる特殊形式の多くが言語組込ではなくマクロでも実装可能であり、ifとcondのようにどちらか片方は必要だが、片方があればもう片方はマクロにできる、といったようなものもある。Schemeの標準規格は、どれを言語組込とし、どれをマクロとするか、ほとんどを処理系実装者の自由に任せている。

 設計と実装
コンピュータ・プログラミング言語の設計は「言語仕様」として示され、実装は「言語処理系」と呼ばれる。以下はそれらについての概観である。
 仕様
前述のようにプログラミング言語は構文と意味から成るから、仕様についても、構文仕様と意味仕様がある。
 構文仕様
構文仕様は一般にバッカス・ナウア記法などによって形式的に示される。
 意味仕様
意味論の仕様は、自然言語などで記述されることが多いが、形式的に与えられている言語もある。

形式意味論（プログラム意味論の記事も参照）で意味論を記述した例として Standard ML や Scheme がある。
 その他
他に、以下のようなスタイルで仕様が与えられている言語もある。

 その言語の処理系のリファレンス実装やモデル実装として示されているもの
 その言語のコンパイラ（FORTRAN）
 その言語のインタプリタ（Ruby（cruby、ただしRubyの標準化以前の場合））
 対象言語自身で書かれることもある（例えば、LISP や Prolog や ANSI REXXANSI — Programming Language Rexx, X3-274.1996）:en:Meta-circular evaluator も参照のこと。

 処理系
プログラミング言語の実装は、プログラミング言語処理系と呼ばれる。コンパイラは、ソースコードなどの入力を中間表現などの、より解釈実行しやすい表現に変換する処理系である。また、インタプリタは、入力されたプログラムを解釈実行する処理系である（ハードウェアのプロセッサは、機械語を解釈実行するインタプリタである、と見ることができる）。

コンパイラとインタプリタの関係は、理論的には二村射影により定式化されている。

なお、「大きく分けて2つの方法がある。コンパイラとインタプリタである。一般にある言語をコンパイラとインタプリタの両方で実装することが可能である。」などといったように（従来書かれた通俗的解説書などには大変多いが）理解していると、Javaなど近年の多くの言語処理系のスタイルが全くわからない、ということになる。

（機械語にまで変換するもののみを指してコンパイラと呼びたがる向きが一部にあり、その立場にもある程度は理もあるのだが、そうするとJavaの一般的な実装を指す用語が無くなる）

「コンパイラの出力したものをインタプリタで実行する方式は、コンパイラとインタプリタの区別が曖昧な場合もある。」などという変な説明をする者もいるが、前述したように、そもそも間違った2分法で考えているから、そのような変な考え方になるのである。

一般に、機械語に変換したもの（実行ファイル）を直接ハードウェアで実行する方が、インタプリタで実行するよりもずっと高速である。インタプリタでの実行を改善する技法として、実行時コンパイラなどの動的コンパイル手法がある。

 言語利用状況の計測
どのプログラミング言語が最もよく使われているかを判断することは難しい。また、利用という意味も文脈によって異なる。プログラマの工数、コードの行数、などが尺度として考えられる。ある言語は特定分野のアプリケーションだけでよく使われているということもある。例えばCOBOLは企業のデータセンター（メインフレームであることが多い）では今でも使われているし、FORTRANは科学技術計算でよく使われ、C言語は組み込みシステムやオペレーティングシステムで使われている。

以下のように言語利用状況の尺度は様々であり、どれを選択しても一種のバイアスがかかっていると考えた方がよい。

 プログラマなどの求人広告で言語が言及されている回数Survey of Job advertisements mentioning a given language
 言語に関する書籍（入門書など）の販売部数Counting programming languages by book sales
 言語ごとの既存のコード行数の推計。公開調査で見逃しやすい言語は少なく推定される傾向がある。Bieman, J.M.; Murdock, V., Finding code on the World Wide Web: a preliminary investigation, Proceedings First IEEE International Workshop on Source Code Analysis and Manipulation, 2001
 検索エンジンが見つけた各言語への参照の回数

 実際の指標の例
 TIOBE Index

 プログラミング言語と自然言語
プログラミング言語は人間同士の会話と比較して、正確性と完全性の要求性が非常に高いという特徴がある。自然言語で人間同士が対話する場合、スペルミスや文法的なエラーがあっても相手は状況から適当に補正し、正確な内容を把握する。しかしコンピュータは指示が曖昧では動作せず、プログラマがコードに込めた意図を理解させることはできない。

プログラミングにおけるプログラミング言語の必要性を排除する方法として自然言語によるプログラムが構想されたり提案されることもあるが、その方向性は実用化には達しておらず、議論が続いている。エドガー・ダイクストラは形式言語の使用によって意味のない命令を防ぐという立場で、自然言語によるプログラミングを批判していたDijkstra, Edsger W. On the foolishness of "natural language programming." EWD667.。アラン・パリスも同様の立場であったPerlis, Alan, Epigrams on Programming. SIGPLAN Notices Vol. 17, No. 9, September 1982, pp. 7-13。

このあたりの歴史的に錯綜した議論は、結局のところ「コンピュータを活用するにはプログラミングが必要であり、プログラミングはプログラミング言語で行われる」というある種の教条（ドグマ）が、次の2つの事象に分解されることで無意味な議論になった。すなわち「コンピュータをほどほどに活用する程度のことならば、各種アプリケーションソフトウェアや自然言語認識や自然言語処理技術の活用など（スマートスピーカーなど）により、利用者が自分でプログラミングすることは必ずしも必要ではなくなった」ということと「コンピュータのより徹底した活用、具体的にはそういった自然言語認識や自然言語処理のシステムそのものを作るには、プログラミングが必要ということは全く相変わらずであり、プログラミング言語の重要性は増えこそすれ、減りはしない」ということである。

自然言語との違い
プログラミング言語は、もともと人間がコンピュータに命令を伝えその実行方法を指示するために作られたものであり、コンピュータが曖昧さなく解析できるように設計されている。多くの場合構文上の間違いは許されず、人間はプログラミング言語の文法に厳密にしたがった文を入力しなければならない。

これに対して、一般に自然言語の文法規則はプログラミング言語にくらべてはるかに複雑であり、例外も多い。ただしこれは規則が一般にいいかげんであったり、曖昧であるということではない。一般に自然言語の規則は奥が深く、驚くほどの非合理性に裏打ちされていることもあれば、驚くほどの合理性に裏打ちされていることもある。驚くほどの非合理性でも合理性でもないものに裏打ちされていることもあれば、驚くほどの裏打ちの無さがあることもある。

また、自然言語の意味は、その文脈（コンテキスト）によって定まる部分も多い。これに対して、プログラミング言語は、コンピュータによって扱いやすいように、文脈によって意味が変わることができるだけないように設計されているが、その文脈によって定まる部分がある場合も無くはない。たいていの言語にいくつかはある。

自然言語は、誤用や流行などにより長い時間をかけ、たくさんの人間の利用により、意図せざる形で変化していく。しかし、プログラミング言語の規則は、言語設計者の意図と作業によってのみ、変更される。実際には言語設計者が「たくさんの人間」である場合もあり（仕様が簡単な言語であれば多くの実装者がいることも多く、そういう場合は個々の実装ごとのその仕様があるとも言える）、長い時間をかけ、自然言語と全く同様にたくさんの人間の利用により変化してきたプログラミング言語もある（Lispなど）。また、プログラミング言語にも同様に流行があり、もともとの言語仕様では規定が無かったような一種の「誤用」に、後から仕様が定められる、といったことも必ずしも珍しくはない。

人間がふだん使っている日本語などの自然言語を使ってコンピュータに指示することができるのが理想ではある、と空想する者もいる。しかし、自然言語はあまりにも複雑で曖昧で変則的なので、それを機械語にコンパイルできるようなプログラムを作成することはとても難しい（コンパイルできるできないの問題ではなく、そもそもその意味が「複雑で曖昧で変則的」であること自体が問題なのだが、それを理解できない者が冒頭のように空想するのである）。そのような研究も進められているが、未だに汎用で実用になるプログラムは作成されたことがない。

そこで、自然言語よりも制限が強く、単純で厳密で規則的な人工言語を作って代用する。これがプログラミング言語である。プログラミング言語は自然言語よりもいくらか人間には扱いづらいが、機械語よりは遥かに親しみやすく、人間の指示の手間を軽減している。ちなみにコンピュータ向けの形式性と人間向けの柔軟性を兼ね備えるロジバンなど、本来の開発目的が違えど潜在的に一つのプログラミング言語として機能しうるものもある。

大部分のプログラミング言語は、基本的には概ね文脈自由文法に沿っているが、プログラミング言語における文法的な制限は必ずしも全て文脈自由文法で表現できるとは限らず、文脈自由文法より制限されていることもあれば文脈自由文法より拡張されていることもあり、多くの場合は文脈自由文法には完全には沿っていない。

なおプログラミングへの応用も想定して設計されたロジバンのように、人間の言語とプログラミング言語の中間に位置するものがある。

日本語における名称
古い規格ではあるが日本産業規格の JIS X 3000 シリーズの規格名称では、全て「プログラム言語」になっている（例： JIS X 3001 プログラム言語 Fortran、JIS X 3014 プログラム言語 C++）ため、それに合わせてプログラム言語と表記されることもあるが、英語では programming language であるため、それに合わせればプログラミング言語となり、近年ではプログラミング言語と表記されることが多い。1960年代、JISでは「プログラム言語」の訳語が用いられた（JIS C 6201-1967「電子計算機プログラム言語FORTRAN」）。このためプログラム言語としている例もJISをはじめとして広く見られるが、英フレーズ programming language に当てる語として

なお言語名が「C」や「D」のように1文字の名称の場合、そのままの表記では文章中に埋没してしまい判別しづらいなどの不都合がある場合もあるので、たとえ登録されている正式名称があくまで「C」などと一文字であっても、通常の文章中で表記する場合は、技術書なども含めて、しばしば「C言語」などと文字の後ろに「言語」を添えて表記される。

 他

 参考文献

Daniel P. Friedman, Mitchell Wand, Christopher Thomas Haynes: Essentials of Programming Languages, The MIT Press 2001.
David Gelernter, Suresh Jagannathan: Programming Linguistics, The MIT Press 1990.
Shriram Krishnamurthi: Programming Languages: Application and Interpretation, オンライン版.
Bruce J. MacLennan: Principles of Programming Languages: Design, Evaluation, and Implementation, Oxford University Press 1999.
John C. Mitchell: Concepts in Programming Languages, Cambridge University Press 2002.
Benjamin C. Pierce: Types and Programming Languages, The MIT Press 2002.
Ravi Sethi: Programming Languages: Concepts and Constructs, 2nd ed., Addison-Wesley 1996.
Michael L. Scott: Programming Language Pragmatics, Morgan Kaufmann Publishers 2005.
Richard L. Wexelblat (ed.): History of Programming Languages, Academic Press 1981.

 脚注

 注釈

 出典

 関連項目
 プログラミング言語一覧

 外部リンク
 - プログラミング言語の番付け
99 Bottles of Beer 同じプログラムを多数の言語で実装したコードを公開
Computer Languages History graphical chart
Dictionary of Programming Languages
History of Programming Languages (HOPL)
Open Directory - Computer Programming Languages
Syntax Patterns for Various Languages
The Evolution of Programming Languages by Peter Grogono
JIS(日本産業規格）X3（プログラム言語）

*
Category:コンピュータ言語
Category:プログラミング

and

A system of precisely defined symbols and rules devised for writing computer programs.

It was often referred to as a programming language.

Flex your word muscles and improve your language and writing skills with a bit of fun.
Does today's Wordle have you STUCK? Wordle Solver can help!TRY IT NOW!
Daily puzzles that are always free.START & SOLVE
How many words can you make with 8 letters?PLAY NOW
All the learning tools you need to level up your knowledge for studying and test preparation.
Find the latest Words of the Day here!
How familiar are you with zodiac signs?
Study these words to help you ace the SAT Writing & …
SIGN UP FOR A VOCABULARY BOOST IN YOUR EMAIL
Learn more with the stories we've written about our words, the origins of our language, and the nuances that make English complicated and so unique.
In Dictionary.com's modern language section, we're constantly documenting the meanings of slang, emoji, and new words as soon as you all start saying them.
The ultimate slang dictionary for words you don’t know, don’t understand, or don’t want to know.READ MORE TERMS
A guide for how to use popular emoji (beware: the meanings are always changing!).EXPLORE MORE EMOJI
Identity is fluid, and so is the language around it.FIND MORE TERMS
Dictionary.com is the world's leading online source for definitions, word origins, and a whole lot more. From Word of the Day to the stories behind today's slang, Dictionary.com unlocks the secrets of the English language for millions of people.
WORD OF THE DAY
WORD OF THE YEAR
CROSSWORD & SOLVER
EVERYTHING AFTER Z
THESAURUS.COM
SCRABBLE® WORD FINDER
ALEXA SKILL

Question: what is a system of precisely defined symbols and rules devised for writing computer programs referred to

and

A system of precisely defined symbols and rules devised for writing computer programs.

It was often referred to as a programming language.

Question: what was the system of symbols and rules devised for

and

what was the system of symbols and rules devised for

Question: what was the purpose of the programming language

and

what was the purpose of the programming language

Question: what is the purpose of programming language

and

what is the purpose of programming language

A system of precisely defined symbols and rules devised for writing computer programs .

It was often referred to as a programming language .

。 コンピュータプログラムを書くために考案された、正確に定義された記号と規則のしくみLexico, definition of programming language. A system of precisely defined symbols and rules devised for writing computer programs.。 以前はしばしばプログラム言語と表記された。

以前はしばしばプログラム言語と表記された。

and A system of precisely defined symbols and rules devised for writing computer programs. It was often referred to as a programming language.

A system of precisely defined symbols and rules devised for writing computer programs.

It was often referred to as a programming language.

and

以前はしばしばプログラム言語と表記された。

Examples of Interpreter language can be referred to as PHP and Ruby.

Question: what are two examples of interpreter language

Examples of Interpreter language can be referred to as PHP and Ruby.

what are two examples of interpreter language

Question: what is a way to classify programming languages by running methods

分類 法 と し て は 、 実行 方法 に よっ て プログラミング 言語 を 分類 する 方法

what is a way to classify programming languages by running methods

Question: what is an example of an interpreter language

what is an example of an interpreter language

Question: what does c++ stand for

言語 を 分類 する 方法 も あり 、 インタープリタ 方式 言語 / コンパイラ

Question: what is another term for interpreter

言語 を 分類 する 方法 も あり 、 インタープリタ 方式 言語 / コンパイラ

Question: what is another way to classify programming languages

プログラミング 言語 を 分類 する 方法 も あり 、 インタープリタ 方式 言語 / コンパイラ

what is another way to classify programming languages

Other classification methods include a way to classify programming languages by running methods , and a way to classify them as an interpreter / compiler language ( compiler language ) .

Examples of Interpreter language can be referred to as PHP and Ruby .

他の分類法としては、実行方法によってプログラミング言語を分類する方法もあり、インタープリタ方式言語 / コンパイラ方式言語（コンパイル方式言語）と分類する方法である。

インタープリタ方式言語の例としてはPHPやRubyを挙げることができる。

Other classification methods include a way to classify programming languages by running methods, and a way to classify them as an interpreter/compiler language (compiler language). Examples of Interpreter language can be referred to as PHP and Ruby.

Examples of Interpreter language can be referred to as PHP and Ruby.

In the past, the method of classification was often used for human purposes.

Question: what is an example of office calculation programming languages

In the past, the method of classification was often used for human purposes.

what is an example of office calculation programming languages

Question: what is a science and technology calculation programming language

what is a science and technology calculation programming language

Question: what is an example of science and technology calculation programming languages

what is an example of science and technology calculation programming languages

Question: when was cobol written as an example of office calculation programming languages

- 1980 年 代 など は 「 事務 計算 用 プログラミング 言語 の 例 は COBOL で 、 科学 技術 計算 用 プログラミング 言語 の

when was cobol written as an example of office calculation programming languages

Question: what was used in the past for human purposes

する 方法 も しばしば 用い られ た こと が

what was used in the past for human purposes

Question: what is the method used to classify programming languages

what is the method used to classify programming languages

Question: what was used for human purposes in the past

人間 側 の 用途 で 分類 する 方法 も しばしば 用い られ た こと が

what was used for human purposes in the past

Question: what programming languages are fortran

Science and Technology computing programming languages

科学 技術 計算 用 プログラミング 言語

Science and Technology computing programming languages

In the past , the method of classification was often used for human purposes .

For instance , it is a way to classify as multi - purpose programming languages / Office computing programming languages / Science and Technology computing programming languages etc .

The 1970s and 1980s were written as “ examples of office calculation programming languages are COBOL , and for example of science and technology calculation programming languages are FORTRAN ” , but in recent years such classification has not been much .

かつては人間側の用途で分類する方法もしばしば用いられたことがある。 たとえば、汎用プログラミング言語 / 事務計算用プログラミング言語/ 科学技術計算用プログラミング言語 などと分類する方法である。 1970年代-1980年代などは「事務計算用プログラミング言語の例はCOBOLで、科学技術計算用プログラミング言語の例はFORTRAN」などと書かれたが、近年ではそのような分類はあまりされなくなった。

かつては人間側の用途で分類する方法もしばしば用いられたことがある。

たとえば、汎用プログラミング言語 / 事務計算用プログラミング言語/ 科学技術計算用プログラミング言語 などと分類する方法である。

1970年代-1980年代などは「事務計算用プログラミング言語の例はCOBOLで、科学技術計算用プログラミング言語の例はFORTRAN」などと書かれたが、近年ではそのような分類はあまりされなくなった。

In the past, the method of classification was often used for human purposes. For instance, it is a way to classify as multi-purpose programming languages/Office computing programming languages/Science and Technology computing programming languages etc. The 1970s and 1980s were written as “examples of office calculation programming languages are COBOL, and for example of science and technology calculation programming languages are FORTRAN”, but in recent years such classification has not been much.

In the past, the method of classification was often used for human purposes.

In the 1940s, the world’s first electronic digital computer group was produced.

At the beginning of the 1950s, computer UNIVAC I and IBM 701 used mechanical language.

Mechanical language programming was soon replaced by assembly language programming.

The punches are interpreted across the top line of the card; this is a feature of the key punch and it works as long as there's a good ribbon. OS JCL Job-card fields are preprinted on the card. Columns 73-80 are reserved for sequence numbers, which can be used by a sorter to put a deck back in order after it has been dropped.
Here is a card punched on keypunch that either had no interpreter, or a broken one, or whose ribbon was dry. The diagonal cut on the upper left facilitates proper orientation of the card (if the card is fed into the reader upside down or face down the data will be misinterpreted). When all the cards in a deck of the corner cut, misoriented cards will stick out.
Here's another customized card (without punches), this one from the University of Karlsruhe (Germany) Computer Center, courtesy of Michael Hartmann, Technische Universität München:
|Language||Link||Date||Translator||Organization|
|German||Deutsch||2021/02/25||Laura Fields||Essayexaminer|
|Norwegian||Norsk||2021/10/31||Stian Skjelbred||Strøm24.no|
|Russian||Русский||2021/12/28||Anonymous||E-ITA|
|Swedish||Swedish||2021/10/31||Peter Torman||https://volantaroma.se/|
|Ukrainian||Українська||2021/09/16||Ann Sole||PapersOwl|
|Columbia University Computing History||Frank da Cruz / fdc@columbia.edu||This page created: January 2001||Last update: 28 December 2021|

Question: what replaced mechanical language programming

アセンブリ 言語 に よる プログラミング

In the 1940s, the world’s first electronic digital computer group was produced.

At the beginning of the 1950s, computer UNIVAC I and IBM 701 used mechanical language.

Mechanical language programming was soon replaced by assembly language programming.

what replaced mechanical language programming

Question: when was the first electronic digital computer group created

when was the first electronic digital computer group created

Question: what type of programming did univac i and ibm 701 use

what type of programming did univac i and ibm 701 use

Question: when was the first electronic digital computer created

when was the first electronic digital computer created

Question: what was replaced by assembly language programming

プログラミング は 、 間 も なく アセンブリ 言語 に よる プログラミング

what was replaced by assembly language programming

Question: what computers used mechanical language at the beginning of the 1950s

what computers used mechanical language at the beginning of the 1950s

Question: what type of computer was produced in the 1940s

電子 式 デジタル コンピュータ 群

what type of computer was produced in the 1940s

In the 1940s , the world ’s first electronic digital computer group was produced .

At the beginning of the 1950s , computer UNIVAC I and IBM 701 used mechanical language .

Mechanical language programming was soon replaced by assembly language programming .

1940年代、世界初の電子式デジタルコンピュータ群が製作された。 1950年代初期のコンピュータであるUNIVAC IやIBM 701では機械語を使っていた。 機械語によるプログラミングは、間もなくアセンブリ言語によるプログラミングに取って代わられた。

1940年代、世界初の電子式デジタルコンピュータ群が製作された。

1950年代初期のコンピュータであるUNIVAC IやIBM 701では機械語を使っていた。

機械語によるプログラミングは、間もなくアセンブリ言語によるプログラミングに取って代わられた。

In the 1940s, the world’s first electronic digital computer group was produced. At the beginning of the 1950s, computer UNIVAC I and IBM 701 used mechanical language. Mechanical language programming was soon replaced by assembly language programming.

In the 1940s, the world’s first electronic digital computer group was produced.

At the beginning of the 1950s, computer UNIVAC I and IBM 701 used mechanical language.

Mechanical language programming was soon replaced by assembly language programming.

APL - the language introduced in serial programming.

Richard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV.

PL/I (NPL) - Designed in the early 1960s, incorporating the advantages of FORTRAN and COBOL.

Question: what is the name of the programming language introduced in serial programming

APL - the language introduced in serial programming.

Richard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV.

PL/I (NPL) - Designed in the early 1960s, incorporating the advantages of FORTRAN and COBOL.

what is the name of the programming language introduced in serial programming

Question: what advantages did pl/i incorporate

Question: when was the history of programming languages published

when was the history of programming languages published

Question: when was pl/i created

Question: what is apl used for

Question: who is the author of the history of programming languages

who is the author of the history of programming languages

Question: which programming language was designed in the 1960s using the advantages of fortran and

which programming language was designed in the 1960s using the advantages of fortran and

APL - the language introduced in serial programming .

Richard L. Wexelblat : History of Programming Languages , Academic Press , 1981 , chapter XIV .

PL / I ( NPL ) - Designed in the early 1960s , incorporating the advantages of FORTRAN and COBOL .

APL - 配列プログラミングを導入した言語。 関数型プログラミングにも影響を与えたRichard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV.。 PL/I (NPL) - FORTRANとCOBOLの長所を取り入れて1960年代初期に設計された。

APL - 配列プログラミングを導入した言語。

PL/I (NPL) - FORTRANとCOBOLの長所を取り入れて1960年代初期に設計された。

APL - the language introduced in serial programming. Richard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV. PL/I (NPL) - Designed in the early 1960s, incorporating the advantages of FORTRAN and COBOL.

APL - the language introduced in serial programming.

Richard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV.

PL/I (NPL) - Designed in the early 1960s, incorporating the advantages of FORTRAN and COBOL.

The 1960s and 1970s were a period of debate about structuralized programming.

Question: who wrote the letter go to statement considered harmful

エドガー ・ ダイクストラ

The 1960s and 1970s were a period of debate about structuralized programming.

who wrote the letter go to statement considered harmful

Question: when was edgar dixtra's letter published

when was edgar dixtra's letter published

Question: the 1960s and 1970s were a period of debate about what

the 1960s and 1970s were a period of debate about what

Question: when was the debate about structuralized programming

と 1970 年 代 は 、 構造 化 プログラミング に 関する 論争 が 盛ん に

when was the debate about structuralized programming

Question: where was edgar dixtra's letter published

where was edgar dixtra's letter published

Question: in what decade was there a debate about structuralized programming

in what decade was there a debate about structuralized programming

Question: who published the go to statement considered harmful

who published the go to statement considered harmful

The 1960s and 1970s were a period of debate about structuralized programming .

What is < unk > famous in this debate will be the 1968 Edgar Dixtra 's letter Go To Statement Considered Harmful , published in Communications of the ACM .

1960年代と1970年代は、構造化プログラミングに関する論争が盛んに行われた時期でもある。 この論争で特に有名なものは、1968年にCommunications of the ACMに掲載されたエドガー・ダイクストラのレターGo To Statement Considered Harmfulであろう。

1960年代と1970年代は、構造化プログラミングに関する論争が盛んに行われた時期でもある。

The 1960s and 1970s were a period of debate about structuralized programming. What is<unk> famous in this debate will be the 1968 Edgar Dixtra's letter Go To Statement Considered Harmful, published in Communications of the ACM.

The 1960s and 1970s were a period of debate about structuralized programming.

The integration and growth of the 1980s were a period of relative integration.

C++ is an integration of object orientation and system programming.

In the United States, a system programming language called ADA was standardized for military use.

Question: what is the name of the system programming language for military use

The integration and growth of the 1980s were a period of relative integration.

C++ is an integration of object orientation and system programming.

In the United States, a system programming language called ADA was standardized for military use.

what is the name of the system programming language for military use

Question: what is c++ an integration of

object orientation and system programming

オブジェクト 指向 と システム プログラミング

object orientation and system programming

Question: what is an integration of object orientation and system programming

what is an integration of object orientation and system programming

Question: when did the integration and growth of c++ occur

when did the integration and growth of c++ occur

Question: for what purpose was ada standardized

Question: the integration and growth of the 1980s were a period of what

the integration and growth of the 1980s were a period of what

The integration and growth of the 1980s were a period of relative integration .

C++ is an integration of object orientation and system programming .

In the United States , a system programming language called ADA was standardized for military use .

統合と成長 1980年代は、相対的な統合の時代であった。 C++は、オブジェクト指向とシステムプログラミングの統合である。 アメリカでは、軍需に使うことを目的としてAdaというシステムプログラミング言語が標準化された。

統合と成長 1980年代は、相対的な統合の時代であった。

C++は、オブジェクト指向とシステムプログラミングの統合である。

アメリカでは、軍需に使うことを目的としてAdaというシステムプログラミング言語が標準化された。

The integration and growth of the 1980s were a period of relative integration. C++ is an integration of object orientation and system programming. In the United States, a system programming language called ADA was standardized for military use.

The integration and growth of the 1980s were a period of relative integration.

C++ is an integration of object orientation and system programming.

In the United States, a system programming language called ADA was standardized for military use.

Other languages are specified in the following styles:

Formal syntax and semantics
This chapter provides formal descriptions of what has already been described informally in previous chapters of this report.
This section provides a formal syntax for Scheme written in an extended BNF.
All spaces in the grammar are for legibility. Case is insignificant; for example, #x1A and #X1a are equivalent. <empty> stands for the empty string.
The following extensions to BNF are used to make the description more concise: <thing>* means zero or more occurrences of <thing>; and <thing>+ means at least one <thing>.
This section describes how individual tokens (identifiers, numbers, etc.) are formed from sequences of characters. The following sections describe how expressions and programs are formed from sequences of tokens.
<Intertoken space> may occur on either side of any token, but not within a token.
Tokens which require implicit termination (identifiers, numbers, characters, and dot) may be terminated by any <delimiter>, but not necessarily by anything else.
The following five characters are reserved for future extensions to the
language:
[
]
{
}
|
The following rules for <num R>, <complex R>, <real R>, <ureal R>, <uinteger R>, and <prefix R> should be replicated for R = 2, 8, 10, and 16. There are no rules for <decimal 2>, <decimal 8>, and <decimal 16>, which means that numbers containing decimal points or exponents must be in decimal radix.
<Datum> is what the read procedure (section 6.6.2) successfully parses. Note that any string that parses as an <expression> will also parse as a <datum>.
The following grammar for quasiquote expressions is not context-free. It is presented as a recipe for generating an infinite number of production rules. Imagine a copy of the following rules for D = 1, 2, 3, .... D keeps track of the nesting depth.
In <quasiquotation>s, a <list qq template D> can sometimes be confused with either an <unquotation D> or a <splicing unquotation D>. The interpretation as an <unquotation> or <splicing unquotation D> takes precedence.
This section provides a formal denotational semantics for the primitive expressions of Scheme and selected built-in procedures. The concepts and notation used here are described in [29]; the notation is summarized below:
The reason that expression continuations take sequences of values instead of single values is to simplify the formal treatment of procedure calls and multiple return values.
The boolean flag associated with pairs, vectors, and strings will be true for mutable objects and false for immutable objects.
The order of evaluation within a call is unspecified. We mimic that here by applying arbitrary permutations permute and unpermute, which must be inverses, to the arguments in a call before and after they are evaluated. This is not quite right since it suggests, incorrectly, that the order of evaluation is constant throughout a program (for any given number of arguments), but it is a closer approximation to the intended semantics than a left-to-right evaluation would be.
The storage allocator new is implementation-dependent, but it must obey the following axiom: if new L, then (new | L) 2 = false.
The definition of is omitted because an accurate definition of would complicate the semantics without being very interesting.
If P is a program in which all variables are defined before being referenced or assigned, then the meaning of P is
where I* is the sequence of variables defined in P, P' is the sequence of expressions obtained by replacing every definition in P by an assignment, <undefined> is an expression that evaluates to undefined, and is the semantic function that assigns meaning to expressions.
Definition of deliberately omitted.
Here and elsewhere, any expressed value other than undefined may be used in place of unspecified.
This section gives macro definitions for the derived expression types in terms of the primitive expression types (literal, variable, call, lambda, if, set!). See section 6.4 for a possible definition of delay.
(define-syntax cond
(syntax-rules (else =>)
((cond (else result1 result2 ...))
(begin result1 result2 ...))
((cond (test => result))
(let ((temp test))
(if temp (result temp))))
((cond (test => result) clause1 clause2 ...)
(let ((temp test))
(if temp
(result temp)
(cond clause1 clause2 ...))))
((cond (test)) test)
((cond (test) clause1 clause2 ...)
(let ((temp test))
(if temp
temp
(cond clause1 clause2 ...))))
((cond (test result1 result2 ...))
(if test (begin result1 result2 ...)))
((cond (test result1 result2 ...)
clause1 clause2 ...)
(if test
(begin result1 result2 ...)
(cond clause1 clause2 ...)))))
(define-syntax case
(syntax-rules (else)
((case (key ...)
clauses ...)
(let ((atom-key (key ...)))
(case atom-key clauses ...)))
((case key
(else result1 result2 ...))
(begin result1 result2 ...))
((case key
((atoms ...) result1 result2 ...))
(if (memv key '(atoms ...))
(begin result1 result2 ...)))
((case key
((atoms ...) result1 result2 ...)
clause clauses ...)
(if (memv key '(atoms ...))
(begin result1 result2 ...)
(case key clause clauses ...)))))
(define-syntax and
(syntax-rules ()
((and) #t)
((and test) test)
((and test1 test2 ...)
(if test1 (and test2 ...) #f))))
(define-syntax or
(syntax-rules ()
((or) #f)
((or test) test)
((or test1 test2 ...)
(let ((x test1))
(if x x (or test2 ...))))))
(define-syntax let
(syntax-rules ()
((let ((name val) ...) body1 body2 ...)
((lambda (name ...) body1 body2 ...)
val ...))
((let tag ((name val) ...) body1 body2 ...)
((letrec ((tag (lambda (name ...)
body1 body2 ...)))
tag)
val ...))))
(define-syntax let*
(syntax-rules ()
((let* () body1 body2 ...)
(let () body1 body2 ...))
((let* ((name1 val1) (name2 val2) ...)
body1 body2 ...)
(let ((name1 val1))
(let* ((name2 val2) ...)
body1 body2 ...)))))
The following letrec macro uses the symbol <undefined> in place of an expression which returns something that when stored in a location makes it an error to try to obtain the value stored in the location (no such expression is defined in Scheme). A trick is used to generate the temporary names needed to avoid specifying the order in which the values are evaluated. This could also be accomplished by using an auxiliary macro.
(define-syntax letrec
(syntax-rules ()
((letrec ((var1 init1) ...) body ...)
(letrec "generate_temp_names"
(var1 ...)
()
((var1 init1) ...)
body ...))
((letrec "generate_temp_names"
()
(temp1 ...)
((var1 init1) ...)
body ...)
(let ((var1 <undefined>) ...)
(let ((temp1 init1) ...)
(set! var1 temp1)
...
body ...)))
((letrec "generate_temp_names"
(x y ...)
(temp ...)
((var1 init1) ...)
body ...)
(letrec "generate_temp_names"
(y ...)
(newtemp temp ...)
((var1 init1) ...)
body ...))))
(define-syntax begin
(syntax-rules ()
((begin exp ...)
((lambda () exp ...)))))
The following alternative expansion for begin does not make use of the ability to write more than one expression in the body of a lambda expression. In any case, note that these rules apply only if the body of the begin contains no definitions.
(define-syntax begin
(syntax-rules ()
((begin exp)
exp)
((begin exp1 exp2 ...)
(let ((x exp1))
(begin exp2 ...)))))
The following definition of do uses a trick to expand the variable clauses. As with letrec above, an auxiliary macro would also work. The expression (if #f #f) is used to obtain an unspecific value.
(define-syntax do
(syntax-rules ()
((do ((var init step ...) ...)
(test expr ...)
command ...)
(letrec
((loop
(lambda (var ...)
(if test
(begin
(if #f #f)
expr ...)
(begin
command
...
(loop (do "step" var step ...)
...))))))
(loop init ...)))
((do "step" x)
x)
((do "step" x y)
y)))

Question: what languages describe the significance in the formal meaning theory

Other languages are specified in the following styles:

what languages describe the significance in the formal meaning theory

Question: standard ml and scheme describe the significance in what

論 （ プログラム 意味 論 の 記事 も 参照 ） で 意味 論 を 記述 し た 例 と し て Standard ML や Scheme が

standard ml and scheme describe the significance in what

Question: what language describes the significance in the formal meaning theory

what language describes the significance in the formal meaning theory

Question: what is the article that describes the significance of formal meaning theory

意味 論 （ プログラム

what is the article that describes the significance of formal meaning theory

Question: what language is used in the formal meaning theory

what language is used in the formal meaning theory

Question: where can you find the formal meaning theory

the article of the Program Meaning Theory

意味 論 （ プログラム 意味 論 の 記事

the article of the Program Meaning Theory

where can you find the formal meaning theory

For example , Standard ML and Scheme describe the significance in the Formal Meaning Theory ( see also the article of the Program Meaning Theory ) .

Other languages are specified in the following styles :

形式意味論（プログラム意味論の記事も参照）で意味論を記述した例として Standard ML や Scheme がある。 その他 他に、以下のようなスタイルで仕様が与えられている言語もある。

形式意味論（プログラム意味論の記事も参照）で意味論を記述した例として Standard ML や Scheme がある。

その他 他に、以下のようなスタイルで仕様が与えられている言語もある。

For example, Standard ML and Scheme describe the significance in the Formal Meaning Theory (see also the article of the Program Meaning Theory). Other languages are specified in the following styles:

Other languages are specified in the following styles:

The languages that are easily missed in public surveys tend to be less predicted.

SSL/Computer Weekly IT salary survey: finance boom drives IT job growth
The second quarter of 2007 was the best for IT job-seekers for several years, with double-digit growth in the full-time and freelance jobs markets. The number of permanent advertised jobs was up 13% on the same period in 2006, and there were 18% more contract positions on offer, according to the Computer Weekly Survey of Appointments Data and Trends compiled by Salary Services Limited (SSL).
The second quarter of 2007 was the best for IT job-seekers for several years, with double-digit growth in the full-time and freelance jobs markets. The number of permanent advertised jobs was up 13% on the same period in 2006, and there were 18% more contract positions on offer, according to the Computer Weekly Survey of Appointments...
Continue Reading This Article
Enjoy this article as well as all of our content, including E-Guides, news, tips and more.
Data and Trends compiled by Salary Services Limited (SSL).
"We are seeing a continuingly buoyant market in all respects," says Paul Smith, development director at recruitment firm Harvey Nash Group.
The money on offer to job-seekers also increased. Salaries for permanent staff rose by 2.6% on average. This does not sound much, but it is the first time that a rise above 2% has been recorded in five quarters. This salary increase is remarkably constant across all 55 job positions surveyed.
Average rates offered to freelancers also increased by 2.6%, the same amount as in the first quarter. Here, some professionals did fare better than others. The average rate for systems analysts rose by 8% - from £38 per hour to £41 - and for programmers by 19% - from £31 to £37.
The average increases are just above the government's Consumer Price Index inflation rate figure of 2.4%, although they do not match average wage inflation across all industries of between 4% and 5%.
The increase in advertised jobs was not uniform across the whole economy. The finance sector is booming, but the manufacturing industry is recruiting fewer people than a year ago.
What is not apparent from the SSL figures is a relative decline in recruitment by the larger corporations. "Medium companies and their IT departments are experiencing much more growth," Smith says.
Permanent staff
In the permanent IT jobs market, it is the rise in demand for PC support staff that is most notable, as this has been a relatively depressed area for several years. Jobs advertisements here were up by nearly 50% on a year ago.
Demand for technical support staff was also up - by about 33% - and there was an increase in advertising for management positions. The number of positions advertised for development and systems staff rose by less than the average. All of this suggests that IT departments are consolidating after a period of development new systems are in place, and the emphasis is now on getting them to work effectively.
Geographically, demand for permanent staff rose most in central London, which was the only area to show double-digit growth. Outer London and the South also showed gains, and these three areas accounted for nearly 66% of all permanent jobs on offer.
The West Midlands, North West, Scotland and Northern Ireland missed out on the market upturn, with the number of permanent jobs on offer down by about 15% on a year ago.
Growth in London is fuelled by the finance industry, which the fastest-growing sector for IT jobs, with the number advertised up by 25%.
The public sector is continuing to recruit permanent staff, despite the maturing of the NHS IT programme and several other major projects. All other industry sectors showed some growth, except manufacturing, which was slightly down on a year ago.
All of these figures relate to job advertising on the web. IT advertising in newspapers and magazines continues to decline, and was down by more than a third on the second quarter of last year. It is now at its lowest level since the end of 2004.
Contractors
In the contract market, the fact that there was a rise at all is significant, as there had been a decline in the first quarter. A rise as high as 18% is very encouraging.
A close examination of the figures shows that the freelance market differs significantly from the permanent jobs market in some respects. Development positions increased by more than twice the average, as did those for database specialists, but demand for PC support and technical support personnel rose by less than the average.
Geographically, demand for contractors rose most in Wales, Scotland and Northern Ireland. Freelance positions in these areas were up by more than half as much again as a year ago. Contract positions in London were up by 25%, following a significant decline in the first quarter of 2007. All areas showed a rise in contract positions on the same period in 2006.
However, several industry sectors rose by less than a year ago. They included the public sector, where demand was down by 19%. This is a sign of a return to stability after the frenetic activity in several large government contracts over the past few years.
The manufacturing industry slashed recruitment of contractors by an even great amount, almost 25%, and this was mirrored in the electronics and communications sector.
Once again it was the finance houses that provided the biggest growth, with demand up by more than 50% on a year ago.
Skills
As far as in-demand skills go, the picture is generally static. The top 14 skills in the second quarter are the same as in the first quarter, and there were only two positional changes: a decline for C++, explained by a transfer of demand to C#, and a rise for SQL Server.
Comparing this year's positions with those of a year ago illustrates the trend of an increasing preference for Microsoft development methodology at the expense of Java, with both steadily displacing the Unix client-server choice of the late 1990s.
"Our development used to be 50-50 Microsoft and Java, now it is 70% Microsoft. That change has happened over 18 months," Smith says.
This change is made apparent in the league table by the growth in demand for SQL Server. This quarter it has risen above Oracle for the first time and is now in its highest-ever position of fifth. The next two positions are occupied by C# and .net, and all three are showing well above average growth of 25% on a year ago, as is ASP.
In contrast, demand for Java rose by 4%, and there was 1% less advertising for J2EE experience than a year ago.
The requirement for Unix skills fell by 13%, and by 16% for the most popular of the proprietary versions, Solaris. Interest in Linux increased slightly. The traditional Unix software packages are also falling away. Demand for Oracle rose, but by less than the average, and interest in Sybase fell 16%.
These figures paint a picture of a swing away from Unix, with some users migrating to open source but a larger number opting for the Microsoft alternative.
how the survey is conducted
This article is based on information from the Computer Weekly/SSL Quarterly Survey of Appointments Data and Trends.
The survey analyses ads for IT professionals on the web, in the trade press, and the quality national dailies and Sundays. It is intended primarily for recruitment agencies and CIOs with a substantial recruitment requirement.
The posts are broken down into 55 categories, which include details of the number of posts advertised and the average and median national salaries offered for the past five quarters.
The survey provides further analyses within each job category by platform type, industry sector and regional location. It also gives a breakdown of the technical skills most in demand.
The survey costs £250 per issue or £350 for an annual subscription. This covers four issues, and includes a free software program, which allows selection of combinations of region, industry and software skills for specified job types. You can order it at www.salaryservices.co.uk.

Question: what is a survey of

The languages that are easily missed in public surveys tend to be less predicted.

Question: what happens to languages that are easily missed in public surveys

what happens to languages that are easily missed in public surveys

Question: where does the term programming languages come from

where does the term programming languages come from

Question: what is counted by book sales

programming languages by book sales 言語 ごと の 既存 の コード 行数 の

Question: numbers of books sold in a survey

Question: what is an estimate of

Question: what is an estimate of programming languages by book sales

what is an estimate of programming languages by book sales

Question: what is an estimate of existing programming languages

what is an estimate of existing programming languages

Survey of Job advertisements mentioning a given language Number of sales of books ( such as entries ) Counting programming languages by book sales An estimate of the existing code lines per language .

The languages that are easily missed in public surveys tend to be less predicted .

プログラマなどの求人広告で言語が言及されている回数Survey of Job advertisements mentioning a given language 言語に関する書籍（入門書など）の販売部数Counting programming languages by book sales 言語ごとの既存のコード行数の推計。 公開調査で見逃しやすい言語は少なく推定される傾向がある。

公開調査で見逃しやすい言語は少なく推定される傾向がある。

Survey of Job advertisements mentioning a given language Number of sales of books (such as entries) Counting programming languages by book sales An estimate of the existing code lines per language. The languages that are easily missed in public surveys tend to be less predicted.

The languages that are easily missed in public surveys tend to be less predicted.

Wed
Aug 2
2006
Programming Language Trends
In his presentation at OSCON, Roger Magoulas, the director of O'Reilly Research, provided some interesting graphs based on our trends data mart. Here's the 3-year programming language market share trend based on computer book sales:
I wrote yesterday about the rise of Ruby and Javascript, driven by the move towards Web 2.0 applications. Also worthy of note in these graphs is the long, slow decline of Java and C/C++, and the continuing rise in market share of C#. You can see how Ruby's sharp ascent follows the introduction of Rails, and that PHP's fortunes reversed before book sales showed that web developers in search of rapid development languages moved over to RoR (and Microsoft's ASP.Net suite of technologies.)
Also worth noting on this chart is that book sales tend to spike even before the release of commercial languages, as the vendors work with publishers to get books out by the release date, while books on open source projects tend to trail the release date. On the one hand, you could interpret this as meaning that open source is slower to market, but I think it says the opposite: open source projects can move fast, and catch publishers by surprise. Few publishers expected the quick uptake of
Java AJAX and Ruby on Rails.
tags:
| comments: 44
| Sphere It
submit:
Subscribe to Comments on this Entry:
0 TrackBacks
TrackBack URL for this entry: http://radar.oreilly.com/mt/mt-tb.cgi/8407
Comments: 44
Few publishers expected the quick uptake of Java and Ruby on Rails.
You mean Javascript, right?
The trendline I find most interesting is the one that isn't like any other one, in at least two senses: SQL. It's not a programming language like any of the others, and it's got a slow, steady trend upward.
What makes this particularly interesting is that various BI vendors will tell you that writing SQL by hand is obsolete, since their products will generate it for you. That's an exaggeration with some truth in it--I never want to write a simple reporting rollup again--and a big lie underneath it, as there is always platform-specific optimization to do even for the SQL that the tools will generate. More importantly, they don't really generate everything you want, just the more routine, repeatable stuff.
Anyway, you'd expect SQL books to trend downward, if that it true, but it isn't, so it's no.
I don't suppose there's any data on SQL dialect, is there?
Strikes me that the methodology - although it's the only one easily open to you - is suspect. Suppose people are buying lots of books on C#; does that really correlate with high usage of C#? Personally, if I had some people writing an application for me, I would be happier if their first move was NOT to rush out and buy books about it. I would prefer them to know the language pretty well already.
So, while there will be some correlation, I wonder if the high C# book sales might simply reflect the fact that a lot of developers are trying to learn it, in the expectation that it will be useful sometime in the future. And maybe declining Java book sales imply, to some extent, that there are a lot of Java developers out there who already know the language pretty well.
Lastly, on your measure a language that has frequent major changes or extensions will bulk larger than one that stays pretty much the same. I bet Ada book sales have been higher than usual recently (e.g. 20 rather than 12).
Sorry, I know it's staring me in the face somewhere, but where is COBOL and Fortran et al on this list? How was this particular set of languages chosen for comparison?
- Don
I think this graph is a wonderful future indicator of the skill pool that will be available, and an immediate indicator of the desired languages these skill developers want to work with.
One consequence may be that those developers staying in "declining" languages may find themselves in greater short-medium term demand. There are less Java developers but a consistent/growing amount of work for them to do. The amount of money a Ruby developer might make might be less (say per hour) as there are more developers per available project (even though both numbers are probably increasing).
Speaking of fast writing, when I said:
Anyway, you'd expect SQL books to trend downward, if that it true, but it isn't, so it's no.
I meant to say:
Anyway, you'd expect SQL books to trend downward, if that were true, but it isn't, so it's not.
This is an interesting signal of technology trend. How does the data relate to the number and availability of new titles for a given language? For example, I would expect Ruby to be on the rise in book sales as it is a new language. PHP in contrast has been around for a while, so it may be that the content of a newly written book is not sufficiently different from previous books to justify the purchase (for someone who has purchased previously). In addition there are already many books in circulation that may be shared.
In support of your point about OS and commercial releases, I would think much of that is to do with a commercial organisation having large promotional groups and budgets to do this work.
Is there any data for actual usage of the languages. Also, how does this relate to the availability and quality of free "tutorial" resources online. Would a user of an open source language be more likely to look for information online and free? Are commercial languages more likely to be used in large organisations who may fund the purchase of books?
The other issue is book sales mapping to language complexity. I would expect a lot more java books to be sold based on the level of difficulty of learning the setup/tear down routines required for it vs say a python or ruby language. I mean like heck, I can read doc strings in any python module and pretty much understand the meaning pretty quickly without a lot of 'skill up' beyond the basics. In something like Java I have to understand pretty deep, about 40% of the classes to get anything done.
The other issue with this methodology is book type. What % are language reference vs application/framework? Language reference sales would tell me number of people attempting to understand a language. Framework numbers would tell me the number of people actually using the language day to day. Heck 'XXXXXX for Dummies' sells a hell of a lot of titles. But how many of those actually then write some app in some paid fashion?
That IS the question is it not?
It's interesting to compare this to actual
job listings for some of these languages.
Perrin -- the indeed job data is very hard to read because of the scale. All of these programming languages are basically rounding errors when all you do is show them as a percentage of all jobs.
What you want to do is to show the rate of change. I did this last week in the posting Ruby Book Sales Pass Perl. I showed some treemaps that show that ruby is the only language with an increase in the number of job postings.
I'll post more detailed information later this week, or early next.
The fundamental here is that people are buying less Java books because lots more people know it and don't need to buy books. It doesn't mean Java is in decline.
It'd be interesting to see absolute figures and %s.
Three weaknesses to this measure:
There's also an inherent weakness to this - free online documentation. The best tutorial on languages like python and php are on the web itself; many people skip the books altogether.
Another weakness is that some languages might be easier and/or more intuitive than others, so fewer books are bought for that language.
Yet another weakness is that some languages are often second or third languages learned. Seasoned developers may or may not buy more books.
Are the trends for C and C++ really tied that closely together, or is it deceptive to graph them that way?
Putting AJAX between the first and second quarter of 2005 is open to debate........
Febuary 8 2005 was the debut of the COINING of the term via a publication......
The concept had been was introduced before that time when Microsoft developed XML/http and was growing as Google and Yahoo and others began incorporating that strategy,.......
AJAX as a concept is like Charles Darwin being credited with inventing evolution theory
I don't really scope in that diagram any sharp decline in php interest after the Ruby On Rails release; I spot a decreas in java and c++ interest though. That many people switching from c++ to ruby on rails + javascript? The mind boggles. Can hardly wait for the first ATC system based on those two.
Srini -- Obviously, computer book sales are not an absolute indicator. But they are meaningful. For example, I began my open source activism in 1997 after the buyer at Borders told me that Programming Perl was one of their top 100 books in any category for all of 1996 -- and I realized that no one in the computer trade press was talking about it. Then I realized that all my bestsellers were equally "off the radar."
As to your three factors: I agree that online documentation is a huge factor, but it affects almost all languages equally. Do you really think that the online doc available for PHP is that much better than the online doc for say, Java? Sun and Microsoft have huge online developer education resources.
And yes, novelty is certainly a factor in people buying books. But remember, someone buying Learning Perl or Learning Python or Pragmatic Ruby is in exactly the same position: I want to learn a new language. So which are they choosing?
Donnie -- We made a decision long ago to combine C and C++ because there were so many books that covered both. That might have been a mistake. We should probably go back and disambiguate the two.
Search Engine Web: while the technologies behind AJAX did not exist prior to the coining of the term, that coining (and the introduction of the first significant AJAX apps, like GMail and Google Maps) were what defined the category, and made people rush out to start buying books.
Zingus -- I noted that the decline in PHP had started before the RoR release. I actually think it might have been impacted a bit more strongly by the release of ASP.Net 2.0, and the switch of some big hosting providers as a result.
For your C# and VB books above, are you including only those books with those language names in the titles? Every ASP.NET or ADO.NET book uses on or the other language (or both), but if I understand your methodology correctly won't show up above.
This seems to undercount the C# and VB number considerably. No?
There's also an inherent weakness to this - free online documentation. The best tutorial on languages like python and php are on the web itself; many people skip the books altogether.
I agree to this.
But remember, someone buying Learning Perl or Learning Python or Pragmatic Ruby is in exactly the same position: I want to learn a new language. So which are they choosing?Tim,
Have you broken out the figures on books like that? Learning and beginner books, that is? (I realize there's a certain subjectivity in deciding just what goes into that category.)
I find that Google Trends is an interesting way of showing the popularity of current trends in technology.
How much of these sales are imposed as required texts for students?
If you go to the job trends link and add C and C++ (separately), C graphs higher on the scale.
Where does Coldfusion fit into this list? I have someone who wants to use Coldfusion for a huge project and I cannot find statistics on how much it is utilized in the industry.
DO you only make the research in the O'Reilly?
If so, I think it only shows that O'Reilly publish no good book in c# and no good book in Ajax
John Adams (adamsj) -- re SQL. I've said about Web 2.0, "data is the intel inside." Hal Varian said, "SQL is the new HTML."
Kevin -- the impact of required texts is relatively small. We do see seasonality from text adoption, but it's less pronounced in programming. To the extent that it happens, it primarily benefits Java and C. A lot of the required texts are sold through channels that don't necessarily report to bookscan.
Mike -- ColdFusion would be showing as a flatline at the bottom if we were to graph it. I showed some visualizations that included ColdFusion in my entry a week or two ago, State of the Computer Book Market, Part 2: Category Winners and Losers. If you look at the web development treemap in that posting, you'll see that ColdFusion is a tiny fraction (about 6%) of the size of PHP or ASP.Net (which are neck and neck in the book marketplace), and shrinking.
Anonymous -- No, as explained in the article linked to at the beginning of the post, this data is reported by Nielsen Bookscan, and represents all publishers. Follow the links in the posting to get more details. And as a matter of fact, O'Reilly is the #1 publisher on Ajax, and the #2 publisher on C# behind Microsoft Press. In the Ajax category, we currently have the top three books on Ajax (Head Rush Ajax, Ajax Design Patterns and Ajax Hacks, and if you count our distribution partners (which include Manning and Pragmatic)
I don't mean to disrespect Steve Oullaine or the other authors who have written C++ books for O'Reilly, but with the excellent Addison Wesley C++ In-Depth Series around, I wouldn't expect O'Reilly to sell very many books on the topic.
According to the post that you link to from 2005, sales bottomed out in 2005 - which is also the point at which C/C++ books seem to peak in your graph. Similarly Java falls a faster rate after this point.
This seems to be not due to a sudden decline in interest in those two languages, but because of an increase in interest in other languages.
I expect that C/C++ book sales are mostly independent of Ruby book sales. The two languages are designed for very different uses. Lumping together the book sales of programming languages in this way seems very misleading.
Anonymous -- as noted above (and repeatedly in all my blog posts about this data), these trends are not based on O'Reilly sales only. They are based on point of sale data for all computer books, via Nielsen Bookscan. We do the categorization and analysis, but they collect the data directly from bookstores.
Daniel -- just because sales of Ruby and C are independent doesn't mean that it's not interesting to put them on the same graph. People eat bananas at breakfast or for a snack, and apples and oranges just for a snack, or apples sometimes in pies and oranges in salads, but that doesn't mean we shouldn't graph them together if we're trying to figure out the most widely-consumed fruit.
I wonder if the book sales included text books? CS students probablby learn C, C++ and Java in their undergrad programs and don't have much need for additional books beyond their texts for these languages. At UMBC the texts we use for CS1 and CS2 are not even standard textbooks -- the publisher produces a custom ones for us drawing on material from several other books.
This is a larger version of my favorite technology popularity metric -- shelf-feet at the Border's in Palo Alto.
Ahem... to the person who said Ruby is a new language. It is far from being new, there is just a lot of interest in it related to Rails.
> Also worthy of note in these graphs is the long, slow decline of Java and C/C++
I think someone is seeing what they want to see, not what is there. C/C++ was at the same place from 2003-Q1 to 2005-Q4. That's 3/4 of the graph.
In theory I would show up in the data as "someone switching from C++ to Ruby-on-Rails + Javascript" because I've bought more books on the latter than the former in the past few years. But that's because I'm way more comfortable with C++ than Ruby and Javascript, so the latter is what I'm practicing. Not to mention that "switching from C++ to Javascript" is insanity. They are different tools for different jobs.
I agree with the poster(s) above who noted that this is primarily useful as a leading indicator -- this is what people are learning more about, so it's what they're buying books about. A massive number of people know a ton about Java and use it every day, but it's not as high on the list of things people really want to learn more about as it used to be. Obviously, there are still many, many people learning about Java -- through school, through their job, etc. But the trend is clear.
By contrast to book sales, I expect job listings are more of a trailing indicator, because people getting their feet wet with, say, Ruby aren't necessarily advertising for new hires with Ruby experience. After you have a project underway (or maybe even deployed), you're more likely to look for new hires.
P.S. To echo a previous post, I'd love to see Tim elaborate on how something like "ASP.NET 2.0 Cookbook" is accounted for. It clearly is associated with C# and VB, but doesn't have those languages in its title. Is there any way to get a breakdown with C# + VB + .Net grouped together to see the popularity of .Net in general?
I believe ASP.Net Cookbook counts towards both C# and VB measurements. This is a multi-dimensional data mart. We have a category rollup, in which a C# book counts as a C# book, and an ASP.Net book counts as an ASP.Net book, and a language rollup, in which both a C# book and an ASP.Net (or a design patterns book, or ... that uses C#) counts as a C# book.
There is also an overall platform rollup, that is even broader than the language rollup. I'll try to do that post sometime soon.
As to book sales being something of a leading indicator, I'd tend to say it's coincident, as you say, with learning, which tends to lead deployment, where job postings trail deployment decisions.
However, we're getting some huge insight out of the difference in job postings between startups and more established companies. And that does turn job data into more of a leading indicator... More on that soon.
I find that Google Trends is an interesting way of showing the popularity of current trends in technology.
How would you determine these languages on Google Trends for sure as Java can also mean coffee, while Ruby can mean the gemstone or a girl's name (sometimes, even a boy's name). If you append language or programming language, you will be cutting down the search trend criteria considerably, but getting a better accuracy:
Java language, Perl language, PHP language, Ruby language
Anyway, I wanted to highlight the foibles of inputting Ruby, Java and such into Google trends and thinking you are getting any accurate picture. There are a lot of us women and men out there who love Ruby gemstones and occasionally search for them. :)
Next, in my opinion, this is simply untrue:
There's also an inherent weakness to this - free online documentation. The best tutorial on languages like python and php are on the web itself; many people skip the books altogether.
I've looked at tutorials on all languages online as I tried to learn each, and the best tutorials I've ever seen are by Why for Ruby, hands down. I haven't seen how the PHP and Python ones are so awesome to entail not buying books for them. In actuality, given PHP has so many tutorials out there, many are equally as crummy as good (and the very depth of the ones available means it is equally as hard to separate the good from the bad in and of itself), not to mention many aren't frequently even updated to account for the (new) PHP versions coming out.
Another point you are missing with the statement of looking at online tutorials is that the people who purchase books usually aren't the same ones who use online tutorials and vice versa. I have a friend who hates to read long texts and only reads via online documentation. He would never pay for any programming book outside what he has to buy for college classes. On the other hand, I love books and often buy them whenever I have an interest in a language even when I have many sites bookmarked for a language. Most people who buy programming books do so despite online documentation because there is an idea by such book buyers that written books have more reference material and depth than online resources do. True or not, that is the sentiment, yet someone who never or rarely buys books is not going to understand that sentiment because that person simply don't feel that way about books, so the individual would not even bother buying books anyway whether the language is new, old or comatose.
Maybe, it would be nice to have a trend comparison for online tutorial site visits for the 100 most popular programming tutorial sites per google searches to the book sales chart so we can see if these awesome PHP and Python tutorials are at the top of the list or not for visits.
The only thing it accurately measures is what the latest hype is, and what those hype people are buying. You'd almost for sure find the same numbers when dvd players came out and compared to vcr sales and their movies etc.
And that's not to say that one of these hype languages(ruby) couldn't translate into something. But the metrics aren't very useful.
Interesting to see is that this graph doesn't reflect a similar comparison available at http://www.tiobe.com/ that one based on Language popularity based on hits on the 3 major search engines.
Books are no longer a good indicator, On-demand printing, blogging, and forums are nowdays the fast and best way to adquire knowledge on a language.
A clear example is Delphi, it is a very popular language, but few books are publish by year (3,4) based on the TIOBE ranking, the distance in popularity between C# and Delphi is of less than 1%. Being Java and C the kings of the hill.
Is Coldfusion included with Java in these trends?
Its use seemed to decline sharply with the arrival of PHP but seems to have rebounded as developers have got used to changeover to the java platform and the launch of the MX7 Server a year or so ago.
Tony -- ColdFusion is not included with Java. In the book market, it's too small to notice -- about 1600 units per quarter is now the total CF book market. It's down 49% over the quarter a year ago.
Esteban -- I agree with you that books are not the sole indicator, but they are still a good one. We like to look at multiple indicators -- in the future, when I do one of these writeups, I'll cover data from other sources besides books.
As to Tiobe, saying it is based on "hits on the 3 major search engines" is somewhat inaccurate. What they say is that "The ratings are based on the world-wide availability of skilled engineers, courses and third party vendors." (as found in the search engines.) So it may well depend on what you search for. Because they don't disclose exactly what it is they are searching for, or how recent the web listings are, it's hard to know what Tiobe is measuring. In our job data as well as our book data, C# is well ahead of Delphi.
Ïðèâåò
Çàõîäèòå â àñþ, âñå îáñóäèì : 227-665-282 , ïèøèòå íà ïî÷òó kt222@mail.ru îòâå÷ó íà âñå Âàøè âîïðîñû.
Ñ íàìè ðàáîòàòü âûãîäíî,ó íàñ ÑÀÌÛÅ ÄÅÌÎÊÐÀÒÈ×ÍÛÅ ÖÅÍÛ.
www.doski-inet.com
Áóäåì ðàäû îêàçàòüñÿ Âàì ïîëåçíûìè.
Assuming that there are roughly as many pros as cons of using books sales as a trend indicator, this method seems pretty accurate.
A major exhibition of work by French-American sculptor Louise Bourgeois is to be held at Tate Modern...

公開調査で見逃しやすい言語は少なく推定される傾向がある。

The --

The ACM Special Interest Group on Programming Languages (SIGPLAN) explores programming language concepts and tools, focusing on design, implementation, practice, and theory. Its members are programming language developers, educators, implementers, researchers, theoreticians, and users.
Machine Learning for Programming Language Processing
Novel Polynomial Approximation Methods for Generating Correctly Rounded Elementary Functions
(for 2012): Multiple facets for dynamic information flow Citation: | The paper proposed to track information flow dynamically through Javascript programs using a run-time monitor; folklore that dynamic monitors were unsound led others to focus on static techniques. Its key new idea was to blend multiple executions into a single one via “faceted values.” This idea generalized a prior whole program technique of “secure multi execution” (SME), and inspired follow-on work in Javascript security, information flow analysis in other languages (e.g., Python, Haskell, Java), and other problem domains, notably “variability-aware execution” and “dynamic determinacy analysis.” It even influenced follow-on improvements to SME itself. The variety of authors in the most-cited citing papers, and the variety of their areas—most top venues in PL, SE, and Security are represented—speak to its influence. The paper is exemplary in seeding a nice core idea that has evidently proliferated throughout its core area, and also influenced solutions to other problems outside this area.
(for 2012) Test-Case Reduction for C Compiler Bugs
(for 2011) Frenetic: A Network Programming Language Citation: | This is the first conference paper in a highly influential line of work creating a bridge between PL and networking. The authors analyzed deficiencies in the state of the art in languages for programming networks, addressed these limitations in a new language design, and described its implementation and performance on a suite of microbenchmarks. The language applied a range of ideas from the functional programming community: a declarative query language for classifying and aggregating network traffic; a reactive combinator library for describing high-level packet-forwarding policies; and a run-time system that automatically generates the low-level packet-processing rules, installing, uninstalling, and querying them on physical switches. This paper inspired a mountain of follow-on work by these authors and others. The practical value of improving network programming, and this paper’s influence on subsequent advances in the state of the art, make it a deserving winner of the award for Most Influential Paper of ICFP 2011.
(for 2011) SugarJ: library-based syntactic language extensibility

Question: the theory, design, implementation, description, and application of computer programming languages is known

The --

Question: SIGplan is the theory, design, implementation, description, and application of what

The --

SIGplan is the theory, design, implementation, description, and application of what

Question: what does SIGplan allow a user to control over a computer's operation

The --

what does SIGplan allow a user to control over a computer's operation

Question: what does SIGplan allow

the specification of a variety of different computations

specification of a variety of different computations

The --

the specification of a variety of different computations

Question: what is the scope of SIGplan

specification of a variety of different computations

specification of a variety of different computations

The --

specification of a variety of different computations

Question: what does SIGplan allow the specification of

The --

what does SIGplan allow the specification of

Question: what does SIGplan provide a user with

The --

The scope of SIGPLAN is the theory , design , implementation , description , and application of computer programming languages - languages that allow the specification of a variety of different computations , thereby providing the user with significant control ( immediate or delayed ) over the computer 's operation .

プログラミング言語はプログラムを書くのに使われる言語であり、それによってコンピュータは何らかの計算, The scope of SIGPLAN is the theory, design, implementation, description, and application of computer programming languages - languages that permit the specification of a variety of different computations, thereby providing the user with significant control (immediate or delayed) over the computer's operation.やアルゴリズムを実行し、場合によってはプリンターやロボットなどの外部装置を制御する。 -->

The scope of SIGPLAN is the theory, design, implementation, description, and application of computer programming languages - languages that allow the specification of a variety of different computations, thereby providing the user with significant control (immediate or delayed) over the computer's operation. The --

The --

There's nothing I'm going to tell you today that you absolutely have to know in order to pass this course. But I'm going to assume that you're not taking this course just to pass it.
The RCX computer combined with the legOS kernel, API and programming environment is simple when compared with, say, a Sparc Ultra 10 combined with Solaris 5.7. But it's about as complex a combination as you'll ever be able to understand completely.
As a class, you have diverse computer science backgrounds. My lecture today tries to teach all of you something and provide each of you with pointers to additional sources so you can go as far as you want.
I could easily spend an entire semester expanding on the material in this one lecture. But for some of you an hour will be quite enough. The references at the end of the web page for today's lecture should suffice for those of you who want to take the next steps.
So, why is what I'm going to say today important to "Building Intelligent Robots"? The answer is that building robots is all about timing, about doing several things at once and about interfacing with a dynamic and unpredictable world.
In programming the RCX, you will have to make use of a single sequence of instructions, a single thread of computation to simulate multiple threads of time-critical control implemented as tight feedback loops.
We need to start with a commonly-understood base model. Something we can ground our subsequent discussion on. For our present purposes, this means a computational model that provides all of the basic primitives for understanding legOS. I'm going to assume that the first part of today's lecture is a quick review of basic material.
What do you think of when you hear the words "computational model?" A Turing Machine perhaps? I'll bet it's not a non-deterministic, one-way, finite-state machine? It may be that these sorts of abstract models don't provide you with an appropriately "high level" of abstraction to help you in thinking constructively about real-world programming problems. It's important to note, however, that we all use abstract models of one sort or another; the trick is to make the abstractions work for you by emphasizing the important aspects of the problems you're trying to solve and hiding the messy details that just get in the way. (I know this is tangential but I can't resist an aside. The book entitled Alan Turing: the Enigma written by Andrew Hodges is interesting for a number of reasons not the least being its discussions of Turing's contributions to computer architecture. Turing was a lot more practical than most computer scientists give him credit.)
An alternative model (but still pretty low level) is the machine defined by the so-called "von Neumann architecture" (named after the mathematician John von Neumann). Most of you have seen this architecture in one or more of your courses, as it is the standard abstract model used to describe most modern computers. We won't actually use the von Neumann model as a basis for thinking about robot programs but it will provide an intermediate level of abstraction for developing an appropriately high level model for programming robots. The computational model corresponding to the von Neumann architecture consists of the following components:
Though not often included in the classic formulation, we usually also assume that there is some way to get data into and out of the computer.
The standard architecture assumes the notion of a program counter which is just a register used to store the location of the next instruction in memory and an instruction set that defines the set of primitive operations that can be performed by the ALU. You learned early in your computer science education that arithmetic and symbolic operations can be implemented in terms of boolean operations on binary data. Here is the sequence of steps repeatedly carried out in this model:
1. Fetch the next instruction from memory.
2. Increment the program counter by 1.
3. Decode the instruction and instruct the control unit to carry out the appropriate operation. This operation could change the contents of registers (including the program counter) thereby allowing loops and conditional branches.
4. Return to Step 1.
What else might you want to add to the above abstraction to have a reasonable computational model for thinking about robots and real-time control? Well, for one thing you might want to have some way of measuring the passage of time. (Note that if you knew how much time each instruction took or could assume that each instruction takes the same amount of time you could create a clock of sorts but it would be rather clumsy to use.) List some of the reasons that a clock would be useful in programming robots.
Another addition that often comes in handy is the notion of an interrupt. Interrupts simplify writing programs that perform other operations while waiting for events (both internal and external). Interrupts and timers together provide the machinery for implementing efficient multi-threaded control (e.g., preemptive multi tasking) which will prove particularly useful in building robot programs.
There are other components that we might add to enhance the standard model. For example, peripheral components that map analog sensors to digital data or visa versa and abstractions such as direct memory access (DMA) that allow us to think of sensor data as magically appearing in designated locations in RAM. You might think however that we are getting hopelessly low level in providing a practical computational model for programming and, indeed, there is reason to build a layer of abstraction that that hides some of these details from the programmer.
The answer to this question depends in part on how much pain you're willing to endure. Given a loader for the H8 Microcontroller you could directly load H8 machine code to the RCX and run machine code programs. Somewhat less painful, you could use a text editor to write H8 assembly code, an assembler to produce machine code and then a loader to load the machine code to the RCX. The following HC6811 assembly program flashes the motor LEDs on a Handy Board back and forth indefinitely from green to red (adapted from [Martin, 2001] Appendix A.2):
org $8000 ; define the program origin at address $8000 start lds #$ffff ; define the program stack at the top of memory again ldaa #$f0 ; load the value of $f0 (red) in the A register staa $7000 ; store the A register to $7000, the motor port jsr delay ; jump to the delay subroutine ldaa #$ff ; load the value of $ff (green) in the A register staa $7000 ; store the A register to $7000, the motor port jsr delay ; jump to the delay subroutine bra again ; branch back to the beginning of the loop delay ldx #0 ; put zero into the X register delayp dex ; decrement 1 from the X register bne delayp ; loop until zero again (65536 times) rts ; return from the delay subroutine org $bffe ; location of the 68HC11 "reset" vector fdb start ; "form a double byte" to start of program end
I should note that even in the simple assembly program above, we've deviated somewhat from the simple model described above. The instruction jsr is a jump to subroutine call. Apart from the fact that this is assembly and not machine language and delay is a symbolic and not numeric address, what is special about the jsr instruction? The answer is that when you jump to a subroutine you have to push the address of the instruction immediately following the jsr instruction onto the stack so that you can restore this address in order to return from the subroutine call. You could get away without the jsr instruction, but would you really want to? You could do the bookkeeping yourself but the abstraction built into the jump-to-subroutine instruction makes your life a lot easier. (Later we'll want to invoke a similar abstraction whose implementation requires that we push not only the program counter but the contents of all the registers onto the stack when we switch (contexts) between processes.)
If you're interested, Martin [2001] has a nice introduction to the architecture and assembly language of the 68HCll MPU in Appendix A.1 of your textbook: everything you wanted to know about memory maps, addressing modes, interrupts and the like. Martin talks about subroutine calls and the method of passing arguments to and returning results from subroutine calls by manipulating the stack (with appropriate warnings of the attendant dangers of relying on the programmer to keep track of such low-level bookkeeping details). Jones and Flynn [Jones and Flynn, 1993] also provide a nice discussion of these issues (see Section 3.5: The Hardware Software Interface).
Indeed, you could do all of your robot programming in assembly or machine code. Most robot programmers, however, prefer to have some reasonably high-level abstractions between them and the nitty gritty details of the microprocessor and the supporting low-level circuitry controlling their robots. These abstractions are typically in the form of a programming language along with libraries and APIs for interfacing with sensors, motors and I/O devices.
Most programming languages depend on various operations provided by an operating system. The operating system along with its various conventions for handling files, performing I/0 and managing memory and processes provides an abstract model of computation that underlies the various programming languages supported by the OS. Before we get into the details of the Lego RCX let's consider what sorts of things we generally expect from operating systems.
Here are the basic operations that a programmer (or programming language designer) typically expects of a modern operating system (adapted from [Silberschatz, Galvin and Gagne, 2001]):
To get us thinking about what sorts of languages and abstractions are useful for programming robots, here is a simple robot problem and some proposed pseudo code for its solution. Suppose that we have a wheeled or tracked robot with two sensors: a downward pointing light sensor that can detect colors on a playing surface and a forward pointing bump sensor that can detect collisions with vertical surfaces. The robot is located on a square playing field surrounded by walls of an appropriate height. In the center of the playing field is a cylindrical object of the same height as the surrounding walls; this object is the "goal post" of the playing field. The playing surface is divided into a central circular area which is colored red and the rest of the playing surface which is colored green. We will assume that the robot's downward pointing light sensor can distinguish between these two colors. (It's worth noting, however, that just because you can discern the difference between these two obviously different hues, it doesn't follow that your particular light sensor will be able to make such distinctions. This is an instance of a more general lesson that roboticists learn over and over again in a multitude of guises.) The robot is supposed to remain within the central red area and to make contact with the goal post. If the robot remains in the green area for more than a specified duration, then the game is over and the robot "fails". If the robot hits the goal post before failing, then the robot "succeeds" and its score is the time elapsed from when the game began. We'll require that the robot demonstrate that it "knows" that it has succeeded by signaling with a distinctive tone and stopping its motion. Here's a graphic depicting the playing field.
Now how would you think about organizing a program to compete in this simple game. Here are some component behaviors which, working together, might provide a reasonable solution.
Now, there are all sorts of problems with the above sketch but it's not a bad start and it does illustrate some of the problems and requirements that you're likely to encounter in designing robot programs. First, you'll often have subroutines that repeatedly check for some condition signaled by a change in sensor values. Second, you'll often want to do several things at once ("chew gum and walk at the same time") in order to contend with the demands of a dynamic environment. Finally, a lot of low-level robotics can be characterized in terms of tight feedback loops that repeatedly sense some aspect of the environment, compare the most recent sensor reading with some desired target value, and then use the difference (called the error signal) to determine what response to make; in the case above, the desired target is "seeing red". (Often, an appropriate response depends on many factors ("seeing red" and "not having hit the goal post") and hence the heart of the controller often consists of a "bunch of logic" to sort out the various circumstances and their corresponding appropriate responses.) Now let's reconsider these operations with the requirements for controlling mobile robots in mind:
Alright already! Let's take a look at the RCX Programmable Brick and the Hitachi H8 Microcontroller (MCU). Kekoa Proudfoot has saved us the trouble (and expense) of taking apart one of the Lego bricks. His web page (see below) provides a glimpse into the hardware and core resident software (referred to as "firmware" in this case) of the RCX. My web page from Spring of 2001 explains some of the issues concerning various firmware alternatives and the programming languages that they support. Last year we programmed in "Not Quite C" (NQC) which depends on the standard firmware that comes with the Lego Mindstorms robot kit. This year we'll be programming using a subset of the C programming language supported by the legOS which is a very simple operating system that depends on its own special firmware.
So what is it that legOS provides us that NQC (plus the standard firmware) doesn't? First, the language is closer to the real C programming language! (What could we possibly mean by that and why should anybody care?) Second, legOS lets us use standard compilers and programming tools to develop RCX code. (Why is this an advantage?) Third, using legOS we run "compiled" rather than "interpreted" code. (What's the difference and why should anybody care? Isn't FORTH an interpreted language that is widely used in embedded control systems?) And, as long as we're posing all these parenthetical questions, you might be wondering about a particularly obvious question. (Why didn't we just use interactive C, the language described in Fred Martin's text book?) Let's start by considering exactly what it is that legOS provides us with and we'll try to answer these questions in the context of explaining what legOS is.
In the next lab, you'll learn the nuts and bolts of compiling and downloading legOS programs. In this lecture, we're still thinking in terms of abstractions: what it is that we want and need in a programming language and how legOS supports these needs.
Here is a quick glimpse of the APIs for motors, sensors and the LCD display:
We assume you're familiar with the standard flow of control constructs such as while, until, if, then and else. Lightweight processes or threads are an important notion in designing embedded control systems and while they exist in standard C, it's probably worth looking at them a little more carefully. (What's the difference between "regular" processes and "lightweight" processes (threads) when programming in C for a POSIX compliant OS?) Here are the basic constructs for creating and managing processes:
If you took CS167, you might recall the lectures on process and lightweight thread management; specifically, look at the slides titled Weenix II. To learn more about how threads are handled in legOS, check out the code in "kernel/tm.c" in the legOS source directory. This file contains the task switcher and scheduler as well as the library functions relating to task management (hence the file name "tm"). Note that this file, like several of the other files in the legOS kernel, contains embedded assembly code subroutines. In the case of "tm.c", these assembly routines are called, when a time slice ends and an interrupt is called signaling that it's time to switch to another thread. These assembly-code routines provide low-level services such as those required in context switching. When a process (thread) is halted, the contents of its registers and program counter are saved to a particular location in memory and the previously saved contents of the registers and program counter for some other process are restored; this shuffling of register contents is called context switching. The task switcher is also called when the currently running thread executes a sleep or yield instruction.
Even if you didn't take CS167 you should be able to figure out some scheme to map your understanding of threads and thread switching onto the von Neumann architecture presented earlier. Note what's happening here; the functions built into legOS for sensors, motors and threads provide a new abstraction that replaces the more primitive von Neumann abstractions. There are times, however, when it is valuable to be able to map back to the more primitive abstraction in order to understand anomalies that can't be easily explained at the higher level. Another good source for learning about threads and processes, is to review the chapters that comprise "Part 2: Process Management" of [Silberschatz, Galvin and Gagne, 2001].
There are a number of sources of useful information about legOS. Markus Noga who designed the first version of legOS describes some of his contributions in [Noga, 1999]. Noga's legOS page is a good source of pointers and articles. [Nielsson, 2000] provides a very readable introduction to the legOS kernel. There's also an online discussion group lugnet.robotics.rcx.legos that provides a wealth of legOS-related information. I managed to find online version of most of the articles listed below either using Google or NEC ResearchIndex (CiteSeer). LegOS is a moving target and soon after a problem is discovered generally you'll find a solution posted to one of the newsgroups.
[Pedersen et al., 2000b] identified some problems with early versions of the legOS task manager. They provide a fix that makes legOS (specifically, the event handlers that respond to changes in sensor readings) more responsive to transitory sensor events, e.g., using a downward pointing light sensor to notice when a wheeled robot rolls over a painted line. Here's a diagram showing how the task manager proposed in their solution tests the conditions of processes waiting on event handlers.
As another example of efforts to make legOS more robust, [Pedersen et al., 2000a] (a different Pedersen (Michael Haugaard) than the Pedersen (Soren Toft) in [Pedersen et al., 2000b]) describe a problem that occurs when a higher priority process is blocked by a lower priority process when both processes share access to a resource gated by semaphores. If you've taken a course in operating systems (e.g., CS167) you should find this article accessible.
There's a lot more to writing robot programs in legOS. Later we'll learn about specialized sensors like the rotation and sonar sensor. You'll also learn how to use sounds and legOS infrared communication protocols. It's not hard to master the syntax; the trick is getting the robot to do what you want it to do and that is what makes robot programming so interesting and challenging.
|[Nielsson, 2000]||Stig Nielsson, "Introduction to the legOS kernel," September, 2000.|
|[Noga, 1999]||Noga, M. L., "Designing the legOS multitasking operating system", Dr. Dobb's Journal, November, 1999.|
|[Jones and Flynn, 1993]||Jones, J.L., Flynn, A.M., Mobile Robots: Inspiration to Implementation, A K Peters, 1993.|
|[Martin, 2001]||Martin, F., Robotic Explorations: A Hands-On Introduction to Engineering, Prentice-Hall, 2001.|
|[Silberschatz et al., 2001]||Abraham Silberschatz, Peter Baer Galvin, Greg Gagne, Operating System Concepts Sixth Edition, John Wiley & Sons, Inc., 2001, [see their web page].|
|[Pedersen et al., 2000a]||Michael Haugaard Pedersen, Morten Klitgaard Christiansen, Thomas Glaesner, "Solving the Priority Inversion Problem in legOS", Technical Report. Computer Science University of Aalborg, May, 2000.|
|[Pedersen et al., 2000b]||Pedersen, S. T., Christensen, L., and Rasmussen, E. B., "Prioritized interrupts in legOS", Unpublished Project Paper Submitted to the Institute for Computer Science at Aalborg, 2000.|
|[Villa, 2000]||Luis Villa, "LegOS HOWTO", 200, [a printable version is available at legos.sourceforge.net].|