Conditions of Use
This textbook covers almost all the topics that a typical Programming I or Computing I course that uses the C++ programming language usually requires. The approach it uses corresponds to a 'late objects' approach, which is what my college and the... read more
This textbook covers almost all the topics that a typical Programming I or Computing I course that uses the C++ programming language usually requires. The approach it uses corresponds to a 'late objects' approach, which is what my college and the college that most of my students transfer to use. However, the way the topics are organized and ordered is a little confusing and unusual .See comments under organization.
The book and its labs are accurate. There are a few minor typos/spellos here and there, a few which make the code not compile.
In this textbook, all demo programs define variables used locally in main as global variables. While this is not inaccurate, it is something that most people in industry avoid in well structured, maintainable code, and something I and most professors counsel students not to do. So having every example do this here is a bit odd.
The book is written in 2013 and many of the program examples are dated 2008/2009. For the most part that isn't an issue. However, newer versions of C++ have been in use since then, with a couple of constructs that are missing here. In particular, C++ 11 introduced nullptr and range-based for loops. My curriculum includes both of these. The latter is particularly useful to teach students. The book could easily be updated to add these. An early section discussed IDE's and the book uses Dev-C++. Other, more recent, IDE's might be more popular now, but Dev-C++ is free and simpler to use than some others, so it's actually helpful to have a section for this. The source code in demo programs should work in any IDE a student chooses to use.
Present in every demo program is the author's custom pause function. Most systems no longer need to call system pause to allow the user to view the output before the output window closes. This is minor, but a professor will either have to explain the pause function, or tell the students to remove it from every example. Also, it necessitates an explanation of functions at the beginning of the course, before the actual study of functions other than main is reached.
The description of the concepts and constructs are pretty clear. Adequate examples are used. A plus in this book is the inclusion of a separate list of definitions for most chapters. Because of the repetition of instructions to the student (i.e. to set up folders to contain their files.) there's a lot of extra text that has to be scrolled past.
The textbook uses consistent format and terminology throughout.
In an intro computer science course that would typically use this textbook, concepts are generally present in the same order in most textbooks. But, yes, if a professor wanted to skip a topic, this textbook allows for that. However, the granularity of this textbook is too small. For the topics I typically cover in this course (thru pointers), there are 22 chapters, as compared to 9 chapters in the textbook I currently use. That actually makes it harder to find specific topics by looking at the table of contents. Of course, searching in the online version can accomplish that.
The section numbering of online version vs. pdf version, i.e. the numbering of chapters/modules, differs by 4. i.e. Chapter 3 is in numbered section 7, etc. It's confusing at first. Students can get used to it, but it makes instructions awkward, i.e. to read Chapter 3, students have to read Sections numbered 7.1 to 7.8.
Chapter 10 introduces 2 forms of selection and 4 forms of repetition all at once. It then covers them separately, but it's a lot for students to look at before understanding what selection or repetition is.
Some concepts are introduced in the middle of chapters devoted to other concepts. This could be confusing to students. For example, File i/o is covered in the middle of the chapter introducing arrays. Most textbooks (and this professor) cover File i/o as its own topic, before or after arrays.
The book comes in two versions: online and a .pdf. The online version is preferable to use, since students can click on links to download code and other sample files, etc. Also, the table of contents is interactive. The .pdf can be printed, but it uses a font that is hard on the eyes. (The font used in the online version is much better.)
The Memory Building Activities (MBA) links are dead in the online version.
Although it's a plus to be able to download a source file to work with it, it should also be visible without having to download it.
Although there are some typos/spellos, they are minor.
This textbook is not inclusive, particularly with respect to gender. Its use of gender pronouns is cause for concern. While many authors grapple with this, some choosing to alternate between male and female pronouns, or use generic pronouns, this author does not. Discussion and examples use generic nouns like friend, chef, programmer, user, systems analyst, painter, professor. However, all these use the pronouns he/him/his. We've spent decades to expand the community of coders to beyond the traditional male students. This textbook is unwelcoming to non-male students. In particular, to read that programmers, users, systems analysts, and students are male sets this textbook backwards in time many years. Women (and non-binary) students are excluded and will not see themselves reflected here. It is troubling that the only examples that use female pronouns are limited to mothers, a wife, and a Miss America contestant. Really. Literally, these are the only instances of non-male examples in the entire textbook, and they are at best a trope, at worst gender stereotypes. Consider these alarming quotes: "Saying that my cousin is the 2nd Runner Up in the Miss America contest sounds so much better than saying that she was in 3rd Place." "Calling you spouse "Snooky" may be meaningful to only you. Others might need to see her full name (Jane Mary Smith) to appropriately identify who you are talking about." In this textbook, women can only be mothers, wives and beauty contestants, but never programmers or system analysts, or students. How depressing.
I was hoping to use this textbook for my Programming I course. It appeared to match my syllabus, particularly since it uses a 'late objects' approach and covers almost all the topics that my curriculum requires. The text I currently use is Tony Gaddis' "C++ From Control Structures through Objects", which is great, but many students won't purchase a textbook, so I am looking for OER. The organization of this text is a bit confusing and the embedding of some of the topics inside others is a bit odd. That said, I was still ready to try it. However, after spending 20 years implementing programs and activities to encourage students in groups which are underrepresented in STEM, particularly women and girls, I am troubled by the exclusion of women in this textbook except in a couple of stereotypic references. This textbook sends a message that women need not apply to computer science careers.
Covers all necessary areas for a beginning C++ class. read more
Covers all necessary areas for a beginning C++ class.
The technical accuracy is great. There are a few (very few) typos that I came across, but nothing that affects the material.
This is a solid foundation for C++ programming. The basics of the language do not fluctuate much over time. The book is clearly laid out addressing one element at a time which would make it easy to update as releases of new language standards are rolled out.
I really appreciate how easy this book is to read - I was able to get through the entire book in no time. I feel that it is very accessible to students who can get easily overwhelmed when reading technical books. Examples are often quite memorable. Little bits of humor are injected just often enough to keep you on your toes.
Each chapter is laid out in the same manner. It is easy to envision how to use each element in a course.
At 24 chapters and 300 pages, it seems like it might be too much. However, the chapters are very short and laden with good coding examples. I can see where I could easily assign two chapters per week because each chapter is fairly specific and steps through the language around the same pace that I cover the material in class.
The book presents the language in clear steps starting with foundational knowledge and building from there.
I read the book as a pdf so I was not able to use some of the links (is there a way to get an interactive pdf?). Other than that, no issues.
none that I saw, just a few typos.
This book in not insensitive or offensive in any way that I could see.
I am planning to adopt this book for fall2022. There are many things that I like about it. It is easy to read. Examples are clear and often humorous (therefore, memorable - I will never cut up a can of soup). Program development and pseudocode are presented early on and stressed throughout. I find that more of my students struggle with the process than the syntax, this should help. The book has a logical progression starting with foundational language skills and building from there.
The book is very comprehensive and covers everything needed for an Intro to Programming class. I love that it has Program Planning and Design as a topic. This is a very important concept we try to teach students at the beginning of this... read more
The book is very comprehensive and covers everything needed for an Intro to Programming class. I love that it has Program Planning and Design as a topic. This is a very important concept we try to teach students at the beginning of this programming class. It would be great to see a quick Intro to Structs and some of the new C++ 11 syntax and examples.
The content and examples I have looked at are accurate to the best of my knowledge.
All content relevant to basics of programming and the language are still relevant. It has been a few years since the book has been written. It could be revised to include C++ 11 and C++ 14 syntax. It could also use some online interactive IDEs like replit, that would be more inclusive of students who use Chromebooks and such. A new book is not needed since a lot of the content is still very relevant - an update or revision to incorporate a few changes would be useful.
The book is very clear and broken into small chunks for students to read and understand! I especially like the fact that it has pseudocode interspersed and definitions at the end of every chapter. Students who are just learning English are always appreciative of the definitions that help them understand the terms better.
The book is very consistent throughout. It follows the same format and uses pseudocode and definitions for most if not all chapters.
The book is definitely modularized well. Some sections could be combined to form solid good sized sections. This format makes it seem like there are too many chapters especially when conditionals and loops are broken up into almost 3 chapters each. This can be overwhelming for students when they look at the long list of chapters. I would also rearrange the topics and sub topics better.
If I were to use this book, I would have to rearrange some of the topics to make sure I put relevant topics in the beginning and move some chapters for later - like Program Control Functions. I would also combine some of the chapters like conditionals and loops and make it more comprehensive, so it is less intimidating for students. I would also make some topics towards the end as optional materials - like recursion and pointers - again I feel like this is too much to cover in one term for a community college!
It would be great to have an interactive text book - where students can fill in some code and test them interactively. It would also benefit to have an app like Python tutor embedded that does code tracing so students can benefit from multiple ways to access the resources. This would also fit well into the Universal Design model that is preferred everywhere these days - especially with all institutions going remote due to COVID.
I have not seen many or any grammatical errors so far.
The book is not culturally insensitive or offensive in any way. I think the addition of definitions makes it inclusive.
This is a good textbook. I would like to see a revised version with some of the major changes incorporated. It would also be good to have an interactive version and more examples and labs so students can get more practice. I would also incorporate more on functions and I would introduce that topic later in the book.
Overall if I were to use this book, I would have to have specific notes to move chapters and sections around, and add supplemental examples and labs to give students more practice.
The text covers the typical content for an introductory programming course in C++ including decisions, loops, functions, arrays and file I/O. It also has chapters that provide a brief explanation of pointers, object-oriented programming and... read more
The text covers the typical content for an introductory programming course in C++ including decisions, loops, functions, arrays and file I/O. It also has chapters that provide a brief explanation of pointers, object-oriented programming and high-performance computing. An appendix with information about the C++ language, a glossary and an index are also included.
Textbook examples appear to be accurate and error-free in terms of the C++ language syntax and program format.
The content is not up-to-date. Several new standards have been released for C++ (C++11, C++14) since the text was published. However, the basic fundamental concepts covered in the text are still relevant.
The text is written clearly and simply. Explanations of a concept are followed by a list of definitions for the same topic which are stated clearly. The author's sometimes writes in the first-person (e.g., to tell a humorous story) and uses relatable analogies (e.g., the concept of a flag in programming is related to flags used in car races or flown from pirate ships). He occasionally introduces color to highlight the relationship between coding lines and the output produced by these lines (p. 207-208). This visual technique makes the connection easy to follow.
The text is very consistent in the organization of the material in each chapter. Every chapter has similar headings in the same order (e.g., General Discussion, Definitions, Demonstration Program, Exercises, etc.). A consistent numbering format is used for sections and subsections in each chapter.
The topics in the text are presented in a logical, clear fashion. Topics are presented in the typical order for an introductory programming text.
The topics in the text are presented in a logical, clear fashion. Topics are presented in the typical order for an introductory programming text except that functions are introduced before decisions and loops. Some may find this preferable while others will not.
Navigation through the text was easy and all text components were clear and easy to read.
The text is free of grammatical errors but there are occasional spelling errors and typos.
The text is mostly free of any cultural references, although there was an occasional example that some might find off-putting or offensive (e.g., p. 177, if gender equals 'F', display "Are you pregnant?"). The text is culturally neutral and does not generally make use of examples that would indicate the race, ethnicity or background of a subject.
The author notes that this text was not created to cover the language in detail (e.g., p. 165) but to concentrate on programming fundamentals and concepts and in that he has succeeded. The book breaks down the introduction to programming topics into small manageable sections (e.g., with separate chapters for each format of the if statement and each type of loop). However, more depth in the topics presented would be desirable for a college course for Computer Science majors. Whatever the audience for the textbook, it would need to be supplemented with additional examples, exercises and lab and programming assignments. The examples and assignments provided in the textbook are very basic. Later examples do not include much integration of the programming constructs introduced earlier in the text.
The book covers many of the topics I would expect to see in a book for an introductory programming course. It skips multidimensional arrays and structures. Although I wouldn't expect the book to cover the topic extensively it would be nice for it... read more
The book covers many of the topics I would expect to see in a book for an introductory programming course. It skips multidimensional arrays and structures. Although I wouldn't expect the book to cover the topic extensively it would be nice for it to mention classes. I feel that I would have to supplement this book with additional examples and chapters. C++ 11 and C++ 14 are not mentioned.
The examples I reviewed appear to be accurate. I did not review every example.
C++ 11 and 14 are not covered. While these additions are not necessary to understand the basics of C++ it would be nice to see them mentioned. They could form their own chapter. Given the nature of C++ a new edition is not necessary on a fast basis. However, it would be nice to see future editions include more examples.
The book is easy to follow and introduces terminology in an easy to follow fashion. I would like to see a list of terms after each chapter.
The book follows a consistent patterns. The material in each chapter is presented using the same pattern. Pseudocode, which is absent from some of the textbooks I review, is used throughout the chapters. It is an excellent way to introduce a new programming feature.
I prefer to cover material in a different order than this textbook presents it. The examples tend to build off each other making it confusing to cover the material out of order. While this is not a problem unique to this book my current textbook is written in such a way that chapters can be re-ordered without encountering this problem.
I don't like the way some chapters are organized. If statements are split into chapters titled two way selection and multiway selection. Why not combine them into a chapter called "decisions structures", "making decisions", or just "if statements"? The average undergrad would understand what is in a chapter called "if statements" right away while multiway selection is confusing.
When viewed on my laptop, which has a rather small screen, some of the examples line wrap. This makes the code a little confusing to view. I prefer the HTML edition to the PDF. Since this textbook is online it would be nice to see some interactive examples.
I found no grammar problems.
The book is not culturally insensitive. This question is irrelevant for this type of book.
This is a relatively good textbook. I would like to see a new edition with some of the major issues addressed. I would cover some of the material in a different order and supplement the material my University requires with chapters from other books. Given the current costs of programming books this textbook is a good value.
This book is designed for students taking an introductory programming course using the C++ programming language. It includes all the relevant topics for an introductory class. It also provides a lot of material to guide students to develop good... read more
This book is designed for students taking an introductory programming course using the C++ programming language. It includes all the relevant topics for an introductory class. It also provides a lot of material to guide students to develop good programming habits which will be beneficial in any subsequent class and in the workplace.
The content I was able to verify is accurate. The author pays close attention to every detail and is thorough in his explanations.
The book is 5 years old at the time of this writing. Computer Science and the programming are rapidly evolving so it very difficult to produce a document that is fully relevant for a long period of time. All content related to the basics of the programming and the discussion on the best habits and techniques of a successful programmer will remain relevant. The software tools such as Dev C++, used in this book, while may still be useful and sufficient are not as relevant. A large variety of new options is available to all programmers. The book however can still be used as is for a current introductory class.
The book is very well written. Each topic is discussed in detail. Relevant supporting material and background information is provided in prior to each new topic. The content is broken down into small units and the flow of content is logical and clear.
The book maintains the same 'feel' throughout. The style is consistent throat the book which makes it easier to follow.
The author does a good job at breaking down concepts into smaller units. As a consequence the initial table of contents clearly outlines the material and makes it easier for users to locate what they are looking for. In some cases some of the numbered subsections are very small. For example, a one line definition does not need to be in a separate section. I would also avoid a third level in the subsection hierarchy. For example section 184.108.40.206 can be combined in some way with all other subsections in 6.5.1.
The book is very well organized. It is evident that the author pays close attention to small detail. The flow of content is clear and all new material is preceded by sufficient relevant background information.
The visual feel of the book is very simplistic. The book can benefit from a visual makeover. Maybe some color, more figures, and a better presentation of code fragments.
No issues identified.
The book does a good job of covering the first term of a programming class. It covers the basics of programming but it's not a perfect fit for a one-term only programming class. Some of the topics not covered are: multidimensional arrays and... read more
The book does a good job of covering the first term of a programming class. It covers the basics of programming but it's not a perfect fit for a one-term only programming class. Some of the topics not covered are: multidimensional arrays and structs, anything beyond the basic arithmetic operators, output formatting, using library functions for advanced math and bitwise operations. I agree with the idea of leaving out object oriented programming (classes).
Although every important feature was discussed, I feel like any adopter would want to supplement with more examples. The book doesn't have much in the way of code tracing examples and additional code examples. It's not always the best approach for students, but students often solve programming problems by searching for a code fragment that they think solves their problem instead of creating the code fragment by themselves. I would provide additional code fragment examples.
I also feel like there's not enough emphasis on functions. I think it's fine to introduce functions early but they should be revisited after covering structured programming when students can deal with larger blocks of code and see the benefits of functions.
I feel like introducing recursion to the average student (especially community college students) is not helpful. So it's fine to have it in there but I wouldn't hesitate to skip it.
There was no index or end of book glossary although it is searchable (the pdf has an index). On the other hand, each module has a definitions section.
The book follows the C++ standard. I haven't checked every example but I noticed one example that wouldn't compile because it was missing a library include statement.
It's not stated which C++ standard is supported although it's obviously C++98. There have been a few important updates to the standard since the text was written but at this level, I don't think it impacts the material or examples very much, although anyone who adopts the text would need to scrub all the examples and add a section on the changes to the spec.
The text is written in a clear style although some of the module titles could be more clear - for example "program control functions" and "Specific Task Functions" seem obfuscated to me. Supporting context is at a minimum, which is a choice of style. Some books surround the code examples with historical context and philosophical context. This book is about the basics.
The structure and style of the text was consistent throughout. The book follows the form of presenting a text description with pseudocode, then the C++ structure and then one or two example code fragments. Each major section has a practice programming exercise.
I think this question applies better to textbooks from other subjects like history or economics. The book is modular in the sense that each module is broken down into easy to digest sub modules. You do have some ability to reorganize the material. For instance simple functions are introduced very early and you could skip it, cover the material on assignments and structure to get to more complex code and then come back and introduce functions.
However, in general it's difficult to reorganize any programming book since examples often depend on concepts and structures introduced in earlier modules.
It's a matter of personal preference but I like to cover functions after structured programming. It's fine to introduce the idea of calling a function if you use an example that requires a library function but the justification for functions doesn't come until the student has created more complicated code. Otherwise the flow from data types and operators to selection statements and then to loop statements is fine and pretty standard for any C++ book. File I/O isn't introduced until late, which might be an issue for some, but it's fine with me.
The HTML works OK as far as the contents and modules. Each section within the module is one to two pages (depending on your monitor resolution and zoom level). There aren't many images and charts so there's no issues there.
It would be nice when I click on the module heading in the HTML version to take me to the start of the module instead of requiring me to expand it and click on a subsection.
The PDF version uses hard to read and old style fonts that look like old faded computer documentation. The HTLM version is much more readable
The grammar is fine.
There are no cultural references in the book or even use of specific names.
It's better than some of the other open or free textbooks I've seen out there and is potentially a good alternative to the $100 books.
If I was to adopt, I would skip over the early introduction to functions and skip the material on recursion and pointers (I think for community college students without calculus it's too much - calculus has nothing to do with pointers but it's the ability to deal with abstraction that's helpful). I would add a more robust section on functions after the section on structured programming. I would also add more many more examples and exercises. Personally I would also add two dimensional arrays because they make a good visual usage case for nested loops.
The lab exercises are fine but I don't think there are enough of them. But that's an easy thing to supplement.
I'll use it as a resource in my classes but not make it the sole textbook.
The book covers all the major topics of C++ up to the C++98 standard. It does have a nice index and table of contents that allows you to find a topic quickly and move to the module quickly. I did not see a glossary. read more
The book covers all the major topics of C++ up to the C++98 standard. It does have a nice index and table of contents that allows you to find a topic quickly and move to the module quickly. I did not see a glossary.
The book is accurate, albeit dated.
The content is dated and this is one of the major drawbacks. I teach in an older style and I was glad to see that it showed an older model; however it hasn't been updated in a while. The online version was published in 2013, but I think the original was published in the late 90s. I was looking for the copyright date, but I couldn't find it when I was typing this.
The reading list is several editions out of date and the book makes no mention of any of the C++11 or C++14 standards. The changes made to C++ in those standard changes really need to be included in a modern C++ text or it is seriously out of date.
I like the book's writing style and I find it very clear.
The book is very consistent. It follows a good style of writing and is easy to follow.
The book is modular but it's hard to assign the modules out of order due to the fact that the nature of a programming text will build off previous modules. This is extremely typical of all programming texts.
I disagree with the flow of topics. I understand why they have chosen to introduce the topics in the way they have but I don't think this is the best way. I prefer to forestall an in-depth discussion of functions until after loops and selection. Selection and loops come very late in the topic list in my opinion.
The interface is clean, clear and easy to use.
The book has very good grammar.
The book is not culturally insensitive.
The book is okay. I don't think I would use this book in my class because there are some major issues with how the examples are developed and the topic flow. Since the modules are sequential it be too hard to rearrange and keep the content clear to the students. Also the examples show the use of global variables which, in my opinion, should be avoided and I teach that in my class, so a text that shows examples using global variables would pose a major issue.
In general I feel the book needs a major revision to include more modern C++ standards, a topic flow alteration and the removal of global variables in examples.
Table of Contents
- 1. Introduction to Programming
- 2. Program Planning & Design
- 3. Data & Operators
- 4. Often Used Data Types
- 5. Integrated Development Environment
- 6. Program Control Functions
- 7. Specific Task Functions
- 8. Standard Libraries
- 9. Character Data, Sizeof, Typedef, Sequence
- 10. Introduction to Structured Programming
- 11. Two Way Selection
- 12. Multiway Selection
- 13. Test After Loops
- 14. Test Before Loops
- 15. Counting Loops
- 16. String Class, Unary Positive and Negative
- 17. Conditional Operator and Recursion
- 18. Introduction to Arrays
- 19. File I/O and Array Functions
- 20. More Array Functions
- 21. More on Typedef
- 22. Pointers
- 23. More Arrays & Compiler Directives
- 24. OOP & HPC
About the Book
Programming Fundamentals - A Modular Structured Approach using C++ is written by Kenneth Leroy Busbee, a faculty member at Houston Community College in Houston, Texas. The materials used in this textbook/collection were developed by the author and others as independent modules for publication within the Connexions environment. Programming fundamentals are often divided into three college courses: Modular/Structured, Object Oriented and Data Structures. This textbook/collection covers the first of those three courses.
The learning modules of this textbook/collection were written as standalone modules. Students using a collection of modules as a textbook will usually view it contents by reading the modules sequentially as presented by the author of the collection.
The learning modules of this textbook/collection were, for the most part, written without consideration of a speci??c programming language. In many cases the C++ language is discussed as part of the explanation of the concept. Often the examples used for C++ are exactly the same for the Java programming language. However, some modules were written speci??cally for the C++ programming language. This could not beavoided as the C++ language is used in conjunction with this textbook/collection by the author in teaching college courses.
About the Contributors
Kenneth Leroy Busbee, M.Acc. (Master of Accountancy), Brigham Young University. Teaches programming topics including courses in COBOL, main frame IBM assembly, Intel assembly, Pascal, "C" and "C++"; Business Computer Applications; Principles of Accounting.