[read.example] Reading the examples
    [read.class] Class terminology used in this book
    [read.glossary] Glossary of words used in this book
    [basic.reinvent] No need to reinvent the wheel
    [basic.tedium] Brute force is not the only way
    [basic.unnecessary] Remove unnecessary noise
    [basic.layout] Well formatted code is easy to debug
    [basic.duplication] Move duplicated code to one place
    [basic.equals] Know your equals
    [basic.parameters] Leave hints for unclear parameters
    [basic.databean] Swap many paramaters for Data Beans
    [basic.struct] Use direct access structures for simple code
    [basic.close] Why do I need to close() things?
    [basic.tostring] What is toString() for?
    [basic.compile] Compile-time Errors beat Runtime Errors
    [basic.nest] Nest code a maximum of four levels deep
    [basic.sequence] Follow a logical sequence in the code
    [basic.noise] Remove obsolete classes from the build
    [basic.loop] Follow industry standard loop patterns
    [basic.repetition] Watch for mindless repetition
    [basic.generic] Fix generic problems generically
    [basic.boolean] Look for 'true' Boolean results
    [basic.notnot] Use 'true' instead of 'not-false'
    [basic.resources] How not to leak resources
    [name.convention] Follow conventions
    [name.abbreviation] Accepted abbreviations are few
    [name.constant] static final variables (constants)
    [name.real] Use real names
    [name.number] Keep numbers out of naming conventions
    [name.magic] Ensure magic numbers have a name
    [name.related] Relate variables through naming conventions
    [name.goodest] Methods - Don't use Good Gooder Goodest
    [name.acronym] Acronyms are words
    [name.invent] Invent new acronyms once
    [name.verbose] Longer variable and method names
    [name.vowel] Vowels are cheap
    [name.english] Use Plain English where possible
    [name.context] Name attributes with respect to the class
    [name.namespace] Consider namespace implications
    [name.repeat] No need to repeat namespace information
    [name.parameter] Naming parameters
    [variable.name] Names for variables
    [variable.verbose] Use verbose variable names
    [variable.scope] Define variables as deep as possible.
    [variable.member] Member variable basics
    [variable.temp] Temp is for temporary only
    [variable.free] Extra variables are free
    [comment.when] When to comment the code
    [comment.not] When NOT to comment
    [comment.deprecated] @deprecated but always say why
    [comment.language] Watch the language in comments
    [comment.useful] Comments should enlighten the reader
    [comment.update] Update or remove obsolete comments
    [comment.jsp] Use correct JSP comments
    [test.junit] Test code with Junit
    [test.coverage] Code Coverage Importance
    [test.waste] Junit testing to oblivion
    [test.vertical] Test vertical slices
    [test.selenium] Write tolerant Selenium tests
    [package.name] Package naming
    [package.dependency] Dependencies between packages
    [package.resuse] Reuse of packages
    [package.reuse] Packages designed for re-use
    [package.refactor] When to refactoring a package
    [package.contents] Deciding package contents
    [class.name] Choosing a class name
    [class.unique] Name classes with common names uniquely
    [class.lifecycle] Life-cycle of a class instance
    [class.purpose] Single purpose classes
    [class.encapsulate] Encapsulate Logic in a Class
    [class.structure] How do you structure a class?
    [class.inherit] When to extend another class
    [class.getname] Use class.getName() instead of a string
    [method.encapsulate] Encapsulate common code in a Method
    [method.how] How to structure a method
    [method.name] Method names
    [method.primary] Method name implies primary function
    [method.structure] Method structure
    [method.lifecycle] Life-cycle of a method.
    [method.return] Returning a value from a method
    [method.return.type] What return types mean
    [method.object] No Object in method signatures
    [method.visible] Control the visibility of a method.
    [method.wrapper] Control wrapper methods
    [method.modify] Parameters are not to be modified
    [method.parameter] Keep method parameters consistent
    [method.split] Split up magic return code methods
    [method.order] Order methods depending on use
    [interface.oop] Use interfaces to provide extensibility
    [interface.name] Naming interfaces
    [interface.impl] Naming interface implementations
    [interface.most] Most classes don't implement interfaces
    [interface.indirection] Too many inherited interfaces.
    [string.buffer] Use StringBuilder instead of StringBuffer
    [string.tokenizing] Dividing a String into portions
    [string.append] Joining strings together
    [trap.static] Be wary of static initialization
    [trap.clever] Clever code is not always easy to debug
    [trap.this] Don’t call methods on ‘this’ in constructors
    [trap.serializable] Serializable on inner classes
    [trap.byte] Limit size of byte arrays
    [trap.gc] Garbage Collection is dead to you
    [exception.why] Why exceptions?
    [exception.understand] Understand Exceptions
    [exception.wrap] Wrap exceptions until recognized
    [exception.try] Trying too hard
    [exception.when] When to use exceptions
    [exception.checked] Checked Exceptions
    [exception.throwable] What to use Throwable for
    [exception.escape] Escaping from legacy code
    [exception.error] It's ok to throw (and catch!) Error
    [exception.rethrow] Why rethrow an exception?
    [exception.cause] Throwable.getCause() for debugging
    [exception.handle] Handle all handleable exceptions
    [exception.name] Suffix exception classes with “Exception”
    [exception.finally] Finally is your friend
    [exception.app] Exception handling for Applications
    [exception.package] Define your own package exceptions
    [exception.message] What to put in exception.getMessage()
    [exception.data] An Exception is not for passing data
    [exception.throw] Exceptions are for throwing
    [exception.generator] Write an exception generator
    [exception.handler] Write an exception handler
    [jar.hell] Jar hell
    [jar.order] Jar loading order
    [stream.lifecycle] Lifecycle of a stream
    [stream.flush] Why flush an output stream?
    [stream.owner] Stream creator is responsible for closing it
    [stream.borrow] Don't close borrowed streams
    [advanced.listener] Sharing listeners
    [advanced.deprecated] Deprecated vs removal
    [advanced.problem] Problems can indicate poor design
    [planning.proliferation] Too many small, similar classes
    [planning.efficiency] Optimise last
    [planning.complexity] Avoid needless complexity
    [oop.type] TYPE alert!
    [oop.multiple] Implementing multiple inheritance in Java
    [oop.real] Concrete classes vs abstract classes
    [oop.super] No need to call super()
    [pattern.read] Read books on patterns
    [pattern.mvc] The Model View Controller (MVC)
    [pattern.clustleton] Clustered Singleton
    [pattern.switcheroo] The Collection Switcheroo
    [clever.stringcompare] String comparison & null checks
    [clever.library] Isolate common code as you go
    [clever.cleanup] Cleanup on shutdown of the JVM
    [debug.all] Go in with all guns blazing
    [debug.log] Forcing an app to provide a log
    [debug.profiling] Worry about profiling last.
    [debug.password] Never log passwords to console or logfiles
    [thread.static] Synchronize on static method
    [thread.daemon] Non daemon 'user' threads prevent shutdown
    [thread.timing] Running a thread for a limited time
    [collection.array] Defining a Java array
    [collection.dimensions] Keep arrays one-dimensional
    [collection.key] Be wary of collection keys
    [collection.containskey] When to use map.containsKey
    [collection.name] name describes what a collection represents
    [collection.return] Returning owned collections
    [collection.nest] Don't nest container classes.
    [collection.wrap] Wrap collections in helper classes
    [upgrade.when] When to upgrade to a new java version
    [upgrade.stringbuilder] StringBuilder instead of StringBuffer
    [upgrade.collection] Use Generics for collections
    [upgrade.loop] Looping made easy
    [upgrade.static] Use static imports carefully
    [project.estimate] Giving Estimates
    [project.simplify] Aim to complete a bite-sized chunk first
    [project.lean] Use small, lean and mean teams
    [project.wiki] Keep a WIKI
    [project.environment] Set up your development environment
    [project.build] Project build scripts.
    [project.framework] Reduce development time-per-screen
    [project.refactor] Refactor refactor refactor.
    [project.developers] Find good java people
    [project.opensource] Use open source readily
    [project.sanity] Sanity check their work
    [project.fired] Get rid of the dead wood
    [project.time] Plan to finish the project in a year or less
    [project.success] Characterisitcs of successful projects
    [project.version] For serious projects, use version control
    [project.freeze] Code freeze before a release.
    [app.name] Invent a unique name for the application.
    [app.production] Are you production grade?
    [app.folder] Install applications together
    [app.source] Common source into libraries
    [app.println] Java logging not System.out.println(..)
    [app.mvc] Keep MVC layers clean
    [app.build] Get a fast end-to-end build working
    [app.logging] Logging
    [app.messages.properties] Where to use messages.properties
    [app.international] Internationalization
    [app.sql] Reduce your dependence on SQL
    [app.tester] Interaction with testers
    [app.config] Match config properties with member variables
    [app.scheduler] Scheduling batch jobs
    [app.transfer] Simple file transfer strategy
    [integration.risk] Integration takes longer than you think
    [integration.point] Remove integration points
    [integration.step] Recommended integration steps
    [integration.model] Exporting an object model as XML
    [integration.validate] Validate on the way in and out
    [integration.middleware] Carefully select middleware
    [webapp.prototype] Get a prototype done early and approved
    [webapp.mvc] Follow the MVC pattern
    [webapp.parameter] Passing parameters between screens
    [webapp.stateless] Stateless Servlets, Actions and Controllers
    [webapp.production] Production grade websites
    [webapp.url] Make the URLs match the filename
    [webapp.global] Global display message for users.
    [webapp.security] Security concepts for web applications
    [webapp.security.roles] Roles vs Permissions vs Access
    [webapp.security.url] Protection against URL rewriting
    [thought.software] Software installation
    [thought.final] Use final only where it adds clarity to do so
    [thought.errorcodes] Give error explanations where possible
    [thought.workspace] Use a simple workspace
    [thought.open] Provide open source project builds
    [cpp.header] Header Files
    [cpp.pointer] Pointers
    [cpp.unions] Unions
    [cpp.operator] Operator Overloading
    [cpp.multiple] Multiple Inheritance
    [cpp.speed] Speed
    [cpp.portability] Portability
    [cpp.platform] Platform Considerations
    [cpp.dma] Direct Memory Access
    [cpp.free] Freeing memory
    [agile.estimation] Estimating Effort
    [agile.story] Everything can be a User Story
    [agile.progress]
    [agile.span] Large User Stories that span iterations
    [agile.reestimation] Re-estimating Story effort
    [agile.burn] Adjust the burn reporting
    [agile.bugs] How are bugs managed in Agile?
    [agile.fixed] Fixed price, fixed scope agile
    [agile.question] Question everything
    [rapid.build] Tame your build
    [career.doco] Documentation is good for you.
    [career.estimate] Never ever give ballpark estimates
    [career.politics] Avoid politics except to trigger change
    [career.challenge] Challenge yourself to new ideas
    [career.reputation] It's a small world.
    [career.certification] Study for certification.
    [career.mentoring] Mentoring
    [career.standards] Follow Standards
    [career.study] Study then Work.
    [career.meticulous] Be Meticulous
    [career.management] Avoid management
    [career.negative] The negative programmer
    [career.professional] Be professional
    [career.slack] The slack programmer
    [career.planet] Reduce the environmental impact of IT
    [career.stuck] Don't get lost in a problem
    [career.family] Look after your private life
    [career.fear] New developer fear-of-failure
    [career.skills] Know what you are good at
    [security.backdoor] The Security Desk
    [security.obscurity] Secret URLs
blog comments powered by Disqus