CramX Logo
RegisterLog in
Solution Manual for Concepts of Programming Languages, 12th Edition - Document preview page 1

Solution Manual for Concepts of Programming Languages, 12th Edition - Page 1

Document preview content for Solution Manual for Concepts of Programming Languages, 12th Edition

Solution Manual for Concepts of Programming Languages, 12th Edition

Struggling with assignments? Solution Manual for Concepts of Programming Languages, 12th Edition has all the answers you need!

Ava Martinez
Contributor
4.5
60
over 1 year ago
Preview (19 of 60 Pages)
100%
Log in to unlock
Page 1 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 1 preview imageInstructor’s Solutions ManualtoConcepts of Programming LanguagesTwelfthEditionR.W. Sebesta
Page 2 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 2 preview image
Page 3 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 3 preview image2PrefaceChanges for theTwelfthEditionhegoals,overallstructure,andapproachofthistwelftheditionofConcepts of Programming Languagesremain the same as those of theelevenearliereditions.Theprincipalgoalsaretointroducethefundamental constructs of contemporary programming languages and toprovide the reader with the tools necessary for the critical evaluation ofexisting and future programming languages. A secondary goal is to prepare thereader for the study of compiler design, by providing an in-depth discussion ofprogramming language structures, presenting a formal method of describingsyntax, and introducing approaches to lexical and syntactic analysis.Thetwelfthedition evolved from theelevenththrough several different kindsof changes. To maintain the currency of the material,nearly allof the discussionofsomeprogramming languages,specificallyLuaandObjective-C, has beenremoved.Material on the newer language, Swift, was added to several chapters.In addition, a new section on optional types was added to Chapter 6. Materialwas added to Section 8.3.4 to describe iterators in Python. In numerous places inthe manuscript small changes were made to correct and/or clarify the discussion.The VisionThis book describes the fundamental concepts of programming languages bydiscussing the design issues of the various language constructs, examining thedesign choices for these constructs in some of the most common languages, andcritically comparing design alternatives.Any serious study of programming languages requires an examination ofsome related topics, among which are formal methods of describing the syntaxand semantics of programming languages, which are covered in Chapter 3. Also,implementation techniques for various language constructs must be considered:Lexical and syntax analysis are discussed in Chapter 4, and implementation ofT
Page 4 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 4 preview image3subprogram linkage is covered in Chapter 10. Implementation of some otherlanguage constructs is discussed in various other parts of the book.The following paragraphs outline the contents of thetwelfthedition.Chapter OutlinesChapter 1 begins with a rationale for studying programming languages. It thendiscusses the criteria used for evaluating programming languages and languageconstructs. The primary influences on language design, common design trade-offs, and the basic approaches to implementation are also examined.Chapter 2 outlines the evolution of the languages that are discussed in thisbook. Although no attempt is made to describe any language completely, theorigins,purposes,andcontributionsofeacharediscussed.Thishistoricaloverviewisvaluable,becauseitprovidesthebackgroundnecessarytounderstanding the practical and theoretical basis for contemporary languagedesign. It also motivates further study of language design and evaluation. Becausenone of the remainder of the book depends on Chapter 2, it can be read on itsown, independent of the other chapters.Chapter 3 describes the primary formal method for describing the syntax ofprogramming language—BNF. This is followed by a description of attributegrammars, which describe both the syntax and static semantics of languages. Thedifficulttaskofsemanticdescriptionisthenexplored,includingbriefintroductions to the three most common methods: operational, denotational, andaxiomatic semantics.Chapter 4 introduces lexical and syntax analysis. This chapter is targeted tothose Computer Science departments that no longer require a compiler designcourse in their curricula. Similar to Chapter 2, this chapter stands alone and can bestudied independently of the rest of the book, except for Chapter 3, on which itdepends.Chapters 5 through 14 describe in detail the design issues for the primaryconstructs of programming languages. In each case, the design choices for severalexample languages are presented and evaluated. Specifically, Chapter 5 covers themany characteristics of variables, Chapter 6 covers data types, and Chapter 7explains expressions and assignment statements. Chapter 8 describes controlstatements, and Chapters 9 and 10 discuss subprograms and their implementation.Chapter 11 examines data abstraction facilities. Chapter 12 provides an in-depth
Page 5 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 5 preview image4discussionoflanguagefeaturesthatsupportobject-orientedprogramming(inheritance and dynamic method binding), Chapter 13 discusses concurrentprogram units, and Chapter 14 is about exception handling, along with a briefdiscussion of event handling.Chapters15and16describetwoofthemostimportantalternativeprogrammingparadigms:functionalprogrammingandlogicprogramming.However,someof thedatastructures andcontrolconstructs offunctionalprogramming languages are discussed in Chapters 6 and 8. Chapter 15 presents anintroduction to Scheme, including descriptions of some of its primitive functions,special forms, and functional forms, as well as some examples of simple functionswritten in Scheme. Brief introductions to ML, Haskell, and F# are given toillustrate some different directions in functional language design. Chapter 16introduces logic programming and the logic programming language, Prolog.To the InstructorChapters 1 and 3 are typically covered in detail, and though students find itinteresting and beneficial reading, Chapter 2 receives little lecture time due to thelack of hard technical content.Because no material in subsequent chaptersdepends on Chapter 2, it can be skipped entirely. If a course in compiler design isrequired, Chapter 4 is not covered.Chapters 5 through 9 should be relatively easy for students with extensiveprogramming experience in C++, Java, or C#. Chapters 10 through 14 are morechallenging and require more detailed lectures.Chapters 15 and 16 are entirely new to most students at the junior level.Ideally, language processors for Scheme and Prolog should be available forstudents required to learn the material in these chapters. Sufficient material isincluded to allow students to dabble with some simple programs.Undergraduate courses will probably not be able to cover all of the materialin the last two chapters. Graduate courses, however, should be able to completelydiscuss the material in those chapters by skipping over some parts of the earlychapters on imperative languages.
Page 6 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 6 preview image5Supplemental MaterialsThefollowingsupplementsareavailabletoallreadersofthisbookatwww.pearsonhighered.com/cs-resources/.•A set of lecture note slides. PowerPoint slides are available for eachchapter in the book.•All of the figures from the book.AcompanionWebsitetothebookisavailableatwww.pearson.com/cs-resources/. This site contains mini-manuals (approximately 100-page tutorials) ona handful of languages.Solutions to many of the problem sets are available to qualified instructors inour Instructor Resource Center atwww.pearson.com. Please contact your school’sPearson Education representative or visitwww.pearson.com to register.Language Processor AvailabilityProcessorsfor andinformation aboutsomeoftheprogramminglanguagesdiscussed in this book can be found at the following Web sites:C, C++, Fortran, and Adagcc.gnu.orgC# and F#microsoft.comJavajava.sun.comHaskellhaskell.orgSchemewww.plt-scheme.org/software/drschemePerlwww.perl.comPythonwww.python.orgRubywww.ruby-lang.orgJavaScript is included in virtually all browsers; PHP is included in virtually allWeb servers.All this information is also included on the companion Web site.
Page 7 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 7 preview image6AcknowledgmentsThe suggestions from outstanding reviewers contributed greatly to this book’s present form and contents. Inalphabetical order, they are:Aaron RababaahUniversity of Maryland at Eastern ShoreAmar RahejaCalifornia State Polytechnic University–PomonaAmer DiwanUniversity of ColoradoBob NeufeldWichita State UniversityBruce R. MaximUniversity of Michigan–DearbornCharles NicholasUniversity of Maryland–Baltimore CountyCristian Videira LopesUniversity of California–IrvineCurtis MeadowUniversity of MaineDavid E. GoldschmidtDonald KraftLouisiana State UniversityDuane J. JarcUniversity of Maryland, University CollegeEuripides MontagneUniversity of Central FloridaFrank J. MitropoulosNova Southeastern UniversityGloria MelaraCalifornia State University–NorthridgeHossein SaiedianUniversity of KansasI-ping ChuDePaul UniversityIan BarlandRadford UniversityK. N. KingGeorgia State UniversityKarina AssiterWentworth Institute of TechnologyMark LlewellynUniversity of Central Florida
Page 8 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 8 preview image7Matthew Michael BurkeMichael PrenticeSUNY BuffaloNancy TinkhamRowan UniversityNeelam SoundarajanOhio State UniversityNigel GweeSouthern University–Baton RougePamela CutterKalamazoo CollegePaul M. JackowitzUniversity of ScrantonPaul TymannRochester Institute of TechnologyRichard M. OsborneUniversity of Colorado–DenverRichard MinUniversity of Texas at DallasRobert McCloskeyUniversity of ScrantonRyan StansiferFlorida Institute of TechnologySalih YurttasTexas A&M UniversitySaverio PeruginiUniversity of DaytonSerita NelesenCalvin CollegeSimon H. LinCalifornia State University–NorthridgeStephen EdwardsVirginia TechStuart C. ShapiroSUNY BuffaloSumanth YenduriUniversity of Southern MississippiTeresa ColeBoise State UniversityThomas TurnerUniversity of Central OklahomaTim R. NortonUniversity of Colorado–Colorado SpringsTimothy HenryUniversity of Rhode IslandWalter PharrCollege of CharlestonXiangyan ZengFort Valley State UniversityNumerous other people provided input for the previous editions ofConceptsof Programming Languagesat various stages of its development. All of their
Page 9 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 9 preview image8comments were useful and greatly appreciated. In alphabetical order, they are:Vicki Allan, Henry Bauer, Carter Bays, Manuel E. Bermudez, Peter Brouwer,Margaret Burnett, Paosheng Chang, Liang Cheng, John Crenshaw, Charles Dana,Barbara Ann Griem, Mary Lou Haag, John V. Harrison, Eileen Head, Ralph C.Hilzer, Eric Joanis, Leon Jololian, Hikyoo Koh, Jiang B. Liu, Meiliu Lu, JonMauney, Robert McCoard, Dennis L. Mumaugh, Michael G. Murphy, AndrewOldroyd, Young Park, Rebecca Parsons, Steve J. Phelps, Jeffery Popyack, StevenRapkin, Hamilton Richard, Tom Sager, Raghvinder Sangwan, Joseph Schell,Sibylle Schupp, Mary Louise Soffa, Neelam Soundarajan, Ryan Stansifer, SteveStevenson, Virginia Teller, Yang Wang, John M. Weiss, Franck Xia, and SalihYurnas.Matt Goldstein,Portfolio Management Specialist;Meghan Jacoby, PortfolioManagement Assistant; Managing Content Producer, Scott Disanno; and PrathibaRajagopal, all deserve my gratitude for their efforts to produce the twelfth editionboth quickly and carefully.About the AuthorRobert Sebesta is an Associate Professor Emeritus in the Computer ScienceDepartment at the University of Colorado–Colorado Springs. Professor Sebestareceived a BS in applied mathematics from the University of Colorado in BoulderandMSandPhDdegreesincomputersciencefromPennsylvaniaStateUniversity. He taught computer science for more than 40 years..
Page 10 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 10 preview image9ContentsChapter 1Preliminaries11.1Reasons for Studying Concepts of Programming Languages...................21.2Programming Domains..........................................................................51.3Language Evaluation Criteria.................................................................61.4Influences on Language Design...........................................................171.5Language Categories...........................................................................201.6Language Design Trade-Offs...............................................................211.7Implementation Methods.....................................................................221.8Programming Environments................................................................29Summary • Review Questions • Problem Set...................................................30Chapter 2Evolution of the Major Programming Languages332.1Zuse’s Plankalkül................................................................................362.2Pseudocodes........................................................................................372.3The IBM 704 and Fortran....................................................................402.4Functional Programming: Lisp.............................................................452.5The First Step Toward Sophistication: ALGOL 60...............................502.6Computerizing Business Records: COBOL..........................................562.7The Beginnings of Timesharing: Basic.................................................61Interview:ALAN COOPER—User Design and Language Design................642.8Everything for Everybody: PL/I...........................................................66
Page 11 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 11 preview image102.9Two Early Dynamic Languages: APL and SNOBOL............................692.10The Beginnings of Data Abstraction: SIMULA 67...............................702.11Orthogonal Design: ALGOL 68...........................................................712.12Some Early Descendants of the ALGOLs.............................................732.13Programming Based on Logic: Prolog..................................................772.14History’s Largest Design Effort: Ada...................................................792.15Object-Oriented Programming: Smalltalk.............................................832.16Combining Imperative and Object-Oriented Features: C++...................852.17An Imperative-Based Object-Oriented Language: Java.........................882.18Scripting Languages............................................................................912.19The Flagship .NET Language: C#........................................................982.20Markup-Programming Hybrid Languages..........................................100Summary • Bibliographic Notes • Review Questions • Problem Set •ProgrammingExercises......................................................................................................102Chapter 3Describing Syntax and Semantics1093.1Introduction.......................................................................................1103.2The General Problem of Describing Syntax........................................1113.3Formal Methods of Describing Syntax...............................................1133.4Attribute Grammars...........................................................................128History Note...........................................................................................1283.5Describing the Meanings of Programs: Dynamic Semantics...............134History Note...........................................................................................142Summary • Bibliographic Notes • Review Questions • Problem Set................155Chapter 4Lexical and Syntax Analysis1614.1Introduction.......................................................................................1624.2Lexical Analysis................................................................................163
Page 12 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 12 preview image114.3The Parsing Problem.........................................................................1714.4Recursive-Descent Parsing.................................................................1754.5Bottom-Up Parsing............................................................................183Summary • Review Questions • Problem Set • Programming Exercises..........191Chapter 5Names, Bindings, and Scopes1975.1Introduction.......................................................................................1985.2Names...............................................................................................199History Note...........................................................................................1995.3Variables...........................................................................................2005.4The Concept of Binding.....................................................................2035.5Scope................................................................................................2115.6Scope and Lifetime............................................................................2225.7Referencing Environments.................................................................2235.8Named Constants...............................................................................224Summary • Review Questions • Problem Set •Programming Exercises...........227Chapter 6Data Types2356.1Introduction.......................................................................................2366.2Primitive Data Types.........................................................................2386.3Character String Types......................................................................242History Note...........................................................................................2436.4Enumeration Types............................................................................2476.5Array Types......................................................................................250History Note...........................................................................................251History Note...........................................................................................2516.6Associative Arrays.............................................................................261
Page 13 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 13 preview image126.7Record Types....................................................................................2656.8Tuple Types......................................................................................2686.9List Types.........................................................................................2706.10Union Types......................................................................................2726.11Pointer and Reference Types..............................................................275History Note...........................................................................................2786.12OptionalTypes..................................................................................2876.13Type Checking..................................................................................2876.14Strong Typing...................................................................................2886.15Type Equivalence..............................................................................2896.16Theory and Data Types......................................................................293Summary • Bibliographic Notes • Review Questions • Problem Set •ProgrammingExercises......................................................................................................295Chapter 7Expressions and Assignment Statements3017.1Introduction.......................................................................................3027.2Arithmetic Expressions......................................................................3027.3Overloaded Operators........................................................................3117.4Type Conversions..............................................................................313History Note...........................................................................................3157.5Relational and Boolean Expressions...................................................316History Note...........................................................................................3167.6Short-Circuit Evaluation....................................................................3187.7Assignment Statements......................................................................319History Note...........................................................................................3237.8Mixed-Mode Assignment..................................................................324Summary • Review Questions • Problem Set • Programming Exercises...........324
Page 14 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 14 preview image13Chapter 8Statement-Level Control Structures3298.1Introduction.......................................................................................3308.2Selection Statements..........................................................................3328.3Iterative Statements...........................................................................3438.4Unconditional Branching...................................................................355History Note...........................................................................................3558.5Guarded Commands..........................................................................3568.6Conclusions.......................................................................................358Summary • Review Questions • Problem Set • Programming Exercises............359Chapter 9Subprograms3659.1Introduction.......................................................................................3669.2Fundamentals of Subprograms...........................................................3669.3Design Issues for Subprograms..........................................................3749.4Local Referencing Environments.......................................................3759.5Parameter-Passing Methods...............................................................377History Note...........................................................................................385History Note...........................................................................................3859.6Parameters That Are Subprograms.....................................................393History Note...........................................................................................3959.7Calling Subprograms Indirectly.........................................................3959.8Design Issues for Functions...............................................................3979.9Overloaded Subprograms...................................................................3999.10Generic Subprograms........................................................................4009.11User-Defined Overloaded Operators..................................................4069.12Closures............................................................................................4069.13Coroutines.........................................................................................408
Page 15 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 15 preview image14Summary • Review Questions • Problem Set • Programming Exercises............411Chapter 10Implementing Subprograms41710.1The General Semantics of Calls and Returns......................................41810.2Implementing “Simple” Subprograms................................................41910.3Implementing Subprograms with Stack-Dynamic Local Variables......42110.4Nested Subprograms..........................................................................42910.5Blocks...............................................................................................43610.6Implementing Dynamic Scoping........................................................437Summary • Review Questions • Problem Set • Programming Exercises............441Chapter 11Abstract Data Types and Encapsulation Constructs44711.1The Concept of Abstraction...............................................................44811.2Introduction to Data Abstraction........................................................44911.3Design Issues for Abstract Data Types...............................................45211.4Language Examples...........................................................................453Interview:BJARNE STROUSTRUP—C++: Its Birth,Its Ubiquitousness, and Common Criticisms..............................................45411.5Parameterized Abstract Data Types....................................................47211.6Encapsulation Constructs...................................................................47611.7Naming Encapsulations.....................................................................480Summary • Review Questions • Problem Set • Programming Exercises............483Chapter 12Support for Object-Oriented Programming48912.1Introduction.......................................................................................49012.2Object-Oriented Programming...........................................................49112.3Design Issues for Object-Oriented Languages....................................49512.4Support for Object-Oriented Programming in Specific Languages.....500
Page 16 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 16 preview image15Interview:BJARNE STROUSTRUP—On Paradigms and BetterProgramming50412.5Implementation of Object-Oriented Constructs...................................52812.6Reflection..........................................................................................531Summary • Review Questions • Problem Set • Programming Exercises............537Chapter 13Concurrency54313.1Introduction.......................................................................................54413.2Introduction to Subprogram-Level Concurrency.................................54913.3Semaphores.......................................................................................55413.4Monitors............................................................................................55913.5Message Passing................................................................................56113.6Ada Support for Concurrency............................................................56213.7Java Threads......................................................................................57013.8C# Threads........................................................................................58013.9Concurrency in Functional Languages................................................58513.10Statement-Level Concurrency............................................................588Summary •Bibliographic Notes• Review Questions • Problem Set • ProgrammingExercises.......................................................................................................590Chapter 14Exception Handling and Event Handling59714.1Introduction to Exception Handling...................................................598History Note...........................................................................................60214.2Exception Handling in C++................................................................60414.3Exception Handling in Java...............................................................60814.4Exception Handling in Python and Ruby............................................61514.5Introduction to Event Handling..........................................................61814.6Event Handling with Java..................................................................619
Page 17 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 17 preview image1614.7Event Handling in C#........................................................................623Summary •Bibliographic Notes• Review Questions • Problem Set • ProgrammingExercises.......................................................................................................626Chapter 15Functional Programming Languages63315.1Introduction.......................................................................................63415.2Mathematical Functions.....................................................................63515.3Fundamentals of Functional Programming Languages........................63815.4The First Functional Programming Language: Lisp............................63915.5An Introduction to Scheme................................................................64315.6Common Lisp....................................................................................66115.7ML....................................................................................................66315.8Haskell..............................................................................................66815.9F#.....................................................................................................67315.10Support for Functional Programming in Primarily Imperative Languages.........................................................................................................67615.11A Comparison of Functional and Imperative Languages.....................679Summary •Bibliographic Notes• Review Questions • Problem Set • ProgrammingExercises.......................................................................................................681Chapter 16Logic Programming Languages68916.1Introduction.......................................................................................69016.2A Brief Introduction to Predicate Calculus.........................................69016.3Predicate Calculus and Proving Theorems..........................................69416.4An Overview of Logic Programming.................................................69616.5The Origins of Prolog........................................................................69816.6The Basic Elements of Prolog............................................................69816.7Deficiencies of Prolog.......................................................................713
Page 18 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 18 preview image1716.8Applications of Logic Programming..................................................719Summary •Bibliographic Notes• Review Questions • Problem Set • ProgrammingExercises.......................................................................................................720Bibliography.....................................................................................725Index..................................................................................................737Answers to Selected ProblemsChapter 1Problem Set:3. Some arguments for having a single language for all programming domains are: Itwould dramatically cut the costs of programming training and compiler purchase andmaintenance; it would simplify programmer recruiting and justify the development ofnumerous language dependent software development aids.4. Some arguments against having a single language for all programming domains are:The language would necessarily be huge and complex; compilers would be expensiveand costly to maintain; the language would probably not be very good for anyprogramming domain, either in compiler efficiency or in the efficiency of the code itgenerated.More importantly, it would not be easy to use, because regardless of theapplication area, the language would include many unnecessary and confusing featuresand constructs (those meant for other application areas). Different users would learndifferent subsets, making maintenance difficult.5. One possibility is wordiness. In some languages, a great deal of text is required foreven simple complete programs. For example, COBOL is a very wordy language. InAda, programs require a lot of duplication of declarations. Wordiness is usuallyconsidered a disadvantage, because it slows program creation, takes more file space forthe source programs, and can cause programs to be more difficult to read.7. The argument for using the right brace to close all compounds is simplicity—a rightbrace always terminates a compound. The argument against it is that when you see a rightbrace in a program, the location of its matching left brace is not always obvious, in partbecause all multiple-statement control constructs end with a right brace.8. The reasons why a language would distinguish between uppercase and lowercase in itsidentifiers are: (1) So that variable identifiers may look different than identifiers that arenames for constants, such as the convention of using uppercase for constant names andusing lowercase for variable names in C, and (2) so that catenated words as names canhave their first letter distinguished, as inTotalWords.(Somethink it is better to includea connector, such as underscore.) The primary reason why a language would not
Page 19 of 19
Solution Manual for Concepts of Programming Languages, 12th Edition - Page 19 preview image18distinguish between uppercase and lowercase in identifiers is it makes programs lessreadable, because words that look very similar are actually completely different, such asSUMandSum.10. One of the main arguments is that regardless of the cost of hardware, it is not free.Why write a program that executes slower than is necessary. Furthermore, the differencebetween a well-written efficient program and one that is poorly written can be a factor oftwo or three. In many other fields of endeavor, the difference between a good job and apoor job may be 10 or 20 percent. In programming, the difference is much greater.15. The use of type declaration statements for simple scalar variables may have very littleeffect on the readability of programs. If a language has no type declarations at all, it maybe an aid to readability, because regardless of where a variable is seen in the programtext, its type can be determined without looking elsewhere. Unfortunately, mostlanguages that allow implicitly declared variables also include explicit declarations. In aprogram in such a language, the declaration of a variable must be found before the readercan determine the type of that variable when it is used in the program.18. The main disadvantage of using paired delimiters for comments is that it results indiminished reliability. It is easy to inadvertently leave off the final delimiter, whichextends the comment to the end of the next comment, effectively removing code from theprogram. The advantage of paired delimiters is that youcancomment out areas of aprogram. The disadvantage of using only beginning delimiters is that they must berepeated on every line of a block of comments. This can be tedious and therefore error-prone. The advantage is that you cannot make the mistake of forgetting the closingdelimiter.Chapter 2Problem Set:6. Because of the simple syntax of LISP, few syntax errors occur in LISP programs.Unmatched parentheses is the most common mistake.7. The main reason why imperative features were put in LISP was to increase itsexecution efficiency.10. The main motivation for the development of PL/I was to provide a single tool forcomputer centers that must support both scientific and commercial applications. IBMbelieved that the needs of the two classes of applications were merging, at least to somedegree. They felt that the simplest solution for a provider of systems, both hardware andsoftware, was to furnish a single hardware system running a single programminglanguage that served both scientific and commercial applications.11. IBM was, for the most part, incorrect in its view of the future of the uses ofcomputers, at least as far as languages are concerned. Commercial applications arenearly all done in languages that are specifically designed for them. Likewise forscientific applications. On the other hand, the IBM design of the 360 line of computerswas a great success--it still dominates the area of computers between supercomputers andminicomputers. Furthermore, 360 series computers and their descendants have beenwidely used for both scientific and commercial applications. These applications havebeen done, in large part, in Fortranand COBOL.
Preview Mode

This document has 60 pages. Sign in to access the full document!

Study Now!

X-Copilot AI
Unlimited Access
Secure Payment
Instant Access
24/7 Support
Document Chat

Document Details

Subject
Information Technology
Textbook
Concepts Of Programming Languages b...

Related Documents

View all
Class Notes

DevOps and Its Importance Study Notes

Past Exams

Veeam Certified Engineer VMCE-V12

Past Exams

Modules 1 - 3 Basic Network Connectivity and Commu

Class Notes

Notes CCNA

Class Notes

CCNA 200-301 Portable Command Guide 5th Edition 20

Class Notes

CCNA 200-301 Portable Command Guide 5th Edition 22

Class Notes

CCNA 200-301 Portable Command Guide 5th Edition 36

Class Notes

Foundations of Novell Networking Section 26

Class Presentation

Modulo 7 DHCPv4

Class Notes

Build and troubleshooting Integration Challenge