This is a series of 8 anthropology lectures on the topic Socities in Transition recorded at Linacre College, Oxford University during early 2009. Each podcast is just under an hour and audio only (occasional mention is made of slides). Each lecture is given by a different presenter. All are fairly academic in nature (a couple are quite dry and I found it hard to maintain concentration), but are still accessible to the non-expert. These lectures are not straight history, there is little discussion of historical events. Instead each podcast presents current research on the process of social transition during a notable period of history. They often provide an interesting snapshot (or at least intriguing tidbits) of life around the time of the transition.

The lectures are in chronological order, spanning the entirity of human history - and beyond. The first lecture is on the Neanderthals - their slow extinction and modern discovery. The next lecture deals with the spread of farming in South East Asia. Then follows an interesting lecture on the spread of metallurgy in the Bronze Age and what the metals meant to society at different times and places. Another interesting lecture details attempts to date and size the volcanic explosion at Thera (now Santorini). From this research the presenter trys to match up the likely effects with events and history in the region (mainly the Minoan society on Crete). The next two lectures are respectively on the beginning and end of Roman rule in Britain. Apparently the collapse of the British economy after the Romans left was particularly swift - previously common pottery and coins disappeared almost overnight and buildings quickly fell into disrepair. The last two lectures are on more modern topics - the industrial and the current information revolutions.

Worth a listen for background information on the timeperiods discussed.

Map<String, VirtualMachine> result = new HashMap<String, VirtualMachine>();
List<VirtualMachineDescriptor> list = VirtualMachine.list();
for (VirtualMachineDescriptor vmd: list) {
   String desc = vmd.toString();
   try {
      result.put(desc, VirtualMachine.attach(vmd));
   } catch (IOException e) {
      e.printStackTrace(); 
   } catch (AttachNotSupportedException e) {
      e.printStackTrace(); 
   }
}

private JMXConnector getLocalConnection(VirtualMachine vm) throws Exception {
   Properties props = vm.getAgentProperties();
   String connectorAddress = props.getProperty(CONNECTOR_ADDRESS_PROPERTY);
   if (connectorAddress == null) {
      props = vm.getSystemProperties();
      String home = props.getProperty("java.home");
      String agent = home + File.separator + "lib" + File.separator + "management-agent.jar";
      vm.loadAgent(agent);
      props = vm.getAgentProperties();
      connectorAddress = props.getProperty(CONNECTOR_ADDRESS_PROPERTY);
   }
   JMXServiceURL url = new JMXServiceURL(connectorAddress);
   return JMXConnectorFactory.connect(url);
}

The resulting JMXConnector can be used in the normal way to retrieve data from JMX calls. For instance, if the JMX process exposed a no-arg function functionName on object objectName, the call would be:

MBeanServerConnection mbsc = connector.getMBeanServerConnection();					
String result = (String)mbsc.invoke(new ObjectName("objectName"),
                                     "functionName", new Object[] {}, new String[] {});

Finding remote JMX processes is something you'll need to work out yourself, but assuming the host, port, user and password are known, the code to get a JMXConnector is:

private JMXConnector getRemoteConnection(String host, int port, String user, String password) throws Exception {
   JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://"+host+":"+port+"/jmxrmi");
   final Map<String, String[]> environment = new HashMap<String, String[]>();
   environment.put(JMXConnector.CREDENTIALS, new String[] {user, password} );
   return JMXConnectorFactory.connect(url, environment);
}

The resulting JMXConnector can be used in the same manner as before. So with the above code it is just a matter of adding some GUI glue to create the required dialog. Excuse the main method and dodgy exception handling (and anything else) - this is just a quick example class.

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JRadioButton;
import javax.swing.JTextField;

import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;

// requires Sun's default-tools.jar
public class JmxConnectorDialog extends JDialog implements ActionListener, KeyListener {

	private static final long serialVersionUID = 1L;
	private static final String CONNECTOR_ADDRESS_PROPERTY = "com.sun.management.jmxremote.localConnectorAddress";
	
	private final JRadioButton localButton = new JRadioButton("Local Process");
	private final JRadioButton remoteButton = new JRadioButton("Remote Process");
	private final Map<String, VirtualMachine> localEngines = findEngines();
	private final JComboBox typeList = new JComboBox(localEngines.keySet().toArray());
	private final JTextField hostField = new JTextField(20);
	private final JTextField portField = new JTextField(20);
	private final JTextField userField = new JTextField(20);
	private final JPasswordField passField = new JPasswordField(20);
	
	private JMXConnector connector = null;
	private String errorString = "";
	
	public static void main(String[] args) {
		JFrame frame = new JFrame("Graph Explorer");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        

	    JmxConnectorDialog jmxDialog = JmxConnectorDialog.showDialog(frame);
	    JMXConnector connector = jmxDialog.getConnector();
        if (connector==null) {
        	JOptionPane.showMessageDialog(frame,
	        	    "Can't connect to JMX server: "+jmxDialog.getError(),
	        	    "Connection error", JOptionPane.ERROR_MESSAGE);
        } else {
        	JOptionPane.showMessageDialog(frame, "Selected real Java process");
        }
   
        /*
        MBeanServerConnection mbsc = connector.getMBeanServerConnection();
		String result = (String)mbsc.invoke(new ObjectName("objectName"),
				"functionName", new Object[] {}, new String[] {});			
        */
	}
	
	public static JmxConnectorDialog showDialog(Component frameComp) {
		Frame frame = JOptionPane.getFrameForComponent(frameComp);
		JmxConnectorDialog dialog = new JmxConnectorDialog(frame);
		dialog.setVisible(true);
		return dialog;
	}

	
	public JmxConnectorDialog(Frame frame) {
		super(frame, "JMX Connection", true);
		addWindowListener(new WindowAdapter() {
			@Override public void windowClosing(WindowEvent e) {
				errorString="User cancelled";
				setVisible(false);
			}
		});
		
		Container contentPane = getContentPane();
		JPanel content = new JPanel();
		content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
		contentPane.add(content);
			
		content.add(createLocalPanel());
		content.add(createRemotePanel());
		content.add(createButtonPanel());
		
		ButtonGroup group = new ButtonGroup();
	    	group.add(localButton);
	    	group.add(remoteButton);
	  
		pack();
	}
	
	private JPanel createLocalPanel() {
		JPanel localPanel = new JPanel(new FlowLayout(FlowLayout.LEADING));
		localButton.setPreferredSize(new Dimension(150, 50));
		localButton.setSelected(true);
		localPanel.add(localButton);
		typeList.addActionListener(new ActionListener() {
			@Override public void actionPerformed(ActionEvent e) {
				localButton.setSelected(true);
			}			
		});
		JPanel listPanel = new JPanel(new FlowLayout());
		listPanel.add(typeList, BorderLayout.SOUTH);
		localPanel.add(listPanel);
		return localPanel;
	}
	
	private JPanel createRemotePanel() {
		JPanel remotePanel = new JPanel(new FlowLayout(FlowLayout.LEADING));
		remoteButton.setPreferredSize(new Dimension(150, 50));
		remotePanel.add(remoteButton);
		JPanel remoteOptionPanel = new JPanel();
		remoteOptionPanel.setLayout(new BoxLayout(remoteOptionPanel, BoxLayout.Y_AXIS));
		remoteOptionPanel.add(createField("Host", hostField));
		remoteOptionPanel.add(createField("Port", portField));
		remoteOptionPanel.add(createField("User", userField));
		remoteOptionPanel.add(createField("Password", passField));
		remotePanel.add(remoteOptionPanel);
		return remotePanel;
	}
	
	private JPanel createButtonPanel() {
		JPanel buttonPanel = new JPanel(new FlowLayout());
		JButton connectButton = new JButton("Connect");
		getRootPane().setDefaultButton(connectButton);
		connectButton.addActionListener(this);
		buttonPanel.add(connectButton);
		JButton cancelButton = new JButton("Cancel");
		cancelButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				errorString="User cancelled";
				setVisible(false);
			}
		});
		buttonPanel.add(cancelButton);
		return buttonPanel;
	}
	
	private JPanel createField(String label, JTextField field) {
		JPanel fieldPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 5, 1));
		JLabel labelComponent = new JLabel(label);
		labelComponent.setPreferredSize(new Dimension(60, 10));
		fieldPanel.add(labelComponent);
		fieldPanel.add(field);
		field.addKeyListener(this);
		return fieldPanel;
	}
	
	private Map<String, VirtualMachine> findEngines() {
		Map<String, VirtualMachine> result = new HashMap<String, VirtualMachine>();
		List<VirtualMachineDescriptor> list = VirtualMachine.list();
		for (VirtualMachineDescriptor vmd: list) {
			String desc = vmd.toString();
			try {
				result.put(desc, VirtualMachine.attach(vmd));
			} catch (IOException e) {
				e.printStackTrace(); 
			} catch (AttachNotSupportedException e) {
				e.printStackTrace(); 
			}
		}	
		return result;
	}
	
	private JMXConnector getLocalConnection(VirtualMachine vm) {
		try {
			Properties props = vm.getAgentProperties();
			String connectorAddress = props.getProperty(CONNECTOR_ADDRESS_PROPERTY);
			if (connectorAddress == null) {
			   props = vm.getSystemProperties();
			   String home = props.getProperty("java.home");
			   String agent = home + File.separator + "lib" + File.separator + "management-agent.jar";
			   vm.loadAgent(agent);
			   props = vm.getAgentProperties();
			   connectorAddress = props.getProperty(CONNECTOR_ADDRESS_PROPERTY);
			}
			
			JMXServiceURL url = new JMXServiceURL(connectorAddress);
			return JMXConnectorFactory.connect(url);
		} catch (Exception e) {
			e.printStackTrace();
			errorString = e.getMessage();
			return null;
		}
	}
	
	private JMXConnector getRemoteConnection(String host, int port, String user, String password) {
		try {
			JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://"+host+":"+port+"/jmxrmi");
			final Map<String, String[]> environment = new HashMap<String, String[]>();
			environment.put(JMXConnector.CREDENTIALS, new String[] {user, password} );
	        return JMXConnectorFactory.connect(url, environment);
		} catch (Exception e) {
			e.printStackTrace();
			errorString = e.getMessage();
			return null;
		}
	}

	public JMXConnector getConnector() {
		return connector;
	}
	
	public String getError() {
		return errorString;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (localButton.isSelected()) {
			connector = getLocalConnection(localEngines.get(typeList.getSelectedItem()));
		} else {
			try {
				int port = Integer.parseInt(portField.getText());
				String password = String.valueOf(passField.getPassword());
				connector = getRemoteConnection(hostField.getText(), port, userField.getText(), password);
			} catch (NumberFormatException nfe) {
				JOptionPane.showMessageDialog(JOptionPane.getRootFrame(), "Invalid port number",
		        	    "Connection error", JOptionPane.ERROR_MESSAGE);
				return;
			}
		}
		setVisible(false);
	}

	@Override
	public void keyPressed(KeyEvent e) {
		remoteButton.setSelected(true);
	}

	@Override
	public void keyReleased(KeyEvent e) {
		remoteButton.setSelected(true);
	}

	@Override
	public void keyTyped(KeyEvent e) {
		remoteButton.setSelected(true);
	}
}

These podcasts detail the life of the Carthaginian general Hannibal, often considered one of the greatest commanders of the ancient world. During the Second Punic War against the Roman Republic in the 3rd century BC, Hannibal led his army over the Alps into Italy. He then used superior strategy and tactics to defeat the Roman army at a number of engagements, resulting in the battle of Cannae - a devastating loss for Rome. After this, the Romans adopted many of Hannibal's techniques. At the Battle of Zama, Hannibal was defeated and Carthage lost the war.

The lectures were given by Patrick Hunt as part of the Stanford Continuing Studies Program sometime during 2007. I couldn't find a course website, but there are a few articles relating to the course. There are 8 lectures (strangely numbered 1 through 10), all of which are audio only and nearly two hours long (around 30MB in size). The first podcast is an interesting discussion on Carthaginian culture, in particular whether they really practiced child sacrifice. The second lecture introduces the First Punic War and Hannibal's father, Hamilcar Barca. The Second Punic War is covered over three lectures (along with an epilogue). The remaining three podcasts are dedicated to Hannibal's crossing of the Alps.

It seems Patrick Hunt organises regular expeditions to cross the Alps, trying to find archeological proof of where Hannibal crossed. Great attention is paid to how closely various mountain passes fit the ancient descriptions. Dr Hunt personally favours the Col de Clapier. If this historical event is of interest, then you will be well served. There is not one, not two, but three different first-person accounts of modern crossings of the Alps in attempts to follow Hannibal's footsteps: Hunt's; Ed Boenig, a student of Dr Hunt's; and John Hoyte's, who crossed the Col de Clapier in 1959 with an elephant (called Jumbo).

Apart from close concentration on a narrow historical time period, the series has many intriguing digressions. For instance, there is occasional mention of the meaning of Hannibal's name, "grace of Ba'al". Ba'al was the main Carthaginian deity, who supposedly lived on a mountain. Thus Dr Hunt suggests Hannibal would have had no fear of mountains. A bit of a stretch, but still interesting. If you have a particular interest in finding out about Hannibal's crossing of the Alps, then this is the podcast for you. However, there is still much to learn even if that is not your focus (and the second two alpine lectures can be safely skipped). On the downside, the first lecture (on the origins of Carthage) seems to be missing. Also, there is no sign of the lecture slides. Being able to see the maps and slides would have been particularly useful during discussions of which Alpine pass most closely matched ancient descriptions. Nevertheless, don't be put off by the long podcast length, this series is well worth a listen.

To display the buttons correctly a custom cell renderer needs to be applied to any columns displaying JButtons. This can be done with the code table.getColumn("Button1").setCellRenderer(new JTableButtonRenderer()) (this assumes that there is a column in the table labelled "Button1". The button renderer is below. The default renderer always returns a JLabel, but this one returns a JButton after colouring it in an appropriate manner. Note, this renderer assumes the contents of column will always be a JButton and will throw an exception if this is not the case. If the table column may not contain JButtons, just extend DefaultTableCellRenderer, detect if the value is a JButton (or even a Swing component) with instanceof, otherwise call super. This Sun article may help with this.

public class JTableButtonRenderer implements TableCellRenderer {		
  @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
    JButton button = (JButton)value;
    if (isSelected) {
      button.setForeground(table.getSelectionForeground());
      button.setBackground(table.getSelectionBackground());
    } else {
      button.setForeground(table.getForeground());
      button.setBackground(UIManager.getColor("Button.background"));
    }
    return button;	
  }
}

To get the table to pass clicks through to the button, add a mouse listener to the table with table.addMouseListener(new JTableButtonMouseListener(table)). This mouse listener (example below) will have to take the click, work out in which cell it occurred and if that cell contains a JButton, click it.

public class JTableButtonMouseListener extends MouseAdapter {
  private final JTable table;
		
  public JTableButtonMouseListener(JTable table) {
    this.table = table;
  }

  @Override public void mouseClicked(MouseEvent e) {
    int column = table.getColumnModel().getColumnIndexAtX(e.getX());
    int row    = e.getY()/table.getRowHeight(); 

    if (row < table.getRowCount() && row >= 0 && column < table.getColumnCount() && column >= 0) {
      Object value = table.getValueAt(row, column);
      if (value instanceof JButton) {
        ((JButton)value).doClick();
      }
    }
  }
}

And with that, the buttons in your table should start to work. All you need to do is return the buttons (which perform the required actions) when requested from your model, using getValueAt(). A complete working example is below.

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.UIManager;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellRenderer;

public class ButtonExample {

	public static void main(String[] args) {
		final ButtonExample example = new ButtonExample();
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
            	example.createAndShowGUI();
            }
        });
	}
	
	private void createAndShowGUI() {
        JFrame frame = new JFrame("Button Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JTable table = new JTable(new JTableModel()); 
        JScrollPane scrollPane = new JScrollPane(table);
		table.setFillsViewportHeight(true);	
		
		TableCellRenderer buttonRenderer = new JTableButtonRenderer();
		table.getColumn("Button1").setCellRenderer(buttonRenderer);
		table.getColumn("Button2").setCellRenderer(buttonRenderer);
		table.addMouseListener(new JTableButtonMouseListener(table));
        
        frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
        frame.getContentPane().setPreferredSize(new Dimension(500, 200));
        frame.pack();
        frame.setVisible(true);
	}
	
	public static class JTableModel extends AbstractTableModel {
		private static final long serialVersionUID = 1L;
		private static final String[] COLUMN_NAMES = new String[] {"Id", "Stuff", "Button1", "Button2"};
		private static final Class<?>[] COLUMN_TYPES = new Class<?>[] {Integer.class, String.class, JButton.class,  JButton.class};
		
		@Override public int getColumnCount() {
			return COLUMN_NAMES.length;
		}

		@Override public int getRowCount() {
			return 4;
		}
		
		@Override public String getColumnName(int columnIndex) {
	        return COLUMN_NAMES[columnIndex];
	    }
		
		@Override public Class<?> getColumnClass(int columnIndex) {
			return COLUMN_TYPES[columnIndex];
		}

		@Override public Object getValueAt(final int rowIndex, final int columnIndex) {
			switch (columnIndex) {
				case 0: return rowIndex;
				case 1: return "Text for "+rowIndex;
				case 2: // fall through
				case 3: final JButton button = new JButton(COLUMN_NAMES[columnIndex]);
						button.addActionListener(new ActionListener() {
							public void actionPerformed(ActionEvent arg0) {
								JOptionPane.showMessageDialog(JOptionPane.getFrameForComponent(button), 
										"Button clicked for row "+rowIndex);
							}
						});
						return button;
				default: return "Error";
			}
		}	
	}

	private static class JTableButtonRenderer implements TableCellRenderer {		
		@Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
			JButton button = (JButton)value;
			if (isSelected) {
				button.setForeground(table.getSelectionForeground());
				button.setBackground(table.getSelectionBackground());
		    } else {
		    	button.setForeground(table.getForeground());
		    	button.setBackground(UIManager.getColor("Button.background"));
		    }
			return button;	
		}
	}
	
	private static class JTableButtonMouseListener extends MouseAdapter {
		private final JTable table;
		
		public JTableButtonMouseListener(JTable table) {
			this.table = table;
		}

		public void mouseClicked(MouseEvent e) {
			int column = table.getColumnModel().getColumnIndexAtX(e.getX());
			int row    = e.getY()/table.getRowHeight(); 

			if (row < table.getRowCount() && row >= 0 && column < table.getColumnCount() && column >= 0) {
			    Object value = table.getValueAt(row, column);
			    if (value instanceof JButton) {
			    	((JButton)value).doClick();
			    }
			}
		}
	}
}

Professor Isabelle Pafford from The Ancient Mediterranean World podcasts returns for another series of Ancient History podcasts. This time a course on the Roman Republic given during Fall 2008 at Santa Clara University. There are 19 podcasts - 1 is a slide show video, but the others are audio only. Each podcast is around 50 minutes in length and around 50MB. In the audio podcasts there are often references to slides that are not available online.

The course starts with the stories of Rome's foundation along with details of the surrounding area and people, which presumably influenced early Rome. The Roman Kingdom is quickly passed over (perhaps due to a lack of information on the era) for the Roman Republic. Most attention is focussed on the Late Republic, with over half the lectures on the period from the Gracchi to Caesar - around 133BC to 49BC.

These lectures are full of engrossing details. There is a bit of historical timeline talk (on this date this happened and on that date that happened), but the series is more about the life and times of ancient Rome. For instance, there is often discussion of the Cursus Honorum (a series of military and administrative positions that provided a semi-formal structure to a political career) and how it affected the way people sought or achieved power. There was also a strong patron-client system, where a person's power could, in part, be measured by the number of clients/followers they had. Thus, manumission was common as freed slaves were typically clients of their previous owner. There is also some interesting consideration of which events are definitely known to have occurred, the fixed-points of history, and those parts of the primary sources that may be apocryphal.

Professor Pafford can be an engaging speaker, and it is clear this is an area she knows well. Indeed the extra colour provided as cracks began to appear in the republic had me hooked. It was a classic fight between two political parties, the Optimates and Populares - modern analogies are too easy to make. Although the ability to raise private armies and the tendency of losers to be executed adds an epic scale to proceedings. The final result may be well-known, with Caesar the unlikely Populares triumphing - but I still raced through the last half-dozen lectures.

It was a good thing I did know what happened in the end, as the end of the lecture series is missing (hint Caesar is assassinated and his nephew eventually dissolved the republic, becoming the first emperor, Augustus). I would guess that around a half-dozen of the lectures are unavailable, mainly around the mid-republic. At one point Professor Pafford apologises for losing some lectures in a hard-drive crash. So I suppose their absence is forgiveable. However, like the earlier Ancient Mediterranean podcasts, there are numerous other production issues. The audio quality is usually good, apart from a few notable exceptions. The video lecture is almost impossible to hear, and the slides are small relative to the screen. Another lecture on the First Triumvirate is split across two lectures because it sounds like the microphone failed (and the second part is very quiet). There is also quite a bit of course administrative talk (assignments, books, etc) - in one 40 minute lecture, 8 minutes are spent on such course administration topics. At least the class seem interested and ask some good questions. The lectures are also presented out of order on iTunes. It helps to know a bit of history to reorganise them from the titles.

Interesting history podcasts, again let down a little by production.

This is a recording of a University of California at Berkeley history course on the ancient Mediterranean given by Professor Isabelle Pafford during Fall 2007. There are 25 podcasts (each around one hour, and 15 MB) starting with a couple on Ancient Egypt and then passing through Ancient Greece, the Hellenistic Period, the Roman Republic before ending with the Roman Empire's collapse in the west around the 5th century AD. Most attention is paid to Greek and Roman history. A following course on Byzantine history is mentioned, but I couldn't find it online.

As should be expected for a series covering so much, the lectures often quickly pass over topics. Some parts of lectures were lists of important events. Despite this, there were more than enough digressions onto engaging side-topics to maintain interest (for instance, there was a passage on the nude in Greek sculpture and another on the formal political structure/progression in the Roman Republic). Thus the podcasts serve as a good introduction to the breadth of ancient Mediterranean civilisations and highlights areas you may want to explore further (after this I was looking forward to learning more on the mid and late Roman republic). I can't find much fault with the content of the course considering its scope.

I can find fault with the production standards, which overall are frustratingly poor. The sound quality is often annoyingly bad. For one lecture I had the volume turned up to max and pushed the earplugs deeper into my ears and I still could barely hear the lecturer, who sounded like she was mumbling next to a static noise generator. Course administration comments are sometimes made during a lecture - including asking unintentionally rhetorical questions to what seem to be largely apathetic students. Considering these are lecture recordings I can understand this, but usually the first few minutes of each lecture are taken up with course administration too (these could have easily been cut). Also, Professor Pafford regularly refers to visual aides that are no longer available online (the bspace website mentioned in the podcasts has been shutdown). Also the first two lectures are missing.

A good introduction to classical history, made slightly less pleasurable by poor production.

• Do a text comparison between generated code and the previously created known text output of the generation process. If they are exactly the same, the test passes. This tests the generation process if correct but doesn't test the logic of the generated code. If the generated code has syntactic errors, compilers or IDEs will pick this up quite fast and the developers in the other project will complain quickly, but subtle logic could go unchecked for ages.
• Write a test that generates a class file from known inputs then compiles it programmactically with the Java Compiler API then loads the class into the JVM and runs tests against it. This would be better than the previous idea, as it tests the functionality of the result. This was my first choice solution. However, getting the Java Compiler API to work can be a bit hard. There was a paucity of documentation on this and in the end I couldn't get it to work within time constraints.
• Generate the test at the same time as the generated code and pass them both to the other project. The other project would then test the generated code as if it was their code. This felt wrong to me. No other generations systems do this - it is like passing the buck. If there is an error in the generated code then the generator needs to be fixed not the generated class!
• A 2-step process - test the functionality and generation process separately. First, create a class that should be the same as a generated class given known inputs (probably by generating it!) and write tests that work against that class. Thus the problem of testing not yet existing code is solved by using some code generated earlier. This tests the generated code's functionality as long as the generating process doesn't change. So the second part is to test the generation process hasn't changed using the first test in this list. Add another test to generate the code and check that it is exactly the same text as the class the rest of the test is written against. If the generation output changes then you have to modify the pre-generated class, and thus change the functionality test if required. Easy.

This complete university course (from Fall 2007) on Ancient Greek History from Yale is the best history podcast I have found so far. It consists of 24 lectures of about an hour's length each, all given by Professor Donald Kagan. It starts with an introduction to Mycenaean Greece before moving onto the Greek Dark Ages and Homeric stories. The series ends with Philip of Macedon's victory at the Battle of Chaeronea and the Greek Polis' permanent loss of independence. Along the way it details all the major events including: the rise and strangeness of Sparta; the rise of Athens and democracy; Persian wars; and the slow decrease of power in the struggle for hegemony after the Peloponnesian War. Only the 27 years of the Peloponnesian War seem to be under represented in coverage (from my previous knowledge of history). Despite 4 lectures being dedicated to it in the syllabus, most of these are taken by finishing prior topics and the buildup to the war. For the war itself, Professor Kagan suggests looking to other sources as it it too much to cover properly, and instead talks in detail about two related topics - Pericles' strategy and Thucydides' history.

One thing I can't fault is the production. The podcasts are professional from start to finish. The only blemish is Professor Kagan's occasional coughing, but this is a minor issue. The podcasts are available in a number of formats on the course website: audio-only (the same mp3s that are on iTunes); video, in both high (around 700 MB) & medium (around 250 MB) bandwith forms; and, complete text transcripts. The website also includes the notes handed out with each lecture, although these unfortunately are without the original images due to copyright problems. The website itself is downloadable too (albeit with only links to the audio and video files). While videos of the lectures are available, it is not really necessary to download them as they mainly just show Kagan talking at his podium. Rarely does he use any visual aid during the lectures. Thus these are excellent podcasts to listen to audio-only - very little will be missed.

The lectures are often a recitation of events together with discussion of how and why things may have occurred that way (for instance a section on various military strategies and whether they were correct). The aim appears to be getting the listener into the mindset of the ancient Greek statesmen (and thus the citystates in general). A goal largely achieved to my mind. There is less discourse on daily life (but still some). Professor Kagan also talks a little about historical controversies and often compares ancient events to modern history (in particular around the use of military force). In both situations he tends to declare his own prejudices so the listener is not led too much.

This is a highly recommended lecture series - interesting content that goes into the subject with some depth and so well produced it is surprisingly easy listening.