10 Dead Programming Languages

Programming languages ​​are constantly evolving with a life cycle that entails: popularity, growth and decline. The reasons behind their decline vary from outdated principles to new, more efficient languages ​​gaining popularity. Here are 10 languages ​​that once enjoyed their prime popularity but were lost into oblivion in the 21st century.


In 1960, the CODASYL organization played a significant role in the development of COBOL, a programming language influenced by the division between business and scientific computing. During that time, high-level languages ​​in the industry were either used for engineering calculations or data management. COBOL, considered one of the four foundational programming languages ​​along with ALGOL, FORTRAN, and LISP, was once the most widely used language worldwide. It continues to operate many of our legacy business systems.

Cause of Death: Two factors contributed to COBOL’s decline. Firstly, it had minimal connections with other programming language efforts. Very few developers built upon COBOL, leading to the scarcity of its influence in second or third generation languages, which benefited from lessons learned from their predecessors. COBOL is exceptionally complicated, even by today’s standards. Consequently, COBOL compilers fell behind those of contemporaneous microcomputers and minicomputers, providing opportunities for other languages ​​to thrive and eventually surpass themselves.


In 1960, the ALGOL committee aimed to create a language for algorithm research, with ALGOL-58 preceding and quickly being replaced by ALGOL-60. Despite being relatively lesser known today compared to LISP, COBOL, and FORTRAN, ALGOL holds significant importance, second only to LISP, among the four original programming languages. It contributed to lexical scoping, structured programming, nested functions, formal language specifications, call-by-name semantics, BNF grammars, and block comments.

Cause of Death: ALGOL was primarily a research language, not intended for commercial use. Its specification lacks input/output capabilities, making practical application difficult. As a result, numerous ALGOL-like languages ​​emerged in the 1960s and 1970s. Subsequent languages ​​were based on these extensions rather than ALGOL itself. During the 1960s and 1970s, numerous ALGOL-like languages ​​emerged as people extended ALGOL with input/output capabilities and additional data structures. Examples of such languages ​​include JOVIAL, SIMULA, CLU, and CPL. The descendants of ALGOL ultimately overshadowed and outpaced it in popularity and usage.


APL was created by Ken Iverson in 1962. Originally developed as a hand-written notation for array mathematics, IBM adopted it as a programming language. APL focused on array processing, enabling concise manipulation of large blocks of numbers. It gained popularity on mainframe computers due to its ability to run with minimal memory requirements.

APL revolutionized array processing by introducing the concept of operating on entire arrays at once. Its influence extends to modern data science and related fields, with its innovations inspiring the development of languages ​​like R, NumPy, pandas, and Matlab. APL also has direct descendants such as J, Dyalog, K, and Q, which, although less successful, still find extensive use in the finance sector.

Cause of Death: APL faced challenges due to keyboard limitations. The language’s non-ASCII symbols made it difficult for widespread adoption. Ken Iverson addressed this issue in 1990 with J, which utilized digraphs instead of distinct symbols. However, this change came relatively late and did not gain significant traction in popularizing a radically different programming style. Another challenge was APL’s limitation to homogeneous data, as it did not support storing both strings and numbers in the same data structure. Working with strings was also cumbersome in APL. These limitations, including the absence of dataframes, hindered APL’s suitability for modern data science applications.


Created by John Kemeny in 1964, BASIC originated as a simplified FORTRAN-like language intended to make computer programming accessible to non-engineering individuals. BASIC could be compactly compiled into as little as 2 kilobytes of memory and became the lingua franca for early-stage programmers. It was commonly used by individuals programming at home in the 1970s.

Its major technical impact lies in its runtime interpretation. It was the first language to feature a real-time interpreter, beating APL by a year.

Cause of Death: BASIC faced the perception of being a “lesser” language compared to other programming languages ​​used by professional programmers. While it continued to be used by children and small business owners, it was not considered the language of choice for experienced programmers. As microcomputers with larger memory capacities became available, BASIC was gradually replaced by languages ​​like Pascal and C. BASIC persisted for some time as a legacy teaching language for kids but eventually faded away from that niche as well.


Developed by IBM in 1966, PL/I aimed to create a language suitable for both engineering and business purposes. IBM’s business was previously divided between FORTRAN for scientists and COMTRAN for business users. PL/I merged the features of these two languages, resulting in a language that supported a wide range of applications.

PL/I implemented structured data as a type, which was a novel concept at the time. It was the first high-level language to incorporate pointers for direct memory manipulation, constants, and function overloading. Many of these ideas influenced subsequent programming languages, including C, which borrowed from both BCPL and PL/I. Notably, PL/I’s comment syntax is also used in C.

Cause of Death: PL/I faced challenges as it tried to straddle the line between FORTRAN and COBOL. Many FORTRAN programmers considered it too similar to COBOL, while COBOL programmers saw it as too similar to FORTRAN. IBM’s attempt to compete with two established languages ​​using a more complex language deterred wider adoption. Moreover, IBM held the sole compiler for PL/I, leading to mistrust from potential users concerned about vendor lock-in. By the time IBM addressed these issues, the computing world had already transitioned to the microcomputer era, where BASIC outpaced PL/I.


Ole Dahl and Kristen Nygaard developed SIMULA 67 in 1967 as an extension of ALGOL for simulations. SIMULA 67, although not the first object-oriented programming (OOP) language, introduced proper objects and laid the groundwork for future developments. It popularized concepts such as class/object separation, subclassing, virtual methods, and protected attributes.

Cause of Death: SIMULA faced performance challenges, being too slow for large-scale use. Its speed was particularly limited to mainframe computers, posing difficulties for broader adoption. It’s worth noting that Smalltalk-80, which extended SIMULA’s ideas further, had the advantage of Moore’s Law advancements over the extra 13 years. Even Smalltalk was often criticized for its speed. As a result, the ideas from SIMULA were integrated into faster and simpler languages ​​by other developers, and those languages ​​gained wider popularity.


Niklaus Wirth created Pascal in 1970 to capture the essence of ALGOL-60 after ALGOL-68 became too complex. Pascal gained prominence as an introductory language in computer science and became the second most popular language on Usenet job boards in the early 1980s.

Pascal popularized ALGOL syntax outside academia, leading to ALGOL’s assignment syntax, “:=”, being called “Pascal style”.

Cause of Death: The decline of Pascal is complex and does not have a clear-cut explanation like some other languages. While some attribute its decline to Edsger Dijkstra’s essay ‘Why Pascal is not my favorite language’, this explanation oversimplifies the situation. Pascal did face competition from languages ​​like C, but managed to hold his own for a significant period. It’s worth noting that Delphi, a variant of Pascal, still ranks well in TIOBE and PYPA measurements, indicating that it continues to exist in certain niches.


CLU was developed by Barbara Liskov in 1975, with the primary intention of exploring abstract data types. Despite being relatively unknown, CLU is one of the most influential languages ​​in terms of ideas and concepts. CLU introduced several concepts that are widely used today, including iterators, abstract data types, generics, and checked exceptions. Although these ideas might not be directly attributed to CLU due to differences in terminology, their origin can be traced back to CLU’s influence. Many subsequent language specifications referenced CLU in their development.

Cause of Death: CLU is served as a demonstration language with Liskov’s primary goal being the adoption of her ideas rather than the language itself. This objective was largely achieved, as nearly all modern programming languages ​​incorporate elements inspired by CLU.


Robin Milner developed ML in 1976 while working on the LCF Prover, one of the first proof assistants. Originally designed as a metalanguage for writing proofs in a sound mathematical format, ML eventually evolved into a standalone programming language.

It is considered one of the oldest “algebraic programming languages”. ML’s most notable innovation was type inference, allowing the compiler to deduce types automatically, freeing programmers from explicitly specifying them. This advancement paved the way for the adoption of typed functional programming in real-world applications.

Cause of Death: ML initially served as a specialized language for theorem provers, limiting its broader usage. While SML emerged in the same year as Haskell, which exemplified a more “pure” typed functional programming language, the wider programming community paid more attention to Haskell. ML’s impact and adoption remained substantial within academic and research settings but did not achieve the same level of popularity as some other languages.


Smalltalk, developed by Alan Kay, had multiple versions released over time. Each version built upon the previous one, with Smalltalk-80 being the most widely adopted and influential. It is often regarded as the language that popularized the concept of object-oriented programming (OOP). While not the first language with objects, Smalltalk was the first language where everything, including booleans, was treated as an object. Its influence can be seen in the design of subsequent OOP languages, such as Java and Python.

Cause of Death: Smalltalk faced challenges related to interoperability with other tools and runtime performance. Its difficulty in integrating with existing systems and relatively slower execution speed hindered broader adoption. Its decline can be attributed to the emergence of Java, which had more seamless interop with existing systems and gained overwhelming popularity. The legacy of Smalltalk lives on in the principles and design patterns that have become integral to modern software development.