Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Intermediate C programming
Lu Y., CRC Press, Inc., Boca Raton, FL, 2015. 498 pp. Type: Book (978-1-498711-63-0)
Date Reviewed: Apr 21 2016

When looking at a textbook on introductory programming in the C language, it is not so difficult to imagine what contents will be found within. Also, for more advanced topics, it is quite likely that a number of books are available to describe any fine details. But it is not easy to immediately imagine what a book on “intermediate” C programming will say. In his book, Y.-H. Lu gives his very personal view to students in computer science (CS) and related fields.

Defining what is “intermediate” is quite subjective, especially in the realm of computer programming. In the author’s view, intermediate programming is a skill required to write programs consisting of a few hundred of lines of code: so not simple procedures as in basic tutorials, nor complex software as in specialized books, where small excerpts of entire programs are reported. The ultimate objective of the book is to prepare students to write and to understand nontrivial programs, a skill that is the necessary prelude for more advanced courses. Admittedly, there are not many books with such an approach, making this one an interesting option.

Given this general idea, the book presents a number of topics grouped in four main parts: memory, recursion, data structures, and applications. Anyone teaching programming in C knows that memory management and recursion are among the most burdensome topics for students. This is why the author dedicates several chapters to them, starting with a chapter on stack memory, in order to make clear the fundamental role of the call stack in running programs, which motivates the introduction of pointers and their arithmetic. Very interesting, from a pedagogical viewpoint, is the presentation of several variants of a single function (the swap function) in the form of exercises, which make clear the central role of pointers as a means for argument passing. From pointers to arrays and strings in particular, the passage is immediate: here, the arguments are not presented from scratch; rather, more pragmatic arguments are preferred, such as testing tools and programming strategies to avoid common bugs. Heap memory and files complete the first part with a discussion of programming problems including string manipulation and array sorting through quick-sort.

Recursion takes an entire part of the book. This is acceptable because recursion is quite a tough subject for undergraduate students. Interestingly, the author criticizes the classical approach adopted in many programming textbooks when presenting recursion. Instead of providing easy examples of recursive functions (such as the well-known factorial), which could be efficiently implemented as iterative programs, the author first proposes problems whose solutions gently lead to a recursive solution that doesn’t have an immediate iterative counterpart. Here, the objective of the author is to show that recursion is a good technique for some problems, but not for all. (This is in compliance with the imperative paradigm, which could horrify the purists of the functional paradigm. The author could have mentioned the existence of techniques for optimizing recursions so as to justify why purely functional programming languages exist and work well.)

The third part of the book concerns data structures, with some mentions of objects. (In the book, objects are intended as instances of structures; this is a very partial view of objects, which could mislead students approaching object-oriented programming in subsequent studies.) The part unfolds with a number of chapters mainly dealing with dynamic structures based on linked lists. Surprisingly, the part includes a chapter on parallel programming with POSIX threads. While it is true that today’s computers offer multitasking at both the architectural and operating system (OS) levels, parallel programming techniques are admittedly an advanced topic that cannot be introduced to students without a general understanding of parallelism as a computational paradigm.

It is therefore safer to skip the chapter and plunge into the last part, where applications are presented. There are three mid-sized applications that could be used as case studies throughout a course to practice with the techniques and tools presented in the book. They are well described and accompanied by a complete implementation of the solution.

Overall, the book is an interesting option for teachers in computer programming. Several sections could inspire a novel approach for teaching C programming beyond the initial fundamentals. However, the organization of the book is rather personalized to the author’s vision: some topics, which could merit a dedicated chapter, are either intermixed with others within a single chapter or span across multiple chapters. Furthermore, some arguments that one could plainly categorize as “intermediate” are completely missing (for example, programming styles, modular programming, defensive programming, documentation, and so on). Finally, not all of the promises advertised in the book are actually kept: the integration of programming and discrete mathematics, promised in the preface, is only hinted at in the discussion of quick-sort, and the appendices describing Linux, Git, and Eclipse are almost useless. Therefore, the book is recommended to teachers so they can grab the best from it and tailor their personal view of what aspects of “intermediate” C programming are worth teaching to their students.

More reviews about this item: Amazon

Reviewer:  Corrado Mencar Review #: CR144344 (1607-0460)
Bookmark and Share
  Reviewer Selected
Featured Reviewer
 
 
C (D.3.2 ... )
 
 
Sequential Programming (D.1.4 )
 
Would you recommend this review?
yes
no
Other reviews under "C": Date
C (2nd ed.)
Schildt H., Osborne/McGraw-Hill, Berkeley, CA, 1990. Type: Book (9780078815386)
Jan 1 1992
C: a software engineering approach
Darnell P., Margolis P., Springer-Verlag New York, Inc., New York, NY, 1991. Type: Book (9780387973890)
Dec 1 1991
C for programmers
Ammeraal L., John Wiley & Sons, Inc., New York, NY, 1991. Type: Book (9780471928515)
Dec 1 1991
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy