Beyond Java - Bruce Tate [95]
Acknowledgments
1. Owls and Ostriches
1.1. Ignorance as a Virtue
1.1.1. Shaken to the Core
1.2. Boiling Frogs
1.2.1. Danger Signs
1.2.2.
1.2.2.1. Complexity
1.2.2.2. Rapid revolution
1.2.2.3. Unnatural stretching
1.2.2.4. Language evolution
1.2.3. What's Good Is GOOD
1.3. New Horizons
1.3.1. Dynamic Languages
1.3.2. Metaprogramming
1.3.3. Continuation Servers
1.4. The Premise
2. The Perfect Storm
2.1. Storm Warnings
2.1.1. Economics of Client-Server Computing
2.1.2. Microsoft
2.1.3. The Internet
2.1.4. Object Orientation
2.2. The C++ Experience
2.2.1. Pointer Arithmetic
2.2.2. Nested Includes
2.2.3. Strings
2.2.4. DLL Hell
2.2.5. CORBA
2.2.6. Inheritance Problems
2.2.7. Consistency
2.2.8. Portability
2.2.9. Compromises
2.3. Clouds Open
2.3.1. New Economics
2.3.2. C++ on Prozac
2.3.3. Architecture
2.4. Fury Unleashed
2.4.1. Servlets
2.4.2. J2EE
2.4.3. Industry Standards
2.4.4. Open Source
2.5. Aftermath
2.6. Moving Ahead
3. Crown Jewels
3.1. Language and JVM Design
3.1.1. Portability
3.1.2. Security
3.1.2.1. Changing threats
3.1.2.2. Remedies in Java
3.1.3. Moving Forward
3.2. The Internet
3.2.1. A Consistent Evolving Vision
3.2.2. Moving Forward
3.3. Enterprise Integration
3.3.1. Moving Forward
3.4. Community
3.4.1. The Importance of Open Source
3.4.2. Moving Forward
3.5. Breaking the Myths
3.5.1. Myth 1: Java's Leadership Is Unassailable
3.5.2. Myth 2: Java Is a Great Applications Language
3.5.3. Myth 3: Java Is the Most Productive Language
3.5.3.1. Corollary 3a: All languages are about the same
3.5.4. Myth 4: Commercial Interests Drive Most Java Innovation
3.5.5. Myth 5: Big Things Usually Come from Likely Sources
3.5.6. Looking Ahead
4. Glass Breaking
4.1. Java's New Job Description
4.1.1. Typical Requirements
4.1.2. The Learning Curve
4.1.2.1. Java for the typical application
4.1.3. Agile Processes
4.1.3.1. Development processes and Java
4.2. Basic Java Limitations
4.3. Typing
4.3.1. Strong Versus Weak Typing
4.3.2. Static Versus Dynamic Typing
4.3.3. Syntax
4.3.4. Thought Process
4.3.5. Code/Compile Cycle
4.3.6. Adaptability
4.3.7. Generics
4.3.8. Overloading
4.3.9. Other Costs
4.3.10. The Benefits of Static Typing
4.3.11. A Safety Net with Holes
4.4. Primitives
4.4.1. Primitives Are Limited
4.4.2. Primitives Are Unnaturally Verbose
4.4.3. The Big Trade-off
4.5. Parting Shots
4.5.1. Sun
4.5.2. Exceptions
4.5.3. Expressing Data
4.5.4. Strings
4.5.5. Simplicity
4.5.5.1. Tools
4.6. Why Not Just Fix Java?
4.6.1. Libraries and Community
4.6.2. Alternatives
5. Rules of the Game
5.1. Java Raises the Bar
5.1.1. Portability
5.1.2. Internet Focus
5.1.3. Interoperability
5.1.3.1. XML and structured data
5.1.3.2. Service-oriented architecture (SOA)
5.2. Enterprise Integration
5.2.1. Database Integration
5.2.2. Transactions and Security
5.3. Generating the Buzz
5.3.1. Open Source
5.3.2. Economics
5.3.3. Approachability
5.3.4. The Killer App
5.4. Language Features
5.4.1. Dynamic Typing
5.4.2. Code Blocks and Continuations
5.4.3. Rapid Feedback Loop
5.4.4. User Interface Focus
5.4.5. Dynamic Class Model
5.4.6. Sound Foundations
5.5. A Few Potential Suitors
5.5.1. Perl
5.5.1.1. What I like
5.5.1.2. What I don't like
5.5.2. Python
5.5.2.1. What I like
5.5.2.2. What I don't like
5.5.3. Ruby
5.5.3.1. What I like
5.5.3.2. What I don't like
5.5.4. PHP
5.5.4.1. What I like
5.5.4.2. What I don't like
5.5.5. C# and Visual Basic
5.5.6. Smalltalk
5.5.6.1. What I like