Download the Full Version of textbook for Fast Typing at textbookfull.

com

Writing High Performance NET Code Ben Watson Et

Al.

https://textbookfull.com/product/writing-high-performance-
net-code-ben-watson-et-al/

OR CLICK BUTTON

DOWNLOAD NOW

Download More textbook Instantly Today - Get Yours Now at textbookfull.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

PRINCIPLES OF MACROECONOMICS 5E Ben Bernanke Et Al

https://textbookfull.com/product/principles-of-macroeconomics-5e-ben-
bernanke-et-al/

textboxfull.com

Anesthesiology David Longnecker Et Al.

https://textbookfull.com/product/anesthesiology-david-longnecker-et-
al/

textboxfull.com

Management John R. Schermerhorn Et Al.

https://textbookfull.com/product/management-john-r-schermerhorn-et-al/

textboxfull.com

Financial Accounting John Hoggett Et Al.

https://textbookfull.com/product/financial-accounting-john-hoggett-et-
al/

textboxfull.com
Stylish F#: Crafting Elegant Functional Code for .NET and
.NET Core 1st Edition Kit Eason

https://textbookfull.com/product/stylish-f-crafting-elegant-
functional-code-for-net-and-net-core-1st-edition-kit-eason/

textboxfull.com

Stylish F Crafting Elegant Functional Code for NET and NET

Core 1st Edition Kit Eason

https://textbookfull.com/product/stylish-f-crafting-elegant-
functional-code-for-net-and-net-core-1st-edition-kit-eason-2/

textboxfull.com

Heinemann Biology 2 Philip Batterham Et Al.

https://textbookfull.com/product/heinemann-biology-2-philip-batterham-
et-al/

textboxfull.com

Paediatric dentistry Richard Welbury Et Al. (Eds.)

https://textbookfull.com/product/paediatric-dentistry-richard-welbury-
et-al-eds/

textboxfull.com

We the People Benjamin Ginsberg Et Al.

https://textbookfull.com/product/we-the-people-benjamin-ginsberg-et-
al/

textboxfull.com
Writing High-Performance
.NET Code
Ben Watson
Writing High-Performance
.NET Code
Writing High-Performance .NET Code
About the Author
Acknowledgements
Foreword
Introduction to the Second Edition
Introduction
Purpose of this Book
Why Should You Choose Managed Code?
Is Managed Code Slower Than Native Code?
Are The Costs Worth the Benefits?
Am I Giving Up Control?
Work With the CLR, Not Against It
Layers of Optimization
The Seductiveness of Simplicity
.NET Performance Improvements Over Time
.NET Core
Sample Source Code
Why Gears?
Performance Measurement and Tools
Choosing What to Measure
Premature Optimization
Average vs. Percentiles
Benchmarking
Useful Tools
Measurement Overhead
Summary
Memory Management
Memory Allocation
Garbage Collection Operation
 Configuration Options
Performance Tips
Investigating Memory and GC
Summary
JIT Compilation
Benefits of JIT Compilation
JIT in Action
JIT Optimizations
Reducing JIT and Startup Time
Optimizing JITting with Profiling (Multicore JIT)
When to Use NGEN
.NET Native
Custom Warmup
When JIT Cannot Compete
Investigating JIT Behavior
Summary
Asynchronous Programming
The Thread Pool
The Task Parallel Library
TPL Dataflow
Parallel Loops
Performance Tips
Thread Synchronization and Locks
Investigating Threads and Contention
Summary
General Coding and Class Design
Classes and Structs
Tuples
Interface Dispatch
Avoid Boxing
ref returns and locals
for vs. foreach
Casting
P/Invoke
Delegates
Exceptions
 dynamic
Reflection
Code Generation
Preprocessing
Investigating Performance Issues
Summary
Using the .NET Framework
Understand Every API You Call
Multiple APIs for the Same Thing
Collections
Strings
Avoid APIs that Throw Exceptions Under Normal Circumstances
Avoid APIs That Allocate From the Large Object Heap
Use Lazy Initialization
The Surprisingly High Cost of Enums
Tracking Time
Regular Expressions
LINQ
Reading and Writing Files
Optimizing HTTP Settings and Network Communication
SIMD
Investigating Performance Issues
Summary
Performance Counters
Consuming Existing Counters
Creating a Custom Counter
Summary
ETW Events
Defining Events
Consume Custom Events in PerfView
Create a Custom ETW Event Listener
Get Detailed EventSource Data
Consuming CLR and System Events
Custom PerfView Analysis Extension
Summary
Code Safety and Analysis
 Understanding the OS, APIs, and Hardware
Restrict API Usage in Certain Areas of Your Code
Centralize and Abstract Performance-Sensitive and Difficult Code
Isolate Unmanaged and Unsafe Code
Prefer Code Clarity to Performance Until Proven Otherwise
Summary
Building a Performance-Minded Team
Understand the Areas of Critical Performance
Effective Testing
Performance Infrastructure and Automation
Believe Only Numbers
Effective Code Reviews
Education
Summary
Kick-Start Your Application’s Performance
Define Metrics
Analyze CPU Usage
Analyze Memory Usage
Analyze JIT
Analyze Asynchronous Performance
Higher-Level Performance
ASP.NET
ADO.NET
WPF
Big O
Common Algorithms and Their Complexity
Bibliography
Useful Resources
People and Blogs
Contact Information
Writing High-Performance
.NET Code
Writing High-Performance .NET Code

Version 2.0

Smashwords Edition

ISBN-13: 978-0-990-58349-3

ISBN-10: 0-990-58349-X

Copyright © 2018 Ben Watson

All Rights Reserved. These rights include reproduction, transmission,

translation, and electronic storage. For the purposes of Fair Use,
brief excerpts of the text are permitted for non-commercial
purposes. Code samples may be reproduced on a computer for the
purpose of compilation and execution and not for republication.

This eBook is licensed for your personal and professional use only.
You may not resell or give this book away to other people. If you
wish to give this book to another person, please buy an additional
copy for each recipient. If you are reading this book and did not
purchase it, or it was not purchased for your use only, then please
purchase your own copy. If you wish to purchase this book for your
organization, please contact me for licensing information. Thank you
for respecting the hard work of this author.

Trademarks

Any trademarked names, logos, or images used in this book are

assumed valid trademarks of their respective owners. There is no
intention to infringe on the trademark.

Disclaimer

While care has been taking to ensure the information contained in

this book is accurate, the author takes no responsibility for your use
of the information presented.

Contact

For more information about this book, please visit

http://www.writinghighperf.net or email
[email protected].

Cover Design

Cover design by Claire Watson, http://www.bluekittycreations.co.uk.

About the Author
Ben Watson has been a software engineer at Microsoft since 2008.
On the Bing platform team, he has built one of the world’s leading
.NET-based, high-performance server applications, handling high-
volume, low-latency requests across thousands of machines for
millions of customers. In his spare time, he enjoys books, music, the
outdoors, and spending time with his wife Leticia and children Emma
and Matthew. They live near Seattle, Washington, USA.
Acknowledgements
Thank you to my wife Leticia and our children Emma and Matthew
for their patience, love, and support as I spent yet more time away
from them to come up with a second edition of this book. Leticia
also did significant editing and proofreading and has made the book
far more consistent than it otherwise would have been.

Thank you to Claire Watson for doing the beautiful cover art for both
book editions.

Thank you to my mentor Mike Magruder who has read this book
perhaps more than anyone. He was the technical editor of the first
edition and, for the second edition, took time out of his retirement to
wade back into the details of .NET.

Thank you to my beta readers who provided invaluable insight into

wording, topics, typos, areas I may have missed, and so much more:
Abhinav Jain, Mike Magruder, Chad Parry, Brian Rasmussen, and
Matt Warren. This book is better because of them.

Thank you to Vance Morrison who read an early version of this and
wrote the wonderful Foreword to this edition.

Finally, thank you to all the readers of the first edition, who with
their invaluable feedback, have also helped contribute to making the
second edition a better book in every way.
Foreword
by Vance Morrison

Kids these days have no idea how good they have it! At the risk of
being branded as an old curmudgeon, I must admit there is more
than a kernel of truth in that statement, at least with respect to
performance analysis. The most obvious example is that “back in my
day” there weren’t books like this that capture both the important
“guiding principles” of performance analysis as well as the practical
complexities you encounter in real world examples. This book is a
gold mine and is worth not just reading, but re-reading as you do
performance work.

For over 10 years now, I have been the performance architect for
the .NET Runtime. Simply put, my job is to make sure people who
use C# and the .NET runtime are happy with the performance of
their code. Part of this job is to find places inside the .NET Runtime
or its libraries that are inefficient and get them fixed, but that is not
the hard part. The hard part is that 90% of the time the
performance of applications is not limited by things under the
runtime’s control (e.g., quality of the code generation, just in time
compilation, garbage collection, or class library functionality), but by
things under the control of the application developer (e.g.,
application architecture, data structure selection, algorithm selection,
and just plain old bugs). Thus my job is much more about teaching
than programming.

So a good portion of my job involves giving talks and writing articles,

but mostly acting as a consultant for other teams who want advice
about how to make their programs faster. It is in the latter context
that I first encountered Ben Watson over 6 years ago. He was “that
guy on the Bing team” who always asked the non-trivial questions
(and finds bugs in our code not his). Ben was clearly a “performance
guy.” It is hard to express just how truly rare that is. Probably 80%
of all programmers will probably go through most of their career
having only the vaguest understanding of the performance of the
code they write. Maybe 10% care enough about performance that
they learned how to use a performance tool like a profiler at all. The
fact that you are reading this book (and this Foreword!) puts you
well into the elite 1% that really care about performance and really
want to improve it in a systematic way. Ben takes this a number of
steps further: He is not only curious about anything having to do
with performance, he also cares about it deeply enough that he took
the time to lay it out clearly and write this book. He is part of the
.0001%. You are learning from the best.

This book is important. I have seen a lot of performance problems in

my day, and (as mentioned) 90% of the time the problem is in the
application. This means the problem is in your hands to solve. As a
preface to some of my talks on performance I often give this
analogy: Imagine you have just written 10,000 lines of new code for
some application, and you have just gotten it to compile, but you
have not run it yet. What would you say is the probability that the
code is bug free? Most of my audience quite rightly says zero.
Anyone who has programmed knows that there is always a non-
trivial amount of time spent running the application and fixing
problems before you can have any confidence that the program
works properly. Programming is hard, and we only get it right
through successive refinement. Okay, now imagine that you spent
some time debugging your 10,000-line program and now it
(seemingly) works properly. But you also have some rather non-
trivial performance goals for your application. What you would say
the probability is that it has no performance issues? Programmers
are smart, so my audience quickly understands that the likelihood is
also close to zero. In the same way that there are plenty of runtime
issues that the compiler can’t catch, there are plenty of performance
issues that normal functional testing can’t catch. Thus everyone
needs some amount of “performance training” and that is what this
book provides.
Another sad reality about performance is that the hardest problems
to fix are the ones that were “baked into” the application early in its
design. That is because that is when the basic representation of the
data being manipulated was chosen, and that representation places
strong constraints on performance. I have lost count of the number
of times people I consult with chose a poor representation (e.g.,
XML, or JSON, or a database) for data that is critical to the
performance of their application. They come to me for help very late
in their product cycle hoping for a miracle to fix their performance
problem. Of course I help them measure and we usually can find
something to fix, but we can’t make major gains because that would
require changing the basic representation, and that is too expensive
and risky to do late in the product cycle. The result is the product is
never as fast as it could have been with just a small amount of
performance awareness at the right time.

So how do we prevent this from happening to our applications? I

have two simple rules for writing high-performance applications
(which are, not coincidentally, a restatement of Ben’s rules):

1. Have a Performance Plan

2. Measure, Measure, Measure

The “Have a Performance Plan” step really boils down to “care about
perf.” This means identifying what metric you care about (typically it
is some elapsed time that human beings will notice, but occasionally
it is something else), and identifying the major operations that might
consume too much of that metric (typically the “high volume” data
operation that will become the “hot path”). Very early in the project
(before you have committed to any large design decision) you
should have thought about your performance goals, and measured
something (e.g., similar apps in the past, or prototypes of your
design) that either gives you confidence that you can reach your
goals or makes you realize that hitting your perf goals may not be
easy and that more detailed prototypes and experimentation will be
necessary to find a better design. There is no rocket science here.
Indeed some performance plans take literally minutes to complete.
The key is that you do this early in the design so performance has a
chance to influence early decisions like data representation.

The “Measure, Measure, Measure” step is really just emphasizing

that this is what you will spend most of your time doing (as well as
interpreting the results). As “Mad-Eye” Moody would say, we need
“constant vigilance.” You can lose performance at pretty much any
part of the product cycle from design to maintenance, and you can
only prevent this by measuring again and again to make sure things
stay on track. Again, there is no rocket science needed—just the will
to do it on an ongoing basis (preferably by automating it).

Easy right? Well here is the rub. In general, programs can be

complex and run on complex pieces of hardware with many
abstractions (e.g., memory caches, operating systems, runtimes,
garbage collectors, etc.), and so it really is not that surprising that
the performance of such complex things can also be complex. There
can be a lot of important details. There is an issue of errors, and
what to do when you get conflicting or (more often) highly variable
measurements. Parallelism, a great way to improve the performance
of many applications also makes the analysis of that performance
more complex and subject to details like CPU scheduling that
previously never mattered. The subject of performance is a many-
layered onion that grows ever more complex as you peel back the
layers.

Taming that complexity is the value of this book. Performance can be

overwhelming. There are so many things that can be measured as
well as tools to measure them, and it is often not clear what
measurements are valuable, and what the proper relationship among
them is. This book starts you off with the basics (set goals that you
care about), and points you in the right direction with a small set of
tools and metrics that have proven their worth time and time again.
With that firm foundation, it starts “peeling back the onion” to go
into details on topics that become important performance
considerations for some applications. Topics include things like
memory management (garbage collection), “just in time” (JIT)
compilation, and asynchronous programming. Thus it gives you the
detail you need (runtimes are complex, and sometimes that
complexity shows through and is important for performance), but in
an overarching framework that allows you to connect these details
with something you really care about (the goals of your application).

With that, I will leave the rest in Ben’s capable hands. The goal of
my words here are not to enlighten but simply motivate you.
Performance investigation is a complex area of the already complex
area of computer science. It will take some time and determination
to become proficient in it. I am not here to sugar-coat it, but I am
here to tell you that it is worth it. Performance does matter. I can
almost guarantee you that if your application is widely used, then its
performance will matter. Given this importance, it is almost a crime
that so few people have the skills to systematically create high-
performance applications. You are reading this now to become a
member of this elite group. This book will make it so much easier.

Kids these days—they have no idea how good they have it!

Vance Morrison

Performance Architect for the .NET Runtime

Microsoft Corporation
Introduction to the Second
Edition
The fundamentals of .NET performance have not changed much in
the years since the first edition of Writing High-Performance .NET
Code. The rules of optimizing garbage collection still remain largely
the same. JIT, while improving in performance, still has the same
fundamental behavior. However, there have been at least five new
point releases of .NET since the previous edition, and they deserve
some coverage where applicable.

Similarly, this book has undergone considerable evolution in the

intervening years. In addition to new features in .NET, there were
occasional and odd omissions in the first edition that have been
corrected here. Nearly every section of the book saw some kind of
modification, from the very trivial to significant rewrites and inclusion
of new examples, material, or explanation. There are too many
modifications to list every single one, but some of the major changes
in this edition include:

Overall 50% increase in content.

Fixed all known errata.
Incorporated feedback from hundreds of readers.
New Foreword by .NET performance architect Vance Morrison.
Dozens of new examples and code samples throughout.
Revamped diagrams and graphics.
New typesetting system for print and PDF editions.
Added a list of CLR performance improvements over time.
Described more analysis tools.
Significantly increased the usage of Visual Studio for analyzing
.NET performance.
Numerous analysis examples using
Microsoft.Diagnostics.Runtime (“CLR MD”).
 Added more content on benchmarking and used a popular
benchmarking framework in some of the sample projects.
New sections about CLR and .NET Framework features related
to performance.
More on garbage collection, including new information on
pooling, stackalloc, finalization, weak references, finding
memory leaks, and much more.
Expanded discussion of different code warmup techniques.
More information about TPL and a new section about TPL
Dataflow.
Discussion of ref-returns and locals.
Significantly expanded discussion of collections, including initial
capacity, sorting, and key comparisons.
Detailed analysis of LINQ costs.
Examples of SIMD algorithms.
How to build automatic code analyzers and fixers.
An appendix with high-level tips for ADO.NET, ASP.NET, and
WPF.
…and much more!

I am confident that, even if you read the first edition, this second
edition is more than worth your time and attention.
Introduction
Purpose of this Book
.NET is an amazing system for building software. It allows us to
build functional, connected apps in a fraction of the time it would
have taken us years ago. So much of it just works, and that is a
great thing. It offers applications memory and type safety, a robust
framework library, services like automatic memory management, and
so much more.

Programs written with .NET are called managed applications because

they depend on a runtime and framework that manages many of
their vital tasks and ensures a basic safe operating environment.
Unlike unmanaged, or native, software written directly to the
operating system’s APIs, managed applications do not have free
reign of their processes.

This layer of management between your program and the

computer’s processor can be a source of anxiety for developers who
assume that it must add some significant overhead. This book will
set you at ease, demonstrate that the overhead is worth it, and that
the supposed performance degradation is almost always
exaggerated. Often, the performance problems developers blame on
.NET are actually due to poor coding patterns and a lack of
knowledge of how to optimize their programs on this framework.
Skills gained from years of optimizing software written in C++, Java,
or Python may not always apply to .NET managed code, and some
advice is actually detrimental. Sometimes the rapid development
enabled by .NET can encourage people to build bloated, slow, poorly
optimized code faster than ever before. Certainly, there are other
reasons why code can be of poor quality: lack of skill generally, time
pressure, poor design, lack of developer resources, laziness, and so
on. This book will explicitly remove lack of knowledge about the
framework as an excuse and attempt to deal with some of the
others as well. With the principles explained in this book, you will
learn how to build lean, fast, efficient applications that avoid these
missteps. In all types of code, in all platforms, the same thing is
true: if you want performant code, you have to work for it.

Performance work should never be left for the end, especially in a

macro or architectural sense. The larger and more complex your
application, the earlier you need to start considering performance as
a major feature.

I often give the example of building a hut versus building a

skyscraper. If you are building a hut, it does not really matter at
what point you want to optimize some feature: Want windows? Just
cut a hole in the wall. Want to add electricity? Bolt it on. You have a
lot of freedom about when to completely change how things work
because it is simple, with few dependencies.

A skyscraper is different. You cannot decide you want to switch to

steel beams after you have built the first five floors out of wood. You
must understand the requirements up front as well as the
characteristics of your building materials before you start putting
them together into something larger.

This book is largely about giving you an idea of the costs and
benefits of your building materials, from which you can apply lessons
to whatever kind of project you are building.

This is not a language reference or tutorial. It is not even a detailed

discussion of the CLR. For those topics, there are other resources.
(See the end of the book for a list of useful books, blogs, and people
to pay attention to.) To get the most out of this book you should
already have in-depth experience with .NET.

There are many code samples, especially of underlying

implementation details in IL or assembly code. I caution you not to
gloss over these sections. You should try to replicate my results as
you work through this book so that you understand exactly what is
going on.

This book will teach you how to get maximum performance out of
managed code, while sacrificing none or as few of the benefits of
.NET as possible. You will learn good coding techniques, specific
things to avoid, and perhaps most importantly, how to use freely
available tools to easily measure your performance. This book will
teach you those things with minimum fluff. This book is what you
need to know, relevant and concise, with no padding of the content.
Most chapters begin with general knowledge and background,
followed by specific tips in a cook-book approach, and finally end
with a section on step-by-step measurement and debugging for
many different scenarios.

Along the way you will deep-dive into specific portions of .NET,
particularly the underlying Common Language Runtime (CLR) and
how it manages your memory, generates your code, handles
concurrency, and more. You will see how .NET’s architecture both
constrains and enables your software, and how your programming
choices can drastically affect the overall performance of your
application. As a bonus, I will share relevant anecdotes from the last
nine years of building very large, complex, high-performance .NET
systems at Microsoft. You will likely notice that my bias throughout
this book is for server applications, but nearly everything discussed
in this book is applicable to desktop, web, and mobile applications as
well. Where appropriate, I will share advice for those specific
platforms.

Understanding the fundamentals will give you the “why”

explanations that will allow the performance tips to make sense. You
will gain a sufficient understanding of .NET and the principles of
well-performing code so that when you run into circumstances not
specifically covered in this book, you can apply your newfound
knowledge and solve unanticipated problems.
Programming under .NET is not a completely different experience
from all the programming you have ever done. You will still need
your knowledge of algorithms and most standard programing
constructs are pretty much the same, but we are talking about
performance optimizations, and if you are coming from an
unmanaged programming mindset, there are very different things
you need to observe. You may not have to call delete explicitly any
more (hurray!), but if you want to get the absolute best
performance, you better believe you need to understand how the
garbage collector is going to affect your application.

If high availability is your goal, then you are going to need to be

concerned about JIT compilation to some degree. Do you have an
extensive type system? Interface dispatch might be a concern. What
about the APIs in the .NET Framework Class Library itself? Can any
of those negatively influence performance? Are some thread
synchronization mechanisms better than others? Have you
considered memory locality when choosing collections or algorithms?

Beyond pure coding, I will discuss techniques and processes to

measure your performance over time and build a culture of
performance in yourself and in your team. Good performance is not
something you do once and then move on. It needs constant
nourishment and care so that it does not degrade over time.
Investing in a good performance infrastructure will pay massive
dividends over time, allowing you to automate most of the grunt
work.

The bottom line is that the amount of performance optimization you

get out of your application is directly proportional to the amount of
understanding you have not only of your own code, but also your
understanding of the framework, the operating system, and the
hardware you run on. This is true of any platform you build upon.

All of the code samples in this book are in C#, the underlying IL, or
occasionally x86 or x64 assembly code, but all of the principles here
apply to any .NET language. Throughout this book, I assume that
you are using .NET 4.5 or higher, and some examples require newer
features only available in more recent versions. I strongly encourage
you to consider moving to the latest version so that you can take
advantage of the latest technologies, features, bug fixes, and
performance improvements.

I do not talk much about specific sub-frameworks of .NET, such as

WPF, WCF, ASP.NET, Windows Forms, Entity Framework, ADO.NET, or
countless others. While each of those frameworks has its own issues
and performance techniques, this book is about the fundamental
knowledge and techniques that you must master to develop code
under all scenarios in .NET. Once you acquire these fundamentals,
you can apply this knowledge to every project you work on, adding
domain-specific knowledge as you gain experience. I did add a small
appendix in the back, however, that can give you some initial
guidance if you are trying to optimize ASP.NET, ADO.NET, or WPF
applications.

Overall, I hope to show that performance engineering is just that:

engineering. It is not something you get for free on any platform,
not even .NET.

Why Should You Choose Managed

Code?
There are many reasons to choose managed code over unmanaged
code:

Safety: The compiler and runtime can enforce type safety

(objects can only be used as what they really are), boundary
checking, numeric overflow detection, security guarantees, and
more. There is no more heap corruption from access violations
or invalid pointers.
 Automatic memory management: No more delete or reference
counting.
Higher level of abstraction: Higher productivity with fewer bugs.
Advanced language features: Delegates, anonymous methods,
dynamic typing, and much more.
Huge existing code base: Framework Class Library, Entity
Framework, Windows Communication Framework, Windows
Presentation Foundation, Task Parallel Library, and so much
more.
Easier extensibility: With reflection capabilities, it is much easier
to dynamically consume late-bound modules, such as in an
extension architecture.
Phenomenal debugging: Exceptions have a lot of information
associated with them. All objects have metadata associated with
them to allow thorough heap and stack analysis in a debugger,
often without the need for PDBs (symbol files).

All of this is to say that you can write more code quickly, with fewer
bugs. You can diagnose what bugs you do have far more easily. With
all of these benefits, managed code should be your default pick.

.NET also encourages use of a standard framework. In the native

world, it is very easy to have fragmented development environments
with multiple frameworks in use (STL, Boost, or COM, for example)
or multiple flavors of smart pointers. In .NET, many of the reasons
for having such varied frameworks disappear.

While the ultimate promise of true “write once, run everywhere”

code is likely always a pipe dream, it is becoming more of a reality.
There are three main options for portability:

1. Portable Class Libraries allow you to target Windows Desktop,

Windows Store, and other types of applications with a single
class library. Not all APIs are available to all platforms, but there
is enough there to save considerable effort.
 2. .NET Core, which is a portable version of .NET that can run on
Windows, Linux, and MacOS. It can target standard PC apps,
mobile devices, data centers servers, or Internet-of-Things (IoT)
devices with a flexible, minimized .NET runtime. This option is
rapidly gaining popularity.

3. Using Xamarin (a set of tools and libraries), you can target

Android, iOS, MacOS, and Windows platforms with a single .NET
codebase.

Given the enormous benefits of managed code, consider unmanaged

code to have the burden of proof, if it is even an option. Will you
actually get the performance improvement you think you will? Is the
generated code really the limiting factor? Can you write a quick
prototype and prove it? Can you do without all of the features of
.NET? In a complex native application, you may find yourself
implementing some of these features yourself. You do not want to
be in the awkward position of duplicating someone else’s work.

Even so, there are legitimate reasons to disqualify .NET code:

Access to the full processor instruction set, particularly for

advanced data processing applications using SIMD instructions.
However, this is changing. See Chapter 6 for a discussion of
SIMD programming available in .NET.
A large existing native code base. In this case, you can consider
the interface between new code and the old. If you can easily
manage it with a clear API, consider making all new code
managed with a simple interop layer between it and the native
code. You can then transition the native code to managed code
over time.
Related to the the previous point: Reliance on native libraries or
APIs. For example, the latest Windows features will often be
available in the C/C++-based Windows SDK before there are
managed wrappers. Often, no managed wrappers exist for some
functionality.
 Hardware interfacing. Some aspects of interfacing with
hardware will be easier with direct memory access and other
features of lower-level languages. This can include advanced
graphics card capabilities for games.
Tight control over data structures. You can control the memory
layout of structures in C/C++ much more than in C#.

However, even if some of the above points apply to you, it does not
mean than all of your application must be unmanaged code. You can
quite easily mix the two in the same application for the best of both
worlds.

Is Managed Code Slower Than

Native Code?
There are many unfortunate stereotypes in this world. One of them,
sadly, is that managed code cannot be fast. This is not true.

What is closer to the truth is that the .NET platform makes it very
easy to write slow code if you are sloppy and uncritical.

When you build your C#, VB.NET, or other managed language code,
the compiler translates the high-level language to Intermediate
Language (IL) and metadata about your types. When you run the
code, it is just-in-time compiled (“JITted”). That is, the first time a
method is executed, the CLR will invoke the JIT compiler on your IL
to convert it to assembly code (e.g., x86, x64, ARM). Most code
optimization happens at this stage. There is a definite performance
hit on this first run, but after that you will always get the compiled
version. As we will see later, there are ways around this first-time hit
when it is necessary.

The steady-state performance of your managed application is thus

determined by two factors:
 1. The quality of the JIT compiler
2. The amount of overhead from .NET services

The quality of generated code is generally very good, with a few

exceptions, and it is getting better all the time, especially quite
recently.

In fact, there are some cases where you may see a significant
benefit from managed code:

Memory allocations: There is no contention for memory

allocations on the heap, unlike in native applications. Some of
the saved time is transferred to garbage collection, but even this
can be mostly erased depending on how you configure your
application. See Chapter 2 for a thorough discussion of garbage
collection behavior and configuration.
Fragmentation: Memory fragmentation that steadily gets worse
over time is a common problem in large, long-running native
applications. This is less of an issue in .NET applications
because the heap is less susceptible to fragmentation in the first
place and when it does happen, garbage collection will compact
the heap.
JITted code: Because code is JITted as it is executed, its
location in memory can be more optimal than that of native
code. Related code will often be co-located and more likely to fit
in a single memory page or processor cache line. This leads to
fewer page faults.

The answer to the question “Is managed code slower than native
code?” is an emphatic “No” in most cases. Of course, there are
bound to be some areas where managed code just cannot overcome
some of the safety constraints under which it operates. They are far
fewer than you imagine and most applications will not benefit
significantly. In most cases, the difference in performance is
exaggerated. In reality, hardware and architecture will often make a
bigger impact than language and platform choices.
It is much more common to run across code, managed or native,
that is in reality just poorly written code; e.g., it does not manage its
memory well, it uses bad patterns, it defies CPU caching strategies
or is otherwise unsuitable for good performance.

Are The Costs Worth the Benefits?

As with most things, there are costs and benefits to every choice. In
most cases, I have found that the benefits of managed code have
outweighed the costs. In fact, with intelligent coding, you can
usually avoid the worst cases of all those costs yet still gain the
benefits.

The cost of the services .NET provides is not free, but it is also lower
than you may expect. You do not have to reduce this cost to zero
(which is impossible); just reduce it to a low enough threshold that
other factors in your application’s performance profile are more
significant.

Feature Benefits
JITted Better
Code memory
locality,
reduced
memory
usage
Bounds Safe
Checking memory
access
(fewer
unfindable
bugs)
Feature Benefits
Type Easier
metadata debugging,
overhead rich
metadata,
reflection,
better
exception
handling,
easy static
analysis
Garbage Fast
Collection memory
allocation,
no bugs
with calling
delete, safe
pointer
access
(access
violations
are not
possible)

All of these can add up to some significant extra gains as well:

Higher software stability

Less downtime
Higher developer agility

Am I Giving Up Control?
One common objection to using managed code is that it can feel like
you are giving up too much control over how your program
executes. This is a particular fear of garbage collection, which occurs
at what feels like random and inconvenient times. For all practical
purposes, however, this is not actually true. Garbage collection is
largely deterministic, and you can significantly affect how often it
runs by controlling your memory allocation patterns, object scope,
and GC configuration settings. What you control is different from
native code, but the ability is certainly there.

Work With the CLR, Not Against It

People new to managed code often view things like the garbage
collector or the JIT compiler as something they have to “deal with”
or “tolerate” or “work around.” This is an unproductive way to look
at it. Getting great performance out of any system requires
dedicated performance work, regardless of the specific frameworks
you use. For this and other reasons, do not make the mistake of
viewing the GC and JIT as problems that you have to fight.

As you come to appreciate how the CLR works to manage your

program’s execution, you will realize that you can make many
performance improvements just by choosing to work with the CLR
rather than against it. All frameworks have expectations about how
they are used and .NET is no exception. Unfortunately, many of
these assumptions are implicit and the API does not, nor cannot,
prohibit you from making bad choices.

I dedicate a large portion of this book to explaining how the CLR

works so that your own choices may more finely mesh with what it
expects. This is especially true of garbage collection, for example,
which has very clearly delineated guidelines for optimal
performance. Choosing to ignore these guidelines is a recipe for
disaster. You are far more likely to achieve success by optimizing for
Exploring the Variety of Random
Documents with Different Content
a delight and a disappointment.... Shaw takes up the empty bladders
of life, the current commonplaces, the cant phrases, the windbags of
rodomontade, the hollow conventions, and the sham sentiments;
quietly he inserts his pin; and the thing collapses with a pop.”
The play was given six special matinée performances at the
London Court Theater in the latter part of 1904, and Arnold Daly has
since presented it in America.
 THE NOVELS AND OTHER
WRITINGS
SHAW’S four published novels both suffer and gain by the
widespread public interest in his plays; gain because this interest
serves to keep them somewhat in the foreground, and suffer
because, as the work of a very young man, they are ill-fitted to stand
comparison with the literary offspring of his maturity. Of the four,
“Love Among the Artists” is the best and “Cashel Byron’s Profession”
the most popular. “An Unsocial Socialist” is a wild extravaganza that
has lived its day and done its task, and “The Irrational Knot” is
forgotten. The author’s first novel, written in his early twenties, has
never seen the light. The publishers of that time would have none of
it, and later on, when Shaw “copy” began to find a market and there
even arose a mild demand for it, Shaw wisely decided that the
yellowing manuscript should remain in the twilight of its tomb.
The hero of “Cashel Byron’s Profession” has become one of the
most familiar characters of latter-day fiction. References to him are
made in the newspapers frequently and every time a star of the
roped arena marries a chorus girl the love making of Mr. Byron is
recalled. He was not the first bruiser to grace the pages of an
English romance—as admirers of “Pendennis” and The Spectator
well know—but he has become, by long odds, the most
conspicuous. It is to be deplored that Shaw did not save him for a
play. “The Admirable Bashville,” a burlesque dramatization of the
novel, does not answer. Cashel should be the hero of a melodrama a
la “Arms and the Man.” What an opportunity he would give to our
Greek god stars!
Cashel is the son of an actress and becoming tired of her
variable moods and the exactions of his instructors, runs away from
boarding school in England and journeys to Australia. There, by
chance, he is taken into the household of Mr. “Ned” Skene, an
eminent retired pugilist, as secretary and gymnasium assistant. The
alert Skene discerns in him a rare “find” and before long he is back in
England again, battling his way to fame and fortune.
Before long, through one Lord Worthington, a man of vast
acquaintance and catholic taste, Cashel is introduced to the notice of
Miss Lydia Carew, a young Englishwoman of huge fortune and most
marvellous intellectuality. It is not until page 189—more than half
way through the 330 page book—that Lydia learns that Cashel is a
prize-fighter. Very naturally she recoils from him, but all the while,
half-unconsciously, she has been falling desperately in love with him,
and in the end, despite his profession, she marries him.
“I practically believe,” she explains to his rejected rival, “in the
doctrine of heredity; and as my body is frail and my brain morbidly
active, I think my impulse toward a man strong in body and
untroubled in mind is a trustworthy one. You can understand that; it
is a plain proposition in eugenics.”
And so Cashel retires from the ring and gradually, though never
completely, takes on the polish of civilization. It is a union so happy
that it soon descends into the commonplace.
The author was born with the dramatic instinct of a Sardou or a
Hal Reid and throughout the book there are scenes of tremendous
excitement and clatter. Cashel fights fairly terrific battles—among
others one with Miss Carew’s footman, Bashville, who also loves her
—and the general air of the book is distinctly warlike. Most of the
minor characters are commonplace. Skene and his wife and Lord
Worthington are old friends from Thackeray and Lucian Webber,
Lydia’s cousin and unsuccessful Romeo, is the ready-made rising
young statesman of contemporary English fiction.
“An Unsocial Socialist” is a tract born of the nights that Shaw
passed in pondering the philosophies. All of the ten articles in the
manifesto of 1845 are preached in it, and in addition there is much
that the Hon. “Tom” Watson, the Hon. Eugene Debs, and various
other earnest gentlemen were destined to spout forth years later. “I
suppose,” says Max Beerbohm, “that there is not under heaven a
subject on which Shaw has not thought deeply and indignantly.” “An
Unsocial Socialist” justifies this venture. It is the most riotous hodge-
podge of cart-tail oratory and low comedy in the language.
Sidney Trefusis, a millionaire, takes to wife Henriette Jansenius,
the daughter of a millionaire, and after a brief honeymoon bids her
good-bye. He is no ordinary money-king, this strange young man,
but a Rothschild with the ideas of a Marx. The times, he decides, are
out of joint. Things have grown rotten in Denmark. To live as men of
his fortune live would be to give his tacit consent to the immoral
scheme of things. And so he deserts his wife, assumes the name of
Smilash, and going to a small country town, sets up shop as the
local jack-of-all-trades.
From this point on, for a hundred pages, the book is a socialist
tract. To his wife, who pursues him, and to everyone else he
encounters—the faculty and student body of a refined young ladies’
seminary, the village politicians, chance passersby, enemies, and
friends—he expounds his theories. Also—and this is what makes
him rise from the common level of propagandists—he practices
many (though not all) of the things he preaches. In the end, his
neglect kills his wife and he goes ranging England in search of a real
affinity. When he finds her he marries her and the book ends—with a
most marvellous letter from the hero to the author.
As in the case of “The Philanderer” a great many persons have
wondered how Shaw could make such a ridiculous character of a
man whose doctrines apparently coincide with his own. In truth, it is
highly improbable that Shaw, or any other sane man, ever held to the
ideas expressed by Trefusis. The latter’s speech beside the corpse
of his wife is without parallel in fiction. And some of his other
utterances and acts—how royally and deliciously sacrilegious they
are! Certainly an age that finds Schopenhauer’s essay on women a
never-ending delight should be better acquainted with the ecstatic
shocks of “An Unsocial Socialist.” Trefusis, being utterly beyond the
pale, is as productive of wicked little thrills to the orthodox and
virtuous as McIntosh Jellaludin, David, Pantagruel, or the latest
popular murderer.
 “The Irrational Knot”—the theme of which is evident from the title
—is now but a name. It was one of a vast multitude of similar books
that saw the light at the time of its birth. Not one of the reviewers,
eulogists or enemies of Shaw seems to think much of it. “Love
Among the Artists,” on the contrary, is a novel that deserves to rank
with the really important fiction of the time. The theme is not
startlingly original and in the 400-odd pages there are oceans of
tiresome talk, but the work, as a whole, bears the stamp of
distinction, and if only for the admirable searching portrait of the
Polish pianiste, Aurélie Szczympliça, it deserves some share of
attention.
The story has the amiably discursive cast of the other Shaw
stories and ill bears translation into a brief summary. Adrian Herbert,
an artist, is a character about whom others, in a sense, revolve,
though, in himself, he is little interesting. At the start he is affianced
to Mary Sutherland, a young woman of artistic longings. The chief
business of the book is to show how he is won away from Mary by
the Szczympliça and duly and regularly married by that remarkable
young woman. As for Mary, she finds consolation in the arms of John
Hoskyn, an eminently practical and matter-of-fact gentleman, who
wanders into Bohemia quite by accident, and is much astonished by
what he sees there.
Shaw was a newcomer in Bohemia himself when he wrote this
book and to this fact may be ascribed the freshness and virility of
some of the characters—the Szczympliça in particular, and Owen
Jack, the eccentric composer. In the former the vagaries of the
artistic mind are revealed with considerable originality and delicacy.
If he was tempted to make a burlesque of the soulful little Aurélie, he
kept a tight rein upon the impulse. Jack, on the contrary, is frankly a
figure out of low comedy. Nothing more grotesque than his struggles
with the Philistines is to be found in any of the Shaw plays. Like
Cashel Byron, he and Aurélie deserve to be translated from the
closet to the stage. Jack especially is sufficiently obvious to give any
comedian of fair talents the opportunity of a lifetime.
Shaw’s pair of critical pamphlets—“The Perfect Wagnerite” and
“The Quintessence of Ibsenism”—will go down into history beside
Robert Schumann’s early reviews of the compositions of Chopin and
Huxley’s opening broadsides for Darwin. Each paved the way for
better knowledge and better understanding. In 1888, when “The
Perfect Wagnerite” was published, the composer of “The Ring of the
Nibelung” was still caviare to the Britons. The professors of the day
knew him and feared that the great gaping public would come to
know him, and so, like the ancient monks who kept the Scriptures
under lock and key, they greatly desired that he be ignored. Shaw
undertook the vain task of proving the younger Siegfried a socialist—
and succeeded in making his readers meditate upon Wagner. Thus
he earned whatever money and fame he got from his pains.
“The Quintessence of Ibsenism” includes some wonderfully
illuminative and searching passages, but on the whole it is rather out
of date. Shaw makes the Norwegian a social-philosopher of most
earnest purposes, and hangs upon the book an elaborate and
ingenious theory of sham-smashing. As a matter of fact, we have
Ibsen’s own word for it that few of his plays contain much conscious
preaching, and no doubt many of the alarming doctrines Shaw found
in them were not there before he conjured them up. Nevertheless,
the book remains the best estimate of Ibsen yet written in English.
Incidentally, it gave birth to the tumultuous discussion of the so-
called “symbolic” play which raged over England and America half a
dozen years ago. Nowadays one hears little of “symbolism” and
even the comic papers have ceased to regard Ibsen and his
company as men who write in mysterious cryptograms. But persons
who follow the trend of things dramatic remember the disputations
that once awoke the echoes. You will find the germ of them in
Shaw’s half-forgotten discourses upon “Brand,” “Peer Gynt,” and
“Emperor and Galilean.”
In the early ’90’s, when Max Nordau’s mighty tome,
“Degeneration,” was making a stir like a new best-selling novel,
Shaw published a counter-blast to it. Even exceeding Nordau in the
minuteness of his knowledge, he made an answer that, in the words
of one admirer, “wiped Nordau off the field of discussion.” Unhappily,
this effort at regeneration has been forgotten with “Degeneration.”
 Shaw’s remarkable essay “On Going to Church,” which was
recently republished in book form, is an earnest plea for less
humbug in public worship. The average church, he argues, is so
hopelessly ugly, tawdry, and irritating, that it straightway dissipates
any religious emotion the stray comer may harbor when he enters.
The socialistic and political essays, while by no means
unimportant to the students of the Shaw plays, are scarcely within
the province of this book.
 BIOGRAPHICAL AND STATISTICAL

I
GEORGE BERNARD SHAW was born in Dublin, July 26, 1856. His
paternal grandfather, Bernard Shaw, was high sheriff of County
Kilkenny, and his maternal grandfather, Walter Bagnall Gurley, a
county ’squire and fox hunter, with an extensive, but entailed estate.
Shaw’s father was a younger son and, in consequence, no
millionaire. But that he was a pauper or that the dramatist, in his
youth, was attracted to vegetarianism because, as James Huneker
hints, cabbages are cheaper than venison, there is no reason to
believe. When the family came to London, in 1876, it took up
quarters in “a well furnished house in a pleasant part” of the city. This
upon the authority of Mr. Stanley Shaw, a relative, in a letter to the
New York Sun, dated Berlin, April 25, 1905.
The Shaws then, were country gentlemen, and in all probability
little different from the other Irish gentry about them. The son of the
younger son was educated and reared in the orthodox fashion. He
learned the speech of the Irish aristocracy and the foreign tongues in
favor—English, French, and maybe a bit of German; he mastered
the three R’s, he studied the history of his country, and went to
church. “When I was a little boy,” he says in his essay “On Going to
Church,” “I was compelled to go on Sunday; and though I escaped
from that intolerable bondage before I was ten, it prejudiced me so
violently against church-going that twenty years elapsed before, in
foreign lands and in pursuit of works of art, I became once more a
church-goer. To this day, my flesh creeps when I recall that genteel
suburban Irish Protestant church, built by Roman Catholic workmen
who would have considered themselves damned had they crossed
its threshold afterward....” A virtuous, commonplace family. Its
present head, says the Mr. Stanley Shaw aforesaid, “is Major Sir
Frederick Shaw, Bart., D. S. O. of Bushey Park, Dublin.” A
respectable, well-sounding name and address.

II
Shaw was twenty when he reached London—the meditative,
impressionable, speculative, iconoclastic age. Apparently he fell an
easy prey to the philosophical anarchists who then held the centre of
the stage—Proudhon, Lassalle, Marx, Louis Blanc, Engels,
Liebknecht, and the lesser Germans. Certainly it was a day of
stimulating stirring about. Huxley and Spencer were up to their necks
in gore; Ibsen, with “The League of Youth” behind him, was giving
form to “The Pillars of Society” and “A Doll’s House”; Nietzsche was
tramping up and down his garden path; Wagner was hard at work;
“The Principles of Sociology” had just come from the press. Sham-
smashing was in the air. Everything respectable was under
suspicion.
It didn’t take Shaw long to spring out of the audience upon the
stage. His first novel, in truth, must have been begun long before he
learned to find his way about the streets of London. Whether it was
good or bad the human race will never know; publishers declined it
without thanks, and the author, when his manuscripts began to have
a value, decided that it should remain unpublished. “It was a very
remarkable work,” he says, “but hardly one which I should be well
advised in letting loose whilst my livelihood depends on my credit as
a literary workman. I can recall a certain difficulty, experienced even
while I was writing the book, in remembering what it was about....”
Thus heavily did his theme bear down upon him.
What the young Irishman did to relieve his imagination during the
next three years is not recorded. That he learned a great deal,
particularly of music and literature, is very probable. His sister was a
professional singer, and the persons he met were chiefly of the
literary-artistic sort. He was “but an infant of twenty-four, when, being
at that time one of the unemployed” he essayed to mend his
“straitened fortunes” by writing his second novel, “The Irrational
Knot.” It was no masterpiece, but if the few persons who glanced
through it possessed prophetic eyes they must have seen in it marks
of a genius rather startling. A year later came “Love Among the
Artists”—a volume of nearly 500 pages. Then, in order, came
“Cashel Byron’s Profession” and “An Unsocial Socialist.” Not one of
these extraordinary tales struck the fancy of the publishers. “An
encouraging compliment or two,” says Shaw, was his sole reward for
the fatiguing labor of writing them. Not until a good while afterward
did any of the five see the light, and then it was only “to fill up the
gaps in socialist magazines financed by generous friends.” “An
Unsocial Socialist” was the first to reach the dignity of covers. After it
came “Cashel Byron’s Profession” and “The Irrational Knot.” “Love
Among the Artists” was the last to appear upon the book stalls.

III
Meanwhile Shaw had become engaged in half a dozen reform
crusades. Vegetarianism found in him an early advocate and
socialism won him easily. In 1883, the year Karl Marx died, Thomas
Davidson, an American, laid the foundation of the Fabian Society at
a series of parlor conferences in London. In 1884 Shaw joined the
society, and four years later, when it began holding public meetings,
he found himself one of its leading lights. He has told us himself how
he delighted to indulge in eloquent socialistic orations from cart-tails
and how he came to acquire a bodyguard of faithful auditors whose
presence was assured whenever it was announced that he would
speak. With the pen, too, he labored for the manifesto of 1845, and
even to-day he is still hard at it—despite prosperity, the approach of
middle age and a fair imitation of the thing called fame. He wrote
tracts in great number and after 1889 edited the Fabian Essays.
Incidentally he wrote “Fabianism and the Empire” (1900), “Fabianism
and the Fiscal Question” (1904), and other socialistic broadsides. At
odd moments he had his say, too, upon the subjects of
vegetarianism, the use of quotation marks, capitalization, evening
clothes, capital punishment, and the eternal snobbishness of the
patriotic Britisher.
During all this time he was drawn nearer and nearer to the
theater. As far back as 1885 he began a play in collaboration with
William Archer, the translator of Ibsen. This drama, rewritten and
amplified seven years later, was the first of his works to be
performed in public. But the need of getting on in the world pressed
gloomily. “The question was,” Shaw has told us, “how to get a pound
a week.” Novel writing was plainly hopeless and play making
seemed equally impossible. There remained a chance to set up shop
as a critic. Shaw made the plunge and almost immediately his humor
and originality won him an audience. “Soon,” he says, “my privileges
were enormous and my wealth immense.... The classes patiently
read my essays; the masses patiently listened to my harangues. I
enjoyed the immunities of impecuniosity with the opportunities of a
millionaire....”
At the start Shaw’s regular topic was the art pictorial, but before
long he began to dabble in music. According to Max Beerbohm, his
first essay was printed in the first number of the Star in 1888. This
was a highly purposeful periodical, founded by T. P. O’Connor (“If we
enable the charwoman to put two lumps of sugar in her tea instead
of one,” said “Tay Pay,” in his salutatory, “we shall not have worked in
vain”), and Shaw wrote over the nom de plume of “Corno di
Bassetto.” In 1890, after two years’ service, he transferred his flag to
the World. Then, like his friend Huneker, he abandoned music for the
drama, and from January, 1895, to May, 1898, he was the critic of
the Saturday Review—the London weekly in whose columns the
ingenious Mr. Beerbohm now holds forth.

IV
 As has been noted, “Widowers’ Houses,” Shaw’s first play, was
completed in 1892. It was given its initial performance during that
year at the Royalty Theater, London, by the Independent Theater
Company, and made a rather strenuous success. “The socialists and
independents,” says Shaw, “applauded me furiously on principle; the
ordinary play-going first-nighters hooted me frantically on the same
ground; I, being at that time in some practice as what might be
unpolitely called a mob-orator, made a speech before the curtain; the
newspapers discussed the play for a whole fortnight, not only in the
ordinary theatrical notices and criticisms, but in leading articles and
letters; and finally the text of the play was published, with an
introduction by Mr. Grein (the manager of the Independent
Company), an amusing account by Mr. Archer of the original
collaboration, and a long preface and several elaborate controversial
appendices in the author’s most energetically egotistical fighting
style.”
“The Philanderer” was written in 1893, also for the Independent
Theater, and “Mrs. Warren’s Profession” was completed the same
year. The former was withdrawn because it was found well-nigh
impossible to unearth actors capable of understanding it sufficiently
to play it, and the latter remained in the manager’s desk because the
virtuous English play-censor forbade its performance. Nine years
later—January 12, 1902—it was presented privately by the Stage
Society.
In 1894 a group of philanthropic play-goers, convinced that the
dramas of the day were intolerable, financed a series of special
performances at the Avenue Theater, London. The second play
presented was Shaw’s “Arms and the Man.” It was given its premiere
April 21, and ran until July 7. Shaw, in his preface to the second
volume of “Plays Pleasant and Unpleasant” enters upon an
elaborate account of its receipts and the philosophy thereof. During
its brief season the Londoners paid $8,500 to see it and the cost of
presenting it, counting salaries, rents, lights, advertising, and
royalties, was nearly $25,000. Soon afterwards Richard Mansfield
presented the play in the United States and it made a very fair
success. It is in the Mansfield repertoire even to-day, and now and
then there is a matinée performance of it. But apparently the public
does not very vigorously demand it. In translation it has been done in
Germany.
“The Man of Destiny” was written in 1895. Two years later it was
given one performance at Croydon, England. Then it slumbered until
the last months of 1904, when Arnold Daly played it in New York as
an after-piece to “Candida.” Since then his company has appeared in
it in most of the large cities of the United States. “Candida” and “You
Never Can Tell” were written in 1896. The former was first played by
the Independent Theater Company, during a tour of the English
provinces, in 1897. Arnold Daly, scraping together $300, presented
it, in association with Winchell Smith, at the Berkeley Lyceum, a
diminutive theater in West 45th street, New York, in 1904. The
success of the drama was so great that before long Daly found
himself a Broadway star under the management of Liebler & Co.,
and at present it seems likely that Shaw’s plays will serve to keep
him in the public eye for a good while to come.
Shaw wrote a one-act piece, “How He Lied to Her Husband,” for
his young American interpreter, and when it was presented in New
York, in the fall of 1904, it made a great stir. “You Never Can Tell,”
which had been withdrawn by Shaw after being placed in rehearsal
in London, was given at the Garrick Theater by Daly at the
conclusion of the run of “Candida.” The two volumes of “Plays
Pleasant and Unpleasant” were published in 1898. They included
“Widowers’ Houses,” “The Philanderer,” “Mrs. Warren’s Profession,”
“Arms and the Man,” “You Never Can Tell,” “Candida,” and “The Man
of Destiny”—not to speak of a 37-page preface dealing with a vast
multitude of subjects.

V
“The Devil’s Disciple,” the first of the “Three Plays for Puritans,”
was written early in 1897. Richard Mansfield presented it in New
York in the fall of that year and it made an excellent success. Like
“Arms and the Man” it is still in his repertoire—pretty far down in the
trunk, it may be mentioned in passing, with many other plays atop of
it. In October, 1899, Murray Carson’s company played it for a few
weeks at Kensington, near London. “Cæsar and Cleopatra” was
written in 1898, and “Capt. Brassbound’s Conversion” the next year.
The “Three Plays for Puritans” were published in 1900. “The
Admirable Bashville, or Constancy Rewarded” was given by the
Stage Society at the Imperial Theatre in 1903. Shaw evolved it from
the fragments of “Cashel Byron’s Profession” to protect his rights in
the latter, an unauthorized dramatization having been made for an
American pugilist-actor. The play was printed as an appendix to the
second English edition of “Cashel Byron’s Profession.”
“Man and Superman” was written in 1902, and published the
next year, with a gigantic preface, and “The Revolutionist’s
Handbook and Pocket Companion” as an appendix. Preface, play,
and appendix make a volume of 244 closely-printed pages. The
drama saw the light on the evening of May 23, 1905, at the Court
Theater, London. Granville Barker, made up to resemble Shaw,
played the role of John Tanner, and Miss Lillian McCarthy was the
Ann Whitefield. May 21 and 22 there were special performances of
the play by the Stage Society, and in September, 1905, Robert
Loraine and his company presented it in New York. The third act with
the scene of Don Juan in Hell was omitted. “John Bull’s Other Island”
was completed in 1904, and presented at six special matinees at the
Court Theater by the Stage Society in the fall of that year. “Major
Barbara” was written in 1905.
Shaw’s two critical tracts, “The Perfect Wagnerite” and “The
Quintessence of Ibsenism” were published in 1888 and 1891,
respectively. His last scholastic manifesto, “The Common Sense of
Municipal Training” was issued in 1904. A remarkable essay, “On
Going to Church,” which appeared originally in the Savoy Quarterly
—Arthur Symons’ journal—in 1896, was reprinted early in 1905, and
attained a large sale. In the late ’80’s, in an English periodical, there
appeared his celebrated answer to Max Nordau’s book,
“Degeneration.” In the opinion of some of his admirers this is, by far,
the best of his controversial works, but, unfortunately, it has not been
reprinted in permanent form.
“When Arnold Daly visited Shaw,” says Gustav Kobbé, “he found
several indications that cynicism and Fabian socialism are not
unprofitable. Shaw lives in large apartments in the New Reform
Club, overlooking the Thames embankment, and he has a country
place at Welwin, too.... There is no sham in the interior of his places
of abode. There is a complete absence of the cheap æsthetic or of
superfluous ornamentation. Simplicity of outline distinguishes such
ornaments as there are. Handles, incrustations and the like are
eschewed. Shaw explained to Daly that he wished nothing in his
abode that would collect dust. Even rugs are tabooed.... Daly did not
find the author a poseur, but simply a man who was not an ordinary
man....”
That Shaw has a keen eye to business a great many aspiring
managers have discovered. He demands a royalty of 15 per cent. of
the gross receipts of his plays—considerably more than all but the
most famous dramatists receive—and is careful and unsentimental
in his negotiations. That he is now basking in the sun of prosperity is
very probable. Saving only Shakespeare, no English author was
better represented in the productions of the winter of 1904–5. In
addition Shaw is much in demand as a lecturer and has no difficulty
in finding a publisher for whatever he chooses to write. In 1898 he
inherited the entailed estate of his maternal grandfather, Walter
Bagnall Gurley. He was married the same year to Miss Charlotte
Frances Payne-Townshend.
“Who’s Who” says that Shaw’s favorite exercises are swimming
and cycling and that his recreation is “anything except sport.” He is
tall, lanky, and wears a shaggy, red beard. He affects loose fitting
flannel shirts and heaps his curses upon the dress suit. He is a
vegetarian, a socialist, and many other things of a heterodox,
fearsome sort. He uses the typewriter in preference to a pen, even
for correspondence. He has travelled in Europe and the Levant, and
may soon come to America. He refuses to use apostrophes in such
words as don’t and can’t, and affects thin spacing, after the German
style, instead of italics, to emphasize words. “Last season,” says the
sapient Mr. Daly, “he was a social freak; now he is a legitimate
amuser (sic!) of the people.”
And so much for George Bernard Shaw.
 SHAKESPEARE AND SHAW
SHAW’S notion that Shakespeare’s plays—or, at least, some of
them—have been left behind by the evolution of popular philosophy
and ideals is scarcely original with him. As he himself points out, the
Bard of Avon has been burned in hot critical fire for many years,
despite the “Shakespeare fanciers” who hold him as a god. Some of
his plays, says Shaw, were so far ahead of their time when they
were first presented that it has taken 300 years of theater-goers to
tire of the “long line of disgraceful farces, melodramas, and stage-
pageants which actor-managers, from Garrick and Cibber to our own
contemporaries, have hacked out of them,” and to understand
performances of the texts as the poet wrote them. By the same
token, those plays which Shakespeare himself “wrote down” to the
level of his audience have grown archaic in sentiment and character.
Dramas like “Anthony and Cleopatra,” says Shaw, will nevermore be
written, “nor relished by men in whose philosophy guilt and
innocence, and, consequently, revenge and idolatry, have no
meaning. Such men must rewrite all the old plays in terms of their
own philosophy....”
When this was published, as a preface to “Cæsar and
Cleopatra,” in “Three Plays for Puritans,” there was a volcanic critical
eruption, and ever since then the flames have roared about the
ingenious Irishman. He has delivered lectures explaining his
position, he has set forth his views, elaborately and carefully, in print,
and his admirers have gone to his rescue—but a large party of
Shakespeare worshipers insist on clinging to the belief that he has
attempted to drag the bard from his pedestal and himself climb upon
it. Recently, in London, he delivered a lecture designed to make
clear his idea. Next morning the London morning papers printed
amazingly confused reports of it, and to set himself right Shaw wrote
a letter to the Daily News containing 12 assertions, which, like the 95
theses Luther nailed upon the church door at Wittenberg, he desired
should make known the substance of his argument. Here they are:
“1. That the idolatry of Shakespeare which prevails now existed
in his own time, and got on the nerve of Ben Jonson.
“2. That Shakespeare was not an illiterate poaching laborer who
came up to London to be a horseboy, but a gentleman with all the
social pretensions of our higher bourgeoisie.
“3. That Shakespeare, when he became an actor, was not a
rogue and a vagabond, but a member and part proprietor of a
regular company, using, by permission, a nobleman’s name as its
patron, and holding itself as exclusively above the casual
barnstormer as a Harley Street consultant holds himself above a
man with a sarsaparilla stall.
“4. That Shakespeare’s aim in business was to make money
enough to acquire land in Stratford, and to retire as a country
gentleman with a coat of arms and a good standing in the county;
and that this was not the ambition of a parvenu, but the natural
course for a member of the highly respectable, though temporarily
impecunious, family of the Shakespeares.
“5. That Shakespeare found that the only thing that paid in the
theater was romantic nonsense, and that when he was forced by this
to produce one of the most effective samples of romantic nonsense
in existence—a feat which he performed easily and well—he publicly
disclaimed any responsibility for its pleasant and cheap falsehood by
borrowing the story and throwing it in the face of the public with the
phrase ‘As You Like It.’
“6. That when Shakespeare used that phrase he meant exactly
what he said, and that the phrase ‘What You Will,’ which he applied
to ‘Twelfth Night,’ meaning ‘Call it what you please,’ is not, in
Shakespearean or any other English, the equivalent of the perfectly
unambiguous and penetratingly simple phrase ‘As You Like It.’
“7. That Shakespeare tried to make the public accept real
studies of life and character in—for instance—‘Measure for Measure’
and ‘All’s Well That Ends Well’; and that the public would not have
them, and remains of the same mind still, preferring a fantastic sugar
doll, like Rosalind, to such serious and dignified studies of women as
Isabella and Helena.
“8. That the people who spoil paper and waste ink by describing
Rosalind as a perfect type of womanhood are the descendants of the
same blockheads whom Shakespeare, with the coat of arms and the
lands in Warwickshire in view, had to please when he wrote plays as
they liked them.
“9. Not, as has been erroneously stated, that I could write a
better play than ‘As You Like It,’ but that I actually have written much
better ones, and in fact, never wrote anything, and never intend to
write anything, half so bad in matter. (In manner and art nobody can
write better than Shakespeare, because, carelessness apart, he did
the thing as well as it can be done within the limits of human faculty.)
“10. That to anyone with the requisite ear and command of
words, blank verse, written under the amazingly loose conditions
which Shakespeare claimed, with full liberty to use all sorts of words,
colloquial, technical, rhetorical, and even obscurely technical, to
indulge in the most far-fetched ellipses, and to impress ignorant
people with every possible extremity of fantasy and affectation, is the
easiest of all known modes of literary expression, and that this is
why whole oceans of dull bombast and drivel have been emptied on
the head of England since Shakespeare’s time in this form by people
who could not have written ‘Box and Cox’ to save their lives. Also
(this on being challenged) that I can write blank verse myself more
swiftly than prose, and that, too, of full Elizabethan quality plus the
Shakespearian sense of the absurdity of it as expressed in the lines
of Ancient Pistol. What is more, that I have done it, published it, and
had it performed on the stage with huge applause.
“11. That Shakespeare’s power lies in his enormous command of
word music, which gives fascination to his most blackguardly
repartees and sublimity to his hollowest platitudes.
“12. That Shakespeare’s weakness lies in his complete
deficiency in that highest sphere of thought, in which poetry
embraces religion, philosophy, morality, and the bearing of these on
communities, which is sociology. That his characters have no
religion, no politics, no conscience, no hope, no convictions of any
sort. That there are, as Ruskin pointed out, no heroes in
Shakespeare. That his test of the worth of life is the vulgar hedonic
test and that since life cannot be justified by this or any other
external test, Shakespeare comes out of his reflective period a
vulgar pessimist, oppressed with a logical demonstration that life is
not worth living, and only surpassing Thackeray in respect to being
fertile enough, instead of repeating ‘Vanitas vanitatum’ at second
hand to work the futile doctrine differently and better in such
passages as ‘Out, out, brief candle.’”
These twelve articles merely serve to arouse a new storm of
discussion and Shaw profited much thereby in the advertising it gave
him. In May, 1905, the controversy had reached such a height that
J. B. Fagan, a young English dramatist, wrote a burlesque about it.
The piece was called “Shakespeare vs. Shaw” and was presented at
the Haymarket Theater, London. The scene of the one act was a
courtroom, in which the case between the two playwrights was being
tried. James Welsh, Miss Winifred Emery, Cyril Maude, and other
prominent players were in the cast and the little revue evidently
made a fair success. At all events, its presentation was a rather
significant thing. Few dramatists, in their lifetimes, see plays written
about them.
THE END
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!

textbookfull.com