The Well-Grounded. Java Developer. Vital techniques of Java 7 and Polyglot Programming BENJAMIN J. EVANS MARTIJN VERBURG MANNING.

The

Well-Grounded

Java

Developer

Vital

techniques

of

Java

7

and

Polyglot Programming

BENJAMIN

J.

EVANS

MARTIJN

VERBURG

II

MANNING Shelter Island

contents

foreword xvii

preface xix

acknowledgments xxi

aboutthisbook xxiv about the authors xxix about thecoverillustration xxx

Part 1

Developing

with

Java

7

1

Introducingjava

7 3

1.1 The

language

and the

platform

4

1.2 Small is

beautiful—Project

Coin 5

1.3 The

changes

in _ProjectCoin 9

Stringsin switch 9 Enhanced_syntaxfor

numeric literals 10 _{Improved exception handling} 12 Try-with-^esources(TWR) 13 Diamond_syntax 16

Simplifiedvarargs methodinvocation 17

1.4

Summary

19

New

I/O

20

2.1

Java

I/O—ahistory 22

Java1.0to1.3 22 • Java1.4 andNIO 23

IntroducingNIO.2 24

CONTENTS

2.2 Path—a foundation offile-basedI/O 24

CreatingaPath 27 * Retrieving

information

fromaPath 27

Removingredundancies 28 * ConvertingPaths 29

NIO. 2 Path and_{fava'sexisting}Fileclass 30

2.3

Dealing

with directories and

directory

trees 30

Findingfilesinadirectory 30 * _Walkingthe_{directorytree} 31

2.4

Filesystem

I/Owith NIO.2 33

Creatingand_{deletingfiles} 34 _Copyingand_movingfiles 35 File attributes 36 * _Readingand_writingdata_quickly 40 File_{changenotification} 41 _{SeekableByteChannel} 42

2.5

Asynchronous

_{I/O operations} 43

Future_style 44 * Callbackstyle 46

2.6

Tidying

_{up Socket-Channel}

functionality

47

NetworkChannel 48 * MulticastChannel 49

2.7

Summary

50

JP^AJE^JC

2|

"\^FF.AL

'A.'JhjCIIISfl^^UES

•••••*«»*a«««o«»*a*»««««a«««a«»*c**««e*««

3.1 _Injectsome

knowledge—understanding

IoC and DI 54

Inversion_ofControl 54 _{Dependency Injection} 55

TransitioningtoDI 56

3.2 StandardizedDI in

Java

61

The_@Injectannotation 62 * The©Qualifierannotation 64

The @Named annotation 65 The_@Scopeannotation 65

The_©Singletonannotation 66* TheProvider<T>_interface 66 3.3 Guice 3—the reference

implementation

forDI in_Java 67

Gettingstartedwith Guice 68 * Sailor's knots—the various

bindings ofGuice 70* _{Scopingyourinjectedobjects} with Guice 73

3.4 _Summary 75

4.1

Concurrency

_{theory—a primer} 77

ExplainingJava's threadingmodel 77 _{Design concepts} 79 How and_whydo the_{forces conflict?} 80 Sources_ofoverhead 81 A transaction_{processorexample} 81

Dependency

Injection

53

4.2 _{Block-structured concurrency}

(pre-Java

5) 83

Synchronizationand locks 83 * The_statemodel_forathread 84

Fullysynchronized objects 85 * Deadlocks 86

Why synchronized! 88 * The volatile_keyword 89

Immutability 90

4.3

Building

blocks for modern concurrent

applications

91

Atomic_{classes—-Java,}util.concurrent,atomic 92

Locks—-java.util.concurrent.locks 93* CountDownLatch 96

ConcurrentHashMap 97 * _{CopyOnWriteArrayLisl} 99

Queues 102

4.4

Controlling

execution 108

Modelingtasks 108 * ScheduledThreadPoolExecutor 110

4.5 The_fork/joinframework 111

A_{simplefork/join example} 112 * ForkJoinTaskand

work_stealing 114 * _{Parallelizingproblems} 115

4.6 The

Java Memory

Model _(JMM) 116

4.7 _Summary 118

Class

files

and

bytecode

119

5.1 _Classloadingand class _objects 120

Overview—loadingand_linking 120* _Verification 121 Class_objects 122 * Classloaders 122 Example—classloaders

in_{Dependency Injection} 124

5.2 _Usingmethodhandles 125

MethodHandle 126 *

MethodType 127 * Looking_up

method handles 127 * Example—reflectionvs.proxies

vs.MethodHandles 128* Whychoose MethodHandles? 131

5.3 _Examiningclass files 132

Introducingjavap 132 * Internal_{form for}

method_signatures 132 * _Theconstant_pool 134

5.4

Bytecode

136

Example—disassemblingaclass 137 * The runtime

environment 138 * Introductionto_opcodes 140 Load andstoreopcodes 141 * Arithmeticopcodes 141

Execution control_opcodes 142 * Invocationopcodes 143

Platformoperationopcodes 143* Shortcut_opcodeforms 144 Example—stringconcatenation 144

CONTENTS

5.5

Invokedynamic

146

How_{invokedynamic}works 146 _{Example—disassembling}

aninvokedynamiccall 147

5.6 _Summary 149

Understandingperformance tuning

150

6.1 Performance_{terminology—some}basic definitions 152

Latency 152 * _Throughput 152 * Utilization 153

Efficiency 153 _Capacity 153 * Scalability 154

Degradation 154

6.2 A_{pragmatic approach}to_{performance analysis} 154 Know what_{you're measuring} 155 * Know how

totakemeasurements _{156* Know what yourperformance}

goalsare 157 * Know whento_{stopoptimizing} 157

Know thecost_{of higherperformance} 158 * Know the danger ofpremature optimization 158

6.3 Whatwent_wrong?

Why

we havetocare 159

Moore's Law—historic and_{future performance}trends 160 Understandingthe_{memory latency hierarchy} 161 _Whyis

Java performance tuninghard? 162

6.4 A

question

oftime—from _{the hardware up} 163

Hardware clocks 163 " The trouble_{withnanoTime()} 164

Therok_oftimein_{performance tuning} 166* Acasestudy—

understandingcache misses 167

6.5

Garbage

collection 169

Basics 170 * Markand_sweep 170 *_jmap 172

UsefulJVMparameters 176 * Readingthe GC_logs 177 Visualizingmemoryusage with VisualVM 178

Escape analysis 181 * ConcurrentMark-Sweep 182

Gl—Java'snewcollector 183

6.6 _JIT

compilation

with

HotSpot

184

Introduction to_HotSpot 186 * _Inliningmethods 187

Dynamic compilationand_monomorphiccalls 188 Readingthe_{compilation logs} 188

Part 3

Polyglot

programming on the

JVM

191

Alternative

JVM languages

193

7.1 _Java too

clumsy?

Them's

fighting

words! 194

The reconciliation_system 194* _Conceptualbasics_of functional programming 196* _Mapand_filteridioms 197

7.2

Language zoology

198

Interpretedvs. _{compiled languages} 199 * _Dynamicvs.

static_typing 199 * _{Imperativevs.functional languages} 200

Reimplementationvs._original 201

7.3 _{Polyglot programming}on the

JVM

202

Whyuse anon-Java language? 203

Up-and-coming languages 204

7.4 Howtochoose a _nonjava

language

for_your

project

205

Is the_projectarealow-risk? 205 * Does the_{language intemperate}

well with_Java? 206 Is there_goodtoolingandtest_supportfor

the_language? 207 * How hard is the_languagetolearn? 207

Are there lots_{of developers using}this_language? 208

7.5 How the_JVMsupportsalternative_languages 208 Runtimeenvironments_{fornon-Java languages} 209

Compilerfictions 209 7.6 _Summary 211

Groovy:Java's dynamicfriend

213

8.1

Getting

started with

Groovy

215

Compilingand_running 216* _Groovyconsole 217

8.2

Groovy 101—syntax

and semantics 217

Default imports 219 * Numerichandling 219

Variables, dynamicversusstatictypes, andscoping 220

Syntax forlistsand_maps 222

8.3 Differences from

Java—traps

fornew

players

223

Optionalsemicolons and return statements 224

Optionalparentheses formethod_parameters 224 Access_modifiers 225 *_{Exception handling} 225

Equalityin _Groovy 225 * Inner classes 226

8.4

Groovy

featuresnot

(yet)

in_Java 226

GroovyBeans 227 * Thesafe-dereference_operator 228

CONTENTS

Function literals 230 First-class_supportfor manipulatingcollections 231 First-class_{support for} regular expressions 233 _SimpleXML_handling 234

8.5

Interoperating

between_Groovyand_Java 236

CallingJava fromGroovy 236 _{CallingGroovyfromJava} 237

8.6 _Summary 240

Scala:

powerful

and concise 241

9.1 A

quick

tourofScala 242

Scalaas aconciselanguage 243 " _{Matchexpressions} 245

Case classes 247 Actors 248

9.2 IsScala_{rightfor myproject?} 249

ComparingScala and_Java 250 When and howto start

usingScala 250 _{Signsthat Scala may} notbe_rightfor

yourcurrent_project 251

9.3

Making

codebeautiful_againwith Scala 251

Usingthe_compilerand the REPL 252 * _{Type inference} 252

Methods 254 * _Imports 255 *

Loopsand control

structures 256 m _Functional

programminginScala 257 9.4 Scala's

object

model—similar butdifferent 258

Everythingisanobject 258 * Constructors 259 Traits 260

Singletonand_{companionobjects} 262 Caseclassesand

match_expressions 264 A _cautionarytale 266

9.5 Datastructures and collections 267

List 268 _Map 271 Generic _types 272 9.6 Introductionto actors 275

All the code'sastage 276 Communicatingwithactors

via the mailbox 276

9.7

Summary

278

Clojure: safer

programming

279

10.1

Introducing Clojure

280

Hello World in_Clojure 281 * Gettingstarted with

the REPL 281 - Making_amistake 282

Learningtolove the brackets 283

10.2 _Lookingfor_{Clojure—syntax}and semantics 284

Specialforms bootcamp 284 * Lists,_vectors,

maps, andsets 285

10.3

Working

with functions and_loops in_Clojure 288

Some_{simple Clojurefunctions} 289 _Loopsin_Clojure 291 Readermacrosanddispatch 292 Functionalprogramming

and closures 293

10.4

Introducing

_{Clojuresequences} 295

Lazysequences 297 Sequencesand variable-arity functions 298

10.5

Interoperating

between_Clojureand_Java 299

CallingJava from Clojure 299 " TheJava type

of Clojurevalues 300 * _{UsingClojure proxies 301}

Exploratory programmingwith the REPL 302

Using Clojure fromJava 302 10.6 Concurrent

Clojure

303

Futures and_pcalls 304 * _{Refs 306} * Agents ₃₀₉

10.7

Summary

310

Part 4

Crafting

thepolyglot

project

,

11

12

Test-driven

development

313

11.1 TDD inanutshell 315

A TDD_examplewithasingleuse case 316 * A TDD_example

with_multipleuse cases 320 *Further_thinkingonthe

red-green-refactor lifecycle 322 _JUnit 324

11.2 Test doubles 325

Dummy object 326 * Stubobject 328 Fakeobject 331

Mock_object 336

11.3

Introducing

ScalaTest 338

11.4

Summary

340

Build and continuous

integration

342

12.1

Getting

started with Maven 3 345

12.2 Maven 3—a

quick-start project

346 12.3 Maven 3—the

Java7developer

build 348

The POM 348 * _Runningthe_examples 354

12.4

Jenkins—serving

_yourCI needs 357

Basic_{configuration} 359 * Setting_upajob 360

CONTENTS

12.5 Code metrics with Maven and_Jenkins 365

InstallingJenkins plugins 366 " Makingcode consistent

with_Checkstyle 367 _Settingthe_{quality barwithFindBugs} 369

12.6

Leiningen

372

Gettingstarted with_Leiningen 372 _Leiningen's architecture 373 " _{Example—Hello}Lein 373

REPL-oriented TDD with_Leiningen 376 Packagingand_deployingwith_Leiningen 377

12.7

Summary

379

Rapid

web

development

380

13.1 The

problem

with_Java-basedweb frameworks 381

WhyJavacompilationis bad_{for rapid}web_development 382 Whystatic_typingis bad_{for rapid}web_development 383

13.2 Criteria in

selecting

aweb framework 383

13.3

Getting

started with Grails 385

13.4 Grails

quick-start

_project 386

Domain_objectcreation 387 * Test-drivendevelopment 388

Domain_{objectpersistence} 390 * _{Test data creation 391}

Controllers 392 - _GSP/JSPviews 393

Scaffoldingandautomatic UIcreation 395

Rapidturnaround_development 395 13.5 Further Grails

exploration

396

Logging 396 * GORM—object-relational mapping ₃₉₇

Grails_plugins 398

13.6

Getting

started with

Compojure

399

Hello World with_Compojure 399 _Ringandroutes 401 Hiccup 402

13.7 A

sample Compojure

_{project—"Am}IanOtterorNot?" 403

Settingup "Am Ian Otter" 404 * _Corefunctions_in

"Am Ian Otter" 406

13.8

Summary

409

Staying

well-grounded

410

14.1 Whatto _expectin

Java

8 411 Lambdas _{(a.k.a. closures)} 411

14.2

Polyglot programming

414

Language interoperabilityand_{metaobject protocols} 415 Multilanguage modularity 416

14.3 Future _concurrencytrends 416

The many-core world 417 * Runtime-managed

concurrency 417 14.4 New directions in the_JVM 418

VM_convergence 418* Coroutines 419* _Tuples 421

14.5

Summary

423

appendixA

Java1/7developer—source

code installation 424

appendix

B Glob_{patternsyntax}and_examples 432

appendix

C

Installing

alternative_JVM

languages

434

appendix

D _Downloadingand_{installingJenkins} 441

appendix

E

Java7developer—theMavenPOM

444