Hubbry Logo
Third-generation programming languageThird-generation programming languageMain
Open search
Third-generation programming language
Community hub
Third-generation programming language
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Third-generation programming language
Third-generation programming language
Third-generation programming language
View on Wikipedia
from Wikipedia

A third-generation programming language (3GL) is a high-level computer programming language that tends to be more machine-independent and programmer-friendly than the machine code of the first-generation and assembly languages of the second-generation, while having a less specific focus to the fourth and fifth generations.[1] Examples of common and historical third-generation programming languages are ALGOL, BASIC, C, COBOL, Fortran, Java, and Pascal.

Characteristics

[edit]

3GLs are much more machine-independent and more programmer-friendly. This includes features like improved support for aggregate data types, and expressing concepts in a way that favors the programmer, not the computer. A third generation language improves over a second-generation language by having the computer take care of non-essential details. 3GLs are more abstract than previous generations of languages, and thus can be considered higher-level languages than their first- and second-generation counterparts. First introduced in the late 1950s, Fortran, ALGOL, and COBOL are examples of early 3GLs.

Most popular general-purpose languages today, such as C, C++, C#, Java, BASIC and Pascal, are also third-generation languages, although each of these languages can be further subdivided into other categories based on other contemporary traits. Most 3GLs support structured programming. Many support object-oriented programming. Traits like these are more often used to describe a language rather than just being a 3GL.

A 3GL enables a programmer to write programs that are more or less independent from a particular type of computer. Such languages are considered high-level because they are closer to human languages and further from machine languages, and hence require compilation or interpretation. In contrast, machine languages are considered low-level because they are designed for and executed by physical hardware without further translation required.

The main advantage of high-level languages over low-level languages is that they are easier to read, write, and maintain. Ultimately, programs written in a high-level language must be translated into machine language by a compiler or directly into behaviour by an interpreter.

These programs could run on different machines (they are portable) so they were machine-independent. As new, more abstract languages have been developed, however, the concept of high- and low-level languages have become rather relative. Many of the early "high-level" languages are now considered relatively low-level in comparison to languages such as Python, Ruby, and Common Lisp, which have some features of fourth-generation programming languages and were called very high-level programming languages in the 1990s.[2][3]

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Third-generation programming language

View on Grokipedia
from Grokipedia
A third-generation programming language (3GL) is a high-level language designed to abstract low-level hardware details, using structured syntax resembling to express algorithms and logic in a machine-independent manner. These languages emerged as a significant advancement over first-generation and second-generation assembly languages, enabling programmers to focus on problem-solving rather than direct hardware manipulation. The development of 3GLs began in the early 1950s, with the first notable example being , created by in 1954 and first compiled in 1958 after substantial development effort. This period saw rapid innovation, driven by the need for more efficient and readable code in scientific and business applications; by 1959, key languages like —for data processing—and —for algorithmic expression—were introduced, marking a shift toward standardized, portable programming. Over the following decades, more than 200 such languages proliferated, influenced by both practical needs and theoretical advancements, with standardization efforts like those for in 1966 enhancing their adoption. Key characteristics of 3GLs include support for constructs such as loops, conditionals, and subroutines, along with basic data types like integers and reals, which promote code readability and reusability. Unlike lower generations, they compile into via translators, allowing the same to run on different systems with minimal adaptation. Influential examples include for numerical computation, for business-oriented tasks with its English-like verbosity, for its elegant block structure that influenced modern syntax, and later languages like , which combined 3GL features with low-level access. These languages laid the foundation for contemporary programming paradigms, emphasizing abstraction and human-centric design.

Definition and Classification

Core Definition

Third-generation programming languages (3GLs), also known as high-level languages, are designed to use syntax that approximates or mathematical expressions, thereby improving human readability while abstracting away low-level machine-specific details such as and addressing. This abstraction enables programmers to express algorithms in a more intuitive manner, focusing on the logic of the problem rather than the underlying hardware . In distinction from first-generation languages (1GLs), which rely on binary machine code directly interpretable by the processor, and second-generation languages (2GLs), which employ symbolic assembly instructions that still require detailed knowledge of machine architecture, 3GLs introduce higher-level symbolic instructions and structured control mechanisms translated by compilers into sequences of machine instructions. For instance, a single 3GL statement might correspond to dozens of machine-level operations, promoting portability across different hardware platforms. Primarily rooted in procedural or imperative paradigms, 3GLs emphasize step-by-step execution of commands to manipulate , incorporating fundamental syntax elements such as variables to declare and store values, loops to enable iterative processing, and conditional statements to implement branching logic based on runtime conditions. These elements facilitate the creation of modular, maintainable by enforcing sequential flow and organization. The term "third-generation" characterizes this era of procedural , reflecting the from machine-dependent coding to more human-centric, problem-oriented approaches in .

Classification Within Generations

Programming language generations represent a taxonomic framework for understanding the of programming paradigms, categorized primarily by their distance from machine hardware and proximity to human expression. First-generation languages (1GL) consist of raw , comprising binary instructions directly executable by the processor without translation, offering no but maximal on specific hardware. Second-generation languages (2GL), or assembly languages, introduce symbolic representations of machine instructions using mnemonics, which are then assembled into , providing slight improvements in human readability while remaining hardware-dependent. Third-generation languages (3GL) mark a shift to high-level, procedural constructs that resemble or , requiring compilation or interpretation to and enabling machine-independent programming. Fourth-generation languages (4GL) emphasize declarative and domain-specific abstractions, such as query languages for databases, further reducing the need for explicit . Fifth-generation languages (5GL) incorporate and , aiming for intuitive, logic-based interfaces that minimize syntactic details. The primary criteria for this generational revolve around the degree of from hardware details, the extent of human , and the necessity for mechanisms like compilers or interpreters. Abstraction levels increase progressively: 1GL and 2GL offer minimal separation from machine architecture, demanding direct hardware knowledge, whereas 3GL and beyond abstract away registers, addressing, and instruction sets to focus on algorithmic logic. Human improves with each through syntactic elements closer to everyday or mathematical language, reducing for programmers; for instance, 3GL syntax uses statements like variable assignments that mirror English or algebraic expressions. All generations beyond 1GL require some form of translator—assemblers for 2GL and compilers or interpreters for 3GL and higher—to bridge the gap between human-oriented code and machine-executable binaries, with 3GL compilers being pivotal in optimizing portable . Third-generation languages serve as a critical bridge in this progression, transitioning from the low-level efficiency of 1GL and 2GL—tied to specific architectures and prone to errors in manual coding—to the enhanced productivity of higher generations by prioritizing procedural and hardware portability. This portability arises from 3GL's machine-independent design, allowing to be recompiled for diverse platforms without rewriting, which facilitated widespread in scientific and domains. By enabling programmers to express computations in a structured, readable form rather than hardware specifics, 3GLs dramatically improved development speed and reliability, laying the groundwork for modern software ecosystems. The boundaries between generations, particularly around 3GL, remain subject to some interpretation due to the model's informal nature as a pedagogical tool rather than a rigid . Early high-level languages like , developed in the 1950s for scientific computing, are standardly classified as 3GL for introducing substantial , readability via algebraic notation, and compiler-based portability that transcended machine dependencies. This framework aids in understanding evolutionary trends, with classifications based on historical consensus in computing history.

Historical Development

Origins in the 1950s

The post-World War II era marked a pivotal shift in , as the rapid advancement of electronic computers like the introduced increasing hardware complexity that outpaced the capabilities of first-generation () and second-generation (assembly) languages. These earlier languages required programmers to manually encode instructions in binary or symbolic forms tightly bound to specific hardware architectures, leading to protracted development times, high error rates, and debugging efforts that consumed 25-50% of available machine time. The economic burden was substantial, with programming costs often equaling or exceeding the price of the computers themselves, prompting a demand for more efficient methods to accelerate software creation amid expanding applications in science and industry. This necessity drove the emergence of third-generation languages (3GLs), which aimed to abstract low-level details and enable faster, more portable coding. Key influences for 3GL development stemmed from the need to align programming with human-readable forms suited to distinct domains: for scientific and structured handling for processing. In scientific contexts, engineers and mathematicians sought languages that could directly express algebraic formulas without tedious machine-specific translations, reflecting the era's emphasis on numerical simulations and engineering calculations. applications, meanwhile, required tools for managing large-scale operations across diverse machines, influenced by the growth of commercial installations—reaching about 200 by 1955—and collaborative user groups like SHARE. These motivations converged in early projects, with IBM's (Formula Translation), released in 1957, recognized as the first 3GL, specifically designed to facilitate formula translation for engineers using English-like statements and mathematical expressions. A primary challenge in realizing 3GLs was the creation of compilers to bridge high-level code and machine instructions, overcoming the inefficiencies of prior interpretive systems that ran 5-10 times slower than hand-coded programs. , leading a small team at 's Programming Research Group—including members like Irving Ziller, Harlan Herrick, Robert A. Nelson, and Roy Nutt—initiated the project in late 1953, securing initial funding for feasibility studies on the IBM 704. By April 1957, they delivered the first , a one-pass system that generated efficient comparable to assembly, dramatically reducing coding effort—for instance, translating 1,000 manual instructions into just 47 high-level ones—while addressing hardware limitations like the absence of index registers. This breakthrough not only validated but also set the foundation for broader 3GL adoption.

Evolution Through the 1960s and 1970s

The proliferation of third-generation programming languages in the and was significantly propelled by the advent of minicomputers and systems, which democratized access to resources and encouraged the development of more versatile high-level languages. , pioneered in systems like the (CTSS) at MIT in 1961, enabled multiple users to interact with computers simultaneously, fostering interactive programming environments that favored languages closer to natural human expression over machine-oriented code. Minicomputers, such as the PDP-8 introduced by in 1965, reduced hardware costs and size, making computational power available to smaller organizations and accelerating the adoption of languages designed for specific domains. This hardware evolution directly supported the maturation of languages like , initiated in 1959 through a U.S. Department of Defense conference to create a standardized business-oriented language, and , developed between 1958 and 1960 as an international effort to formalize algorithmic expression. targeted commercial with English-like syntax for business applications, while emphasized precise algorithm description, influencing subsequent scientific and educational programming. A pivotal shift in this era was the introduction of paradigms, which sought to replace unstructured control flows like the statement with more disciplined constructs such as loops and conditionals, enhancing code readability and maintainability. This movement gained momentum following Edsger W. Dijkstra's influential 1968 letter, "Go To Statement Considered Harmful," published in Communications of the ACM, where he critiqued for complicating program verification and advocated for hierarchical control structures. Dijkstra's arguments, rooted in the growing complexity of software for time-shared systems, inspired revisions in languages like and influenced the design of newer ones, promoting block-structured code that aligned with the mathematical rigor of algorithm development. By the early 1970s, these principles were increasingly incorporated into third-generation languages, reducing reliance on ad-hoc jumps and supporting the collaborative programming demands of expanding user bases on minicomputers. Standardization efforts further solidified the portability and widespread implementation of these languages, addressing the fragmentation caused by vendor-specific variants. The (ANSI) released the first standard for in 1966 (ANSI X3.9-1966), formalizing features like subroutines and input/output operations to ensure compatibility across diverse hardware platforms. Similarly, achieved ANSI standardization in 1968, building on its 1959 specifications to define syntax for data manipulation and report generation, which facilitated its migration between systems in business environments. These standards, developed through committees involving industry and academic stakeholders, promoted amid the rise of and minicomputers, enabling developers to write code once for deployment on multiple architectures without extensive rewrites. Industrial adoption underscored the practical impact of these advancements, with third-generation languages becoming integral to mission-critical applications. extensively employed during the 1960s and 1970s for space programs, including trajectory calculations and simulation software at the , where numerous custom programs supported Apollo missions and analysis. In the financial sector, banks relied on for , leveraging its strengths in handling large-scale data files and batch operations; by 1970, had become the dominant language for such systems, powering automated and account management in institutions transitioning to computerized operations. This reliance stemmed from 's design for readable, maintainable code suited to non-scientific users, aligning with the era's economic push for efficient business computing on time-shared mainframes.

Key Characteristics

High-Level Abstraction

Third-generation programming languages achieve high-level abstraction by employing symbolic representations for data and operations that are decoupled from specific hardware architectures, enabling developers to express computations in a more intuitive, problem-oriented manner. This layer of abstraction includes built-in data types such as integers for whole numbers, floating-point types for approximate real numbers, and strings for textual data, which encapsulate memory layout and access patterns without requiring programmers to manage low-level details like bit-level manipulations or register assignments. Arithmetic, logical, and relational operations are similarly abstracted, allowing expressions to mimic mathematical notation rather than machine instructions, thereby enhancing productivity by focusing attention on algorithmic logic over hardware constraints. Central to this abstraction is the role of compilers and interpreters, which bridge the gap between high-level and machine-executable instructions through a multi-stage translation process. Compilers analyze the source code via lexical, syntactic, and semantic to build an , apply optimizations such as and to improve efficiency, and then generate intermediate or that is linked with system libraries to produce platform-specific binaries. Interpreters execute code more dynamically by reading statements sequentially, evaluating them on-the-fly without producing intermediate files, which supports but trades off some runtime performance. These tools encapsulate the complexity of hardware mapping, allowing 3GL code to remain agnostic to the target machine's instruction set or . Memory management in third-generation languages further exemplifies by automating allocation through declarations and scope mechanisms, obviating the need for explicit address arithmetic or manual pointer manipulation prevalent in prior generations. When variables are declared—such as assigning a type and name—the runtime or allocates contiguous blocks from the stack or heap, enforces bounds checking where applicable, and handles deallocation upon scope exit via stack unwinding or garbage collection in supported implementations. This declarative approach minimizes errors like dangling references or buffer overflows by leveraging type systems to validate access, promoting safer and more maintainable code without direct intervention in physical addressing. The resulting portability is a key advantage, as the hardware-independent design supports a "write once, compile anywhere" model where can be recompiled for diverse architectures with adjustments limited to conditional compilation directives. This cross-platform compatibility reduces development costs and accelerates deployment, as illustrated by the C language developed in 1972, which facilitated porting across UNIX variants and other systems through its balanced abstraction of low-level facilities while maintaining efficiency.

Structured Programming Features

Third-generation programming languages (3GLs) introduced core control structures that form the foundation of , enabling developers to organize in a logical, predictable manner. These include sequences, where statements execute one after another in order; selections, such as constructs that allow conditional branching based on conditions; and iterations, implemented via for or while loops that repeat a block of until a specified condition is met. Subroutines or functions further support by encapsulating reusable logic, allowing programmers to define modular blocks that can be invoked with parameters from other parts of the program. These elements collectively promote a procedural approach, where programs are built as a of tasks rather than flat, linear scripts. A pivotal advancement associated with 3GLs was the promotion of , which sought to minimize unstructured jumps like the statement in favor of verifiable . The , proved by Corrado Böhm and Giuseppe Jacopini in 1966, demonstrated that any computable algorithm can be expressed using only sequences, selections, and iterations, without arbitrary jumps. This theoretical foundation, combined with Edsger Dijkstra's 1968 critique labeling the statement as harmful due to its tendency to create convoluted, unmaintainable code, encouraged 3GL designers to prioritize these restricted structures. As a result, programs became easier to analyze, debug, and prove correct, fostering the widespread adoption of in languages like and Pascal. Modularity in 3GLs enhances organization through procedures, parameter passing, and scope rules, allowing complex programs to be decomposed into manageable, hierarchical components. Procedures define self-contained units of that receive inputs via parameters and produce outputs, promoting reusability and from low-level details. Scope rules delineate variable visibility, typically limiting access to local blocks to prevent unintended interactions and support . Most 3GLs incorporate these features to facilitate large-scale , where modules can be developed, tested, and maintained independently. To improve reliability over second-generation assembly languages, 3GLs incorporate compile-time mechanisms like validation and type checking, which detect before execution. validation ensures adherence to the language's , catching structural issues such as mismatched brackets or invalid keywords during compilation. Type checking verifies that operations involve compatible data types—e.g., preventing arithmetic on strings—reducing runtime crashes and subtle bugs common in untyped assembly code. These static analyses enable early detection, enhancing program correctness and developer productivity in procedural environments.

Notable Examples

Early Pioneers

The development of in 1957 by and his team at marked the advent of the first widely implemented third-generation programming language, specifically tailored for scientific and engineering computations on the computer. Its design emphasized , incorporating features such as arithmetic expressions, conditional statements, and iterative loops to allow scientists to express algorithms in a mathematical-like notation rather than machine-specific instructions. introduced fixed-form , where statements were formatted in 72-character punch cards with specific column positions for operations, keywords, and variables to facilitate input and reduce errors during . Additionally, it pioneered robust handling, supporting multi-dimensional arrays with up to three dimensions stored in column-major order, along with subscript expressions that enabled efficient manipulation of large datasets for simulations and calculations. In 1959, the Conference on Data Systems Languages (CODASYL) spearheaded the creation of COBOL as a standardized language for business data processing, aiming to bridge the gap between non-technical users and computer systems across diverse hardware. Drawing from earlier efforts like FLOW-MATIC, COBOL adopted an English-like syntax using verbose keywords and phrases—such as "ADD A TO B GIVING C" or "IF CONDITION THEN NEXT SENTENCE"—to enhance readability and make programs accessible to business analysts without deep programming expertise. The language prioritized business applications through structured divisions for data description, procedure logic, and environment configuration, with a strong emphasis on report generation via the Report Writer module, which supported formatted output, headings, footings, and control breaks for producing summaries and invoices. File input/output operations were central, featuring statements like OPEN, READ, WRITE, and REWRITE to handle sequential and indexed files on mass storage devices, facilitating tasks such as inventory management and payroll processing. ALGOL 60, formalized in a 1960 report by an international committee including and others, emerged as a pivotal algorithmic language that emphasized clarity and generality, influencing the syntactic foundations of subsequent high-level languages. Its block-structured paradigm allowed nested scopes for variables and statements, enabling modular code organization where local declarations within a block did not affect outer scopes, a concept that promoted and reuse in later languages like Pascal and . ALGOL 60 introduced sophisticated parameter passing mechanisms, including call-by-value, where actual arguments are copied to formal parameters as local values, and call-by-name, which substituted the actual expression into the procedure body for evaluation on each use, providing flexibility akin to later call-by-reference semantics. These early third-generation languages collectively transformed by abstracting away machine-specific details, enabling programmers to focus on problem logic rather than hardware intricacies. Contemporary reports from the late and early documented substantial productivity gains, with development times for complex programs reduced by factors of 10 to 100 compared to equivalents, primarily through minimized and coding efforts. , for instance, allowed over 80% of computational work at some installations to shift to high-level coding by 1958, while and similarly accelerated business and academic applications, establishing the viability of compilers for practical use.

Widely Adopted Languages

The , developed in 1972 by at Bell Laboratories, achieved widespread adoption for owing to its inclusion of pointers for direct memory manipulation and low-level hardware access. These features enabled efficient, portable code, making C the foundation for the Unix operating system, which was largely rewritten in it by 1973. Its influence extended to later developments, including object-oriented extensions that built upon its core syntax and control structures. Pascal, created in 1970 by at , saw broad and enduring use, particularly in education and early computing environments, due to its strong typing system that enforced data type consistency and promoted readable, maintainable code. The language's design emphasized structured programming principles, such as modular code organization, which facilitated its implementation on early microcomputers via systems like , a portable environment tailored for small systems with integrated editors and interpreters. Third-generation languages from earlier decades, including and , continue to demonstrate modern persistence in specialized domains. continues to underpin critical banking and financial systems, processing 80% of in-person transactions and 95% of transactions in the 2020s, with its robust data handling for large-scale operations. Similarly, remains a staple in scientific , powering simulations in fields like climate modeling and physics due to its high-performance array operations and with legacy codes. Within the third-generation paradigm, variants like C++, introduced in 1985 by at Bell Laboratories, extended C's capabilities by incorporating object-oriented features such as classes, inheritance, and polymorphism while preserving low-level control. This evolution maintained compatibility with existing C codebases, facilitating its adoption in for operating systems, applications, and embedded systems.

Comparisons and Transitions

Versus First- and Second-Generation Languages

Third-generation programming languages (3GLs) represent a significant advancement over first-generation languages (1GLs), which consist of in the form of binary instructions (sequences of 0s and 1s) directly executable by the processor. While 1GLs offer no and execute with minimal overhead, they are inherently non-portable, as code must be rewritten for different hardware architectures, and highly error-prone, requiring programmers to manage every bit manually without symbolic aids. In contrast, 3GLs fully abstract machine-level details through high-level syntax resembling or mathematics, allowing to be compiled into for various platforms, thus achieving complete portability and reducing errors by focusing on logic rather than hardware specifics. Compared to second-generation languages (2GLs), or assembly languages, which use human-readable mnemonics for opcodes along with labels and symbolic addresses that an assembler translates to binary, 3GLs further enhance usability by eliminating the need for hardware-specific instructions. Assembly code, while more readable than binary, remains tightly coupled to a particular processor architecture, necessitating revisions for to new hardware and still demanding detailed knowledge of registers and addressing. 3GLs introduce true hardware independence via compilers that translate abstract, platform-agnostic into optimized tailored to the target system, enabling reuse across diverse environments without manual adaptation. These abstractions yield substantial productivity gains in 3GLs—for instance, adding three variables might demand eight lines in assembly but a single statement in a 3GL. This conciseness translates to development speeds increased by orders of magnitude, as programmers focus on problem-solving rather than low-level implementation, with empirical studies showing productivity roughly 2 to 5 times higher in high-level languages compared to assembly. However, 3GLs introduce trade-offs; while compiled implementations achieve performance comparable to through optimizations, interpreted variants may incur runtime overhead that slows execution.

Influence on Fourth-Generation Languages

The success of third-generation languages (3GLs) in enhancing programmer productivity through high-level abstractions and structured constructs drove the transition to fourth-generation languages (4GLs), which further abstracted away procedural details to focus on declarative specifications for specific domains. By the mid-1970s, 3GLs like had demonstrated significant gains in development speed over earlier generations, but their verbose, step-by-step nature still required substantial code for routine tasks such as data querying and reporting, prompting innovations in non-procedural paradigms. This productivity imperative led to the emergence of 4GLs, exemplified by SQL in 1974, which abstracted database queries into English-like statements, reducing the need for explicit procedural logic in data manipulation. A key influence of 3GLs on 4GLs was their emphasis on and reusability, which inspired declarative styles that minimized procedural code while targeting domain-specific applications like and business reporting. 3GL features such as subroutines and data structures in languages like provided a foundation for 4GLs to build higher-level interfaces, allowing users to specify desired outcomes rather than execution steps, thereby achieving 5- to 50-fold improvements over 3GL equivalents in tasks like report generation. For instance, 's file handling routines, which often spanned hundreds of lines for processing sales data into monthly summaries, evolved into concise 4GL commands that automated such operations without algorithmic detail. This evolution is illustrated by tools like FOCUS, developed in 1975 by Information Builders as a 4GL for , which extended COBOL's data-oriented approach into interactive, end-user-friendly reporting on systems. FOCUS enabled non-programmers to generate complex reports from databases using simple directives, such as summarizing units by month, customer, and product with subtotals and page breaks—all in a single statement—contrasting sharply with COBOL's procedural overhead. By 1990, FOCUS had become the world's most widely used 4GL product, underscoring how 3GL successes in business applications catalyzed domain-focused tools. 4GLs addressed 3GL limitations in end-user and development time by leveraging underlying 3GL compilers for execution while prioritizing over general-purpose control, often restricting scope to specialized environments like query . Unlike 3GLs' broad applicability, 4GLs like SQL and FOCUS sacrificed flexibility for rapid in targeted areas, compiling declarative to 3GL intermediates or directly to machine instructions to maintain performance. This design choice enabled non-experts to handle database interactions that previously demanded programmers, though it highlighted trade-offs in customization compared to 3GLs' fine-grained control.

References

  1. https://www-users.york.ac.uk/~mijp1/teaching/4th_year_HPC/lecture_notes/Languages.pdf
  2. https://www.csee.umbc.edu/courses/undergraduate/331/resources/papers/sammet1972.pdf
  3. https://www.umsl.edu/~joshik/msis480/chapt05.htm
  4. https://nrs-projects.humboldt.edu/~st10/s11cs335/335lect15-2/maclennan-generations.pdf
  5. https://www.ebsco.com/research-starters/language-and-linguistics/computer-programming-languages
  6. https://archium.ateneo.edu/cgi/viewcontent.cgi?article=1171&context=ecce-faculty-pubs
  7. https://www.softwarepreservation.org/projects/FORTRAN/paper/p165-backus.pdf
  8. https://www.ibm.com/history/fortran
  9. https://www.researchgate.net/publication/263743154_When_Technology_Became_Language_The_Origins_of_the_Linguistic_Conception_of_Computer_Programming_1950-1960
  10. https://www.computerhistory.org/timeline/software-languages/
  11. https://www.britannica.com/technology/computer/Time-sharing-and-minicomputers
  12. https://dl.acm.org/doi/10.1145/960118.808378
  13. https://heerdebeer.org/ALGOL/The_History_of_ALGOL.pdf
  14. https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf
  15. https://wg5-fortran.org/ARCHIVE/Fortran66.pdf
  16. https://dl.acm.org/doi/pdf/10.5555/1074100.1074217
  17. https://ntrs.nasa.gov/api/citations/19910014734/downloads/19910014734.pdf
  18. https://ntrs.nasa.gov/api/citations/19880069935/downloads/19880069935_Optimized.pdf
  19. https://cacm.acm.org/article/lessons-from-pl-i-a-most-ambitious-programming-language/
  20. https://dl.acm.org/doi/10.1145/1455567.1455599
  21. https://www.sciencedirect.com/book/9780128154120/engineering-a-compiler
  22. https://dl.acm.org/doi/10.1145/234286.1057834
  23. https://www.cs.jhu.edu/~cs333/ProgrammingStructures.pdf
  24. https://dl.acm.org/doi/10.1145/355592.365646
  25. https://www.cise.ufl.edu/~mssz/Pascal-CGS2462/prog-dsn.html
  26. https://www.cs.cmu.edu/~fgandon/lecture/uk1999/intro_soft/
  27. https://www.cs.cmu.edu/~411/lectures/11-typecheck-1.pdf
  28. https://archive.computerhistory.org/resources/text/Fortran/102663113.05.01.acc.pdf
  29. https://dl.acm.org/doi/pdf/10.1145/800025.1198345
  30. https://nvlpubs.nist.gov/nistpubs/Legacy/hb/nbshandbook106.pdf
  31. https://dl.acm.org/doi/10.1145/367236.367262
  32. https://www.bell-labs.com/usr/dmr/www/chist.html
  33. https://dl.acm.org/doi/pdf/10.1145/953032.804618
  34. https://dl.acm.org/doi/10.1145/1500518.1500646
  35. https://www.ibm.com/think/topics/cobol
  36. https://astg.pages.smce.nasa.gov/website/fortran/
  37. https://dl.acm.org/doi/10.1145/234286.1057836
  38. https://eng.libretexts.org/Courses/Prince_Georges_Community_College/INT_1010%3A_Concepts_in_Computing/12%3A_Information_Systems_for_Business/12.10%3A_Information_Systems_Development/12.10.04%3A_Programming_Languages/12.10.4.01%3A_Language_Generations
  39. https://www.jhuapl.edu/techdigest/content/techdigest/pdf/V26-N04/26-04-Hanke.pdf
  40. https://www.ifpug.org/wp-content/uploads/2017/04/IYSM.-Thirty-years-of-IFPUG.-Software-Economics-and-Function-Point-Metrics-Capers-Jones.pdf
  41. https://homepage.cs.uri.edu/faculty/wolfe/book/programming/chapsix.html
  42. https://dl.acm.org/doi/10.1145/800296.811515
  43. https://www.ibi.com/about-us
  44. https://www.fundinguniverse.com/company-histories/information-builders-inc-history/
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.