This is default featured post 1 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.This theme is Bloggerized by Lasantha Bandara - Premiumbloggertemplates.com.

This is default featured post 2 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.This theme is Bloggerized by Lasantha Bandara - Premiumbloggertemplates.com.

This is default featured post 3 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.This theme is Bloggerized by Lasantha Bandara - Premiumbloggertemplates.com.

This is default featured post 4 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.This theme is Bloggerized by Lasantha Bandara - Premiumbloggertemplates.com.

This is default featured post 5 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.This theme is Bloggerized by Lasantha Bandara - Premiumbloggertemplates.com.

Survey

Tampilkan postingan dengan label Ebook. Tampilkan semua postingan
Tampilkan postingan dengan label Ebook. Tampilkan semua postingan

Selasa, 25 Oktober 2011

Belajar Linux : Gratis E-Book Linux-For-Dummies 8th edition

Linux-For-Dummies 8th edition


Dee-Ann LeBlanc, Richard Blum Book is entitled “For Dummies”, but this free book really is not for Linux dummies, better to say professionals. New in Linux, check out some other free easier Linux book downloads here. Not really a pocket reference, can be hard to understand, the written book comes with some DVDs so, if you have an electronic copy of this book, you need to find the DVD images from the authors or publisher’s site. Download it, burn it and start reading. Author mentions GRUB and LILO, but the book does contain enough information about it.

Table of Contents

About This Book
1. Acknowledgments
2. Revision History
3. Source and pre-formatted versions available
4. Typographical Conventions

1. Introduction
1.1. Linux or GNU/Linux, that is the question.
1.2. Trademarks

2. Overview of a Linux System
2.1. Various parts of an operating system
2.2. Important parts of the kernel
2.3. Major services in a UNIX system

3. Overview of the Directory Tree
3.1. Background
3.2. The root filesystem
3.3. The /etc directory
3.4. The /dev directory
3.5. The /usr filesystem.
3.6. The /var filesystem
3.7. The /proc filesystem

4. Hardware, Devices, and Tools
4.1. Hardware Utilities
4.2. Kernel Modules

5. Using Disks and Other Storage Media
5.1. Two kinds of devices
5.2. Hard disks
5.3. Storage Area Networks - Draft
5.4. Network Attached Storage - Draft
5.5. Floppies
5.6. CD-ROMs
5.7. Tapes
5.8. Formatting
5.9. Partitions
5.10. Filesystems
5.11. Disks without filesystems
5.12. Allocating disk space

6. Memory Management
6.1. What is virtual memory?
6.2. Creating a swap space
6.3. Using a swap space
6.4. Sharing swap spaces with other operating systems
6.5. Allocating swap space
6.6. The buffer cache

7. System Monitoring
7.1. System Resources
7.2. Filesystem Usage
7.3. Monitoring Users

8. Boots And Shutdowns
8.1. An overview of boots and shutdowns
8.2. The boot process in closer look
8.3. More about shutdowns
8.4. Rebooting
8.5. Single user mode
8.6. Emergency boot floppies

9. init
9.1. init comes first
9.2. Configuring init to start getty: the /etc/inittab file
9.3. Run levels
9.4. Special configuration in /etc/inittab
9.5. Booting in single user mode

10. Logging In And Out
10.1. Logins via terminals
10.2. Logins via the network
10.3. What login does
10.4. X and xdm
10.5. Access control
10.6. Shell startup

11. Managing user accounts
11.1. What's an account?
11.2. Creating a user
11.3. Changing user properties
11.4. Removing a user
11.5. Disabling a user temporarily

12. Backups
12.1. On the importance of being backed up
12.2. Selecting the backup medium
12.3. Selecting the backup tool
12.4. Simple backups
12.5. Multilevel backups
12.6. What to back up
12.7. Compressed backups

13. Task Automation --To Be Added

14. Keeping Time
14.1. The concept of localtime
14.2. The hardware and software clocks
14.3. Showing and setting time
14.4. When the clock is wrong
14.5. NTP - Network Time Protocol
14.6. Basic NTP configuration
14.7. NTP Toolkit
14.8. Some known NTP servers
14.9. NTP Links

15. System Logs --To Be Added

16. System Updates --To Be Added

17. The Linux Kernel Source

18. Finding Help
18.1. Newsgroups and Mailing Lists
18.2. IRC

A. GNU Free Documentation License
A.1. PREAMBLE
A.2. APPLICABILITY AND DEFINITIONS
A.3. VERBATIM COPYING
A.4. COPYING IN QUANTITY
A.5. MODIFICATIONS
A.6. COMBINING DOCUMENTS
A.7. COLLECTIONS OF DOCUMENTS
A.8. AGGREGATION WITH INDEPENDENT WORKS
A.9. TRANSLATION
A.10. TERMINATION
A.11. FUTURE REVISIONS OF THIS LICENSE
A.12. ADDENDUM: How to use this License for your documents
Glossary (DRAFT, but not for long hopefully)
Index-Draft

List of Tables
5-1. Comparing Filesystem Features
5-2. Sizes
5-3. My Partitions
9-1. Run level numbers
12-1. Efficient backup scheme using many backup levels
List of Figures
2-1. Some of the more important parts of the Linux kernel
3-1. Parts of a Unix directory tree. Dashed lines indicate partition limits.
5-1. A schematic picture of a hard disk.
5-2. A sample hard disk partitioning.
5-3. Three separate filesystems.
5-4. /home and /usr have been mounted.
10-1. Logins via terminals: the interaction of init, getty, login, and the shell.
12-1. A sample multilevel backup schedule.

Belajar Linux: Gratis Ebook The Linux Cookbook, Great book by Michael Stutz

The Linux Cookbook, Great book by Michael Stutz


Free book uses open source resource resources to write the book. The book contains some out dated FAQs, inconsistent how to’s. He has put everything in such a way that, user can uses this book in almost every destro. The chapters are well organized and nicely covered with every aspects of Linux. Nice book for beginners and intermediates.
Linux System Administrator's Guide, Lars Wirzenius, Joanna Oja, Stephen Stafford, Alex WeeksOnline Linux book covers file system, disk uses, memory management, system monitoring, managing users and task automation. Linux book leaves out parts of the system administration, like security and managing servers from remote location nor the installation process and best practices. Free Linux book is a start but not written as a complete book for Linux System Administrators.

Preface
Format of Recipes
Assumptions, Scope, and Exclusions
Typographical Conventions
Versions, Latest Edition, and Errata
Acknowledgments
PART ONE: Working with Linux
Introduction
Background and History
What's Unix?
What's Free Software?
What's Open Source?
What's Linux?
What's Debian?
Unix and the Tools Philosophy
What to Try First
If You Need More Help
What Every Linux User Knows
Controlling Power to the System
Powering Up the System
Turning Off the System
Accounts and Privileges
Logging In to the System
Logging Out of the System
Console Basics
Switching between Consoles
Scrolling the Console Text
Keys for Console Manipulation
Running a Command
Changing Your Password
Listing User Activity
Listing Your Username
Listing Who Is on the System
Listing Who Is on and What They're Doing
Listing the Last Times a User Logged In
Listing System Activity
Listing Your Current Processes
Listing All of a User's Processes
Listing All Processes on the System
Listing Processes by Name or Number
Help Facilities
Finding the Right Tool for the Job
Listing a Description of a Program
Listing the Usage of a Tool
Reading a Page from the System Manual
Using the GNU Info System
Reading System Documentation and Help Files
The Shell
Keys for Command Line Editing
Passing Special Characters to Commands
Letting the Shell Complete What You Type
Repeating the Last Command You Typed
Running a List of Commands
Redirecting Input and Output
Redirecting Input to a File
Redirecting Output to a File
Redirecting Error Messages to a File
Redirecting Output to Another Command's Input
Managing Jobs
Suspending a Job
Putting a Job in the Background
Putting a Job in the Foreground
Listing Your Jobs
Stopping a Job
Command History
Viewing Your Command History
Specifying a Command from Your History
Recording a Shell Session
Customizing Your Shell
Changing the Shell Prompt
Making a Command Alias
Adding to Your Path
Customizing Future Shells
The X Window System
Running X
Starting X
Stopping X
Running a Program in X
Specifying Window Size and Location
Specifying Window Colors
Specifying Window Font
Specifying Additional Window Attributes
Manipulating X Client Windows
Moving a Window
Resizing a Window
Destroying a Window
Minimizing a Window
Maximizing a Window
Moving around the Desktop
Running a Shell in X
Configuring X
Switching between Video Modes
Running X Clients Automatically
Changing the Root Window Parameters
Choosing a Window Manager
PART TWO: Files
Files and Directories
Naming Files and Directories
Making an Empty File
Making a Directory
Making a Directory Tree
Changing Directories
Changing to Your Home Directory
Changing to the Last Directory You Visited
Getting the Name of the Current Directory
Listing Directories
Listing File Attributes
Listing Directories Recursively
Listing Newest Files First
Listing Hidden Files
Listing Directories in Color
Listing Directory Tree Graphs
Additional Directory Listing Options
Copying Files and Directories
Moving Files and Directories
Changing File Names to Lowercase
Renaming Multiple Files with the Same Extension
Removing Files and Directories
Removing a File with a Strange Name
A Safe Way to Remove a File
Giving a File More than One Name
Specifying File Names with Patterns
Browsing Files
Sharing Files
Groups and How to Work in Them
Listing the Groups a User Belongs To
Listing the Members of a Group
File Ownership
Determining the Ownership of a File
Changing the Ownership of a File
Controlling Access to Files
Listing the Permissions of a File
Changing the Permissions of a File
Write-Protecting a File
Making a File Private
Making a File Public
Making a File Executable
Finding Files
Finding All Files That Match a Pattern
Finding Files in a Directory Tree
Finding Files in a Directory Tree by Name
Finding Files in a Directory Tree by Size
Finding Files in a Directory Tree by Modification Time
Finding Files in a Directory Tree by Owner
Running Commands on the Files You Find
Finding Files by Multiple Criteria
Finding Files in Directory Listings
Finding the Largest Files in a Directory
Finding the Smallest Files in a Directory
Finding the Smallest Directories
Finding the Largest Directories
Finding the Number of Files in a Listing
Finding Where a Command Is Located
Managing Files
Determining File Type and Format
Changing File Modification Time
Splitting a File into Smaller Ones
Comparing Files
Determining Whether Two Files Differ
Finding the Differences between Files
Patching a File with a Difference Report
Compressed Files
Compressing a File
Decompressing a File
File Archives
Creating a File Archive
Listing the Contents of an Archive
Extracting Files from an Archive
Tracking Revisions to a File
Checking In a File Revision
Checking Out a File Revision
Viewing a File's Revision Log
PART THREE: Text
Viewing Text
Perusing Text
Perusing a Text File
Perusing Multiple Text Files
Commands Available While Perusing Text
Outputting Text
Showing Non-printing Characters
Outputting a Beginning Part of a Text
Outputting an Ending Part of a Text
Outputting a Middle Part of a Text
Outputting the Text between Strings
Outputting Text in a Dialect
Streaming Text
Viewing a Character Chart
Text Editing
Choosing the Perfect Text Editor
Emacs
Getting Acquainted with Emacs
Basic Emacs Editing Keys
Making Abbreviations in Emacs
Recording and Running Macros in Emacs
Inserting Special Characters in Emacs
Running a Vi Tutorial
Selecting Text
Cutting Text
Pasting Text
Editing Streams of Text
Concatenating Text
Writing Text to Files
Appending Text to a File
Inserting Text at the Beginning of a File
Including Text Files
Grammar and Reference
Spelling
Finding the Correct Spelling of a Word
Listing the Misspellings in a Text
Keeping a Spelling Word List
Interactive Spell Checking
Spell Checking in Emacs
Dictionaries
Listing Words that Match a Pattern
Listing the Definitions of a Word
Listing the Synonyms of a Word
Listing the Antonyms of a Word
Listing the Hypernyms of a Word
Online Dictionaries
Checking Grammar
Checking Text for Misused Phrases
Checking Text for Doubled Words
Checking Text for Readability
Checking Text for Difficult Sentences
Checking Text for Long Sentences
Word Lists and Reference Files
Analyzing Text
Counting Text
Counting the Characters in a Text
Counting the Words in a Text
Counting the Lines in a Text
Counting the Occurrences of Something
Counting Lines per Page in Emacs
Making a Concordance of a Text
Text Relevance
Sorting Text in Order of Relevance
Listing Relevant Files in Emacs
Finding Anagrams in Text
Finding Palindromes in Text
Text Cut-Ups
Making Simple Text Cut-Ups
Making Random Word Cut-Ups
Making Cut-Ups in Emacs
Formatting Text
Spacing Text
Eliminating Extra Spaces in Text
Single-Spacing Text
Double-Spacing Text
Triple-Spacing Text
Adding Line Breaks to Text
Adding Margins to Text
Swapping Tab and Space Characters
Paginating Text
Placing Headers on Each Page
Placing Text in Columns
Options Available When Paginating Text
Underlining Text
Sorting Text
Numbering Lines of Text
Reversing Text
Searching Text
Searching for a Word or Phrase
Regular Expressions -- Matching Text Patterns
Matching Lines Beginning with Certain Text
Matching Lines Ending with Certain Text
Matching Lines of a Certain Length
Matching Lines That Contain Any of Some Regexps
Matching Lines That Contain All of Some Regexps
Matching Lines That Don't Contain a Regexp
Matching Lines That Only Contain Certain Characters
Finding Phrases Regardless of Spacing
Finding Patterns in Certain Contexts
Using a List of Regexps to Match From
Regexps for Common Situations
Searching More than Plain Text Files
Matching Lines in Compressed Files
Matching Lines in Web Pages
Outputting the Context of a Search
Searching and Replacing Text
Searching Text in Emacs
Searching Incrementally in Emacs
Searching for a Phrase in Emacs
Searching for a Regexp in Emacs
Searching and Replacing in Emacs
Searching Text in Less
Typesetting and Word Processing
Choosing the Right Typesetting System for the Job
Converting Plain Text for Output
Outputting Text in a Font
Outputting Text as a Poster or Sign
Outputting Text with Language Highlighting
Outputting Text with Fancy Headers
Outputting Text in Landscape Orientation
Outputting Multiple Copies of Text
Selecting the Pages of Text to Output
Additional PostScript Output Options
LyX Document Processing
Features of LyX
Writing Documents with LyX
Learning More about LyX
Typesetting with TeX and Friends
Is It a TeX or LaTeX File?
Processing TeX Files
Processing LaTeX Files
Writing Documents with TeX and LaTeX
TeX and LaTeX Document Templates
Writing Documents with SGMLtools
Elements of an SGML Document
Checking SGML Document Syntax
Generating Output from SGML
Other Word Processors and Typesetting Systems
Fonts
X Fonts
Selecting an X Font Name
Listing Available X Fonts
Displaying the Characters in an X Font
Resizing the Xterm Font
Console Fonts
Setting the Console Font
Displaying the Characters in a Console Font
Text Fonts
Horizontal Text Fonts
Making a Text Banner
Other Font Tools
PART FOUR: Images
Viewing Images
Previewing Print Files
Previewing a DVI File
Previewing a PostScript File
Previewing a PDF File
Viewing an Image in X
Browsing Image Collections in X
Putting an Image in the Root Window
Browsing Images in a Console
Viewing an Image in a Web Browser
Browsing PhotoCD Archives
Additional Image Viewers
Editing Images
Transforming Images
Changing the Size of an Image
Rotating an Image
Adjusting the Colors of an Image
Annotating an Image
Adding Borders to an Image
Making an Image Montage
Combining Images
Morphing Two Images Together
Converting Images between Formats
Editing Images with the GIMP
Interactive Image Editors and Tools
Importing Images
Taking Screen Shots
Taking a Screen Shot in X
Taking a Screen Shot in a Console
Scanning Images
Listing Available Scanner Devices
Testing a Scanner
Scanning an Image
Extracting PhotoCD Images
Converting a PhotoCD Image
Removing PhotoCD Haze
PostScript
Manipulating PostScript Pages
Extracting DVI Pages to PostScript
Extracting Pages from a PostScript File
Combining PostScript Pages
Arranging PostScript Pages in Signatures
Manipulating PostScript Documents
Resizing a PostScript Document
Combining PostScript Documents
Arranging a PostScript Document in a Booklet
Converting PostScript
Converting PostScript to PDF
Converting PostScript to Plain Text
PART FIVE: Sound
Sound Files
Sound File Formats
Adjusting the Audio Controls
Listing the Current Audio Settings
Changing the Volume Level
Muting an Audio Device
Selecting an Audio Recording Source
Playing a Sound File
Playing an MP3 File
Playing a MIDI File
Recording a Sound File
Other Sound File Tools
Audio Compact Discs
Controlling CD Audio
Playing an Audio CD
Pausing an Audio CD
Stopping an Audio CD
Shuffling Audio CD Tracks
Displaying Information about an Audio CD
Ejecting an Audio CD
Sampling Sound from a CD
Writing an Audio CD-R
Other Audio CD Applications
Editing Sound Files
Working with Selections from Sound Files
Cutting Out Part of a Sound File
Pasting a Selection of Sound
Mixing Sound Files Together
Sound Effects
Changing the Amplitude of a Sound File
Changing the Sampling Rate of a Sound File
Adding Reverb to a Sound File
Adding Echo to a Sound File
Adding Flange to a Sound File
Adding Phase to a Sound File
Adding Chorus to a Sound File
Adding Vibro-Champ Effects to a Sound File
Reversing a Sound File
Converting Sound Files
Making an MP3 File
Converting MP3 to Another Format
Other Tools for Sound Editing
PART SIX: Productivity
Disk Storage
Listing a Disk's Free Space
Listing a File's Disk Usage
Floppy Disks
Formatting a Floppy Disk
Mounting a Floppy Disk
Unmounting a Floppy Disk
CD-ROMs
Mounting a CD-ROM
Unmounting a CD-ROM
Printing
Making and Managing Print Jobs
Sending a Print Job to the Printer
Printing Multiple Copies of a Job
Listing Your Print Jobs
Cancelling a Print Job
More Recipes for Printing
Printing in Emacs
Printing with Dvips
Printing the Contents of an Xterm Window
Preparing Files for Printing
Preparing a PostScript File for Printing
Preparing a DVI File for Printing
Preparing a PDF File for Printing
Preparing a Man Page for Printing
Cross-Platform Conversions
Using DOS and Windows Disks
Listing the Contents of a DOS Disk
Copying Files to and from a DOS Disk
Deleting Files on a DOS Disk
Formatting a DOS Disk
Using Macintosh Disks
Specifying the Macintosh Disk to Use
Listing the Contents of a Macintosh Disk
Copying Files to and from a Macintosh Disk
Deleting Files on a Macintosh Disk
Formatting a Macintosh Disk
Converting Text Files between DOS and Linux
Converting Microsoft Word Files
Converting Word to LaTeX
Converting Word to Plain Text
Reminders
Displaying the Date and Time
Playing an Audible Time Announcement
Calendars
Displaying a Calendar
Displaying a Calendar in Emacs
Managing Appointments
Making an Appointment File
Including Holidays in Your Reminders
Automatic Appointment Delivery
Contact Managers
Keeping a Free-Form Address List
Keeping a Contact Manager Database
Reminding Yourself of Things
Sending Yourself Email Reminders
Reminding Yourself When You Have to Leave
Running a Command on a Delay
Mathematics
Calculating Arithmetic
Making a Quick Arithmetic Calculation
Making Many Arithmetic Calculations
Outputting a Random Number
Listing a Sequence of Numbers
Finding Prime Factors
Converting Numbers
Converting an Amount between Units of Measurement
Converting an Arabic Numeral to English
Other Math Tools
PART SEVEN: Networking
Communications
Connecting to the Internet
Setting Up PPP
Controlling a PPP Connection
Faxing
Sending a Fax
Receiving a Fax
Receiving Faxes Automatically
Converting to and from Fax Format
Calling Out on a Modem
Email
Sending Mail
Mailing a User on the Same System
Mailing a File or the Output of a Command
Mailing the Contents of a URL
Special Mail Composition Keystrokes
Receiving Mail
Deleting Mail
Options Available while Reading Mail
Managing Mail
Viewing a Mail Folder
Setting Notification for New Mail
Counting How Many Messages You Have
Seeing Who Your Mail Is From
Verifying an Email Address
Mail Attachments
Reading a Mail Attachment
Sending a Mail Attachment
Making an Email Signature
Picking the Right Mail Application
The World Wide Web
Browsing the Web
Maintaining a List of Visited Web Sites
Opening a URL from a Script
Mozilla Browsing Tips
Viewing an Image from the Web
Reading Text from the Web
Perusing Text from the Web
Viewing a Site That Requires Authorization
Options Available while Browsing Text
Browsing the Web in Emacs
Getting Files from the Web
Saving a URL to a File
Archiving an Entire Web Site
Archiving Part of a Web Site
Reading the Headers of a Web Page
Writing HTML
Adding Parameters to Image Tags
Converting HTML to Another Format
Validating an HTML File
More Web Browsers and Tools
Other Internet Services
Connecting to Another System
Suspending a Connection with Another System
Connecting to Another System with Encryption
Transferring Files with Another System
Uploading a File
Downloading a File
Reading Usenet
Choosing a Newsreader
Finding Newsgroups for a Topic
Listing Online System and User Activity
Checking Whether a System Is Online
Checking Whether a User Is Online
Listing Who Is Logged In to a System
Finding the IP Address of a Host Name
Finding the Host Name of an IP Address
Listing the Owner of a Domain Name
Sending a Message to Another User's Terminal
Chatting with Other Users
Chatting Directly with a User
Chatting with Users on IRC
Chatting with Users on ICQ
Administrative Issues
Linux and Hardware Compatibility
Shutting Down the System
Shutting Down Immediately
Shutting Down at a Certain Time
Cancelling a Shutdown
Installing Software
Getting and Installing Debian
Installing a Debian Package
Upgrading a Debian Package
Installing a Shell Script
Administrating Users
Making a User Account
Letting Users Access Hardware Peripherals
Letting Users Mount Drives
Displaying Information about the System
How Long Has the System Been Up?
What Version of Linux Am I Running?
What Version of Debian Am I Running?
Linux Resources on the Web
License
Design Science License
Applying Copyleft to Your Work
Program Index
Concept Index

Belajar Linux: Gratis E-Book Java Application Development On Linux

Java Application Development On Linux


Java programming, in 1999 - 2000 in a Red Hat Linux box, supposed one was mad. No help available on the Internet; but the days are gone; Lots of good books available on the Internet on this topic. Simply covers the basics of Linux; Clear instructions on different compilers such as Sun java and IBM java compiler. Another interesting thing it also covers RMI (Remote Method Invocation), Javadoc, rmiregistry, rmic and jar. This book basically uses gcj, i.e. The GNU compiler for java with multiclass program. Great online Linux book.

Belajar Linux: Gratis E-Book The Big Online Book of Linux Ada Programming, Ken O. Burtch

The Big Online Book of Linux Ada Programming, Ken O. Burtch


Free Linux book reviews the code Ada 95 language along with the Ada bindings with other packages like – Motif, TCL and GTK+. Book download covers, the Predefined language libraries like GNAT. Linux book download perfect for the beginners and professionals; Clear instructions about installation, configuration and IDE. This Linux book covers TIA, GRASP and other IDE like VAD,Jessie,RAPID,VIDE,GLIDE. On the other hand it describes the AdaGIde a IDE for Windows. For modern Linux destros, the book covers Kdevelop and Ada Browser. In short – a step-by-step comprehensive guide for Ada

Table of Contents

i. Preface
1 Introduction
1.1 A Brief History of Linux
1.2 1995: The Year of Ada and Gnat
1.3 Why use Ada?
1.4 Why Ada and Linux?
1.5 Linux Ada Resources
2 Installing Gnat on Linux
2.1 Installing GCC Ada on Linux
2.2 Building GCC Ada from Sources
2.3 Installing the old NYU Gnat
2.4 Installing the old ALT Gnat
2.5 Compiling Older Versions of Gnat from Sources
2.6 Case Study: Installing Gnat 3.11 on over an old Linux Distribution
2.7 Gnat and Windows
2.8 Ada for .Net
3 The Integrated Development Environments
3.1 TIA: The Console IDE
3.1.1 Quick Start
3.1.2 TIA Keyboard Legend
3.1.3 The File Menu
3.1.4 The Edit Menu
3.1.5 The Find Menu
3.1.6 The Misc Menu
3.1.7 The Project Menu
3.1.8 The ? Menu
3.2 GRASP-the X windows IDE
3.2.1 Installation
3.2.2 QuickStart
3.2.3 The Project Window
3.2.4 The Source File Window
3.2.5 The Button Bar
3.3 Other Tools and IDEs
3.3.1 VAD - an IDE
3.3.2 Jessie - an IDE
3.3.3 RAPID - a GUI builder
3.3.3 VIDE - an IDE
3.3.5 GLIDE - an GUI builder
3.3.6 AdaGIDE (for Win32)
3.3.7 AdaBrowse - documentation tool
3.3.8 KDevelop - KDE's IDE (and it supports Ada)
3.3.9 Ada on the Eclipse IDE
3.4 BUSH (AdaScript Business Shell)
4 From Source Code to Executable
4.1 Gnat Filename Conventions
4.2 Writing Your First Ada Program
4.2.1 Writing a Program with an IDE
4.2.2 Writing a Program without an IDE
4.2.3 After Building
4.3 The Three Step Process
4.4 Gnat Compiling Options
4.4.1 Run-time Error Checking
4.4.2 Checking without Compiling
4.4.3 When you have Too Many Errors
4.5 Gnat Binding Options
4.6 Gnat Linking Options
4.7 Gnatmake Options
4.7.1 So you changed the comments ?
4.7.2 Gnatbl: Bind and Link
4.8 Project Management
4.9 Linker Pragmas
4.10 AdaControl Source Control Checker
5 Building Large Projects
5.1 Make: the Traditional Project Builder
5.1.1 A Simple Ada Makefile
5.2 Cook: A Parallel Make

5.2.1 Cooking in Parallel
5.2.2 A Simple Ada Cookbook
5.3 Automake and Autoconf: UNIX Portability
5.4 PRCS: Project-wide Source Control
6 Development Utilities
6.1 Saving Time with Gnatstub
6.2 Crossreferencing with Gnatxref
6.3 Eliminating Dead Code with Gnatelim
6.4 Execution Stack & Memory Leak Detection
6.5 Conditional Compiling with Gnatprep
6.6 Profiling with gprof
6.7 Static Libraries and Shared Libraries (gnatdll)
6.8 Source as Web Pages Using GnatHTML
6.9 GnatFIND
7 Optimizing Your Project
7.1 Compiler Optimization Options
7.2 Gnat Source Optimization Options
7.3 CPU Optimization Options
7.4 What Differnece Does Optimization Make?
7.5 Working with the Assmebly Source
8 Debugging Your Project
8.1 Limit and the Heap Size
8.2 The Debugging Pragmas
8.3 Identifying Files
8.4 Compiler Info with -gnatG
8.5 Floating Point Numbers
8.6 Gdb: The GNU Debugger
8.7 Code Restrictions
9 Team Development
9.1 Change Logs
9.2 RCS: Revision Control System
9.3 CVS: Concurrent Versions System
9.4 Creating Transcripts with Script
9.5 Timing Execution with Time
10 An Introduction to Ada
10.1 Your Main Program
10.2 Text_IO
10.3 Fundamental Data Types
10.4 Type Attributes
10.5 Operatiors and Expressions
10.6 Variable Declarations
10.7 New Types
10.7.1 Modular Types
10.7.2 Text_IO and New Types
10.8 Aggregate Types
10.9 Enumerated Types
10.10 Procedures and Function
10.11 Flow of Control
11 Advanced Ada Programming
11.1 Packages
11.2 Controlling Elaboration
11.2.1 First line of defense: Pure, Preelaborate and No_Elaboration_Code
11.2.2 Second line of defense: Elaborate, Elaborate_Body, Elaborate_All
11.2.3 Other Elaboration Pragmas
11.3 Objects
11.4 Objects with Automatic Initialization/Finalization
11.5 Multiple Inheritance
11.6 Private Objects
11.7 Generics
11.8 Exceptions
11.9 Dynamic Allocation
11.10 Callbacks
11.10.1 Storage Pools
11.10.2 Access Parameters
11.11 Multithreading
11.11.1 FSU vs. Native Threads
11.11.2 Tasks
11.11.3 Task Types
11.11.4 Protected Items/Types
11.12 Ada Text Streams
11.13 Pragmas
11.14 Low-Level Ada
12 Standard Gnat Packages
12.1 Standard String and Character Packages
12.1.1 String Performance
12.2 Advanced Input/Output
12.2.1 GNAT.IO
12.2.2 GNAT.IO_Aux
12.3 Sequential_IO
12.4 Direct_IO
12.5 Formatted Output
12.6 Calendar Package
12.7 Tags Package
12.8 Tables
12.8.1 Dynamic Tables [Not Yet Written]
12.9 Hash Tables
12.10 Bubble and Heap Sorts
12.11 Regular Expressions
12.12 Advanced String Processing
12.13 GLADE Distributed Processing [not finished]
12.14 Basic Math Packages
12.15 Exception Handling and Traceback Packages
12.16 GNAT.Most_Recent_Exception [Not Yet Written]
12.17 GNAT.Exception_Traces Package [Not Yet Written]
12.18 GNAT.CGI [Not Yet Written]
12.19 GNAT.CGI.Cookies [Not Yet Written]
12.20 GNAT.AWK [Not Yet Written]
12.21 GNAT.Threads [Not Yet Written]
12.22 GNAT.Expect [Not Yet Written]
12.23 Ada.Real_Time.Timing_Events [Not Yet Written]
12.24 Ada.Execution_Time [Not Yet Written]
13 Linux Introduction
13.1 Introduction to Processes
13.1.1 Parents, Children and Families
13.1.2 Ownership and Permissions
13.2 Using System and OsLib.Spawn
13.3 The Linux Environment
13.4 Standard C Libraries
13.5 The Linux Kernel
13.5.1 Kernel Calls
13.5.2 Devices
13.5.3 Proc File System
13.5.4 AudioCD: An Example Program
13.6 Standard Input/Output/Error
13.8 Linux Binary Formats
13.9 Linux Libraries
13.10 Libc5, Libc6 and Upward Compatibility
13.11 Linux Basics
14 Linux Programming
14.1 Gnat OS Library
14.2 Installing Binding Packages
14.3 Catching Linux Signals
14.3.1 Ada.Interrupts.Signals [Not Yet Written]
14.4 Working with the Command Line
14.4 Linux Environment Variables
14.6 GNAT.Directory_Operations Package
14.7 GNAT.Lock_Files Package
14.8 GNAT.Sockets
15 Free Ada Bindings
15.1 Using Florist, a POSIX binding
15.2 Using Texttools
15.2.1 Installation
15.2.2 Introduction
15.2.3 Package Overview
15.2.4 Window Overview
15.2.5 Other Useful Window Manager Subprograms
15.2.6 Alerts
15.2.7 Other Predefined Windows
15.2.8 Control Overview
15.2.9 OS Package
15.2.10 UserIO Overview
15.2.11 Appearance and Keys
15.3 Using Ncurses [not finished]
15.4 Using GTK+ Widgets [not finished]
15.5 Using Motif Widgets [not finished]
15.6 Using the TASH TCL Binding [not finished
15.7 Using the OpenGL Bindings [not finished]
15.8 Engine_3D
15.9 Using the APQ Postgres Binding
15.10 GNU.PDF - A PDF Package
15.11 Gwindows (for Win32) - GUI, DB, ActiveX
15.12 GNATCOM and DirectX (for Win32)
15.13 Graph - plotting library
15.14 Using QtAda Widgets [not finished]
15.15 Using Cairo [not finished]
16 Advanced Linux Programming
16.1 Writing Your Own Bindings
16.2 Linux Errors and Errno
16.3 The Linux Clock
16.3.1 Basic time functions
16.3.2 Timeval Calls - Microsecond Accuracy
16.3.3 Functions Using the tm Record
16.3.4 Time as a String
16.3.5 Timer Functions
16.4 Process Information
16.4.1 Ownership
16.4.2 Other Functions
16.5 Environment Variables
16.6 Multitasking
16.7 Linux File Operations
16.8 Opening and Closing Files
16.9 Directories
16.10 Stdio Files
16.11 Stdio Pipes
16.12 Memory Management
16.13 The Virtual Consoles
16.14 Making Database Queries
16.14.1 mySQL [not finished]
16.14.2 PostgreSQL [not finished]
16.15 Dynamic Loading [not finished]
16.16 Writing Linux Modules
16.17 Linux Sound
16.17.1 Detecting a Sound Card
16.17.2 Playing Sound Samples
16.17.3 Using the Mixer
16.17.4 Recording Sound Samples [not finished]
16.18 Audio CDs
16.19 Kernel Pipes [not finished]
16.20 Shared Memory [not finished]
16.21 Message Queues
16.22 Semaphores [not finished]
16.23 Sockets
16.24 Memory Management
16.25 Exit Procedures
16.26 Example: An Ada Daemon
17 Translating To Ada
17.1 c2ada: Translating Your Programs
17.2 Interfaces.C package
17.3 Interfaces.C.Pointers package
17.4 Interfaces.C_Streams package
17.5 Ada and C Files
17.6 A Word on Interfaces.Fortran
17.7 P2Ada - Pascal to Ada
18 Data Structures
18.1 Using the Booch Components
18.1.1 Containers
18.1.2 Iterators
18.1.3 Single linked Lists
18.1.4 Double linked Lists
18.1.5 Bags
18.1.6 Sets
18.1.7 Collections
18.1.8 Queues
18.1.9 Stacks
18.1.10 Deques
18.1.11 Rings
18.1.12 Maps
18.1.13 Binary Trees
18.1.14 AVL Trees
18.1.15 Multiway Trees
18.1.16 Graphs
18.1.17 Smart Pointers
18.1.18 Booch Multithreading
18.2 XMLAda - Unicode, XML, SAX and DOM
18.2.1 Unicode Basics
18.2.2 UTF and ASCII Characters
18.2.3 Unicode and Latin-1 Conversions
18.2.4 Ada, UTF-8 and UTF-16 Strings
18.2.5 Inputting XML
18.2.6 Parsing XML Using SAX (Simple API for XML)
18.2.7 SAX Example: RSS Headlines
18.2.8 SAX Attribute Handling
18.2.9 Parsing XML Using DOM (Document Object Model)
18.3 General Purpose Libraries
18.3.1 AdaCL
18.3.2 SAL (Stephe's Ada Library)
18.3.3 Jeffery Carter's PragmARCs
19 Java Byte Code and Mixing Languages
19.1 Ada Meets Java
19.1.1 The Java Virtual Machine
19.1.2 JGNAT [unfinished]
19.2 ASIS
19.3 Assembly Language
19.3.1 Pentium Family Processors
19.3.2 Instruction Set
19.3.3 Operands
19.3.4 System.Machine_Code.Asm
19.3.5 Other Asm Flags
19.3.6 A Complete Example
19.3.7 Assembly to Ada
19.4 Calling Ada from C
19.5 Calling C++ from Ada
19.6 Calling Ada from C++
19.7 Calling Ada from Java
19.8 GCC GNAT for Microcontrollers
20 Developing Your Project
20.1 The Project Proposal
20.2 The Design Phase
20.3 The Development Phase
20.4 The Alpha/Beta Release
20.5 Releasing Your Software
20.5.1 A Third Party Library
20.6 Distribution Formats
20.6.1 RPM: Red Hat Package Manager [not finished]
20.6.2 TGZ Packages
20.6.3 TAR.BZ2 Packages
20.6.4 Other Formats
20.7 Man Pages
20.8 Linux Software Map Entry
20.9 Licensing Options
Appendices
Appendix A: The Linux Shell
Appendix B: Linux Error Codes
Appendix C: Linux Kernel Calls
Appendix D: Signals
Appendix E: Ioctl parameters
Appendix F: Overview of Gnat Packages
Glossary

Belajar Linux: Gratis E-Book Ubuntu Pocket Guide and Reference Looking to delve further into the world of Ubuntu Linux?

Ubuntu Pocket Guide and Reference Looking to delve further into the world of Ubuntu Linux?


MacFreda's pocket guide and reference provides a bevy of useful tools and tips to help you better understand the world's most popular desktop Linux distribution. Holding this comprehensive yet surprisingly compact reference in your hand, you'll never be at a loss when confronting even the most difficult tasks in Ubuntu Linux. Chapters cover the desktop, the command line, security, file management, user creation, and much more! You'll find out fun, complex tasks like setting up dual monitors, automatically installing software packages, and enabling advanced desktop effects. Taking on Ubuntu Linux has never been this easy or fun.


Belajar Linux: Gratis E-Book Linux Device Drivers, 2nd Edition

Linux Device Drivers, 2nd Edition


As the popularity of the Linux system continues to grow, the interest in writing Linux device drivers steadily increases. Most of Linux is independent of the hardware it runs on, and most users can be (happily) unaware of hardware issues. But, for each piece of hardware supported by Linux, somebody somewhere has written a driver to make it work with the system. Without device drivers, there is no functioning system. Device drivers take on a special role in the Linux kernel. They are distinct "black boxes" that make a particular piece of hardware respond to a well-defined internal programming interface; they hide completely the details of how the device works. User activities are performed by means of a set of standardized calls that are independent of the specific driver; mapping those calls to device-specific operations that act on real hardware is then the role of the device driver. This programming interface is such that drivers can be built separately from the rest of the kernel, and "plugged in" at runtime when needed. This modularity makes Linux drivers easy to write, to the point that there are now hundreds of them available.

Table of Contents

Preface
Chapter 1: An Introduction to Device Drivers
Chapter 2: Building and Running Modules
Chapter 3: Char Drivers
Chapter 4: Debugging Techniques
Chapter 5: Enhanced Char Driver Operations
Chapter 6: Flow of Time
Chapter 7: Getting Hold of Memory
Chapter 8: Hardware Management
Chapter 9: Interrupt Handling
Chapter 10: Judicious Use of Data Types
Chapter 11: kmod and Advanced Modularization
Chapter 12: Loading Block Drivers
Chapter 13: mmap and DMA
Chapter 14: Network Drivers
Chapter 15: Overview of Peripheral Buses
Chapter 16: Physical Layout of the Kernel Source
Bibliography
Index

Belajar Linux : Gratis E-Book The Linux Development Platform

The Linux Development Platform


The Linux Development Platform shows how to choose the best open source and GNU development tools for your specific needs, and integrate them into a complete development environment that maximizes your effectiveness in any project. It covers editors, compilers, assemblers, debuggers, version control, utilities, LSB, Java, cross-platform solutions, and the entire Linux software development process.


Belajar Linux : Gratis E-Book The Art of Unix Programming

The Art of Unix Programming


There is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all. This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren't aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books — both explicit and implicit culture, both conscious and unconscious traditions. It is not a ‘how-to’ book, it is a ‘why-to’ book. The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn't anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design.

Table of Contents

Preface
Who Should Read This Book
How to Use This Book
Related References
Conventions Used in This Book
Our Case Studies
Author's Acknowledgements
I. Context
1. Philosophy
Culture? What Culture?
The Durability of Unix
The Case against Learning Unix Culture
What Unix Gets Wrong
What Unix Gets Right
Open-Source Software
Cross-Platform Portability and Open Standards
The Internet and the World Wide Web
The Open-Source Community
Flexibility All the Way Down
Unix Is Fun to Hack
The Lessons of Unix Can Be Applied Elsewhere
Basics of the Unix Philosophy
Rule of Modularity: Write simple parts connected by clean interfaces.
Rule of Clarity: Clarity is better than cleverness.
Rule of Composition: Design programs to be connected with other programs.
Rule of Separation: Separate policy from mechanism; separate interfaces from engines.
Rule of Simplicity: Design for simplicity; add complexity only where you must.
Rule of Parsimony: Write a big program only when it is clear by demonstration that nothing else will do.
Rule of Transparency: Design for visibility to make inspection and debugging easier.
Rule of Robustness: Robustness is the child of transparency and simplicity.
Rule of Representation: Fold knowledge into data, so program logic can be stupid and robust.
Rule of Least Surprise: In interface design, always do the least surprising thing.
Rule of Silence: When a program has nothing surprising to say, it should say nothing.
Rule of Repair: Repair what you can — but when you must fail, fail noisily and as soon as possible.
Rule of Economy: Programmer time is expensive; conserve it in preference to machine time.
Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.
Rule of Optimization: Prototype before polishing. Get it working before you optimize it.
Rule of Diversity: Distrust all claims for one true way.
Rule of Extensibility: Design for the future, because it will be here sooner than you think.
The Unix Philosophy in One Lesson
Applying the Unix Philosophy
Attitude Matters Too
2. History
Origins and History of Unix, 1969-1995
Genesis: 1969–1971
Exodus: 1971–1980
TCP/IP and the Unix Wars: 1980-1990
Blows against the Empire: 1991-1995
Origins and History of the Hackers, 1961-1995
At Play in the Groves of Academe: 1961-1980
Internet Fusion and the Free Software Movement: 1981-1991
Linux and the Pragmatist Reaction: 1991-1998
The Open-Source Movement: 1998 and Onward
The Lessons of Unix History
3. Contrasts
The Elements of Operating-System Style
What Is the Operating System's Unifying Idea?
Multitasking Capability
Cooperating Processes
Internal Boundaries
File Attributes and Record Structures
Binary File Formats
Preferred User Interface Style
Intended Audience
Entry Barriers to Development
Operating-System Comparisons
VMS
MacOS
OS/2
Windows NT
BeOS
MVS
VM/CMS
Linux
What Goes Around, Comes Around
II. Design
4. Modularity
Encapsulation and Optimal Module Size
Compactness and Orthogonality
Compactness
Orthogonality
The SPOT Rule
Compactness and the Strong Single Center
The Value of Detachment
Software Is a Many-Layered Thing
Top-Down versus Bottom-Up
Glue Layers
Case Study: C Considered as Thin Glue
Libraries
Case Study: GIMP Plugins
Unix and Object-Oriented Languages
Coding for Modularity
5. Textuality
The Importance of Being Textual
Case Study: Unix Password File Format
Case Study: .newsrc Format
Case Study: The PNG Graphics File Format
Data File Metaformats
DSV Style
RFC 822 Format
Cookie-Jar Format
Record-Jar Format
XML
Windows INI Format
Unix Textual File Format Conventions
The Pros and Cons of File Compression
Application Protocol Design
Case Study: SMTP, the Simple Mail Transfer Protocol
Case Study: POP3, the Post Office Protocol
Case Study: IMAP, the Internet Message Access Protocol
Application Protocol Metaformats
The Classical Internet Application Metaprotocol
HTTP as a Universal Application Protocol
BEEP: Blocks Extensible Exchange Protocol
XML-RPC, SOAP, and Jabber
6. Transparency
Studying Cases
Case Study: audacity
Case Study: fetchmail's -v option
Case Study: GCC
Case Study: kmail
Case Study: SNG
Case Study: The Terminfo Database
Case Study: Freeciv Data Files
Designing for Transparency and Discoverability
The Zen of Transparency
Coding for Transparency and Discoverability
Transparency and Avoiding Overprotectiveness
Transparency and Editable Representations
Transparency, Fault Diagnosis, and Fault Recovery
Designing for Maintainability
7. Multiprogramming
Separating Complexity Control from Performance Tuning
Taxonomy of Unix IPC Methods
Handing off Tasks to Specialist Programs
Pipes, Redirection, and Filters
Wrappers
Security Wrappers and Bernstein Chaining
Slave Processes
Peer-to-Peer Inter-Process Communication
Problems and Methods to Avoid
Obsolescent Unix IPC Methods
Remote Procedure Calls
Threads — Threat or Menace?
Process Partitioning at the Design Level
8. Minilanguages
Understanding the Taxonomy of Languages
Applying Minilanguages
Case Study: sng
Case Study: Regular Expressions
Case Study: Glade
Case Study: m4
Case Study: XSLT
Case Study: The Documenter's Workbench Tools
Case Study: fetchmail Run-Control Syntax
Case Study: awk
Case Study: PostScript
Case Study: bc and dc
Case Study: Emacs Lisp
Case Study: JavaScript
Designing Minilanguages
Choosing the Right Complexity Level
Extending and Embedding Languages
Writing a Custom Grammar
Macros — Beware!
Language or Application Protocol?
9. Generation
Data-Driven Programming
Case Study: ascii
Case Study: Statistical Spam Filtering
Case Study: Metaclass Hacking in fetchmailconf
Ad-hoc Code Generation
Case Study: Generating Code for the ascii Displays
Case Study: Generating HTML Code for a Tabular List
10. Configuration
What Should Be Configurable?
Where Configurations Live
Run-Control Files
Case Study: The .netrc File
Portability to Other Operating Systems
Environment Variables
System Environment Variables
User Environment Variables
When to Use Environment Variables
Portability to Other Operating Systems
Command-Line Options
The -a to -z of Command-Line Options
Portability to Other Operating Systems
How to Choose among the Methods
Case Study: fetchmail
Case Study: The XFree86 Server
On Breaking These Rules
11. Interfaces
Applying the Rule of Least Surprise
History of Interface Design on Unix
Evaluating Interface Designs
Tradeoffs between CLI and Visual Interfaces
Case Study: Two Ways to Write a Calculator Program
Transparency, Expressiveness, and Configurability
Unix Interface Design Patterns
The Filter Pattern
The Cantrip Pattern
The Source Pattern
The Sink Pattern
The Compiler Pattern
The ed pattern
The Roguelike Pattern
The ‘Separated Engine and Interface’ Pattern
The CLI Server Pattern
Language-Based Interface Patterns
Applying Unix Interface-Design Patterns
The Polyvalent-Program Pattern
The Web Browser as a Universal Front End
Silence Is Golden
12. Optimization
Don't Just Do Something, Stand There!
Measure before Optimizing
Nonlocality Considered Harmful
Throughput vs. Latency
Batching Operations
Overlapping Operations
Caching Operation Results
13. Complexity
Speaking of Complexity
The Three Sources of Complexity
Tradeoffs between Interface and Implementation Complexity
Essential, Optional, and Accidental Complexity
Mapping Complexity
When Simplicity Is Not Enough
A Tale of Five Editors
ed
vi
Sam
Emacs
Wily
The Right Size for an Editor
Identifying the Complexity Problems
Compromise Doesn't Work
Is Emacs an Argument against the Unix Tradition?
The Right Size of Software
III. Implementation
14. Languages
Unix's Cornucopia of Languages
Why Not C?
Interpreted Languages and Mixed Strategies
Language Evaluations
C
C++
Shell
Perl
Tcl
Python
Java
Emacs Lisp
Trends for the Future
Choosing an X Toolkit
15. Tools
A Developer-Friendly Operating System
Choosing an Editor
Useful Things to Know about vi
Useful Things to Know about Emacs
The Antireligious Choice: Using Both
Special-Purpose Code Generators
yacc and lex
Case Study: Glade
make: Automating Your Recipes
Basic Theory of make
make in Non-C/C++ Development
Utility Productions
Generating Makefiles
Version-Control Systems
Why Version Control?
Version Control by Hand
Automated Version Control
Unix Tools for Version Control
Runtime Debugging
Profiling
Combining Tools with Emacs
Emacs and make
Emacs and Runtime Debugging
Emacs and Version Control
Emacs and Profiling
Like an IDE, Only Better
16. Reuse
The Tale of J. Random Newbie
Transparency as the Key to Reuse
From Reuse to Open Source
The Best Things in Life Are Open
Where to Look?
Issues in Using Open-Source Software
Licensing Issues
What Qualifies as Open Source
Standard Open-Source Licenses
When You Need a Lawyer
IV. Community
17. Portability
Evolution of C
Early History of C
C Standards
Unix Standards
Standards and the Unix Wars
The Ghost at the Victory Banquet
Unix Standards in the Open-Source World
IETF and the RFC Standards Process
Specifications as DNA, Code as RNA
Programming for Portability
Portability and Choice of Language
Avoiding System Dependencies
Tools for Portability
Internationalization
Portability, Open Standards, and Open Source
18. Documentation
Documentation Concepts
The Unix Style
The Large-Document Bias
Cultural Style
The Zoo of Unix Documentation Formats
troff and the Documenter's Workbench Tools
TeX
Texinfo
POD
HTML
DocBook
The Present Chaos and a Possible Way Out
DocBook
Document Type Definitions
Other DTDs
The DocBook Toolchain
Migration Tools
Editing Tools
Related Standards and Practices
SGML
XML-DocBook References
Best Practices for Writing Unix Documentation
19. Open Source
Unix and Open Source
Best Practices for Working with Open-Source Developers
Good Patching Practice
Good Project- and Archive-Naming Practice
Good Development Practice
Good Distribution-Making Practice
Good Communication Practice
The Logic of Licenses: How to Pick One
Why You Should Use a Standard License
Varieties of Open-Source Licensing
MIT or X Consortium License
BSD Classic License
Artistic License
General Public License
Mozilla Public License
20. Futures
Essence and Accident in Unix Tradition
Plan 9: The Way the Future Was
Problems in the Design of Unix
A Unix File Is Just a Big Bag of Bytes
Unix Support for GUIs Is Weak
File Deletion Is Forever
Unix Assumes a Static File System
The Design of Job Control Was Badly Botched
The Unix API Doesn't Use Exceptions
ioctl2 and fcntl2 Are an Embarrassment
The Unix Security Model May Be Too Primitive
Unix Has Too Many Different Kinds of Names
File Systems Might Be Considered Harmful
Towards a Global Internet Address Space
Problems in the Environment of Unix
Problems in the Culture of Unix
Reasons to Believe
A. Glossary of Abbreviations
B. References
C. Contributors
D. Rootless Root
Editor's Introduction
Master Foo and the Ten Thousand Lines
Master Foo and the Script Kiddie
Master Foo Discourses on the Two Paths
Master Foo and the Methodologist
Master Foo Discourses on the Graphical User Interface
Master Foo and the Unix Zealot
Master Foo Discourses on the Unix-Nature
Master Foo and the End User
List of Figures

2.1. The PDP-7.
3.1. Schematic history of timesharing.
4.1. Qualitative plot of defect count and density vs. module size.
4.2. Caller/callee relationships in GIMP with a plugin loaded.
6.1. Screen shot of audacity.
6.2. Screen shot of kmail.
6.3. Main window of a Freeciv game.
8.1. Taxonomy of languages.
11.1. The xcalc GUI.
11.2. Screen shot of the original Rogue game.
11.3. The Xcdroast GUI.
11.4. Caller/callee relationships in a polyvalent program.
13.1. Sources and kinds of complexity.
18.1. Processing structural documents.
18.2. Present-day XML-DocBook toolchain.
18.3. Future XML-DocBook toolchain with FOP.
List of Tables

8.1. Regular-expression examples.
8.2. Introduction to regular-expression operations.
14.1. Language choices.
14.2. Summary of X Toolkits.
List of Examples

5.1. Password file example.
5.2. A .newsrc example.
5.3. A fortune file example.
5.4. Basic data for three planets in a record-jar format.
5.5. An XML example.
5.6. A .INI file example.
5.7. An SMTP session example.
5.8. A POP3 example session.
5.9. An IMAP session example.
6.1. An example fetchmail -v transcript.
6.2. An SNG Example.
7.1. The pic2graph pipeline.
8.1. Glade Hello, World.
8.2. A sample m4 macro.
8.3. A sample XSLT program.
8.4. Taxonomy of languages — the pic source.
8.5. Synthetic example of a fetchmailrc.
8.6. RSA implementation using dc.
9.1. Example of fetchmailrc syntax.
9.2. Python structure dump of a fetchmail configuration.
9.3. copy_instance metaclass code.
9.4. Calling context for copy_instance.
9.5. ascii usage screen.
9.6. Desired output format for the star table.
9.7. Master form of the star table.
10.1. A .netrc example.
10.2. X configuration example.
18.1. groff1 markup example.
18.2. man markup example.
19.1. tar archive maker production.

Belajar Linux: Gratis E-Book The Art of Unix Programming

The Art of Unix Programming


There is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all. This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren't aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books — both explicit and implicit culture, both conscious and unconscious traditions. It is not a ‘how-to’ book, it is a ‘why-to’ book. The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn't anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design.

Table of Contents

Preface
Who Should Read This Book
How to Use This Book
Related References
Conventions Used in This Book
Our Case Studies
Author's Acknowledgements

I. Context

1. Philosophy
Culture? What Culture?
The Durability of Unix
The Case against Learning Unix Culture
What Unix Gets Wrong
What Unix Gets Right
Open-Source Software
Cross-Platform Portability and Open Standards
The Internet and the World Wide Web
The Open-Source Community
Flexibility All the Way Down
Unix Is Fun to Hack
The Lessons of Unix Can Be Applied Elsewhere
Basics of the Unix Philosophy
Rule of Modularity: Write simple parts connected by clean interfaces.
Rule of Clarity: Clarity is better than cleverness.
Rule of Composition: Design programs to be connected with other programs.
Rule of Separation: Separate policy from mechanism; separate interfaces from engines.
Rule of Simplicity: Design for simplicity; add complexity only where you must.
Rule of Parsimony: Write a big program only when it is clear by demonstration that nothing else will do.
Rule of Transparency: Design for visibility to make inspection and debugging easier.
Rule of Robustness: Robustness is the child of transparency and simplicity.
Rule of Representation: Fold knowledge into data, so program logic can be stupid and robust.
Rule of Least Surprise: In interface design, always do the least surprising thing.
Rule of Silence: When a program has nothing surprising to say, it should say nothing.
Rule of Repair: Repair what you can — but when you must fail, fail noisily and as soon as possible.
Rule of Economy: Programmer time is expensive; conserve it in preference to machine time.
Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.
Rule of Optimization: Prototype before polishing. Get it working before you optimize it.
Rule of Diversity: Distrust all claims for one true way.
Rule of Extensibility: Design for the future, because it will be here sooner than you think.
The Unix Philosophy in One Lesson
Applying the Unix Philosophy
Attitude Matters Too

2. History
Origins and History of Unix, 1969-1995
Genesis: 1969–1971
Exodus: 1971–1980
TCP/IP and the Unix Wars: 1980-1990
Blows against the Empire: 1991-1995
Origins and History of the Hackers, 1961-1995
At Play in the Groves of Academe: 1961-1980
Internet Fusion and the Free Software Movement: 1981-1991
Linux and the Pragmatist Reaction: 1991-1998
The Open-Source Movement: 1998 and Onward
The Lessons of Unix History

3. Contrasts
The Elements of Operating-System Style
What Is the Operating System's Unifying Idea?
Multitasking Capability
Cooperating Processes
Internal Boundaries
File Attributes and Record Structures
Binary File Formats
Preferred User Interface Style
Intended Audience
Entry Barriers to Development
Operating-System Comparisons
VMS
MacOS
OS/2
Windows NT
BeOS
MVS
VM/CMS
Linux
What Goes Around, Comes Around

II. Design

4. Modularity
Encapsulation and Optimal Module Size
Compactness and Orthogonality
Compactness
Orthogonality
The SPOT Rule
Compactness and the Strong Single Center
The Value of Detachment
Software Is a Many-Layered Thing
Top-Down versus Bottom-Up
Glue Layers
Case Study: C Considered as Thin Glue
Libraries
Case Study: GIMP Plugins
Unix and Object-Oriented Languages
Coding for Modularity

5. Textuality
The Importance of Being Textual
Case Study: Unix Password File Format
Case Study: .newsrc Format
Case Study: The PNG Graphics File Format
Data File Metaformats
DSV Style
RFC 822 Format
Cookie-Jar Format
Record-Jar Format
XML
Windows INI Format
Unix Textual File Format Conventions
The Pros and Cons of File Compression
Application Protocol Design
Case Study: SMTP, the Simple Mail Transfer Protocol
Case Study: POP3, the Post Office Protocol
Case Study: IMAP, the Internet Message Access Protocol
Application Protocol Metaformats
The Classical Internet Application Metaprotocol
HTTP as a Universal Application Protocol
BEEP: Blocks Extensible Exchange Protocol
XML-RPC, SOAP, and Jabber

6. Transparency
Studying Cases
Case Study: audacity
Case Study: fetchmail's -v option
Case Study: GCC
Case Study: kmail
Case Study: SNG
Case Study: The Terminfo Database
Case Study: Freeciv Data Files
Designing for Transparency and Discoverability
The Zen of Transparency
Coding for Transparency and Discoverability
Transparency and Avoiding Overprotectiveness
Transparency and Editable Representations
Transparency, Fault Diagnosis, and Fault Recovery
Designing for Maintainability

7. Multiprogramming
Separating Complexity Control from Performance Tuning
Taxonomy of Unix IPC Methods
Handing off Tasks to Specialist Programs
Pipes, Redirection, and Filters
Wrappers
Security Wrappers and Bernstein Chaining
Slave Processes
Peer-to-Peer Inter-Process Communication
Problems and Methods to Avoid
Obsolescent Unix IPC Methods
Remote Procedure Calls
Threads — Threat or Menace?
Process Partitioning at the Design Level

8. Minilanguages
Understanding the Taxonomy of Languages
Applying Minilanguages
Case Study: sng
Case Study: Regular Expressions
Case Study: Glade
Case Study: m4
Case Study: XSLT
Case Study: The Documenter's Workbench Tools
Case Study: fetchmail Run-Control Syntax
Case Study: awk
Case Study: PostScript
Case Study: bc and dc
Case Study: Emacs Lisp
Case Study: JavaScript
Designing Minilanguages
Choosing the Right Complexity Level
Extending and Embedding Languages
Writing a Custom Grammar
Macros — Beware!
Language or Application Protocol?

9. Generation
Data-Driven Programming
Case Study: ascii
Case Study: Statistical Spam Filtering
Case Study: Metaclass Hacking in fetchmailconf
Ad-hoc Code Generation
Case Study: Generating Code for the ascii Displays
Case Study: Generating HTML Code for a Tabular List

10. Configuration
What Should Be Configurable?
Where Configurations Live
Run-Control Files
Case Study: The .netrc File
Portability to Other Operating Systems
Environment Variables
System Environment Variables
User Environment Variables
When to Use Environment Variables
Portability to Other Operating Systems
Command-Line Options
The -a to -z of Command-Line Options
Portability to Other Operating Systems
How to Choose among the Methods
Case Study: fetchmail
Case Study: The XFree86 Server
On Breaking These Rules

11. Interfaces
Applying the Rule of Least Surprise
History of Interface Design on Unix
Evaluating Interface Designs
Tradeoffs between CLI and Visual Interfaces
Case Study: Two Ways to Write a Calculator Program
Transparency, Expressiveness, and Configurability
Unix Interface Design Patterns
The Filter Pattern
The Cantrip Pattern
The Source Pattern
The Sink Pattern
The Compiler Pattern
The ed pattern
The Roguelike Pattern
The ‘Separated Engine and Interface’ Pattern
The CLI Server Pattern
Language-Based Interface Patterns
Applying Unix Interface-Design Patterns
The Polyvalent-Program Pattern
The Web Browser as a Universal Front End
Silence Is Golden

12. Optimization
Don't Just Do Something, Stand There!
Measure before Optimizing
Nonlocality Considered Harmful
Throughput vs. Latency
Batching Operations
Overlapping Operations
Caching Operation Results

13. Complexity
Speaking of Complexity
The Three Sources of Complexity
Tradeoffs between Interface and Implementation Complexity
Essential, Optional, and Accidental Complexity
Mapping Complexity
When Simplicity Is Not Enough
A Tale of Five Editors
ed
vi
Sam
Emacs
Wily
The Right Size for an Editor
Identifying the Complexity Problems
Compromise Doesn't Work
Is Emacs an Argument against the Unix Tradition?
The Right Size of Software

III. Implementation

14. Languages
Unix's Cornucopia of Languages
Why Not C?
Interpreted Languages and Mixed Strategies
Language Evaluations
C
C++
Shell
Perl
Tcl
Python
Java
Emacs Lisp
Trends for the Future
Choosing an X Toolkit

15. Tools
A Developer-Friendly Operating System
Choosing an Editor
Useful Things to Know about vi
Useful Things to Know about Emacs
The Antireligious Choice: Using Both
Special-Purpose Code Generators
yacc and lex
Case Study: Glade
make: Automating Your Recipes
Basic Theory of make
make in Non-C/C++ Development
Utility Productions
Generating Makefiles
Version-Control Systems
Why Version Control?
Version Control by Hand
Automated Version Control
Unix Tools for Version Control
Runtime Debugging
Profiling
Combining Tools with Emacs
Emacs and make
Emacs and Runtime Debugging
Emacs and Version Control
Emacs and Profiling
Like an IDE, Only Better

16. Reuse
The Tale of J. Random Newbie
Transparency as the Key to Reuse
From Reuse to Open Source
The Best Things in Life Are Open
Where to Look?
Issues in Using Open-Source Software
Licensing Issues
What Qualifies as Open Source
Standard Open-Source Licenses
When You Need a Lawyer

IV. Community

17. Portability
Evolution of C
Early History of C
C Standards
Unix Standards
Standards and the Unix Wars
The Ghost at the Victory Banquet
Unix Standards in the Open-Source World
IETF and the RFC Standards Process
Specifications as DNA, Code as RNA
Programming for Portability
Portability and Choice of Language
Avoiding System Dependencies
Tools for Portability
Internationalization
Portability, Open Standards, and Open Source

18. Documentation
Documentation Concepts
The Unix Style
The Large-Document Bias
Cultural Style
The Zoo of Unix Documentation Formats
troff and the Documenter's Workbench Tools
TeX
Texinfo
POD
HTML
DocBook
The Present Chaos and a Possible Way Out
DocBook
Document Type Definitions
Other DTDs
The DocBook Toolchain
Migration Tools
Editing Tools
Related Standards and Practices
SGML
XML-DocBook References
Best Practices for Writing Unix Documentation

19. Open Source
Unix and Open Source
Best Practices for Working with Open-Source Developers
Good Patching Practice
Good Project- and Archive-Naming Practice
Good Development Practice
Good Distribution-Making Practice
Good Communication Practice
The Logic of Licenses: How to Pick One
Why You Should Use a Standard License
Varieties of Open-Source Licensing
MIT or X Consortium License
BSD Classic License
Artistic License
General Public License
Mozilla Public License

20. Futures
Essence and Accident in Unix Tradition
Plan 9: The Way the Future Was
Problems in the Design of Unix
A Unix File Is Just a Big Bag of Bytes
Unix Support for GUIs Is Weak
File Deletion Is Forever
Unix Assumes a Static File System
The Design of Job Control Was Badly Botched
The Unix API Doesn't Use Exceptions
ioctl2 and fcntl2 Are an Embarrassment
The Unix Security Model May Be Too Primitive
Unix Has Too Many Different Kinds of Names
File Systems Might Be Considered Harmful
Towards a Global Internet Address Space
Problems in the Environment of Unix
Problems in the Culture of Unix
Reasons to Believe

A. Glossary of Abbreviations
B. References
C. Contributors
D. Rootless Root
Editor's Introduction
Master Foo and the Ten Thousand Lines
Master Foo and the Script Kiddie
Master Foo Discourses on the Two Paths
Master Foo and the Methodologist
Master Foo Discourses on the Graphical User Interface
Master Foo and the Unix Zealot
Master Foo Discourses on the Unix-Nature
Master Foo and the End User
List of Figures

2.1. The PDP-7.
3.1. Schematic history of timesharing.
4.1. Qualitative plot of defect count and density vs. module size.
4.2. Caller/callee relationships in GIMP with a plugin loaded.
6.1. Screen shot of audacity.
6.2. Screen shot of kmail.
6.3. Main window of a Freeciv game.
8.1. Taxonomy of languages.
11.1. The xcalc GUI.
11.2. Screen shot of the original Rogue game.
11.3. The Xcdroast GUI.
11.4. Caller/callee relationships in a polyvalent program.
13.1. Sources and kinds of complexity.
18.1. Processing structural documents.
18.2. Present-day XML-DocBook toolchain.
18.3. Future XML-DocBook toolchain with FOP.
List of Tables

8.1. Regular-expression examples.
8.2. Introduction to regular-expression operations.
14.1. Language choices.
14.2. Summary of X Toolkits.
List of Examples

5.1. Password file example.
5.2. A .newsrc example.
5.3. A fortune file example.
5.4. Basic data for three planets in a record-jar format.
5.5. An XML example.
5.6. A .INI file example.
5.7. An SMTP session example.
5.8. A POP3 example session.
5.9. An IMAP session example.
6.1. An example fetchmail -v transcript.
6.2. An SNG Example.
7.1. The pic2graph pipeline.
8.1. Glade Hello, World.
8.2. A sample m4 macro.
8.3. A sample XSLT program.
8.4. Taxonomy of languages — the pic source.
8.5. Synthetic example of a fetchmailrc.
8.6. RSA implementation using dc.
9.1. Example of fetchmailrc syntax.
9.2. Python structure dump of a fetchmail configuration.
9.3. copy_instance metaclass code.
9.4. Calling context for copy_instance.
9.5. ascii usage screen.
9.6. Desired output format for the star table.
9.7. Master form of the star table.
10.1. A .netrc example.
10.2. X configuration example.
18.1. groff1 markup example.
18.2. man markup example.
19.1. tar archive maker production.

Belajar Linux : Gratis E-Book Writing GNOME Applications

Writing GNOME Applications


Programming with GNOME is no simple task for the uninitiated. GNOME is one of the larger desktop programming suites you'll find. It has taken two years and hundreds of programmers to become what it is now. GNOME covers a lot of ground and makes use of many, many supporting libraries. Despite its nec- essary complexity, however, GNOME is very well laid out. It makes sense when you see it as a whole. On a line-by-line basis the code is not arcane or obfuscated. It's actually well written and quite nicely formatted. There's just so much of it! This book will attempt to guide you through all the fundamental parts of GNOME, to explain how things work and why. Rather than taking you through an exhaustive listing of function calls and coding semantics, we'll concentrate on what makes GNOME tick. We'll certainly go into detail about the important function calls and how to use them, but you'll still want to keep the official GNOME and GTK+ documentation on hand. The official documents are free, just like the rest of GNOME, and should even be bundled with your GNOME distribution. When you finish with this book, you should have a very clear, intuitive understanding of the GNOME 1.2 framework. You'll be able to write a com- plete GNOME application, from front to back. If you run into problems, you'll know how to diagnose the problem and where to look for the answers. It's impossible to know absolutely everything, but this book should at least iden- tify everything you need to know.

Table of Contents
Preface
Preface
Prerequisites
Conventions
Resources
Acknowledgments
2. The GTK+/GNOME System
GLib
Simple Data Types
Namespaces
Logging
Containers
Other Toys
GDK
The GTK+ Connection
The Thin Wrapper
GDK Events
Drawing Primitives
Reference Counting
GTK+
Widgets
The GTK+ Type System
Object Classes
Object Properties
Signals
GNOME
Core Libraries
Graphics Libraries
Components
Gnome-xml
3. The GNOME Build Environment
The Configuration Script
Running configure
Inside the configure Script
Makefile Variable Substitution
Creating Your Own Configuration
Autoconf
The Configuration Header
Checking for Tools
Checking for Header Files
Custom Checks
Helper Tools
Generating Makefiles
GNU Makefile Standards
Using automake
Automake Variables
Conditional Compiling
Cutting a Distribution
Dealing with Libraries
Libtool Support
libtoolize
A Grumpy Example
Exploring the Results
A Note about Version Numbers
Adding GNOME
GNOME Macros
gnome-config
GNOME Makefile Variables
autogen.sh
Some Grumpy GNOME Examples
10. Graphics
Graphics in the X Window System
Frame Buffers
Color Maps
Visuals
Drawables
Images
The GDK Wrapper
Simpler API
Using Color in GDK
GdkRGB
The RGB Buffer
Drawing Functions
Color Management
Libart
Vector Paths
Bezier Paths
Sorted Vector Paths
Microtile Arrays
Affine Transformations
Pixel Buffers
Gdk-pixbuf
Creating
Rendering
Scaling
Progressive Loading
Autoconf Support
Gdk-pixbuf Application Example
11. The GNOME Canvas
The Canvas
Double-Buffered Drawing Surface
The Canvas Abstraction
Canvas Groups
Events
Coordinate Systems
World Coordinates
Item Coordinates
Canvas Coordinates
Window Coordinates
Using the Canvas
GDK versus AA
The Scrolling Region
Adding Canvas Items
Moving Canvas Items Around
Transformations
Canvas Items
Vector-Based Drawing Items
Line Styles
The Shape of the Item
Widgets in the Canvas
Text Canvas Items
Graphical Canvas Items
Canvas Events
The Event Callback
Clicks and Double Clicks
Mouse Motion
Rollovers
Keyboard Events
Grabbing Items
Dragging and Dropping Canvas Items
A. GNU Free Documentation License
0. PREAMBLE
1. APPLICABILITY AND DEFINITIONS
2. VERBATIM COPYING
3. COPYING IN QUANTITY
4. MODIFICATIONS
5. COMBINING DOCUMENTS
6. COLLECTIONS OF DOCUMENTS
7. AGGREGATION WITH INDEPENDENT WORKS
8. TRANSLATION
9. TERMINATION
10. FUTURE REVISIONS OF THIS LICENSE
Addendum
List of Figures
2-1. Singly and Doubly Linked Lists
2-2. Structure of a Hash Table
2-3. Structure of an N-ary Tree
2-4. The GNOME Dependency Tree
2-5. GDK Event Flow
2-6. Widget Appearances
3-1. Running the configure Script
3-2. Running aclocal
3-3. Four Grumpy Library Cases
10-1. Color Map Example
10-2. Relationships among X Visuals
10-3. Double Buffering with a Pixmap
10-4. RGB Row Strides
10-5. Array of ArtVpath Elements
10-6. Vector Paths of the Letters V and R
10-7. Microtile Arrays
10-8. Rendering an Alpha Channel to a Bitmap
10-9. Scaling Parameters
10-10. Image Composition with testpixbuf-scale
10-11. Screen Shot of Sample Gdk-pixbuf Application
11-1. The test-gnome Application
11-2. Maximizing the Viewing Space
11-3. Bitmaps for Stipple Masks
11-4. Stipple Mask Example
11-5. Arrow Shapes for GnomeCanvasLine Item
11-6. Rectangle and Ellipse Canvas Items with the Same Bounding Box

GNU Emacs manual

GNU Emacs manual


Emacs is the extensible, customizable, self-documenting real-time display editor. This Info file describes how to edit with Emacs and some of how to customize it.

The GNU Emacs manual is available in the following formats:
HTML - with one page per node.
HTML - entirely on one page.
HTML compressed - entirely on one page.
HTML compressed - with one page per node.
Info document.
ASCII text.
ASCII text compressed.
TeX dvi file.
PostScript file.
PDF file.
Texinfo source

Belajar Linux : Gratis E-Book The Book of Webmin - How I Learned to Stop Worrying and Love UNIX

The Book of Webmin - How I Learned to Stop Worrying and Love UNIX

Belajar Linux : Gratis E-Book Vi iMproved (VIM)

Vi iMproved (VIM)


Vim is one of the most powerful text editors around. It is also extremely efficient, enabling the user to edit files with a minimum of key strokes. This power and functionality comes at a cost, however. When getting started, users face a steep learning curve.

Belajar Linux: Gratis E-Book Linux Client Migration Cookbook - A Practical Planning and Implementation Guide for Migrating to Desktop Linux

Linux Client Migration Cookbook - A Practical Planning and Implementation Guide for Migrating to Desktop Linux


Abstract
The goal of this IBM Redbooks publication is to provide a technical planning reference for IT organizations large or small that are now considering a migration to Linux-based personal computers. For Linux, there is a tremendous amount of “how-to” information available online that addresses specific and very technical operating system configuration issues, platform-specific installation methods, user interface customizations, and so forth. This book includes some technical “how-to” as well, but the overall focus of the content in this book is to walk the reader through some of the important considerations and planning issues that you could encounter during a migration project. Within the context of a pre-existing Microsoft Windows-based environment, we attempt to present a more holistic, end-to-end view of the technical challenges and methods necessary to complete a successful migration to Linux-based clients.
This second version of the Linux Client Migration Cookbook builds on the content strategy we started with in the first version. Although anyone interested in using Linux on the desktop could benefit from different portions of this book, our primary audience for this book is existing business IT environments that need to begin an evaluation of desktop Linux, or in a broader sense, any organization whose strategy is to move toward greater adoption of open source software and open standards. For this version, we have completed an end-to-end refresh and have added a significant amount of new content. Some key areas that we have focused on include the following:
- Greater emphasis on illustrating the technical details of the Linux client operating system stack, and understanding how to best leverage those differences in a migration scenario from Microsoft Windows
- The tremendous amount of flexibility that Linux gives you to design custom client operating system images
- Deployment models: Understanding how Linux's flexibility allows for new, innovative, and cost-effective approaches to deploying and managing desktop operating systems
- In larger IT environments, the importance of automating the capture and migration of user's client-side personalization data

Table of contents
Part 1 Choosing Linux
Chapter 1. Introduction
Chapter 2. The case for migration

Part 2 Planning the pilot migration
Chapter 3. Organizational and human factors planning
Chapter 4. Technical planning
Chapter 5. Linux architecture and technical differences

Part 3 Performing the pilot migration
Chapter 6. Migration best practices
Chapter 7. Client deployment models
Chapter 8. Client migration scenario
Chapter 9. Integration how-tos

Part 4 Appendixes
Appendix A. Linux glossary for Windows users
Appendix B. Using enterprise management tools
Appendix C. Automating desktop migration using Versora Progression Desktop
Appendix D. Multi-station computing deep dive using Userful Desktop Multiplier
Appendix E. Client personalization
Appendix F. Desktop automation and scripting
Appendix G. Application porting

Belajar Linux : Gratis E-Book GNU Bash Reference Manual

GNU Bash Reference Manual


Bash is the shell, or command language interpreter, for the GNU operating system. The name is an acronym for the 'Bourne-Again SHell', a pun on Stephen Bourne, the author of the direct ancestor of the current Unix shell /bin/sh, which appeared in the Seventh Edition Bell Labs Research version of Unix.

Publisher's Preface
1 Introduction

1.1 What is Bash?
1.2 What is a shell?

2 Definitions
3 Basic Shell Features

3.1 Shell Syntax

3.1.1 Shell Operation
3.1.2 Quoting

3.1.2.1 Escape Character
3.1.2.2 Single Quotes
3.1.2.3 Double Quotes
3.1.2.4 ANSI-C Quoting
3.1.2.5 Locale-Specific Translation

3.1.3 Comments

3.2 Shell Commands

3.2.1 Simple Commands
3.2.2 Pipelines
3.2.3 Lists of Commands
3.2.4 Compound Commands

3.2.4.1 Looping Constructs
3.2.4.2 Conditional Constructs
3.2.4.3 Grouping Commands

3.3 Shell Functions
3.4 Shell Parameters

3.4.1 Positional Parameters
3.4.2 Special Parameters

3.5 Shell Expansions

3.5.1 Brace Expansion
3.5.2 Tilde Expansion
3.5.3 Shell Parameter Expansion
3.5.4 Command Substitution
3.5.5 Arithmetic Expansion
3.5.6 Process Substitution
3.5.7 Word Splitting
3.5.8 Filename Expansion

3.5.8.1 Pattern Matching

3.5.9 Quote Removal

3.6 Redirections

3.6.1 Redirecting Input
3.6.2 Redirecting Output
3.6.3 Appending Redirected Output
3.6.4 Redirecting Standard Output and Standard Error
3.6.5 Here Documents
3.6.6 Here Strings
3.6.7 Duplicating File Descriptors
3.6.8 Moving File Descriptors
3.6.9 Opening File Descriptors for Reading and Writing

3.7 Executing Commands

3.7.1 Simple Command Expansion
3.7.2 Command Search and Execution
3.7.3 Command Execution Environment
3.7.4 Environment
3.7.5 Exit Status
3.7.6 Signals

3.8 Shell Scripts

4 Shell Builtin Commands

4.1 Bourne Shell Builtins
4.2 Bash Builtin Commands
4.3 The Set Builtin
4.4 Special Builtins

5 Shell Variables

5.1 Bourne Shell Variables
5.2 Bash Variables

6 Bash Features

6.1 Invoking Bash
6.2 Bash Startup Files
6.3 Interactive Shells

6.3.1 What is an Interactive Shell?
6.3.2 Is this Shell Interactive?
6.3.3 Interactive Shell Behavior

6.4 Bash Conditional Expressions
6.5 Shell Arithmetic
6.6 Aliases
6.7 Arrays
6.8 The Directory Stack

6.8.1 Directory Stack Builtins

6.9 Controlling the Prompt
6.10 The Restricted Shell
6.11 Bash POSIX Mode

7 Job Control

7.1 Job Control Basics
7.2 Job Control Builtins
7.3 Job Control Variables

8 Command Line Editing

8.1 Introduction to Line Editing
8.2 Readline Interaction

8.2.1 Readline Bare Essentials
8.2.2 Readline Movement Commands
8.2.3 Readline Killing Commands
8.2.4 Readline Arguments
8.2.5 Searching for Commands in the History

8.3 Readline Init File

8.3.1 Readline Init File Syntax
8.3.2 Conditional Init Constructs
8.3.3 Sample Init File

8.4 Bindable Readline Commands

8.4.1 Commands For Moving
8.4.2 Commands For Manipulating The History
8.4.3 Commands For Changing Text
8.4.4 Killing And Yanking
8.4.5 Specifying Numeric Arguments
8.4.6 Letting Readline Type For You
8.4.7 Keyboard Macros
8.4.8 Some Miscellaneous Commands

8.5 Readline vi Mode
8.6 Programmable Completion
8.7 Programmable Completion Builtins

9 Using History Interactively

9.1 Bash History Facilities
9.2 Bash History Builtins
9.3 History Expansion

9.3.1 Event Designators
9.3.2 Word Designators
9.3.3 Modifiers

10 Installing Bash

10.1 Basic Installation
10.2 Compilers and Options
10.3 Compiling For Multiple Architectures
10.4 Installation Names
10.5 Specifying the System Type
10.6 Sharing Defaults
10.7 Operation Controls
10.8 Optional Features

A Reporting Bugs
B Major Differences From The Bourne Shell
B.1 Implementation Differences From The SVR4.2 Shell
C Copying This Manual
History
Index of Shell Builtin Commands
Index of Shell Reserved Words
Parameter and Variable Index
Function Index
Concept Index

Share

Twitter Delicious Facebook Digg Stumbleupon Favorites More