Ok, so this is funny. A few days ago I blogged about trying in vain to find software that would automatically back up my important files, ignore the ones that havem't changed, and send them to an FTP server. And so I just find out that WinZip 10 Pro will do that, and compress your files, too. And it's $50. Hmmm...

Some teaser screenshots:

Maybe I'll be checking out WinZip after all, and have it just watch my project directories, zip everything up, and upload it to a cheap web host.

Since I've started using an offsite backup service, I've been feeling better about my disaster recovery ability. However, I wanted to ensure that my files stayed small so that a) they would transfer faster to the offsite backup, and b) so they'd take up less space, which saves me money on storage.

So here's an updated SQL Command Line Backup script (see my previous post for details and the SQL script I used):

@echo off 
REM get today's date and time as one big string
for /f "tokens=2-4 delims=/ " %%i in ( 'date /t') do set theday=%%k%%i%%j
for /f "tokens=1-2 delims=: " %%i in ( 'time /t') do set thetime=%%i%%j
set now=%theday%%thetime%

REM create backup files
C:
cd "\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\Binn"
sqlcmd -S localhost -U sa -P somepassword -i c:\sqlbackup\backup.sql -o c:\sqlbackup\log.txt

REM compress backup files
gzip -f C:\sqlbackup\*.bak

REM copy backup files to backup device
xcopy "C:\sqlbackup\*.*" \\10.1.10.50\ben_backup\sqlbackup\%now%\ /E /H /R 

The main difference is I'm now using a command line compression utility called gzip to compress the database backups (down to 10-13% of their original size). Gzip is open source, fast, and small. Obviously, you could use other utilities like WinZip's command line utility, or even Windows Services for Unix (with its ironic 230+mb download). But I figured free was good enough for me. You can download a Win32 version of gzip here.

FYI, the 10.1.10.50\ben_backup\ folder is on a local file server with RAID1, so it's relatively stable. But I now also have Mozy watching that folder, too, so everything that gets dumped there gets backed up over the internet.

Hopefully the above has given you some ideas on how to protect your code. By make regular database & source code repository dumps, and backing them up, you'll be in a better position to recover if your computer goes down, or worse.

Just ran across a tool to more easily read log4net files. There's a free single-user version apparently.

log4net Dashboard / Viewer

So you have an ASP.NET application and want to do some custom logging other than by using Response.AppendToLog(). Or maybe you have a console app that you want to log what it's doing. Good! Let's get you set up using log4net (a very popular logging library) in a few minutes so you can start keeping track of things. Much of this is based on Haacked's Quick and Dirty Guide to log4net, which is based on VS2003 but still a good read. I also got some tips for Visual Studio 2005 from Akash's blog. Now let's get started.

Download log4net

Download and extract the latest stable release of log4net here.

Add a reference

In your Visual Studio project, add a reference (Project->Add Reference) to log4net.dll (in the bin\net\<dotnet version>\release directory where you extracted the log4net zip file).

Add a log4net config file

Even though you can add log4net configuration settings to your app's main .config file, we're going to give log4net it's own config file for two reasons: 1) cleanliness, and 2) you can log4net change the config settings on the fly without having to restart the app. :)

So, create a new .config file in the root directory of your application ad name it log4net.config. If you're building a client app, set the "Copy to Output Directory" property to "Copy Always". Remove everything in the log4net.config file, and paste the below XML into it.  It contains sample configurations to log many types of events (info, warning, error, fatal) to a rolling set of log files in a "log4net" subdirectory in your application's root directory. It will also send emails for any error or fatal events. You'll at least want to change the Smtp settings to a valid host & email account.

<?xml version="1.0"?>
<log4net>
    <appender name="SmtpAppender" type="log4net.Appender.SmtpAppender">
        <to value="support@yourcompany.com" />
        <from value="support@yourcompany.com" />
        <subject value="ERROR on site" />
        <smtpHost value="your.smtp.host" />
        <bufferSize value="256" />
        <lossy value="true" />
        <evaluator type="log4net.spi.LevelEvaluator">
            <threshold value="ERROR" />
        </evaluator>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%-5p %d [ThreadId: %t] Class:%c{1} Method:%M %nMESSAGE:%n%m%n%n" />
        </layout>
    </appender>
    <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
        <file value="log4net\\logfile.txt" />
        <appendToFile value="true" />
        <datePattern value="yyyyMMdd" />
        <rollingStyle value="Date" />
        <filter type="log4net.Filter.LevelRangeFilter">
            <acceptOnMatch value="true" />
            <levelMin value="INFO" />
            <levelMax value="FATAL" />
        </filter>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%-5p %d %5rms %-22.22c{1} %-18.18M - %m%n" />
        </layout>
    </appender>
    <root>
        <level value="DEBUG" />
        <appender-ref ref="SmtpAppender" />
        <appender-ref ref="RollingLogFileAppender" />
    </root>
</log4net>

Initialize the configuration

If you're using a web application, add the following line to your Application_Start method in global.asax.

log4net.Config.XmlConfigurator.ConfigureAndWatch(new System.IO.FileInfo(Server.MapPath("log4net.config")));

If you're using a client application (e.g. a console app), add the following line to your app's initialization routine:

log4net.Config.XmlConfigurator.ConfigureAndWatch(new System.IO.FileInfo("log4net.config"));

These lines tell log4net to load configuration information from the local log4net.config file and watch it for any configuration changes while the app is running.

Start logging

Now wherever you want to log some information in a particular class, add a member variable like this

private log4net.ILog logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

This creates a logger variable, and causes log messages to be prefixed with the class name containing the logger variable. That makes it easier to sift through logs, since you'll be able to see which messages came from which classes.

Then when you want to do some logging you can just use statements like this

logger.Info("some info");
logger.Warn("a stern warning!")
logger.Error("An error occurred!");

Reading the logs

The sample config (above) creates a log file named logfile.txt in a log4net subdirectory inside your application's root directory. Note that for client applications, that'll be your bin/debug or bin/release folders (or wherever the EXE lives). Since we used a RollingLogAppender, older logs will be archived with the date apprended to the file name. That means that "logfile.txt" only contains messages for the current day.

Deploying your app

When you deploy your application, make sure to deploy the log4net.dll, log4net.xml, and log4net.config files. Also make sure that your application's account (e.g. the ASPNET account for web apps, or the user for client apps) can create and write to the "log4net" subdirectory. For web applications you may want to go ahead and create the "log4net" subdirectory up front and assign ASPNET full control rights to that.

Tweaking the configuration

You can tweak the settings in your log4net.config at any time, even while the app is running. You may wish to change the location of the log file, or add different appenders, or change what type of messages get logged. I suggest reading the log4net documentation for more information.

In order to work on the largest user base possible (who often are behind routers and firewalls), Skype will listen on port 80 and prevent IIS (and other services) from using it. That may cause some minutes of frustration as your IIS stops working, Visual Studio won't bind to the local web server, and you repeatedly click "Start" in IIS Manager to no effect.

To put Skype in its place and make it stay away from port 80 for good, open up Skype and go to Tools->Options, General, click "Set connection parameters and proxies", and uncheck "Use port 80 & 443 as alternatives for incoming connections." Then restart Skype. That should allow IIS to use port 80 as it needs to.

However, if Skype then stops working for you, you may need to open up a port in your router. You'll find the port that Skype's using on the same options page where you unchecked "use port 80...".

Google recently released an API for Google Calendar. Even though the Google Calendar UI is already pretty slick, developers can now write applications to extend the functionality further. C# and Java versions of the API are available.

For example, you can query your upcoming events in C# like so:

1. First download & install the libraries. You may need to build them first.
2. Make a new project and reference GData.dll, GDataExtensions.dll, and CalendarService.dll
3. Use code kinda like the below :)

using System;
using System.IO;
using System.Xml;
using System.Net;
using Google.GData.Client;
using Google.GData.Extensions;
using Google.GData.Calendar;

namespace ConsoleApplication1
{
    class Class1
    {
        [STAThread]
        static void Main(string[] args)
        {
            string calendarURL = "http://www.google.com/calendar/feeds/default/private/full";
            string appName = "MyCompany-MyApp-v1.0";
            string userName = "you@someisp.com";    // google calendar login
            string password = "somepassword"; // google calendar password

            // create a query object
            // get 10 entries that start between now & the next 10 days
            EventQuery query = new EventQuery();
            query.Uri = new Uri(calendarURL);
            query.NumberToRetrieve = 10;
            query.StartTime = System.DateTime.Now;
            query.EndTime = System.DateTime.Today.AddDays(10);

            // connect to the calendar service
            CalendarService service = new CalendarService(appName);
            service.setUserCredentials(userName, password);

            // execute the query & get the results back
            EventFeed calFeed = service.Query(query);

            // iterate through the results
            foreach (EventEntry feedEntry in calFeed.Entries)
            {
                string eventStartDesc = "n/a";
                string eventWhereDesc = "n/a";
                
                if (feedEntry.Times.Count > 0)
                {
                    When eventStart = feedEntry.Times[0];
                    if (eventStart.AllDay)
                        eventStartDesc = "All day";
                    else if (eventStart.StartTime.Date == System.DateTime.Today.Date)
                        eventStartDesc = "Today at " + eventStart.StartTime.ToShortTimeString();
                    else
                        eventStartDesc = eventStart.StartTime.ToString();
                }

                if (feedEntry.Locations.Count > 0)
                {
                    Where where = feedEntry.Locations[0];
                    if (where.ValueString != null || where.Label != null)
                        eventWhereDesc = where.Rel + " " + where.Label + " " + where.ValueString;
                }

                Console.WriteLine("Event:");
                Console.WriteLine("\tTitle: " + feedEntry.Title.Text);
                Console.WriteLine("\tWhen: " + eventStartDesc);
                Console.WriteLine("\tWhere: " + eventWhereDesc);

            }
        }
    }
}

As you can see, it's pretty easy. Note that you should change the username & password information at the top, and make sure you have some upcoming events in your calendar.

You can also download a sample .NET 1.1 project here.

Saw this SQL Login Killer Script on SQL Server Central (yes I know it's old, but it's still good) ...

Handy when you need to kill everyone off in order to perform a restore. I even use it on my dev workstation, since IIS, ColdFusion, & a million other things like to hang on.

Although, I wonder if SQL Server 2005 has an easier way to boot everyone off. Hmm.

So I spent several hours last week doing some research on remote backups. Even though I have a file server here for local backups, something could always happen -- fire, flood, crazy electrical storm, theft, etc -- that could cause me to lose files or data from every machine in the building.

What I wanted was something simple: make it automatically back up certain files and folders on my computer, start up when Windows starts, run in the background (when idle or on a schedule), and back up changed files only. I did not want to manually click some "Backup" button all the day -- I needed "set & forget" behavior. And I was even willing to pay!

I started by reading reviews of storage providers on PC World and TechCrunch. After some more research, I signed up for a small GoDaddy Online File Folder since that got some kudos. Verdict: bleh! Would have been nice to learn about it before shelling out my $10, but oh well. Their web interface is slow. The backup software can only automatically back up one folder on your PC. One? If you want to back up multiple folders, you instead have to find a third party app and over it over FTP or WebDAV. WebDAV is slow, and their FTP service was giving me weird errors. I spent a few hours trying out third party software and eventually gave up.

I then looked at Box.net, a Web 2.0 darling. However, it didn't have any backup software -- I'd have to log into their site & drag files onto it every time I wanted to back something up. Forget that, guys. I started seeing a trend with other online storage services, too -- it was like they didn't really focus on backing up files, and instead made cool-looking web sites that made it easy to share your MP3 collection with your friends. Like we don't know how file sharing companies eventually turn out. Granted, I can see how sharing might fit in, since people will want to back up their photos, and why not share them with friends and let them print copies etc. But anyhow.

Finally I tried out Mozy, which thankfully fit the bill. Easy to install, 2gb storage for free, with a little app that rests on your computer and automatically backs up what you want when you want. They even encrypt your files before uploading, which is neat. You can upgrade to 30gb of storage for about $5/month. Two additional things I'd like to see out of Mozy, though: 1) offer a business-grade plan for 100+gb storage; and 2) compress the files (or at least compressible ones like BMP/TXT/.CS) before uploading so we can store more stuff and use less bandwidth.

So for now I'm trying out Mozy...we'll see how that goes. If anyone knows of third-party software that does automatic, differential backups over FTP, please let me know! I was tempted to write my own, but you know how that goes. 

I recently needed to parse a tab-delimited file and I figured it would be easier if I could manipulate it in DataSet form. I came across Dave O's article on The Code Project which was close, but not quite what I needed. First, I wanted to read the files a line at a time, because some of them are pretty big. Granted, the DataSet will be in-memory the whole time, but I didn't want to allocate all that ram twice -- once for the initial parsing and then again for the DataSet. Second, I needed some extra massaging on the data (e.g. the values are encapsulated in quotes).

So, here's my updated code, which I'll upload to the Code Project one of these days.

using System;
using System.Data;
using System.IO;

namespace AssessmentDownload
{
    class TextToDataSet
    {
        public static DataSet Convert(string fileName,
         string tableName, string delimiter)
        {

            //The DataSet to Return
            DataSet result = new DataSet();

            //Open the file in a stream reader
            StreamReader s = new StreamReader(fileName);

            //Split the first line into the columns       
            string[] columns = s.ReadLine().Split(delimiter.ToCharArray());

            //Add the new DataTable to the RecordSet
            result.Tables.Add(tableName);

            // Cycle the colums, adding those that don't exist yet 
            // and sequencing the one that do.
            for(int columnIndex = 0; columnIndex < columns.Length; columnIndex++)
            {
                string col = columns[columnIndex];
                bool added = false;
                string next = "";
                int i = 0;  // used in case there are duplicate column names
                while (!added)
                {
                    //Build the column name and remove any unwanted characters.
                    string columnname = col + next;
                    columnname = columnname.Replace("#", "");
                    columnname = columnname.Replace("'", "");
                    columnname = columnname.Replace("&", "");
                    columnname = columnname.Trim('\"');

                    //See if the column already exists
                    if (!result.Tables[tableName].Columns.Contains(columnname))
                    {
                        //if it doesn't then we add it here and mark it as added
                        result.Tables[tableName].Columns.Add(columnname);
                        added = true;
                    }
                    else
                    {
                        // if it did exist then we increment the sequencer and try again
                        // with a modified column name (e.g. MyColumn_2)
                        i++;
                        next = "_" + i.ToString();
                    }
                }

                // now update the column array with the newly cleaned column name
                columns[columnIndex] = col;
            }

            // read file a line at a time
            string row;
            while ((row = s.ReadLine()) != null)
            {

                //Split the row at the delimiter.
                string[] items = row.Split(delimiter.ToCharArray());

                // clean up the data a bit (mostly removing surrounding quotes)
                for (int i = 0; i < items.Length; i++)
                {
                    string item = items[i];
                    if (item.StartsWith("'") && item.EndsWith("'"))
                        item = item.Trim('\'');
                    if (item.StartsWith("\"") && item.EndsWith("\""))
                        item = item.Trim('\"');
                    items[i] = item;
                }

                //Add the item
                result.Tables[tableName].Rows.Add(items);
            }


            //Return the imported data.        
            return result;
        }
    }
}

Screencasting is the act of making a movie of what's on your computer screen and making available electronically (usually via the intra- or Internet). Making screencasts can help in a number of ways:

• You could record demos of software you own for sales & marketing purposes
• You could record demos of other software for review purposes
• You could record demos of software or processes for training & support purposes
• You could record demos of your all-time high frag score on UT2004 for bragging (or getting fired) purposes

Two free tools I've used are Wink and CamStudio. Both will let you record a screencast with audio, add some textboxes & arrows, and output a compressed SWF and HTML file for easy uploading to your web site.

Wink used to be missing audio and other feaures, but they just came out with version 2.0 that includes audio recording, the ability to plop textboxes & objects on your video, and other improvements. It's easy to use and includes some tutorials on how to make your own screencasts. Wink works by recording a series of screenshots and tying them together as keyframes on a Flash movie. The upside of that is that images are clearer and filesizes are smaller, but Wink can't record animation or other nuances. Wink create an EXE from your screencast (good for CDROMS or those small cdrom business cards), uncompressed SWFs (for importing into Flash), and compressed SWFs for sticking on a web site. 

Click here for a sample screencast made with Wink.

CamStudio is based on an open source release from RenderSoft (you can read the whole history on the CamStudio site). While both programs are easy to use, CamStudio is really easy to use because it's simpler -- optionally set a few settings (usually just Region->Region and the SWF/AVI toggle), just click a Record button to record, then click Stop to finish recording. CamStudio actually captures video and compresses it to AVI or Flash, so it'll capture all the animation you need. The downside is that since it's video, you'll notice some grainy compression artifacts, and filesizes are much bigger (the CamStudio sample screencast I made was 4.9mb vs 1.2mb for Wink). Wink seems to have more features then CamStudio, although only CamStudio can convert your movie to an AVI file -- handy if you want to upload your screencast to YouTube or burn a DVD for Uncle Joe to watch on his TV. CamStudio can generate AVIs using a number of codecs (DivX, WM9, etc) if they're installed on your computer.  

Click here for a screencast made with CamStudio.

I suggest checking out both tools. Each will work for most screencasts, although you may prefer one over the other for different things.

I avoided debugging javascript for a long time because 1) I didn't write a lot of it, and 2) it used to be a pain to do so with Visual Studio. Nowadays it's pretty easy, though, if you know how to do it.

You'll notice that if you open up your ASPX page in Visual Studio and try to set a breakpoint in javascript, you'll usually get a "This is not a valid location for a breakpoint" error. What you need to do is open up the client-side version of the page in Visual Studio and debug that. Here's how:

• Open Internet Explorer, go to Tools->Internet Options, click the Advanced Tab, and ensure that "Disable script debugging" is unchecked.
• Fire up your web project in Visual Studio and debug it using Debug->Start Debugging (or F5). IE will open up and display your web site.
• In IE, navigate to the page whose javascript you want to debug
• In IE, click the View->Script Debugger->Open menu item. That will open up the current page's html and javascript in Visual Studio.
• Switch back to Visual Studio. You'll see the page's html and javascript. You can now set breakpoints, etc.
• Now you can switch back to IE and do whatever you want in the page. Any breakpoints that you set in the previous step will be hit, and you can inspect variables, etc. just like in normal code-behind debugging.

If the above annoys you, another javascript-debugging option is to instead use Firefox and Firebug, which I posted about briefly a few months back. Firebug is a powerful plugin that not only lets you debug javascript, but explore the DOM and watch AJAX requests. You can download it here.

Both approaches (Visual Studio and FireBug) have their merits. I suggest trying them both out to see which works for you.

Fresh Installs With Fresh Hardware

Say you just bought a new motherboard, SCSI drive, or RAID card and you want to install a fresh copy of Windows onto it. If the standard Windows OS install contains drivers for it, then you can just boot from the install CD and start installing. Otherwise, you'll need to install the drivers after the install is complete, or during the install.

Installing drivers after you're done installing Windows isn't that bad if you have them on CD and you don't need them during the install. But if you're installing Windows onto a RAID array or a SCSI drive, for example, you'll need those drivers during the install, not after, because you won't be able to complete the installation without them. In my case, I just bought a new RAID card from NewEgg (this one). My plan was to make a RAID 1 (Mirrored) array for redundancy and install a clean copy of Windows onto it. But to do that, I needed the drivers to be available during the install.

Installing Drivers During an Install -- the F6 Floppy Solution

To install the drivers during a Windows install, you need to watch for the message "Press F6 to add a third party SCSI or RAID driver". The message may not be exactly like that depending on which version of Windows you're installing, but it definitely starts with "Press F6." It appears at the bottom of the screen almost right away in the install (while the screen is still blue and in text mode), and you only get a second or two to hit F6 before the opportunity is lost, forcing you to reboot and try again. The F6 method also requires you to have the drivers on a floppy, assuming the drivers will even fit on a floppy, and assuming you even have a floppy drive anymore. A USB Floppy Drive won't always work -- you really need a good ol' fashioned floppy "A:" drive. Blech.

Slipstreaming Your Windows Install CD -- a Cleaner Way

But assume you don't want to go the floppy drive route. You can instead make a "slipstream" version of your Windows install CD, which is basically a copy of the install CD that includes any extra drivers you need (RAID cards, network cards, etc). No floppy drive needed, no pressing F6, no driverless hardware after install, etc. A slipstream CD can also contain hotfixes and service packs, or even be an "unattended" version with all the install questions answered ahead of time. Note that a slipstream CD is not an illegal copy -- you must own a legal version of Windows. For those of you with MSDN subscriptions, your developer disks will work as well.

Slipstreaming used to be a PITA, but nowadays the process is easier thanks to NLite, a free utility that handles most of the dirty work. This quick & dirty guide assumes you know what driver files (.INF) are and have installed drivers and hardware before. It also assumes you know which drivers are the right ones for your hardware and OS.

Using NLite to Make the Slipstream

Anyhow, to make a slimstream CD:

1. Get your Windows OS Install CD and copy all the files into a folder on your hard drive called c:\windowsinstall or somesuch. If you have an ISO image of the install CD (as you might if you had downloaded the ISO from MSDN), you can instead use a tool like IsoBuster to copy the files from the ISO to c:\windowsinstall. Otherwise you'd have to burn the ISO to a CD and then rip the files. Moving on....
2. Download and install NLite. You'll need .NET 2.0 in order to run it.
3. Get the drivers, hotfixes, and service packs you want and save them somewhere on your hard drive. If the drivers are in an EXE (for example, platform drivers for NForce motherboards) you'll need to get them out of the EXE via winzip, or maybe by running the driver EXE and hitting Cancel after the drivers have been extracted but before they've been installed (this works for nforce drivers). Remember that the drivers are where the INF files are.
4. Run NLite.
5. Navigate to the folder containing the files from your install cd (e.g. c:\windowsinstall). NLite will scan the files and try to guess what the OS is. If it's correct, click Next.
6. You'll see a screen listing any previous NLite sessions. If you used it before it'll ask you if you want to load a previous session. In this case we're starting from scratch so click Next.
7. Now you'll see some toggle buttons where you click on all the things you want to do with your new slipstream CD. I wish NLite had them as checkboxes instead of buttons, but anyhow. If you want to learn about the options, you can read the full NLite guide. In this case we're just integrating some drivers, so click Integrate Drivers and Create a Bootable ISO (so they highlight) and click Next.
8. You'll see the Integrate Drivers screen. At the bottom, click Install. You'll see two options: Single Driver and Multiple Driver Folder.
9. Single Driver
   1. If you have one driver in a folder (which is often the case with RAID drivers), choose Single Driver and navigate to the folder, click the appropriate INF file, and click Open.
   2. NLite will auto suggest a mode (PlugNPlay or Textmode) and show the driver(s) below.
   3. Click the appropriate one and click OK. You'll see it added to the list of driver.
10. Multiple Driver Folder
    1. If you have a bunch of drivers in a single folder (e.g. NForce drivers in C:\NVIDIA\nForceWin2KXP\5.11), click Multiple driver folder.
    2. Navigate to the folder containing all the drivers and click OK. NLite will recurse through that folder and subfolders and display all the drivers it found.
    3. Highlight all the drivers you want to install and click OK. NLite may ask you to pick from a few different drivers as in the Single Driver selection, then finally drop you back to the Integrate Drivers screen.
11. Now that you've chosen the drivers, click Next. NLite will ask you to confirm, and then it'll start packing all the files together into a single install set, which might take a few minutes. Then click Next.
12. Now you'll have a chance to specify a label and attributes for a bootable ISO. Enter an ISO Label, leave the attributes alone, and click Make ISO. Choose a target directory and name, click OK, and wait as the ISO is created.
13. Once your ISO is built, go ahead and burn it to CD or DVD using Nero, Deepburner, or your favorite ISO burning program.

That's it! Now you have a customized Windows OS Install CD that you can use to install a fresh copy of Windows on your new hardware without worrying about hitting F6, missing drivers, installing drivers later, etc.

Note that with certain RAID/SATA drivers there may be extra things you need to do to slipstream them correctly. If you have install problems using the above rough guide, check out the NLite forum or MediaMan's article on Slipstreaming, especially pages 4-5.

Google just blogged about the Google Web Toolkit, a development framework that allows you to write an application in Java and convert it into a working AJAX app. I've always felt that using a toolkit or framework is good when they work -- why reinvent the wheel coding low-level stuff when you can use someone else's to implement your own high-level stuff faster and easier? Unless your product idea is to actually make something low level. As in if you're Google and making a toolkit, say for AJAX apps.