Hubbry Logo
John BackusJohn BackusMain
Open search
John Backus
Community hub
John Backus
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
John Backus
John Backus
John Backus
View on Wikipedia
from Wikipedia

John Warner Backus (December 3, 1924 – March 17, 2007) was an American computer scientist. He led the team that invented and implemented FORTRAN, the first widely used high-level programming language, and was the inventor of the Backus–Naur form (BNF), a widely used notation to define syntaxes of formal languages. He also contributed to the design of ALGOL, and later researched the function-level programming paradigm, presenting his findings in his influential 1977 Turing Award lecture "Can Programming Be Liberated from the von Neumann Style?"[1]

Key Information

The IEEE awarded Backus the W. W. McDowell Award in 1967 for the development of FORTRAN.[2] He received the National Medal of Science in 1975[3] and the 1977 Turing Award "for profound, influential, and lasting contributions to the design of practical high-level programming systems, notably through his work on FORTRAN, and for publication of formal procedures for the specification of programming languages".[4]

John Backus retired in 1991. He died at his home in Ashland, Oregon on March 17, 2007.[5]

Early life

[edit]

Backus was born in Philadelphia and grew up in nearby Wilmington, Delaware.[6] He studied at The Hill School in Pottstown, Pennsylvania, but he was apparently not a diligent student.[5] He entered college at the University of Virginia to study chemistry, but struggled with his classes there, and he was expelled after less than a year for poor attendance.[7] He was subsequently conscripted into the U.S. Army during World War II,[5] and eventually came to hold the rank of corporal, being put in command of an anti-aircraft battery stationed at Fort Stewart, Georgia.[7]

After receiving high scores on a military aptitude test, the Army sent him to study engineering at the University of Pittsburgh.[7] He later transferred to a pre-medical program at Haverford College.[8] During an internship at a hospital, he was diagnosed with a cranial bone tumor, which was successfully removed, and a plate was installed in his head. He then moved to the Flower and Fifth Avenue Medical School for medical school, but found it uninteresting and dropped out after nine months.[7] He soon underwent a second operation to replace the metal plate in his head with one of his own design,[9] and received an honorable medical discharge from the U.S. Army in 1946.[7]

Fortran

[edit]

After moving to New York City he trained initially as a radio technician and became interested in mathematics. He graduated from Columbia University with a bachelor's degree in 1949 and a master's degree in 1950, both in mathematics,[7][10] and joined IBM in 1950. During his first three years, he worked on the Selective Sequence Electronic Calculator (SSEC); his first major project was to write a program to calculate positions of the Moon. In 1953, Backus developed the language Speedcoding, the first high-level language created for an IBM computer, to aid in software development for the IBM 701 computer.[11]

Programming was very difficult at this time, and in 1954 Backus assembled a team to define and develop Fortran for the IBM 704 computer. Fortran was the first high-level programming language to be put to broad use. This widely used language made computers practical and accessible machines for scientists and others without requiring them to have deep knowledge of the machinery.[12]

Backus–Naur form

[edit]
Main article: Backus–Naur form

Backus served on the international committees that developed ALGOL 58 and the very influential ALGOL 60, which quickly became the de facto worldwide standard for publishing algorithms. Backus developed the Backus–Naur form (BNF), published in the UNESCO report on ALGOL 58. It was a formal notation able to describe any context-free programming language, and was important in the development of compilers. A few deviations from this approach were tried (notably in Lisp and APL), but by the 1970s, Backus–Naur context-free specifications for computer languages had become quite standard, following the development of automated compiler generators such as yacc.

This contribution helped Backus win the Turing Award in 1977.

Function-level programming

[edit]

Backus later worked on a function-level programming language known as FP, which was described in his Turing Award lecture "Can Programming be Liberated from the von Neumann Style?".[1] Sometimes viewed as Backus's apology for creating Fortran, this paper did less to garner interest in the FP language than to spark research into functional programming in general. When Backus publicized the function-level style of programming, his message was mostly misunderstood[13] as being the same as traditional functional programming style languages.

FP was strongly inspired by Kenneth E. Iverson's APL, even using a non-standard character set. An FP interpreter was distributed with the 4.2BSD Unix operating system, but there were relatively few implementations of the language, most of which were used for educational purposes.

Backus spent the latter part of his career developing FL (from "Function Level"), a successor to FP. FL was an internal IBM research project, and development of the language stopped when the project was finished. Only a few papers documenting it remain, and the source code of the compiler described in them was not made public. FL was at odds with functional programming languages being developed in the 1980s, most of which were based on the lambda calculus and static typing systems instead of, as in APL, the concatenation of primitive operations. Many of the language's ideas have now been implemented in versions of the J programming language, Iverson's successor to APL.

Awards and honors

[edit]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

John Backus

View on Grokipedia
from Grokipedia
John Warner Backus (December 3, 1924 – March 17, 2007) was an American computer scientist best known for leading the development of FORTRAN, the first widely used high-level programming language, which revolutionized scientific computing and software development by enabling programmers to write code in a more intuitive, English-like syntax rather than machine-specific instructions. Born in Philadelphia, Pennsylvania, and raised in Wilmington, Delaware, as the son of a stockbroker, Backus overcame early academic challenges—including expulsion from the University of Virginia's chemistry program and dropping out of medical school—before earning a Bachelor of Science and Master of Arts in mathematics from Columbia University in 1949 and 1950, respectively. Backus joined IBM in 1950 as a programmer, embarking on a 41-year career that spanned roles from researcher to manager and culminated in his designation as an IBM Fellow in 1963, retiring in 1991 from facilities in Yorktown Heights, New York, and San Jose, California. His early work at IBM included contributions to the IBM 704, the company's first mass-produced computer featuring core memory and floating-point arithmetic, and the creation of Speedcoding in 1954, an early high-level programming system for the IBM 701 that simplified data manipulation for scientific applications. In 1954, Backus assembled a team of diverse experts—including programmers, mathematicians, and engineers—to tackle the inefficiencies of programming in assembly language, resulting in the successful release of FORTRAN in 1957, which dramatically reduced development time for complex calculations and influenced subsequent languages used in projects like NASA's Apollo missions. Beyond FORTRAN, Backus co-developed the Backus-Naur Form (BNF) in 1960 with Peter Naur, a formal notation for describing the syntax of programming languages that became a foundational standard in compiler design and language specification. Later in his career, he pioneered functional programming concepts through the design of the FP language in the 1970s and 1980s, advocating for computation models that treated programs as mathematical functions to enhance clarity and efficiency, as explored during his time as an adjunct professor at the University of California, Santa Cruz, in 1974 and visiting professor at UC Berkeley in 1980 and 1985. Backus's innovations earned him prestigious accolades, including the National Medal of Science in 1975, the ACM Turing Award in 1977 for his work on FORTRAN and BNF, the IEEE W. W. McDowell Award in 1967, the National Academy of Engineering's Charles Stark Draper Prize in 1993, and induction as a Computer History Museum Fellow in 1997; additionally, asteroid 6830 was named Johnbackus in his honor shortly after his death in 2007.

Early Life and Education

Childhood and Health Challenges

John Warner Backus was born on December 3, 1924, in Philadelphia, Pennsylvania, and raised in the affluent community of Wilmington, Delaware. His father, Cecil Franklin Backus, had trained as a chemist before becoming an investment banker, while his mother, Elizabeth Warner Edsall, was the daughter of a local physician; she passed away when Backus was eight and a half years old, leaving a lasting impact on the family dynamics. The family, which included an older sister and a younger brother, enjoyed a comfortable lifestyle, collecting American antique furniture, but Backus later described his relationship with his father as strained and complicated. Backus exhibited early academic difficulties, showing little interest in formal schooling and prioritizing social activities over studies. He attended the Tower Hill School in Wilmington before transferring to the Hill School in Pottstown, Pennsylvania, for his later prep years, from which he graduated in 1942. There, he admitted to consistently underperforming, stating, "I flunked out every year. I never studied. I was just goofing around," reflecting a rebellious disinterest in traditional education. His pursuits leaned toward leisure, including sailing and socializing, rather than intellectual endeavors, which exacerbated his challenges in a structured academic environment. Under pressure from his father to follow a practical path, Backus enrolled at the University of Virginia in 1943 to study chemistry but lasted only one semester before expulsion for poor academic performance and minimal class attendance. In his second semester, he registered solely for a music appreciation course, later recalling the campus atmosphere as one where "all anyone seemed to do... was drink themselves silly," highlighting his rebellious behavior and detachment from scholarly expectations. This episode marked a low point in his early life, underscoring the tensions between family expectations and his own inclinations. This turning point led him toward military service, which provided the discipline he had previously lacked.

Military Service and Academic Path

In 1943, at the age of 18, John Backus enlisted in the U.S. Army during World War II, serving until his discharge in 1946. Initially assigned to an antiaircraft crew at Fort Stewart, Georgia, where he rose to the rank of corporal, Backus was later transferred for specialized training, including pre-engineering studies at the University of Pittsburgh and pre-medical training at Haverford College. Due to a bone tumor requiring surgical intervention, he shifted to clerical and administrative roles in medical facilities, including work in a neurosurgery ward at an Atlantic City hospital. Following his discharge, Backus enrolled in medical school at Flower and Fifth Avenue Hospital in New York City but dropped out after about nine months, finding the emphasis on memorization unappealing. He then transferred to Columbia University, where he overcame initial academic difficulties to earn a B.S. in mathematics in 1949. His studies were supported by the GI Bill, and he found a newfound focus in mathematics after earlier disinterest in fields like chemistry and medicine. In 1950, he completed an M.S. in mathematics at Columbia, during which he took courses in electrical engineering and computing that sparked his interest in applied problem-solving. Backus's first significant exposure to computers came in 1950, shortly after receiving his master's degree, when he visited IBM's headquarters on Madison Avenue and toured the Selective Sequence Electronic Calculator (SSEC), one of the era's most advanced machines. Impressed by its ability to perform complex mathematical computations—such as calculating the moon's position using extensive series expansions—Backus recognized the transformative potential of such technology for mathematical work, prompting him to abandon pure mathematics for a career in computing. This encounter led directly to his hiring by IBM as an SSEC programmer, marking a pivotal shift in his professional trajectory.

Professional Career at IBM

Early Work and Speedcoding

John Backus joined IBM in 1950 as a mathematician-programmer at the Watson Scientific Computing Laboratory in New York, shortly after earning his master's degree in mathematics from Columbia University. His mathematical training provided a strong foundation for tackling complex computational problems in an era when programming was rudimentary and labor-intensive. In his initial role, Backus programmed the Selective Sequence Electronic Calculator (SSEC) for scientific computations, such as calculating astronomical positions. By 1952, he contributed to the development of the IBM 701, IBM's first commercial scientific computer, where he helped write assemblers to streamline the translation of symbolic instructions into machine code. These early efforts exposed him to the inefficiencies of low-level programming, where coders had to manage every detail manually on vacuum-tube machines. Frustrated by the dominance of assembly language, which prioritized execution speed but demanded weeks of effort for even modest programs, Backus developed Speedcoding in 1953 specifically for the IBM 701. This interpretive system functioned as a three-address floating-point calculator, incorporating features like automatic loops via address modification, built-in subroutines, and conditional transfers to simplify common operations and reduce instruction counts by up to half. Speedcoding dramatically cut coding time—from over two weeks in assembly to just days or even hours—making it feasible for non-expert users to prepare small scientific problems, though it imposed a 10- to 20-fold increase in runtime due to its interpretive overhead. Despite these advantages, Speedcoding faced resistance from engineers accustomed to assembly's efficiency, who dismissed high-level tools as impractical luxuries amid the high costs of early computing hardware. Backus noted that programming expenses often accounted for 50 to 75 percent of total computing costs, underscoring the need for such innovations to shift focus from tedious coding to problem-solving. This work laid crucial groundwork for more advanced languages by demonstrating the trade-offs between development speed and execution performance.

Development of Fortran

In late 1953, John Backus, then a programmer at IBM, drafted a proposal to develop an automatic programming system that would translate mathematical formulas into efficient machine code, addressing the high costs and complexity of assembly language programming for the IBM 704 computer. Facing skepticism from IBM management, who viewed the project as overly ambitious and risky, Backus persuaded Cuthbert Hurd, manager of the Applied Science Group, to approve it with a memo emphasizing potential economic savings in programming time. The Fortran team was formed shortly thereafter in early 1954 at IBM's headquarters in New York City, starting with four members—Backus, Irving Ziller, Harlan Herrick, and Robert Nelson—most of whom were young mathematicians and programmers, and expanding to around ten by the project's later stages. The team's primary design goals centered on creating a language that enabled scientists and engineers to write programs in a notation close to mathematical expressions, while generating object code as fast as hand-optimized assembly. Key features included indexed variables for array handling, the DO loop for iterative computations, and IF statements for basic conditional logic, all tailored to the floating-point capabilities of the IBM 704. Development progressed from 1954 to 1957, marked by the release of a preliminary report on November 10, 1954, which outlined the language specifications, followed by intensive compiler implementation in machine language. This work built on precursors like Speedcoding, an earlier interpretive system that demonstrated the value of higher-level abstraction but suffered from performance limitations. A major innovation was the creation of the first optimizing compiler, which employed techniques such as data flow analysis to track variable dependencies and register allocation to minimize memory access, ensuring generated code rivaled expert hand-coding in speed. Fortran I, the initial version, was released for distribution in April 1957 after roughly three years of effort, encompassing over 25,000 lines of assembly code for the compiler itself. Upon release, Fortran rapidly gained traction in scientific computing, with the compiler installed at IBM 704 sites starting in 1957; by late 1958, more than half of the approximately 60 such installations were using it to generate the majority of their instructions. This accessibility for non-expert programmers reduced development time dramatically—for instance, complex programs that once required thousands of assembly instructions could be expressed in dozens of Fortran statements—while contributing to increased adoption and sales of the IBM 704.

Contributions to ALGOL and Backus-Naur Form

In 1958, John Backus represented IBM at the ALGOL 58 conference held in Zurich, Switzerland, from May 27 to June 3, where he joined other American delegates in advocating for a programming language that incorporated mathematical notation to enhance expressiveness and readability. As a member of the ACM subcommittee formed earlier that year, Backus co-authored the Preliminary Report—International Algebraic Language, which outlined the initial specifications for what became ALGOL 58. Backus continued his involvement in ALGOL's evolution by leading the U.S. subcommittee during the 1959–1960 revisions, culminating in his attendance at the Paris meeting in January 1960 as one of six American representatives. During this period, he developed a formal notation for describing syntax, initially termed Backus Normal Form, which was first presented in his 1959 paper on the syntax and semantics of the proposed International Algebraic Language. This notation, later refined and popularized as Backus-Naur Form (BNF) by Peter Naur in the ALGOL 60 report, provided a metalanguage for defining recursive context-free grammars using production rules of the form <nonterminal> ::= expression. BNF's structure specifies non-terminal symbols enclosed in angle brackets (e.g., <integer>), terminal symbols in quotes (e.g., "+"), and alternatives separated by a vertical bar | (e.g., <sign> ::= "+" | "-"). For instance, a simple arithmetic expression might be defined as:

<expression> ::= <term> | <expression> "+" <term> | <expression> "-" <term> <term> ::= <factor> | <term> "*" <factor> | <term> "/" <factor> <factor> ::= <integer> | "(" <expression> ")"

<expression> ::= <term> | <expression> "+" <term> | <expression> "-" <term> <term> ::= <factor> | <term> "*" <factor> | <term> "/" <factor> <factor> ::= <integer> | "(" <expression> ")"

This formal approach revolutionized compiler design by enabling the systematic generation of parsers, such as LL (top-down) and LR (bottom-up) algorithms, which process input left-to-right while constructing parse trees for deterministic context-free languages. BNF's declarative nature allowed language designers to specify syntax unambiguously, facilitating automated tools that detect errors and support semantic analysis in compilers. The success of Fortran lent Backus significant credibility, positioning him as a key figure in these international efforts to standardize algorithmic languages. In 1960, Backus transitioned to IBM Research, where he could dedicate himself more fully to theoretical work in programming language design.

Later Innovations and Research

Function-Level Programming and the FP Language

In the 1970s, John Backus turned his attention to theoretical computer science, motivated by a desire to address the fundamental limitations of the von Neumann architecture that had shaped computing since the 1940s. In his 1977 Turing Award lecture, published in 1978, Backus critiqued how this architecture's "word-at-a-time bottleneck"—a single pathway for data and instructions—forces programmers into sequential, state-dependent thinking that mirrors machine-level operations rather than higher-level abstractions. He argued that conventional programming languages, bound by this model, suffer from weak expressive power, excessive complexity in handling control flow and data structures, and a lack of mathematical structure for reasoning about programs, as assignments create a rigid split between expressions (which compute values) and statements (which update state). To overcome these constraints, Backus proposed function-level programming as an alternative paradigm, where programs are constructed purely as compositions of higher-order functions operating on data without any variables, assignments, or mutable state. This applicative-style approach emphasizes defining computations through function application and combination, treating functions themselves as first-class objects that can be passed as arguments or returned as results, thereby enabling more modular, hierarchical, and mathematically tractable program design. Unlike variable-based paradigms, function-level programming avoids side effects, allowing programs to be viewed as transformations on structured data aggregates, such as sequences, in a way that supports formal algebraic manipulation. Backus formalized these ideas in the FP (Functional Programming) language, designed in 1977 at IBM's Thomas J. Watson Research Center as a practical system for function-level programming. FP's core revolves around a small set of primitive functions (e.g., for arithmetic and selection) combined via functional forms, including composition (denoted ∘, applying one function after another, as in f ∘ g), construction (building sequences from functions, as in [f, g]), insertion (reducing a sequence using a binary function, as in /f), apply-to-all (mapping a function over a sequence, as in αf), and others like conditional and iteration forms. FP employs strict evaluation, where all function applications are fully computed before proceeding, ensuring that undefined values (denoted ⊥) propagate consistently without partial results. An initial implementation of FP was completed in 1978 on the IBM System/370 mainframe, demonstrating its feasibility for real-world computation despite the paradigm's novelty. Building on FP, Backus pursued extensions in the 1980s to address scalability and concurrency, developing FL—a simplified subset of FP—at IBM's Almaden Research Center in collaboration with John H. Williams and Edward L. Wimmers. FL was specifically tailored to explore parallel processing, leveraging FP's stateless nature to enable automatic detection and exploitation of parallelism in function compositions without explicit thread management, making it suitable for emerging multiprocessor architectures. In a seminal 1981 paper, Backus formalized the underlying mathematics through an algebra of functional programs, introducing concepts like function-level reasoning via equivalence laws, solving linear equations over function spaces for optimization, and extended definitions to handle recursion and iteration algebraically—providing tools for program transformation and verification that treat functions as elements in a ring-like structure. Despite these innovations, FP and its variants like FL were not widely adopted, largely due to their steep learning curve, lack of familiar imperative features, and the dominance of lambda-calculus-based functional languages that better integrated with existing tools. Nonetheless, Backus's work exerted a lasting influence on modern functional programming languages such as Haskell, by pioneering the use of higher-order functions, applicative computation, and algebraic program analysis, which inspired subsequent research into pure, declarative paradigms and their implementation on parallel hardware.

Retirement and Post-IBM Activities

Backus was appointed an IBM Fellow in 1963, a prestigious position that allowed him to pursue independent research until his retirement from the company on October 31, 1991, at the age of 66, after 41 years of service. His work on function-level programming and the FP language represented his final major contribution during this period at IBM's research facilities in Yorktown Heights, New York, and San Jose, California. Following retirement, Backus resided in San Jose until the death of his second wife, Barbara Una Stannard, in 2004, after which he relocated to Ashland, Oregon, to live near his daughter Paula. In Oregon, he largely withdrew from professional circles, engaging in limited public activities such as an oral history interview in 2006, and produced no major new publications after the 1980s. He devoted time to personal hobbies, including music and reading histories and biographies. Backus's personal life included two marriages: his first to Marjorie Ruth Jamison in 1947, with whom he had two daughters, Karen and Paula, ending in divorce in 1966; and his second to Barbara Una Stannard in 1968. He experienced ongoing health challenges stemming from a bone tumor removed during a hospital internship in the 1940s, which necessitated the insertion of a metal plate in his skull and later surgical adjustments to address curvature issues.

Recognition and Legacy

Awards and Honors

John Backus received numerous prestigious awards recognizing his pioneering contributions to computer science, particularly in the development of high-level programming languages and compiler design. In 1963, he was named an IBM Fellow, a distinction that acknowledged his leadership in creating FORTRAN and allowed him to pursue independent research at IBM's facilities. In 1967, Backus was awarded the W. Wallace McDowell Award by the IEEE Computer Society for his theoretical contributions to computing, especially in compiler design and the development of FORTRAN, which revolutionized programming efficiency. The following year, his work continued to garner recognition, though major honors accelerated in the 1970s. Backus was elected to the National Academy of Sciences in 1974. He was elected to the National Academy of Engineering in 1975 for his development of FORTRAN, the first widely used, general-purpose, high-level programming language. That same year, President Gerald Ford presented him with the National Medal of Science, honoring his advancements in programming languages, including FORTRAN, which made complex computations accessible to non-specialists. In 1977, he received the ACM Turing Award individually for his profound, influential, and lasting contributions to the design of practical high-level programming systems, notably FORTRAN and the Backus-Naur Form (BNF) for syntax notation; during his acceptance lecture, he critiqued the limitations of imperative programming paradigms. In 1985, Backus was elected to the American Academy of Arts and Sciences as a recognition of his intellectual achievements in computer science. Later in his career, Backus was awarded the Charles Stark Draper Prize by the National Academy of Engineering in 1993 for his engineering innovations in computing, specifically the invention of FORTRAN, which transformed software development and enabled widespread scientific computing. In 1997, he was inducted as a Fellow of the Computer History Museum for his development of FORTRAN and contributions to computer systems theory and software project management. Shortly after his death in 2007, asteroid 6830 was named Johnbackus in his honor. These honors underscored the enduring impact of his work on the foundations of modern programming.

Impact on Computer Science

John Backus's development of FORTRAN revolutionized software development by introducing the first practical high-level programming language, which dramatically increased programmer productivity and made computational tools accessible to scientists and engineers without deep expertise in machine code. Prior to FORTRAN, programming costs often exceeded machine runtime costs by factors of up to 10 or more on early systems like the IBM 704, but FORTRAN's compiler enabled code that ran within 20% of hand-optimized assembly in many cases, allowing complex scientific simulations in physics, engineering, and weather forecasting to flourish. This shift democratized programming, transforming computing from a hardware-centric activity dominated by specialists into a broader discipline that supported interdisciplinary applications, with FORTRAN remaining the dominant language for high-performance scientific computing decades later. Backus's co-invention of the Backus-Naur Form (BNF) established a formal standard for describing programming language syntax, profoundly influencing the design and specification of subsequent languages such as Pascal, C, and Java. Introduced in the ALGOL 60 report, BNF provided a metalanguage for unambiguous grammar definitions, enabling the creation of parsers and compilers through systematic methods rather than ad hoc approaches. Its adoption became foundational to formal language theory, automated syntax analysis tools, and the standardization efforts that underpin modern compiler design, ensuring portability and verifiability across diverse systems. Through his later work on function-level programming and the FP language, Backus pioneered alternatives to imperative paradigms, emphasizing pure functions and algebraic transformations that inspired key concepts in contemporary functional languages. FP's variable-free style and support for higher-order functions influenced lazy evaluation and parallelism in languages like Miranda and Haskell, where side-effect-free compositions facilitate automatic parallel execution without explicit synchronization. This challenged the von Neumann bottleneck of sequential state updates, promoting a view of programs as mathematical expressions amenable to optimization and concurrency, which resonated in Lisp variants and spurred research into declarative computing. Backus's contributions collectively shifted the focus of computer science from low-level hardware emulation to high-level abstraction and software engineering principles, inspiring generations of researchers to prioritize expressive, verifiable systems over machine-specific details. His ideas permeate modern curricula in programming languages and formal methods, while his induction into institutions like the Computer History Museum underscores a legacy that extends to ethical reflections on computing's role in society, balancing technological advancement with human-centered concerns.

References

  1. https://www.ibm.com/history/john-backus
  2. https://amturing.acm.org/award_winners/backus_0703524.cfm
  3. https://mathshistory.st-andrews.ac.uk/Biographies/Backus/
  4. https://archive.computerhistory.org/resources/text/Oral_History/Backus_John/Backus_John_1.oral_history.2006.102657970.pdf
  5. https://www.nytimes.com/2007/03/20/world/americas/20iht-obits.4966553.html
  6. https://lemelson.mit.edu/resources/john-backus
  7. https://www.columbia.edu/cu/computinghistory/backus.html
  8. https://www.nature.com/articles/446998a
  9. http://www.columbia.edu/cu/computinghistory/backus.html
  10. https://archive.computerhistory.org/resources/text/Fortran/102663108.05.01.acc.pdf
  11. https://dl.acm.org/doi/pdf/10.1145/800025.1198345
  12. https://dl.acm.org/doi/10.1145/800025.1198345
  13. https://www.ibm.com/history/fortran
  14. https://web.eecs.utk.edu/~bmaclenn/POPL/ch2.pdf
  15. https://dl.acm.org/doi/10.1145/368273.368275
  16. https://www.softwarepreservation.org/projects/ALGOL/paper/Backus-Syntax_and_Semantics_of_Proposed_IAL.pdf
  17. https://www.softwarepreservation.org/projects/ALGOL/report/Algol60_report_CACM_1960_June.pdf
  18. https://history.computer.org/pioneers/backus.html
  19. https://dl.acm.org/doi/10.1145/359576.359579
  20. https://link.springer.com/chapter/10.1007/3-540-10699-5_91
  21. https://dl.acm.org/doi/10.1145/1238844.1238856
  22. https://ethw.org/John_Backus
  23. https://ethw.org/w/images/b/bd/IEEE_1967-03_OCR.pdf
  24. https://www.nytimes.com/1974/04/28/archives/science-academy-elects-96-members.html
  25. https://www.nsf.gov/honorary-awards/national-medal-science/recipients/john-w-backus
  26. https://awards.acm.org/award-recipients/backus_0703524
  27. https://www.amacad.org/person/john-backus
  28. https://www.naeawardsonline.com/docs/nae/NAE_Guide_2023.pdf
  29. https://computerhistory.org/profile/john-backus/
  30. https://ssd.jpl.nasa.gov/tools/sbdb_lookup.html#/?sstr=6830
  31. https://www.computerhistory.org/timeline/software-languages/
  32. https://dl.acm.org/doi/10.1145/512927.512934
  33. https://dl.acm.org/doi/pdf/10.1145/72551.72554
Add your contribution
Related Hubs
User Avatar
No comments yet.