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

Rabu, 26 Oktober 2011

Belajar Python : Gratis E-Book Python Tutorials

Python Tutorials

Download : Python Tutorials

Learning to Program web tutor! - Become computer savie, yet do not have the true idea how programs you use are constructed? “Learning to Program Web Tutor” introduces the experienced computer user to the world of programming through simple explanation terms the new programmer can understand. Has general introduction to computer programming, its varied history, problem solving techniques and reasoning behind different programming concepts.

Belajar Perl : Gratis E-Book Embedding Perl in HTML with Mason

Embedding Perl in HTML with Mason


Mason is a tool for embedding the Perl programming language into text, in order to create text dynamically, most often in HTML. But Mason does not simply stop at HTML. It can just as easily create XML, WML, POD, configuration files, or the complete works of Shakespeare.

Table of Contents
Foreword
Preface
Intended Audience
Requirements
How to Read This Book
Overview
Other Resources
Typographic Conventions
We'd Like to Hear from You
Open Publication License
Acknowledgments
Chapter 1: Introduction
A First Example
The Main Features of Mason
Components: Modular Design Elements
Object-Style Component Inheritance
Intelligent Caching Mechanisms
Integration with Apache and mod_perl
Alternatives to Mason
Embperl
Apache::ASP
HTML::Template
Text::Template
Template Toolkit
PHP
Philosophy
Getting Started with Mason
A Standalone Installation
A mod_perl Installation
Trying It Out
Chapter 2: Components
Mason from 10,000 Feet
Core Concepts
Basic Component Syntax
Substitution Tags: <% %>
Embedded Perl: % Lines and <%perl> Blocks
Calling Other Components: <& &> Tags
Other Named Blocks
Escaping a Newline
Component Arguments
<%args> Block Revisited
%ARGS
%ARGS Versus @_
Argument Examples
Arguments via Component Calls
Arguments via HTTP Requests
Component Return Values
Special Globals
$m
$r
Sample Component
Chapter 3: Special Components: Dhandlers and Autohandlers
Dhandlers
Finer Control over Dhandlers
Dhandlers and Apache Configuration
Autohandlers
Using Autohandlers for Initialization
Using Autohandlers as Filters
Inspecting the Wrapping Chain
Using Autohandlers and Dhandlers Together
Chapter 4: APIs
Request Class and Object API
Constructor Parameters
Calling Other Components
Aborting the Flow of Execution
The Wrapping Chain
Dhandler-Related Methods
Miscellaneous Methods
Introspection
Buffer-Related Methods
Caching
Subrequests
Methods Available Only When Using ApacheHandler
Methods Available When Using ApacheHandler or CGIHandler
Getting in Close with Buffers
Component Object API
Methods for File-based Components
Buffers
Chapter 5: Advanced Features
Subcomponents
Creating Components on the Fly
Sharing Data Among Component Sections
Methods and Attributes
Methods
Using Methods for Titles and Headers
Methods with Dynamic Content
Attributes
Top-Down Versus Bottom-Up Inheritance
Calling Components with Content Blocks
Advanced Inheritance
Inheritance and Multiple Component Roots
An Advanced Inheritance Example
Subrequests
A Caution About Autohandler Inheritance
Chapter 6: The Lexer, Compiler, Resolver, and Interpreter Objects
Passing Parameters to Mason Classes
The Lexer
The Compiler
Altering Every Component's Content
Compiler Methods
The Resolver
The Interpreter
Request Parameters Passed to the Interpreter
Chapter 7: Using Mason with mod_perl
Configuring Mason
Configuration via httpd.conf
Configuration via Custom Code
Document Root Versus the Component Root
Not OK
$r
ApacheHandler Parameters
To Autoflush or Not to Autoflush
Generating Something Besides HTML
Apache::Status and Mason
Chapter 8: Building a Mason Site
Functionality
Directory Layout
File Extensions
Apache Configuration
The Components
The Unrestricted Parts
Components with Access Controls
All Done
Further Directions
Chapter 9: Mason and CGI
CGI-Appropriate Situations
CGI-Inappropriate Situations
Creating a CGI-Based Site in Mason
Using Mason Templates Inside Regular CGI Scripts
Design Considerations
Differences Between Mason Under CGI and mod_perl
Chapter 10: Scalable Design
Modules Versus Components
The Other Side
Components as Independent Units
Component Layout
File Naming and Directory Layout
Random Advice
Chapter 11: Recipes
Sessions
Without Touching httpd.conf
Predeclaring the Global via an httpd.conf File
Predeclaring the Global via a handler.pl Script
Using Cache::Cache for Sessions
Putting the Session ID in the URL
Making Use of Autoflush
User Authentication and Authorization
Using Apache::AuthCookie
Authentication Without Cookies
Access Controls with Attributes
Co-Branding Color Schemes
With Stylesheets
With Code
Developer Environments
Multiple Component Roots
Multiple Server Configurations
Managing DBI Connections
Using Mason Outside of Dynamic Web Sites
Generating a Static Site from Components
Generating Config Files
Chapter 12: Custom Mason Subclasses
Class::Container as a Superclass
Syntax: Your Very Own Lexer
Output: Compiling to a Different Output
Storage: Replacing the Resolver
Request: A Request Object with a Built-in Session
Argument Munging: ApacheHandler
More Reader Exercises
Appendix A: The Mason API
Interpreter
Object Properties
Directories
Runtime Methods
Request
Object Properties
Altering the Request Flow
Caching
Introspection
Content and Output
Fetching/Running Components
Subrequests
Component
Object Properties
Component Relationships
Inheritance
Resolver
ApacheHandler
CGIHandler
Compiler
Object Properties
Compilation Callbacks
Lexer
Appendix B: Object Constructor Parameters
HTML::Mason::Interp
HTML::Mason::Request
HTML::Mason::Resolver::File
HTML::Mason::ApacheHandler
HTML::Mason::Compiler
HTML::Mason::Component
HTML::Mason::Buffer
HTML::Mason::CGIHandler
HTML::Mason::Lexer
Appendix C: Text Editors That Understand Mason
Emacs
Vim
Appendix D: Content Management with Bricolage
Installing Bricolage
Elements: the Building Blocks of Content
Content Editing
Templates
Where to Learn More
Glossary
Colophon
Copyright


Belajar Perl : Gratis E-Book Perl Design Patterns Book

Perl Design Patterns Book


Perl Design Patterns documents Perl style and design/analysis. Design Patterns are a hands-on, pragmatic object oriented approach, in contrast to the vague, theory ridden texts IT is plagued with.

Perl Design Patterns documents Perl style and design/analysis. Design Patterns are a hands-on, pragmatic object oriented approach, in contrast to the vague, theory ridden texts IT is plagued with. We cover dynamic programming, lambda abstraction, and other techniques with the same approach.
Moderate through advanced experience level. Similar to "Design Pattern" books for Java, C++, influenced by "A Pattern Language", Christopher Alexander. At the time of this writing, approximately 100 pages worth of content exist, entirely covering the traditional, expected patterns. Browsing the Wiki directly at http://perldesignpatterns.com/?PerlDesignPatterns directly has the advantage of allowing you submit questions, corrections, ideas, and amendments directly, as well as browse non-linearly. CVS access is available as well, in some cases. Ultimate goal is to produce a bound, printed manual, preserving the GNU FDL license. The text should be useful as a college textbook on object oriented methods, an advanced language textbook using Perl, a guide for "Enterprise" software architecture using Perl, as well as merely a Perl-centric crash course on design patterns. Java and Smalltalk have long embraced design patterns, creating a commercial credibility sorely lacking in Perl. What is lacking? Proofreaders: My spelling is atrocious, but I can fix spelling and typographical errors in due time. Feedback on readability, accuracy, and comprehensiveness is much more important. Many sections are missing entirely or only very sketchy; others have not yet been discovered yet. Having addressed boring OO stuff, I'm expanding into the realm of dynamic languages, a somewhat uncharted area. Specific questions relating to how the book fits a real software development problem would be very useful. A section meant to catalog Perl modules related to software development, interoperability and frameworks has barely been started. Most of all, please read as much as you can stand, and tell me why you do or don't like it.

Registration Date: Thu 26 Sep 2002 12:05:56 AM UTC
License: GNU Free Documentation License
Development Status: 4 - Beta

Download : Perl Design Patterns Book

Belajar Python : Gratis E-Book Text Processing in Python

Text Processing in Python


At the broadest level text processing is simply taking textual information and -doing something- with it. This doing might be restructuring or reformatting it, extracting smaller bits of information from it, algorithmically modifying the content of the information, or performing calculations that depend on the textual information. The lines between "text" and the even more general term "data" are extremely fuzzy; at an approximation, "text" is just data that lives in forms that people can themselves read--at least in principle, and maybe with a bit of effort. Most typically computer "text" is composed of sequences of bits which have a "natural" representation as letters, numerals and symbols; and most often such text is delimited (if delimited at all) by symbols and formatting that can be easily pronounced as "next datum."


Belajar Perl : Gratis E-Book Beginning Perl

Beginning Perl

Download : Beginning Perl

This book is for those new to programming who want to learn with Perl. You will find it easier if you already have some basic programming experience, but the material covered can be mastered by anyone with just a text editor, some common sense and a computer. If you want to learn how to program with Perl and then find out far you can go with it, this is the book for you. An excellent companion on any programming course.

Introduction
Chapter 1: First Steps In Perl
Chapter 2: Working with Simple Values
Chapter 3: Lists and Hashes
Chapter 4: Loops and Decisions
Chapter 5: Regular Expressions
Chapter 6: Files and Data
Chapter 7: References
Chapter 8: Subroutines
Chapter 9: Running and Debugging Perl
Chapter 10: Modules
Chapter 11: Object-Oriented Perl
Chapter 12: Introduction to CGI
Chapter 13: Perl and Databases
Chapter 14: The World of Perl
Appendix A: Regular Expressions
Appendix B: Special Variables
Appendix C: Function Reference
Appendix D: The Perl Standard Modules
Appendix E: Command Line Reference
Appendix F: The ASCII Character Set
Appendix G: Licenses
Appendix H: Solutions to Exercises
Appendix J: Support, Errata and P2P.Wrox.Com
Index

Code Examples (Zip Format)
Code Examples (tar.gz Format)

Download : Beginning Perl

Belajar Python : Gratis E-Book Python Imaging Library Handbook

Python Imaging Library Handbook


The Python Imaging Library adds image processing capabilities to your Python interpreter. This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities. The core image library is designed for fast access to data stored in a few basic pixel formats. It should provide a solid foundation for a general image processing tool.

This is the PIL handbook, last updated May 6, 2005. This edition covers release 1.1.5 of the Python Imaging Library. You can find versions in other formats, as well as earlier versions, in the PythonWare library.

Belajar Perl : Gratis E-Book Web Client Programming with Perl

Web Client Programming with Perl - Automating Tasks on the Web


Table of Contents
Preface
Chapter 1: Introduction
Chapter 2: Demystifying the Browser
Chapter 3: Learning HTTP
Chapter 4: The Socket Library
Chapter 5: The LWP Library
Chapter 6: Example LWP Programs
Chapter 7: Graphical Examples with Perl/Tk

Appendix A: HTTP Headers
Appendix B: Reference Tables
Appendix C: The Robot Exclusion Standard

Index
Examples

Belajar Grails : Gratis E-Book Learning Perl the Hard Way

Learning Perl the Hard Way


I want a book for people who already know how to program in another language, but don't know Perl. I want a book that gets through the basics as quickly as possible. I'm sick of reading about the precedence of operators; I want to know how to do the fun stuff. I want a book that emphasizes good programming style in Perl. Many of the Perl programs I have seen are written in a quick-and-dirty style; I wanted to see if the style I have developed in other languages can translate. In many Perl books, object-oriented programming is treated as an optional feature for advanced programming. I wanted to bring it closer to the center of focus (although I am anything but an object-oriented bigot).


Belajar Python : Gratis E-Book Mason Developer Manual

Mason Developer Manual


While Mason can be used for tasks besides implementing a dynamic web site, that is what most people want to do with Mason, and is thus the focus of this manual.

NAME
DESCRIPTION
HOW TO USE THIS MANUAL
WHAT ARE COMPONENTS?
IN-LINE PERL SECTIONS
Examples and Recommended Usage
MASON OBJECTS
Request Objects
Component Objects
System Objects

CALLING COMPONENTS
Components that output HTML
Component Calls with Content
Advanced Components Calls with Content
Components that Return Values
Subrequests

TOP-LEVEL COMPONENTS
dhandlers
autohandlers
dhandlers vs. autohandlers

PASSING PARAMETERS
In Component Calls
In HTTP requests
Accessing Parameters
Parameter Passing Examples
Using @_ instead

INITIALIZATION AND CLEANUP
<%init>
<%cleanup>
<%once>
<%shared>

EMBEDDED COMPONENTS
<%def name>
<%method name>

FLAGS AND ATTRIBUTES
<%flags>
<%attr>

FILTERING
<%filter> section

COMMENT MARKERS
<%doc>
<% # comment... %>
%# comment
% if (0) { }

HTML/XML/... comments

OTHER SYNTAX
<%text>
Escaping expressions
User-defined Escapes
Manually applying escapes
Backslash at end of line

DATA CACHING
Basic Usage
Multiple Keys/Values
Expiration
Avoiding Concurrent Recomputation
Caching All Output
Cache Object
Choosing a Cache Subclass - with Cache::Cache
Choosing a Cache Subclass - with CHI
Accessing a Cache Externally
Mason 1.0x Cache API

WEB-SPECIFIC FEATURES
Sending HTTP Headers
Returning HTTP Status
Filters and $m->abort
External Redirects
Internal Redirects

USING THE PERL DEBUGGER

LOGGING

OBJECT-ORIENTED TECHNIQUES
Determining inheritance
Content wrapping
Accessing methods and attributes
Sharing data
Example

COMMON TRAPS

MASON AND SOURCE FILTERS
AUTHORS
SEE ALSO

Belajar Python : Gratis E-Book Practical mod_perl

Practical mod_perl


mod_perl is an Apache module that builds the power of the Perl programming language directly into the Apache web server. With mod_perl, CGI scripts run as much as 50 times faster, and you can integrate databases with the server, write Apache modules in Perl, embed Perl code directly into Apache configuration files, and even use Perl in server-side includes. With mod_perl, Apache is not only a web server, it is a complete programming platform.

Part I: mod_perl Administration

Chapter 1: Introducing CGI and mod_perl
Chapter 2: Getting Started Fast
Chapter 3: Installing mod_perl
Chapter 4: mod_perl Configuration
Chapter 5: Web Server Control, Monitoring, Upgrade, and Maintenance
Chapter 6: Coding with mod_perl in Mind

Part II: mod_perl Performance

Chapter 7: Identifying Your Performance Problems
Chapter 8: Choosing a Platform for the Best Performance
Chapter 9: Essential Tools for Performance Tuning
Chapter 10: Improving Performance with Shared Memory and Proper Forking
Chapter 11: Tuning Performance by Tweaking Apache's Configuration
Chapter 12: Server Setup Strategies
Chapter 13: TMTOWTDI: Convenience and Habit Versus Performance
Chapter 14: Defensive Measures for Performance Enhancement
Chapter 15: Improving Performance Through Build Options
Chapter 16: HTTP Headers for Optimal Performance

Part III: Databases and mod_perl

Chapter 17: Databases Overview
Chapter 18: mod_perl Data-Sharing Techniques
Chapter 19: DBM and mod_perl
Chapter 20: Relational Databases and mod_perl

Part IV: Debugging and Troubleshooting

Chapter 21: Error Handling and Debugging
Chapter 22: Troubleshooting mod_perl
Chapter 23: Getting Help and Online Resources

Part V: mod_perl 2.0

Chapter 24: mod_perl 2.0: Installation and Configuration
Chapter 25: Programming for mod_perl 2.0

Part VI: Appendixes

Appendix A: mod_perl Recipes
Appendix B: Apache Perl Modules
Appendix C: ISPs Providing mod_perl Services
Appendix D: The Template Toolkit
Appendix E: The AxKit XML Application Server
Appendix F: HTTP Status Codes
Index
Colophon

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.

Share

Twitter Delicious Facebook Digg Stumbleupon Favorites More