Programming Fundamentals - A Modular Structured Approach using C++
Kenneth Busbee, Houston Community College
Pub Date: 2013
Publisher: OpenStax CNX
Conditions of Use
This book is designed for students taking an introductory programming course using the C++ programming language. It includes all the relevant topics 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 220.127.116.11 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 covers many of the topics I would expect to see in a book for an introductory programming course. It skips multidimensional arrays and 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.
The text covers the typical content for an introductory programming course in C++ including decisions, loops, functions, arrays and file I/O. It 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 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 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 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
- Chapter 1. Introduction to Programming
- Chapter 2. Program Planning & Design
- Chapter 3. Data & Operators
- Chapter 4. Often Used Data Types
- Chapter 5. Integrated Development Environment
- Chapter 6. Program Control Functions
- Chapter 7. Specific Task Functions
- Chapter 8. Standard Libraries
- Chapter 9. Character Data, Sizeof, Typedef, Sequence
- Chapter 10. Introduction to Structured Programming
- Chapter 11. Two Way Selection
- Chapter 12. Multiway Selection
- Chapter 13. Test After Loops
- Chapter 14. Test Before Loops
- Chapter 15. Counting Loops
- Chapter 16. String Class, Unary Positive and Negative
- Chapter 17. Conditional Operator and Recursion
- Chapter 18. Introduction to Arrays
- Chapter 19. File I/O and Array Functions
- Chapter 20. More Array Functions
- Chapter 21. More on Typedef
- Chapter 22. Pointers
- Chapter 23. More Arrays & Compiler Directives
- Chapter 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 be avoided 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.