Megatome Technologies

Identity Theft, And The Crooks May Be In Our Own Backyard

2017-04-27T00:00:00-06:00

Roughly two weeks ago, my wife received a letter in the mail informing her that her credit card application had been denied. Since she hadn’t applied for anything, our suspicion was immediately aroused.

She called the company and confirmed that no account had been opened and had the transaction marked as fraudulent. The next step was to place a freeze on her credit to try to prevent any further issues.

Late last week, we got another letter from a different credit card company congratulating her on her new card and letting her know that her new card would be in the mail shortly.

We figured that whoever had applied for the other card had applied for this one at the same time and this application had passed muster. A call to the company got the account closed and marked fraudulent as well.

We kept checking her credit report and nothing new showed up, so we thought we were in the clear.

We get our mail at a cluster of mailboxes that are at various points in our neighborhood.

Yesterday, there was no mail. Very unusual, but not unheard of.

Today, there was no mail. Knowing I had an Amazon delivery waiting, I knew something was wrong. I confirmed with my neighbors that they’d received their mail then headed for the post office.

Up until this point, this had been a crime of annoyance. Things like this are almost the background noise of living in a digital world with easy access to information. What I learned at the post office changed all of that.

I found that someone had gone to the post office and put a hold on our mail — but only the mail addressed to my wife. Luckily, all of our mail was held or we may not have noticed anything wrong since my wife gets so little mail. The hold instructions clearly stated that my “wife” would be picking up the held mail.

This means that there’s someone in my little town or surrounding area committing this crime. This isn’t anonymous anymore. There’s an actual person in driving distance doing this to us. I’m sure we weren’t specifically singled out for this; we may only be one of many. Still, it makes this situation feel personal.

I don’t have any idea how this could have been prevented. The woman at the post office clearly did not believe me when I explained that nobody in our household placed the hold, and the idea of someone placing a hold maliciously wasn’t even in her realm of belief. She almost let me walk out with the bin of held mail without even checking my ID, but then she muttered that I could be a bad guy so she should check, I guess.

Without diligent vetting, anyone can walk into the post office and place a hold on mail. With no vetting at all, someone can go online and place a mail hold on an address. There’s no way that I’ve found online or by talking to the postal clerk that allows you to protect your mail from this kind of tampering. I’d love it if I could fill out something that prevented holds from being placed unless my wife or I did it in person, verified by our IDs.

We’re working with the police, who are hopeful that the crook will show up at some point to pick up the mail, or that they left some kind of trail when placing the hold. Until then, we keep a more diligent eye on everything.

Working with NodeJS source

2015-05-20T00:00:00-06:00

I’ve developed an interest in contributing to the NodeJS project, especially since I found some things while working on my sslinfo module that could be improved in the x509 realm.

I’m not comfortable building and running the Node source on my everyday machine since I don’t know what kinds of side effects and conflicts I might cause. It seemed only natural to use some kind of virtual machine based solution, but I’ve been having little luck getting an environment set up to my liking.

I have a modest list of requirements that I’d like to satisfy with a VM-based solution:

Quick and repeatable VM creation
Access to the Node source from within the VM, for building/testing/deploying in a “clean” environment.
Access to the Node source from the host machine, for using my existing dev tools (TextMate, SublimeText) to modify code and documentation, and for using my existing Git tools.

Basically, I’ve already got a set of tools in my Mac environment that I’m very accustomed to. I don’t want to reinvent that wheel by requiring a bunch more tools within the VM.

My initial thought was to simply repurpose the Vagrant setup I use to manage this blog. It’s a simple setup, with a config.vm.synced_folder "../node/", "/opt/node" line in the Vagrantfile to map my already checked out NodeJS source into the VM.

Once I had the VM running, I SSH’ed in and ran the following:

$ cd /opt/node
$ make clean && rm -rf out
$ ./configure
$ make
$ make test

The code builds with no errors, but 14 tests fail.

Failed test summary -

Path: simple/test-cluster-http-pipe
Error: bind EPERM

Path: simple/test-fs-error-messages
assert.js:86
  throw new assert.AssertionError({
        ^
AssertionError: false == true

Command: out/Release/node /opt/node/test/simple/test-fs-error-messages.js
Message from syslogd@debian-7 at May 20 12:48:18 ...
 kernel:[  951.248484] Oops: 0002 [#1] SMP

Path: simple/test-fs-symlink
Error: EPERM, link '/opt/node/test/tmp/link1.js'

Path: simple/test-http-client-pipe-end
Error: listen EPERM

Path: simple/test-http-client-response-domain
Error: listen EPERM

Path: simple/test-http-unix-socket
Error: listen EPERM

Path: simple/test-net-pingpong
/opt/node/test/tmp/test.sock
Error: listen EPERM

Path: simple/test-net-pipe-connect-errors
Error: listen EPERM

Path: simple/test-pipe-address
Error: listen EPERM

Path: simple/test-pipe-stream
Error: listen EPERM

Path: simple/test-pipe-unref
Error: listen EPERM

Path: simple/test-repl
repl test
Error: listen EPERM

Path: simple/test-tls-connect-pipe
Error: listen EPERM

Grrr, although there is a pattern. The majority of the failures have an EPERM root cause.

For this attempt, I didn’t bother setting a shared folder in the Vagrantfile. Parallels tools are installed, and they give me access to my Mac’s files through /media/psf.

The steps this time:

$ cd /media/psf/Home/Documents/workspaces/node #Yeah, that's where I keep my code.
$ make clean && rm -rf out
$ ./configure
$ make
$ make test

14 tests fail, just like before.

Grrr again.

I asked Twitter. I asked the NodeJS IRC channel. I Googled. Finally, I found a single page that offered anecdotal evidence that NodeJS cannot create sockets in a shared directory in a VM. Looking back at the failing tests, they were all socket or pipe related.

I have not been able to find “official” confirmation of this. If anyone can confirm or deny, please let me know.

Attempt Three: Vagrant VM with SFTP Sync

I didn’t bother with shared folders at all this time. I installed the handy SFTP plugin for Sublime Text and synced my local NodeJS source into the VM.

Steps again:

$ cd /home/cjohnston/node
$ make clean && rm -rf out
$ ./configure
$ make
$ make test

Only 1 test fails this time, but it’s a new failure.

Failed test summary -

Path: simple/test-fs-realpath
Error: EEXIST, file already exists '/home/cjohnston/node/test/fixtures/nested-index/one/symlink1-dir'

I honestly have no idea why this test fails. Maybe it’s file permissions due to the SFTP copy?

Attempt Four: Give up and check out the code in the VM

As expected, building and running the tests works perfectly with this method. However, I’ve also lost the ability to expose the code to the host OS. My Vagrant VM doesn’t have a windowing system installed, so I’m down to vi for code edits, and checking out the source in parallel on my Mac for making and previewing doc changes.

At this point, I’d be happy for any input on how to achieve my development goals as stated at the top of the post. Solving the issue of being able to open sockets and pipes in a shared folder would be fantastic, but I don’t know how hard that problem would be to solve.

Simple Data Analysis with Hive

2013-07-17T00:00:00-06:00

Hive is a data warehouse system for Hadoop that facilitates easy data summarization, ad-hoc queries, and the analysis of large datasets stored in Hadoop compatible file systems. Hive provides a mechanism to project structure onto this data and query the data using a SQL-like language called HiveQL.

This is a simple getting started example that’s based upon “Hive for Beginners”, with what I feel is a bit more useful information.

(This example is also available using Pig.)

The installation and configuration of Hadoop and Hive is beyond the scope of this article. If you’re just getting started, I would highly recommend grabbing one of Cloudera’s pre-built virtual machines that have everything you need.

Cloudera’s VMs have changed substantially since this article was written. I have not been able to verify that the new VMs will work with these instructions.

I’m assuming that you will be running the following steps using the Cloudera VM, logged in as the cloudera user. If your setup is different, adjust accordingly.

Step 1: Preparing the Data

Like “Hive for Beginners”, we’re going to use the Book Crossing Dataset. Download the CSV dump and extract the files. We’re interested in the BX-Books.csv data file.

Type head BX-Books.csv to see the first few lines of the raw data. You’ll notice that’s it’s not really comma-delimited; the delimiter is ‘;’. There are also some escaped HTML entities we can clean up, and the quotes around all of the values can be removed.

The first line in the file looks like this:

"ISBN";"Book-Title";"Book-Author";"Year-Of-Publication";"Publisher";"Image-URL-S";"Image-URL-M";"Image-URL-L"

This lines defines the data format of the fields in the file. We’ll want to refer back to it later.

Open a terminal and enter:

sed 's/\&amp;/\&/g' BX-Books.csv | sed -e '1d' |sed 's/;/$$$/g' | sed 's/"$$$"/";"/g' | sed 's/"//g' > BX-BooksCorrected.txt

This will:

Replace all & instances with &
Remove the first (header) line
Change all semicolons to $$$
Change all "$$$" instances into ";"
Remove all " characters

Steps 3 and 4 may look strange, but some of the field content may contain semicolons. In this case, they will be converted to $$$, but they will not match the "$$$" pattern, and will not be converted back into semicolons and mess up the import process.

Step 2: Importing the Data

Now that we have some normalized data, we need to add it to the Hadoop file system (HDFS) so that Hive can access it. In the terminal, type:

hadoop fs -mkdir input
hadoop fs -put /path/to/BX-BooksCorrected.txt input

(Use the correct path to the BX-BooksCorrected.txt file.)

Step 3: Running Hive

Enter hive at the console to start Hive.

Once Hive has started, you’ll see the hive> command prompt. Let’s verify that our file did get loaded into HDFS.

dfs -ls input;

Step 4: Analyzing the Data

Now that we have the data ready, let’s do something with it. The simple example is to see how many books were published per year. We’ll start with that, then see if we can do a bit more.

Load the data into a Hive table:

CREATE TABLE IF NOT EXISTS BookData
> (ISBN STRING,
> BookTitle STRING,
> BookAuthor STRING,
> YearOfPublication INT,
> Publisher STRING)
> ROW FORMAT DELIMITED
> FIELDS TERMINATED BY '\;'
> STORED AS TEXTFILE;

LOAD DATA INPATH '/user/cloudera/input/BX-BooksCorrected.txt'
> OVERWRITE INTO TABLE BookData;

(HQL commands are terminated with semicolons. If you press Return on a line without terminating it, you’ll get the > character, indicating that the command has been continued and not entered yet.) This creates a Hive table named BookData and loads the information from HDFS into it. Hive expects data to be tab-delimited by default, but ours is not; we have to tell it that semicolons are field separators by providing the FIELDS TERMINATED BY argument. You’ll notice that we left off all of the “Image-URL-XXX” fields; we don’t need them for analysis, and Hive will ignore fields that we don’t tell it to load.

If you want to see what the loaded data structure looks like, you can use the DESCRIBE command:

DESCRIBE BookData;

Finding books by year

We’ll start with the simple analysis of how many books were written by year. In Hive, this can be accomplished with a single query.

Get number of books by year:

SELECT YearOfPublication, COUNT(BookTitle)
> FROM BookData GROUP BY YearOfPublication;

You’ll see a listing of years, along with the number of books for that year. You may notice that some of the values don’t make much sense; there should be no year 0, nor should there be entries for a blank year. We’ll clean those problems up in the next analysis.

More Advanced Analysis

There’s a lot more data in the set beyond years and books counts. What if we wanted to see books published per year by author? Why don’t we go a step farther and group those results by publisher as well?

Let’s do a little bit of cleanup on the data to eliminate the unwanted years.

INSERT OVERWRITE TABLE BookData
> SELECT BookData.*
> FROM BookData WHERE YearOfPublication > 0;

This will only keep records where we have a positive year of publication value.

Generating the final results is again a single query:

SELECT Publisher, BookAuthor, YearOfPublication, COUNT(BookTitle)
> FROM BookData
> GROUP BY Publisher, BookAuthor, YearOfPublication;

At last! We have our results.

(Want to compare the Hive steps with Pig? Here’s the same example using Pig.)

Simple Data Analysis with Pig

2013-07-16T00:00:00-06:00

Pig is a platform that works with large data sets for the purpose of analysis. The Pig dialect is called Pig Latin, and the Pig Latin commands get compiled into MapReduce jobs that can be run on a suitable platform, like Hadoop.

This is a simple getting started example that’s based upon “Pig for Beginners”, with what I feel is a bit more useful information.

(This example is also available using Hive.)

The installation and configuration of Hadoop and Pig is beyond the scope of this article. If you’re just getting started, I would highly recommend grabbing one of Cloudera’s pre-built virtual machines that have everything you need.

Cloudera’s VMs have changed substantially since this article was written. I have not been able to verify that the new VMs will work with these instructions.

I’m assuming that you will be running the following steps using the Cloudera VM, logged in as the cloudera user. If your setup is different, adjust accordingly.

Step 1: Preparing the Data

Like “Pig for Beginners”, we’re going to use the Book Crossing Dataset. Download the CSV dump and extract the files. We’re interested in the BX-Books.csv data file.

Type head BX-Books.csv to see the first few lines of the raw data. You’ll notice that’s it’s not really comma-delimited; the delimiter is ‘;‘. There are also some escaped HTML entities we can clean up, and the quotes around all of the values can be removed.

The first line in the file looks like this:

"ISBN";"Book-Title";"Book-Author";"Year-Of-Publication";"Publisher";"Image-URL-S";"Image-URL-M";"Image-URL-L"

This lines defines the data format of the fields in the file. We’ll want to refer back to it later.

Open a terminal and enter:

sed 's/\&amp;/\&/g' BX-Books.csv | sed -e '1d' |sed 's/;/$$$/g' | sed 's/"$$$"/";"/g' | sed 's/"//g' > BX-BooksCorrected.txt

This will:

Replace all & instances with &
Remove the first (header) line
Change all semicolons to $$$
Change all "$$$" instances into ";"
Remove all " characters

Step 2: Importing the Data

Now that we have some normalized data, we need to add it to the Hadoop file system (HDFS) so that Pig can access it. This can be accomplished from the command line as well as within Pig itself. For this example, we’ll use the command line. In the terminal, type:

hadoop fs -mkdir input
hadoop fs -put /path/to/BX-BooksCorrected.txt input

(Use the correct path to the BX-BooksCorrected.txt file.)

Step 3: Running Pig

There are several ways to run Pig. We’re going to run in MapReduce mode against the local node. MapReduce mode runs against the HDFS, which is why we needed to import the file in the previous step.

Enter pig at the console to start Pig.

Once Pig has started, you’ll see the grunt> command prompt. Let’s verify that our file did get loaded into HDFS.

ls
hdfs://localhost.localdomain:8020/user/cloudera/input	<dir>
cd input
ls
hdfs://localhost.localdomain:8020/user/cloudera/input/BX-BooksCorrected.txt	<dir>

Step 4: Analyzing the Data

Now that we have the data ready, let’s do something with it. The simple example is to see how many books were published per year. We’ll start with that, then see if we can do a bit more.

Load the data into a Pig collection:

books = LOAD '/user/cloudera/input/BX-BooksCorrected.txt'
>> USING PigStorage(';') AS
>> (ISBN:chararray, BookTitle:chararray,
>> BookAuthor:chararray, YearOfPublication:int,
>> Publisher:chararray);

(Pig Latin commands are terminated with semicolons. If you press Return on a line without terminating it, you’ll get the >> characters, indicating that the command has been continued and not entered yet.) This line loads the information from HDFS into a Pig collection named books. Pig expects data to be tab-delimited by default, but ours is not; we have to tell it that semicolons are field separators by providing the PigStorage() argument. The AS clause defines how the fields in the file are mapped into Pig data types. You’ll notice that we left off all of the “Image-URL-XXX” fields; we don’t need them for analysis, and Pig will ignore fields that we don’t tell it to load.

If you want to see what the loaded data structure looks like, you can use the DESCRIBE command:

DESCRIBE books;
books: {ISBN: chararray,BookTitle: chararray,BookAuthor: chararray,YearOfPublication: int,Publisher: chararray}

Finding books by year

We’ll start with the simple analysis of how many books were written by year.

Group the collection by year of publication:

groupByYear = GROUP books BY YearOfPublication;

DESCRIBE groupByYear;
groupByYear: {group: int,books: {(ISBN: chararray,BookTitle: chararray,BookAuthor: chararray,YearOfPublication: int,Publisher: chararray)}}

This is a lot like a Java Map. The groupByYear collection contains all unique year values, along with a list holding the full entry of each book that belongs to that year.

Generate book count by year:

countByYear = FOREACH groupByYear
>> GENERATE group AS YearOfPublication, COUNT($1) AS BookCount;

DESCRIBE countByYear;
countByYear: {YearOfPublication: int,BookCount: int}

This is the meat of the operation. The FOREACH loops over the groupByYear collection, and we GENERATE values. Our output is defined using some values available to us within the FOREACH. We first take group, which is an alias for the grouping value and say to place it in our new collection as an item named YearOfPublication. (This value is also available as $0.) The next value $1 is an alias for the list of book entries for that group. We only care about the number of books, so we use COUNT and give it the name BookCount.

We have the results, but how do we see them? We could store them back into HDFS and extract them that way, or we can use the DUMP command.

DUMP countByYear;

More Advanced Analysis

You should still have your books collection defined if you haven’t exited your Pig session. You can redefine it easily by following the above steps again. Let’s do a little bit of cleanup on the data this time, however.

books = FILTER books BY YearOfPublication > 0;

This will only keep records where we have a positive year of publication value.

Now, we need to create a set of all authors, and all years they wrote books:

pivot = FOREACH (GROUP books BY BookAuthor)
>> GENERATE group AS BookAuthor, FLATTEN(books.YearOfPublication) AS Year;

Note that I’ve inlined the group creation in the FOREACH statement. It should be obvious that we’re grouping books by author. This statement also introduces the FLATTEN operation. We know that the GROUP operation creates a collection where each key corresponds to a list of values; FLATTEN “flattens” this list to generate entries for each list value. (See the Pig Latin reference for a more detailed definition.) You may want to DUMP the pivot collection to see how the flattening works.

Create author book count by year:

authorYearGroup = GROUP pivot BY (BookAuthor, Year);

with_count = FOREACH authorYearGroup
>> GENERATE FLATTEN(group), COUNT(pivot) as count;

DESCRIBE with_count;

with_count: {group::BookAuthor: chararray,group::Year: int, count: long}

This time, we’re grouping on 2 fields. This will find all (author, year) combinations. We then execute a FOREACH over the group; this time, however, we’re using FLATTEN on the group which will expand to BookAuthor and Year. We also grab the count of items to get the number of books for that author/year combination. You can see the resulting data structure in the DESCRIBE results.

Let’s group those results a little better:

author_result = FOREACH (GROUP with_count BY BookAuthor) {
>> order_by_count = ORDER with_count BY count DESC;
>> GENERATE group AS Author, order_by_count.(Year, count) AS Books;
>> };

DESCRIBE author_result;

author_result: {Author: chararray,Books: {(group::Year: int,count: long)}}

We’re running a FOREACH that looks different than the ones we’ve seen to this point. This nested structure lets us perform some extra steps before generation of values. In this case, we’re sorting the book count, then placing the year/count tuples into the collection with the author.

Group the author results by publisher:

pub_auth = FOREACH books GENERATE Publisher, BookAuthor;

distinct_authors = FOREACH (GROUP pub_auth BY Publisher) {
>> da = DISTINCT pub_auth.BookAuthor;
>> GENERATE group AS Publisher, da AS Author;
>> };

distinct_flat = FOREACH distinct_authors GENERATE Publisher, FLATTEN(Author) AS Author;

First, we use a projection to extract only the publisher and author from the books collection. This is a recommended practice as it helps with performance. In this FOREACH, we’re grabbing the distinct authors per publisher. This collection is then flattened into distinct_flat, and we end up with a publisher/author list, similar to the author/year collection previously.

Join the results so far:

joined = JOIN distinct_flat BY Author, author_result BY Author;
filtered = FOREACH joined GENERATE
>> distinct_flat::Publisher AS Publisher,
>> distinct_flat::Author AS Author,
>> author_result::Books AS Books;

Here we’re joining the author/year results with the publisher/author results. The “::” syntax may look a little different than what we’ve seen before; it’s a dereference operator, and it’s used when you need to unambiguously declare a column. Try DESCRIBE on joined and filtered to see the structure difference.

Generate the final results:

result = FOREACH (GROUP filtered BY Publisher) {
>> order_by_pub = ORDER filtered BY Publisher ASC;
>> GENERATE group AS Publisher, order_by_pub.(Author, Books); };

This should be familiar by now. We sort publishers, then generate a collection of publishers/authors/books.

At last! We have our results. You can DUMP them, but let’s also save the results back into HDFS.

STORE result INTO '/user/cloudera/publisher_books';

Now you can exit Pig with “quit”.

Let’s get a file listing:

hadoop fs -ls publisher_books

Hadoop stores publisher_books as a directory with associated files. Our actual data is in part-r-00000

hadoop fs -cat publisher_books/part-r-00000

(Want to compare the Pig steps with Hive? Here’s the same example using Hive.)

iOS6 table views and accessory segues

2012-10-25T00:00:00-06:00

If you’re performing segues on a table row selection, you’re probably used to doing something like this in the prepareForSegue: method:

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
  if ([[segue identifier] isEqualToString:@"mySegueIdentifier"]) {
    NSIndexPath *indexPath = [self.tableView indexPathForSelectedRow];
    ... do some work ...
  }
}

In iOS6, segues can now be connected from a table cell’s accessory action. When making this connection, however, the indexPathForSelectedRow returns nil. The prepareForSegue: method has a sender parameter. In the case of an accessory action, this parameter is a UITableViewCell. Knowing this, we can get the correct indexPath like this:

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
  if ([[segue identifier] isEqualToString:@"mySegueIdentifier"]) {
    NSIndexPath *indexPath = [self.tableView indexPathForCell:sender];
    ... do some work...
  }
}

Optimizing images for iOS (and more)

2012-09-21T00:00:00-06:00

Now that Apple is requiring launch images in all iOS apps, many developers will see their application size increase, perhaps drastically. I use a fantastic (and free!) tool called ImageOptim to reduce the size of the images in my projects.

I was able to get over 65% file size reduction on my iPad launch images, and well over 50% on the iPhone images. Of course, your mileage may vary but it’s certainly worth checking out.

ImageOptim isn’t limited to iOS apps. It’s useful wherever you may have a need to for reduced PNG file sizes.

Supporting the iPhone 5 Screen

2012-09-20T00:00:00-06:00

I had to dig a bit to find this information when adding iPhone 5 support to my app. It’s pretty easy: you need to supply a 640px by 1136px launch image. That’s it. Of course, there may be layout issues that need tending to afterwards, but that’s a different story.

I suspect that Apple forced the inclusion of the launch image to make all devs use them. I know quite a few apps that don’t have launch images, even though Apple’s HIG says they’re required.

Setting UITableView with grouped style background in iOS

2012-09-11T00:00:00-06:00

Setting the background of a UITableView is a simple operation in most cases. In my latest app, we set the background to a nice texture with a line like this:

self.tableView.backgroundColor = [UIColor colorWithPatternImage: [UIImage imageNamed: @"myFancyBackground.png"]];

For some reason, when a UITableView with the grouped style is presented in a popover, this code does not work. It turns out that grouped table views have a custom backgroundView property. I don’t know why this property only takes precedence when the table is in a popover, but here’s how to fix it to display your custom background:

self.tableView.backgroundView = nil;
self.tableView.backgroundColor = [UIColor colorWithPatternImage: [UIImage imageNamed: @"myFancyBackground.png"]];

Setting the backgroundView to nil doesn’t seem to have any ill side effects that I’ve noticed. Hopefully someone can correct me if I’m wrong.

Open PDF in New Window with Seam

2009-10-12T00:00:00-06:00

For a recent Seam development project, I had the task of creating a PDF report from some user input and displaying the result in a new window.

Initially, I used a <h:commandLink/> with target="_blank". This worked well until the user entered criteria that failed validation. The new window was still created, and the validation messages were shown in the new window. This was not a good solution, so after some research and experimentation I came up a solution that meets the following criteria:

Validation messages are shown in original window.
A new window is not created when there are validation messages.
A new window is not created when the entered criteria returns zero (0) results.

The Action Class

For this example, the action class is very simple:

public String getReportURL() {
  return "/pdfpopup/reports/reportDisplay.seam";
}
// Getters and setters omitted
public List<String> getReportData() {
  return reportData;
}
public void doSearch() {
  // This is where the work would actually happen
  reportData = new ArrayList<String>();
  for (int i = 0; i < selectOneValue; i++) {
    reportData.add("Report Row " + (i + 1));
  }
  if (reportData.isEmpty()) {
    facesMessages.add("Report will be empty, not popping up");
  }
}

I added the getReportURL() method to the action because there may be occasions where the report URL differs based on criteria. In the application I worked on, we had to support PDF and Excel reports, so the method returned the correct URL.

The action simply takes the criteria specified on the JSF page and populates a list of results based on that criteria. The PDF generation page will access the list later.

The JSF Page

The JSF page looks like this:

<ui:define name="body">
  <script type="text/javascript">
  //<![CDATA[
  function showReport(conversationId) {
    if (document.getElementById("messages") != null) {
      return;
    }
    var reportWin = window.open('#{reportAction.reportURL}' + '?cid=' + conversationId);
    if (!reportWin) {
      alert("Could not open the report window. Please disable popup blocking for this website and try again.");
    }
  }
  // ]]>
  </script>
  <h:form id="generateReport">
    <s:validateAll>
      <h:panelGrid width="100%" columns="1" style="text-align: center; font-weight:bold; font-size: 12px">
        <h:outputText value="Report Query"/>
      </h:panelGrid>
      <h:panelGrid columns="2" border="0" frame="none" style="padding-top:30px;">
        <h:outputLabel for="selectOneValue">Number of Output Rows</h:outputLabel>
        <h:selectOneMenu id="selectOneValue" value="#{reportAction.selectOneValue}" required="true">
          <f:selectItem itemLabel="Zero" itemValue="0"/>
          <f:selectItem itemLabel="One" itemValue="1"/>
          <f:selectItem itemLabel="Two" itemValue="2"/>
          <f:selectItem itemLabel="Three" itemValue="3"/>
          <f:selectItem itemLabel="Four" itemValue="4"/>
        </h:selectOneMenu>
        <h:outputLabel for="startDate">Report Period:</h:outputLabel>
        <h:panelGroup>
          <rich:calendar id="startDate" enableManualInput="true" value="#{reportAction.startDate}" showWeeksBar="false" datePattern="MM/dd/yyyy" immediate="true" required="true" label="Report Start Date"/>
          <h:outputLabel for="endDate">through</h:outputLabel>
          <rich:calendar id="endDate" enableManualInput="true" value="#{reportAction.endDate}" showWeeksBar="false" datePattern="MM/dd/yyyy" immediate="true" required="true" label="Report End Date"/>
        </h:panelGroup>
      <a4j:commandButton id="getReportLink" action="#{reportAction.doSearch}" value="Get Report" oncomplete="showReport('#{conversation.id}')"/>
     </h:panelGrid>
    </s:validateAll>
  </h:form>
</ui:define>

This is really the guts of the operation. When the commandButton is clicked, the doSearch() method will be executed. Once that call is complete, the oncomplete handler will be called.

The page template is configured so that any FacesMessages will be displayed in an element with id “messages”. If this element is present, we assume that either a validation error or no data message is being displayed and do not show the PDF. If the element is not present, everything is OK and we open the new window with the URL for the PDF. Note that it’s crucial to pass the conversation ID along so that the data loaded by the action will be visible to the page creating the PDF.

The PDF

For completeness, here’s the sample page I’m using to create a PDF:

<p:document xmlns:p="http://jboss.com/products/seam/pdf" xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:f="http://java.sun.com/jsf/core" title="Sample PDF Report">
  <f:facet name="header">
    <p:font size="12">
      <p:header borderWidthTop="0" borderWidthBottom="0.4" alignment="center">
        <p:paragraph indentationLeft="50">REPORT HEADER</p:paragraph>
      </p:header>
      <p:footer borderWidthTop="1" borderColorTop="black" borderWidthBottom="0" alignment="center"> [<p:pageNumber/>] </p:footer>
    </p:font>
  </f:facet>
  <ui:repeat var="item" value="#{reportAction.reportData}">
    <p:font size="8">
      <p:table columns="1" headerRows="1" widthPercentage="100">
        <p:font style="bold">
          <p:cell verticalAlignment="bottom">Report Data</p:cell>
        </p:font>
        <p:cell>#{item}</p:cell>
      </p:table>
    </p:font>
  </ui:repeat>
</p:document>

Full Sample Code

You can view and download the full sample code for this solution from here.

The Phone Screen Works Both Ways

2009-09-08T00:00:00-06:00

I recently applied for a position through a recruiting service. I jumped through the requisite hoops and was told that the prospective employer was very excited to talk to me.

The standard procedure for this employer is to give candidates a simple phone screen before arranging an interview. Personally, I feel that having one person make a decision about whether or not I’ll “fit well with the team” after 10 minutes on the phone is ludicrous, but that’s the game I had to play.

During the phone call, I was asked several generic questions about Java. I gave what I felt was correct answers to the questions, but the interviewer wasn’t happy with my results. Every time I answered a question, I heard “Well, I was looking for…”, with the expected answer simply being a different wording of what I had said.

I chalked this up to the interviewer simply being used to different terminology than I for the same concepts, so I was a bit surprised when I wasn’t called in for an in-person interview. It wasn’t until a few days later that I realized that the answers I was expected to give told me quite a bit about the company, and that I wouldn’t have been happy working there had I been offered the job.

The particular question that stuck in my mind was a simple one. “What are some of the benefits of the introduction of generics in Java, especially in collections?”

I gave the answer that pretty much anybody familiar with Java generics would give: compile-time type checking, no need for casting objects, etc. What I got from the interviewer was “Well, I was looking for the fact that you don’t have to do instanceof checks all over any more.”

On the surface, this may seem like another way of saying what I said, but it’s actually quite different.

Before generics, you would need to cast objects to the proper class when retrieving them from a collection. This does not mean that you would be using instanceof to do this. The only situation I can think of that requires using instanceof with a collection is if there are a lot of heterogenous objects in the collection.

There are limited situations where storing different object types in the same collection makes sense. Most of the time, however, this is a sign of either lazy development or not understanding the collection mechanism very well.

It’s generally a good idea to only put one type of object into a collection. This makes it much easier to work with and avoids any need for instanceof checks. By “one type of object”, I don’t mean that all of the objects need to be the exact same class. Chances are good that all of the objects being placed into a collection have some relationship; perhaps they will all implement the same interface.

I may have completely misinterpreted the interviewer, but I have a very strong impression that he and perhaps others on his team are used to using collections as grab bags of widely different things. Personally, I wouldn’t want to maintain that code. I can hope that the addition of generics to Java has forced the interviewer to change at least one practice for the better. I’m glad I wasn’t called in for the job — who knows how many more “well, at least it works” practices are being followed? I’ve got enough of those at my current job; I don’t need to learn a new set.