%{search_type} search results

• Intro
• Inhalt
• Vorwort
• Danksagung
• Die Bell Labs
• Naturwissenschaften in den Bell Labs
• Kommunikationstechnik und Informatik
• Meine Zeit in den Bell Labs
• Die Büros
• 137 → 127 → 1127 → 11276
• Das Ur-Unix (1969)
• Technischer Hintergrund
• CTSS und Multics
• Die Ursprünge von Unix
• Namen sind Schall und Rauch
• Biografie: Ken Thompson
• Erste Version (1971)
• Unix für Patentanträge
• Der Unix-Raum
• Das Unix-Programmiererhandbuch
• Anmerkungen zum Thema Speicher
• Biografie: Dennis Ritchie
• Sechste Version (1975)
• Das Dateisystem
• Systemaufrufe

• Die Shell
• Pipes
• Grep
• Reguläre Ausdrücke
• Die Programmiersprache C
• Ratfor und »Software Tools«
• Biografie: Doug McIlroy
• Siebte Version (1976-1979)
• Die Bourne-Shell
• Yacc, Lex und Make
• Dokumenterstellung
• Sed und Awk
• Andere Sprachen
• Weitere Errungenschaften
• Jenseits der Forschung
• Programmer's Workbench
• Universitätslizenzen
• Benutzergruppen und Usenix
• John Lions' Kommentar
• Portierbarkeit
• Kommerzialisierung
• Zerschlagung
• USL und SVR4
• UNIX™
• Public Relations
• Abkömmlinge
• BSD (Berkeley Software Distribution)
• Die Unix-Kriege

• Minix und Linux
• Plan 9
• Diaspora
• Das Vermächtnis
• Technische Aspekte
• Organisatorische Aspekte
• Anerkennung
• Könnte sich die Geschichte wiederholen?
• Quellen
• Quellen
• Index

• 1. Style. Names. Expressions and Statements. Consistency and Idioms. Function Macros. Magic Numbers. Comments. Why Bother?
• 2. Algorithms and Data Structures. Searching. Sorting. Libraries. A Java Quicksort. O-Notation. Growing Arrays. Lists. Trees. Hash Tables. Summary.
• 3. Design and Implementation. The Markov Chain Algorithm. Data Structure Alternatives. Building the Data Structure in C. Generating Output. Java. C++. Awk and Perl. Performance. Lessons.
• 4. Interfaces. Comma-Separated Values. A Prototype Library. A Library for Others. A C++ Implementation. Interface Principles. Resource Management. Abort, Retry, Fail? User Interfaces.
• 5. Debugging. Debuggers. Good Clues, Easy Bugs. No Clues, Hard Bugs. Last Resorts. Non-reproducible Bugs. Debugging Tools. Other People's Bugs. Summary.
• 6. Testing. Test as You Write the Code. Systematic Testing. Test Automation. Test Scaffolds. Stress Tests. Tips for Testing. Who Does the Testing? Testing the Markov Program. Summary.
• 7. Performance. A Bottleneck. Timing and Profiling. Strategies for Speed. Tuning the Code. Space Efficiency. Estimation. Summary.
• 8. Portability. Language. Headers and Libraries. Program Organization. Isolation. Data Exchange. Byte Order. Portability and Upgrade. Internationalization. Summary.
• 9. Notation. Formatting Data. Regular Expressions. Programmable Tools. Interpreters, Compilers, and Virtual Machines. Programs that Write Programs. Using Macros to Generate Code. Compiling on the Fly. Epilogue. Appendix: Collected Rules. Index. 020161586XT04062001.
• (source: Nielsen Book Data)

With the same insight and authority that made their book The Unix Programming Environment a classic, Brian Kernighan and Rob Pike have written The Practice of Programming to help make individual programmers more effective and productive. This book is full of practical advice and real-world examples in C, C++, Java, and a variety of special-purpose languages. Kernighan and Pike have distilled years of experience writing programs, teaching, and working with other programmers to create this book. Anyone who writes software will profit from its principles and guidance.
(source: Nielsen Book Data)

Introduces the features of the C programming language, discusses data types, variables, operators, control flow, functions, pointers, arrays, and structures, and looks at the UNIX system interface.
(source: Nielsen Book Data)

Introduces the features of the C programming language, discusses data types, variables, operators, control flow, functions, pointers, arrays, and structures, and looks at the UNIX system interface.
(source: Nielsen Book Data)

• 1. UNIX for Beginners.
• 2. The File System.
• 3. Using the Shell.
• 4. Filters.
• 5. Shell Programming.
• 6. Programming with Standard I/0.
• 7. UNIX System Calls.
• 8. Program Development.
• 9. Document Preparation. Epilog. Appendices. Index.
• (source: Nielsen Book Data)

In their preface, the authors explain, "This book is meant to help the reader learn how to program in C. It contains tutorial introduction to get new users started as soon as possible, separate chapters on each major feature, and a reference manual. Most of the treatment is based on reading, writing, and revising examples, rather than on mere statement of rules. For the most part, the examples are complete, real programs, rather than isolated garments. All examples have been tested directly from the text, which is in machine-readable form. Besides showing how to make effective use of the language, we have also tried where possible to illustrate useful algorithms and principles of good style and sound design....
(source: Nielsen Book Data)

With the same style and clarity that characterized their highly acclaimed The Elements of Programming Style and Software Tools, the authors have written Software Tools in Pascal to teach how to write good Pascal programs that make good tools. The programs contained in the book are not artificial, but are actual tools that have proved valuable in the production of other programs. Structured programming and top-down design are emphasized and applied to every program, as are principles of sound design, testing, efficiency, and portability. All of the programs are complete and have been tested directly from the text. The programs are available in machine-readable form from Addison-Wesley. Software Tools in Pascal is ideal for use in a software engineering course, for a second course in programming, or as a supplement in any programming course. All programmers, professional and student, will find the book invaluable as a source of proven, useful programs for reading and study. Numerous exercises are provided to test comprehension and to extend the concepts presented in the book. 0201103427B04062001.
(source: Nielsen Book Data)

• Preface xi
• Chapter 1: Tutorial 1 1.1 Hello, World 1 1.2 Command-Line Arguments 4 1.3 Finding Duplicate Lines 8 1.4 Animated GIFs 13 1.5 Fetching a URL 15 1.6 Fetching URLs Concurrently 17 1.7 A Web Server 19 1.8 Loose Ends 23
• Chapter 2: Program Structure 27 2.1 Names 27 2.2 Declarations 28 2.3 Variables 30 2.4 Assignments 36 2.5 Type Declarations 39 2.6 Packages and Files 41 2.7 Scope 45
• Chapter 3: Basic Data Types 51 3.1 Integers 51 3.2 Floating-Point Numbers 56 3.3 Complex Numbers 61 3.4 Booleans 63 3.5 Strings 64 3.6 Constants 75
• Chapter 4: Composite Types 81 4.1 Arrays 81 4.2 Slices 84 4.3 Maps 93 4.4 Structs 99 4.5 JSON 107 4.6 Text and HTML Templates 113
• Chapter 5: Functions 119 5.1 Function Declarations 119 5.2 Recursion 121 5.3 Multiple Return Values 124 5.4 Errors 127 5.5 Function Values 132 5.6 Anonymous Functions 135 5.7 Variadic Functions 142 5.8 Deferred Function Calls 143 5.9 Panic 148 5.10 Recover 151
• Chapter 6:. Methods 155 6.1 Method Declarations 155 6.2 Methods with a Pointer Receiver 158 6.3 Composing Types by Struct Embedding 161 6.4 Method Values and Expressions 164 6.5 Example: Bit Vector Type 165 6.6 Encapsulation 168
• Chapter 7: Interfaces 171 7.1 Interfaces as Contracts 171 7.2 Interface Types 174 7.3 Interface Satisfaction 175 7.4 Parsing Flags with flag.Value 179 7.5 Interface Values 181 7.6 Sorting with sort.Interface 186 7.7 The http.Handler Interface 191 7.8 The error Interface 196 7.9 Example: Expression Evaluator 197 7.10 Type Assertions 205 7.11 Discriminating Errors with Type Assertions 206 7.12 Querying Behaviors with Interface Type Assertions 208 7.13 Type Switches 210 7.14 Example: Token-Based XML Decoding 213 7.15 A Few Words of Advice 216
• Chapter 8: Goroutines and Channels 217 8.1 Goroutines 217 8.2 Example: Concurrent Clock Server 219 8.3 Example: Concu rent Echo Server 222 8.4 Channels 225 8.5 Looping in Parallel 234 8.6 Example: Concurrent Web Crawler 239 8.7 Multiplexing with select 244 8.8 Example: Concurrent Directory Traversal 247 8.9 Cancellation 251 8.10 Example: Chat Server 253
• Chapter 9: Concurrency with Shared Variables 257 9.1 Race Conditions 257 9.2 Mutual Exclusion: sync.Mutex 262 9.3 Read/Write Mutexes: sync.RWMutex 266 9.4 Memory Synchronization 267 9.5 Lazy Initialization: sync.Once 268 9.6 The Race Detector 271 9.7 Example: Concurrent Non-Blocking Cache 272 9.8 Goroutines and Threads 280
• Chapter 10: Packages and the Go Tool 283 10.1 Introduction 283 10.2 Import Paths 284 10.3 The Package Declaration 285 10.4 Import Declarations 285 10.5 Blank Imports 286 10.6 Packages and Naming 289 10.7 The Go Tool 290
• Chapter 11: Testing 301 11.1 The go test Tool 302 11.2 Test Functions 302 11.3 Coverage 318 11.4 Benchmark Functions 321 11.5 Profiling 323 11.6 Example Functions 326
• Chapter 12: Reflection 329 12.1 Why Reflection? 329 12.2 reflect.Type and reflect.Value 330 12.3 Display, a Recursive Value Printer 333 12.4 Example: Encoding S-Expressions 338 12.5 Setting Variables with reflect.Value 341 12.6 Example: Decoding S-Expressions 344 12.7 Accessing Struct Field Tags 348 12.8 Displaying the Methods of a Type 351 12.9 A Word of Caution 352
• Chapter 13: Low-Level Programming 353 13.1 unsafe.Sizeof, Alignof, and Offsetof 354 13.2 unsafe.Pointer 356 13.3 Example: Deep Equivalence 358 13.4 Calling C Code with cgo 361 13.5 Another Word of Caution 366
• Index 367.
• (source: Nielsen Book Data)

The Go Programming Language is the authoritative resource for any programmer who wants to learn Go. It shows how to write clear and idiomatic Go to solve real-world problems. The book does not assume prior knowledge of Go nor experience with any specific language, so you'll find it accessible whether you're most comfortable with JavaScript, Ruby, Python, Java, or C++. The first chapter is a tutorial on the basic concepts of Go, introduced through programs for file I/O and text processing, simple graphics, and web clients and servers. Early chapters cover the structural elements of Go programs: syntax, control flow, data types, and the organization of a program into packages, files, and functions. The examples illustrate many packages from the standard library and show how to create new ones of your own. Later chapters explain the package mechanism in more detail, and how to build, test, and maintain projects using the go tool. The chapters on methods and interfaces introduce Go's unconventional approach to object-oriented programming, in which methods can be declared on any type and interfaces are implicitly satisfied. They explain the key principles of encapsulation, composition, and substitutability using realistic examples. Two chapters on concurrency present in-depth approaches to this increasingly important topic. The first, which covers the basic mechanisms of goroutines and channels, illustrates the style known as communicating sequential processes for which Go is renowned. The second covers more traditional aspects of concurrency with shared variables. These chapters provide a solid foundation for programmers encountering concurrency for the first time. The final two chapters explore lower-level features of Go. One covers the art of metaprogramming using reflection. The other shows how to use the unsafe package to step outside the type system for special situations, and how to use the cgo tool to create Go bindings for C libraries. The book features hundreds of interesting and practical examples of well-written Go code that cover the whole language, its most important packages, and a wide range of applications. Each chapter has exercises to test your understanding and explore extensions and alternatives. Source code is freely available for download from http://gopl.io/ and may be conveniently fetched, built, and installed using the go get command.
(source: Nielsen Book Data)

• 1. PRODUCTION MODELS: MAXIMIZING PROFITS. A two-variable linear program. The two-variable linear program in AMPL. A linear programming model. The linear programming model in AMPL. Adding lower bounds to the model. Adding resource constraints to the model. AMPL interfaces.
• 2. DIET AND OTHER INPUT MODELS: MINIMIZING COSTS. A linear program for the diet problem. An AMPL model for the diet problem. Using the AMPL diet model. Generalizations to blending, economics, and scheduling.
• 3. TRANSPORTATION AND ASSIGNMENT MODELS. A linear program for the transportation problem. An AMPL model for the transportation problem. Other interpretations of the transportation model.
• 4. BUILDING LARGER MODELS. A multicommodity transportation model. A multiperiod production model. A model of production and transportation.
• 5. SIMPLE SETS AND INDEXING. Unordered sets. Sets of numbers. Set operations. Set membership operations and functions. Indexing expressions. Ordered sets.
• 6. COMPOUND SETS AND INDEXING. Sets of ordered pairs. Subsets and slices of ordered pairs. Sets of longer tuples. Operations on sets of tuples. Indexed collections of sets.
• 7. PARAMETERS AND EXPRESSIONS. Parameter declarations. Arithmetic expressions. Logical and conditional expressions. Restrictions on parameters. Computed parameters. Randomly generated parameters. Logical parameters. Symbolic parameters.
• 8. LINEAR PROGRAMS: VARIABLES, OBJECTIVES AND CONSTRAINTS. Variables. Linear expressions. Objectives. Constraints.
• 9. SPECIFYING DATA. Formatted data: the data command. Data in lists. Data in tables. Other features of data statements. Reading unformatted data: the read command.
• 10. DATABASE ACCESS. General principles of data correspondence. Examples of table-handling statements. Reading data from relational tables. Writing data to relational tables. Reading and writing the same table. Indexed collections of tables and columns. Standard and built-in table handlers.
• 11. MODELING COMMANDS. General principles of commands and options. Setting up and solving models and data. Modifying data. Modifying models.
• 12. DISPLAY COMMANDS. Browsing through results: the display command. Formatting options for display. Numeric options for display. Other output commands: print and printf. Related solution values. Other display features for models and instances. General facilities for manipulating output.
• 13. COMMAND SCRIPTS. Running scripts: include and commands. Iterating over a set: the for statement. Iterating subject to a condition: the repeat statement. Testing a condition: the if-then-else statement. Terminating a loop: break and continue. Stepping through a script. Manipulating character strings.
• 14. INTERACTIONS WITH SOLVERS. Presolve. Retrieving results from solvers. Exchanging information with solvers via suffixes. Alternating between models. Named problems.
• 15. NETWORK LINEAR PROGRAMS. Minimum-cost transshipment models. Other network models. Declaring network models by node and arc. Rules for node and arc declarations. Solving network linear programs.
• 16. COLUMNWISE FORMULATIONS. An input-output model. A scheduling model. Rules for columnwise formulations.
• 17. PIECEWISE-LINEAR PROGRAMS. Cost terms. Common two-piece and three-piece terms. Other piecewise-linear functions. Guidelines for piecewise-linear optimization.
• 18. NONLINEAR PROGRAMS. Sources of nonlinearity. Nonlinear variables. Nonlinear expressions. Pitfalls of nonlinear programming.
• 19. COMPLEMENTARITY PROBLEMS. Sources of complementarity. Forms of complementarity constraints. Working with complementarity constraints.
• 20. INTEGER LINEAR PROGRAMS. Integer variables. Zero-one variables and logical conditions. Practical considerations in integer programming. APPENDIX A: AMPL REFERENCE MANUAL. INDEX.
• (source: Nielsen Book Data)

AMPL is a language for large-scale optimization and mathematical programming problems in production, distribution, blending, scheduling, and many other applications. Combining familiar algebraic notation and a powerful interactive command environment, AMPL makes it easy to create models, use a wide variety of solvers, and examine solutions. Though flexible and convenient for rapid prototyping and development of models, AMPL also offers the speed and generality needed for repeated large-scale production runs. This book, written by the creators of AMPL, is a complete guide for modelers at all levels of experience. It begins with a tutorial on widely used linear programming models, and presents all of AMPL's features for linear programming with extensive examples. Additional chapters cover network, nonlinear, piecewise-linear, and integer programming; database and spreadsheet interactions; and command scripts. Most chapters include exercises. Download free versions of AMPL and several solvers from www.ampl.com for experimentation, evaluation, and education. The Web site also lists vendors of the commercial version of AMPL and numerous solvers.
(source: Nielsen Book Data)

• Preface.
• 1. An AWK Tutorial. Getting Started. Simple Output. Fancier Output. Selection. Computing with AWK. Control-Flow Statements. Arrays. A Handful of Useful "One-liners." What Next?
• 2. The AWK Lanaguage. Patterns. Actions. User-Defined Functions. Output. Input. Interaction with Other Programs. Summary.
• 3. Data Processing. Data Transformation and Reduction. Data Validation. Bundle and Unbundle. Multiline Records. Summary.
• 4. Reports and Databases. Generating Reports. Packaged Queries. A Relational Database System. Summary.
• 5. Processing Words. Random Text Generation. Interactive Text-Manipulation. Text Processing. Summary.
• 6. Little Languages. An Assembler and Interpreter. A Language for Drawing Graphs. A Sort Generator. A Reverse-Polish Calculator. An Infix Calculator. Recursive-Descent Parsing. Summary.
• 7. Experiments with Algorithms. Sorting. Profiling. Topological Sorting. Make: A File Updating Program. Summary.
• 8. Epilog. AWK as a Language. Performance. Conclusion. Appendix A: AWK Summary. Appendix B: Answers to Selected Exercises. Index.
• (source: Nielsen Book Data)

Originally developed by Alfred Aho, Brian Kernighan, and Peter Weinberger in 1977, AWK is a pattern-matching language for writing short programs to perform common data-manipulation tasks. In 1985, a new version of the language was developed, incorporating additional features such as multiple input files, dynamic regular expressions, and user-defined functions. This new version is available for both Unix and MS-DOS. This is the first book on AWK. It begins with a tutorial that shows how easy AWK is to use. The tutorial is followed by a comprehensive manual for the new version of AWK. Subsequent chapters illustrate the language by a range of useful applications, such as: *Retrieving, transforming, reducing, and validating data *Managing small, personal databases *Text processing *Little languages *Experimenting with algorithms The examples illustrates the book's three themes: showing how to use AWK well, demonstrating AWK's versatility, and explaining how common computing operations are done. In addition, the book contains two appendixes: summary of the language, and answers to selected exercises. 020107981XB04062001.
(source: Nielsen Book Data)

No abstract available