Newsletters related to All by Date

Issue	Subject	Date
185	Book Review: Java: The Good Parts In his latest book, Jim Waldo describes several Java features that he believes make Java "good". A nice easy read, and I even learned a few new things from it.	2010-07-11
184	Deadlocks through Cyclic Dependencies A common approach to ensuring serialization consistency in thread safe classes such as Vector, Hashtable or Throwable is to include a synchronized writeObject() method. This can result in a deadlock when the object graph contain a cyclic dependency and we serialize from two threads. Whilst unlikely, it has happened in production.	2010-06-04
183	Serialization Size of Lists What has a larger serializable size, ArrayList or LinkedList? In this newsletter we examine what the difference is and also why Vector is a poor candidate for a list in a serializable class.	2010-05-31
182	Remote Screenshots In this newsletter, we describe how we can generate remote screen shots as compressed, scaled JPGs to build a more efficient remote control mechanism.	2010-05-12
181	Generating Static Proxy Classes - 2/2 In this newsletter, we show how the Generator described in our previous issue can be used to create virtual proxy classes statically, that is, by generating code instead of using dynamic proxies.	2010-03-01
180	Generating Static Proxy Classes - 1/2 In this newsletter, we have a look at how we can create new classes in memory and then inject them into any class loader. This will form the basis of a system to generate virtual proxies statically.	2010-02-19
179	Escape Analysis Escape analysis can make your code run 110 times faster - if you are a really really bad programmer to begin with :-) In this newsletter we look at some of the places where escape analysis can potentially help us.	2009-12-30
178b	WalkingCollection Generics Generics can be used to further improve the WalkingCollection, shown in our previous newsletter.	2009-11-17
178	WalkingCollection We look at how we could internalize the iteration into a collection by introducing a Processor interface that is applied to each element. This allows us to manage concurrency from within the collection.	2009-11-14
177	Logging Part 3 of 3 After almost nine years of silence, we come back to bring the logging series to an end, looking at best practices and what performance measurements to log.	2009-10-13
176	The Law of the Xerox Copier Concurrency is easier when we work with immutable objects. In this newsletter, we define another concurrency law, The Law of the Xerox Copier, which explains how we can work with immutable objects by returning copies from methods that would ordinarily modify the state.	2009-09-22
175	Creating Objects Without Calling Constructors De-Serialization creates objects without calling constructors. We can use the same mechanism to create objects at will, without ever calling their constructors.	2009-09-08
174	Java Memory Puzzle Explained In this newsletter, we reveal the answer to the puzzle from last month and explain the reasons why the first class sometimes fails and why the second always succeeds. Remember this for your next job interview ...	2009-06-26
173	Java Memory Puzzle In this newsletter we show you a puzzle, where a simple request causes memory to be released, that otherwise could not. Solution will be shown in the next newsletter.	2009-05-28
172	Wonky Dating The DateFormat produces some seemingly unpredictable results parsing the date 2009-01-28-09:11:12 as "Sun Nov 30 22:07:51 CET 2008". In this newsletter we examine why and also show how DateFormat reacts to concurrent access.	2009-04-23
171	Throwing ConcurrentModificationException Early One of the hardest exceptions to get rid of in a system is th ConcurrentModificationException, which typically occurs when a thread modifies a collection whilst another is busy iterating. In this newsletter we show how we can fail on the modifying, rather than the iterating thread.	2009-03-09
170	Discovering Objects with Non-trivial Finalizers It is well known that implementing a non-trivial finalize() method can cause GC and performance issues, plus some subtle concurrency bugs. In this newsletter, we show how we can find all objects with a non-trivial finalize() method, even if they are not currently eligible for finalization.	2009-02-27
169	Monitoring Sockets In this newsletter, we show two approaches for listening to bytes on sockets. The first uses the Delegator from our previous newsletter, whereas the second uses AspectJ to intercept the call to Socket.getInput/OutputStream. We also write an MBean to publish this information in JConsole.	2009-01-22
168	The Delegator In this newsletter we show the reflection plumbing needed for writing a socket monitor that sniffs all the bytes being sent or received over all the Java sockets. The Delegator is used to invoke corresponding methods through some elegant guesswork.	2009-01-15
167	Annotation Processing Tool In this newsletter we answer the question: "How do we force all subclasses to contain a public no-args constructor?" The Annotation Processing Tool allows us to check conditions like this at compile time, rather than only at runtime.	2008-12-05
166	Serialization Cache Java's serialization mechanism is optimized for immutable objects. Writing objects without resetting the stream causes a memory leak. Writing a changed object twice results in only the first state being written. However, resetting the stream also loses the optimization stored in the stream.	2008-11-30
165	Starvation with ReadWriteLocks In this newsletter we examine what happens when a ReadWriteLock is swamped with too many reader or writer threads. If we are not careful, we can cause starvation of the minority in some versions of Java.	2008-10-14
164	Why 0x61c88647? Prior to Java 1.4, ThreadLocals caused thread contention, rendering them useless for performant code. In the new design, each thread contains its own ThreadLocalMap, thus improving throughput. However, we still face the possibility of memory leaks due to values not being cleared out of the ThreadLocalMap with long running threads.	2008-09-29
163	Book Review: Effective Java 2nd Edition Joshua Bloch has at long last published an updated version of Effective Java. An essential guide for professional Java programmers who are interested in producing high quality code, this book is also very readable. In this newsletter we describe some of the nuggets found in the book.	2008-08-13
162	Exceptions in Java In this article, we look at exception handling in Java. We start with the history of exceptions, looking back at the precursor of Java, a language called Oak. We see reasons why Thread.stop() should not be used and discover the mystery of the RuntimeException name. We then look at some best practices that you can use for your coding, followed by some worst practices, in the form of exception anti-patterns.	2008-06-10
161	Of Hacking Enums and Modifying "final static" Fields The developers of the Java language tried their best to stop us from constructing our own enum instances. However, for testing purposes, it can be useful to temporarily add new enum instances to the system. In this newsletter we show how we can do this using the classes in sun.reflect. In addition, we use a similar technique to modify static final fields, which we need to do if we want the switch statements to still work with our new enums.	2008-05-23
160	The Law of the Uneaten Lutefisk Imagine a very stubborn viking father insisting that his equally stubborn child eat its lutefisk before going to sleep. In real life one of the "threads" eventually will give up, but in Java, the threads become deadlocked, with neither giving an inch. In this newsletter we discover how we can sometimes escape from such deadlocked situations in Java and learn why the stop() function should never ever ever be called.	2008-05-12
159	The Law of Sudden Riches We all expect faster hardware to make our code execute faster and better. In this newsletter we examine why this is not always true. Sometimes the code breaks on faster servers or executes slower than on worse hardware.	2008-05-05
158	Polymorphism Performance Mysteries Explained In this newsletter, we reveal some of the polymorphism mysteries in the JDK. The HotSpot Server Compiler can distinguish between mono-morphism, bi-morphism and poly-morphism. The bi-morphism is a special case which executes faster than poly-morphism. Mono-morphism can be inlined by the compiler in certain circumstances, thus not costing anything at all.	2008-04-01
157	Polymorphism Performance Mysteries Late binding is supposed to be a bottleneck in applications - this was one of the criticisms of early Java. The HotSpot Compiler is however rather good at inlining methods that are being called through polymorphism, provided that we do not have very many implementation subclasses.	2008-03-06
156	The Law of Cretan Driving The Law of Cretan Driving looks at what happens when we keep on breaking the rules. Eventually, we might experience a lot of pain when we migrate to a new architecture or Java Virtual Machine. Even if we decide not to obey them, we need to know what they are. In this newsletter, we point you to some essential reading for every Java Specialist.	2008-02-26
155	The Law of the Micromanager In good Dilbert style, we want to avoid having Pointy-Haired-Bosses (PHBs) in our code. Commonly called micromanagers, they can make a system work extremely inefficiently. My prediction is that in the next few years, as the number of cores increases per CPU, lock contention is going to be the biggest performance problem facing companies.	2008-01-16
154	ResubmittingScheduledPoolExecutor Timers in Java have suffered from the typical Command Pattern characteristics. Exceptions could stop the timer altogether and even with the new ScheduledPoolExecutor, a task that fails is cancelled. In this newsletter we explore how we could reschedule periodic tasks automatically.	2007-12-04
153	Timeout on Console Input In this newsletter, we look at how we can read from the console input stream, timing out if we do not get a response by some timeout.	2007-11-25
152	The Law of the Corrupt Politician Corruption has a habit of creeping into system that do not have adequate controls over their threads. In this law, we look at how we can detect data races and some ideas to avoid and fix them.	2007-11-12
151	The Law of the Leaked Memo In this fifth law of concurrency, we look at a deadly law where a field value is written early.	2007-10-04
150	The Law of the Blind Spot In this fourth law of concurrency, we look at the problem with visibility of shared variable updates. Quite often, "clever" code that tries to avoid locking in order to remove contention, makes assumptions that may result in serious errors.	2007-09-05
149	The Law of the Overstocked Haberdashery Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the third part of a series of laws that help explain how we should be writing concurrent code in Java. In this section, we look at why we should avoid creating unnecessary threads, even if they are not doing anything.	2007-08-20
148	Snappy JSliders in Swing Recent versions of Swing do a good job of mimicking the underlying platform, with a few caveats. For example, the JSlider only snaps onto the correct tick once you let go of the mouse. Here I present a fix for this problem with a non-intrusive one-liner that we can add to the application code.	2007-07-31
147	The Law of the Distracted Spearfisherman Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the second part of a series of laws that help explain how we should be writing concurrent code in Java. We look at how to debug a concurrent program by knowing what every thread in the system is doing.	2007-07-20
146	The Secrets of Concurrency (Part 1) Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the first part of a series of laws that help explain how we should be writing concurrent code in Java.	2007-06-26
145	TristateCheckBox Revisited The Tristate Checkbox is widely used to represent an undetermined state of a check box. In this newsletter, we present a new version of this popular control, retrofitted to Java 5 and 6.	2007-05-25
144	Book Review: Java Puzzlers Experienced Java programmers will love the Java Puzzlers book by Josh Bloch and Neal Gafter, both well known Java personalities. In this newsletter, we look at two of the puzzles as a teazer for the book.	2007-05-16
143	Maths Tutor in GWT Google Web Toolkit (GWT) allows ordinary Java Programmers to produce highly responsive web user interfaces, without needing to become experts in JavaScript. Here we demonstrate a little maths game for practicing your arithmetic. Included is an Easter egg.	2007-04-08
142	Instrumentation Memory Counter Memory usage of Java objects has been a mystery for many years. In this newsletter, we use the new instrumentation API to predict more accurately how much memory an object uses. Based on earlier newsletters, but revised for Java 5 and 6.	2007-03-26
141	Hacking Enums Enums are implemented as constant flyweights. You cannot construct them. You cannot clone them. You cannot make copies with serialization. But here is a way we can make new ones in Java 5.	2007-03-13
140	Book Review: Java Generics and Collections Java Generics and Collections is the "companion book" to The Java Specialists' Newsletter. A well written book that explains generics really nicely, including some difficult concepts. In addition, they cover all the new collection classes up to Java 6 Mustang.	2007-03-08
139	Mustang ServiceLoader Mustang introduced a ServiceLoader than can be used to load JDBC drivers (amongst others) simply by including a jar file in your classpath. In this newsletter, we look at how we can use this mechanism to define and load our own services.	2007-02-10
138	Better SQLExceptions in Java 6 Java 6 has support for JDBC 4, which, amongst other things, gives you better feedback of what went wrong with your database query. In this newsletter we demonstrate how this can be used.	2007-01-31
137	Creating Loggers DRY-ly A common idiom for logging is to create a logger in each class that is based on the class name. The name of the class is then duplicated in the class, both in the class definition and in the logger field definition, since the class is for some reason not available from a static context. Read how to solve that problem.	2006-12-28
136	Sneaking in JDBC Drivers In this newsletter, we look at a technique of how we can replace an existing database driver with our own one. This could be used to migrate an application to a new database where you only have the compiled classes. Or it could be used to insert a monitoring JDBC connection that measures the length of database queries.	2006-12-11
135	Are you really Multi-Core? With Java 5, we can measure CPU cycles per thread. Here is a small program that runs several CPU intensive tasks in separate threads and then compares the elapsed time to the total CPU time of the threads. The factor should give you some indication of the CPU based acceleration that the multi cores are giving you.	2006-11-06
134	DRY Performance As developers we often hear that performance often comes at the price of good design. However when we have our performance tuning hats on, we often find that good design is essential to help achieve good performance. In this article we will explore one example of where a good design choice has been essential in an effort to improve performance.	2006-10-08
133	Safely and Quickly Converting EJB3 Collections When we query the database using EJB3, the Query object returns an untyped collection. In this newsletter we look at several approaches for safely converting this to a typed collection.	2006-09-29
132	Thread Dump JSP in Java 5 Sometimes it is useful to have a look at what the threads are doing in a light weight fashion in order to discover tricky bugs and bottlenecks. Ideally this should not disturb the performance of the running system. In addition, it should be universally usable and cost nothing. Have a look at how we do it in this newsletter.	2006-09-11
131	Sending Emails from Java In this newsletter, we show how simple it is to send emails from Java. This should obviously not be used for sending unsolicited emails, but will nevertheless illustrate why we are flooded with SPAM.	2006-08-28
130	Deadlock Detection with new Locks Java level monitor deadlocks used to be hard to find. Then along came JDK 1.4 and showed them in CTRL+Break. In JDK 1.5, we saw the addition of the ThreadMXBean, which made it possible to continually monitor an application for deadlocks. However, the limitation was that the ThreadMXBean only worked for synchronized blocks, and not the new java.util.concurrent mechanisms. In this newsletter, we take a fresh look at the deadlock detector and show what needs to change to make it work under JDK 1.6. Also, we have a look at what asynchronous exceptions are, and how you can post them to another thread.	2006-07-29
129	Fast Exceptions in RIFE One of the tricks that Java allows us to employ is to change the control flow of the application using exceptions. This is generally strongly discouraged, since it makes the code hard to decipher. In addition, exceptions are notoriously bad at performance. Here is a trick used in RIFE to make this work faster.	2006-06-27
128	SuDoKu Madness In this Java Specialists' Newsletter, we look at a simple Java program that solves SuDoKu puzzles.	2006-06-21
127	Casting like a Tiger Java 5 adds a new way of casting that does not show compiler warnings or errors. Yet another way to shoot yourself in the foot?	2006-06-07
126	Proxy equals() When we make proxies that wrap objects, we have to remember to write an appropriate equals() method. Instead of comparing on object level, we need to either compare on interface level or use a workaround to achieve the comparisons on the object level, described in this newsletter.	2006-05-14
125	Book Review: Java Concurrency in Practice We review Java Concurrency in Practice by Brian Goetz. Brian's book is the most readable on the topic of concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. It is interesting, useful, and relevant to the problems facing Java developers today.	2006-04-17
124	Copying Arrays Fast In this newsletter we look at the difference in performance between cloning and copying an array of bytes. Beware of the Microbenchmark! We also show how misleading such a test can be, but explain why the cloning is so much slower for small arrays.	2006-03-28
123	Strategy Pattern with Generics The Strategy Pattern is elegant in its simplicity. With this pattern, we should try to convert intrinsic state to extrinsic, to allow sharing of strategy objects. It gets tricky when each strategy object needs a different set of information in order to do its work. In this newsletter, we look at how we can use Java 5 Generics to pass the correct subtype of the context into each strategy object.	2006-03-14
122	Copying Files from the Internet Sometimes you need to download files using HTTP from a machine that you cannot run a browser on. In this simple Java program we show you how this is done. We include information of your progress for those who are impatient, and look at how the volatile keyword can be used.	2006-03-08
121	How Deep is Your Hierarchy? Someone asked me yesterday what the maximum inheritance depth is in Java. I guessed a value of 65535, but for practical purposes, not more than 5. When I asked performance guru Kirk Pepperdine to estimate, he shot back with 63. In this newsletter, we look at the limitations in the JVM and examine some existing classes.	2006-02-14
120	Exceptions From Constructors What do you do when an object cannot be properly constructed? In this newsletter, we look at a few options that are used and discuss what would be best. Based on the experiences of writing the Sun Certified Programmer for Java 5 exam.	2006-02-08
119	Book Review: "Wicked Cool" Java The book "Wicked Cool Java" contains a myriad of interesting libraries, both from the JDK and various open source projects. In this review, we look at two of these, the java.util.Scanner and javax.sql.WebRowSet classes.	2006-01-13
118	A Simple Database Viewer A simple database viewer written in Java Swing that reads the metadata and shows you all the tables and contents of the tables, written in under 100 lines of Java code, including comments.	2005-12-19
117	Reflectively Calling Inner Class Methods Sometimes frameworks use reflection to call methods. Depending how they find the correct method to call, we may end up with IllegalAccessExceptions. The naive approach of clazz.getMethod(name) is not correct when we send instances of non-public classes.	2005-12-02
116	Closing Database Statements Don't Repeat Yourself. The mantra of the good Java programmer. But database code often leads to this antipattern. Here is a neat simple solution from the Jakarta Commons DbUtils project.	2005-11-28
115	Young vs. Old Generation GC A few weeks ago, I tried to demonstrate the effects of old vs. new generation GC. The results surprised me and reemphasized how important GC is to your overall program performance.	2005-10-13
114	Compile-time String Constant Quiz When we change libraries, we need to do a full recompile of our code, in case any constants were inlined by the compiler. Find out which constants are inlined in this latest newsletter.	2005-09-16
113	Enum Inversion Problem A problem that I encountered when I first started using enums was how to serialize them to some persistent store. My initial approach was to write the ordinal to the database. In this newsletter, I explore some ideas of a more robust approach. It will also show you some applications of Java generics.	2005-08-29
112	Book Review: Head First Design Patterns This book is a fantastic introduction to Design Patterns, probably the best available. In this newsletter, I look at some of the winning formulae used in the book, and explain why they work. I also give some tips of where I disagree with the book and some additional information that will be useful to you.	2005-08-22
111	What is faster - LinkedList of ArrayList?	2005-07-12
110	Break to Labeled Statement	2005-06-30
109	Strategy Pattern of HashCode Equality	2005-05-18
108	Object Adapter based on Dynamic Proxy	2005-05-10
107	Making Enumerations Iterable	2005-04-19
106	Multi-line cells in JTable in JDK 1.4+	2005-04-14
105	Performance Surprises in Tiger	2005-03-28
104	EDT Lockup Detection	2005-02-13
103	New for/in loop gymnastics	2005-02-07
102	Mangling Integers	2005-01-31
101b	Causing Deadlocks in Swing Code (Follow-up)	2005-01-19
101	Causing Deadlocks in Swing Code	2005-01-18
100	Java Programmers aren't Born	2004-11-30
099	Orientating Components Right to Left	2004-11-23
098	References	2004-11-08
097	Mapping Objects to XML Files using Java 5 Annotations	2004-10-17
096	Java 5 - "final" is not final anymore	2004-10-07
095b	Follow-up: Self-reloading XML Property Files	2004-10-01
095	Self-reloading XML Property Files	2004-09-30
094	Java Field Initialisation	2004-09-20
093	Automatically Detecting Thread Deadlocks	2004-07-28
092	OutOfMemoryError Warning System	2004-07-20
091	Controlling Machines Remotely with Java	2004-07-08
090	Autoboxing Yourself in JDK 1.5	2004-06-22
089	Catching Uncaught Exceptions in JDK 1.5	2004-05-26
088	Resetting ObjectOutputStream	2004-05-19
087	sun.reflect.Reflection	2004-04-09
086b	Initialising Fields before Superconstructor call (Follow-up)	2004-03-20
086	Initialising Fields before Superconstructor call	2004-03-19
085	Book Review: Pragmatic Programmer One of my favourite software development books, this one takes a good hard look at how to be a programmer in the real world. Surprisingly thin for a book with this much substance, I refer to the ideas in here all the time. The pragmatic bunch have built an entire industry around their software pragmatism.	2004-03-05
084	Ego Tripping with Webservices	2004-02-05
083	End of Year Puzzle	2003-12-26
083b	End of Year Puzzle Follow-up	2003-12-26
082	TristateCheckBox based on the Swing JCheckBox	2003-12-02
081	Catching Exceptions in GUI Code	2003-11-25
080	Many Public Classes in One File	2003-10-13
079	Generic toString()	2003-10-08
078	MemoryCounter for Java 1.4	2003-09-29
077	"Wonderfully disgusting hack"	2003-09-02
076	Asserting Locks	2003-08-05
075	An Automatic Wait Cursor: WaitCursorEventQueue	2003-07-29
074	GoF Factory Method in writing GUIs	2003-07-14
073	LinkedHashMap is Actually Quite Useful	2003-06-22
072	Java and Dilbert	2003-06-15
071	Overloading considered Harmful	2003-06-01
070b	Multi-Dimensional Arrays - Creation Performance	2003-05-18
070	Too many dimensions are bad for you	2003-05-17
069b	Results of last survey	2003-05-02
069	Treating Types Equally - or - Life's Not Fair!	2003-04-29
068	Appending Strings	2003-04-21
067	BASIC Java	2003-03-31
066	Book Review: Java Performance Tuning by Jack Shirazi In this book, Jack outlines the process used to make Java systems run faster. He gives lots of tips on how to find your bottlenecks and then also gives specific tricks to make your code just that bit faster. A must-have for Java programmers who care about the speed of their programs.	2003-03-21
065	Wait, Cursor, Wait!	2003-03-06
064	Disassembling Java Classes	2003-02-14
063	Revisiting Stack Trace Decoding	2003-01-28
062b	Follow-up and Happy New Year!	2002-12-31
062	The link to the outer class	2002-12-27
061	Double-checked locking	2002-12-07
060	Nulling variables and garbage collection	2002-11-29
059b	Follow-up to Loooong Strings	2002-11-13
059	When arguments get out of hand...	2002-11-11
058	Counting bytes on Sockets	2002-10-09
057	A Tribute to my Dad, Hans Rudolf Kabutz	2002-09-22
056	Shutting down threads cleanly	2002-09-16
055	Once upon an Oak ...	2002-08-26
054b	Follow-up to JDK 1.4 HashMap hashCode() mystery	2002-08-15
054	HashMap requires a better hashCode() - JDK 1.4 Part II	2002-08-14
053	Charting unknown waters in JDK 1.4 Part I	2002-07-23
052	J2EE Singleton	2002-07-02
051	Java Import Statement Cleanup	2002-06-18
050	Commenting out your code?	2002-06-10
049	Doclet for finding missing comments	2002-06-05
048	Review: The Secrets of Consulting How much do your customers love you? How should you give and receive advice? In this excellent book, we learn why it is so important to understand your customer. I use the principles daily in my work with code reviews, performance tuning and dealing with customers or clients.	2002-05-29
047	Lack of Streaming leads to Screaming	2002-05-24
046	"The compiler team is writing useless code again ..."	2002-05-05
045	Multi-line cells in the JTable	2002-04-11
044	Review: Object-Oriented Implementation of Numerical Methods In our first book review, we look at an interesting book that talks about implementing numerical methods in Java. Although not primarily a Java book, it gives us some insight as to the performance of Java versus other languages like C or Smalltalk.	2002-04-01
043	Arrgh, someone wants to kill me!	2002-03-11
042	Speed-kings of inverting booleans	2002-02-23
041	Placing components on each other	2002-02-15
040	Visiting your Collection's Elements	2002-01-31
039	Why I don't read your code comments ...	2002-01-17
038a	Counting Objects Clandestinely	2001-12-28
038b	Counting Objects Clandestinely - Follow-up	2001-12-28
037	Checking that your classpath is valid	2001-12-13
036	Using Unicode Variable Names	2001-11-23
035	Doclets Find Bad Code	2001-11-17
034	Generic Types with Dynamic Decorators	2001-10-24
033	Making Exceptions Unchecked	2001-10-18
032	Exceptional Constructors - Resurrecting the dead	2001-10-11
031	Hash, hash, away it goes! When I first started using Java in 1997, I needed very large hash tables for matching records as quickly as possible. We ran into trouble when some of the keys were mutable and ended up disappearing from the table, and then reappearing again later.	2001-09-26
030	What do you Prefer?	2001-09-17
029	Determining Memory Usage in Java	2001-08-28
028	Multicasting in Java	2001-08-14
027	Circular Array List	2001-08-02
026	Package Versioning	2001-07-25
025	Final Newsletter	2001-07-12
024	Self-tuning FIFO Queues	2001-07-06
023	Socket Wheel to handle many clients	2001-06-21
022	Classloaders Revisited: "Hotdeploy"	2001-06-07
021	Non-virtual Methods in Java	2001-05-31
020	Serializing Objects Into Database	2001-05-24
019	Finding Lost Frames	2001-05-10
018	Class names don't identify a class	2001-05-03
017b	Follow-up	2001-04-28
017a	Switching on Object Handles	2001-04-26
016	Blocking Queue	2001-04-11
015	Implementing a SoftReference based HashMap	2001-03-28
014	Insane Strings	2001-03-21
013b	Follow-up	2001-03-15
013a	Serializing GUI Components Across Network	2001-03-14
012	Setting focus to second component of modal dialog	2001-03-07
011	Hooking into the shutdown call	2001-02-28
010	Writing GUI Layout Managers	2001-02-22
009	Depth-first Polymorphism	2001-02-15
008	boolean comparisons	2001-02-08
007	java.awt.EventQueue	2001-02-01
006	Implementation code inside interfaces	2001-01-25
005	Dynamic Proxies - Short Tutorial	2001-01-18
004	Logging part 2	2001-01-11
003	Logging part 1	2000-12-14
002	Anonymous Inner Classes	2000-12-07
001	Deadlocks	2000-11-30

What is the Java Specialists Club?

	© 2010 Heinz Kabutz - All Rights Reserved	Sitemap		seo web design Catch22 Marketing

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. JavaSpecialists.eu is not connected to Oracle, Inc. and is not sponsored by Oracle, Inc.