After some hesitation I’ve bought my first DSLR – Canon 450D.
After a few days of playing I’m quite happy with it. Now I only miss 50mm f/1.8 lens, so in near future I’m planning to buy it. Kit lens is ok for everyday shooting, but I want a faster lens for portraits.

Meet my 5 months old baby girl Lėja:

Canon EF-S 18-55mm f/3.5-5.6 IS (Shutter: 1/25, aperture: 4.0, ISO: 400)

Recently I was working on a small console application with a few threads that concurrently updated the database. I had to make things transactional and separated so each thread had to have it’s own connection.
ThreadLocal to the rescue:

package electro.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * Thread local database connection.
 * Main thread is expected to call init with database connection parameters.
 *
 * @author Viktoras Agejevas
 *
 */
public class ThreadConnection {

	private static ThreadLocal<Connection> connection = new ThreadLocal<Connection>();

	private static String user;

	private static String pass;

	private static String url; 

	private static String driver;

	private static boolean initialized = false;

	/**
	 * Initializes ThreadConnection with connection data.
	 *
	 * @param user database username
	 * @param pass database password
	 * @param url database connection jdbc url
	 * @param driver database driver name
	 */
	public static  void init(String driver, String url, String user, String pass) {
		ThreadConnection.user = user;
		ThreadConnection.pass = pass;
		ThreadConnection.url = url;
		ThreadConnection.driver = driver;
		ThreadConnection.initialized = true;
	}

	/**
	 * Gets connection associated with current thread.
	 *
	 * If currently associated connection is closed, recreates a new connection.
	 *
	 * @return database connection bound to this thread
	 * @throws SQLException if database access error occurs
	 *         or db driver is missing
	 */
	public static Connection getConnection() throws SQLException {
		if (!initialized) {
			throw new IllegalStateException(
					"ThreadConnection is not initialized");
		}

		if (connection.get() == null || connection.get().isClosed()) {
			try {
				Class.forName(driver);
			} catch (ClassNotFoundException e) {
				throw new SQLException(
						"Can't find db driver: " + e.getMessage(), e);
			}

			connection.set(DriverManager.getConnection(url, user, pass));
		}

		return connection.get();
	}
}

At the application entry I just init the database connection parameters and after that every thread can access it’s connection:

package electro.jdbc;

import java.sql.Connection;
import java.sql.SQLException;

public class Runner {

	public static void main(String[] args) throws SQLException {
        ThreadConnection.init("org.hsqldb.jdbcDriver", "jdbc:hsqldb:test", "sa", "");

        Connection connection = ThreadConnection.getConnection();
        // main thread's connection

        new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Connection connection = ThreadConnection.getConnection();
					// this thread's connection
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
        }).start();
	}
}

At my current job we have some annual developer test which consists of some general computing/programming/architecture questions. Personally I haven’t done the test, but I have reviewed a corrected test (the test was on paper) of my colleague. One question caught my attention:

Define encapsulation.
a) Hiding internal details of an object.
b) Aggregating child objects inside a parent object.
c) Wrapping data and functions that operate on that data inside an object.

The answer c) was shown to be correct and the answer a) (which my college answered) was marked as incorrect.
I honestly think that a) is correct and c) is almost correct – if we change ‘Wrapping’ to ‘Hiding’ in it it would be really correct.

After all this I had a discussion with the test creator and he thinks that encapsulation and information hiding are completely separate things. According to him, encapsulation is just wrapping of data (no hiding of anything) and that every Java object is inherently (by design) encapsulated and that hiding internal details/data has nothing to do with encapsulation.

I think that this point of view is quite narrow and misses the general point of encapsulation. I think that encapsulation and information hiding are almost synonymous – supplementary and tandemic.

I will not even try to explain my point, people much more authoritative than me have already done that:

Design Patterns – Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, Glossary:
“Encapsulation – The result of hiding a representation and implementation in an object. The representation is not visible and cannot be accessed directly from outside the object. Operations are the only way to access and modify an object’s representation.”

Design Patterns – Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, p. 19 (this quote shows that object is not encapsulated by definition):
“Because inheritance exposes a subclass to details of its parent’s implementation, it’s often said that ‘inheritance breaks encapsulation’.”

Object-Oriented Analysis and Design with Applications by Grady Booch, Ivar Jacobson, and James Rumbaugh, p. 51:
“Encapsulation is most often achieved through information hiding (not just data hiding), which is the process of hiding all the secrets of an object that do not contribute to its essential characteristics; typically, the structure of an object is hidden, as well as the implementation of its methods. “No part of a complex system should depend on the internal details of any other part” [50]. Whereas abstraction “helps people to think about what they are doing,” encapsulation “allows program changes to be reliably made with limited effort” [51].”

Effective Java™ Second Edition by Joshua Bloch, p. 67:
“The single most important factor that distinguishes a well-designed module from a poorly designed one is the degree to which the module hides its internal data and other implementation details from other modules. A well-designed module hides all of its implementation details, cleanly separating its API from its implementation. Modules then communicate only through their APIs and are oblivious to each others’ inner workings. This concept, known as information hiding or encapsulation, is one of the fundamental tenets of software design.”

Code Complete Second Edition, Steve McConnell, p. 567 (this book has a lot of information about encapsulation, this quote is chosen because it uses both notions synonymously):
“Encapsulation (information hiding) is probably the strongest tool you have to make your program intellectually manageable and to minimize ripple effects of code changes. Anytime you see one class that knows more about another class than it should–including derived classes knowing too much about their parents–err on the side of stronger encapsulation rather than weaker.”

Wikipedia, http://en.wikipedia.org:/wiki/Encapsulation_(computer_science)
“In computer science, encapsulation is the hiding of the internal mechanisms and data structures of a software component behind a defined interface, in such a way that users of the component (other pieces of software) only need to know what the component does, and cannot make themselves dependent on the details of how it does it.”

These quotes clearly show that encapsulation and information hiding are almost synonymous.

So is any Java object is inherently encapsulated? Is Point object, that has public x and y properties encapsulated? I think the answer should be clear…

I was always fond of precise time. One day I wondered how NTP works and in the way decided to create SNTP Java client (RFC-2030).

For now client has only basic features and works only in unicast mode. Currently SNTPJC doesn’t update system time, if such feature might be needed by someone, it might be implemented using JNI.

This programming session was ignited by academic curiosity so I don’t think I will actively develop it any further. But the source code might be useful for somebody so here’s the SNTPJC google code project.

If you are interested in testing it – go and download latest sntpjc-<version>.jar and execute it with some NTP server address:

java -jar sntpjc-<version>.jar ntp.data.lt

Output:

Checking with: ntp.data.lt (92.61.32.9)
System time offset is: -0.004765 s

Great post that explains why I bothered programming it.

After extensive observation of software development, my friend Tomas got a very interesting interpretation of Albert Einstein’s mass–energy equivalence:

E = mc²

Interpretation:

Enterprise = lots of middle class

“It’s what I call ‘mental masturbation’, when you engage is some pointless intellectual exercise that has no possible meaning.” – Linus Torvalds

Currently I have some idle time at my job (waiting for a new project), so I thought I don’t want to get too rusty. Programmer has to program… I have found Project Euler, a site dedicated to math/programming problems by Colin Hughes (aka Euler).

So if you want to exercise your head (and fingers) look no more: http://projecteuler.net

To make things more interesting, I’m solving some of the problems in C++, not my first programming language :)
So far I have 17 solutions under my belt, some of which use brute force so I might get back to them some time.

Happy hacking :)

Here are some photos of Crete, that me and my wife made during our honeymoon (click to see more):

Update after some comments: this post is not a discussion whether to use Singleton or not. It’s not a discussion on why Singleton might be an anti-pattern. It’s just an example on an alternative implementation of Singleton in Java. Just that.

There are two classic ways to implement Singleton pattern in Java: public final instance field or static factory method to create/get instance.

However there is one more, probably the best way to do it if you are using Java >= 1.5. You can use Enum – this way you get Singleton functionality easily and don’t have to think about serialization as you get it for free:

package electro;

public enum YourSingleton {
	INSTANCE;

	public void doStuff(String stuff) {
		System.out.println("Doing " + stuff);
	}
}

Now you can use it and be completely sure it’s Singleton:

YourSingleton.INSTANCE.doStuff("some stuff");

Thanks to Joshua Bloch and his great book “Effective Java Second Edition“.

Well, the EuroPython 2008 is almost over…

I think that last year’s EuroPython 2007 was better, but this time there were some very interesting talks too (my opinion may be a bit biased, because I’m not primarily a Python programmer):

• “Why I Want You to Use Eggs” by Ignas Mikalajūnas was interesting, I was only wandering why the Python community (which I consider smart) does not have a fully working repository of eggs and why is it still in so immature state. For example Java community has Maven which stands much further in a sense of adoption and maturity.
• “Developing a Very Large Python Web Application LEAN style” by Steve Alexander revealed interesting points on LEAN principles and their usage and adoption at Canonical (Launchpad, Bazaar and Ubuntu).
• Mind blowing keynote by professor Hans Rosling
• “Core Python Containers — Under the Hood” by Raymond D. Hettinger. Great talk on the insides of Python containers and how to properly use lists and dictionaries to get the maximum performance.
  

  Tim Peters: “Code written with Python dictionaries is a gazillion times faster than C”.

  Raymond: “If you need a mapping but try something else, it will be dog slow no matter what language you use.”

  The moral – use and love dictionaries :)

• “Why It’s Good To Be Lazy: Functional Programming with Python” by Adam Byrtek. General introduction to functional programming and the possibilities of functional programming with Python.

Ok, so that’s the stuff I remember, there were more good talks I guess…

And of course there were some nice T-shirts and CD’s (CD’s are a bit out of scale):

Another thing – Sun was among conference sponsors. I think Sun has some serious plans about Python: they hired Ted Leung and Frank Wierzbicki (JPython, they did talks at the conference too), opened Python Developer Center + there are some other clues (Python support in NetBeans, etc.).

Interesting trends taken from ITJobWatch:

Java programming demand:

And Python programming demand:

Demands are quite different yet, but lets wait and see :)

My friend Tomas Varaneckas noticed interesting google trends in his blog post “The Death of Software Development“.

So what do you think? Why do we see “loss of interest” in software development?

I think that Google, other free services and Open Source are to be “blamed” for this.

Search results for: “google services”

So my answer is no, software development is here to stay, it’s just shifting to Open Source and free services.