Download Full Version ebookmass - Visit ebookmass.

com

Functional Programming in R 4 - Second Edition

Thomas Mailund

https://ebookmass.com/product/functional-programming-
in-r-4-second-edition-thomas-mailund/

OR CLICK HERE

DOWLOAD NOW

Discover More Ebook - Explore Now at ebookmass.com

 Instant digital products (PDF, ePub, MOBI) ready for you
Download now and discover formats that fit your needs...

Functional Programming in R 4: Advanced Statistical

Programming for Data Science, Analysis, and Finance Thomas
Mailund
https://ebookmass.com/product/functional-programming-in-r-4-advanced-
statistical-programming-for-data-science-analysis-and-finance-thomas-
mailund/
ebookmass.com

Mastering Functional Programming with Python Brett

Neutreon

https://ebookmass.com/product/mastering-functional-programming-with-
python-brett-neutreon/

ebookmass.com

Biblical Interpretation in Early Christian Gospels: Volume

4: The Gospel of John Thomas R. Hatina

https://ebookmass.com/product/biblical-interpretation-in-early-
christian-gospels-volume-4-the-gospel-of-john-thomas-r-hatina/

ebookmass.com

Lunchtime Chronicles: On the Rocks: Lunchtime Chronicles

Season 6 Tiya Rayne & Lunchtime Chronicles

https://ebookmass.com/product/lunchtime-chronicles-on-the-rocks-
lunchtime-chronicles-season-6-tiya-rayne-lunchtime-chronicles/

ebookmass.com
eTextbook 978-1337093224 American Government and Politics
Today, 2017-2018 Edition

https://ebookmass.com/product/etextbook-978-1337093224-american-
government-and-politics-today-2017-2018-edition/

ebookmass.com

Three Streams: Confucian Reflections on Learning and the

Moral Heart-Mind in China, Korea, and Japan Philip J
Ivanhoe
https://ebookmass.com/product/three-streams-confucian-reflections-on-
learning-and-the-moral-heart-mind-in-china-korea-and-japan-philip-j-
ivanhoe/
ebookmass.com

Americanist Approaches to The Book of Mormon Elizabeth

Fenton

https://ebookmass.com/product/americanist-approaches-to-the-book-of-
mormon-elizabeth-fenton/

ebookmass.com

Bratva Jewel (The Ivankov Brotherhood Book 6) Sabine

Barclay & Celeste Barclay

https://ebookmass.com/product/bratva-jewel-the-ivankov-brotherhood-
book-6-sabine-barclay-celeste-barclay/

ebookmass.com

Nietzsche on Conflict, Struggle and War (Modern European

Philosophy) James S. Pearson

https://ebookmass.com/product/nietzsche-on-conflict-struggle-and-war-
modern-european-philosophy-james-s-pearson/

ebookmass.com
Dental Implants for Hygienists and Therapists Ulpee R.
Darbar

https://ebookmass.com/product/dental-implants-for-hygienists-and-
therapists-ulpee-r-darbar/

ebookmass.com
Thomas Mailund

Functional Programming in R 4
Advanced Statistical Programming for Data Science,
Analysis, and Finance
2nd ed.
Thomas Mailund
Aarhus N, Denmark

ISBN 978-1-4842-9486-4 e-ISBN 978-1-4842-9487-1

https://doi.org/10.1007/978-1-4842-9487-1

© Thomas Mailund 2017, 2023

Apress Standard

The use of general descriptive names, registered names, trademarks,

service marks, etc. in this publication does not imply, even in the
absence of a specific statement, that such names are exempt from the
relevant protective laws and regulations and therefore free for general
use.

The publisher, the authors and the editors are safe to assume that the
advice and information in this book are believed to be true and accurate
at the date of publication. Neither the publisher nor the authors or the
editors give a warranty, express or implied, with respect to the material
contained herein or for any errors or omissions that may have been
made. The publisher remains neutral with regard to jurisdictional
claims in published maps and institutional affiliations.

This Apress imprint is published by the registered company APress

Media, LLC, part of Springer Nature.
The registered company address is: 1 New York Plaza, New York, NY
10004, U.S.A.
Any source code or other supplementary material referenced by the
author in this book is available to readers on GitHub
(https://github.com/Apress). For more detailed information, please
visit http://www.apress.com/source-code.
Acknowledgments
I would like to thank Duncan Murdoch and the people on the R-help
mailing list for helping me work out a kink in lazy evaluation in the
trampoline example.
Table of Contents
Chapter 1:​Introduction
Chapter 2:​Functions in R
Writing Functions in R
Named Parameters and Default Parameters
The “Gobble Up Everything Else” Parameter:​“.​.​.​”
Lazy Evaluation
Functions Don’t Have Names
Vectorized Functions
Infix Operators
Replacement Functions
Chapter 3:​Pure Functional Programming
Writing Pure Functions
Recursion As Loops
The Structure of a Recursive Function
Tail-Recursion
Runtime Considerations
Chapter 4:​Scope and Closures
Environments and Functions
Environment Chains, Scope, and Function Calls
Scopes, Lazy Evaluation, and Default Parameters
Nested Functions and Scopes
Closures
Reaching Outside Your Innermost Scope
Lexical and Dynamic Scope
Chapter 5:​Higher-Order Functions
 Currying
A Parameter Binding Function
Continuation-Passing Style
Thunks and Trampolines
Chapter 6:​Filter, Map, and Reduce
The General Sequence Object in R Is a List
Filtering Sequences
Mapping over Sequences
Reducing Sequences
Bringing the Functions Together
The Apply Family of Functions
sapply, vapply, and lapply
The apply Function
The tapply Function
Functional Programming in purrr
Filter-like Functions
Map-like Functions
Reduce-like Functions
Chapter 7:​Point-Free Programming
Function Composition
Pipelines
Chapter 8:​Conclusions
Index
About the Author
Thomas Mailund
is Senior Software Architect at Kvantify, a
quantum computing company from
Denmark. He has a background in math
and computer science. He now works on
developing algorithms for computational
problems applicable for quantum
computing. He previously worked at the
Bioinformatics Research Centre, Aarhus
University, on genetics and evolutionary
studies, particularly comparative
genomics, speciation, and gene flow
between emerging species. He has
published Beginning Data Science in R
with Apress, as well as other books out
there.
About the Technical Reviewer
Megan J. Hirni
is currently pursuing her PhD at the
University of Missouri-Columbia with a
focus on applied statistics research. In
addition to her love for R coding, Megan
loves meeting new people and learning
new topics in multifaceted fields.
© The Author(s), under exclusive license to APress Media, LLC, part of Springer
Nature 2023
T. Mailund, Functional Programming in R 4
https://doi.org/10.1007/978-1-4842-9487-1_1

1. Introduction
Thomas Mailund1
(1) Aarhus N, Denmark

Welcome to Functional Programming in R 4. I wrote this book to have

teaching material beyond the typical introductory level most textbooks
on R have, where functions are simple constructions for wrapping up
some reusable instructions that you can then call when you need those
instructions run. In languages such as R, functions are more than this.
They are objects in their own right that you can also treat as data,
create and manipulate and pass around like other objects, and learning
how to do this will make you a far more effective R programmer.
The R language is a multiparadigm language with elements from
procedural programming, object-oriented programming, and functional
programming. Procedural programming focuses on the instructions you
want the computer to execute—add these numbers, put the result in
this variable, loop through this list, etc. Object-oriented programming,
on the other hand, focuses on what kind of data you manipulate, which
operations you can perform on them, and how they change when you
manipulate them. If you are interested in these aspects of the R
language, I have written another book, Advanced Object-Oriented
Programming in R, also by Apress, that you might be interested in.
Functional programming is the third style of programming, where
the focus is on transformations. Functions transform data from input to
output, and by composing transformations, you construct programs
from simpler functions to more involved pipelines for your data. In
functional programming, functions themselves are considered data, and
just as with other data, you can write transformations that take
functions as input and produce (other) functions as output. You can
thus write simple functions, then adapt them (using other functions to
modify them), and combine them in various ways to construct complete
programs.
The R programming language supports procedural programming,
object-oriented programming, and functional programming, but it is
mainly a functional language. It is not a “pure” functional language.
Pure functional languages will not allow you to modify the state of the
program by changing values parameters hold and will not allow
functions to have side effects (and need various tricks to deal with
program input and output because of it).
R is somewhat close to “pure” functional languages. In general, data
is immutable, so changes to data inside a function do ordinarily not
alter the state of data outside that function. But R does allow side
effects, such as printing data or making plots, and, of course, allows
variables to change values.
Pure functions have no side effects, so a function called with the
same input will always return the same output. Pure functions are
easier to debug and to reason about because of this. They can be
reasoned about in isolation and will not depend on the context in which
they are called. The R language does not guarantee that the functions
you write are pure, but you can write most of your programs using only
pure functions. By keeping your code mostly purely functional, you will
write more robust code and code that is easier to modify when the need
arises.
You will want to move the impure functions to a small subset of
your program. These functions are typically those that need to sample
random data or that produce output (either text or plots). If you know
where your impure functions are, you know when to be extra careful
with modifying code.
The next chapter contains a short introduction to functions in R.
Some parts you might already know, and so feel free to skip ahead, but I
give a detailed description of how functions are defined and used to
ensure that we are all on the same page. The following chapters then
move on to more complex issues.
© The Author(s), under exclusive license to APress Media, LLC, part of Springer
Nature 2023
T. Mailund, Functional Programming in R 4
https://doi.org/10.1007/978-1-4842-9487-1_2

2. Functions in R
Thomas Mailund1
(1) Aarhus N, Denmark

In this chapter, we cover how to write functions in R. If you already

know much of what is covered, feel free to skip ahead. We will discuss
the way parameters are passed to functions as “promises,” a way of
passing parameters known as lazy evaluation. If you are not familiar
with that but know how to write functions, you can jump forward to
that section. We will also cover how to write infix operators and
replacement functions, so if you do not know what those are, and how
to write them, you can skip ahead to those sections. If you are new to R
functions, continue reading from here.

Writing Functions in R
You create an R function using the function keyword or, since R 4.1,
the \() syntax. For example, we can write a function that squares
numbers like this:

square <- function(x) x**2

or like this:

square <- \(x) x**2

and then use it like this:

square(1:5)

## [1] 1 4 9 16 25
The shorter syntax, \(x) x**2, is intended for so-called “lambda
expressions,” and the backslash notation is supposed to look like the
Greek letter lambda, λ. Lambda expressions are useful when we need to
provide short functions as arguments to other functions, which is
something we return to in later chapters. Usually, we use the
function() syntax when defining reusable functions, and I will stick
to this notation in every case where we define and name a function the
way we did for square earlier.
The function we have written takes one argument, x, and returns
the result x**2. The return value of a function is always the last
expression evaluated in it. If you write a function with a single
expression, you can write it as earlier, but for more complex functions,
you will typically need several statements in it. If you do, you can put
the function’s body in curly brackets like this:

square <- function(x) {

x**2
}

The following function needs the curly brackets since it needs three
separate statements to compute its return value, one for computing the
mean of its input, one for getting the standard deviation, and a final
expression that returns the input scaled to be centered on the mean
and having one standard deviation.

rescale <- function(x) {

m <- mean(x)
s <- sd(x)
(x - m) / s
}

The first two statements are just there to define some variables we
can use in the final expression. This is typical for writing short
functions.
 Variables you assign to inside a function will only be visible from
inside the function. When the function completes its execution, the
variables cease to exist. From inside a function, you can see the so-
called local variables—the function arguments and the variables you
assign to in the function body—and you can see the so-called global
variables—those assigned to outside of the function. Outside of the
function, however, you can only see the global variables. At least that is
a good way to think about which variables you can see at any point in a
program until we get to the gritty details in Chapter 4. For now, think in
terms of global variables and local variables, where anything you write
outside a function is in the first category and can be seen by anyone,
and where function parameters and variables assigned to inside
functions are in the second category; see Figure 2-1. If you have the
same name for both a global and a local variable, as in the figure where
we have a global variable x and a function parameter x, then the name
always refers to the local variable.

Figure 2-1 Local and global variables

Assignments are really also expressions. They return an object, the

value that is being assigned; they just do so quietly. R considers some
expressions “invisible,” and while they do evaluate to some value or
other—all expressions do—R does not print the result. Assignments
are invisible in this way; they do return to the value on the right-hand
side of the assignment, but R makes the result invisible. You can remove
this invisibility by putting an assignment in parentheses. The
parentheses make R remove the invisibility of the expression result, so
you see the actual value:

(x <- 1:5)

## [1] 1 2 3 4 5
You can also go the other way and make a value invisible. When you
evaluate an expression, R will print it:

x**2

## [1] 1 4 9 16 25

but if you put the expression in a call to invisible, R will not

print the result:

invisible(x**2)

We usually use assignments for their side effect, assigning a name to

a value, so you might not think of them as expressions, but everything
you do in R is actually an expression. That includes control structures
like if-statements and for-loops. They return values. They are
actually functions themselves, and they return values. If you evaluate an
if-statement, you get the value of the last expression in the branch it
takes:

if (2 + 2 == 4) "Brave New World" else "1984"

## [1] "Brave New World"

If you evaluate a loop, you get the value NULL (and not the last
expression in its body):

x <- for (i in 1:10) i

x

## NULL
 Even parentheses and subscripting are functions. Parentheses
evaluate to the value you put inside them (but stripped of invisibility),
and subscripting, [...] or [[...]], evaluates to some appropriate
value on the data structure you are accessing (and you can define how
this will work for your own data structures if you want to).
If you want to return a value from a function before its last
expression, you can use the return function. It might look like a
keyword, but it is a function, and you need to include the parentheses
when you use it. Many languages will let you return a value by writing

return expression

Not R. In R, you need to write

return(expression)

If you are trying to return a value, this will not cause you much
trouble. R will tell you that you have a syntax error if you use the
former and not the latter syntax. Where it can be a problem is if you
want to return from a function without providing a value (in which case
the function automatically returns NULL).
If you write something like this:

f <- function(x) {
if (x < 0) return;
# Something else happens here...
}

you will not return if x is negative. The if-expression evaluates to

the function return, which is not what you want. Instead, you must
write

f <- function(x) {
if (x < 0) return();
# Something else happens here...
}
 If x is negative, we call return(), which will return NULL. (To
return a value, val, use return(val)).
Return is usually used to exit a function early and isn’t used that
much in most R code. It is easier to return a value by just making it the
last expression in a function than it is to explicitly use return. But you
can use it to return early like this:

rescale <- function(x, only_translate) {

m <- mean(x)
translated <- x - m
if (only_translate) return(translated)
s <- sd(x)
translated / s
}
rescale(1:4, TRUE)

## [1] -1.5 -0.5 0.5 1.5

rescale(1:4, FALSE)

## [1] -1.1618950 -0.3872983 0.3872983 1.1618950

This function has two arguments, x and only_translate. Your

functions can have any number of parameters. When a function takes
many arguments, however, it becomes harder to remember in which
order you have to put them. To get around that problem, R allows you
to provide the arguments to a function using their names. So the two
function calls earlier can also be written as

rescale(x = 1:4, only_translate = TRUE)

rescale(x = 1:4, only_translate = FALSE)

Named Parameters and Default Parameters

If you use named arguments, the order doesn’t matter, so this is also
equivalent to these function calls:

rescale(only_translate = TRUE, x = 1:4)

rescale(only_translate = FALSE, x = 1:4)
You can mix positional and named arguments. The positional
arguments have to come in the same order as used in the function
definition, and the named arguments can come in any order. All the
following four function calls are equivalent:

rescale(1:4, only_translate = TRUE)

rescale(only_translate = TRUE, 1:4)
rescale(x = 1:4, TRUE)
rescale(TRUE, x = 1:4)

When you provide a named argument to a function, you don’t need

to use the full parameter name. Any unique prefix will do. So we could
also have used the following two function calls:

rescale(1:4, o = TRUE)
rescale(o = TRUE, 1:4)

This is convenient for interactive work with R because it saves some

typing, but I do not recommend it when you are writing programs. It
can easily get confusing, and if the author of the function adds a new
argument to the function with the same prefix as the one you use, it will
break your code. If the function author provides a default value for that
parameter, your code will not break if you use the full argument name.
Not breaking, in a situation like this, is a whole lot worse than breaking,
because the code will not do the right thing and you will not be
immediately aware of that.
Now, default parameters are provided when the function is defined.
We could have given rescale a default parameter for
only_translate like this:

rescale <- function(x, only_translate = FALSE) {

m <- mean(x)
translated <- x - m
if (only_translate) return(translated)
s <- sd(x)
translated / s
}
 Then, if we call the function, we only need to provide x if we are
happy with the default value for only_translate.

rescale(1:4)

## [1] -1.1618950 -0.3872983 0.3872983 1.1618950

R makes heavy use of default parameters. Many commonly used

functions, such as plotting functions and model fitting functions, have
lots of arguments. These arguments let you control in great detail what
the functions do, making them very flexible, and because they have
default values, you usually only have to worry about a few of them.

The “Gobble Up Everything Else” Parameter: “...”

There is a special parameter all functions can take called .... This
parameter is typically used to pass parameters on to functions called
within a function. To give an example, we can use it to deal with missing
values, NA, in the rescale function.
We can write (where I’m building from the shorter version)

rescale <- function(x, ...) {

m <- mean(x, ...)
s <- sd(x, ...)
(x - m) / s
}

If we give this function a vector x that contains missing values, it

will return NA:

x <- c(NA, 1:3)

rescale(x)

## [1] NA NA NA NA

It would also have done that before because that is how the
functions mean and sd work. But both of these functions take an
additional parameter, na.rm, that will make them remove all NA values
before they do their computations. Our rescale function can do the
same now:

rescale(x, na.rm = TRUE)

## [1] NA -1 0 1
The first value in the output is still NA. Rescaling an NA value can’t
be anything else. But the rest are rescaled values where that NA was
ignored when computing the mean and standard deviation.
The “...” parameter allows a function to take any named
parameter at all. If you write a function without it, it will only take the
predetermined parameters, but if you add this parameter, it will accept
any named parameter at all:

f <- function(x) x
g <- function(x, ...) x
f(1:4, foo = "bar")

## Error in f(1:4, foo = "bar"): unused argument

(foo = "bar")

g(1:4, foo = "bar")

## [1] 1 2 3 4

If you then call another function with “...” as a parameter, then all
the parameters the first function doesn’t know about will be passed on
to the second function:

f <- function(...) list(...)

g <- function(x, y, ...) f(...)
g(x = 1, y = 2, z = 3, w = 4)

## $z
## [1] 3
##
## $w
## [1] 4
In the preceding example, function f creates a list of named
elements from “...”, and as you can see, it gets the parameters that g
doesn’t explicitly take.
Using “...” is not particularly safe. It is often very hard to figure
out what it actually does in a particular piece of code. What is passed on
to other functions depends on what the first function explicitly takes as
arguments, and when you call a second function using it, you pass along
all the parameters in it. If the function you call doesn’t know how to
deal with them, you get an error:

f <- function(w) w
g <- function(x, y, ...) f(...)
g(x = 1, y = 2, z = 3, w = 4)

## Error in f(...): unused argument (z = 3)

In the rescale function, it would have been much better to add

the rm.na parameter explicitly.
That being said, “...” is frequently used in R. Particularly because
many functions take very many parameters with default values, and
adding these parameters to all functions calling them would be tedious
and error-prone. It is also the best way to add parameters when
specializing generic functions, which is a topic for another book,
Advanced Object-Oriented Programming in R, by yours truly.

Lazy Evaluation
Expressions used in a function call are not evaluated before they are
passed to the function. Most common languages have so-called pass-by-
value semantics, which means that all expressions given to parameters
of a function are evaluated before the function is called. In R, the
semantic is “call-by-promise,” also known as “lazy evaluation.”
When you call a function and give it expressions as its arguments,
these are not evaluated at that point. What the function gets is not the
result of evaluating them but the actual expressions, called “promises”
(they are promises of an evaluation to a value you can get when you
need it), thus the term “call-by-promise.” These expressions are only
evaluated when they are actually needed, thus the term “lazy
evaluation.”
This has several consequences for how functions work. First of all,
an expression that isn’t used in a function isn’t evaluated:

f <- function(a, b) a
f(2, stop("error if evaluated"))

## [1] 2

f(stop("error if evaluated"), 2)

## Error in f(stop("error if evaluated"), 2):

error if evaluated

If you have a parameter that can only be meaningfully evaluated in

certain contexts, it is safe enough to have it as a parameter as long as
you only refer to it when those necessary conditions are met.
It is also very useful for default values of parameters. These are
evaluated inside the scope of the function, so you can write default
values that depend on other parameters:

f <- function(a, b = a) a + b
f(a = 2)

## [1] 4

This does not mean that all the expressions are evaluated inside the
scope of the function, though. We discuss scopes in Chapter 4, but for
now, you can think of two scopes: the global scope where global
variables live and the function scope that has parameters and local
variables as well.
If you call a function like this:

f(a = 2, b = a)
 you will get an error if you expect b to be the same as a inside the
function. If you are lucky and there isn’t any global variable called a,
you will get a runtime error. If you are unlucky and there is a global
variable called a, that is what b will be assigned, and if you expect it to
be set to 2 here, your code will just give you an incorrect answer.
However, it is safe for a default parameter to be an expression that
uses some of the other function arguments. The default parameters are
evaluated after the function is called, where they have access to the
other arguments. An expression you use when calling a function,
however, doesn’t see the local variables inside the function, but the
variables you have in the calling scope.

Figure 2-2 Where arguments and default arguments are evaluated

Consider Figure 2-2. We have a function, f, that takes two

arguments, a and b, where b has a default of 2*a. If we call it as
f(2*a, b = 2*a), then both arguments will be expressions that R
knows have to be evaluated in the global scope where a is the list 1 2
3 4 5 and where we don’t have a b. Neither parameter will be
evaluated until we look at the arguments, but when we do, both will be
evaluated and to the same value since both are 2*a and a refers to the
global a. If, however, we call f as f(2*a) so b gets the default value,
we are in a different situation. Inside the function call, a still refers to
the expression 2*a to be evaluated in the global scope, but b, also still
referring to the expression 2*a, will be evaluated in the local scope. So,
if we evaluate b, we will first evaluate the parameter a to get 2*a
(evaluated using the global a) 2 4 6 8 10, and then we evaluate 2*a
with this local a to get 4 8 12 16 20.
So, while arguments aren’t evaluated yet when you call a function,
they will be when you access them. If they are default arguments, you
evaluate them inside the function, and if they were provided in the
function call, you evaluated them outside the call, where the function
was called.
This also means that you cannot change what an expression
evaluates to just by changing a local variable:

a <- 4
f <- function(x) {
a <- 2
x
}
f(1 + a)

## [1] 5

In this example, the expression 1 + a is evaluated inside f, but the

a in the expression is the a outside of f and not the a local variable
inside f.
This is of course what you want. If expressions really were evaluated
inside the scope of the function, then you would have no idea what they
evaluated to if you called a function with an expression. It would
depend on any local variables the function might use.
Because expressions are evaluated in the calling scope and not the
scope of the function, you mostly won’t notice the difference between
call-by-value and call-by-promise. There are certain cases where the
difference can bite you, though, if you are not careful.
As an example, we can consider this function:

f <- function(a) function(b) a + b

This might look a bit odd if you are not used to it, but it is a function
that returns another function. We will see many examples of this kind
of functions in later chapters.
 When we call f with a parameter a, we get a function back that will
add a to its argument:

f(2)(2)

## [1] 4

We can create a list of functions from this f:

ff <- vector("list", 4)
for (i in 1:4) {
ff[[i]] <- f(i)
}
ff

## [[1]]
## function(b) a + b
## <bytecode: 0x7fe446ad68a8>
## <environment: 0x7fe446a07ca0>
##
## [[2]]
## function(b) a + b
## <bytecode: 0x7fe446ad68a8>
## <environment: 0x7fe446ad71e8>
##
## [[3]]
## function(b) a + b
## <bytecode: 0x7fe446ad68a8>
## <environment: 0x7fe446ad7098>
##
## [[4]]
## function(b) a + b
## <bytecode: 0x7fe446ad68a8>
## <environment: 0x7fe446ad6f48>

Here, ff contains four functions, and the idea is that the first of
these adds 1 to its argument, the second adds 2, and so on.
 If we call the functions in ff, however, weird stuff happens:

ff[[1]](1)

## [1] 5

When we get the element ff[[1]], we get the first function we

created in the loop. If we substitute into f the value we gave in the call,
this is

function(b) i + b

The parameter a from f has been set to the parameter we gave it, i,
but i has not been evaluated at this point!
When we call the function, the expression is evaluated, in the global
scope, but there i now has the value 4 because that is the last value it
was assigned in the loop. The value of i was 1 when we called it to
create the function, but it is 5 when the expression is actually evaluated.
This also means that we can change the value of i before we
evaluate one of the functions, and this changes it from the value we
intended when we created the function:

i <- 1
ff[[2]](1)

## [1] 2

This laziness is only in effect the first time we call the function. If we
change i again and call the function, we get the same value as the first
time the function was evaluated:

i <- 2
ff[[2]](1)

## [1] 2

We can see this in effect by looping over the functions and

evaluating them:
results <- vector("numeric", 4)
for (i in 1:4) {
results[i] <- ff[[i]](1)
}
results

## [1] 5 2 4 5
We have already evaluated the first two functions, so they are stuck
at the values they got at the time of the first evaluation. The other two
get the intended functionality but only because we are setting the
variable i in the loop where we evaluate the functions. If we had used a
different loop variable, we wouldn’t have been so lucky.
This problem is caused by having a function with an unevaluated
expression that depends on variables in the outer scope. Functions that
return functions are not uncommon, though, if you want to exploit the
benefits of having a functional language. It is also a consequence of
allowing variables to change values, something most functional
programming languages do not allow for such reasons. You cannot
entirely avoid it, though, by avoiding for-loops. If you call functions
that loop for you, you do not necessarily have control over how they do
that, and you can end up in the same situation.
The way to avoid the problem is to force an evaluation of the
parameter. If you evaluate it once, it will remember the value, and the
problem is gone.
You can do that by just writing the parameter as a single statement.
That will evaluate it. It is better to use the function force though, to
make it explicit that this is what you are doing. It really just gives you
the expression back, so it works exactly as if you just wrote the
parameter, but the code makes clear why you are doing it.
If you do this, the problem is gone:

f <- function(a) {
force(a)
function(b) a + b
}

ff <- vector("list", 4)
for (i in 1:4) {
ff[[i]] <- f(i)
}

ff[[1]](1)

## [1] 2

i <- 1
ff[[2]](1)

## [1] 3

Functions Don’t Have Names

The last thing I want to stress when we talk about defining functions is
that functions do not have names. Variables have names, and variables
can refer to functions, but these are two separate things.
In many languages, such as Java, Python, or C++, you define a
function, and at the same time, you give it an argument. When possible
at all, you need a special syntax to define a function without a name.
Not so in R. In R, functions do not have names, and when you define
them, you are not giving them a name. We have given names to all the
functions we have used earlier by assigning them to variables right
where we defined them. We didn’t have to. It is the “function(...)
...” syntax that defines a function. We are defining a function whether
we assign it to a variable or not.
We can define a function and call it immediately like this:

(function(x) x**2)(2)

## [1] 4

We would never do this, of course. Anywhere we would want to

define an anonymous function and immediately call it, we could instead
just put the body of the function. Functions we want to reuse we have to
give a name so we can get to them again.
 The syntax for defining functions, however, doesn’t force us to give
them names. When you start to write higher-order functions, that is,
functions that take other functions as input or return functions, this is
convenient.
Such higher-order functions are an important part of functional
programming, and we will see much of them later in the book.

Vectorized Functions
Expressions in R are vectorized. When you write an expression, it is
implicitly working on vectors of values, not single values. Even simple
expressions that only involve numbers really are vector operations.
They are just vectors of length 1.
For longer vectors, expressions work component-wise. So if you
have vectors x and y, you can subtract the first from the second
component-wise just by writing x - y:

x <- 1:5
y <- 6:10
x – y

## [1] -5 -5 -5 -5 -5

If the vectors are not of the same length, the shorter vector is just
repeated as many times as is necessary. This is why you can, for
example, multiply a number to a vector:

2 * x

## [1] 2 4 6 8 10

Here, 2 is a vector of length 1 and x a vector of length 5, and 2 is just

repeated five times. You will get a warning if the length of the longer
vector is not divisible by the length of the shorter vector, and you
generally want to avoid this. The semantic is the same, though: R just
keeps repeating the shorter vector as many times as needed.

x <- 1:6
y <- 1:3
x – y

## [1] 0 0 0 3 3 3
Depending on how a function is written, it can also be used in
vectorized expressions. R is happy to use the result of a function call in
a vector expression as long as this result is a vector. This is not quite the
same as the function operating component-wise on vectors. Such
functions we can call vectorized functions.
Most mathematical functions such as sqrt, log, cos, and sin are
vectorized, and you can use them in expressions:

log(1:3) - sqrt(1:3)

## [1] -1.0000000 -0.7210664 -0.6334385

Functions you write yourself will also be vectorized if their body

consists only of vectorized expressions:

f <- function(a, b) log(a) - sqrt(b)

f(1:3, 1:3)

## [1] -1.0000000 -0.7210664 -0.6334385

The very first function we wrote in this book, square, was also a
vectorized function. The function scale was also, although the
functions it used, mean and sd, are not; they take vector input but
return a summary of the entire vector and do not operate on the vector
component-wise.
A function that uses control structures usually will not be
vectorized. We can write a comparison function that returns -1 if the
first argument is smaller than the second and 1 if the second is larger
than the first, and zero otherwise like this:

compare <- function(x, y) {

if (x < y) {
-1
} else if (y < x) {
 1
} else {
0
}
}
This function will work fine on single values but not on vectors. The
problem is that the if-expression only looks at the first element in the
logical vector x < y. (Yes, x < y is a vector because < is a vectorized
function.)
To handle if-expressions, we can get around this problem by using
the ifelse function. This is a vectorized function that behaves just as
an if-else-expression:

compare <- function(x, y) {

ifelse(x < y, -1, ifelse(y < x, 1, 0))
}
compare(1:6, 1:3)

## [1] 0 0 0 1 1 1

The situation is not always so simple that we can replace if-

statements with ifelse. In most cases, we can, but when we cannot,
we can instead use the function Vectorize. This function takes a
function that can operate on single values and translate it into a
function that can work component-wise on vectors.
As an example, we can take the compare function from before and
vectorize it:

compare <- function(x, y) {

if (x < y) {
-1
} else if (y < x) {
1
} else {
0
}
}
compare <- Vectorize(compare)
compare(1:6, 1:3)

## [1] 0 0 0 1 1 1
By default, Vectorize will vectorize on all parameters of a
function. As an example, imagine that we want a scale function that
doesn’t scale all variables in a vector by the same vector’s mean and
standard deviation but use the mean and standard deviation of another
vector:

Scale_with <- function(x, y) {

(x - mean(y)) / sd(y)
}

This function is already vectorized on its first parameter since it just

consists of a vectorized expression, but if we use Vectorize on it, we
break it:

scale_with(1:6, 1:3)

## [1] -1 0 1 2 3 4

scale_with <- Vectorize(scale_with)

scale_with(1:6, 1:3)

## [1] NA NA NA NA NA NA

The function we create with Vectorize is vectorized for both x

and y, which means that it operates on these component-wise. When
scaling, the function only sees one component of y, not the whole
vector. The result is a vector of missing values, NA because the standard
deviation of a single value is not defined.
We can fix this by explicitly telling Vectorize which parameters
should be vectorized—in this example, only parameter x:

Scale_with <- function(x, y) {

(x - mean(y)) / sd(y)
}
scale_with <- Vectorize(scale_with,
vectorize.args="x")
scale_with(1:6, 1:3)

## [1] -1 0 1 2 3 4
Simple functions are usually already vectorized, or can easily be
made vectorized using ifelse, but for functions more complex, the
Vectorize function is needed.
As an example, we can consider a tree data structure and a function
for computing the node depth of a named node—the node depth
defined as the distance from the root. For simplicity, we consider only
binary trees. We can implement trees using lists:

Make_node <- function(name, left = NULL, right =

NULL)
list(name = name, left = left, right = right)

tree <- make_node("root",

make_node("C", make_node("A"),
make_node("B")),
make_node("D"))

To compute the node depth, we can traverse the tree recursively:

node_depth <- function(tree, name, depth = 0) {

if (is.null(tree)) return(NA)
if (tree$name == name) return(depth)

left <- node_depth(tree$left, name, depth + 1)

if (!is.na(left)) return(left)
right <- node_depth(tree$right, name, depth +
1)
return(right)
}

This is not an unreasonably complex function, but it is a function

that is harder to vectorize than the scale_with function. As it is, it
works well for single names:

node_depth(tree, "D")

## [1] 1

node_depth(tree, "A")

## [1] 2
but you will get an error if you call it on a sequence of names:

node_depth(tree, c("A", "B", "C", "D"))

It is not hard to imagine that a vectorized version could be useful,

however. For example, to get the depth of a sequence of names:

node_depth <- Vectorize(node_depth, vectorize.args

= "name",
USE.NAMES = FALSE)
node_depth(tree, c("A", "B", "C", "D"))

## [1] 2 2 1 1

Here, the USE.NAMES = FALSE is needed to get a simple vector

out. If we did not include it, the vector would have names based on the
input variables. See the documentation for Vectorize for details.

Infix Operators
Infix operators in R are also functions. You can overwrite them with
other functions (but you really shouldn’t since you could mess up a lot
of code), and you can also make your own infix operators.
User-defined infix operators are functions with special names. A
function with a name that starts and ends with % will be considered an
infix operator by R. There is no special syntax for creating a function to
be used as an infix operator, except that it should take two arguments.
There is a special syntax for assigning variables, though, including
variables with names starting and ending with %.
 To work with special variables, you need to quote them with
backticks. You cannot write +(2, 2) even though + is a function. R
will not understand this as a function call when it sees it written like
this. But you can take + and quote it, `+`, and then it is just a variable
name like all other variable names:

`+`(2, 2)

## [1] 4

The same goes for all other infix operators in R and even control
structures:

`if`(2 > 3, "true", "false")

## [1] "false"

The R parser recognizes control structure keywords and various

operators, for example, the arithmetic operators, and therefore these
get to have a special syntax. But they are all really just functions. Even
parentheses are a special syntax for the function `(`, and the subscript
operators are as well, `[` and `[[`, respectively. If you quote them,
you get a variable name that you can use just like any other function
name.
Just like all these operators have a special syntax, variables starting
and ending with % get a special syntax. R expects them to be infix
operators and will treat an expression like this:

exp1 %op% exp2

as the function call

`%op%`(exp1, exp2)

Knowing that you can translate an operator name into a function

name just by quoting it also tells you how to define new infix operators.
If you assign a function to a variable name, you can refer to it by that
name. If that name is a quoted special name, it gets to use the special
syntax for that name.
So, to define an operator %x% that does multiplication, we can write

`%x%` <- `*`

3 %x% 2

## [1] 6

Here, we used quotes twice, first to get a variable name we could

assign to for %x% and once to get the function that the multiplication
operator, *, points to.
Just because all control structures and operators in R are functions
that you can overwrite, you shouldn’t go doing that without extreme
caution. You should never change the functions the control structures
point to, and you should not change the other operators unless you are
defining operators on new types where it is relatively safe to do so.
Defining entirely new infix operators, however, can be quite useful if
they simplify expressions you write often.
As an example, let us do something else with the %x% operator—
after all, there is no point in having two different operators for
multiplication. We can make it replicate the left-hand side a number of
times given by the right-hand side:

`%x%` <- function(expr, num) replicate(num, expr)

3 %x% 5

## [1] 3 3 3 3 3

cat("This is ", "very " %x% 3, "much fun")

## This is very very very much fun

We are using the replicate function to achieve this. It does the

same thing. It repeatedly evaluates an expression a fixed number of
times. Using %x% infix might give more readable code, depending on
your taste.
 In the interest of honesty, I must mention, though, that we haven’t
just given replicate a new name here, switching of arguments aside.
The %x% operator works slightly differently. In %x%, the expr
parameter is evaluated when we call replicate. So if we call %x%
with a function that samples random numbers, we will get the same
result repeated num times; we will not sample num times.

rnorm(1) %x% 4

## [1] -0.8094755 -0.8094755 -0.8094755 -0.8094755

Lazy evaluation only takes you so far.

To actually get the same behavior as replicate, we need a little
more trickery:

`%x%` <- function(expr, num) {

m <- match.call()
replicate(num, eval.parent(m$expr))
}
rnorm(1) %x% 4

## [1] 0.8430961 -2.9336330 -1.1009706 0.2947148

Here, the match.call function just gets us a representation of the

current function call from which we can extract the expression without
evaluating it. We then use replicate to evaluate it a number of times
in the calling function’s scope.
If you don’t quite get this, don’t worry. We cover scopes in a later
chapter.

Replacement Functions
Another class of functions with special names is the so-called
replacement functions. Data in R is immutable. You can change what
data parameters point to, but you cannot change the actual data. Even
when it looks like you are modifying data, you are, at least conceptually,
creating a copy, modifying that, and making a variable point to the new
copy.
We can see this in a simple example with vectors. If we create two
vectors that point to the same initial vector, and then modify one of
them, the other remains unchanged:

x <- y <- 1:5

x

## [1] 1 2 3 4 5

## [1] 1 2 3 4 5

x[1] <- 6
x

## [1] 6 2 3 4 5

## [1] 1 2 3 4 5

R is smart about it. It won’t make a copy of values if it doesn’t have

to. Semantically, it is best to think of any modification as creating a copy,
but for performance reasons, R will only make a copy when it is
necessary—at least for built-in data like vectors. Typically, this happens
when you have two variables referring to the same data, and you
“modify” one of them.
We can use the address function to get the memory address of an
object. This will change when a copy is made but will remain the same
when it isn’t. And we can use the mem_change function from the pryr
package to see how much memory is allocated for an expression. Using
these two functions, we can dig a little deeper into this copying
mechanism. (The exact output will depend on your computer, but you
should see something similar to what is shown as follows.)
We can start by creating a longish vector and modifying it:
library(pryr)

rm(x) ; rm(y)
mem_change(x <- 1:10000000)

## 2.31 kB

address(x)

## [1] "0x7fe426826a90"

mem_change(x[1] <- 6)

## 80 MB

address(x)

## [1] "0x7fe420000000"
When we assign to the first element in this vector, we see that the
entire vector is being copied. This might look odd since I just told you
that R would only copy a vector if it had to, and here we are just
modifying an element in it, and no other variable refers to it.
The reason we get a copy here is that the expression we used to
create the vector, 1:10000000, creates an integer vector. The value 6
we assign to the first element is a floating point, called “numeric” in R. If
we want an actual integer, we have to write “L” (for “long” integer) after
the number:

class(6)

## [1] "numeric"

class(6L)

## [1] "integer"

When we assign a numeric to an integer vector, R has to convert the

entire vector into numeric, and that is why we get a copy:
z <- 1:5
class(z)

## [1] "integer"

z[1] <- 6
class(z)

## [1] "numeric"
If we assign another numeric to it, after it has been converted, we
no longer get a copy:

mem_change(x[3] <- 8)

## -1.14 kB

address(x)

## [1] "0x7fe420000000"

All expression evaluations modify the memory a little, up or down,

but the change is much smaller than the entire vector, so we can see
that the vector isn’t being copied, and the address remains the same.
If we assign x to another variable, we do not get a copy. We just have
the two names refer to the same value:

mem_change(y <- x)

## 376 B

address(x)

## [1] "0x7fe420000000"

address(y)

## [1] "0x7fe420000000"
Random documents with unrelated
content Scribd suggests to you:
 Joseph Fels war in einem kleinen Landhaus in Virginia zur Welt
gekommen. Sein Vater arbeitete emsig, aber nicht sehr erfolgreich.
Er machte Toilettenseife.
Joseph war ein schlechter Schüler, wie die besten Jungen es
gewöhnlich sind. Er liebte das tägliche Einerlei und das
Auswendiglernen nicht. Mit 15 Jahren lehnte er sich auf und
verweigerte es, länger in die Schule zu gehen.
Er wurde Reisender in Seife. Er sparte sein Geld und mit 22 Jahren
kaufte er eine kleine Seifensiederei um 800 Dollar und wurde
Fabrikant.
Fünfzehn Jahre lang widmete er seine volle Energie seinem
Geschäft. Er nahm seine Brüder als Teilhaber hinein.
Da die Konkurrenz im Seifengeschäft sehr lebhaft war, erkannte er
die Notwendigkeit einer Spezialität. Er fand sie — eine Naphtaseife,
mit der man Flecken aus Kleidern entfernen konnte. Er kaufte das
Rezept zur Erzeugung dieser Seife und begründete so sein
Vermögen. Sie ist jetzt über die ganze Welt verbreitet.
Mit 20 Jahren verliebte er sich in ein Mädchen von großem Reiz
und großer Tüchtigkeit. Auch sie war sehr klein. Sie paßten
ausgezeichnet zueinander und waren in ihrem Familienleben sehr
glücklich. Soviel ich weiß, war das einzige Leid, das jemals ihr Heim
befiel, der Tod ihres Kindes. Fels hatte eine Leidenschaft für Kinder
und erholte sich niemals vollständig von diesem Verlust.
Als er reich geworden war, widmete er den größten Teil seiner Zeit
sozialen Problemen.
Er hörte auf, für sich selbst zu arbeiten und arbeitete für andere.
Es gab zwei Dinge, die Joseph Fels haßte, soweit seine Natur ihm
überhaupt zu hassen gestattete, und diese beiden Dinge waren
Verschwendung und Ungerechtigkeit. Wie Sie sehen, war er halb ein
Geschäftsmann und halb ein Apostel. Er glaubte gleichmäßig an
Erfolg und an Güte.
 Er war nicht der Meinung, daß Geld irgend etwas Gutes bewirken
könne, und ebensowenig glaubte er daran, daß man den Himmel auf
Erden Leuten predigen sollte, die ungerecht behandelt wurden.
Er behauptete, daß die größte Verschwendung in England das
brachliegende Land sei. Da liegt es, dreißigtausend Morgen groß,
während fünfzigtausend Arbeitslose auf dem Trafalgar-Square nach
Brot rufen!
Brachliegendes Land und brachliegende Menschen: Warum
werden im Namen der Menschlichkeit und der Vernunft diese beiden
nicht zusammengebracht, um so die Fruchtlosigkeit beider
abzuschaffen? Das war die Frage, die Joseph Fels den
Staatsmännern Englands vorlegte, und keiner von ihnen hat sie bis
jetzt beantwortet.
Noch immer gibt es brachliegendes Land, und noch immer gibt es
arbeitslose Männer — frühere Soldaten und Seeleute —,
Zehntausende davon.
Als das größte aller Verbrechen erschien Fels, für einen Mann
einen Palast inmitten zehntausend Morgen brachliegenden Landes zu
errichten, während zweihundert Familien in schmutzigen Hütten
zusammengepfercht sind, ohne einen Fuß Landes ihr Eigen nennen
zu können.
Fels mochte weder Armut noch Luxus leiden. Er betrachtete
beides als dem Volke nachteilig. Niemand sollte ganz ohne Besitz
sein, dachte er, und niemand sollte zuviel davon haben.
Er betrachtete die Menschen als wichtiger denn alles übrige, als
Finanz und Geschäft, als Erblichkeit und Aristokratie, ja selbst als
Regierung: er war wirklich ein eigenartiger Millionär.
In einer Ansprache an eine Handelskammer sagte er einmal: »Ich
besitze in einer gewissen Stadt 11½ Morgen Land, für die ich vor
einigen Jahren 6500 Pfund Sterling gezahlt habe. Durch das
Anwachsen der Bevölkerung dieser Stadt ist mein Grundbesitz jetzt
auf 25 000 Pfund Sterling gestiegen.
 Ich habe nichts dazu getan, diese Wertsteigerung zu bewirken.
Meine Mitbürger haben sie geschaffen, und ich glaube, daß sie ihnen
und nicht mir zugute kommen soll. Ich glaube daran, daß wir diese
Gemeinschaftswerte für unsere gemeinsamen Zwecke in Anspruch
nehmen sollten, anstatt Unternehmungen und Industrien zu
besteuern.«
Fels gab Tausende aus, um seine Idee
»Das Land dem Volk«
zu verbreiten. Er sandte jedem Wähler in Großbritannien ein Paket
Flugblätter, Jahr für Jahr nahm er an jedem Gewerkschaftskongreß
teil.
Einmal hatte er versprochen, einem fünfjährigen kleinen Mädchen
einen Esel zu kaufen. Kurz darauf kam er auch an, einen Esel am
Halfter, dem jedoch noch ein kleiner neugeborener Esel folgte. Man
fragte ihn: »Warum haben Sie zwei gekauft?« »Sie sehen,«
antwortete er, »ich konnte doch Mutter und Kind nicht trennen, und
so habe ich beide gekauft.«
Bei einer Tischgesellschaft saß er neben einer Dame, die
versuchte, ihm ihre überlegene Bedeutung einzuprägen. Sie
beschrieb einen gewissen Mann und sagte: »Natürlich ist er nicht
unseresgleichen.« Fels antwortete ruhig: »Ist nicht jedermann
unseresgleichen?«
Er baute sich ein Haus in Bickley in Kent und ließ folgende
Inschrift über seinem Tor anbringen:
Was ich ausgegeben habe, das hatte ich.
Was ich gespart habe, habe ich verloren.
Was ich gegeben habe, das habe ich.
Als er einmal im Balliol-Kolleg in Oxford sprach, begann er seine
Vorlesung mit den Worten: »Ich will zu Ihnen über das Land
sprechen, über diese Erde, auf der Sie leben. Wer schuf sie? Wem
gehört sie? Wer hat ein Recht auf sie?
 Und wie kann Gelehrsamkeit in einem Volke blühen, das
Ungerechtigkeit gestattet?«
Bei einer anderen Gelegenheit überraschte er sein Londoner
Auditorium in der Gildenhalle, indem er sagte: »Nicht weiter als eine
Omnibusfahrt vor der Bank von England liegen 10 000 Morgen Land
in London brach. Wäre dieses Land ordnungsgemäß bebaut, so
könnte es 8000 Familien erhalten.«
Joseph Fels war ein Mensch gewordenes Weberschiffchen. Er wob
alle Art Leute zusammen. Reichtum und Ehren, mit denen er
überschüttet wurde, konnten ihn nicht verderben.
Er war ein Landbesitzer, und doch verlangte er, daß sein Land
schwerer besteuert werden sollte. Er war ein Kapitalist, und doch
unterstützte er die Kandidaten der Arbeiterpartei.
Er war
ein Mann der Wahrheit.
Sein ganzes Leben lang focht er gegen Dummheit und Grausamkeit.
Er machte die Welt edler und intelligenter. Er starb 1914, unmittelbar
bevor der große Krieg begann.
Einer seiner nächsten Freunde in England war George Lansbury,
der Herausgeber des »Daily Herald«, ein Führer der Arbeiterpartei.
Lansbury schrieb einmal über Fels:
»Ich lernte Joseph Fels im Sommer 1903 kennen. Er kam in mein
Haus wie ein frischer Luftzug. Die offenbare Ehrenhaftigkeit seiner
Ziele und seine Menschenliebe überzeugten uns sofort.
Ich hatte sehr wenig von ihm gehört, und ich bekenne, daß ich
einigermaßen gegen ihn voreingenommen war, weil er ein reicher
Amerikaner war. Aber nachdem ich fünf Minuten mit ihm gesprochen
hatte, waren meine Zweifel und Befürchtungen zerstreut und dann
begann zwischen uns eine enge und intime Freundschaft, die
niemals enden kann.
 Er ließ mich mehr als je zuvor einsehen, daß es der Mühe wert ist,
für eine große Sache zu ringen und zu kämpfen, und er erfüllte mich
mit dem Glauben an meine Mitmenschen.«
So spricht ein Arbeiterführer von einem Kapitalisten. Zeigt das
nicht, daß alle Unterschiede der Klasse und des Vermögens ernstlich
betrachtet sehr unwesentliche Dinge sind, und daß alle Menschen,
die das Herz auf dem rechten Fleck haben, Mitarbeiter und Freunde
werden können?
 George Westinghouse.
Ich lade Sie ein, fünf Minuten darauf zu verwenden, aus folgenden
drei Gründen die Geschichte des George Westinghouse zu lesen:
1. Er war ein Erfinder, der eine Gesellschaft mit zwölf Millionen
Pfund Aktien aufbaute.
2. Er war ein Arbeitgeber von fünfzigtausend Arbeitern, die
niemals streikten.
3. Er war ein Mann, der reich und berühmt wurde, dabei aber bis
zum letzten Tag seines Lebens einfach, freundlich und nützlich blieb.
Westinghouse wurde natürlich, wie die meisten großen Männer,
arm geboren. Sein Vater war ein Farmer, der gleichzeitig eine
Tischlerei in einem kleinen Dorfe in den Vereinigten Staaten betrieb.
Er wurde 1846 geboren, und es ist erwähnenswert, daß ein Jahr
vor seiner Geburt sein Vater sich mit der Erfindung einer
Dreschmaschine befaßte. So mag es einen vorgeburtlichen Einfluß
gegeben haben, der den Kleinen dazu bestimmte, ein großer
Erfinder zu werden.
Als Schüler war der junge George Westinghouse hoffnungslos —
wenigstens sagte der Lehrer so. Er war ein großer plumper Junge,
stets bereit zu raufen, und mit einem Willen und einem
Temperament, die ihn unkontrollierbar machten.
Immer war er der Letzte in seiner Klasse, und Eltern und Lehrer
waren begierig, was jemals aus ihm werden würde. Wie Darwin,
Edison, Clive und viele andere war er ein »häßliches Entlein«, das
aufwuchs, um ein Schwan zu werden.
So oft er konnte, lief er von der Schule fort und schnitzte mit
seinem Taschenmesser Maschinen aus Holz. Meist erwischte ihn sein
Vater und zerbrach die Maschinen. Väter sind gewöhnlich so.
 Schließlich hatte einer der Arbeiter seines Vaters Mitleid mit dem
Jungen und richtete ihm auf einem Heuboden eine kleine Werkstatt
ein, fern von den väterlichen Eingriffen.
Mit 14 Jahren verließ er die Schule und wurde für zwei Schilling
pro Tag Arbeiter bei seinem Vater. Aber auch dieser Betrag war nach
Ansicht von Westinghouse Senior noch zu viel, weil der Junge seine
Zeit damit zubrachte, eine Maschine zu erfinden, welche die Arbeit
an seiner Statt verrichten sollte.
»Sein einziger Wunsch ist, die Arbeit zu vermeiden«,
sagte der Vater, der ihn nicht verstehen konnte.
Mit siebzehn Jahren wurde er Soldat im amerikanischen
Bürgerkrieg. Er trat bei der Kavallerie ein, weil er dachte, daß Reiten
leichter wäre als zu Fuß zu gehen; und er war sehr enttäuscht, als er
merkte, daß er für sein eigenes Pferd zu sorgen habe.
Mit 19 Jahren bezog er die Universität, aber er fühlte sich dort so
wenig am Platz wie ein Fisch in einem Sack Federn. »Es war zum
Verzweifeln mit ihm«, sagte einer der Professoren. »Sein Gehirn
sehnte sich nach schöpferischem Tun, nicht nach dem Auswendig
lernen von toten Sprachen und Ideen.«
So ging der junge Westinghouse auf den Rat des
Universitätspräsidenten wieder nach Hause und wurde Mechaniker.
Er arbeitete für seinen Vater für acht Schilling den Tag.
Mit 20 Jahren hatte er das Glück, einen Eisenbahnunfall zu
erleben. Zwei Waggons entgleisten und die Linie war zwei Stunden
lang gesperrt.
Sofort dachte er an eine Erfindung, um die Wagen in einer halben
Stunde wieder in das Geleise zu bringen. Er erhielt ein Patent und
fand tatsächlich zwei Leute, die um je tausend Pfund Anteile an dem
Patent erwarben.
Das war der Anfang seiner wirklichen Karriere. Von diesem
Augenblick an wendete er sein ganzes Leben an die Erfindung von
Verbesserungen für Eisenbahnen.
 Um diese Zeit verliebte er sich auch. Er lernte ein schönes
Mädchen namens Marguerite Walker in einem Eisenbahnwaggon
kennen — all sein Glück kam immer von Eisenbahnen. Er heiratete
sie, und sie wurde seine unzertrennliche Genossin in allen seinen
Erfolgen und Mißerfolgen.
In ihrer Art war sie gerade so klug und originell wie er.
Sie war ihm immer mehr als die ganze Welt.
Wie sie ihm im Leben folgte, folgte sie ihm auch rasch im Tode.
Bald nach seiner Heirat sah Westinghouse einen zweiten
Eisenbahnunfall. Zwei Züge waren zusammengestoßen. Die Strecke
war eben und gerade. Er fragte, warum der Zusammenstoß erfolgt
sei.
»Die beiden Lokomotivführer sahen einander, aber sie konnten
nicht anhalten,« sagte der Bahnhofsvorsteher. »Sie hatten zu wenig
Zeit. Man kann einen Zug nicht in einem Augenblick bremsen!«
Westinghouse hörte nicht auf, zu fragen: Warum? Er studierte das
altmodische Handbremssystem und fand, daß es unzulänglich sei.
Monatelang studierte er das System. Er versuchte es mit einer
langen Kette, die der Führer anziehen sollte. Aber das war zu
schwerfällig. Er versuchte Dampf, aber der wurde von Hitze und
Kälte beeinflußt.
Dann kam ein glücklicher Zufall. Eines Morgens kam eine junge
Dame in sein Bureau und versuchte, ihn als Abonnenten auf eine
Monatsschrift, genannt »The Living Age« (Das lebende Zeitalter), zu
gewinnen. Westinghouse lehnte ziemlich kurz angebunden ab, und
traurig wendete sie sich weg. Da bemerkte er, daß sie sanft und
schüchtern war, und bedauerte seine Grobheit. Er rief sie zurück und
gab ihr acht Schilling.
»Sie können mir Ihre Monatsschrift einige Monate lang schicken,«
sagte er.
 Bald kam die erste Nummer, und Westinghouse, der niemals viel
gelesen hatte, war erstaunt, einen Artikel zu finden, der ihm das
Problem der Bremse löste.
Der Artikel hieß »Im Mont Cenis Tunnel«. Er stammte von einem
englischen Ingenieur und erzählte, wie der Tunnel durch die
Anwendung von Preßluft gegraben worden war.
Der englische Ingenieur (ich wollte, ich wüßte seinen Namen)
erzählte, wie die Preßluft dreitausend Fuß weit durch eine Röhre
herangebracht und dazu verwendet wurde, um einen Bohrer durch
das Felsgestein des Mont Cenis zu treiben.
Westinghouse schrie auf vor Freude! Hier war der Wink, den er
gebraucht hatte. Wenn Preßluft verwendet werden konnte, um einen
Bohrer zu treiben, warum konnte sie nicht verwendet werden, um
die Bremsen eines Zuges anzuziehen?
Er legte alles andere beiseite und stürzte sich in die Aufgabe, die
erste Luftbremse zu konstruieren. In wenigen Wochen hatte er eine
hergestellt. Sie funktionierte. Im Nu war er einer der größten
Erfinder der Welt geworden.
Natürlich begegnete er den üblichen Schwierigkeiten, denen sich
jeder Pionier gegenüber sieht. Die Eisenbahnleute hielten ihn für
einen Narren. Sein eigener Vater lehnte es ab, ihm für solch ein
»Kinderspielzeug« wie eine Luftbremse Geld zu leihen.
Westinghouse wanderte von einem Eisenbahnbureau zum andern
und wurde von den meisten Eisenbahndirektoren wie ein harmloser
Irrer behandelt.
»Einen Zug durch Wind aufzuhalten! Was denn sonst?«
Schließlich fand er einen Fachmann, der Mut und Vernunft hatte —
Mr. W. W. Card von der Panhandle-Eisenbahn.
Mr. Card war bereit, Westinghouse einen Versuch zu gestatten,
aber nur unter der Bedingung, daß dieser die Ausgaben selbst trage.
 Zu dieser Zeit hatte Westinghouse überhaupt keine Geldmittel —
aber er stimmte zu. Dann lief er zu allen seinen Freunden und
borgte jeden Heller, den er bekommen konnte. Es war ein junger
Mann namens Ralph Baggaly, der ihn besonders unterstützte.
Eine Versuchsfahrt wurde unternommen. Der Lokomotivführer war
ein eifriger junger Mann namens Daniel Tate. Unmittelbar vor der
Abfahrt gab ihm Westinghouse eine Zehnpfundnote als Trinkgeld:
»Gib der Bremse eine gute Chance, Dan!« sagte er. Es war alles
Geld, was Westinghouse hatte, und auch dieses war geliehen.
Dann ereignete sich ein glücklicher Zufall. Der Versuchszug lief
dreißig Meilen die Stunde, als ein Fuhrwerk das Geleise kurz vor ihm
zu kreuzen versuchte. Der Kutscher hieb auf die Pferde ein, aber
diese scheuten rückwärts und schleuderten ihn zwischen die
Schienen.
Tate zog die Luftbremse an. Der Zug blieb stehen — vier Fuß vor
dem am Boden liegenden Kutscher. Das war das sensationelle Debut
der Luftbremse. Danach regnete es viele Aufträge und viele
Zehnpfundnoten.
Drei Jahre später kam Westinghouse nach England und schlug
seine zweite Schlacht mit den Eisenbahndirektoren. Sein bester
Freund war die Zeitung »Engineering«, die von Anfang an seine
Sache verfocht. Und sein erster Auftrag kam von der Metropolitan
District Railway in London.
Im Jahre 1881 war die Luftbremse bereits in allgemeiner
Verwendung. Westinghouse hatte eine große Fabrik in Pittsburg. Mit
35 Jahren war er reich und berühmt geworden.
Er lebte dann noch 33 Jahre, und jedes davon war von neuen
Ideen und Erfindungen erfüllt. Er stürzte sich auf Elektrizitätswerke
und Gasmaschinen. Er ließ neue Fabriken aufsprießen wie ein Farmer
den Weizen.
»Niemand kann erraten, wo der Alte das nächste Mal ausbrechen
wird«, pflegten seine Leute zu sagen.
 Das Beste aber war, daß sein Erfolg ihn nicht verdarb.
Er hatte einen starken Willen und war beherrschend, wie es jeder
Führer sein muß. Aber er verlor niemals die Fühlung mit seinen
Leuten.
Seine Arbeiter standen stets loyal zu ihm. Wenn seine Bankiers nur
halb so loyal zu ihm gestanden wären, hätte er niemals die
finanzielle Kontrolle über sein Geschäft verloren.
Einmal boten ihm seine Arbeiter an, gegen halben Lohn zu
arbeiten, weil sie wußten, daß er Geld brauchte.
Ein andermal brachten seine Leute 120 000 Pfund auf, um ihm
durchzuhelfen zu einer Zeit, in der ihn die Banken hart bedrängten.
Ernst, zäh, ehrenhaft, anständig, angriffslustig, optimistisch,
energisch, mutig — so war George Westinghouse. Er war stolz auf
seine Arbeiter. Er erzog sie und arbeitete an ihrer Seite. Er liebte sein
Werk und seine Werkleute. Und als er im Jahre 1914 starb, trugen
die Bahre acht alte Mechaniker, die mehr als vierzig Jahre lang seine
Mitarbeiter gewesen waren.
 Charles Seabrook.
Charlie Seabrook: Nein, Sie haben nie von ihm gehört. Er ist noch
nicht berühmt. Er hat gerade angefangen.
Er ist erst 43 Jahre alt, aber er ist der leistungsfähigste Farmer der
Welt.
In einem Jahre hat er auf einer Farm von 1200 Morgen um eine
Million Pfund Gemüse gezogen.
Er betreibt seine Farm wie eine Fabrik. Er ist kein Farmer im
gewöhnlichen Sinne. Er begnügt sich nicht damit, Samen in den
Boden zu streuen und dann die Natur und die Vögel das weitere tun
zu lassen.
Er ist ein Gemüsefabrikant. Und er erzielt ein größeres Erträgnis
per acres als jemals jemand vor ihm erzielt hat.
Die Geschichte von Charlie Seabrook beginnt mit seiner Geburt auf
einer kleinen Farm in Bridgetown, New-Jersey, U. S. A., im Jahre
1883. Sein Vater war ein Anglo-Amerikaner, der als Farmer nicht
besonders erfolgreich war.
Mit fünf Jahren begann Charlie zu arbeiten. Mit 14 Jahren
verrichtete er die Arbeit eines erwachsenen Mannes.
Seine Arbeit war Schwerarbeit, aber Schweiß, Schmutz und
Plackerei waren ihm zuwider. Er arbeitete mit den Händen, weil es
notwendig schien — doch während er arbeitete, überlegte er: Gibt
es keine bessere, schnellere und leichtere Art, eine Farm zu
betreiben?
So lernte er Bücher und Zeitschriften schätzen. Er kaufte jedes
gute Buch über landwirtschaftlichen Betrieb, das er sich leisten
konnte.
 Er war ein Leser und Denker. Das war der Anfang seines Erfolges.
Mit 25 Jahren hatte er drei bestimmte Ideen:
1. Die Farm braucht mehr Regen.
2. Die Farm braucht mehr Düngemittel.
3. Eine Ernte im Jahre ist nicht genug.
Zunächst richtete er ein oberirdisches Berieselungssystem ein. Er
führte eine 1¼zöllige eiserne Röhre über sechs Fuß hohe Pfosten.
Die Röhre war durchlocht, um einen feinen Sprühregen zu
ermöglichen. Die Röhren wurden 50 Fuß voneinander aufgestellt. Er
erprobte dieses System auf einer Fläche von drei Morgen und die
Ergebnisse waren vorzüglich.
So verbesserte er die Natur. Er schuf künstlichen Regen. Wo früher
nur ein Stengel wuchs, ließ er nun deren zehn wachsen.
Bis zu seinem 25. Jahre arbeitete Charlie Seabrook für seinen
Vater. Von da an arbeitete der Vater für Charlie — er war einer der
klügsten Väter, von denen ich je gehört habe.
Im Jahre 1911 verdienten die beiden Seabrooks 5000 Pfund
Sterling. »Jetzt wollen wir das auf die Bank legen«, sagte der Vater.
»Nein,« sagte Charlie, »wir wollen es wieder in den Boden
stecken. Der Boden ist die beste Bank.«
Sie steckten es in den Boden. Sie verschwendeten es gleichsam an
den Boden. Die Nachbarfarmer hielten sie für verrückt.
»Bringt dir dein Geschäft einen Schilling — tue ihn wieder in das
Geschäft, um mehr zu verdienen!«
Das ist einer der Grundsätze, den Charlie Seabrook aus seinen
Büchern gelernt hatte.
Wie wenige Farmer erkannte er den Wert des Kunstdüngers. Er
fand, daß der Boden erst geschaffen werden müsse, daß ihn die
Natur erst zur Hälfte geschaffen hat.
 Gewöhnlicher Boden ist ebensowenig Boden wie vier Räder und
ein Zahnrad ein Motorwagen sind. Er ist nur ein Anfang — ein Ort,
auf dem die Ernten stehen sollen.
Der junge Seabrook begann also, Boden zu machen. Er tat
hundert Tonnen Düngemittel pro Morgen in Neuland und vierzig
Tonnen in altes. Dann verteilte er pro Morgen zwei oder drei Tonnen
Knochenmehl zu 12 Pfund Sterling die Tonne über die hundert
Tonnen.
Hundert Tonnen pro Morgen; zu zehn Schilling die Tonne: 74
Pfund Sterling pro Morgen ausschließlich für Düngung! Kein Wunder,
daß die übrigen Farmer sich über Seabrook und seine
Buchgelehrsamkeit lustig machten.
Dazu kamen noch die Kosten der Berieselung, 60 Pfund Sterling
pro Morgen. Die Kosten des Landerwerbes betrugen nicht weniger
als 30 Pfund Sterling pro Morgen, so daß die Gesamtkosten pro
Morgen waren:
Landerwerb 30 Pfd. Sterl.
Berieselung 60 „ „
Düngung 74 „ „
Summe: 164 Pfd. Sterl.
Die Seabrook-Farm war bis zum nächsten Jahre ein Gegenstand
der Belustigung, bis der Dorfkaufmann die erstaunliche Geschichte
erzählte, daß Charlie Seabrook auf einem einzigen Morgen eine
Ernte im Werte von mehr als 400 Pfund Sterling erzielt hatte. Von da
ab hörten die übrigen Farmer auf, Witze zu machen. Sie verstanden
nicht, was geschehen war, aber sie hätten es gerne verstanden.
Nur um zu zeigen, was Seabrook wirklich tat, führe ich hier eine
Seite aus seinem Farmwirtschaftsbuch an, die erzählt, was auf einem
einzelnen Morgen geschehen ist:
»Spinat, angepflanzt am 25. Februar, Spinat verkauft am 15. April
für 30 Pfund Sterling. Kartoffeln, angepflanzt am 10. Mai, verkauft
10. August für 90 Pfund Sterling. Salat angepflanzt 11. August,
untermischt mit Erdbeeren. Salat verkauft Oktober um 100 Pfund
Sterling.
Gesamtverkauf 220 Pfund Sterling.«
»Zweites Jahr: Eine halbe Ernte Erdbeeren verkauft für 120 Pfund
Sterling.«
»Drittes Jahr: Eine volle Erdbeerenernte 260 Pfund Sterling, eine
Ernte Kopfsalat 200 Pfund Sterling, eine Ernte Spinat 30 Pfund
Sterling. Gesamtverkauf 490 Pfund Sterling.«
Das macht im Durchschnitt 277 Pfund Sterling pro Morgen. Der
Bruttonutzen war daher gegen 130 Pfund Sterling pro Morgen.
Seabrook erzielt drei Ernten im Jahr — manchmal vier.
Zum Beispiel hatte er in einem Jahr auf demselben Land Ernten von
Spinat, Kartoffeln, Kopfsalat und wieder Spinat.
In einer Ernte auf einem Morgen erhielt er 604 Scheffel Kartoffeln.
Von einem einzigen Land erntete er 8500 Liter Erdbeeren.
Seine Spezialität ist Salat, weil er herausgefunden hat, daß er am
einträglichsten ist. In einem Jahr hat er zum Beispiel folgende
Verkäufe erzielt:
Salat 22.410 Pfd. Sterl.
Kohl 7.859 „ „
Radieschen 7.360 „ „
Spinat 6.394 „ „
Zwiebeln 4.954 „ „
Kartoffeln 4.952 „ „
Erdbeeren 3.781 „ „
Gurken 3.509 „ „
Charlie Seabrook besitzt jetzt 1200 Morgen. Aber beinahe sein
ganzer Ertrag kommt von 200 Morgen. Er hat seine Farm zu einer
Aktiengesellschaft organisiert. Er hat ein voll eingezahltes Kapital von
100 000 Pfund Sterling. Und er zahlt 20 Prozent Dividende.
 Auf seiner Farm hat er 300 Arbeiter, zur Zeit der Erdbeerernte oft
zweimal so viel.
Seine Arbeiter wohnen in netten Betonhäusern auf der Farm. Sie
arbeiten das ganze Jahr zehn Stunden täglich und werden
wöchentlich bezahlt.
Wenn Sie fragen: »Wie aber beschäftigt man sie im Winter?«, so
ist die Antwort: »Auf der Seabrook-Farm gibt es keinen Winter.«
Es sind da sechs enorme Glashäuser im Ausmaß von 60 : 300 Fuß.
Jedes von ihnen hat 200 Pfund Sterling gekostet — zuerst wurden
sie der »Seabrook-Wahnsinn« genannt.
Diese Glashäuser verlängern für Seabrook das Jahr. Sie schaffen
den Winter ab. Sie ermöglichen es ihm, Gemüse außerhalb der
Saison zu ziehen und zu Höchstpreisen zu verkaufen. Er
beabsichtigt, noch mehr Glashäuser zu bauen.
Außerdem gehen im Winter seine Arbeiter in eine auf der Farm
errichtete Kistenfabrik und machen hunderttausend Kisten — für den
eigenen Bedarf.
Die Farm hat auch einen Kühlspeicher im Ausmaß von 60 : 325
Fuß, eine Garage für vier Traktoren und acht Lastkraftwagen, einen
Stall für fünfzig Pferde, eine Maschinenwerkstatt für Reparaturen, ein
Eisenbahnstockgeleise und ein großes, modern organisiertes
Bureaugebäude.
»Es ist keine Farm«, sagt Seabrook. »Es ist eine
Nahrungsmittelfabrik.«
 George F. Johnson.
Ich sollte dieses Kapitel eigentlich mit den Worten: »Es war
einmal« beginnen, aber die Wahrheit ist, daß ich im Begriffe stehe,
die größte und einträglichste Schuhfabrik der Welt zu beschreiben.
Es ist also kein Märchen. Es ist die Geschichte wirksamen Betriebes
in der weitestgehenden Bedeutung.
Etwa hundert Meilen von Neuyork entfernt liegt ein schönes Tal in
den Vereinigten Staaten.
Die Leute, die dort leben, nennen es:
Das Tal des »Fairplay«.
In diesem Tale liegen dicht nebeneinander zwei Städte, die eine
heißt Johnson, die andere Endicott.
Gegen 50 000 Einwohner leben in diesem Tale, und 15 000 davon
arbeiten in den beiden großen Schuhfabriken, die der Endicott-
Johnson-Gesellschaft gehören.
Sie fabrizieren täglich 81 000 Paar Schuhe.
Der Wert dieser Erzeugung übersteigt jährlich 28 000 000 Pfund
Sterling.
Diese erstaunlichen Ziffern lassen Sie erkennen, daß die Leute in
diesem Tal zu arbeiten verstehen. In diesem Tale des »Fairplay« wird
mit der Arbeit nicht gespielt.
Wären Ihnen aber diese Zahlen nicht vor Augen, so könnten Sie
glauben, daß die Leute in diesem Tal nichts anderes als Spaß im Sinn
haben.
Es gibt in diesem Tal keine Wohnhöhlen. Es gibt wenige
Mietshäuser. Die meisten Familien besitzen ihr eigenes Haus. Die
Häuser sind aus Holz erbaut und in lebhaften Farben bemalt.
 Zwischen den beiden Städten liegt ein weiter Landstrich, der
»Idealpark« genannt ist. In ihm ist eine große Schwimmanstalt, frei
für alle, daneben ein kleines Schwimmbassin für die Kinder. Ebenso
ein Karussell, frei für alle.
Dann gibt es einen Tanzpavillon, der an drei Abenden der Woche
geöffnet ist. Die Tänzer zahlen 25 Cent Eintritt.
Dann gibt es einen Ballspielplatz, groß genug, um zwei Partien
gleichzeitig Platz zu bieten, und da die Fabriken 4 Uhr 30 Minuten
geschlossen werden, gibt es jeden Nachmittag zwei Baseballspiele.
Auch eine Rennbahn ist da — eine halbe Meile lang, mit Ställen
und Tribünen. Jeden Sonnabend Nachmittag finden Rennen statt,
und zeitweilig ist die Rennbahn von hunderttausend Leuten
eingesäumt.
Inmitten einer weiten Rasenfläche steht ein Klubhaus. Der Rasen
ist mit Blumenbeeten wie gespickt. Das Haus ist das Zentrum der
Geselligkeit, wo jeder jeden trifft. Es enthält eine freie Bibliothek,
besondere Zimmer für Pfadfinderjungen, Spielzimmer und
Speisesäle. Jeden Abend findet man sich hier fröhlich zusammen.
Scherz! Geselligkeit! Erziehung! Sport! Musik! Das scheinen die
allein wesentlichen Dinge im Tale von »Fairplay« zu sein und
dennoch erzeugen diese lustigen Schuhmacher täglich 81 000 Paar
Schuhe.
Ihre tägliche Durchschnittserzeugung ist elf fertige Schuhe pro
Mann.
In diesem Tale glaubt man daran, daß das Spiel der Sonnenschein
des Lebens ist und daß jeder es so sehr braucht wie Nahrung.
Man glaubt dort an Lachen, Liebe und Lebensfreude gerade so
sehr wie an Maschinen, Kohle, Organisation.
Sie werden erraten, daß in diesem Tale ein Mann lebt, der diese
Erfolge begründet hat. Sein Name ist George F. Johnson, aber
jedermann nennt ihn »George F.«.
 Er lebt in einem netten Hause in der Nähe des Parks. Er ist immer
sichtbar. Er lebt, bewegt sich und hat sein Dasein inmitten seiner
Leute.
Jeder Arbeiter kann ihn in seinem Bureau sprechen. Ist er nicht in
seinem Bureau, so kann man ihn auf der Rennbahn, im Tanzpavillon
oder bei einem Ballspiel antreffen.
Für gewöhnlich ist er umgeben von einer Schar von Kindern oder
von einer Arbeitermenge. Ununterbrochen fragen die Leute ihn um
Rat in allen erdenklichen Angelegenheiten. »Er ist der Papa unserer
Familie,« sagen sie.
Jedes Kind auf der Straße nennt ihn »George F.«. Denkt daran und
erschauert, ihr steifgeborenen Direktoren mit den versteinerten
Gesichtern! Hier ist ein Mann, der 28 000 000 Pfund Sterling im Jahr
umsetzt, und der Zeit hat, Drachen steigen zu lassen und Puppen zu
flicken.
Am letzten Maitage hatten die Arbeiter seines Tales eine große
Parade von 20 000 Mann, und wer glauben Sie, führte sie? George F.
Er ging an der Spitze seiner Leute, wie jedermann es von ihm
erwartete.
»Sie wissen, ich liebe alle diese Leute«, sagte er zu einem Freund,
als sie zusammen auf der Tribüne saßen und auf das nächste
Pferderennen warteten. »Und ich hoffe,« fügte er hinzu, »daß einige
von ihnen auch mich lieben.«
Er ist kein Philantrop, dieser George F., weder ist er ein Genie noch
ein Übermensch. Er ist nichts weiter als
ein großer, einsichtsvoller, gutherziger Mann,
der es liebt, inmitten geschäftiger, frohsinniger Menschen zu leben.
In diesem Tal gibt es keine Verdächtigung und keinen Snobismus.
Es gibt dort kein »Klassenbewußtsein«, weil es keine Klassen gibt.
Jeder Arbeiter hat die Möglichkeit, Teilhaber zu sein, und jeder
Kapitalist arbeitet.
 Die sämtlichen 15 000 Arbeiter von George F. abwärts bis zu dem
kleinsten Jungen in der Gerberei gehören alle den »E.-J. Workers«,
der dortigen Gewerkschaft an.
Alles geschieht offen. Jedermann kann seine Meinung äußern. Es
gibt keine Maßregelungen. Alle Arbeiter scheinen zu fühlen, daß die
ganze Anlage ihnen gehört.
George F. Johnson ist jetzt über 70 Jahre alt. Er ist der
erfolgreichste unter allen Schuhfabrikanten, aber vor 35 Jahren war
er noch nichts als ein Vorarbeiter in einer kleinen Schuhfabrik, die
zusammengebrochen war. Damals erzielt er weniger als 20 Dollar
wöchentlichen Lohn.
Der Hauptgläubiger dieser kleinen bankrotten Fabrik war ein
Finanzmann namens Endicott, der in Boston lebte. Er kam
nachzusehen, was man tun könne. Er lernte dort F. Johnson kennen,
und Johnsons Vernunft und Ernst machten ihm einen tiefen
Eindruck.
»Ich habe kein Geld,« sagte Johnson, »aber ich kann aus dieser
Fabrik einen Erfolg machen. Mir liegt nichts an einem Gehalt, aber
wenn Sie mir den halben Anteil an der Fabrik für 150 000 Dollar
verkaufen wollen, will ich Ihnen meinen Wechsel dafür geben.«
Das war ein erstaunlicher Vorschlag. Er war absurd und riskant,
aber Endicott war ein weiser Mann, und er stimmte zu. Er wettete
150 000 Dollar auf Johnson.
Die kleine Fabrik machte ihre Fortschritte in Riesensprüngen. Sie
wuchs, bis Johnson sich als Vater einer Familie von 15 000 fand.
Die Arbeiter seiner Fabrik leben jetzt in zwei Städten, die gänzlich
ihnen gehören und die sie »Endicott« und »Johnson« genannt
haben.
Sie sind nicht Angestellte im gewöhnlichen Sinne. Sie sind
Teilhaber.
Gerade so wie Endicott Johnson zu seinem Teilhaber machte, ohne
von ihm Bezahlung für seine Aktien zu verlangen, so hat Johnson
aus seinen Arbeitern Teilhaber gemacht.
Vier Fünftel von ihnen arbeiten im Akkord und alle nehmen an
dem Nutzen teil, sobald sie ein Jahr lang in der Fabrik tätig gewesen
sind.
Alljährlich werden auf die Vorzugsaktien sieben Prozent und auf
die Stammaktien zehn Prozent Dividende gezahlt; der gesamte dann
noch verbleibende Nutzen wird zu gleichen Teilen zwischen den
Arbeitern und den Inhabern der Stammaktien geteilt.
Die Gesellschaft beschließt jedes Jahr, ob der Nutzen in Geld oder
in Stammaktien auszuzahlen ist. Für gewöhnlich beträgt der
Nutzanteil der Arbeiter 50 Prozent ihres gesamten Lohnes.
Der Hauptunterschied zwischen dieser Endicott-Johnson-
Gesellschaft und anderen guten Firmen scheint zu sein, daß die
Arbeiter auch ihrerseits volle Leistung geben. Sie geben ebenso wie
sie bekommen.
So hat zum Beispiel vor kurzem George F. Johnson die beiden
Städte mit einem prachtvollen Denkmal beschenkt, das der Bildhauer
Moretti zur Erinnerung an die 1692 Angestellten des Werkes
ausgeführt hat, die in dem großen Kriege gekämpft hatten.
Dann wiederum beschenkten die Arbeiter ihrerseits Johnson mit
einem schönen Marmorportal. Die gesamten Kosten dieses
Bauwerkes trugen die Arbeiter.
Oft hält George F., der Vater dieser beiden Städte, Ansprachen an
seine Leute — klare, einfache Ansprachen von eindringlicher
Wirkung. So sagte er unter anderem:
»Wenn Sie Besseres leisten, gehört der Nutzen in dieser
Gesellschaft Ihnen. Niemand steht da und wartet darauf, ihn Ihnen
wegzunehmen.«
»Jeder von uns auf dieser Welt braucht jemand, der uns veranlaßt,
unser Bestes zu tun.«
 »Wir können unsere Erzeugungskosten herabsetzen, ohne unsere
Löhne zu vermindern,
wenn wir alle zusammenwirken wollen, um die Nichtproduzierenden
auszuscheiden, die Bremser und die Schmarotzer.«
»Ich bitte euch nicht, irgend etwas für mich zu tun. Ich bitte euch
nur, euer Bestes für euch zu tun. Und das Beste, das ihr heute tun
könnt, ist noch nicht das Beste, das ihr morgen tun könnt.«
»In diesem demokratischen Geschäft müssen wir uns alle selbst
fragen: Wieviel Arbeiter haben wir angestellt, die wir entbehren
könnten? Wie viele sind nur eine Belastung und eine Ausgabe für
uns?«
»Seid keine Bürde! Schafft keine Hindernisse! Faßt euer Ruder und
zieht fest an. Seid der Mühe wert! Tut euer Bestes! Gebt dem alten
Geschäft seine Chancen!«
 Thomas A. Edison.
Edison ist jetzt bald 80 Jahre alt. Er wurde in Ohio von englisch-
holländischen Eltern geboren. Sein Vater war ein Landwirt und
Getreidehändler ohne besondere Erfolge.
Mit acht Jahren wurde Edison zur Schule geschickt. Drei Monate
später schickte ihn der Lehrer mit der Bemerkung nach Hause, daß
er zu dumm sei, um unterrichtet zu werden. (Was für ein Narr war
dieser Lehrer.)
Edison hatte niemals mehr Schulunterricht. Seine Mutter, eine
kluge und gute Frau, unterrichtete ihn selbst.
Er war immer ein eigentümlicher Junge. Mit sechs Jahren fand
man ihn einmal auf Gänseeiern sitzen, die er auszubrüten versuchte.
Bei einem anderen Anlaß machte er ein großes Experiment in der
Scheune und steckte sie in Brand, wofür er eine gute Tracht Prügel
erhielt.
Von Anfang an hatte er eine Neigung für Chemie. In seinem
räumlichen Hause richtete er sich ein Laboratorium mit 200 Flaschen
ein. Er versah jede einzelne davon mit der Aufschrift »Gift«, damit
niemand sie berühren sollte.
Mit 14 Jahren wurde er Zeitungsjunge und verkaufte Magazine
und Zeitungen auf Eisenbahnzügen.
Er hatte auf dem Zuge ein kleines Laboratorium. Schließlich
steckte er damit den Zug in Brand, und der Schaffner warf ihn
hinaus und ließ seine Flaschen folgen. Auch gab er dem Jungen eine
so mächtige Ohrfeige, daß er seit damals taub wurde.
Mit 16 Jahren wurde er in Kanada Telegraphenbote. Er verlor aber
seine Anstellung, weil er eine arbeitsparende Erfindung machte —
sein Vorgesetzter sagte, er wäre faul. Aus ähnlichen Gründen verlor
er später noch drei weitere Anstellungen.
Mit 23 Jahren wanderte er nach Neuyork. Dort kam er ohne einen
Heller an. Er erhielt eine Stellung in dem Bureau einer
Börsentelegraphenfirma mit 300 Dollar monatlich. Das war seine
erste Chance. Er erhielt dieses hohe Gehalt, weil er es
zustandegebracht hatte, eine wertvolle Maschine zu reparieren, die
in Unordnung geraten war.
Im nächsten Jahre erfand er einen Telegraphenapparat, den er der
Western Union Telegraphen-Gesellschaft für 40 000 Dollar verkaufte.
Er hätte auch ganz gerne 400 000 Dollar dafür genommen, da er von
dem Wert seiner Erfindung zu jener Zeit keine Ahnung hatte.
Er benutzte diese 40 000 Dollar, um eine Maschinenwerkstatt zu
eröffnen. Im Jahre 1873 kam er das erstemal nach England und
verkaufte einige seiner Erfindungen.
Eine englische Firma machte ihm ein Angebot von
»dreißigtausend« für eines seiner Patente. Edison dachte, es
bedeutete 30 000 Dollar — er sagte: »Ja.« Zu seiner Überraschung
erhielt er 30 000 Pfund — fünfmal so viel. Seit jener Zeit hat Edison
ein warmes Gefühl für England.
Edison ist der fruchtbarste Erfinder der Welt. Er hat über 1000
Patente erworben. 45 Jahre lang ist er ein berufsmäßiger Erfinder. Er
ist der ausdauerndste aller Experimentierer. Er arbeitete schwerer
und schläft weniger als irgendein anderer Mensch. Es liegt ihm
nichts am Geld. Er raucht und kaut Tabak.
Er haßt neue Kleider. Seit 30 Jahren ist ihm nicht für einen neuen
Anzug Maß genommen worden. Vor 30 Jahren hat ihm irgendein
gewisser Schneider Maß genommen und seither geht er immer
wieder zu diesem und sagt: »Ich möchte einen anderen Anzug von
dem gleichen Stoff.«
Er hat viele Mißerfolge und einige wunderbare Erfolge
aufzuweisen. Einmal wendete er zwei Jahre und 2 000 000 Dollar an
eine Erfindung, die sich als ziemlich wertlos herausstellte.
 Er macht sich nichts aus Ehren. Eine englische Universität bot ihm
ein Ehrendoktorat — er hat sich niemals die Mühe genommen,
hinzukommen, um es in Empfang zu nehmen. Vor einiger Zeit wurde
ihm in Neuyork eine Goldene Medaille verliehen. Er verlor sie
unterwegs auf dem Fährboot. »Was liegt daran«, sagte er zu seiner
Frau. »Ich habe mindestens zwei Liter solcher Medaillen in meinem
Zimmer.«
Als er das letztemal in Frankreich war, erhielt er das Kreuz der
Ehrenlegion. Er nahm das Kreuz an, aber als man ihm auch die
Schärpe anlegen wollte, zog er sich zurück und ließ es nicht zu. Nach
seiner Denkungsart ist eine Schärpe an einem Mann ungefähr so
töricht wie ein Band an einem Frosch.
Seine Erfindungen haben viel zur Bequemlichkeit und
Annehmlichkeit der Welt beigetragen. Tatsächlich war sein ganzes
Leben sozialer Dienstleistung gewidmet.
Sein intimster Freund ist vielleicht Henry Ford — ein anderer
Erfinder von gleichem Typus. Diese beiden Männer gehen
gemeinsam mit John Burroughs, dem führenden Naturforscher
Amerikas, jeden Winter auf eine Pflanzung nach Florida.
Edison hat niemals einen unbeschäftigten Augenblick. Selbst wenn
er spielt, erfindet er. Ich habe ihn bei verschiedenen Gelegenheiten
in seinem langen schmalen Laboratorium in Neujersey beobachtet,
wie er grübelte und grübelte und grübelte, immer in irgendein
schweres Problem vertieft.
Edison glaubt selten etwas, bevor er den Beweis dafür hat. Er hat
eine Fülle von Zweifeln in Bezug auf die Meinungen und die
Praktiken der Menschen auf Lager.
In seiner Bibliothek hat er mehr als zehntausend Bücher, meist
wissenschaftliche Gegenstände. Aber Edison glaubt selten irgendeine
Feststellung in irgendeinem dieser Bücher, bevor er sie selbst
ausprobiert und bewiesen hat.
Bei seiner Arbeit nimmt er ein Buch lediglich als Ausgangspunkt,
um anzufangen. Es bedeutet keineswegs einen Abschluß.
 Sein ganzes Leben hat er damit zugebracht, jenes Niemands-Land
zu erforschen, das außerhalb der Bücher besteht.
Edison ist zuerst und vor allem ein harter Arbeiter. Er verabscheut
Faulheit als die schlimmste von allen Krankheiten. Er wird unter
Umständen einen dummen Menschen beschäftigen, aber niemals
einen faulen.
Edison nimmt nichts als vorausgesetzt an. Er hat eine Abneigung
gegen Menschen, die sprunghaft und oberflächlich sind. In jeder
Sache gräbt er bis an die Wurzeln. Er hat sein ganzes Leben damit
zugebracht, das Warum herauszufinden.
 Lord Rhondda.
Dies ist die Geschichte des Mannes, der, ohne ein Redner zu sein,
sein Leben lang der »ungekrönte König von Wales« war — D. A.
Thomas, der in den letzten beiden Jahren seines Lebens als Lord
Rhondda bekannt war.
»D. A.«, wie seine Freunde ihn nannten, war der größte
Geschäftsschöpfer, den Wales jemals hervorgebracht hat.
Er war der Schöpfer der »Cambrian Coal Combine« — einer
Gartenstadt von 12 000 gutbezahlten Bergleuten. Er gründete mehr
als 30 Gesellschaften, und was immer er anfaßte, wurde ein Erfolg.
Als er im Jahre 1918 starb, betrug sein Vermögen gegen 685 000
Pfund — aber er hätte leicht doppelt so viel haben können. Er war
immer mehr darauf bedacht, ein Geschäft aufzubauen, als seinen
Anteil an dessen Nutzen hereinzubekommen.
D. A. Thomas war ein kaufmännischer Abenteurer von der Art, die
das britische Weltreich aufgebaut hat. Er war mehr als das — er war
ein unabhängiger Denker.
Er war so unabhängig, daß er noch nicht seinem vollen Werte
nach gewürdigt worden ist, wie Sie beim Lesen der folgenden kurzen
Skizze seiner Laufbahn sehen werden.
Er wurde vor 70 Jahren in einem kleinen Dorfe in Wales, dessen
Namen ich nicht buchstabieren kann, geboren. Sein Vater war ein
Krämer, der ein Kohlengeschäft angefangen hatte und dies sehr
bedauerte.
Man erzählt, daß sein Vater vor seinem Kohlenlager stand und sich
von seinen Verlusten sehr bedrückt fühlte, als ein Nachbar mit der
Nachricht zu ihm kam: »Es ist ein Junge.«
 »Gut«, sagte der Vater. »Ich weiß zwar nicht, was aus ihm werden
soll. Für uns gibt es nur noch das Armenhaus.«
Der junge D. A. war anfangs ein zarter Knabe, aber er trainierte
sich zu einem Athleten. Er wurde ein guter Geher, Schwimmer und
Radfahrer. Er war auch ein geschickter Boxer, und ungeachtet seiner
Kurzsichtigkeit wurde er Mittelgewichts-Champion von Cambridge.
Er war immer mutig. Als junger Bursche gewann er die Medaille
der »Royal Humane Society« für eine Lebensrettung. Er sprang in
einen eisigen See und zog einen Mann aus dem Wasser.
Als er 21 Jahre alt war, starb sein Vater, und er begann ein
selbständiges Geschäft. Mit 26 Jahren heiratete er Sybill Haig, die
Tochter eines Kohlenbergwerksbesitzers. Sie hatten ein Kind, die
gegenwärtige Viscountesse Rhondda, die jetzt die weitausgedehnten
Interessen ihres Vaters verwaltet.
D. A. beschäftigte sich mit Politik nicht weniger als mit dem
Geschäft. Aber als Politiker hatte er keinen Erfolg, oder besser
gesagt, er war nicht der Mann, sich in den schlüpfrigen Winkelzügen
des Parlaments zurecht zu finden.
Er war ein Liberaler, aber er ließ sich durch keine Führung
beeinflussen. Er war kein angestelltes Parlamentsmitglied mit dem
Namen seines Meisters auf seinem Halsband.
Er war unabhängig. Das ist das Wort, das in diesen Tagen der
Maschinenmenschen besonders betont werden muß.
Die kunstreichen Ränkemacher der Politik fürchteten und haßten
ihn. Er war zu tüchtig — zu ehrenhaft — zu furchtlos, um ein
Mitglied der Mitglieder zu werden.
Wie Leverhulme wurde er von den Kabinettsmachern vollkommen
vernachlässigt. Es ist eine auffallende Tatsache, daß D. A. Thomas
25 Jahre lang dem Parlament angehört hat und niemals ein
wichtiges Amt bekleidet hat.
Im Jahre 1910 gab er die Politik auf. Es wurde ihm klar, daß er
vollständig ungeeignet war, das Spiel der Politik mitzumachen. Er
war kein guter Redner. Seine Stimme war schwach, und er hatte nie
daran gedacht, sie auszubilden. Er hatte eher eine Verachtung für
fließendes Reden: in einem Lande, das stets von redegewandten
Leuten regiert worden war, entschieden ein Fehler!
Stets zog er das Geschäft der Politik vor. Das Geschäft war sein
Leben. Er liebte seine Aufregungen und seine Nützlichkeit.
Immerwährend las er Bücher über Geschäft.
Er war kein Zuschauer. Er war voll Energie — durchaus Tatmensch.
Er liebte seinen großen Schreibtisch in seinem großen Bureau in dem
Cambrian-Gebäude in Cardiff.
Er hatte einen stahlharten Willen, aber er war weder grob noch
laut. Er war ein ruhiger, zäher, schlauer Mann, der alles
vorauszusehen schien.
Er hatte auch Streiks, natürlich. Niemand kann die Bergleute von
Süd-Wales beschäftigen, ohne Streiks zu haben. Aber selbst die
Streikleiter achteten D. A. und sympathisierten mit ihm, wenn die
Schlacht einmal vorüber war.
Sein ganzes Leben lang war er ein Gegner der Staatskontrolle.
Sein einziger Fehler in dieser Hinsicht war sein Vorschlag, ein
Gesundheitsamt zu errichten. Er widersprach der Staatsidee amtlich
fixierter Löhne, ohne Rücksicht auf seine persönlichen Vor- oder
Nachteile.
Er hatte eine Menge Feinde — Leute, die versucht hatten, ihn zu
narren, ihn zu betrügen oder ihn zu bedrohen. »Kein Mann ist sein
Salz wert,« sagte er, »der keine Feinde hat.«
Er verachtete langsame, verschlagene und unverläßliche Leute. Er
war kein Idealist. Er wußte, was Menschennatur ist. Aber er war
durchaus für ein faires Spiel und Festhalten an seinen Regeln.
Als er reich wurde, verdarb ihn sein Geld nicht. Er wurde niemals
ein Nabob. Er war immer gesellig. Er liebte die Arbeiter und zog
jederzeit ein Kohlenbergwerk dem Hause der Lords vor.
 Er liebte die Landwirtschaft, aber er konnte sie nie einträglich
gestalten. Wer kann es? Er hatte eine große Herde von Hereford-
Schafen und einen großen Landsitz in Monmouthshire.
Während des Krieges legte er alle Privatangelegenheiten beiseite
und stellte seine volle Energie der Regierung zur Verfügung.
Er und seine Tochter waren an Bord der »Lusitania« bei ihrem
Untergang, wurden aber aufgefischt und gerettet. Kaum in England
angelangt, wurde er ersucht, wieder den Ozean zu kreuzen — und er
tat es. Er war ein Mann ohne Furcht.
Als Nahrungsmittelkontrolleur hatte er mehr Erfolg als irgendein
anderer Träger dieses Amtes in irgendeinem andern Land.
Jedermann fühlte, daß er vollkommen gewissenhaft vorging und
daß, was immer er tat, das Rechte war.
Schließlich, im Jahre 1918, wurde er von seiner Bürde erdrückt. Er
starb — 20 Jahre zu früh. Er gab sein Leben für sein Land, so gut
wie irgendein Kämpfer.
Er war ein charakteristischer britischer Geschäftsmann vom
vornehmsten Typ. Er liebte Wales, seine Bergleute und das ganze
Land. Seinen Adelstitel nahm er von dem Rhonddatal, wo seine
Bergleute lebten. Und er überschüttete Cardiff mit Geschenken.
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!

ebookmass.com