Cover image for Beyond Java

Book description

Bruce Tate, author of the Jolt Award-winning Better, Faster, Lighter Java has an intriguing notion about the future of Java, and it's causing some agitation among Java developers. Bruce believes Java is abandoning its base, and conditions are ripe for an alternative to emerge.

In Beyond Java, Bruce chronicles the rise of the most successful language of all time, and then lays out, in painstaking detail, the compromises the founders had to make to establish success. Then, he describes the characteristics of likely successors to Java. He builds to a rapid and heady climax, presenting alternative languages and frameworks with productivity and innovation unmatched in Java. He closes with an evaluation of the most popular and important programming languages, and their future role in a world beyond Java.

If you are agree with the book's premise--that Java's reign is coming to an end--then this book will help you start to build your skills accordingly. You can download some of the frameworks discussed and learn a few new languages. This book will teach you what a new language needs to succeed, so when things do change, you'll be more prepared. And even if you think Java is here to stay, you can use the best techniques from frameworks introduced in this book to improve what you're doing in Java today.

Table of Contents

  1. Beyond Java
  2. SPECIAL OFFER: Upgrade this ebook with O’Reilly
  3. Preface
    1. Who Should Read This Book?
    2. Conventions
    3. Using Code Examples
    4. Comments and Questions
    5. Safari® Enabled
    6. Acknowledgments
  4. 1. Owls and Ostriches
    1. 1.1. Ignorance as a Virtue
      1. 1.1.1. Shaken to the Core
    2. 1.2. Boiling Frogs
      1. 1.2.1. Danger Signs
      2. 1.2.2.
        1. 1.2.2.1. Complexity
        2. 1.2.2.2. Rapid revolution
        3. 1.2.2.3. Unnatural stretching
        4. 1.2.2.4. Language evolution
      3. 1.2.3. What's Good Is GOOD
    3. 1.3. New Horizons
      1. 1.3.1. Dynamic Languages
      2. 1.3.2. Metaprogramming
      3. 1.3.3. Continuation Servers
    4. 1.4. The Premise
  5. 2. The Perfect Storm
    1. 2.1. Storm Warnings
      1. 2.1.1. Economics of Client-Server Computing
      2. 2.1.2. Microsoft
      3. 2.1.3. The Internet
      4. 2.1.4. Object Orientation
    2. 2.2. The C++ Experience
      1. 2.2.1. Pointer Arithmetic
      2. 2.2.2. Nested Includes
      3. 2.2.3. Strings
      4. 2.2.4. DLL Hell
      5. 2.2.5. CORBA
      6. 2.2.6. Inheritance Problems
      7. 2.2.7. Consistency
      8. 2.2.8. Portability
      9. 2.2.9. Compromises
    3. 2.3. Clouds Open
      1. 2.3.1. New Economics
      2. 2.3.2. C++ on Prozac
      3. 2.3.3. Architecture
    4. 2.4. Fury Unleashed
      1. 2.4.1. Servlets
      2. 2.4.2. J2EE
      3. 2.4.3. Industry Standards
      4. 2.4.4. Open Source
    5. 2.5. Aftermath
    6. 2.6. Moving Ahead
  6. 3. Crown Jewels
    1. 3.1. Language and JVM Design
      1. 3.1.1. Portability
      2. 3.1.2. Security
        1. 3.1.2.1. Changing threats
        2. 3.1.2.2. Remedies in Java
      3. 3.1.3. Moving Forward
    2. 3.2. The Internet
      1. 3.2.1. A Consistent Evolving Vision
      2. 3.2.2. Moving Forward
    3. 3.3. Enterprise Integration
      1. 3.3.1. Moving Forward
    4. 3.4. Community
      1. 3.4.1. The Importance of Open Source
      2. 3.4.2. Moving Forward
    5. 3.5. Breaking the Myths
      1. 3.5.1. Myth 1: Java's Leadership Is Unassailable
      2. 3.5.2. Myth 2: Java Is a Great Applications Language
      3. 3.5.3. Myth 3: Java Is the Most Productive Language
        1. 3.5.3.1. Corollary 3a: All languages are about the same
      4. 3.5.4. Myth 4: Commercial Interests Drive Most Java Innovation
      5. 3.5.5. Myth 5: Big Things Usually Come from Likely Sources
      6. 3.5.6. Looking Ahead
  7. 4. Glass Breaking
    1. 4.1. Java's New Job Description
      1. 4.1.1. Typical Requirements
      2. 4.1.2. The Learning Curve
        1. 4.1.2.1. Java for the typical application
      3. 4.1.3. Agile Processes
        1. 4.1.3.1. Development processes and Java
    2. 4.2. Basic Java Limitations
    3. 4.3. Typing
      1. 4.3.1. Strong Versus Weak Typing
      2. 4.3.2. Static Versus Dynamic Typing
      3. 4.3.3. Syntax
      4. 4.3.4. Thought Process
      5. 4.3.5. Code/Compile Cycle
      6. 4.3.6. Adaptability
      7. 4.3.7. Generics
      8. 4.3.8. Overloading
      9. 4.3.9. Other Costs
      10. 4.3.10. The Benefits of Static Typing
      11. 4.3.11. A Safety Net with Holes
    4. 4.4. Primitives
      1. 4.4.1. Primitives Are Limited
      2. 4.4.2. Primitives Are Unnaturally Verbose
      3. 4.4.3. The Big Trade-off
    5. 4.5. Parting Shots
      1. 4.5.1. Sun
      2. 4.5.2. Exceptions
      3. 4.5.3. Expressing Data
      4. 4.5.4. Strings
      5. 4.5.5. Simplicity
        1. 4.5.5.1. Tools
    6. 4.6. Why Not Just Fix Java?
      1. 4.6.1. Libraries and Community
      2. 4.6.2. Alternatives
  8. 5. Rules of the Game
    1. 5.1. Java Raises the Bar
      1. 5.1.1. Portability
      2. 5.1.2. Internet Focus
      3. 5.1.3. Interoperability
        1. 5.1.3.1. XML and structured data
        2. 5.1.3.2. Service-oriented architecture (SOA)
    2. 5.2. Enterprise Integration
      1. 5.2.1. Database Integration
      2. 5.2.2. Transactions and Security
    3. 5.3. Generating the Buzz
      1. 5.3.1. Open Source
      2. 5.3.2. Economics
      3. 5.3.3. Approachability
      4. 5.3.4. The Killer App
    4. 5.4. Language Features
      1. 5.4.1. Dynamic Typing
      2. 5.4.2. Code Blocks and Continuations
      3. 5.4.3. Rapid Feedback Loop
      4. 5.4.4. User Interface Focus
      5. 5.4.5. Dynamic Class Model
      6. 5.4.6. Sound Foundations
    5. 5.5. A Few Potential Suitors
      1. 5.5.1. Perl
        1. 5.5.1.1. What I like
        2. 5.5.1.2. What I don't like
      2. 5.5.2. Python
        1. 5.5.2.1. What I like
        2. 5.5.2.2. What I don't like
      3. 5.5.3. Ruby
        1. 5.5.3.1. What I like
        2. 5.5.3.2. What I don't like
      4. 5.5.4. PHP
        1. 5.5.4.1. What I like
        2. 5.5.4.2. What I don't like
      5. 5.5.5. C# and Visual Basic
      6. 5.5.6. Smalltalk
        1. 5.5.6.1. What I like
        2. 5.5.6.2. What I don't like
      7. 5.5.7. No Silver Bullet
  9. 6. Ruby in the Rough
    1. 6.1. About Ruby
      1. 6.1.1. Ruby Is Fully OO
      2. 6.1.2. Typing
      3. 6.1.3. Conditionals
      4. 6.1.4. Looping
      5. 6.1.5. Ranges
      6. 6.1.6. Regular Expressions
      7. 6.1.7. Containers
      8. 6.1.8. Files
      9. 6.1.9. Why Should You Care?
    2. 6.2. Applying Some Structure
      1. 6.2.1. Classes
      2. 6.2.2. Using Mixins
      3. 6.2.3. Interceptors
      4. 6.2.4. AOP
      5. 6.2.5. Dependency Injection
    3. 6.3. Breaking It Down
      1. 6.3.1. Collapsing Under the Weight of Abstraction?
  10. 7. Ruby on Rails
    1. 7.1. The Numbers Game
      1. 7.1.1. A Blinding Flash of Insight
      2. 7.1.2. Making the Commitment
      3. 7.1.3. Some Numbers
      4. 7.1.4. The Community Response
    2. 7.2. Rails by Example
      1. 7.2.1. Generating a Basic Application
      2. 7.2.2. Managing Relationships and Updating Views
    3. 7.3. Under the Hood
      1. 7.3.1. Active Record
        1. 7.3.1.1. Automatic properties
        2. 7.3.1.2. Association management
        3. 7.3.1.3. Composition
        4. 7.3.1.4. Inheritance
        5. 7.3.1.5. Other features
      2. 7.3.2. Action Pack
        1. 7.3.2.1. Capabilities
    4. 7.4. The Essence
      1. 7.4.1. Is Rails the Killer App?
      2. 7.4.2. Or Is Metaprogramming the Killer Technique?
      3. 7.4.3. Final Thoughts on Ruby and Rails
  11. 8. Continuation Servers
    1. 8.1. The Problem
      1. 8.1.1. What You Want
      2. 8.1.2. Statelessness
      3. 8.1.3. The Back Button
      4. 8.1.4. Navigation
      5. 8.1.5. Continuation Servers to the Rescue
    2. 8.2. Continuations
      1. 8.2.1. The Syntax
      2. 8.2.2. A More Powerful Example
      3. 8.2.3. Why Would You Use Them?
    3. 8.3. Continuation Servers
      1. 8.3.1. Advantages and Disadvantages
    4. 8.4. Seaside
      1. 8.4.1. A Little Smalltalk Syntax
      2. 8.4.2. A Seaside Overview
    5. 8.5. A Seaside Example
      1. 8.5.1. Components
      2. 8.5.2. Complex Control Flows
        1. 8.5.2.1. Debugging and browsing
        2. 8.5.2.2. Tasks
    6. 8.6. So What?
  12. 9. Contenders
    1. 9.1. The Primary Contenders
      1. 9.1.1. Ruby
        1. 9.1.1.1. In favor
        2. 9.1.1.2. Against
        3. 9.1.1.3. Overall
      2. 9.1.2. Python
        1. 9.1.2.1. In favor
        2. 9.1.2.2. Against
        3. 9.1.2.3. Overall
      3. 9.1.3. Groovy
        1. 9.1.3.1. In favor
        2. 9.1.3.2. Against
        3. 9.1.3.3. Overall
      4. 9.1.4. .NET
        1. 9.1.4.1. Language options
        2. 9.1.4.2. Visual Basic for .NET
        3. 9.1.4.3. C#
        4. 9.1.4.4. Other languages on the CLR
        5. 9.1.4.5. A weakness and a strength
    2. 9.2. Minor Contenders
      1. 9.2.1. PHP
      2. 9.2.2. Perl
      3. 9.2.3. Smalltalk
      4. 9.2.4. Lisp
      5. 9.2.5. Functional Languages
    3. 9.3. The Next Big Thing
      1. 9.3.1. A Charge to You
  13. 10. About the Author
  14. Index
  15. About the Author
  16. Colophon
  17. SPECIAL OFFER: Upgrade this ebook with O’Reilly
  18. Copyright