The Pragmatic Programmer: From Journeyman to Master.

Hello, my dear reader!

Today I'm going to provide some thoughts after reading the Pragmatic Programmer book.
Here are the thoughts that caught me:

1. Tag a commit, to see how many number of files affected by the bug fix.
2. Find the opportunity to refine the code.
3. Flexible, adaptable design.
4. Deployment: stand-alone, client-server, n-tier model just by changing a configuration file.
5. Domain specific language.
6. Know your shell & text editor.
7. Fix the problem, not the Blame.
8. Bertrand Meyer.
9. Design by contract for java.
10. Perl for text processing.
11. Pluggable exception handlers.
12. Resources: memory, transactions, threads, files, timers, sockets.
13. Metaprogramming.
14. Large-Scale C++ Software design.
15. The project needs at least two "heads" -- one technical, the other administrative. The technical head sets the development philosophy & style, assigns responsibilities to teams, and arbitrates the inevitable "discussions" between people. The technical head also looks constantly at the big picture, trying to find any unnecessary commonality between teams that could reduce the orthogonality of the overall effort. The administrative head, or project manager, schedules the resources that the teams need, monitors and reports on progress, and helps decide priorities in terms of business needs. The administrative head might also act as the team's ambassador when communication with the outside world.
16. Tool builders -> Automation of project activities.
17. Give each member the ability to shine in his or her own way.
18. Unit testing: resource exhaustion, errors, and recovery.
19. Surviving Object-Oriented Projects: A Manager's Guide: Alister Cockburn.
20. Eiffel.
21. Michael Holt. Math puzzles & games.

 Nice book. Keep up!

Last read book: SQL Antipatterns: Avoiding the Pitfalls of Database Programming

Hello!  Today I'm going to share my impressions about
SQL Antipatterns: Avoiding the Pitfalls of Database Programming.

Bugs in your code

"The software industry average is 15 to 50 bugs per 1,000 lines of code."
This is quotation from the book SQL Antipatterns: Avoiding the Pitfalls of Database Programming (p. 71).

I don't know how did they get the results, but info is rather curious.

Do you know how many bugs in you code?

Last read book: Mastering Apache Maven 3

Just have finished reading Mastering Apache Maven 3.
Although this is a step by step guide and contains a lot of examples this book is more a reference guide.

Last read book: Functional JavaScript Introducing Functional Programming with Underscore.js

During reading the documentation on underscore.js I found out the link to the book Functional javascript. For a long time I had postponed the learning of this theme and now I can fill the gap in my knowledge of functional programming and javascript techniques.

This book has positive and negative reviews, but in my opinion this book is more of a practical approach. Can I recommend to to anyone? In my opinion, yes. Of course, you cannot master the functional programming only by this book. It gives you a lot of information and directions in where to find more information.

What I like about this book is a good bibliography and a reference to useful javascript libraries.

Last read book: How Linux Works, 2nd Edition

Just have finished reading the book How Linux Works, 2nd Edition. I enjoyed reading it. It makes me better understand the current state of Linux and its ecosystem. I can recommend this book...

Book I have read recently

Beginning XML, 5th Edition

is the book I have read recently. It is a good introduction to XML and related technologies. It is not a reference book, but a textbook or tutorial. 

It tells you about XML, namespaces, XML Schema, XPath, XSLT and among interesting things - WSDL and SOAP. This book is a good start to learn XML.

Among XML editors I recommend to use Altova XML Spy. You can download trial version. 

In java you can use IBM java api for XML which provides support for XML standards XSLT 2.0, XPath 2.0, and XQuery 1.0. Link to the book.

Thoughts about AspectJ in Action: Enterprise AOP with Spring Applications

Have finished reading book AspectJ in Action.
This is a rather lengthy book, but it covers AOP in depth. First, AOP theory and AspectJ as a reference implementation. Second, Spring AOP and the use of AspectJ and Spring altogether.

The author writes that AOP is not the silver bullet. As always choose the right tool for the right job.

I would also recommend read Spring documentation on AOP together with this book. Also, the book contains the path to gradually adoption of AOP in your projects.

Code complete. Complete.

Just have finished reading Code Complete by Steve McConnell. This book blew up my mind. It contains a lot information about programming as a collection of  activities. The most useful idea for me was that we program for people first, computers second. Some useful thoughts i wrote out in my recent post "Programming quotes".

The last chapter contains the book list that a developer should read. Here it is:

Book review. Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications

Hi. Have just finished reading "Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications".

A good book to scratch the surface from the J2EE development. It gives you an overview of J2EE 6 and gives you direction to further investigation. The cons of this book are a tutorial style which describes how to do something in different containers. In my opinion this information can be obtained from the documentation to that containers.

Java 7 Concurrency Cookbook

Have read Java 7 Concurrency Cookbook.
A very good book about concurrency in Java.
Every feature is accompanied with an example.
Most important thing is that examples are clear and resemble some real problems.
When working with an examples one should be very careful, because of the typos in the text. So it's better to consult errata on the publisher's site.
Also you can get 2 free chapters and source code on the publisher's site.

Thoughts after reading "Practical TDD and Acceptance TDD for developers"

TDD for web applications

After reading the book «Practical TDD and Acceptance TDD fot developers» I decided to write some thoughts about testing.

TDD Steps

1. Write the Test.
2. Write the code that will pass the test.
3. Refactor the test and the code. Watch carefully what dependencies can be eliminated or restructed.

The real question is how to write code that can be tested? Not how to test the written code. If code can't be tested — nobody needs such code.

Therefore when writing the code one should rely on the technical solutions that allow you to test the code.

Testing servlets

There is no universal solution to testing the servlets.

The main obstacle — how to make servlet that it could support dependency injection.

Following choices are available:

• use the interface HttpRequestHandler from Spring library,
• use methods get and set for setting the dependencies.

Unit testing database access code

How to test jdbc? One can test the code that use the services to access the data or the code that directly work with database.

One can use spring jdbctemplate or hibernate. Along with it you can use EasyMock for testing the code, that access the database.

Hibernate allows you to offload from controlling the differencies in SQL among the databases. Also it looks for opening and closing the resources

Testing database access code in memory database

Testing in HSQLDB. Hibernate settings:

hibernate.dialect=org.hibernate.dialect.HSQLDialect

hibernate.connection.driver_class=org.hsqldb.jdbcDriver

hibernate.connection.url=jdbc:hsqldb:mem:testdb

hibernate.connection.username=sa

hibernate.connection.password=

hibernate.show_sql=true

hibernate.hbm2ddl.auto=create-drop

Automating database schema configuration

Solutions: http://dbdeploy.com/ , http://www.liquibase.org/.

Testing Database access code: http://dbunit.sf.net .

Testing code working with files

For working with files it is better to use http://commons.apache.org/vfs/.

One can use RAM filesystem for unit testing.

Testing code dealing with time

One of the solutions is to create your onw interface and substitute different implementations on the demand. Also you can take a look at joda-time library. Also watch for the strategy pattern.