I have slowly pieces together a solution from following sources:

• http://stackoverflow.com/questions/2624459/how-to-suppress-quotes-in-powershell-commands-to-executables/3999955#3999955
• http://docs.oracle.com/javase/1.5.0/docs/guide/deployment/deployment-guide/silent.html
• http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4966488

The final PowerShell script looks like this:

$installDir = 'C:\Program Files\JDK\' # Just an example, of course
$arguments = @(
'/s', "/v/qn`" INSTALLDIR=\`"$installDir\`" REBOOT=Supress IEXPLORER=0 MOZILLA=0 /L \`"install.log\`"`""
)
$proc = Start-Process "jdk.exe" -ArgumentList $arguments -Wait -PassThru
if($proc.ExitCode -ne 0) {
Throw "ERROR"
}

Note the double escape characters in the second argument, which basically contains all the non-switch parameters for the installer. The backslash in “\`"” escapes the double quote for JDK installer program, while the grave accent escapes it for PowerShell. Also note the space before INSTALLDIR=...: for some reason, if it is omitted, the installer will fail.

I have tested that script on both WinXP (32bit JDK) and Win7 (64bit JDK) machines and it works like a charm. It also works for JRE installers, which have similar problems with passing arguments. Oh, and a bit of advice if you install 64bit JDK and 32 bit JRE on the same system: do it in the JRE->JDK order, not the other way around.

UPDATE 21.03.12: Richard Neff suggested adding the info on setting the machine-level environment variable JAVA_HOME in the same script. It’s actually quite simple:

[environment]::SetEnvironmentVariable('JAVA_HOME', $installDir, 'machine')

Enjoy.

Basically, the answer depends on your browser:

• Internet Explorer (at least the v9.0.2 that I have) allows you to copy an HTML table with Ctrl-C and paste it directly into Excel with Ctrl-V. All data, including hyperlinks and images will be copied to Excel, which can become a problem if you only want text data.
• Mozilla Firefox (I have the v6.0.2) isn’t on speaking terms with the MS Office, so when you try to copy-paste HTML tables into Excel, you get it all crammed into a single cell. There is a trick, however: copy-paste the table from Firefox to Notepad. This will create a tab-separated “table”, which can be then copy-pasted to Excel (at least the Excel 2007 SP2). This will strip the data off hyperlinks, formatting, and images (replaced by alt-texts), however.

So there. Depending on whether you want to preserve the formatting or get rid of it, you should take one browser or the other.

What you will need:

• Images of the two original Japanese CDs of Ace Combat 3: Electrosphere. I will not tell you where to get them other than legally buying them from a collector or eBay.co.jp. Consider it the first test of your dedication to the series and this game in particular. You can’t proceed until you beat it.
• A PlayStation 1 emulator. I used ePSXe (1.7.0 for Win32) because, really, it’s the industry standard PSX emulator by now (too bad it’s not available in 64 bit).
• A PlayStation BIOS image. I used SCPH7502.bin, as recommended by the ePSXe crew. Again, I will not tell you where to download it, so google it.
• An ePSXe GPU plugin for your graphic card. They are all available from a certain Pete’s page; I used the “Pete’s OpenGL2 PSX GPU” because I have an ATI Radeon HD 3200 in my laptop. If you are not certain which plugin to get, refer to the ePSXe FAQ, the section titled “Choosing the best GPU plugin”.
• And just in case your ePSXe installation decides to be bitchy, get the zlib1.dll file from SourceForge.

If you want to play the game using a real controller rather than on your keyboard (which I recommend unless your keyboard is designed for such abuse), you will further need:

• A PlayStation-compatible USB game controller. I took a DualShock 3 from my PS3 because I am used to it.
• A Windows driver for DualShock controllers. Get the latest ZIP file appropriate for your operating system (32 or 64 bit) from the MotionInJoy homepage.

Now that you have all the stuff, break out your shaman tambourine and begin:

1. Unpack the contents of epsxe170.zip you just downloaded to somewhere. It can be C:\Program Files (x86)\epsxe170 but needs not be. I will henceforth refer to this root installation directory as “\epsxe170″.
2. Place your SCPH7502.bin into the \epsxe170\bios folder.
3. Open the ZIP archive you downloaded from Pete’s site and extract only the file gpuPeteOpenGL2.dll (or whatever the only DLL in your package is called) to the folder \epsxe170\plugins.
4. Open the ZIP archive you downloaded from SourceForge and extract only the file zlib1.dll to \epsxe170 (right next to ePSXe.exe).

The next steps are only relevant if you want to play with a controller.

5. Unpack the MotionInJoy ZIP and start the EXE inside to install it. I recommend to do so in admin mode, because, you know, drivers.
6. Once MotionInJoy application is installed and starts up (again, preferably in admin mode), go to the “Driver Manager” tab.
7. Connect your controller to a USB port and wait for it to appear between the blue bar with instructions in it and the buttons bar underneath it. It may take some time but not longer than 2-3 minutes.
8. Select the controller and press the “Load driver” button. Again, it may take some time, but wait until a success log appears underneath the buttons.
9. Windows may say it needs to restart at this point but ignore and cancel it.
10. Go back to the “Profile” tab. Your controller should now appear in the drop down menu under “Connected game controller(s):” and the red bar to the right of it should be blinking.
11. Select the “PlayStation 3″ radio button and click “Options” next to it.
12. For some reason, in my initial installation, two D-Pad buttons (up and down) were mapped to numbered “Directx input” keys (12 and 13) , while the other two weren’t. This led to me being later unable to map the controller keys to the “simulated” controller in ePSXe, so make sure all D-Pad buttons are mapped to numbered “Directx input” keys.
13. Also, while you are at it, you might want to set “Axis Rz” and “Axis Slider” inputs to “None” because you won’t need them anyway and it will be easier to map the controller’s other buttons that way.
14. Press the “Enable” button (highlighted because it’s so easy to forget) to activate the analogue controls (thumb sticks)
15. Optionally, press the “Game Controller Panel” button. It will open the standard Windows controller overview, where you can check whether your controller works (via “Properties” button).

OK, back to the general part:

16. Start \epsx170\ePSXe.exe. On first start, it should pop up a configuration wizard. Otherwise, select Config -> Wizard Guide in the top menu.
17. For BIOS, choose the only one you’ve downloaded.
18. For Video, ditto.
19. For Sound, the default plugin that comes bundled with ePSXe (ePSXe SPU Core 1.7.0) will do.
20. For CDROM, confirm whichever standard option is pre-selected.
21. For controller, confirm the default values if you want to play with the keyboard, otherwise, see next section. You can also access the controller configuration from main menu: Config -> Game Pad -> Port 1 -> Pad 1.

Again, the next part is for controller users only:

22. Select “[SCPH-1200] DualShock (F5)” in the top-right corner drop down menu.
23. In the “Rumble” box on the right, select: “DXJoy1″ for Type, “Sine” for both Big and Small Motor.
24. Inputting the key mappings in the central diagram was the tricky part, at least for me, because my controller seems to have been constantly sending the “Slider” signal to the PC because I didn’t hold it in a perfectly horizontal position. So, when I clicked onto an input field and pressed the corresponding button, it was instantly overridden by the continuous “Slider” signal. I have come up with this trick: click into an input field, press and hold the intended button, then click into the next input field with the mouse in your other hand. For the thumb sticks (red and blue lines on the diagram), I found that holding them all the way down in a certain direction would make the intended button code appear in the input field, after which I could click away. After inputting the final field, click OK.
25. Don’t look at me like that. If you want to use a controller, you should have at least this much finger dexterity. Anyway, here is a picture of what it should look like when done:
    

    My ePSXe controller settings.

This next part is relevant only if you have a wide screen or don’t like the original (notoriously low-res) video output of PS1 games to be stretched out, and only if you have an ATI graphic card like myself (though I am sure NVIDIA ones have something similar).

26. Go to Control Panel -> Display -> Display properties.
27. Reduce your resolution to 800 x 600.
28. Go to Advanced properties -> Catalyst Control Center -> ATI Catalyst Control Center.
29. Go to Graphics (top-left) -> Desktops & Display.
30. Click on the small triangle next to the small display symbol underneath to bring up a context menu. The large display above will not have the option you need. In the context menu, click “Configure…”
31. In the Attributes -> Scaling box select either “Maintain aspect ratio” (video will be upscaled) or “Centered” (video will remain in original resolution) radio button.

And back to the general part again:

32. In ePSXe, choose “File -> Run ISO” in the main menu, then select your Electrosphere CD1 image.
33. If it shows the “Analog Off” message in the top-right corner on start up, press F5 (repeatedly, if it doesn’t work the first time) until it changes to “Analog On” and disappears.
34. Once you see the red Namco logo appear on the screen, you’ve made it.

That is it. Now that you have reached this point, you have to beat all five endings of the game on Very Hard difficulty, simply to make the ridiculous amount of time and effort you invested into setting it up worth it.

Oh, and one last thing: on PS1, especially in Japanese games, the Circle button meant “Confirm” and the Cross meant “Cancel”. Have fun.

EDIT 2011-10-11: Just tested the guide above on my other PC with Windows XP x86. Essentially, it’s the same thing, though I couldn’t get MotionInJoy to work since it apparently only works with .NET 3.5 and I recently updated to 4.0. No matter, I found my old Saitek USB controller for PC and set it up. Worked like a charm. Also, I couldn’t bother to look for Aspect ratio settings in the Nvidia settings (have a GeForce on this machine), so I just found an option for this in my monitor hardware settings.

To begin with the basic definitions, the most universal formula of a story I know reads “A character wants something badly and is having trouble getting it.” This is effectively what 99% of stories boil down to: the same thing repeated over and over again throughout thousands of books, plays, movies, TV series, etc.. And it’s not even a very complex or exciting one. From an alien point of view, we humans must be so weird, getting a kick out of such dumb and repetitive entertainment.

But the devil is in the details. Who is this character? What is it that they want? What trouble are they having? More importantly, why is the character sympathetic? Why do they want that which they do so badly? Why are they having so much trouble? The questions “who/what/when/where” relate to the outer side of a story; the question “why” prods its inner workings. The inner story is a swarm of emotions and ideas your readers want you to transmit to them.  The outer story is the medium you use for this transmission. The readers want to see the inner story through the prism of immediate experiences of the outer one.

The writer’s ability to tell both outer and inner stories in the same work by answering only the four “outer” questions is the measure of their skill. It sounds easy but our language makes it tricky by offering constructs to tell inner stories directly, rather than  through their outer manifestations. Thank gods for that, too: our science and other analytical disciplines wouldn’t get anywhere, had we not invented these abstract terms and concepts. But when it comes to creative storytelling, telling an inner story instead of letting it show through the outer one is deadly. This is the “Show, Don’t Tell” principle.

Tropes are the bridge between outer and inner stories. They are always twofold: a trope always shows something and it always implies something. What it shows is a small bit of the outer story; what it implies is a piece of the inner story: an emotion or an idea, packaged as a hint or a promise. A great story plays its tropes in such way that they build up to a consistent, logical outer plot but simultaneously offer a myriad of clues, which the readers “get”, “don’t get”, or “get” differently.

If a “trope” only shows something without implying more, it’s not a trope. For instance, “Red Hair” is not a trope but a description of personal appearance. On the other hand, “Fiery Redhead” is, because it shows a character with red hair and implies that this character has a passionate personality. It doesn’t have to be true but the readers are invited to read between the actual lines. And the writer is invited to play with their expectations.

First off, when I started looking for such software, I faced the immediate problem: what search words are associated with it? “Software to play a MIDI controller”? Long story short, it took a few hours before I discovered that what I’ve been looking for is called “digital audio workstation“. Using Wikipedia to help me, I have discovered that only a few such tools are available for Windows and most of them are not free to use. In the end of the day, the only free Windows program that remained was Macaw.

So I stuck with Macaw and found that it was perfect for just playing stuff, though getting there was not trivial. The biggest problem I had was that it reacted too well when I didn’t press a key hard enough and played it very quietly.  Now, it’s probably great for experienced pianists who can fine tune the volume of their playing that way but a beginner like me, I want to hear the same sound when I press the key and I want to hear it loud. I wanted to be able to play in what I dubbed “noob mode”, where the software always played the keys in the same loud volume.

It took some tinkering, as I said, but here is what you have to do:

1. The first thing you’ll notice when you start up Macaw is that while it obviously recognizes keys being pressed on your keyboard (the MIDI input activity indicator square on the top-right turns yellow), it doesn’t play any sounds. This is because you first need to create at least one track.
2. To create a track, right-click under the “Master Track” label on the left and select “Track -> Insert Track”. Create one track.
3. Now you need to configure it. To open the track properties, simply click on the “1: Master” label. This part is not trivial, by the way. It took me several days to find.
4. Set “Name” to “Main” or whatever you want to call it.
5. Drag Volume (“Vol”) all the way up to 127. This will ensure a nice, loud sound later.
6. Drag Velocity adjustment (“Vel+”) all the way up to 127, t00. This is the essential part, since it basically forces Macaw to play each note as if the key was hit with full strength every time.
7. Set “Track Output -> Port” to whatever MIDI driver you prefer (I strongly recommend installing Timidity and a good SoundFont, see my earlier post). This will tell Macaw which sounds to actually play for you.
8. Optionally, you can also select a different instrument under “Track Output -> Program/Patch”. Tip: If you have SGM-V2.01, choose Overdriven Guitar and play some power chords!
9. In the end, your track config should look something like this:

   

10. Now click OK and try playing something on your keyboard.

If you hear those sounds, this how-to was a success. Now go and have fun.

Essentially, what you need is the cmdlet Get-Process. Normally, it returns the object representing a process identified by the PID you pass to it, but thanks to its ability to check for processes on remote computers and the fact that it sets the return code to True if a process corresponding to the PID is found and to False otherwise, it can be abused for our purpose. In fact, following code should do the trick:

do {
  Get-Process -id $PID -computername $remoteComputerName
} while ($?)

Where “$PID” contains the numeric ID of the process on the remote computer and “$?” is the boolean PS command return code. The do-while loop checks the return value of Get-Process inside it and exits once it turns to False (meaning that the remote process can no longer be found, i.e. it terminated).

However, you will soon notice that the Get-Process throws exceptions and prints totally unnecessary output once the process is not found. To avoid that, you need to suppress the exceptions and reroute the output into Out-Null by adding following to the cmdlet call:

-ea SilentlyContinue | Out-Null

Full code in a single line (remove the linebreak):

do { Get-Process -id $PID -computername $remoteComputerName 
-ea SilentlyContinue | Out-Null } while ($?)

Alternatively, you can just wrap the whole thing in a subroutine. Enjoy.

Long story short, the default sound synthesizers on Windows 7 (and probably earlier versions) suck. The only instrument that sound more or less natural is a piano, whereas the guitars, much less distorted or overdriven ones, sound awful. Those who don’t have to work with MIDIs often may be fine with just that, but if you would like to compose music on your PC, you definitely need a decent SoundFont.

As usual, there exists a perfectly legal and cost-free solution, but you’ll have to put in some effort. What you’ll need:

• An actual SoundFont with good sounds. I recommend SGM-V2.01 (download here) because it’s free and of very high quality.
• The TiMidity++ driver for Windows, or better yet, its installer (here, ignore the moonspeak, it’s still in English).
• DOSBox (only on Windows 7 and Vista), unless you already have it.

What you do:

1. Install TiMidity. It’s pretty straightforward, you can do it. EDIT: The only thing important to remember is to launch the installer with admin privileges, otherwise the driver won’t get installed properly.
2. Unpack the SGM archive. Actually, we only need one file: “SGM-V2.01.sf2″.
3. Move the “SGM-V2.01.sf2″ to “C:\Program Files (x86)\timidity\musix” (or wherever you have installed TiMidity).
4. Edit the configuration file. Actually, TiMidity keeps two config files, but you can edit both, just to be sure (note that both are write-protected by default): “C:\Windows\timidity.cfg” and “C:\Program Files (x86)\timidity\musix\timidity.cfg”. The files should contain following lines:

   dir "C:\Program Files (x86)\timidity\Musix"
   
   soundfont "SGM-V2.01.sf2" amp=200%

   If you want to know what that means, the driver installation also contain the documentation, go read it.

5. Reboot your PC.
6. If you are using XP or earlier Windows, simply go to “Control Panel -> Sounds and Audio Devices -> Audio” and select TiMidity++ from the drop down menu under “MIDI music playback”. That’s it, you are done.
7. Under Win7, you’ll have to install the DOSBox. In it, type “mixer /listmidi” to get he list of available MIDI drivers. It must output something along the lines of:

    0       "Microsoft GS Wavetable Synth"
    1       "Timidity++ Driver"

   Note the index corresponding to TiMidity.

8. Open regedit and look for the key “HKEY_CURRENT_USER\Software\Microsoft\ActiveMovie\devenum\{4EFE2452-168A-11D1-BC76-00C04FB9453B}\Default MidiOut Device”. There, edit the value of “MidiOutId” (default: 0xffffffff) and type in the index of TiMidity from step 7.
9. Reboot your PC. It must be working now.

UPDATE 08.08.2011: Alkel U3 pointed me towards a small utility called Vista Midi Picker that allows you to skip steps 7 through 9 on Win7/Vista. Haven’t tried it out yet, but it may be helpful.

To test your installation, try playing a MIDI that contains instruments other than piano (like guitars). Have fun.

The idea I had was to write an algorithm that created a unique GUIDs out of a string (or two strings: module/product name and version number). This way I could ensure that the package whose version has not changed will always have the same product GUID, regardless how many times it is rebuilt. The only difficult part was to find a way to make the implementation of said algorithm as simple and stupid as possible.

As I set off, I discovered that Java (my primary programming language at the moment) already has a nifty UUID class. However, it could only create random UUIDs (the universal term describing what Microsoft calls “GUID”) with the static randomUUID() method. Now, there was also nameUUIDFromBytes(), which made the algorithm pathetically easy:

String tempResult =
  UUID.nameUUIDFromBytes(aSourceString.getBytes()).toString();
System.out.println(tempResult);

However, the problem with that is that it generates Version 3 UUIDs (read more about versions on the Wikipedia) and WiX only accepts Version 4 (like the ones generated by randomUUID(), which are, well, too random). Then I took a look at the standard constructors and saw that there’s only one and it generates a Version 4 GUID out of two Long numbers (basically, a GUID consists of two 64 bit arrays, read two Long numbers: least significant long and most significant long). Yay! Now, where can I get an injective function that would map a string to a particular Long number?

Immediately, I thought of the MD5 hashes but a bit of googling revealed that there is no single pretty string-to-MD5 hashing function in the standard Java libraries. Unwilling to make my own implementation (simple-stupid, remember), however, I soon found the next best thing: the CRC32 class. Now, the beauty of this solution lies in the fact that it’s a standard library class and it’s relatively easy to use:

private CRC32 localCRC32Generator = new CRC32();

public String generateGUID(String anApplication, String aVersion) {
  localCRC32Generator.update(anApplication.getBytes());
  Long tempApplicationChecksum = localCRC32Generator.getValue();
  localCRC32Generator.update(aVersion.getBytes());
  Long tempVersionChecksum = localCRC32Generator.getValue();
  localCRC32Generator.reset();

Basically, you initialize the CRC32 instance, update it with a byte array generated from the source string, read the Long value, then reset the instance. The last part is essential if you want to generate identical Longs during the entire runtime.

The rest seemed easy at first:

    return UUID(tempApplicationChecksum, tempVersionChecksum).toString();

However, I immediately noticed that the resulting UUIDs had a lot of nulls in them. This is because the return values of CRC32.getValue() are 10 digits long and the 64 bit Long is 20 digits. Hence, half of the numbers (higher registers) are padded with nulls in the UUID. So I thought, how to produce two 20 digit Longs out of two 10 digit Longs. The answer is trivial if you know some math:

  Long tempMSBits = tempApplicationChecksum * tempVersionChecksum;
  Long tempLSBits = tempVersionChecksum * tempVersionChecksum;
  return UUID(tempMSBits, tempLSBits).toString();

I chose to use tempVersionChecksum as the multiplier in both cases, because it is what actually changes across versions, whereas the tempApplicationChecksum is just there to avoid collisions between product GUIDs of different product packages with the same version. Apropos collisions: I decided that CRC32 has good enough collision resistance for my purposes and the products of the results are distinct enough on such scale.

However, even after that, I was again frustrated by failure. This time, the WiX compiler again claimed that the GUID is invalid. I consulted the Wikipedia again and remembered that the Version 4 GUIDs had several reserved bits, which, of course, are not present in the UUIDs generated by my algorithm thus far. However, that was a minor problem: all I had to do was to wrap the GUID string I got into a StringBuffer, replace the 15th character with a “4″ and the 20th, with an “8″, “9″, “A”, or “B”. Actually, it doesn’t matter which of the four characters is in the 20th position, it can even be always the same, but I wrote a small subroutine for additional collision resistance. In the end my class looked like this:

import java.util.UUID;
import java.util.zip.CRC32;

public class VersionToGuidConverter {

  private CRC32 localCRC32Generator = new CRC32();

  public static void main(String[] args) {
    VersionToGuidConverter tempConverter = new VersionToGuidConverter();
    System.out.println(tempConverter.generateGUID(args[0], args[1]));
  }

  public String generateGUID(String anApplication, String aVersion) {
    localCRC32Generator.update(anApplication.getBytes());
    Long tempApplicationChecksum = localCRC32Generator.getValue();
    localCRC32Generator.update(aVersion.getBytes());
    Long tempVersionChecksum = localCRC32Generator.getValue();
    localCRC32Generator.reset();

    Long tempMSBits = tempApplicationChecksum * tempVersionChecksum;
    Long tempLSBits = tempVersionChecksum * tempVersionChecksum;

    StringBuffer tempUUID =
      new StringBuffer(new UUID(tempMSBits, tempLSBits).toString());
    tempUUID.replace(14, 15, "4");
    tempUUID.replace(19, 20,
      convertSecondReservedCharacter(tempUUID.substring(19, 20)));

    return tempUUID.toString();
  }

  private String convertSecondReservedCharacter(String aString) {
    switch (aString.charAt(0) % 4) {
      case 0: return "8";
      case 1: return "9";
      case 2: return "a";
      case 3: return "b";
      default: return aString;
    }
  }
}

For a cherry tapping, you can add a feature that generates truly random UUIDs (with UUID.randomUUID()) if the Version or Product have a specific value. But that should be easy. Now go and have fun.

Tinkered with the design a little, but I seem to like the default one best. The header image is courtesy of Dru! from Flickr, who has been kind enough to publish that awesome picture under the CC-BY-NC licence. Also, the term “blag” is an XKCD reference.

That’s all for now, let’s see how far I get with this.