This document contains the following sections:
Typist is a program to provide you with instruction and practice in the use of a computer keyboard.
If you cannot touch type, Typist contains all the tutorials and practice text you will need in order to master this skill. And if you can already touch type, then you can use the program to sharpen your keyboard skills, and improve your typing speed and efficiency.
Typist contains lessons and practice text for the standard QWERTY keyboard, the Dvorak (simplified) keyboard, and the PC numeric keypad. On each typing exercise, it measures your speed, and can provide you with information about which keys or fingers need additional practice.
You can use the Help Window to display online help while running Typist. At the top of the window you can select from the topics that the help window offers. Selecting a topic brings the help information for that area into the window's text display.
To reduce program startup time, the online help text is not accessed until the Help Window is first displayed. This is particularly useful when Typist is running as an applet. You may however see a delay when accessing the online help for the first time.
Select File->Close Window on the menu bar for this window to close it.
The file Typist31.html contains an HTML version of the online help text.
This is the main window for Typist. The menu bar allows you to activate the other windows that Typist can display -- the Tutorial Window, the Exercise Window, the Keyboard Window, the Statistics Window, and the online Help Window. Additionally, it also offers a Help pulldown item: Use Help->About to get information about Typist and its licensing, and Help->On Typist to obtain the online Help Window.
Typist offers a number of alternative and complementary lesson series. The Control Window allows you to select which lesson series is currently active, and within a lesson series allows you to select a particular lesson.
Beneath the window's menu bar is a toolbar. Using the toolbar, you can select the lesson series that is active, and move forwards and backwards through the lessons in that series using the <Prev and Next> buttons.
The central area of the Control Window is the lessons list. This shows each lesson that the currently active series contains. To run any lesson individually, select it from this list. Lessons can be of three basic types:
Tutorials are displayed in the Tutorial Window. Drills and Speed Tests are displayed in the Exercise Window.
This window shows the text of the most recently selected Tutorial. Use the scroll bars to read the text. The window may be left up as a reminder of the lesson if you wish.
This window also maintains a list of several past tutorials you have viewed. Use the History menu on the menu bar to review them.
This is the window that you type into for practice, and displays both Drills and Speed Tests.
When a Drill is being shown, the window contains two text areas. The upper one shows the target text that should be typed, highlighting the next character expected. The lower text area shows what you have typed at the keyboard so far, with error characters picked out as '*'s. In a Drill, backspace characters will not delete the last typed character.
For a Speed Test, only one text area is shown. Again, the expected next character is highlighted. When in a Speed Test, you need to overtype the characters in this text area. If you enter an incorrect character, Typist puts a '*' at the location of the error. You can use backspace to back up and correct mis-typings in Speed Tests.
For both of these types of exercise, Typist times each keystroke, and at the end of the exercise, it displays information about how many errors you made in typing the exercise, and also your typing speed and adjusted speed in Words Per Minute (WPM). Your raw typing speed is calculated as the number of keystrokes you made, divided by five (the notional average word is taken as being five characters), divided by the time in minutes taken to complete the exercise. The adjusted WPM is calculated in the same way, except that one word is taken away for each single character typing error you made.
When timing keystrokes, Typist does not count the first character of an exercise. Also, if you pause for a few seconds between characters it won't count the next character after the pause as part of the exercise. It does this to try to maintain sensible keystroke timing information in cases where you might take breaks in mid-exercise.
By default, Typist will try to behave like a word processor. A space character is treated as correctly typed at the end of a line, and multiple spaces are condensed down into a single space. If you hit Return at the end of a line, the cursor moves forward to the next significant character to be typed, skipping over blank lines and paragraph indentation. Typist won't insist that you type the hyphen at the end of lines that end in one, but will wrap for you. To switch off any or all of these word processing features, use the Options menu on the menu bar.
To restart an exercise from the beginning, use File->Restart Lesson on the menu bar.
Like the Tutorial Window, this window maintains a list of several past exercises you have worked on. Use the History menu on the menu bar to re-run these exercises.
The Keyboard Window shows a picture of your keyboard. When Typist is expecting you to type a key in an exercise, it indicates the key that it is waiting for in this window. It also indicates the finger that you should use to strike that key, and which Shift key you should press, if any.
The Keyboard Window can also show you your successful keystrokes, and any mistakes that you may make in an exercise. Use the Options menu on the menu bar to select what things you want the Keyboard Window to show you.
Note that only fingering for the main keyboard is indicated by this window. It does not show you which finger you should use for the numeric keypad. Also, the numeric keypad is not controlled by the keyboard layout you are using; Typist assumes it is the same for every keyboard type.
Although it is a useful learning aid, especially in the early stages of learning the keyboard, you should aim to practice without the Keyboard Window as soon as you can.
Each time you strike a key in an exercise, Typist notes the key that you struck, the one it was expecting you to strike, and the time it took you between the last key you struck and this one.
The Statistics Window displays a complete analysis of all of this timing information collected on exercises. Keystroke statistics are integrated globally, by finger, and displayed by individual key. You can use the View pulldown menu to decide which set of statistics you want to see in the window.
Each statistic is shown as a pair of gauges, giving the percent accuracy and speed for the finger or key. If the accuracy or speed drop below certain threshold levels, the gauges will change color to orange or red, to indicate that these are areas in which you might consider some additional practice.
Press the Refresh button to bring the window up to date with current keystroke statistics. The window is automatically refreshed if you change which set of statistics is on view, when the window is displayed, and at the end of each typing exercise you complete. You can also use the autorefesh function to have the statistics refresh automatically. To control this feature, use the Options->Automatic Refresh Every Second pulldown menu item.
You can use the File->Reset All pulldown menu item to set the complete collection of measurements back to their initial condition. To display adjusted WPM statistics, use the Options->Display Adjusted WPM pulldown menu item.
The statistics shown by this window are the normal keystroke statistics, broken down by key and by finger. Note that the WPM rates are calculated on timing information that is maintained regardless of whether you struck the right key or the wrong one -- this means that where accuracy is poor, the WPM rates shown for individual keys and fingers can become misleading.
Because a large amount of Typist is exercises and other typing practise material, it makes sense for the program to only load those lesson series that are actually required. It does this by using dynamic class file loading to access a lesson series when it is selected on the Control Window. Once a lesson series has been loaded, Typist keeps it in memory, so there is no need to load it again.
The effect of this is that the startup time is reduced where Typist is being run as an applet. You may however notice a delay due to downloading when you access a lesson series for the first time. Dynamic lesson loading happens automatically, and does not require you to take any special actions.
Typist (Java version) consists of a flat directory of Java source files, and a single Makefile. If you have make on your system, then merely invoking the command should be sufficient to build the complete set of class files -- the Makefile does not contain any complicated or GNU-make dependent constructs.
If you do not have make available, try 'javac [-O] *.java'. The Java compiler is sometimes smart enough to automatically compile any source files for a needed class file, so building may not be too much of a problem.
It is not necessary to install the program in order to run it. If you do choose to install the program, however, as an application, the command to do this is 'make install_application'. Installation of the program as an applet depends on the Web server you are using, and is not automated by the Makefile. Typically, all you should need to do is to copy the class files and the HTML files into a subdirectory of your Web server's main documents directory (for example, htdocs on Apache). Please consult your Web server's documentation if you are unsure of how to do this.
Most classes contain a main() method that tests the class in some way, the obvious exception being the Typist class that contains the 'real' main() method, and also the applet entry point for the program. The main() method in the HelpHTML class prints out the online help text as a single HTML User Guide document.
The single main runnable class file in Typist is:
To run Typist as an application; use a command something like 'java Typist' to run the Typist class. You can add -k keyboard_type to specify the keyboard type. Use -h for a full list of arguments.
If you have installed the program using 'make install_application', you can run the program using the simple command 'jtypist', found in the directory /usr/local/bin.
Typist can translate between keyboard types for you as it runs. To do this you need to add the option -r real_keyboard_type. This can be confusing, so here is an example. Say you are using a US keyboard, and want to try out Typist in Dvorak mode; you can do this by adding the options '-k Dvorak -r US'. This tells Typist to map each keystroke from your US keyboard into its Dvorak equivalent. You should note, however, that Typist does not translate menu accelerator keys; in all cases, these need to be entered using the keys shown on the actual system keyboard.
If you have localized messages and help text, Typist will use them, obtaining the locale from the Java runtime's default locale setting. You can also request a specific locale using the -l or -locale option. See Localization for details on how to specify a locale.
To run Typist as an applet, again use the Typist class. For an an applet, the keyboard type can be specified using the applet parameter kbtype -- see TypistApplet.html for an example of HTML applet tags to activate the program. Because the program makes heavy use of frames and menu bars, the applet form is nothing more than a single pushbutton that starts the main program in a separate frame outside the browser.
Applet parameters include:
Note that it is not necessary to use a Web server in order to run Typist as an applet. You can, for example, simply point a JVM-capable browser at the TypistApplet.html file using a 'file:/' URL.
Typist allows you to add new lessons to the ones that it offers. To do this, you need to create a lesson series class file. For example, if you want to create a lesson series Foo, the class file containing your lesson should be named LessonSeriesFoo.class. You can then use the -s or -series flags, or the series applet parameter, to specify the series that you want Typist to offer. This is a comma-separated list, for example, 'T,R,Q,Foo'.
To build the LessonSeriesFoo.class file, copy an existing lesson series java source file to LessonSeriesFoo.java, and edit the file to contain the lessons you want to put in this series; use the existing files as an example of format. When finished, compile the java source file. Javac, guavac, or any other Java compiler should be suitable.
Each lesson in a series needs to be one of the three allowable lesson types. For tutorials, a lesson title needs to be given, along with the tutorial text. For exercises, both a title and a brief set of instructions may accompany the exercise text.
Typist also allows you to extend its range of keyboard maps. To do this, you need to create a new KBLayout class file. You can then use the -k or -kb flags, or the kbtype applet parameter, to tell the program to use the new keyboard map. The new map can also be used with the -r or -realkb flags, or the realkbtype applet parameter, too.
As with adding a new lesson series, the simplest way to create the KBLayout class file is to copy an existing keyboard layout, and use it as a template. For example, to create KBLayoutFoo.class, copy KBLayoutUS.java to the file KBLayoutFoo.java, and edit this file to contain your layout. When finished, compile this file to create KBLayoutFoo.class, and then run Typist with the option -k Foo to use the new layout.
For each keyboard character, the new layout needs to specify the finger that is assigned to the key, whether the key is shifted, the group the character is in for statistical purposes, and the keycode of the key that creates the character. Typist will create the Keyboard Window by using the following table to turn keycodes into key positions in the window:
Row 1: 41, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14
Row 2: 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 43
Row 3: 58, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 28
Row 4: 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54
Row 5: 29, 56, 57, 100, 97
Typist is written to allow localization of messages, GUI elements, and online help text. There are two resources that you should translate if you intend to create localized strings for the program:
The first of these contains the messages, GUI element labels, and GUI menu shortcuts - in short, all program text except the help text. To create a national language version of this class, copy the file to the new file MessageResource_<nn>.java, where <nn> is the ISO code for the language you are translating for, edit this file and translate each text message in it, and compile it.
The second file is the help text for the program, also used to generate the HTML User Guide document. Translation for this file is the same as for the messages. The reason Typist splits internationalization into two files is so that loading the help text may be avoided in cases where the user does not access it in any way.
To run Typist in a particular locale, use the -l or -locale flags, or the locale applet parameter. Locales are specified in the format nn[_CC[_variant], where nn is the ISO language code (for example, "en", CC is the ISO country code (for example, "US"), and variant is any local variant of the locale. Only the language part is required for a locale; the country and variant may be omitted. Typist will also pick up the default locale set for the user, using it when no locale is specified to the program.
If there are no messages or help text for a particular locale, Typist will fall back to English messages and help text.
Typist was developed on a combination of the 1.0.2 JDK and the 1.1.7 JDK. both running on Linux, but is now fully converted to use the Java 1.1 event model. The following notes apply to the the various Java runtimes tried so far:
You may need to be prepared for a voyage of discovery with your Java runtime. At the very minimum, if you see any odd failures or other strange behaviour with the program on a particular platform, and you haven't done so already, try recompiling -- the Linux JDK used to build the distribution is probably not bug-free either, so this may be all it takes.
The Caps Lock key does not work correctly on some AWT 1.1 implementations. See Java Runtime Notes for at least some details on which ones have specific problems. There is a workround in the program for this, selectable from the Options menu of the Exercise Window.
The numeric keypad does not generate KeyEvents on some AWT 1.1 implementations. Again, see Java Runtime Notes for details of which JVMs are affected. No workround exists for this problem.
The exercise GUI interface is not as slick as it could be. In particular the slavish use by Typist of TextArea components does not give as much control over things like text placement as might be desirable.
The dynamic loading of lesson series class files should be OK, but it is a a relatively new feature, so hasn't had as much testing as the rest of the program. The same goes for loading keyboard layout files.
The gauge in the startup dialog popup never appears when the program is started as an applet. I have no idea why.
This program is a Java reworking of a UNIX C++ reworking of a UNIX C/Curses reworking of an IBM PC reworking of an original DECUS VAX BASIC program. This Java version, Typist v3.1 was created by Simon Baldwin, simonb@sco.com.
Thanks to the original authors, whoever they were, to D. Jason Penney for the initial conversion into C/Curses, and to George Ferguson for posting it to the Internet.
Typist v3.1d (Java), Copyright (C) 1999 Simon Baldwin
This program comes with ABSOLUTELY NO WARRANTY; for details please see the file 'COPYING' supplied with the source code. This is free software, and you are welcome to redistribute it under certain conditions; again, see 'COPYING' for details. This program is released under the GNU General Public License.