Following is a listing of resources that you may find useful either to own or bookmark
during your navigation through the .NET language space. If you feel that there's
a resource that other .NET developers should know about, please
CIL Programming: Under the Hood of .NET, by Jason Bock, Apress, 2002. This
book covers the essentials of programming CIL. It also discusses the basics of what
.NET assemblies are and how manifests fit into the picture, and how to create assemblies
Procedural languages are generally well understood and their formal foundations
cast in the forms of various lambda-calculi. For object- oriented languages however
the situation is not as clear-cut. In this book the authors propose and develop
a different approach by developing object calculi in which objects are treated as
primitives. Using object calculi,the authors are able to explain both the semantics
of objects and their typing rules and demonstrate how to develop all of the most
important concepts of object-oriented programming languages: self, dynamic dispatch,
classes, inheritance, protected and private methods, prototyping, subtyping, covariance
and contravariance, and method specialization. Many researchers and graduate students
will find this an important development of the underpinnings of object-oriented
As the .NET Framework and Common Language Runtime (CLR) continue to mature in terms
of platform adoption, robustness, reliability, and feature richness, developers
have an increasing need to understand the foundation on top of which all managed
code runs. This book looks at the underlying platform commonalities that all developers
can use, regardless of language choice or development tools. This includes languages
such as C#, Visual Basic, C++/CLI, and others.
Inside Microsoft .NET IL Assembler, by Serge Lidin, MSPress, 2002. Get the
inside scoop on this critical low-level language with an architectural guide from
the most reliable authority-the language's designer, Serge Lidin. You'll discover
common structures, functions, and rules for designing .NET applications, explanations
for how .NET executables compile, details on the .NET IL Assembler, IL Disassembler
and Metadata Validation tools, and more.
Compiling for the .NET Common Language Runtime, by John Gough, Prentice Hall,
2001. This book is about code generation for the Microsoft.NET Common Language Runtime
(CLR). It guides software engineers in creating .NET compilers and implementing
programming languages for the .NET environment, explains key concepts underlying
.NET CLR, and demonstrates how CLR maximizes interoperability across multiple programming
Shared Source CLI Essentials, by David Stutz, Ted Neward, and Geoff Shilling,
O'Reilly, 2003. Microsoft's Shared Source CLI (code-named "Rotor") is the publicly
available implementation of the ECMA Common Language Infrastructure (CLI) and the
ECMA C# language specification. Loaded with three million lines of source code,
it presents a wealth of programming language technology that targets developers
interested in the internal workings of the Microsoft .NET Framework, academics working
with advanced compiler technology, and people developing their own CLI implementations.
The CLI, at its heart, is an approach to building software that enables code from
many independent sources to co-exist and interoperate safely. This book is a companion
guide to Rotor's code. This concise and insightful volume provides a road map for
anyone wishing to navigate, understand, or alter the Shared Source CLI code. This
book illustrates the design principles used in the CLI standard and discusses the
complexities involved when building virtual machines. Included with the book is
a CD-ROM that contains all the source code and files.
The .NET Languages, by Brian Bischof, Apress, 2001. For Visual Basic and
C# programmers facing Microsoft's new platform, The .NET Languages: A Quick Translation
Guide offers an extremely useful comparison of three languages: Visual Basic 6,
Visual Basic .NET, and C#.
Programming in the .NET Environment, by Damien Watkins, Mark Hammond, Brad
Abrams, Addison-Wesley, 2002. This book is the software developer's guide to the
.NET Framework. The authors describe Microsoft's vision for distributed component-based
systems development and then show programmers how to develop software that takes
full advantage of the features of the .NET Framework. Readers learn how to author
components, libraries, and frameworks that not only exploit the capabilities of
the .NET Framework but also integrate seamlessly into that environment.
Build Your Own .NET Language and Compiler, by Edward G. Nilges, Apress, 2004.
This book takes the mystery out of compiler and language development and makes it
accessible to every programmer. Ruthlessly practical, this book teaches fundamental
techniques that programmers can use in their every day work.
The Common Language Infrastructure Annotated Standard, by James S. Miller,
Susann Ragsdale, Jim Miller, Addison-Wesley, 2003. The Common Language Infrastructure
Annotated Standard is the definitive guide to understanding the annotated specification
for the Common Language Infrastructure (CLI) standard. With annotations and code
samples from both the ECMA standards committee and the Microsoft Common Language
Runtime (CLR) team, this book goes beyond the online documentation to clarify and
amplify the original standard and describe its implementation.
.NET Common Language Runtime Unleashed, by Kevin Burton, Sams, 2002. This
book is a high-end comprehensive reference to the capability of the CLR. The samples
in the book have been written so that they not only illustrate a principle but give
the reader a springboard to quickly translate the sample to practical, real-world
applications. After reading this book, readers will be able to significantly increase
their productivity by comfortably using the power and expressiveness of the Common
Language Runtime in their applications. This book will take the reader beyond the
syntax of C# to using and understanding the CLR to build secure, maintainable, and
high performance applications.
The C# Programming Language, by Anders Hejlsberg, Scott Wiltamuth, Peter
Golde, Addison-Wesley, 2003. C# is a simple, modern, object-oriented, and type-safe
programming language that combines the high productivity of rapid application development
languages with the raw power of C and C++. Written by the language's architect and
design team members, The C# Programming Language is the definitive technical reference
for C#. Moving beyond the online documentation, the book provides the complete specification
of the language along with descriptions, reference materials, and code samples from
the C# design team.
The Visual Basic .Net Programming Language, by Paul Vick, Addison-Wesley,
2004. Vick exposes VB .NET’s most powerful capabilities with unprecedented depth
and clarity, and packs this book with information you simply won’t find anywhere
else. Whether you’re an experienced VB .NET programmer, upgrading from earlier versions
of Visual Basic, or coming to Visual Basic and .NET for the first time, you’ll find
this book indispensable.
Engineering a Compiler, by Keith D. Cooper, Linda Torczon, Morgan Kaufmann,
2003. Today's compiler writer must choose a path through a design space that is
filled with diverse alternatives, each with distinct costs, advantages, and complexities.
This book explores this design space by presenting some of the ways these problems
have been solved, and the constraints that made each of those solutions attractive.
By understanding the parameters of the problem and their impact on compiler design,
the authors hope to convey both the depth of the problems and the breadth of possible
solutions. Their goal is to cover a broad enough selection of material to show readers
that real tradeoffs exist, and that the impact of those choices can be both subtle
Advanced Compiler Design and Implementation, by Steven S. Muchnick, Morgan
Kaufmann, 1997. Guides professionals and graduate students in designing and implementing
highly optimizing compilers for real-world languages. The author covers a wide range
of code optimizations, explaining how to determine the relative importance of the
optimizations and the most effective ways to implement them. He uses four case studies
of commercial compiling suites, including Sun Microsystem's for SPARC, IBM's for
POWER and PowerPC, DEC's for Alpha, and Intel's for Pentium and related processors,
to illustrate various approaches to compiler structure, intermediate-code design,
Programming Language Pragmatics, by Michael S. Scott, Morgan Kaufmann, 2000.
This book addresses the fundamental principles at work in the most important contemporary
languages, highlights the critical relationship between language design and language
implementation, and devotes special attention to issues of importance to the expert
programmer. Thanks to its rigorous but accessible teaching style, you'll emerge
better prepared to choose the best language for particular projects, to make more
effective use of languages you already know, and to learn new languages quickly
Compilers, by Alfred V. Aho, Ravi Sethi, Jeffrey D. Ullman, Addison-Wesley,
1986. The text begins with an introduction to the principal ideal behind compilation,
and then illustrates these ideas by constructing a simple one-pass compiler. The
remainder of the book amplifies the ideas presented in the first two chapters and
discusses more advanced topics such as syntax analysis, type checking, code generation,
and code optimization.
Writing Compilers and Interpreters, by Ronald Mak, Wiley, 1996. Grab hold
of your C++ because here you'll learn how to use it to write compilers and interpreters--
those programs that translate high-level computer code into machine-executable code.
The only C++-based book on compilers and interpreters available, this revised and
updated edition shows you the ABC's of reading and listing a program, breaking it
into tokens, parsing it, and examining its syntax. Then it shows you how to build
an actual interpreter, debugger, and finally, a compiler.
The Interpretation of Object-Oriented Programming Languages, by Iain Craig,
Springer-Verlag, 2000. While there are many books on particular languages, especially
C++ and Java, they tend to concentrate on how to program using that language and
their treatment of the semantics is highly languages-specific. A more wide-ranging
comparison of the various languages and their underlying concepts is lacking. The
Interpretation of Object-Oriented Programming Languages attempts to provides a comprehensive
treatment of the main approaches to object-oriented languages, including:- class-based,
prototype, and actor languages. This book will be useful for final year undergraduates/first
year postgraduates studying object-oriented programming, as well as research students
and others requiring a detailed account of object-oriented programming languages
and their central concepts.
Foundations of Object-Oriented Languages: Types and Semantics, by Kim B.
Bruce, MIT Press, 2002. In recent years, object-oriented programming has emerged
as the dominant computer programming style, and object-oriented languages such as
C++ and Java enjoy wide use in academia and industry. This text explores the formal
underpinnings of object-oriented languages to help the reader understand the fundamental
concepts of these languages and the design decisions behind them.
Essentials of Programming Languages - 2nd Ed., by Daniel P. Friedman, Mitchell
Wand, Christopher T. Haynes, MIT Press, 2001. This textbook offers a deep understanding
of the essential concepts of programming languages. The approach is analytic and
hands-on. The text uses interpreters, written in Scheme, to express the semantics
of many essential language elements in a way that is both clear and directly executable.
It also examines some important program analyses. Extensive exercises explore many
design and implementation alternatives.