Removing boat bottom paint

I read somewhere that the best tool for removing bottom paint is your checkbook. After my experience, I would have to agree, but it can be done. Apparently the pros sandblast the stuff off. Not being a pro, I turned to Google and read about several different methods for DIY: scraping, stripping, and sanding being the top three. In the end, I believe the most efficient way is to scrape AND sand.

Important tip: have a file in your pocket and keep the scraper sharp. The copper bottom paint dulls the scraper quickly. To sharpen, you have to lay the file down and hold the scraper perpendicular to the file. Just a few strokes makes a huge difference.

Flying Scot #338 had several layers of bottom paint so scraping removed a bunch of material, but did not remove the last layer of paint. The picture above shows the results of scraping on the right and after sanding on the left. I sanded using a 1-2 punch of a 6" sander with 50 grit lightly and carefully run over the paint to remove 95% and then a 5" orbital sander with 80 grit to get the last bit off and smooth out the agressive grit. This process took about 1 hour for the first side, second side TBD...

Fairing and repainting a Flying Scot

I will be blogging regularly about this year’s refurbishment of Flying Scot 338. Last weekend I removed all of the hardware including rub rails. This weekend I removed the centerboard (with the help of the club hoist). Launched the 338 onto dry land – a very unnaturally feeling. And, with the help of 3 club members, flipped the hull onto low sawhorses. Next up, cutting the bad balsa out of the aft deck and removing the bottom paint. I feel itchy already.

Take a look at that centerboard. I got a chance to give it a close inspection while we were…uh…sideways a few weeks ago. I think I see why light air has never been kind to us!

Configuring Oracle XE connection pool in Glassfish and Using JPA

I followed these instructions for creating an Oracle JDBC datasource. I needed to download the Oracle JDBC driver (ojdbc14.jar) into my <Glassfish>/lib directory and restart the server. After that the “Ping” was successful.

In “step 2” I had to specify 4 properties: user, password, url, and xa-driver-does-not-support-non-tx-operations.

Next I needed to create a JDBC resource that my persistence.xml file would reference.

With those tasks complete, I modified an existing EJB 3 JPA project to utilize the new connection pool. All that was necessary was to change two lines in the persistence.xml file. First was to point to the new JNDI name:

<jta-data-source>jdbc/AMRPool</jta-data-source>

And second was to change the “toplink.platform.class.name” (now deprecated) to:

<property name="toplink.target-database" value="Oracle"/>

After redeploying the JAR the CUSTOMER table was added to my schema. I re-ran the test client and was delighted to find a record in the table. Bravo to the Java community!

Excellent EJB 3 Persistence Tutorial

It had been a long time since I have visited the land of Java. When I was a regular traveler there, I remember feeling inundated by the rapidly progressing proliferation of APIs. JMS, JNDI, RMI, CMP, and on…and on…and ON. The technologies and vendors were spawning and/or evolving so fast and from so many directions it was difficult to stay current. From what I can see the frameworks have matured and are stabilizing. While there are still many innovations occuring, the rate of change does not appear to be the dizzying pace that I remembered.

To get up-to-speed on the current J2EE release, I dutifully installed the latest version of the open source Java EE 5 implementation…something called GlassFish. It has a decidedly un-Microsoft feel about it. I had flashbacks of all the previous Weblogic/Tomcat/Apache configuration nightmares and had to steel myself for navigation through the narrow passages in the reefs surrounding a modern Java app server. I have found…in general…that Java technologies are much less tolerant of the neophyte and the learning curve seems significantly steeper than the reciprocal Microsoft technology (“platform agnostic”…I know…I know).

I also downloaded the Java EE tutorial and attempted to follow it using Eclipse instead of the recommend NetBeans because I had previously used Eclipse and thought it was generally a great IDE. In doing so, I ran into trouble with creating the EJB example that was entirely related to my inexperience…and the 50 different project types Eclipse now ships with out of the box. I left the Sun script and started working through simple JSP examples just to get some tiny amount of momentum built. After following the online documentation, success was not far behind.

Then I ran across the EJB 3 persistence topic and decided that looked interesting, particularly hibernate.org. The top tutorial on the matter…as declared by Google, was from Web Age Solutions. It was short enough that it didn’t scare me off so I dove in with low expectations of a working example. I was pleasantly surprised by the author’s accuracy and brevity. The logical and successful progression was refreshing and rewarding. By the end of the tutorial, I had a basic understanding of the Java Persistence API (JPA) and a new level of respect for the current Java specification. Bravo!

http://www.webagesolutions.com/knowledgebase/javakb/jkb006/index.html

Data densification using Oracle Partitioned Outer Joins

I ran across a feature of Oracle 10g called Partitioned Outer Joins while tracking down the answer to another problem. Rather than get side tracked, I made a note to check them out at a later time and I’m glad I did. I frequently get specifications for reports where the data has gaps, but the report should be continuous, regardless of the presence of the data. The typical example is when you want a customer sales report, but some months a customer has no orders. Oracle-Developer.Net has a great article explaining how to create just such a query (and proper use of WITH). The first helpful piece of SQL is a WITH clause to generate a “time dimension” of continuous months

WITH year_months
AS (SELECT To_char(Add_months(DATE '2004-01-01',ROWNUM - 1), 'YYYYMM') AS year_month
FROM dual
CONNECT BY ROWNUM < 12)

Adding the Partition clause turns out to be quite straightforward:

SELECT co.name,
ym.year_month,
Nvl(Sum(co.amt),0) AS total_amount
FROM year_months ym
LEFT OUTER JOIN customer_orders co
PARTITION BY (co.name)
ON (To_char(co.dt,'YYYYMM') = ym.year_month)
GROUP BY co.name,
ym.year_month
ORDER BY co.name,
ym.year_month;

Use Oracle Table Function to Encapsulate and Modularize your Data Layer

I finally ran into a situation where I wanted the functionality of a Table Function so I was forced to learn the PL/SQL way to do this. In this case, the benefits of accepting parameters made the Table Function a clear winner. To start off you need a table:

CREATE TABLE cool_people (
cp_id NUMBER(8,0),
first_name VARCHAR2(30),
last_name VARCHAR2(30))

Next you need a new TYPE that describes a single “row” of your Table Function’s output. In my contrived example, I’m only returning a formatted name:

create or replace TYPE PEOPLE_OBJ AS OBJECT(

PERSON_NAME VARCHAR(100));

Now that we have created the new type of OBJECT, we can declare a TABLE of that new type:

create or replace TYPE PEOPLE_TABLE AS TABLE OF PEOPLE_OBJ;

Now we can create our function that accepts a parameter of CHAR:

CREATE OR REPLACE FUNCTION
     TFN_GET_COOL_PEOPLE (formatName CHAR)
     RETURN PEOPLE_TABLE PIPELINED
IS
     fName VARCHAR(30);
     lName VARCHAR(30);
     p1 PEOPLE_OBJ := PEOPLE_OBJ(NULL);
     CURSOR C1 IS
             SELECT FIRST_NAME,
                    LAST_NAME
             FROM   COOL_PEOPLE;

BEGIN
      OPEN C1;
      LOOP
              FETCH C1
              INTO  fName,
                    lName;
           
              EXIT
      WHEN C1%NOTFOUND;
              IF formatName           = 'Y' THEN
                      p1.PERSON_NAME := lName
                      || ', '
                      || fName;
              ELSE
                      p1.PERSON_NAME := fName
                      || ' '
                      || lName;
              END IF;
              PIPE ROW (p1);
      END LOOP;
      RETURN;
END TFN_GET_COOL_PEOPLE;

You can then use the function in a FROM clause:

SELECT * FROM TABLE(TFN_GET_COOL_PEOPLE('N'));

Private stored procedures in an Oracle package

I never knew you could write a procedure in a package that isn’t declared in the package declaration.  It’s kind of like a private function/subroutine since it can’t be called by anything outside of the package…which is how I discovered this “feature”.  I was trying to call an “undeclared” procedure from a different package.  I had already written another procedure that called it from its own package, so I was mighty confused about the error I was getting: “MY_PROC must be declared” but now it makes perfect sense. 

One other discovery I made is that you can pass NULL as a parameter to another procedure instead of declaring a null valued variable.