Introduction to Programming Languages Programming in

C C Scheme Prolog C and SOA 5th Edition Yinong Chen

download pdf

https://ebookfinal.com/download/introduction-to-programming-languages-
programming-in-c-c-scheme-prolog-c-and-soa-5th-edition-yinong-chen/

Visit ebookfinal.com today to download the complete set of

ebook or textbook!
Here are some recommended products that we believe you will be
interested in. You can click the link to download.

Programming Languages Principles and Practices 3rd Edition

Kenneth C. Louden

https://ebookfinal.com/download/programming-languages-principles-and-
practices-3rd-edition-kenneth-c-louden/

Medicine in Rural China C. C. Chen

https://ebookfinal.com/download/medicine-in-rural-china-c-c-chen/

C Programming in Linux 2nd Edition David Haskins

https://ebookfinal.com/download/c-programming-in-linux-2nd-edition-
david-haskins/

C Programming Program Design Including Data Structures 5th

Edition D. S. Malik

https://ebookfinal.com/download/c-programming-program-design-
including-data-structures-5th-edition-d-s-malik/
A Complete Guide to Programming in C 1st Edition Ulla
Kirch-Prinz

https://ebookfinal.com/download/a-complete-guide-to-programming-
in-c-1st-edition-ulla-kirch-prinz/

Mastering C Database Programming 1st Edition Jason Price

https://ebookfinal.com/download/mastering-c-database-programming-1st-
edition-jason-price/

Programming with ANSI C 2nd Edition Bhushan Trivedi

https://ebookfinal.com/download/programming-with-ansi-c-2nd-edition-
bhushan-trivedi/

Functional Programming in C Classic Programming Techniques

for Modern Projects Wrox Programmer to Programmer 1st
Edition Oliver Sturm
https://ebookfinal.com/download/functional-programming-in-c-classic-
programming-techniques-for-modern-projects-wrox-programmer-to-
programmer-1st-edition-oliver-sturm/

Programming in Prolog Fifth Edition W. F. Clocksin

https://ebookfinal.com/download/programming-in-prolog-fifth-edition-w-
f-clocksin/
Introduction to Programming Languages Programming
in C C Scheme Prolog C and SOA 5th Edition Yinong
Chen Digital Instant Download
Author(s): Yinong Chen
ISBN(s): 9781524916992, 1524916994
Edition: 5
File Details: PDF, 27.24 MB
Year: 2016
Language: english
Introduction to Programming Languages

Programming in C, C++, Scheme, Prolog, C#, and SOA

Fifth Edition

Yinong Chen
Arizona State University

Kendall Hunt
publishing company
 Cover image courtesy of© Shutter stock, Inc. Used under license.

Kendall Hunt
publis�ing company

www .kendallhunt.com
Send all inquiries to:
4050 West mark Drive
Dubuque, IA 52004-1840

Copyright© 2003, 2006, 2012, 2015 by Yinong Chen and Wei-Tek Tsai
2017 by Kendall Hunt Publishing Company

ISBN 978-1-5249-1699-2

All rights reserved. No part of this publication may be reproduced,

stored in a retrieval system, or transmitted, in any form or by any means,
electronic, mechanical, photocopying, recording, or otherwise,
without the prior written permission of the copyright owner.

Published in the United States of America

 Table of Contents

Preface .............................................................................................................................................. x1
Chapter 1 Basic Principles of Programming Languages.................................................................... 1
1.1 Introduction............................................................................................................................ 2
1.1.1 Programming concepts and paradigms 2
1.1.2 Program performance and features of programming languages 3
1.1.3 Development of programming languages 4
1.2 Structures of programming languages ................................................................................... 8
1.2.1 Lexical structure 8
1.2.2 Syntactic structure 9
1.2.3 Contextual structure 9
1.2.4 Semantic structure 9
1.2.5 BNF notation 9
1.2.6 Syntax graph 11
1.3 Data types and type checking .............................................................................................. 12
1.3.1 Data types and type equivalence 13
1.3.2 Type checking and type conversion 13
1.3.3 Orthogonality 14
1.4 Program processing and preprocessing ................................................................................ 16
1.4.1 Interpretation and compilation 16
1.4.2 Preprocessing: macro and inlining 18
* 1.5 Program development .......................................................................................................... 23
1.5.1 Program development process 23
1.5.2 Program testing 24
1.5.3 Correctness proof 27
1.6 Summary .............................................................................................................................. 29
1.7 Homework and programming exercises .............................................................................. 31
Chapter 2 The Imperative Programming Languages, C/C++ ......................................................... 39
2.1 Getting started with CIC++.................................................................................................. 40
2.1.1 Write your first CIC++ program 40
2.1.2 Basic input and output functions 41
2.1.3 Formatted input and output functions 42
2.2 Control structures in CIC++ ................................................................................................. 44
2.2.1 Operators and the order of evaluation 44

111
 2.2.2 Basic selection structures (if-then-else and the conditional expression) 45
2.2.3 Multiple selection structure (switch) 46
2.2.4 Iteration structures (while, do-while, and for) 49
2.3 Data and basic data types in CIC++ ..................................................................................... 51
2.3.1 Declaration of variables and functions 51
2.3.2 Scope rule 52
2.3.3 Basic data types 53
2.4 Complex types ..................................................................................................................... 56
2.4.1 Array 56
2.4.2 Pointer 58
2.4.3 String 60
2.4.4 Constants 69
2.4.5 Enumeration type 70
2.5 Compound data types........................................................................................................... 73
2.5.1 Structure types and paddings 73
2.5.2 Union 75
2.5.3 Array of structures using static memory allocation 77
2.5.4 Linked list using dynamic memory allocation 80
2.5.5 Doubly linked list 84
2.5.6 Stack 86
2.6 Standard input and output, files, and file operations ........................................................... 89
2.6.1 Basic concepts of files and file operations 89
2.6.2 File operations in C 90
2.6.3 Flush operation in C 95
2.7 Functions and parameter passing ......................................................................................... 97
2.8 Recursive structures and applications ................................................................................ 101
2.8.1 Loop structures versus recursive structures 101
2.8.2 The fantastic-four abstract approach of writing recursive functions 102
2.8.3 Hanoi Towers 103
2.8.4 Insertion sorting 106
2.8.5 Merge sort algorithm 108
2.8.6 Quick sort algorithm 110
2.8.7 Tree operations 110
2.8.8 Gray code generation 114
2.9 Modular design .................................................................................................................. 116
2.10 Case Study: Putting All Together ...................................................................................... 118

iv
 2.11 Summary ............................................................................................................................ 125
2.12 Homework, programming exercises, and projects ............................................................. 127
Chapter 3 The Object-Oriented Programming Language, C++ ................................................... 147
3.1 A long program example: a queue and a priority queue written in C++ ........................... 148
3.2 Class definition and composition ....................................................................................... 151
3.2.1 Class definition 151
3.2.2 Scope resolution operator 152
3.2.3 Objects from a class 153
3.2.4 Definition of constructor and destructor 153
3.3 Memory management and garbage collection ................................................................... 154
3.3.1 Static: global variables and static local variables 155
3.3.2 Runtime stack for local variables 156
3.3.3 Heap: dynamic memory allocation 159
3.3.4 Scope and garbage collection 159
3.3.5 Memory leak detection 164
3.4 Inheritance ......................................................................................................................... 171
3.4.1 Class containment and inheritance 171
3.4.2 Inheritance and virtual function 174
3.4.3 Inheritance and hierarchy 177
3.4.4 Inheritance and polymorphism 191
3.4.5 Polymorphism and type checking 193
3.4.6 Polymorphism and late binding 194
3.4.7 Type Casting in C++ 194
3.5 Function and Operator Overloading .................................................................................. 196
3.5.1 Function overloading 196
3.5.2 Operator overloading 197
3.6 File Operations in C++ ...................................................................................................... 203
3.6.1 File objects and operations in C++ 203
3.6.2 Ignore operation in C++ 208
3.7 Exception Handling ........................................................................................................... 209
3.8 Case Study: Putting All Together ...................................................................................... 213
3.8.1 Organization of the program 213
3.8.2 Header files 214
3.8.3 Source fi1es 216
*3.9 Parallel computing and multithreading .............................................................................. 224
3.9. l Basic concepts in parallel computing and multithreading 224

V
 3.9.2 Generic features in C++ 224
3.9.3 Case Study: Implementing multithreading in C++ 226
3.10 Summary ............................................................................................................................ 230
3.11 Homework, programming exercises, and projects ............................................................. 231
Chapter 4 The Functional Programming Language, Scheme ....................................................... 241
4.1 From imperative programming to functional programming .............................................. 242
4.2 Prefix notation.................................................................................................................... 244
4.3 Basic Scheme terminology ................................................................................................ 246
4.4 Basic Scheme data types and functions ............................................................................. 249
4.4.1 Number types 249
4.4.2 Boolean 250
4.4.3 Character 251
4.4.4 String 252
4.4.5 Symbol 252
4.4.6 Pair 252
4.4.7 List 254
4.4.8 Application of Quotes 255
4.4.9 Definition of procedure and procedure type 256
4.4.10 Input/output and nonfunctional features 258
*4.5 Lambda-calculus ................................................................................................................ 260
4.5.1 Lambda-expressions 260
4.5.2 A-procedure and parameter scope 261
4.5.3 Reduction rules 261
4.6 Define your Scheme procedures and macros ..................................................................... 262
4.6.1 Unnamed procedures 263
4.6.2 Named procedures 263
4.6.3 Scopes of variables and procedures 263
4.6.4 Let-form and unnamed procedures 265
4.6.5 Macros 266
4.6.6 Compare and contrast imperative and functional programming paradigms 268
4.7 Recursive procedures ......................................................................................................... 270
4.8 Define recursive procedures on data types ........................................................................ 272
4.8.1 Number manipulations 272
4.8.2 Character and string manipulations 276
4.8.3 List manipulations 277
4.9 Higher-order functions....................................................................................................... 279

Vl
 4.9.1 Mapping 280
4.9.2 Reduction 283
4.9.3 Filtering 284
4.9.4 Application of filtering in query languages 286
4.10 Summary ............................................................................................................................ 287
4.11 Homework, programming exercises, and projects ............................................................. 289
Chapter 5 The Logic Programming Language, Prolog .................................................................. 299
5.1 Basic concepts of logic programming in Prolog ................................................................ 299
5.1.1 Prolog basics 300
5.1.2 Structures of Prolog facts, rules, and goals 302
5.2 The Prolog execution model .............................................................................................. 303
5.2.1 Unification of a goal 303
5.2.2 Example of searching through a database 305
5.3 Arithmetic operations and database queries ...................................................................... 306
5.3.1 Arithmetic operations and built-in functions 306
5.3.2 Combining database queries with arithmetic operations 308
5.4 Prolog functions and recursive rules .................................................................................. 310
5.4.l Parameter passing in Prolog 310
5.4.2 Factorial example 311
5.4.3 Fibonacci numbers example 311
5.4.4 Hanoi Towers 312
5.4.5 Graph model and processing 313
5.4.6 Map representation and coloring 314
5.5 List and list manipulation .................................................................................................. 316
5.5.1 Definition of pairs and lists 316
5.5.2 Pair simplification rules 317
5.5.3 List membership and operations 318
5.5.4 Knapsack problem 321
5.5.5 Quick sort 322
5.6 Flow control structures ...................................................................................................... 323
5.6.l Cut 324
5.6.2 Fail 327
5.6.3 Repeat 328
*5.7 Prolog application in semantic Web .................................................................................. 330
5.8 Summary ............................................................................................................................ 331
5.9 Homework, programming exercises, and projects ............................................................. 333

vii
Chapter 6 Fundamentals of the Service-Oriented Computing Paradigm .................................... 341
6.1 Introduction to C# .............................................................................................................. 341
6.1.1 Getting started with C# and Visual Studio 341
6.1.2 Comparison between C++ and C# 343
6.1.3 N amespaces and the using directives 343
6.1.4 The queue example in C# 345
6.1.5 Class and object in C# 346
6.1.6 Parameters: passing by reference with re f&out 349
6.1.7 Base classes and constructors 350
6.1.8 Constructor, destructor, and garbage collection 350
6.1.9 Pointers in C# 351
6.1.10 C# unified type system 352
6.1.11 Further topics in C# 353
6.2 Service-oriented computing paradigm ............................................................................... 353
6.2.l Basic concepts and terminologies 353
6.2.2 Web services development 355
6.2.3 Service-oriented system engineering 356
6.2.4 Web services and enabling technologies 357
6.3 *Service providers: programming web services in C# ...................................................... 358
6.3.l Creating a web service project 359
6.3.2 Writing the service class 360
6.3.3 Launch and access your web services 361
6.3.4 Automatically generating a WSDL file 363
6.4 Publishing and searching web services using UDDI ......................................................... 365
6.4.1 UDDI file 365
6.4.2 ebXML 367
6.4.3 Ad hoc registry lists 368
6.5 Building applications using ASP.Net ................................................................................ 368
6.5.1 Creating your own web browser 368
6.5.2 Creating a Windows application project in ASP.Net 369
6.5.3 Developing a website application to consume web services 374
6.6 Silverlight and Phone Applications Development ............................................................. 377
6.6.1 Silverlight Applications 377
6.6.2 Developing Windows Phone Apps Using Silverlight 380
6.7 Cloud computing and big data processing ......................................................................... 389
6.7.1 Cloud computing 389
6.7.2 Big data 392

Vlll
 6.8 Summary ............................................................................................................................ 394
6.9 Homework, programming exercises, and projects ............................................................. 395
Appendix A Basic Computer Architectures and Assembly Language Programming .................... 401
A. l Basic computer components and computer architectures .................................................. 401
A.2 Computer architectures and assembly programming ......................................................... 402
A.3 Subroutines and local variables on stack ........................................................................... 407
Appendix B Programming Environments Supporting C, C++, Scheme, and Prolog ..................... 409
B. l Introduction to operating systems ...................................................................................... 409
B.2 Introduction to Unix and CIC++ programming environments........................................... 412
B.2.1 Unix and Linux operating systems 412
B.2.2 Unix shell and commands 413
B.2.3 Unix system calls 417
B.2.4 Getting started with GNU GCC under the Unix operating system 419
B.2.5 Debugging your CIC++ programs in GNC GCC 421
B.2.6 Frequently used GCC compiler options 424
B.2.7 CIC++ operators 424
B.2.8 Download programming development environments and tutorials 426
BJ Getting started with Visual Studio programming environment ......................................... 426
B.3.1 Creating a CIC++ project in Visual Studio 427
B.3.2 Debugging your CIC++ programs in Visual Studio 429
B.4 Programming environments supporting Scheme programming ........................................ 430
B.4.1 Getting started with DrRacket 430
B.4.2 Download DrRacket programming environment 431
B.5 Programming environments supporting Prolog programming .......................................... 432
B.5.1 Getting started with the GNU Prolog environment 432
B.5.2 Getting started with Prolog programming 433
B.5.3 Download Prolog programming development tools 435
Appendix C ASCII Character Table ................................................................................................... 437
Bibliography ........................................................................................................................................... 439
Index ........................................................................................................................................... 443

ix
Preface

We all have witnessed the rapid development of computer science and its applications in many domains,
particularly in web-based computing (Web 2.0), cloud computing, big data processing, and mobile
computing. As a science discipline, the fundamentals of computer science, including programming
language principles and the classic programming languages, are stable and do not change with the
technological innovations. C, C++, Scheme/LISP, and Prolog belong to the classic programming languages
that were developed several decades ago and are still the most significant programming languages today,
both in theory and in practice. However, the technologies that surround these languages have been changed
and improved, which give these languages new perspectives and new applications. For example, C++ is
extended to generic classes and writing multithread programs. Functional programming principles are
widely used in database query languages and the new object- and service-oriented programming languages
such as C#.
This text is intended for computer science and computer engineering students in their sophomore year of
study. It is assumed that students have completed a basic computer science course and have learned a high­
level programming language like C, C++, or Java.
Most of the content presented in the text has been used in the "Introduction to Programming Languages"
course taught by the author in the School of Computer Science at the University of the Witwatersrand at
Johannesburg, and in the Computer Science and Engineering programs at Arizona State University. This
text is different from the existing texts on programming languages that either focus on teaching
programming paradigms, principles, and the language mechanisms, or focus on language constructs and
programming skills. This text takes a balanced approach on both sides. It teaches four programming
languages representing four major programming paradigms. Programming paradigms, principles, and
language mechanisms are used as the vehicle to facilitate learning of the four programming languages in a
coherent way. The goals of such a programming course are to make sure that computer science students are
exposed to different programming paradigms and language mechanisms, and obtain sufficient
programming skills and experience in different programming languages, so that they can quickly use these
or similar languages in other courses.
Although there are many different programming paradigms, imperative, object-oriented, functional, and
logic programming paradigms are the four major paradigms widely taught in computer science and
computer engineering departments around the world. The four languages we will study in the text are the
imperative C, object-oriented C++, functional Scheme, and logic Prolog. At the end of the course, students
should understand
• the language structures at different layers (lexical, syntactic, contextual, and semantic), the control
structures and the execution models of imperative, object-oriented, functional, and logic
programming languages;
• program processing (compilation versus interpretation) and preprocessing (macros and inlining);
• different aspects of a variable, including its type, scope, name, address, memory location, and value.
More specific features of programming languages and programming issues are explored in cooperation with
the four selected languages. Students are expected to have understood and be able to
• write C programs with complex data types, including pointers, arrays, and generic structures, as
well as programs with static and dynamic memory allocation;

xi
 • apply the object-oriented features such as inheritance and class hierarchy, polymorphism and
typing, overloading, early versus late binding, as well as the constructors, the destructor and the
management of static memory, stack, and heap in C++;
• apply the functional programming style of parameter passing and write Scheme programs requiring
multiple functions;
• apply the logic programming style of parameter passing, write Prolog facts, rules, and goals, and
use multiple rules to solve problems;
• be able to write programs requiring multiple subprograms/procedures to solve large programming
problems;
• be able to write recursive subprograms/procedures in imperative, object-oriented, functional, and
logic programming languages.
The text has been revised and improved throughout in each of the new editions. In the second edition, the
major change made was the inclusion of programming in Service-Oriented Architecture (SOA). Since the
publication of the first edition in 2003, SOA programming has emerged as a new programming paradigm,
which has demonstrated its strength to become a dominating programming paradigm. All major computing
companies, including HP, IBM, Intel, Microsoft, Oracle, SAP, and Sun Microsystems, have moved into
this new paradigm and are using the new paradigm to produce software and even hardware systems. The
need for skill in SOA programming increases as the deployment of SOA applications increases. This new
SOA paradigm is not only important in the practice of programming, but it also contributes to the concepts
and principles of programming theory. In fact, SOA programming applies a higher level of abstraction,
which requires fewer technical details for building large software applications. We, the authors of this book,
are leading researchers and educators in SOA programming. The inclusion of the new chapter on C# and
SOA programming makes the text unique, which allows teaching of the most contemporary programming
concepts and practice. The new chapter also gives professors a new component to choose from, which adds
flexibility for them to select different contents for different courses. As SOA has developed significantly in
the past 10 years, this chapter is also updated in the fourth edition to include an introduction to Silverlight
animation, phone application development, cloud computing, and big data processing.
In the third edition, we completely rewrite Chapter 5. We also discuss the modem applications of Prolog in
the semantic web (Web 3.0) and its relationship with the currently used web semantic languages RDF
(Resource Description Framework) and OWL (Web Ontology Language). Semantic web is considered the
next generation of web that allows the web to be browsed and explored by both humans and computer
programs. In the third edition revised print, this chapter is further expanded with the latest computing
technologies in cloud computing and big data processing.
Since the publication of the second edition in 2006, the programming environment for Chapter 4, on
Scheme, has been changed from DrScheme to DrRacket. The change does not affect the examples in the
text. They all work in the new DrRacket environment, except certain notational issues. We have updated
Chapter 4 to match the changes made in DrRacket.
As parallel computing and multithreading are becoming more and more important in software development,
the third edition adds a new section on parallel computing and multithreading in C++, in Chapter 3. A
MapReduce example is used as a case study for explaining multithreading in C++. The parallel computing
concept is also emphasized in Chapter 4, where the eager evaluation and higher functions Map and Reduce
are linked to parallel computing.
In the fourth edition, we added a number of new sections and many examples throughout Chapters 1, 2, 3,
4, 5, and 6 to explain the more difficulty concepts. In Chapter 1, macro expansion and execution are
explained in more detail and the order of executions are discussed and showed on different programming
environments. More complex examples of syntax graphs are given in Section 1.2. In Chapter 2, structure
padding is discussed in Section 2.5. The file operations in Section 2.6 are extended. More recursive

xii
 examples are given in Section 2.7. A case study that puts a11 together is given in a new section at the end of
the chapter. In Chapter 3, a new subsection on memory leak detection is added in Section 3.3 on memory
management. Section 3.4 on inheritance is extended with a new subsection on type casting. A new section
on C++ file operations is added as Section 3.5. In Chapter 4, the application of filtering in query languages
is added in Section 4.9. In the new editions, Chapter 5 is further extended to include web application and
phone application development in C#. It also extends the discussions to cloud computing and big data
processing.
In the fifth edition, changes and revisions are made throughout the book. In Chapter 2, more data structures
are discussed, including doubly linked list, graphs, and trees. Chapter 3, Object-Oriented Programming
Language C++, is significantly extended to include inheritance, type casting, function overloading and
operator overloading, and C++ file operations. A new section 3.8 Case Study is included to put together all
the concepts and programming mechanisms learned in this chapter. In Appendix B, tutorials on using GNU
GCC environment and Visual Studio environment to edit and debug programs are added.
This edition of the text is organized into six chapters and three appendices. Chapter 1 discusses the
programming paradigms, principles, and common aspects of programming languages. Chapter 2 uses C as
the example of the imperative programming paradigm to teach how to write imperative programs. It is
assumed that students have a basic understanding of a high-level programming language such as C, C++,
or Java. Chapter 3 extends the discussion and programming from C to C++. The chapter focuses on the
main features of object-oriented programming paradigms, including class composition, dynamic memory
management and garbage collection, inheritance, dynamic memory allocation and deallocation, late
binding, polymorphism, and class hierarchy. Chapters 4 and 5 take a major paradigm shift to teach
functional and logic programming, respectively. Students are not required to have any knowledge of
functional and logic programming to learn from these two chapters. Chapter 6 gives a brief introduction to
C# and service-oriented computing paradigm. A full discussion of the service-oriented computing paradigm
is given in another book by the authors: Service-Oriented Computing and Web Software Integration.
Assignments, programming exercises, and projects are given at the end of each chapter. The sections with
an asterisk(*) are optional and can be skipped if time does not permit covering all the material. Chapters 4
and 5 are self-contained and can be taught independently, or in a different order.
The three appendices provide supplementary materials to the main text. In Appendix A, the basic computer
organization and assembly language programming are introduced. If students do not have a basic computer
science background, the material should be covered in the class. Appendix B starts with basic Unix
commands. If the class uses a Unix-based laboratory environment, students can read the appendix to get
started with Unix. Then the appendix introduces the major programming language environments that can
be used to support teaching the four programming languages, including GNU GCC/G++ for C and C++,
Visual Studio for C and C++, DrRacket for Scheme, and GNU Prolog. Appendix C gives the ASCII code
table that is referred to in various parts of the text.
The text consists of six chapters, which can be considered reconfigurable components of a course. A half­
semester course(25-30 lecture hours) can teach from two to three chapters, and a full semester course can
teach four to five chapters of choice from the text. Chapter 3(C++) is closely related to Chapter 2. If Chapter
3 is selected as a component of a course, Chapter 2, or a part of Chapter 2, should be selected as well. Other
chapters are relatively independent of each other and can be selected freely to compose a course.
For a half-semester course, sensible course compositions could include: (Chapters 1, 2, 3);(Chapters 2, 3);
(Chapters 1, 2, 6); (Chapters 2, 3, 6); (Chapters 1, 4, 5); and (Chapters 4, 5). For a full semester course,
sensible course compositions could include: (chapters 1, 2, 3, 4, 5); (chapters 1, 2, 3, 4, 6); (Chapters 1, 2,
3, 5, 6); and(Chapters 2, 3, 4, 5, 6).
I wish to thank all those who have contributed to the materials and to the formation of this text. Particularly,
I would like to thank my colleagues Scott Hazelhurst and Conrad Mueller of the University of the

Xlll
Witwatersrand, and Richard Whitehouse of Arizona State University who shared their course materials
with me. Parts of these materials were used in teaching the programming languages course and in preparing
this text. Thomas Boyd, Joe DeLibero, Renee Turban, and Wei-Tek Tsai of Arizona State University
reviewed the drafts of the text and made constructive suggestions and useful comments. Other instructors
using this text have given me invaluable feedback and improvement suggestions, including Janaka
Balasooriya, Calvin Cheng, Mutsumi Nakamura, and Yalin Wang. My teaching assistants helped me in the
past few years to prepare the assignments and programming exercises; particularly, I would like to thank
Ruben Acuna, Raynette Brodie, Justin Convery, Gennaro De Luca, Garrett Gutierrez, and Kevin Liao.
The text was written and revised while I was carrying out a full university workload. I am thankful to my
family. I could not imagine that I would be able to complete the task without their generous support by
allowing me to use most of the weekends in the past year to write the text.
Although I have used the materials in teaching the programming languages courses at the University of the
Witwatersrand, Johannesburg and at Arizona State University for several years, the text was put together
in a short period of time. There are certainly many errors of different kinds. I would appreciate it if you
could send me any corrections, comments, or suggestions for improving the text. My email address
dedicated to dealing with the responses to the text is <[email protected]>. Instructors who use the text
can contact the author for instructional support, including lecture slides in PowerPoint format and the
solutions to the assignments.

Yinong Chen
December 2016

XIV
Chapter 1
Basic Principles of Programming Languages

Although there exist many programming languages, the differences among them are insignificant compared
to the differences among natural languages. In this chapter, we discuss the common aspects shared among
different programming languages. These aspects include:
• programming paradigms that define how computation is expressed;
• the main features of programming languages and their impact on the performance of programs
written in the languages;
• a brief review of the history and development of programming languages;
• the lexical, syntactic, and semantic structures of programming languages, data and data types,
program processing and preprocessing, and the life cycles of program development.
At the end of the chapter, you should have learned:
• what programming paradigms are;
• an overview of different programming languages and the background knowledge of these
languages;
• the structures of programming languages and how programming languages are defined at the
syntactic level;
• data types, strong versus weak checking;
• the relationship between language features and their performances;
• the processing and preprocessing of programming languages, compilation versus interpretation,
and different execution models of macros, procedures, and inline procedures;
• the steps used for program development: requirement, specification, design, implementation,
testing, and the correctness proof of programs.
The chapter is organized as follows. Section 1.1 introduces the programming paradigms, performance,
features, and the development of programming languages. Section 1.2 outlines the structures and design
issues of programming languages. Section 1.3 discusses the typing systems, including types of variables,
type equivalence, type conversion, and type checking during the compilation. Section 1.4 presents the
preprocessing and processing of programming languages, including macro processing, interpretation, and
compilation. Finally, Section 1.5 discusses the program development steps, including specification, testing,
and correctness proof.

1
 1.1 Introduction
1.1.1 Programming concepts and paradigms
Millions of programming languages have been invented, and several thousands of them are actually in use.
Compared to natural languages that developed and evolved independently, programming languages are far
more similar to each other. This is because
• different programming languages share the same mathematical foundation (e.g., Boolean algebra,
logic);
• they provide similar functionality (e.g., arithmetic, logic operations, and text processing);
• they are based on the same kind of hardware and instruction sets;
• they have common design goals: find languages that make it simple for humans to use and efficient
for hardware to execute;
• designers of programming languages share their design experiences.
Some programming languages, however, are more similar to each other, while other programming
languages are more different from each other. Based on their similarities or the paradigms, programming
languages can be divided into different classes. In programming language's definition, paradigm is a set
of basic principles, concepts, and methods for how a computation or algorithm is expressed. The major
paradigms we wilJ study in this text are imperative, object-oriented, functional, and logic paradigms.
The imperative, also called the procedural, programming paradigm expresses computation by fully
specified and fully controlled manipulation of named data in a stepwise fashion. In other words, data or
values are initially stored in variables (memory locations), taken out of (read from) memory, manipulated
in ALU (arithmetic logic unit), and then stored back in the same or different variables (memory locations).
Finally, the values of variables are sent to the 1/0 devices as output. The foundation of imperative languages
is the stored program concept-based computer hardware organization and architecture (von Neumann
machine). The stored program concept will be further explained in the next chapter. Typical imperative
programming languages include all assembly languages and earlier high-level languages like Fortran,
Algol, Ada, Pascal, and C.
The object-oriented programming paradigm is basically the same as the imperative paradigm, except that
related variables and operations on variables are organized into classes of objects. The access privileges of
variables and methods (operations) in objects can be defined to reduce (simplify) the interaction among
objects. Objects are considered the main building blocks of programs, which support language features like
inheritance, class hierarchy, and polymorphism. Typical object-oriented programming languages include
Smalltalk, C++, Java, and C#.
The functional, also called the applicative, programming paradigm expresses computation in terms of
mathematical functions. Since we express computation in mathematical functions in many of the
mathematics courses, functional programming is supposed to be easy to understand and simple to use.
However, since functional programming is very different from imperative or object-oriented programming,
and most programmers first get used to writing programs in imperative or object-oriented paradigms, it
becomes difficult to switch to functional programming. The main difference is that there is no concept of
memory locations in functional programming languages. Each function will take a number of values as
input (parameters) and produce a single return value (output of the function). The return value cannot be
stored for later use. It has to be used either as the final output or immediately as the parameter value of
another function. Functional programming is about defining functions and organizing the return values of
one or more functions as the parameters of another function. Functional programming languages are mainly

2
based on the lambda calculus that will be discussed in Chapter 4. Typical functional programming
languages include ML, SML, and Lisp/Scheme.
The logic, also called the declarative, programming paradigm expresses computation in terms of logic
predicates. A logic program is a set of facts, rules, and questions. The execution process of a logic program
is to compare a question to each fact and rule in the given fact and rulebase. If the question finds a match,
we receive a yes answer to the question. Otherwise, we receive a no answer to the question. Logic
programming is about finding facts, defining rules based on the facts, and writing questions to express the
problems we wish to solve. Prolog is the only significant logic programming language.
It is worthwhile to note that many languages belong to multiple paradigms. For example, we can say that
C++ is an object-oriented programming language. However, C++ includes almost every feature of C and
thus is an imperative programming language too. We can use C++ to write C programs. Java is more object­
oriented, but still includes many imperative features. For example, Java's primitive type variables do not
obtain memory from the language heap like other objects. Lisp contains many nonfunctional features.
Scheme can be considered a subset of Lisp with fewer nonfunctional features. Prolog's arithmetic
operations are based on the imperative paradigm.
Nonetheless, we will focus on the paradigm-related features of the languages when we study the sample
languages in the next four chapters. We will study the imperative features of C in Chapter 2, the object­
oriented features of C++ in Chapter 3, and the functional features of Scheme and logic features of Prolog
in Chapters 4 and 5, respectively.
1.1.2 Program performance and features of programming languages
A programming language's features include orthogonality or simplicity, available control structures, data
types and data structures, syntax design, support for abstraction, expressiveness, type equivalence, and
strong versus weak type checking, exception handling, and restricted aliasing. These features will be further
explained in the rest of the book. The performance of a program, including reliability, readability,
writability, reusability, and efficiency, is largely determined by the way the programmer writes the
algorithm and selects the data structures, as well as other implementation details. However, the features of
the programming language are vital in supporting and enforcing programmers in using proper language
mechanisms in implementing the algorithms and data structures. Table 1.1 shows the influence of a
language's features on the performance of a program written in that language.
Readability/
L� Efficiency Reusability Writability Reliability
Simplicity/Orthogonality ✓ ✓ ✓ ✓
Control structures ✓ ✓ ✓ ✓
Typing and data structures ✓ ✓ ✓ ✓
Syntax design ✓ ✓ ✓
Support for abstraction ✓ ✓ ✓
Expressiveness ✓ ✓
Strong checking ✓
Restricted aliasing ✓
Exception handling ✓

Table 1.1. Impact of language features on the performance of the programs.

3
The table indicates that simplicity, control structures, data types, and data structures have significant impact
on all aspects of performance. Syntax design and the support for abstraction are important for readability,
reusability, writability, and reliability. However, they do not have a significant impact on the efficiency of
the program. Expressiveness supports writability, but it may have a negative impact on the reliability of the
program. Strong type checking and restricted aliasing reduce the expressiveness of writing programs, but
are generally considered to produce more reliable programs. Exception handling prevents the program from
crashing due to unexpected circumstances and semantic errors in the program. All language features will
be discussed in this book.
1.1.3 Development of programming languages
The development of programming languages has been influenced by the development of hardware, the
development of compiler technology, and the user's need for writing high-performance programs in terms
of reliability, readability, writability, reusability, and efficiency. The hardware and compiler limitations
have forced early programming languages to be close to the machine language. Machine languages are the
native languages of computers and the first generation of programming languages used by humans to
communicate with the computer.
Machine languages consist of instructions of pure binary numbers that are difficult for humans to remember.
The next step in programming language development is the use of mnemonics that allows certain symbols
to be used to represent frequently used bit patterns. The machine language with sophisticated use of
mnemonics is called assembly language. An assembly language normally allows simple variables, branch
to a label address, different addressing modes, and macros that represent a number of instructions. An
assembler is used to translate an assembly language program into the machine language program. The
typical work that an assembler does is to translate mnemonic symbols into corresponding binary numbers,
substitute register numbers or memory locations for the variables, and calculate the destination address of
branch instructions according to the position of the labels in the program.
This text will focus on introducing high-level programming languages in imperative, object-oriented,
functional, and logic paradigms.
The first high-level programming language can be traced to Konrad Zuse's Plankalkiil programming system
in Germany in 1946. Zuse developed his Z-machines Zl, Z2, Z3, and Z4 in the late 1930s and early 1940s,
and the Plankalkill system was developed on the Z4 machine at ETH (Eidgenossisch Technische
Hochschule) in Ztirich, with which Zuse designed a chess-playing program.
The first high-level programming language that was actually used in an electronic computing device was
developed in 1949. The language was named Short Code. There was no compiler designed for the language,
and programs written in the language had to be hand-compiled into the machine code.
The invention of the compiler was credited to Grace Hopper, who designed the first widely known
compiler, called AO, in 1951.
The first primitive compiler, called Autocoder, was written by Alick E. Glennie in 1952. It translated
Autocode programs in symbolic statements into machine language for the Manchester Mark I computer.
Autocode could handle single letter identifiers and simple formulas.
The first widely used language, Fortran (FORmula TRANslating), was developed by the team headed by
John Backus at IBM between 1954 and 1957. Backus was also the system co-designer of the IBM 704 that
ran the first Fortran compiler. Backus was later involved in the development of the language Algol and the
Backus-Naur Form (BNF). BNF was a formal notation used to define the syntax of programming languages.
Fortran II came in 1958. Fortran III came at the end of 1958, but it was never released to the public. Further
versions of Fortran include ASA Fortran 66 (Fortran IV) in 1966, ANSI Fortran 77 (Fortran V) in 1978,

4
ISO Fortran 90 in 1991, and ISO Fortran 95 in 1997. Unlike assembly languages, the early versions of
Fortran allowed different types of variables (real, integer, array), supported procedure call, and included
simple control structures.
Programs written in programming languages before the emergence of structured programming concepts
were characterized as spaghetti programming or monolithic programming. Structured programming is a
technique for organizing programs in a hierarchy of modules. Each module had a single entry and a single
exit point. Control was passed downward through the structure without unconditional branches (e.g., goto
statements) to higher levels of the structure. Only three types of control structures were used: sequential,
conditional branch, and iteration.
Based on the experience of Fortran I, Algol 58 was announced in 1958. Two years later, Algol 60, the first
block-structured language, was introduced. The language was revised in 1963 and 1968. Edsger Dijkstra is
credited with the design of the first Algol 60 compiler. He is famous as the leader in introducing structured
programming and in abolishing the goto statement from programming.
Rooted in Algol, Pascal was developed by Niklaus Wirth between 1968 and 1970. He further developed
Modula as the successor of Pascal in 1977, then Modula-2 in 1980, and Oberon in 1988. Oberon language
had Pascal-like syntax, but it was strongly typed. It also offered type extension (inheritance) that supported
object-oriented programming. In Oberon-2, type-bound procedures (like methods in object-oriented
programming languages) were introduced.
The C programming language was invented and first implemented by Dennis Ritchie at DEC between 1969
and 1973, as a system implementation language for the nascent Unix operating system. It soon became one
of the dominant languages at the time and even today. The predecessors of C were the typeless language
BCPL (Basic Combined Programming Language) by Martin Richards in 1967 and then the B written by
Ken Thompson in 1969. C had a weak type checking structure to allow a higher level of programming
flexibility.
Object-oriented (00) programming concepts were first introduced and implemented in the Simula
language, which was designed by Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center
(NCC) between 1962 and 1967. The original version, Simula I, was designed as a language for discrete
event simulation. However, its revised version, Simula 67, was a full-scale general-purpose programming
language. Although Simula never became widely used, the language was highly influential on the modern
programming paradigms. It introduced important object-oriented concepts like classes and objects,
inheritance, and late binding.
One of the object-oriented successors of Simula was Smalltalk, designed at Xerox PARC, led by Alan Kay.
The versions developed included Smalltalk-72, Smalltalk-74, Smalltalk-76, and Smalltalk-80. Smalltalk
also inherited functional programming features from Lisp.
Based on Simula 67 and C, a language called "C with classes" was developed by Bjarne Stroustrup in 1980
at Bell Labs, and then revised and renamed as C++ in 1983. C++ was considered a better C (e.g., with
strong type checking), plus it supported data abstraction and object-oriented programming inherited from
Simula 67.
Java was written by Ja mes Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun
Microsystems. It was called Oak at first and then renamed Java when it was publicly announced in 1995.
The predecessors of Ja va were C++ and Smalltalk. Java removed most non-object-oriented features of C++
and was a simpler and better object-oriented programming language. Its two-level program processing
concept (i.e., compilation into an intermediate bytecode and then interpretation of the bytecode using a
small virtual machine) made it the dominant language for programming Internet applications. Java was still

5
not a pure object-oriented programming language. Its primitive types, integer, floating-point number,
Boolean, etc., were not classes, and their memory allocations were from the language stack rather than from
the language heap.
Microsoft's C# language was first announced in June 2000. The language was derived from C++ and Java.
It was implemented as a full object-oriented language without "primitive" types. C# also emphasizes
component-oriented programming, which is a refined version of object-oriented programming. The idea is
to be able to assemble software systems from prefabricated components.
Functional programming languages are relatively independent of the development process of imperative
and object-oriented programming languages. The first and most important functional programming
language, Lisp, short for LISt Processing, was developed by John McCarthy at MIT. Lisp was first released
in 1958. Then Lisp 1 appeared in 1959, Lisp 1.5 in 1962, and Lisp 2 in 1966. Lisp was developed
specifically for artificial intelligence applications and was based on the lambda calculus. It inherited its
algebraic syntax from Fortran and its symbol manipulation from the Information Processing Language, or
IPL. Several dialects of Lisp were designed later, for example, Scheme, InterLisp, FranzLisp, MacLisp, and
ZetaLisp.
As a Lisp dialect, Scheme was first developed by G. L. Steele and G. J. Sussman in 1975 at MIT. Several
important improvements were made in its later versions, including better scope rule, procedures (functions)
as the first-class objects, removal of loops, and sole reliance on recursive procedure calls to express loops.
Scheme was standardized by the IEEE in 1989.
Efforts began on developing a common dialect of Lisp, referred to as Common Lisp, in 1981. Common
Lisp was intended to be compatible with all existing versions of Lisp dialects and to create a huge
commercial product. However, the attempt to merge Scheme into Lisp failed, and Scheme remains an
independent Lisp dialect today. Common Lisp was standardized by the IEEE in 1992.
Other than Lisp, John Backus's FP language also belongs to the first functional programming languages.
FP was not based on the lambda calculus, but based on a few rules for combining function forms. Backus
felt that lambda calculus's expressiveness on computable functions was much broader than necessary. A
simplified rule set could do a better job.
At the same time that FP was developed in the United States, ML (Meta Language) appeared in the United
Kingdom. Like Lisp, ML was based on lambda calculus. However, Lisp was not typed (no variable needs
to be declared), while ML was strongly typed, although users did not have to declare variables that could
be inferentially determined by the compiler.
Miranda is a pure functional programming language developed by David Turner at the University of Kent
in 1985-1986. Miranda achieves referential transparency (side effect-free) by forbidding modification to
global variables. It combines the main features of SASL (St. Andrews Static Language) and KRC (Kent
Recursive Calculator) with strong typing similar to that of ML. SASL and KRC are two earlier functional
programming languages designed by Turner at the University of St Andrews in 1976 and at the University
of Kent in 1981, respectively.
There are many logic-based programming languages in existence. For example, ALF (Algebraic Logic
Functional language) is an integrated functional and logic language based on Hom clauses for logic
programming, and functions and equations for functional programming. Godel is a strongly typed logic
programming language. The type system is based on a many-sorted logic with parametric polymorphism.
RELFUN extends Horn logic by using higher-order syntax, first-class finite domains, and expressions of
nondeterministic, nonground functions, explicitly distinguished from structures.

6
Random documents with unrelated
content Scribd suggests to you:
and legs exposed to view. George Ives’ horse was blanketed in the
same way. It was a dappled gray, with a roached mane. He himself
was masked with a piece of a gray blanket, with the necessary
perforations. Zachary rode a blue-gray horse, belonging to Bob
Dempsey, (“All the country” was their stable)—blanketed like the
others—and his mask was a piece of a Jersey shirt.
Ives was on the off side of the driver, and Graves on the near side.
When Zachary walked up to Southmayde, he said, “Shut your eyes.”
This Southmayde respectfully declined, and the matter was not
pressed. Bob then took Leroy’s pistol and money, and threw them
down.
While Southmayde was being robbed, Billy, feeling tired, put down
his hands; upon which Ives instantly roared out, “Throw them up, you
——.” It is recorded that Billy obeyed with alacrity, though not with
cheerfulness.
Zachary walked up to Captain Moore and made a similar request.
The Captain declared with great solemnity, as he handed him his
purse, that it was “All he had in the world;” but it afterwards appeared
that a sum of $25 was not included in that estimate of his terrestial
assets; for he produced this money when the Road Agents had
disappeared.
Continuing his search, the relieving officer came to Billy, and
demanded his pistol, which was immediately handed over. Ives
asked, “Is it loaded,” and being answered in the negative, told Bob to
give it back to the owner. Tom Caldwell’s turn came next. He had
several small sums belonging to different parties, which he was
carrying for them to their friends, and also he had been
commissioned to make some purchases. As Bob approached him,
he exclaimed, “My God! what do you want with me; I have nothing.”
Graves told Zachary to let him alone, and inquired if there was
anything in the mail that they wanted. Tom said he did not think that
there was. Zachary stepped upon the brake bar and commenced an
examination, but found nothing. As Caldwell looked at Zachary while
he was thus occupied, Ives ordered him not to do that. Tom turned
and asked if he might look at him. Ives nodded.
 Having finished his search, Zachary picked up his gun, and
stepped back. Ives dismissed the “parade” with the laconic
command, “Get up and ‘skedaddle.’”
The horses were somewhat restive, but Tom held them fast, and
Southmayde, with a view to reconnoitering, said in a whisper, “Tom,
drive slow.” Ives called out, “Drive on.” Leroy turned round on his
seat, determined to find out who the robbers were, and looked
carefully at them for nearly a minute, which Ives at last observing, he
yelled out, “If you don’t turn round, and mind your business, I’ll shoot
the top of your head off.” The three robbers gathered together, and
remained watching, till the coach was out of sight.
Leroy Southmayde lost $400 in gold, and Captain Moore delivered
up $100 in Treasury Notes, belonging to another man.
The coach proceeded on its way to Bannack without further
molestation, and on its arrival there, Plummer was in waiting, and
asked, “Was the coach robbed to-day?” and being told that it had
been, as Southmayde jumped down, he took him by the arm, and
knowing him to be Sheriff, Southmayde was just about to tell him all
about it, when Judge G. G. Bissell gave Leroy a slight nudge, and
motioned for him to step back, which he did, and the Judge told him
to be very careful what he told that man, meaning Plummer;
Southmayde closed one eye as a private signal of comprehension,
and rejoined Plummer, who said, “I think I can tell you who it was
that robbed you.” Leroy asked, “Who?” Plummer replied, “George
Ives was one of them.” Southmayde said, “I know; and the others
were Whiskey Bill and Bob Zachary; and I’ll live to see them hanged
before three weeks.” Plummer at once walked off, and though Leroy
was in town for three days, he never saw him afterwards. The object
of Plummer’s accusation of Ives was to see whether Southmayde
really knew anything. Some time after, Judge Bissell—who had
overheard Southmayde telling Plummer who the thieves were—
remarked to him, “Leroy, your life is not worth a cent.”
On the second day after, as Tom was returning, he saw Graves at
the Cold Spring Ranch, and took him on one side asking him if he
had heard of the “little robbery.” Graves replied that he had, and
asked him if he knew who were the perpetrators. Tom said, “No,”
adding, “And I wouldn’t for the world; for if I did, and told of them, I
shouldn’t live long.” “That’s a fact, Tom,” said Graves, “You wouldn’t
live fifteen minutes. I’ll tell you of a circumstance as happened to me
about bein’ robbed in Californy:
“One night about ten o’clock, me and my partner was ridin’ along,
and two fellers rode up and told us to throw up our hands, and give
up our money. We did it pretty quick I guess. They got $2,000 in
coined gold from us. I told ’em, ‘Boys,’ sez I, ‘It’s pretty rough to take
all we’ve got.’ So the feller said it was rather rough, and he gave us
back $40. About a week after, I seen the two fellers dealin’ Faro. I
looked pretty hard at them, and went out. One of the chaps follered
me, and sez he, ‘Ain’t you the man that was robbed the other night?’
‘No,’ sez I, for I was afraid to tell him the truth. Sez he, ‘I want you to
own up; I know you’re the man. Now I’m agoing to give you $4,000
for keeping your mouth shut,’ and he did, ——. Now you see, Tom,
that’s what I got for keepin’ my mouth shut. I saved my life, and got
$4,000.”
Ives made for Virginia City, and there told, in a house of ill-fame,
that he was the Bamboo chief that made Tom Caldwell throw up his
hands, and that, ——, he would do it again. He and a Colorado
driver, who was a friend of Caldwell’s went together to Nevada. Each
of them had a shot-gun. Ives was intoxicated. The driver asked Ives
whom did he suppose to be the robbers; to which he quickly replied,
“I am the Bamboo chief that robbed it,” etc., etc., as before
mentioned. The man then said, “Don’t you think Tom knows it?” “Of
course I do,” said George. As they came back to town, the driver
saw Tom, and waved to him to keep back, which he did, and sent a
man to inquire the reason of the signal. The messenger brought him
back information of what had passed, and told him to keep out of
Ives’ way, for he was drunk and might kill him.
The same evening, Tom and his friend went to the Cold Spring
Ranch together, on the coach, and the entire particulars came out, in
conversation. The driver finished the story by stating that he sat on
his horse, ready to shoot Ives, if he should succeed in getting the
“drop” on Caldwell.
 Three days after, when Southmayde was about to return from
Bannack, Buck Stinson and Ned Ray came into the Express Office,
and asked who were for Virginia. On being told that there were none
but Southmayde, they said, “Well, then, we’ll go.” The Agent came
over and said to Leroy, “For God’s sake, don’t go; I believe you’ll be
killed.” Southmayde replied, “I have got to go; and if you’ll get me a
double-barrelled shot gun, I will take my chances.” Oliver’s Agent
accordingly provided Leroy Southmayde, Tom Caldwell, and a young
lad about sixteen years of age, who was also going by the coach to
Virginia, with a shot gun each. Leroy rode with Tom. They kept a
keen eye on a pair of Road Agents, one driving and the other
watching.
The journey was as monotonous as a night picket, until the coach
reached the crossing of the Stinkingwater, where two of the three
men that robbed it (Bob Zachary and Bill Graves) were together, in
front of the station, along with Aleck Carter. Buck Stinson saw them,
and shouted, “Ho! you —— Road Agents.” Said Leroy to Tom
Caldwell, “Tom, we’re gone up.” Said Tom, “That’s so.”
At the Cold Spring Station, where the coach stopped for supper,
the amiable trio came up. They were, of course fully armed with gun,
pistols and knife. Two of them set down their guns at the door, and
came in. Aleck Carter had his gun slung at his back. Bob Zachary
feigning to be drunk, called out, “I’d like to see the —— man that
don’t like Stone.” Finding that, as far as could be ascertained,
everybody present, had a very high opinion of Stone, he called for a
treat to all hands, which having been disposed of, he bought a bottle
of whiskey and behaved “miscellaneously” till the coach started.
After going about a quarter of a mile, they wheeled their horses
and called “Halt.” The instant the word left their lips, Leroy dropped
his gun on Aleck Carter; Tom Caldwell, and the other passenger
each picked his man, and drew a bead on him, at the same moment.
Aleck Carter called out, “We only want you to take a drink; but you
can shoot and be ——, if you want to.” Producing the bottle, it was
handed round; but Leroy and Tom only touched their lips to it. Tom
believed it to be poisoned. After politely inquiring if any of the ——
wanted any more, they wheeled their horses, saying, “We’re off for
Pete Daley’s,” and clapped spurs to their horses, and headed for the
Ranch, going on a keen run.
Before leaving Cold Spring Ranch, Leroy Southmayde told Tom
that he saw through it all, and would leave the coach; but Tom said
he would take Buck up beside him, and that surely the other fellow
could watch Ray. Buck did not like the arrangement; but Tom said,
“You’re an old driver, and I want you up with me, ——.”
The two passengers sat with their shot guns across their knees,
ready for a move on the part of either of the robbers.
At Lorraine’s Ranch, Leroy and Caldwell went out a little way from
the place, with the bridles in their hands, and talked about the
“situation.” They agreed that it was pretty rough, and were debating
the propriety of taking to the brush, and leaving the coach, when
their peace of mind was in no way assured by seeing that Buck
Stinson was close to them, and must have overheard every word
they had uttered. Buck endeavored to allay their fears by saying
there was no danger. They told him that they were armed, and that if
they were attacked, they would make it a warm time for some of
them; at any rate, they would “get” three or four of them. Buck
replied, “Gentlemen, I pledge you my word, my honor, and my life,
that you will not be attacked between this and Virginia.”
The coach went on, directly the horses were hitched up, and Buck
commenced roaring out a song, without intermission, till at last he
became tired, and then, at his request, Ray took up the chorus. This
was the signal to the other three to keep off. Had the song ceased,
an attack would have been at once made, but, without going into
Algebra, they were able to ascertain that such a venture had more
peril than profit, and so they let it alone. The driver, Southmayde and
the young passenger were not sorry when they alighted safe in town.
Ned Ray called on Southmayde and told him that if he knew who
committed the robbery he should not tell; for that death would be his
portion if he did.
 CHAPTER XIV.
THE OPENING OF THE BALL—GEORGE IVES.

They mustered in their simple dress,

For wrongs to seek a stern redress.
As a matter of course, after the failure of Justice in the case of the
murderers of Dillingham, the state of society, bad as it was rapidly
deteriorated, until a man could hardly venture to entertain a belief
that he was safe for a single day. We have been repeatedly shown
places where bullets used to come through the chinks between the
logs separating one of the stores in town from a saloon. Wounded
men lay almost unnoticed about the city, and a night or day without
shooting, knifing or fighting would have been recognized as a small
and welcome instalment of the millennium. Men dared not go from
Virginia to Nevada or Summit after dark. A few out of the hundreds
of instances must suffice. A Dutchman, known as Dutch Fred, was
met by one of the band, who ordered him to throw up his hands, as
usual. Finding he had $5 in Treasury Notes with him, the robber told
him he would take them at par, and added with a volley of curses, “If
ever you come this way with only $5, I’ll shoot you; —— you, I’ll
shoot you anyhow,” and raising his pistol, he shot him in the arm.
Another man was robbed of two or three dollars, about two or three
miles below Nevada, and was told that if ever he came with as little
money again they would kill him.
George Ives was a young man of rather prepossessing
appearance, probably twenty-seven years old. His complexion and
hair were light, and his eyes blue. He wore no whiskers. His height
was nearly six feet, and he wore a soldier’s overcoat and a light felt
hat. The carriage of this renowned desperado was sprightly, and his
coolness was imperturbable. Long practice in confronting danger
had made him absolutely fearless. He would face death with an
indifference that had become constitutional, and the spirit of reckless
bravado with which he was animated made him the terror of the
citizens. He would levy black mail under the guise of a loan and as a
matter of sport, and to show the training of his horse, he would back
the animal into the windows of a store, and then ride off laughing. In
looking at Ives a man would, at first sight, be favorably impressed;
but a closer examination by any one skilled in physiognomy, would
detect in the lines of the mouth and in the strange, fierce and sinister
gleam of the eye, the quick spirit which made him not only the terror
of the community, but the dread of the band of ruffians with whom he
was associated.
As before mentioned, he was with Henry Plummer when he
started to rob Langford and Hauser; he assisted at the robbery of the
coaches in October and November, and, after that, he figured as a
highwayman with Aleck Carter, down on Snake River, under the alias
of Lewis.
In company with a friend, he visited his comrades, Hunter and
Carter, at Brown’s Gulch, and on their way back, among the hills
which form, as it were, the picket line of the Ramshorn Mountains,
the two met Anton M. Holter, now a citizen of Virginia. They politely
invited him to replenish their exchequers by a draft on his own,
which, under the circumstances, he instantly did; but he was able at
the moment to honor only a small check. They read him a lecture
upon the impropriety of travelling with so small a sum in his
possession, and then, as an emphatic confirmation of their
expressed displeasure, George drew his revolver, and, aiming at his
head, sent a ball through his hat, grazing his scalp. A second shot,
with more deliberate aim, was only prevented by the badness of the
cap. After this failure, this “Perfect gentleman” went his way, and so
did Holter, doubtless blessing the cap maker.
Tex was a frequent companion of Ives, who was also intimate with
Plummer, and George used frequently to show their letters, written in
cypher, to unskilled if not unsuspecting citizens. He spent a life of
ceaseless and active wickedness up to the very day of his capture.
Perhaps the most daring and cold blooded of all his crimes was
the murder which he committed near the Cold Spring Ranch. A man
had been whipped for larceny near Nevada, and to escape the sting
of the lash, he offered to give information about the Road Agents.
Ives heard of it, and meeting him purposely between Virginia and
Dempsey’s, he deliberately fired at him with his double-barrelled
gun. The gun was so badly loaded, and the man’s coat so thickly
padded that the buckshot did not take effect, upon which he coolly
drew his revolver and, talking to him all the time, shot him dead. This
deed was perpetrated in broad daylight, on a highway—a very
Bloomingdale Road of the community—and yet, there, in plain view
of Daley’s and the Cold Spring Ranch, with two or three other teams
in sight, he assassinated his victim, in a cool and business like
manner, and when the murdered man had fallen from his horse, he
took the animal by the bridle and led it off among the hills.
Ives then went to George Hilderman and told him that he should
like to stay at his wakiup for a few days, as he had killed a man near
Cold Spring Ranch, and there might be some stir and excitement
about it.
In about half an hour after, some travellers arrived at the scene of
murder. The body was still warm, but lifeless, and some of the
neighbors from the surrounding ranches dug a lonely grave in the
beautiful valley, and there, nameless, uncoffined and unwept, the
poor victim:
“Life’s fitful fever over,
Sleeps well.”
The passer-by may even now notice the solitary grave, where he
lies, marked as it still is by the upheaved earth, on the left side of the
road as he goes down the valley, about a mile on the Virginia side of
the Cold Spring Ranch.
All along the route the ranchmen knew the Road Agents, but the
certainty of instant death in case they revealed what they knew
enforced their silence, even when they were really desirous of giving
information or warning.
Nicholas Tbalt had sold a span of mules to his employers, Butschy
& Clark, who paid him the money. Taking the gold with him, he went
to Dempsey’s Ranch to bring up the animals. Not returning for some
time, they concluded that he had run away with the mules, and were
greatly grieved that a person they had trusted so implicitly should
deceive them. They were, however, mistaken. Faithful to his trust, he
had gone for the mules, and met his death from the hand of George
Ives, who shot him, robbed him of his money, and stole his mules.
Ives first accused Long John of the deed; but he was innocent of it,
as was also Hilderman, who was a petty thief and hider, but neither
murderer nor Road Agent. His gastronomic feats at Bannack had
procured him the name, the American Pie-Eater. Ives contradicted
himself at his execution, stating that Aleck Carter was the murderer;
but in this he wronged his own soul. His was the bloody hand that
committed the crime. Long John said, on his examination at the trial,
that he did not see the shots fired, but that he saw Nicholas coming
with the mules, and George Ives going to meet him; that Ives rode
up shortly after with the mules, and said that the Dutchman would
never trouble anybody again.
The body of the slaughtered young man lay frozen, stiff and stark,
among the sage brush, whither it had been dragged, unseen of man;
but the eye of Omniscience rested on the blood-stained corpse, and
the fiat of the Eternal Judge ordered the wild bird of the mountains to
point out the spot, and, by a miracle, to reveal the crime. It was the
finger of God that indicated the scene of the assassination, and it
was His will stirring in the hearts of the honest and indignant gazers
on the ghastly remains of Tbalt that organized the party which,
though not then formally enrolled as a Vigilance Committee, was the
nucleus and embryo of the order—the germ from which sprang that
goodly tree, under the shadow of whose wide-spreading branches
the citizens of Montana can lie down and sleep in peace.
Nicholas Tbalt was brought into Nevada on a wagon, after being
missing for ten days. William Herren came to Virginia and informed
Tom Baume, who at once went down to where the body lay. The
head had been pierced by a ball, which had entered just over the left
eye. On searching the clothes of the victim, he found in his pocket a
knife which he had lent him in Washington Gulch, Colorado, two
years before, in presence of J. X. Beidler and William Clark.
 The marks of a small lariat were on the dead man’s wrists and
neck. He had been dragged through the brush, while living, after
being shot, and when found lay on his face, his right arm bent across
his chest and his left grasping the willows above him.
William Palmer was coming across the Stinkingwater Valley, near
the scene of the murder, ahead of his wagon, with his shot-gun on
his shoulder. A grouse rose in front of him, and he fired. The bird
dropped dead on the body of Tbalt. On finding the grouse on the
body, he went down to the wakiup, about a quarter of a mile below
the scene of the murder, and seeing Long John and George
Hilderman there, he told them that there was the body of a dead man
below, and asked them if they would help him to put the corpse into
his wagon, and that he would take it to town, and see if it could be
identified. They said “No; that is nothing. They kill people in Virginia
every day, and there’s nothing said about it, and we want to have
nothing to do with it.”
The man lay for half a day exposed in the wagon, after being
brought up to Nevada. Elk Morse, William Clark and Tom Baume got
a coffin made for him; took him up to the burying ground above
Nevada; interred him decently, and, at the foot of the grave, a
crotched stick was placed, which is, we believe still standing.
The indignation of the people was excited by the spectacle. The
same afternoon, three or four of the citizens raised twenty-five men,
and left Nevada at 10 p. m. The party subscribed an obligation before
starting, binding them to mutual support, etc., and then travelled on,
with silence and speed, towards the valley of the Stinkingwater.
Calling at a Ranch on their way, they obtained an accession to their
numbers, in the person of the man who eventually brought Ives to
bay, after he had escaped from the guard who had him in charge.
Several men were averse to taking him with them, not believing him
to be a fit man for such an errand; but they were greatly mistaken,
for he was both honest and reliable, as they afterwards found.
Avoiding the travelled road, the troop rode round by the bluff, so
as to keep clear of Dempsey’s Ranch. About six miles further on,
they called at a cabin and got a guide, to pilot them to the
rendezvous.
At about half-past three in the morning, they crossed Wisconsin
Creek, at a point some seven miles below Dempsey’s, and found
that it was frozen, but that the ice was not strong enough to carry the
weight of man and horse, and they went through one after another,
at different points, some of the riders having to get down, in order to
help their horses, emerging half drowned on the other side, and
continuing their journey, cased in a suit of frozen clothes, which, as
one of them observed, “Stuck to them like death to a dead nigger.”
Even the irrepressible Tom Baume was obliged to take a sharp nip
on his “quid,” and to summon all his fortitude to his aid to face the
cold of his ice-bound “rig.”
The leader called a halt about a mile further on, saying, “Every one
light from his horse, hold him by the bridle, and make no noise till
day break.” Thus they stood motionless for an hour and a half. At the
first peep of day the word was given, “Boys, mount your horses, and
not a word pass, until we are in sight of the wakiup.” They had not
travelled far when a dog barked. Instantly they put spurs to their
horses, and breaking to the right and left, formed the “surround,”
every man reining up with his shot-gun bearing on the wakiup. The
leader jumped from his horse, and seeing eight or ten men sleeping
on the ground in front of the structure, all wrapped up in blankets,
sang out, “The first man that raises will get a quart of buckshot in
him, before he can say Jack Robinson.” It was too dark to see who
they were, so he went on to the wakiup, leaving his horse in charge
of one of the party, half of whom had dismounted and the others held
the horses. “Is Long John here?” he asked. “Yes,” said that
longitudinal individual. “Come out here; I want you.” “Well,” said he,
“I guess I know what you want me for.” “Probably you do; but hurry
up; we have got no time to lose.” “Well,” said John, “Wait till I get my
moccasins on, won’t you?” “Be quick about it then,” observed his
captor. Immediately after he came out of the wakiup, and they waited
about half an hour before it was light enough to see distinctly. The
captain took four of his men and Long John, and walked to the place
where the murder had been committed, leaving the remainder of the
troop in charge of the other men. They went up to the spot, and there
Long John was charged with the murder. Palmer showed the
position in which the body was found. He said, “I did not do it, boys.”
He was told that his blood would be held answerable for that of
Nicholas Tbalt; for that, if he had not killed him, he knew well who
had done it, and had refused to help to put his body into a wagon.
“Long John,” said one of the men, handling his pistol as he spoke,
“You had better prepare for another world.” The leader stepped
between and said, “This won’t do; if there is anything to be done, let
us all be together.” Long John was taken aside by three of the men,
and sat down. They looked up, and there, in the faint light—about a
quarter of a mile off—stood Black Bess, the mule bought by X.
Beidler in Washington Gulch. Pointing to the animal, they said,
“John, whose mule is that?” “That’s the mule that Nick rode down
here,” he answered. “You know whose mule that is, John. Things
look dark. You had better be thinking of something else now.” The
mule was sent for, and brought before him, and he was asked where
the other two mules were. He said he did not know. He was told that
he had better look out for another world, for that he was played out in
this. He said, “I did not commit that crime. If you give me a chance,
I’ll clear myself.” “John,” said the leader, “You never can do it; for you
knew of a man lying dead for nine days, close to your house, and
never reported his murder; and you deserve hanging for that. Why
didn’t you come to Virginia and tell the people?” He replied that he
was afraid and dared not do it. “Afraid of what?” asked the captain.
“Afraid of the men round here.” “Who are they?” “I dare not tell who
they are. There’s one of them round here.” “Where?” “There’s one of
them here at the wakiup, that killed Nick.” “Who is he?” “George
Ives.” “Is he down at the wakiup?” “Yes.” “You men stand here and
keep watch over John, and I’ll go down.” Saying this he walked to
the camp.
On arriving at the wakiup, he paused, and picking out the man
answering to the description of George Ives, he asked him, “Is your
name George Ives?” “Yes,” said that worthy. “I want you,” was the
laconic reply. “What do you want me for?” was the natural query. “To
go to Virginia City,” was the direct but unpleasing rejoinder. “All right,”
said George, “I expect I have to go.” He was at once given in charge
of the guard.
So innocent were some of the troop, that they had adopted the
“Perfect gentleman” hypothesis, and laid down their arms in anger, at
the arrest of this murderous villain. A little experience prevented any
similar exhibition of such a weakness, in the future.
Two of the party went over to Tex, who was engaged in the highly
necessary operation of changing his shirt. “I believe we shall want
you too,” said one of them; Tex denuded himself of his under
garment, and throwing it towards Tom Baume, exclaimed, “There’s
my old shirt and plenty of graybacks. You’d better arrest them too.”
He was politely informed that he himself, but neither the shirt nor its
population, was the object of this “unconstitutional restraint,” and
was asked if the pistols lying on the ground were his, which he
admitted, and was thereupon told that they were wanted, also, and
that he must consider himself “under arrest”—a technical, yet simple,
formula adopted by mountaineers, to assure the individual
addressed that his brains will, without further warning, be blown out,
if he should attempt to make a “break.” Tex dressed himself and
awaited further developments.
There appeared to be a belief on the part of both Tex and Ives that
they should get off; but when they saw the party with Long John,
they appeared cast down, and said no more.
The other men who were lying round the wakiup, when the
scouting party rode up, were Aleck Carter, Bob Zachary, Whiskey
Bill, Johnny Cooper, and two innocent strangers, whose prolonged
tenure of life can only be accounted for by the knowledge of the
circumstance that they were without money at the time. Of the fact of
the connection of the others with the band, the boys were ignorant,
and were drinking coffee with them, laying down their guns within the
reach of the robbers, on their bed clothes. Had the Road Agents
possessed the nerve to make the experiment, they could have blown
them to pieces. One of the party, pointing to Aleck Carter, said to the
leader, “There’s one good man among them, any way. I knew him on
the ‘other side,’” (west of the Mountains.) The captain’s view of the
state of things was not altered by this flattering notice. He sang out,
in a tone of voice that signified “something’s up,” “Every man take his
gun and keep it.” In after expeditions, he had no need to repeat the
command. Five men were sent into the wakiup, and the rest stood
round it. The result of their search was the capture of seven dragoon
and navy revolvers, nine shot-guns and thirteen rifles. These were
brought out, and in laying them down, one of them went off close to
Tom Baume’s head. Leroy Southmayde’s pistol—taken from him at
the time of the robbery of the coach—was one of the weapons. It
was recognized at the trial of Ives, by the number upon it. About half
an inch of the muzzle had been broken off, and it had then been
fixed up smoothly.
All being now ready, the party started for Dempsey’s, and George,
who was mounted on his spotted bob-tailed pony, went along with
them. He had determined to escape and in order to carry out his
design, he expressed a wish to try the speed of his horse against the
others, and challenged several to race with him. This was foolishly
permitted, and, but for the accidental frustration of his design to
procure a remount of unsurpassed speed, a score of names might
have been added to the long list of his murdered victims.
At Dempsey’s Ranch there was a bridge in course of construction,
and two of the men riding ahead, saw George Hilderman, standing
on the center, at work. He was asked if his name was George
Hilderman, and replied “Yes,” whereupon he was informed that he
was wanted to go up to Virginia City. He inquired whether they had
any papers for him, and being told that they had not any, he declared
that he would not leave the spot; but the leader coming up, told him
to go “Without any foolishness,” in a manner that satisfied him of the
inutility of resistence, and he prepared to accompany them; but not
as a volunteer, by any means. He said he had no horse. Tom Baume
offered him a mule. Then he had no saddle. The same kind friend
found one, and he had to ride with them. His final effort was couched
in the form of a declaration that the beast would not go. A stick was
lying on the ground, and he received an instruction, as the
conventions word it, either to “whip and ride,” or “walk and drive.”
This practically speaking, reconciled him to the breach of the
provisions of Magna Charta and the Bill of Rights involved in his
arrest, and he jogged along, if not comfortably, yet, at all events, in
peace.
In the meantime, the arch villain in custody of the main body was
playing his role with much skill and with complete success. He
declared his entire innocence of the awful crime with which he was
charged, and rather insinuated than expressed his wish that he
might be taken to Virginia, where his friends were, and that he might
be tried by civil authorities, (Plummer to empannel the jury,) and
incidentally remarked that he should not like to be tried at Nevada,
for that he once killed a dog there, which had scared his horse, and
for that reason, they had prejudices against him, which might work
him serious injury in the event of his trial at that place.
There is no doubt that the seeming alacrity with which he
apparently yielded to the persuasions of his captors, threw them off
their guard, and he was permitted to ride unarmed, but otherwise
unrestrained, along with the escort.
So large a troop of horsemen never yet rode together, mounted on
fleet cayuses, on the magnificent natural roads of Montana, without
yielding to the temptation presented to try the comparative merits of
their horses, and our company of partizan police were no exception
to this rule. Scrub races were the order of the day, until, in one of
them, Geo. Ives, who was the winner, attracted the attention of the
whole party, by continuing his race at the top of his horse’s speed;
but not until he was at least ten rods ahead of the foremost rider, did
the guard (?) realize the fact that the bird had flown from the open
cage. Twenty-four pairs of spurs were driven home, into the flanks of
twenty-four horses, and with a clatter of hoofs never since equalled
on that road, except when the deluded cavalry of Virginia rode down
the valley:
“To see the savage fray;”
or at the reception given to the Hon. J. M. Ashley and party—they
swept on like a headlong rout.
 For awhile, the fugitive gained gradually, but surely, on his
pursuers, heading for Daley’s Ranch, where his own fleet and
favorite mare was standing bridled and saddled, ready for his use,
(so quickly did intelligence fly in those days.) Fortune, however,
declared against the robber. He was too hotly pursued to be able to
avail himself of the chance. His pursuers seeing a fresh horse from
Virginia and a mule standing there, leaped on their backs and
continued the chase. Ives turned his horses’ head towards the
mountains round Bivens’ Gulch, and across the plain, in that race for
life, straining every nerve, flew the representatives of crime and
justice. Three miles more had been passed, when the robber found
that his horses’ strength was failing, and every stride diminishing.
The steeds of Wilson and Burtchey were in no better condition; but
the use of arms might now decide the race, and springing from his
horse, he dashed down a friendly ravine, whose rocky and boulder
strewn sides might offer some refuge from his relentless foes. Quick
as thought, the saddles of his pursuers were empty, and the trial of
speed was now to be continued on foot. On arriving at the edge of
the ravine, Ives was not visible; but it was evident that he must be
concealed within a short distance. Burtchey quickly “surrounded” the
spot, and sure enough, there was Ives crouching behind a rock.
Drawing a bead on him, Burtchey commanded him to come forth,
and with a light and careless laugh he obeyed. The wily Bohemian
was far too astute, however, to be thus overreached, and before Ives
could get near enough to master his gun, a stern order to “stand
fast,” destroyed his last hope, and he remained motionless until
assistance arrived, in the person of Wilson.
Two hours had elapsed between the time of the escape and the
recapture and return of the prisoner. A proposition was made to the
captain to raise a pole and hang him there, but this was negatived.
After gaily chatting with the boys, and treating them, the word was
given to “Mount,” and in the centre of a hollow square, Ives began to
realize his desperate situation.
Tidings of the capture flew fast and far. Through every nook and
dell of the inhabited parts of the Territory, wildly and widely spread
the news. Johnny Gibbons, who afterwards made such sly and rapid
tracks for Utah, haunted with visions of vigilance committees, joined
the party before they reached the canyon at Alder Creek, and
accompanied them to Nevada. At that time he was a part owner of
the Cottonwood Ranch, (Dempsey’s,) and kept the band well
informed of all persons who passed with large sums of money.
The sun had sunk behind the hills when the detachment reached
Nevada, on the evening of the 18th of December, and a discussion
arose upon the question whether they should bring Ives to Virginia,
or detain him for the night at Nevada. The “conservatives” and
“radicals” had a long argument developing an “irrepressible conflict;”
but the radicals, on a vote, carried their point—rejecting Johnny
Gibbon’s suffrage on the ground of mixed blood. It was thereupon
determined to keep Ives at Nevada until morning, and then to
determine the place of trial.
The prisoners were separated and chained. A strong guard was
posted inside and outside of the house, and the night came and went
without developing anything remarkable. But all that weary night, a
“solitary horseman might have been seen” galloping along the road
at topmost speed, with frequent relays of horses, on his way to
Bannack City. This was Lieut. George Lane alias Club-Foot, who
was sent with news of the high-handed outrage that was being
perpetrated in defiance of law, and with no regard whatever to the
constituted authorities. He was also instructed to suggest that
Plummer should come forthwith to Nevada; demand the culprit for
the civil authorities, enforce that demand by what is as fitly called
hocus pocus as habeas corpus, and see that he had a fair (?)
trial.
As soon as it was determined that Ives should remain at Nevada,
Gibbons dashed up the street to Virginia, meeting a lawyer or two on
the way—
“Where the carrion is, there will the vultures,” etc.
At the California Exchange, Gibbons found Messrs. Smith and
Ritchie, and a consultation between client, attorney and proch ein
ami, resulted in Lane’s mission to Bannack, as one piece of strategy
that faintly promised the hoped for rewards. All of Ives’ friends were
notified to be at Nevada early the next morning.
The forenoon of the 19th saw the still swelling tide of miners,
merchants and artizans wending their way to Nevada, and all the
morning was spent in private examinations of the prisoners, and
private consultations as to the best method of trial. Friends of the
accused were found in all classes of society; many of them were
assiduously at work to create a sentiment in his favor, while a large
multitude were there, suspicious that the right man had been caught;
and resolved, if such should prove to be the case, that no loop-hole
of escape should be found for him, in any technical form of the law.
Although on the eve of “Forefathers’ Day,” there was in the
atmosphere the mildness and the serenity of October. There was no
snow, and but little ice along the edges of sluggish streams; but the
Sun, bright and genial, warmed the clear air, and even thawed out
the congealed mud in the middle of the streets. Little boys were at
play in the streets, and fifteen hundred men stood in them, impatient
for action, but waiting without a murmur, in order that everything
might be done decently and in order.
Messrs. Smith, Richie, Thurmond and Colonel Wood were Ives’
lawyers, with whom was associated Mr. Alex. Davis, then a
comparative stranger in Montana.
Col. W. F. Sanders, at that time residing at Bannack City, but
temporarily sojourning at Virginia, was sent for to conduct the
prosecution, and Hon. Charles S. Bagg was appointed his colleague,
at the request of Judge Wilson, Mr. Bagg being a miner, and, then,
little known.
In settling upon the mode of trial, much difference of opinion was
developed; but the miners finally determined that it should be held in
presence of the whole body of citizens, and reserved to themselves
the ultimate decision of all questions; but lest something should
escape their attention, and injustice thereby be done to the public, or
to the prisoner, a delegation composed of twelve men from each
district (Nevada and Junction) was appointed to hear the proof, and
to act as an advisory jury. W. H. Patton, of Nevada, and W. Y.
Pemberton, of Virginia, were appointed amanuenses. An attempt to
get on the jury twelve men from Virginia was defeated, and late in
the afternoon, the trial began and continued till nightfall. The three
prisoners, George Ives, George Hilderman and Long John (John
Franck) were chained with the lightest logging chain that could be
found—this was wound round their legs, and the links were secured
with padlocks.
In introducing testimony for the people, on the morning of the 21st,
the miners informed all concerned that the trial must close at three p.
m. The announcement was received with great satisfaction.
It is unnecessary to describe the trial, or to recapitulate the
evidence. Suffice it to say that two alibis, based on the testimony of
George Brown and honest Whiskey Joe, failed altogether. Among
the lawyers, there was, doubtless, the usual amount of brow-beating
and technical insolence, intermingled with displays of eloquence and
learning; but not the rhetoric of Blair, the learning of Coke, the
metaphysics of Alexander, the wit of Jerrold, or the odor of Oberlin,
could dull the perceptions of those hardy Mountaineers, or mislead
them from the stern and righteous purpose of all this labor, which
was to secure immunity to the persons and property of the
community, and to guarantee a like protection to those who should
cast their lot in Montana in time to come.
The evidence was not confined to the charge of murder; but
showed, also, that Ives had been acting in the character of a robber,
as well as that of a murderer; and it may well be doubted whether he
would have been convicted at all, if developments damaging to the
reputations and dangerous to the existence of some of his friends
had not been made during the trial, on which they absented
themselves mysteriously, and have never been seen since. There
was an instinctive and unerring conviction that the worst man in the
community was on trial; but it was hard work, after all the proof and
all this feeling, to convict him.
Prepossessing in his appearance; brave, beyond a doubt; affable
in his manners; jolly and free among his comrades, and with
thousands of dollars at his command; bad and good men alike
working upon the feeling of the community, when they could not
disturb its judgment—it seemed, at times, that all the labor was to
end in disastrous failure.
The crowd which gathered around that fire in front of the Court, is
vividly before our eyes. We see the wagon containing the Judge, and
an advocate pleading with all his earnestness and eloquence for the
dauntless robber, on whose unmoved features no shade of
despondency can be traced by the fitful glare of the blazing wood,
which lights up, at the same time, the stern and impassive features
of the guard, who, in every kind of habiliments, stand in various
attitudes, in a circle surrounding the scene of Justice. The attentive
faces and compressed lips of the Jurors show their sense of the vast
responsibility that rests upon them, and of their firm resolve to do
their duty. Ever and anon a brighter flash than ordinary reveals the
expectant crowd of miners, thoughtfully and steadily gazing on the
scene, and listening intently to the trial. Beyond this close phalanx,
fretting and shifting around its outer edge, sways with quick and
uncertain motion, the wavering line of desperadoes and
sympathizers with the criminal; their haggard, wild and alarmed
countenances showing too plainly that they tremble at the issue
which is, when decided to drive them in exile from Montana, or to
proclaim them as associate criminals, whose fate could neither be
delayed nor dubious. A sight like this will ne’er be seen again in
Montana. It was the crisis of the fate of the Territory. Nor was the
position of prosecutor, guard, juror, or Judge, one that any but a
brave and law-abiding citizen would chose, or even except. Marked
for slaughter by desperadoes, these men staked their lives for the
welfare of society. A mortal strife between Colonel Sanders and one
of the opposing lawyers was only prevented by the prompt action of
wise men, who corraled the combatants on their way to fight. The
hero of that hour of trial was avowedly W. F. Sanders. Not a
desperado present but would have felt honored by becoming his
murderer, and yet, fearless as a lion, he stood there confronting and
defying the malice of his armed adversaries. The citizens of
Montana, many of them his bitter political opponents, recollect his
actions with gratitude and kindly feeling. Charles S. Bagg is also
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

ebookfinal.com