Free Shipping In Australia
Currency:
AUD $ AUD
Guaranteed Christmas Delivery Has Ended | We can no longer guarantee arrival by December 25th
Sams Teach Yourself Linux Programming in 24 Hours By Warren Gay

Sams Teach Yourself Linux Programming in 24 Hours
by Warren Gay

In Stock
$15.99
+10% GST

PLEASE PROVIDE COURSE INFORMATION

PLEASE PROVIDE

Only 1 left

Sams Teach Yourself Linux Programming in 24 Hours Summary


Sams Teach Yourself Linux Programming in 24 Hours by Warren Gay

Sams Teach Yourself Linux Programming in 24 Hours is a tutorial, organized into a series of easy-to-follow, 1-hour lessons. The book focuses on C, the fundamental language of Linux, throughout the lessons. You will learn: Linux, compilers and GNU, how to code a Linux Utility, Modular programming in "C", how to make files, Linux Command Option Processing, Linux filter programs, Error handling and reporting, Useful debugging techniques, Static and Shared Libraries, Advanced String functions, Conversion Functions, and Pipes and Processes.

Why buy from World of Books

Our excellent value books literally don't cost the earth
Free delivery in Australia
Read more here
Every used book bought is one saved from landfill

About Warren Gay


Warren Gay is a Linux/ UNIX developer for Mackenzie Financial Corporation and has been working as a developer since 1980 in areas including C/ C++ and Java. He has written articles for Linux Journal and won the Caldera CND 1.0 Beta Testing Prize for Linux utilities. If you use Linux... you are probably already using one of the software packages the Warren has donated to the Linux cause.

Table of Contents




Introduction.

Who Should Read This Book. Conventions Used in This Book.



Hour 1. Getting Started.

Introducing Linux. Introducing GNU gcc. Compiling for Debugging. Examining Compiler Warning Levels. Working with Compiler Warning Messages. Testing Your C Compiler. Summary. Q&A. Workshop.



Hour 2. Managing Your Source Code.

The Benefits of Using Source Control. What Tool Choices Exist? Setting Up RCS for a Project. Creating a New Source File. Viewing an RCS-Controlled File. Using an RCS Subdirectory. Checking Out Source for Editing. Editing Your Changes. Displaying Your Changes. Registering Your Changes. Listing History with the rlog Command. Embedded Substitutions. Using Source File Templates. Undoing a Locked Checkout. Summary. Q&A. Workshop.



Hour 3. Writing a Linux Utility.

Starting Project dos_cvrt. Using Command-Line Editing. Summary. Q&A. Workshop.



Hour 4. Modular Programming in C.

Programming in Modules. Making dos_cvrt.c Modular. Summary. Q&A. Workshop.



Hour 5. Introducing Makefiles.

Why Use make? The Makefile. Defining make Macros. Examining File Suffixes. Understanding Inference Rules. Using a Makefile for dos_cvrt. Summary. Q&A. Workshop.



Hour 6. Linux Command-Line Option Processing.

Introducing Command-Line Processing. Understanding Command-Line Conventions. Examining Arguments That Look Like Options. Introducing getopt(). Working with the getopt() Function Call. Reviewing the getopt() Function Prototype. Defining an Option-Processing Loop. Enhancing dos_cvrt to Use getopt(). Understanding the GNU Long Options Extension. Using the GNU getopt_long() Function. Adding GNU Long Options to dos_cvrt. Summary. Q&A. Workshop.



Hour 7. Error Handling and Reporting.

Learning How to Handle Errors. Understanding UNIX Error Reporting. The Old errno Value. The New errno Value. Reporting on errno Values. Enhancing dos_cvrt to be Error-Reporting Friendly. Testing for All Errors. Summary. Q&A. Workshop.



Hour 8. The Linux main Program and Its Environment.

The main Program Interface. The Linux Program Address Space. Working with the Environment. Process Exit Values. Summary. Q&A. Workshop.



Hour 9. Useful Debugging Techniques.

Introducing Debugging Techniques. Understanding the Limitations of a Debugger. Tracing with C Macros. Working with Runtime Debug Trace Facilities. Designing Subsystem Trace Facilities. Summary. Q&A. Workshop.



Hour 10. Static and Shared Libraries.

Introduction to C Libraries. The Static Library. The Shared Library. The Implications for Libraries. Knowing When to Use Static or Shared Libraries. Summary. Q&A. Workshop.



Hour 11. Advanced String Functions.

Introducing Advanced String Functions. Including the String Function Declarations. Functions strcasecmp() and strncasecmp(). Function strdup(). Functions strchr() and strrchr(). Function strpbrk(). Functions strspn() and strcspn(). Function strstr(). Functions strtok() and strtok_r(). Having Fun with Strings. Summary. Q&A. Workshop.



Hour 12. Conversion Functions.

Introduction to Conversion Functions. The atoi(), atol(), and atof() Family of Functions. Using sscanf() for Conversion and Validation. The strtol() and strtoul() Functions. The strtod() Function. Summary. Q&A. Workshop.



Hour 13. Linux Date and Time Facilities.

Introducing Date and Time Support. Introducing Epoch Time. Understanding the Current Linux Date and Time. Working with Time Conversion Functions. Customizing Date and Time Formats. Summary. Q&A. Workshop.



Hour 14. Userid, Password, and Group Management.

Introduction to Linux Management. The Identity Functions. Understanding the /etc/passwd File. The Password Database Routines. The Group Database. Summary. Q&A. Workshop.



Hour 15. File System Information and Management.

Performing Basic File Operations. Performing Directory Operations. Setting Your umask Value. Understanding File System Information. Summary. Q&A. Workshop.



Hour 16. Temporary Files and Process Cleanup.

Generating Temporary Filenames. Making Files Temporary. Summary. Q&A. Workshop.



Hour 17. Pipes and Processes.

Using External Processes. Introducing Pipes. Introducing the system() Function. Summary. Q&A. Workshop.



Hour 18. Forked Processes.

Introduction to Processes. The fork() Function. The wait() Family of Functions. The exec() Family of Functions. Summary. Q&A. Workshop.



Hour 19. Semaphores.

Introducing Semaphores. Creating and Accessing Semaphore Sets. Waiting on and Notifying Semaphore Sets. Releasing Semaphore System Resources. Using Semaphores in a Simulation. Summary. Q&A. Workshop.



Hour 20. Shared Memory.

Understanding the Need for Shared Memory. Identifying Shared Memory. Creating, Attaching, and Destroying Shared Memory. Using Shared Memory. Applying Shared Memory to a Game. Summary. Q&A. Workshop.



Hour 21. Message Queues.

Introducing the Message Queue. Working with Message Queues. The Paging Server. Summary. Q&A. Workshop.



Hour 22. Signals.

Understanding What Signals Are. Discovering Signal SIGINT. Understanding Signal Terminology. Understanding Reliable and Unreliable Signals. Working with Signal Sets. Setting Signal Actions. Catching Signals. Blocking and Unblocking Signals. Obtaining Pending Signals. Using the sigsuspend() Function. Using the alarm() Function. Advanced Signal Concepts. Commonly Used Linux Signals. Raising Linux Signals. Summary. Q&A. Workshop.



Hour 23. Client/Server Programming.

The Advantage of Client/Server. The TQL Server Design. Understanding SQL. Examining the TQL Source Code. Summary. Q&A. Workshop.



Hour 24. Using the Man Pages.

Introducing the man Command. Summary. Looking Ahead. Q&A. Workshop.



Appendix A. Answers to Quiz Questions.

Hour 1. Hour 2. Hour 3. Hour 4. Hour 5. Hour 6. Hour 7. Hour 8. Hour 9. Hour 10. Hour 11. Hour 12. Hour 13. Hour 14. Hour 15. Hour 16. Hour 17. Hour 18. Hour 19. Hour 20. Hour 21. Hour 22. Hour 23. Hour 24.



Index.

Additional information

GOR005310501
Sams Teach Yourself Linux Programming in 24 Hours by Warren Gay
Warren Gay
Used - Good
Hardback
Pearson Education (US)
1999-05-21
552
0672315823
9780672315824
N/A
Book picture is for illustrative purposes only, actual binding, cover or edition may vary.
This is a used book - there is no escaping the fact it has been read by someone else and it will show signs of wear and previous use. Overall we expect it to be in very good condition, but if you are not entirely satisfied please get in touch with us.