Rating: 
Summary: Will become a well-worn addition to your programming shelf..
Review: (This review is for the second edition)
If you're involved in trying to port software to a Unix/Linux application platform, you should get a copy of the 2nd edition of Linux Application Development by Michael K. Johnson and Erik W. Troan (Addison Wesley). This will become a key part of your learning.
Chapter Breakout:
Part 1 - Getting Started - History Of Linux Development; Licenses And Copyright; Online System Documentation
Part 2 - Development Tools And Environment - Development Tools; gcc Options And Extensions; The GNU C Library; Memory Debugging Tools; Creating And Using Libraries; Linux System Environment
Part 3 - System Programming - The Process Model; Simple File Handling; Signal Processing; Advanced File Handling; Directory Operations; Job Control; Terminals And Pseudo Terminals; Networking With Sockets; Time; Random Numbers; Programming Virtual Consoles; The Linux Console; Writing Secure Programs
Part 4 - Development Libraries - String Matching; Terminal Handling With S-Lang; A Hashed Database Library; Parsing Command-Line Options; Dynamic Loading At Run Time; User Identification And Authentication
Appendix A - Header Files; Appendix B - ladsh Source Code; Glossary; Bibliography; Index
With the recent rapid uptake of Linux-based servers and desktops, more and more companies are looking at porting their software from Windows platforms over to Linux. The trouble with porting in that instance is that the underlying operating system dependancies are all different, and unless you understand how to work with the OS, you're lost. Linux Application Development does an excellent job in first introducing the common tools that are used for application development on Linux. The assumption is that you'll be programming in C, but within that framework the authors explain each tool and how it can aid in developing your system (such as memory-checking tools that come with the GNU C library). Once the subject of application development environments is finished, they move on to the actual OS and how it should interface with the application. The book presents a lot of code for examples, as well as explaining exactly why things work as they do. By the time you've gotten to the end of the material, you should have a more-than-adequate understanding of how to build applications for Linux/Unix.
Excellent material for the application developer who needs to build on the Linux platform...
Rating: 
Summary: Difficult to Read Program Listings
Review: I haven't read this yet, so take my "3 stars" with a grain of salt. What immediately struck me was the lousy font chosen for the program listings. It is very weak and while the listings are readable, and most programmers know where to expect {} vice (), for example, it would be nice if your eyes could immediately differentiate between such similar characters. Mine can't.
Rating: 
Summary: Second Edition
Review: I'm one of the authors, so take the 5 stars with a grain of salt...
Amazon's database is a bit confused about the two editions of Linux Application Development. Both are hardcover, but the second edition was released in November, 2004. The version with a mostly white color is the second edition; the cover of the first edition is mostly yellow. Hopefully this will get fixed; in the mean time I suggest you look at Addison Wesley's site (http://www.awl.com) for information on the second edition.
Rating:
Summary: Fantastic book
Review: Johnson and Troan is a great book for Linux programmers. It covers in good detail a wide range of topics in system programming, including process management, file and directory structures, linux development tools, signals, and terminal programming. Network programming is lightly covered, but network programming is a very large topic and is covered well in other books. Threads are also not covered, but again, threaded programming is a complex topic and is covered elsewhere. Johnson and Troan contains a long running example program, ladsh, which is a shell. This is a great example because developing a shell requires a high degree of interaction with the kernel and file system. The book does a great job of accurately covering the function prototypes for the core system library, including the many flags passed as parameters. Overall this is an excellent book, and it is one of the most frequently used programming texts on by shelf. I highly recommend it.
Rating:
Summary: A lot of good info in one place, but organization needs work
Review: The Linux operating system provides a sophisticated framework for running programs. Within its sturdy covers, Linux Application Development by Michael K. Johnson and Erik W. Troan provides much of what intermediate to advanced programmers need to know to take advantage of that framework.
The book is divided into four major parts: Getting Started, Development Tools and Environment, System Programming and Development Libraries.
Part 1 - Getting Started, is a very high-level overview of Linux itself. The three chapters cover barely 20 pages, and discuss the history of Linux, its licensing, and the online documentation.
Part 2 - Development Tools and Environment gets more detailed, but ends up as a medium-level view of what tools you might use to actually create and debug your application. Six chapters covering about 75 pages discuss editors (Emacs and vi), make, the GNU debugger gdb, tracing, gcc options, glibc, memory debugging tools, libraries, and the environment. Each chapter feels a little light-weight except for the one on memory debugging tools.
If the first two parts seemed to just skim the surface somewhat, Part 3 - System Programming definitely dives into the deep end of the pool. Part 3 has 13 chapters and covers 450 pages, almost two-thirds of the total book. My major complaint with Part 3 is that related chapters appear to be separated by others. Five major groups of functionality are covered.
The Unix/Linux process model is explained in detail in Chapter 10, and should be followed by chapter 15, which goes into job control. File handling is introduced in chapter 11, expanded in chapter 13, and directory handling is covered in chapter 14. Interprocess communication is discussed in chapters 12 - Signal Processing (discussing simple semaphores) and chapter 17 - Networking with Sockets, which extends IPC across the network. User interfaces are covered in chapters 16 (terminals and pseudo-terminals), 20 (virtual consoles), and 21 (text-based interfaces for the Linux console). Timers, encryption, and writing secure programs are the topics of chapters 18, 19, and 22.
Finally, Part 4 covers the various development libraries commonly available to the programmer. Chapter 23 covers the ins and outs of string handling and regular expressions. Using S-Lang to handle the terminal is the main interest of the next chapter. Chapter 25 discusses database interfaces, specifically qdbm, which is licensed under the LGPL. Traditional option functions getopt and getopt_long and their cousin on steriods popt are detailed in the following chapter. The final two chapters cover dynamic loading of shared objects with the advantages that provides, and user identification and authentication, covering id-to-name translation, and Pluggable Authentication Modules (PAM).
This book has a lot of information packed within its covers, When programming, one needs a number of reference books at hand, and Linux Application Development should definitely be one of the handiest. My only concerns were how the first two parts seemed skimpy compared to the rest of the book, and the part on System Programming could have been laid out better. That said, Linux Application Development rates a 4 out of 5.
Rating:
Summary: Contains information that is hard to find in other places.
Review: This book contains information that is just not in more introductory level Linux programming books. It is really Linux specific, rather than a Unix programming book that just has Linux printed on its cover because Linux sells books right now. In addition to covering the traditional interfaces, the Linux specific interfaces that those are built on top of are also covered.
Readers should notice that several of the interfaces used in this book are being depreciated infaver of reintrant (thread/signal safe) versions. This is something that hadn't yet happened when this book was written and is easily fixed by reading the man pages for any function that you worry about, as most have been made thread safe or have a thread safe version now.
Before reading this, I spent a lot of time using strace (easier than reading source code for apps and libs) on programs to figure out how they did things that other books on Unix or Linux programming left out.
The GOOD parts of this book are mostly in section 3 (system programming) and later, but well worth getting the book just for that.
To read this book you should:
_ know how to program in C
_ know how to use Unix or Linux from a command shell
_ know what users and groups are
Like most Linux books, this one waste too much space in the beginning telling what Linux is, what Unix is, and other stuff that is just included in too many books already.
This book may not tell you everything there is to know about programming for Linux, but it tells you enough to let man pages tell you the rest.
Rating:
Summary: Contains information that is hard to find in other places.
Review: This book contains information that is just not in more introductory level Linux programming books. It is really Linux specific, rather than a Unix programming book that just has Linux printed on its cover because Linux sells books right now. In addition to covering the traditional interfaces, the Linux specific interfaces that those are built on top of are also covered.
Readers should notice that several of the interfaces used in this book are being depreciated infaver of reintrant (thread/signal safe) versions. This is something that hadn't yet happened when this book was written and is easily fixed by reading the man pages for any function that you worry about, as most have been made thread safe or have a thread safe version now.
Before reading this, I spent a lot of time using strace (easier than reading source code for apps and libs) on programs to figure out how they did things that other books on Unix or Linux programming left out.
The GOOD parts of this book are mostly in section 3 (system programming) and later, but well worth getting the book just for that.
To read this book you should:
_ know how to program in C
_ know how to use Unix or Linux from a command shell
_ know what users and groups are
Like most Linux books, this one waste too much space in the beginning telling what Linux is, what Unix is, and other stuff that is just included in too many books already.
This book may not tell you everything there is to know about programming for Linux, but it tells you enough to let man pages tell you the rest.
Rating:
Summary: Elementary introduction to linux/unix programming
Review: This book does a decent job introducing basic concepts of unix (system) programming. It would be great for a newcomer to linux/unix. However, the unix/linux specific information is very incomplete - searches on google for related topics often yield more useful leads. On the system programming aspects, beyond the basics, this book is of no comparison to classics like Stevens' "Advanced Programming in the UNIX Environment". It only skims various system calls without detailed description of what's going on behind the scene, which most seasoned unix programmers would consider important. For newcomer who prefers a more rigorous approach to learning unix programming (but not as detailed as Stevens'), I would recommend Robbins' "Practical UNIX Programming: A Guide to Concurrency, Communication, and Multithreading".
Rating:
Summary: An excellent book for for programming in the Linux/Unix OS.
Review: This book is an excellent choice for someone with a serious desire to program in the Linux environement. It covers the simpler subjects briefly, before moving on to a more in depth coverage of more complex subjects. It also does a good job of pointing out where Linux differs from the POSIX standard, or where Linux offers alternatives to POSIX, to allow for more portable code. I would strongly recommend this book to any Linux/Unix programmers. [Note: You should have a strong grasp of the C Programming language to fully use this book.]
Rating:
Summary: Enlightening Introduction plus Excellent Reference Book
Review: This book was written with an easy to read style, and the content is excellent. I'll forgive them for not including anything related to X11 programming, but they mention that their reason was that X Windows programming is not specific to Linux, and this is a *LINUX* programming book. Well fine, but I still have to find a book on X Programming. Imagine a book on Windows NT Programming that skipped all the GUI parts. I guess the Unix crowd is 10 years behind the NT crowd in acceptance of GUIs.Reading this book made many of the arcane details of Unix architecture make sense, finally. I have read many Linux books, and most are long on technical drivel and short on enlightenment. If you are enlightened, you don't need the drivel, because the technical details are easy to absorbe and remember once they make sense. This book excels at making sense of Linux. It should have been called "Making Sense of Linux Application Development", because that's what it is. You could probably get a lot out of it, even if you don't know C very well or you aren't all that interested in C programming in Linux. The explanations are clearly presented, and the chapters stand alone, and are a great reference material, as well as interesting general reading for those interested in the internals of Linux. This book explains a lot of services that the kernel provides, especially in regards to the Linux process model and unix filesystems, as well as interprocess communications (Unix domain sockets) and network programming (TCP/IP sockets). CAVEAT: This shouldn't be your *first* Linux book. There's a lot of material besides the writing of the code that you need to cover first. To get you comfy in the classic Unix shell environment read Hands On Unix, by Mark Sobell.
|
