Guidelines for New IATH Fellows

John Unsworth Director 4-3137 jmu2m@virginia.edu

Worthy Martin Technical Director 4-3004 martin@virginia.edu

Daniel Pitti Project Director 4-6594 dpitti@virginia.edu

Regina Carlson Development Officer 2-4570 rbc2z@virginia.edu

Joy Shifflette Administrative Procedures Specialist 4-4527 jbs9q@virginia.edu

Robbie Bingler Senior Programmer/Analyst 2-4556 rwb3y@virginia.edu

Chris Jesssee Media Designer 2-2710 cj8n@virginia.edu

Cindy Mazza Information Specialist 2-4547 clm6u@virginia.edu

Felicia Johnson Web Designer 2-4557 fmj4f@virginia.edu

Sarah Wells Technical Writer 4-4570 spw4s@virginia.edu

The IATH staff will provide full-time assistance for fellows during the two-year fellowship at IATH and assistance as needed afterwards.

IATH’s normal working hours are 8am to 5pm Monday through Friday, but fellows can get a key to the office during library hours. This key does not open the library’s outside doors, either to get in or get out. Once the library has closed you will be locked in, so you should pay attention to the library’s posted hours (on-line at http://www.lib.virginia.edu/hours/libhoursnf.html). There is no signal to alert you when the doors are about to be locked.

1.2. Hiring Staff

You should start planning what kind of staff your project will require. Each project is different: some are just one faculty member working alone (“Uncle Tom’s Cabin”) some are several faculty collaborating and several students (Blake). If you want a large staff, build it up slowly.

1.2.1. Payroll

If you have negotiated a cost-sharing arrangement with your department, Joy and your department secretary will handle the paperwork.

1.2.2. Research assistants

Fellows can hire undergraduate and graduate students as research assistants. We encourage you to hire from inside your department, since those students are more likely to understand the particular scholarly issues in your project. We will help you recruit students in other departments if you cannot find appropriate candidates. Note that while we do provide some technical training, you should consider a student’s technical experience and comfort level when hiring. It will save time and frustration if your staff starts out with good technical skills. Anyone being added to the IATH payroll needs to talk to the appropriate IATH staffer.

Human resources’ policies on student employment are on-line at http://www.hrs.virginia.edu/Policies/payroll/studemp.html.

You may need to hire or pay research assistants at other universities, if you are involved in a collaborative effort. You will need to discuss this with Joy, to be sure that the paperwork is handled correctly.

If absolutely necessary you can hire research assistants who are not students, but it is extremely difficult to do and will cost you more. We recommend that you avoid this if possible.

1.2.3. Project managers

Each project has a designated project manager. The project manager coordinates the day-to-day work flow for the fellow, watches the project’s current budget status, and acts as a point person for interactions within the institute and the larger environment of the library and other electronic centers. He or she manages the creation of text and image files and may also be responsible for maintaining the project’s file structure and integrity, producing documentation, and other tasks, depending on the project.

1.2.4. Salaries

You can set a wage for your staff within your budgetary limits and University guidelines, but we can recommend a standard starting wage, depending on the student’s technical skills. We can adjust the wage to match the rate paid by individual departments, if necessary.

weekly hours???[***Joy/John***]

1.2.5. Working with staff at other UVa centers

The UVa Library has several electronic centers, including the Electronic Text Center and Robertson Media Center. There is information about the electronic centers on the Library’s web site at http://www.lib.virginia.edu/ecenters.html. The IATH staff will help you take best advantage of these resources.

1.2.6. Machines for project staff

Your project staff may require computers, scanners, software, etc. IATH has equipment for public use, which you and your staff can reserve for your use. You can also use your IATH money to buy new equipment.

(click here to see PHP database of IATH equipment)

1.3. Budget

1.3.1. IATH money

Each fellow gets up to $10,000/year from IATH. This money can be spent as you wish, on students, equipment, services (scanning, photographic services, permission fees, etc.), software, supplies, travel, and so on. Generally, fellows spend about half of this money on student wages.

1.3.2. Tracking and reporting expenses

Joy is responsible for the day-to-day management of IATH’s budget. Talk to her about adding students to your payroll, getting matching departmental funds for payroll, and processing travel and equipment costs.

1.3.3. Sharing with other institutions

If you are collaborating with other institutions, you may need to coordinate your budget with other faculty members. This has been done in the past but it can be complicated. You should consult Joy about the best way to do this.

1.4. CorporateTime

Corporate Time is a free scheduling software application that the University provides for all faculty and students. We don’t require that fellows use it, but we strongly suggest it to help coordinate meetings with your staff and with IATH people. Information about downloading and using it is at http://www.itc.virginia.edu/desktop/ctime/.

1.5. Majordomo lists

Most IATH projects have at least one majordomo list for archiving discussions and decisions. We strongly suggest that you start and use a majordomo list so that your project’s development history is preserved. For help setting up majordomo lists, please send a note to helpdesk@jefferson.village.virginia.edu.

2. GETTING STARTED

2.1. Building an information architecture

The first part of an IATH fellowship involves regular meetings with the IATH directors to discuss an information architecture. IATH projects are not just web sites, but structures that can be repackaged and recycled as current technologies become obsolete and new technologies put unexpected demands on archived material. Web sites that are currently cutting edge may be unreadable or may rely on proprietary software that is no longer supported in the future. Rather than building a web site to hold your information, your goal should be to design a structure that can support, archive, and distribute your information over the next ten to twenty years.

Before you can start to construct this structure, though, you will need to identify the assumptions you will be using, such as common base of knowledge, scholarship, and technical ability you will assume your average user to possess. You need to know what scholarly conventions you need to observe, what research objectives the project will fulfill, how the data needs to be presented (e.g., how your users are accustomed to using it), etc. You cannot please everyone, but we will help you determine reasonable parameters that will guide the rest of your project.

From a technical point of view, you should also determine what kind of data you will be distributing. What formats will you need? It is important to separate questions of data capture (putting the data into a usable format) from presentation (how the data is distributed).

This takes time to do properly, and may be frustrating. It may require some up-front labor to get solid, stable data. Each project will have its own particular pace and technical challenges. It is important to avoid getting bogged down and losing sight of your long-term goals and the long-term survival of your data. You do need to find a good project manager with appropriate computer skills, take care of your training and equipment needs, build your staff up as necessary, etc., but you must address the abstract issues first (such as data types, scholarly conventions and taxonomies, research objectives and purposes). Your final product isn't a product at all, but an information structure that can be repackaged over and over again as new technologies emerge and users develop new expectations for web sites. We will help you with these questions, however, and will work with you throughout your fellowship to be sure that you are making good decisions.

2.2. Rights

Depending on your project and subject materials, copyrights may be of extreme importance. If you have not already investigated this subject, you must know what materials you are thinking of using, where they are located, who owns them, and what rights or permissions you need to obtain. You must investigate and start to handle any rights issues in the first year of your fellowship, or you will have problems later on when you are trying to secure funding or publish your work on your site.

2.2.1. IATH help

IATH has helped other projects with copyright permissions and access issues in the past and can provide templates, advice, and information as needed.

2.2.2. UVa and IATH copyright policies

Note that your work will be subject to UVa copyright policies. The official UVA Copyright Statement (http://www.virginia.edu/copyright.html) does not apply to IATH project. The IATH copyright statement declares that:

Unless otherwise noted, items published by the Institute for Advanced Technology in the Humanities are copyrighted by the authors and may be shared in accordance with the Fair Use provisions of U.S. copyright law. Redistribution or republication on other terms, in any medium, requires express written consent from the author(s) and advance notification of the publisher.

For information about UVA’s copyright and intellectual ownership policies, please see http://www.virginia.edu/~polproc/pol/xve1.html.

2.2.3. Fair Use

Fair Use policy is a provision to the US copyright laws allowing for exemptions to laws. It allows you to reproduce other authors’ works for scholarly and pedogogical purposes. For more information about Fair Use and international copyright laws see http://www.lib.virginia.edu/acquisitions/copyright/, http://fairuse.stanford.edu/ and http://www.loc.gov/copyright/.

2.3. Collaborators

Depending on the project, some fellows have worked with collaborators at UVA and other academic institutions or with independent researchers. There are pros and cons to having collaborators. A good partnership or editorial board can make a project more efficient, give it greater depth, and improve its quality control. A poorly organized coordination can, on the other hand, cause administrative, financial, and philosophical headaches. If you do decide to collaborate, we would suggest a maximum of three or four partners or co-editors (or whatever title you choose). Also, we would suggest that large collaborative efforts are better served by starting off slowly, with fewer people, and then gradually growing to the final size.

2.4. Web site and home directory

You will be given a starter web site and a home directory on the jefferson server. Depending on your equipment and needs, you may want to do much of your work on your laptop or PC and use jefferson to store files. If so, please contact the appropriate IATH staffer to be sure that your machine is being backed up. [***need info on available space on jefferson?***]

2.4.1. Web site location

If you don’t already have a web site for your project, the IATH staffer in charge of web design will make you a placeholder home page on jefferson. The URL will be something like

http://jefferson.village.virginia.edu/<project_name>/

The files are located on the jefferson server in the public_html directory of your home directory (e.g., /home/project/public_html).

2.4.2. HTML

If you have not worked with HTML before, you should learn it. You may not be actually tagging in HTML but you should understand how an HTML document is put together and how browsers display it. There are many books and web sites that can help teach HTML, such as http://hotwired.lycos.com/webmonkey/authoring/html_basics/ and http://www.htmlhelp.com/links/tutorials.htm. The library also has short courses for faculty, staff, and students on the web, Photoshop, Flash, image processing, etc. The catalog is on-line at http://www.lib.virginia.edu/usered/catalog.html.

2.5. Before you start your web site

Building and implementing your web site will (and should) occupy a great deal of time and energy over the next few years, but before you start tagging, coding, and compiling you should take time to plan, outline, and design the site.

IATH strongly believe that IATH projects should place a premium on the long-term survival of their data, and that should be at the forefront of your mind while working through the issues discussed in this section.

Another thing you should think about it avoiding letting any one part of the project take up a disproportionate amount of time. You should identify and tackle the more difficult or ambitious aspects of the project in the first year so that when start looking for outside funding you can show solid (or at least plausible) solutions. However, you don’t want to overlook basic work on prototyping the site design and long-term planning. The first year is a difficult balancing act between long- and short-term planning, design, and prototyping and you may need to be vigilent about covering all your bases.

Long term survival of data. This should include planning for future users, who may be using different interfaces or software to use your site. The basic components should be persistent.

Practical, realistic planning for your two-year residency.

Finding the right scope for your project, to fit technical possibilities, audience needs, and expected uses.

Everything on the site should be relevant to your larger purpose and to your scholarship.
- Is it relevant and necessary to the project?
- Why is the information important and for whom?
- What kind of scholarship will it support?
- How much will it cost (in money & time) and is it worth that price?

Practical planning so that your staff doesn’t have to re-engineer the site for unexpected detours and late-breaking ideas.

Build a logical and clear structure for content that will be added later (i.e., two, three, or four years later).

Avoid letting a particular part of the project take over at the expense of other parts.

As the opportunities arise, continue your technical training.

Planning for whatever technical support various parts of your site will require (databases, stylesheets, etc.) and have a system for identifying and handling problems.

2.5.1. Branding

It is a good idea to design and stick to some kind of visual coherency, especially with a large site. Branding involves a recognizable look and feel which gives a web site an identity. This can be as simple as an icon which appears at the top left corner of each page or identical layouts on each page or as subtle as a unifying system of colors and design factors. This not only lets visitors know that they are still in your site, it also gives the site a clear visual identity. For help deciding what might work best, please consult the appropriate IATH staff member.

2.5.2. Basic information that every web site should have

This information should either be on the home page or within a few mouseclicks from the home page. Note that you need to be wary of putting too much information on one page but instead aim for a site that lets users quickly and independently find whatever they are looking for.

table of contents

site map

staff list

contact information

introductory text about this site

introductory text about the subject matter

FAQs

special instructions for using the site and links to any plug-ins

history of the project

IATH logo and standard IATH text

links to other related sites

2.5.3. Open source vs. proprietary software

Open source software is software that is freely distributed to anyone (usually over the internet), with no royalties attached; allows its source code to be freely distributed, altered, and redistributed; amd has a nonrestrictive license. In other words, it is free and its source code is free. Proprietary software is owned and distributed by an individual, institution, or corporation. It may not cost anything to get and use the software, but its source code is restricted and may not be altered. While proprietary software is often well-written, useful, and supported it is attached to the fortunes of its owner. If its owner someday decides to stop supporting it or radically redesigns it, previous releases of the software may become unusable and data which was distributed with those versions may disappear. We therefore suggest that you use open source software at every reasonable opportunity. If you have questions about the best piece of software for a given task, talk to the appropriate staff member.

2.5.4. Templates and prototypes

Templates and prototypes are very useful tools and we strong recommend that you use them. They will save time and effort, add quality control, and maintain graphic coherence.

Prototypes, using small sections of content put in proof-of-concept pages to test software and interface ideas, are crucial and should be used while designing the site. They should work with representative samples of all data types that you will use. Be sure to keep in mind the expected audience for your site, and be aware of what the average user will want from your site and how he or she will expect to use it.

2.5.5. Stay inside the project scope and budget

This may seem obvious, but you should consider limitations of time, staff, and funds when designing the site. Unexpected circumstances may create a surplus or lack of these factors, but you should try to plan something that you can reasonably finish.

3. FUNDING

The goal of much of the work of the first year is to prepare for asking for funding during the second year. It can take 18-24 months to get a large grant. However, there is no point in asking someone to fund a threadbare or disorganized project. Prospective funders will expect you to clearly explain why they should give you money and what you will do with it. You should therefore spend most of your first year building an interesting demo site or prototype that clearly demonstrates what you want to accomplish and what your project contributes to the scholarship in your field.

One of our major funding sources is NEH, but you should think creatively and consider government grants, foundations, alumni, and corporations. Regina will work closely with you to consider what kind of money you will need and for what and to come up with a calendar for preparing proposals. Each project is different and each one has different opportunities and restrictions.

4. TECHNICAL INFO

4.1. Machine names and passwords

We will give you a list of the basic passwords and machine names that you need to know.

4.2. Equipment

4.2.1. Legacy

If you have legacy machines or data that you wish to use at IATH, please talk to John about it. Depending on the equipment you now have, IATH’s current machines and software, and the nature of your project, it may be difficult or impossible to use legacy materials.

4.2.2. New equipment

IATH will help you select and purchase any new hardware and software that you need.

4.2.3. Available equipment in IATH

(click here to see PHP database of IATH equipment)

IATH has two public machines, a PC and Mac, that can be used by fellows and research assistants. There is a notebook for reserving time on the PC on the table next to the machine, but otherwise both machines are available on a first come, first served basis. We also have two scanners, one of which is for slides, and two printers, one color and one black and white. You can reserve one of the IATH laptops (one PC and one Mac) and a portable video projector for remote presentations.

The IATH conference table can be reserved for meetings and such via Corporate Time. The table has a Corportate Time account as "IATH-319 table" and can be "invited" to meetings as if it were a person or signed up as a resource. The table should be included when setting up "group agendas" for meetings here at IATH to avoid conflicts.

4.2.4. Library equipment

The UVa library and electronic centers have computer equipment, services, and technical support available for UVa faculty, students, and staff. The following may prove useful:

The Electronic Text Center (aka E-Text) home page is http://etext.lib.virginia.edu/. Click on “Services” for information about their resources.

The Geospacial and Statistical Data Center (aka Geostat) has a home page at http://fisher.lib.virginia.edu/. Click on “Staff and Services” to see a list of software and services.

The Digital Media Lab in the Robertson Media Center has several resources related to digital media and digital collections as well as help finding outside resources. The home page is http://www.lib.virginia.edu/clemons/RMC/dml.html.

If you need to use any of these resources, we can advise you as to who you should contact.

4.2.5. Restrictions on use of UVa equipment

Please note that all IATH equipment is subject to UVa restrictions of equipment use (see http://www.virginia.edu/~polproc/pol/xvg2.html). Equipment that you purchase with money from IATH or grants is UVa property and therefore subject to these restrictions.

4.3. Security

There are some basic security precautions that everyone should observe, such as guarding your equipment against theft, using strong passwords, maintaining up-to-date virus protection software, and backing-up data. The ITC web site has information on current security alerts and guidelines for safe computing at http://www.itc.virginia.edu/pubs/docs/RespComp/. If you think that your computer has been hacked or that you have a virus on your machine, please contact the IATH system staff as soon as possible. ITC also has a page on current virus alerts and fixes at http://www.itc.virginia.edu/desktop/virus/.

We will give you Norton anti-virus software and back-up your hard drives, but we encourage you and your staff to take reasonable steps to protect your data, such as not opening unknown attachments and not downloading suspect files.

4.4. Back-ups

All IATH machines are backed-up nightly. We cannot back up machines that you have at home, but we schedule weekly back-up sessions for laptops. The IATH servers are backed up nightly by ITC. If you have questions about back-ups, please talk to an IATH staff member.

4.5. Training

IATH will provide training or help finding appropriate classes for you and your reseach assistants either through ITC and library short courses or with outside companies. Depending on your project, you may need to work on Unix, Windows, and/or Mac operating systems. Training may also cover basic Unix commands, imaging and scanning, SGML, and so on.

The library offers a series of short courses that cover web basics, Photoshop, Flash, image processing, and so forth. The catalog of courses is on-line at http://www.lib.virginia.edu/usered/catalog.html. ITC also has training courses, listed at http://www.itc.virginia.edu/training/. UVa has a contract with three outside training agencies to provide Microsoft and Novell training (see http://www.itc.virginia.edu/training/techtrain/index.htm for more information). A list of other training opportunities is on the library’s web site at http://www.lib.virginia.edu/usered/programs.html.

4.6. Help desk info

IATH uses an on-line request system to assign and track help desk queries. We strongly encourage fellows and their employees to use the help desk for all technical problems and questions. Information about help desk is on the IATH web site at http://www.iath.virginia.edu/helpdesk.html. Joy receives all queries and passes them on to the appropriate staff member within an hour of receiving them (during regular business hours). This system is designed to manage the help desk demands on the staff, so that one person is not swamped with requests for help and advice. If you have a problem or question for help desk, please either send an e-mail to helpdesk@jefferson.village.virginia.edu or call the main IATH number (924-4527)

4.6.1. ITC

Those with problems requiring technical support should consider whether the problem is appropriate for the IATH helpdesk system or is instead an ITC helpdesk problem or a longer term IATH project. IATH helpdesk problems include malfunctioning IATH hardware or software, installation of new IATH hardware or software, resuscitation of IATH systems, and problems with IATH networking. Problems that are like any of the foregoing but involve software or hardware owned, distributed, or supported by ITC should be referred to the ITC helpdesk (call 924-3731 or see "Getting Help" from ITC, at http://www.itc.virginia.edu/help.html).

4.6.2. Rules for use

If you have an IATH helpdesk problem, or if you're not sure whether it's an ITC or an IATH problem, send email to the IATH helpdesk. If what you have is a longer term project, it should be scheduled through the Project Director, and not by going directly to staff members. If you have submitted a helpdesk problem by email, and you don't get a speedy and cheerful response with a thorough and effective follow-through, please mention the problem to John.

4.6.3. After-hour emergencies

If you run into an emergency situation that demands instant attention after regular business hours, call John at home (434) 296-3451 or on his mobile phone (434) 825-2969.

4.7. Getting help beyond help desk

If you have a problem that doesn’t require help desk, you should of course ask for help. The IATH staff does its best to help fellows as quickly and efficiently as possible, so if we don’t immediately know the answer to your question, we will help you find out. However, it will save you (and us) much frustration if you know who is most likely to have the information you want. In some cases, you may be better served by someone outside IATH.

Please note that a staff member may be preoccupied by another problem and may not be able to give you immediate attention. If this happens, please be patient!

4.7.1. Who knows what

A reminder: you should submit all technical problems and questions to the help desk).

[***This will eventually be a PHP database***]

John Unsworth General IATH policy issues; general funding and budget questions; selecting and purchasing equipment; planning and getting technical training; resolving problems with IATH staff; finding and training student employees; guidance with project development; questions about IATH server usage and Windows system administration; majordomo; PHP; legal issues; Unix system administration; Perl

Worthy Martin Implementation questions; general programming questions; help with technical development; imaging

Daniel Pitti Project management issues; XML, XSL, and DTD help and development

Regina Carlson Fundraising; help preparing budgets and proposals; guiding proposals through the UVa machine; negotiating awards, and consulting on post-award administration and reporting

Joy Shifflette Financial issues; tracking and submitting expenses; running projects; coordinating work and finances with other UVa and non-UVa groups; using help desk; payroll; finding John

Robbie Bingler Selecting and developing specialized software for projects; Java; CGI; networking issues; Unix; Perl

Chris Jessee Imaging and design work; mapping software; modeling and animation; Flash; CD and DVD burning; Mac applications and Mac system administration

Cindy Mazza XML and XSL; Unix; back-up for laptops, Macs, and PCs; DynaWeb; Perl

Felicia Johnson Web design; Dreamweaver; Mac applications

Sarah Wells Technical writing; copy-editing; SDS

ITC Jefferson system administration

E-Text Generating electronic text

4.7.2. ITC software and services

ITC has PC and Mac software available for downloading either for free or for a reduced price. You can find information about various operating systems, documentation, and pointers to free software at http://www.itc.virginia.edu/desktop/central/.

4.7.4. Central Mail Service (CMS)

CMS is the University's e-mail server. You are not required to have an e-mail account on CMS, but it is a good idea. You are automatically given an e-mail account on jefferson (the main IATH server) when your fellowship begins, and you can use that account for e-mail. However, CMS is probably more reliable and has the added advantage of Web Mail (below). All UVA faculty, staff, and students are entitled to a CMS account. To get an account, go to http://www.itc.virginia.edu/helpdesk/accounts/createacct.html and click "Central Mail Service" (note that an account on Blue Unix is not the same as a CMS account: Blue Unix is for files and CMS is for e-mail).

4.7.3. Web Mail

Web Mail is a browser-based e-mail reader for CMS account holders. If you have a CMS mail account, you can read and send mail from that account from any web browser. Note that jefferson accounts are separate from CMS accounts and that you can only use a CMS account in Web Mail. For instructions for getting a CMS account and using Web Mail, please go to http://www.mail.virginia.edu/.

4.8. Unix commands

In all likelihood, you will be doing some file management work from the command line, copying, moving, and deleting files. There are some basic Unix commands that will make your life easier. Please note that Unix commands can vary from one platform to another and that system administrators sometimes set up short cuts so that a certain command will always run in a certain way (for example, when you delete a set of files you may have to confirm that you want to delete each file one by one). The instructions in this section are intended as a general introduction and should not be treated as universally true. If you aren’t sure about a command, ask for help.

4.8.1. Other Unix information

Basic Unix information is available on the web in several guises, such as UNIXHelp (http://www.geek-girl.com/Unixhelp/), Webmonkey (http://hotwired.lycos.com/webmonkey/reference/unix_guide/) and in Unix man pages. To see a man page, enter the command “man” plus the command name. E.g.,

$ man cp

You can often get information with a -help or --help flag. The output will vary from one command to another, since it depends on what kind of documentation the individual programmer provided. You may get no more than an brief line of syntax or a longer explanation of the command's options and some helpful usage suggestions. For example:

$ rm --help
Usage: rm [OPTION]... FILE...
Remove (unlink) the FILE(s).

  -d, --directory       unlink directory, even if non-empty (super-user only)
  -f, --force           ignore nonexistent files, never prompt
  -i, --interactive     prompt before any removal
  -r, -R, --recursive   remove the contents of directories recursively
  -v, --verbose         explain what is being done
      --help            display this help and exit
      --version         output version information and exit

To remove a file whose name starts with a `-', for example `-foo',
use one of these commands:
  rm -- -foo

  rm ./-foo

Note that if you use rm to remove a file, it is usually possible to recover
the contents of that file.  If you want more assurance that the contents are
truly unrecoverable, consider using shred.

Report bugs to <bug-fileutils@gnu.org>.

Finally, you can also look in the O’Reilly Unix in a Nutshell reference guide in the IATH reference library (aka the shelves above the public machines: if it isn’t there it’s probably sitting on someone’s desk, so ask around).

4.8.2. Syntax conventions

There are certain conventions used when documenting command syntax that are used in this section. Anything between [ ] is optional and anything between { } is required. When a series of arguments are separated by the “|” character it means that you can use only one of the arguments. For example:

$ command [-xy] {-z | -a} <file name>

This means that the –x and -y arguments are optional (you can use one, both, or neither) but you must use either –z or -a (but not both) when running the command. You must also include the file name (but not the actual string “file name”).

4.8.3. Terminology

This section contains a few technical definitions that you should know. There are other terms, of course, that you will run across so we suggest that you find and use some of the technical and computer dictionaries on-line, such as FOLDOC (http://foldoc.doc.ic.ac.uk/foldoc/index.html).

argument: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

execute: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

input: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

output: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

process: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

regular expression: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

script: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

server: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

shell: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

text file: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

user id: Supplemental information provided on the command line when running a program. Arguments can specify how a command should behave; where it should find its input and put output; when, where, and how long it should run; etc. Unix commands often have a bewildering array of possible arguments, which can vary depending on which platform you are working on.

4.8.4. Common commands

The commands in this section are:

cat | cd | chmod | chown | cp | diff | emacs | find | grep | groups | id | kill | less | ln | lpr | ls | mkdir | more | mv | passwd | pico | ps | rm | sed | ssh | su | tar | whatis | whois

Command Definition

cat Short for “concatenate,” cat lets you read multiple files. It reads each file in sequence and prints them out to the screen. For example:

$ cat file1.txt file2.txt This is file file1.txt This is file file2.txt

You see the contents of the two files on your screen. You can also use the “>” character to copy the contents of files into a file. For example, if you enter:

$ cat file1.txt file2.txt > file3.txt

The cat command will copy the contents of file1.txt and file2.txt into a new files called file3.txt (however, if a file3.txt already exists in the working directory, it will overwrite it).

cd Use to move to another directory.

$ cd mydirectory/stuff

You can go back up a level by using “…”

$ cd ../anotherdirectory

To return to the previous directory, use “-“.

$ cd -

If you aren’t sure which directory you are currently in use the ls command.

chmod Change access permissions for a file, group of files, or a directory. Access permissions consists of read (r), write (w), and execute (x) permissions for the file owner, a group of users, and all others.You can see the current settings for a file or directory with ls –l (figure 1).

Figure 1

To change this file’s permissions, you use chmod with arguments indicating which permissions you want to change. You can do this two ways: in absolute mode or symbolic mode. Absolute mode is more efficient but potentially confusing (see the Webmonkey site or the chmod man page for more information). Symbolic mode uses a “+” or “-“ to add or remove permissions from the user (u), group (g), other (o), or to all (a). The syntax looks like this:

chmod [u, g, o, or a]{+ | -}{a | w | x} <file name>

For example, to give write permissions for the foo.txt file to anyone you would enter:

$ chmod a+w foo.txt

Notice that there are no spaces in the “g+w” argument. To remove write permissions from all, you would simply change the “+” to a “-“:

$ chmod a-w foo.txt

If you want to change permissions on every file in a directory, you can use the –R flag. For example, to give everyone permission to read all files in mydirectory you would enter:

$ chmod –R a+r mydirectory

chown Change the owner of one or more files or directories. You can use ls –l to see who currently owns the file (see figure 1, above, for a full explanation of the output). You must be logged in as the file’s current owner or as root before you can change a file or directory’s owner. The syntax is

chown <new owner> [: <new group>] <file name>

The <new owner> name is the new owner’s user id (e.g., jmu2m). You can assign a new group as well (e.g., staff).
As with chmod, you can use the –R flag to change every file in a directory. You can also use the –h flag to change the ownership of a symbolic link: if you don’t use it, the ownership of the referenced file is changed (see ln for more information about symbolic links).

cp Copy a file or directory.

$ cp file1.txt file2.txt

Note that, in this example, if a file called file2.txt already existed in the current directory it will be overwritten.
You can also use this to copy a file into a different directory:

$ cp file1.txt /some/directory/somewhere/

This puts a copy of file1.txt in the /some/directory/somewhere/ directory.

diff Compares two files, line by line, and reports where there are differences. The syntax is

diff <file name1> <file name2>

So, suppose that you have two files, foo.txt:

This is file foo.txt It's a nice file

and bar.txt:

This is file bar.txt It's a nice file but it has 3 lines of text.

If you run diff on these files you’ll get the following results:

$ diff foo.txt bar.txt 1c1 < This is file foo.txt --- > This is file bar.txt 2a3 > but it has 3 lines of text.

The first piece of output, 1c1, tells you that that line 1 in the two files is not the same. It then shows the two lines. The second piece, 2a3, tells you that the bar.txt has an extra line of text. If the files were identical, there would be no output.
This can be very useful for debugging and comparing small text files and scripts but the results can be confusing.

emacs Emacs is a word processing program that can be run from the command line. It is an excellent tool for working with text-based files but it may take some time to learn how to use it. It has a tutorial and help feature, which you may want to investigate. The tutorial is quite tborough and a good starting point. To start an emacs session, type

$ emacs

You can include a file name if you want to open an existing file. E.g.,

$ emacs foo.txt

You can get help with Ctrl-h (hold the Ctrl and "h" keys at the same time)and see the tutorial with Ctrl-h t (hit Ctrl-h, then hit "t"). If you have trouble, send a note to helpdesk@jefferson.village.virginia.edu.

While emacs is a good tool, there are other command-line word processing applications that you may find better suited to some jobs. For simple jobs involving only a few files, pico or WordPad (on Windows machines) may be more efficient. We do not recommend jove because of the line length restrictions. Desktop word processors such as Word and Frame are helpful for writing documents, although we don't recommend them for writing HTML pages or code.

find Use this to find particular groups of files and directories. This is a useful command to know. The syntax is

find <path name(s)> <condition(s)>

You have to provide at least one <path name> (i.e., a directory path) and <condition>. You can specify several path names to look in multiple directories. The <condition> argument defines the terms of the search. There are several possible conditions, and you should look in Unix in a Nutshell or the find man page for a full discussion. The more useful conditions are –name, -newer, and –user.

-name <pattern> Find files whose name matches <pattern>.

-newer <file> Find files that have been modified after the file named in <file>. You must provide a full path for the file (i.e., if the file is not in your current directory you have to say where it is).

-user <user id> Find files belonging to the specified user id.

For example, to find all .jpg files in /mydirectory, you would enter this:

$ find /mydirectory –name *jpg

grep Search one or more file for a pattern (called a regular expression). The command returns the names of all files that have contents matching the regular expression, along with the line(s) which matches the pattern. The syntax is

grep <regular expression> [<directory or full or partial file name>]

You can use the “*” character to look for file names matching a certain pattern as well. It may take a bit of practice to learn to finetune your searches, since you may get matches that you didn’t intend (searches for the word “red” for instance, will yield “retired”, “adored”, and “reduction”).

* A wildcard that matches zero or more characters. For example, “foo*bar” matches “foobar”, “foofbar”, “fooBARbar”, etc. If you wanted to look in all .txt files, for example, you could use “*.txt”:

$ grep foo *txt

You can also just use a “*” to indicate that you want to look in all files in the current directory.

$ grep foo *

. A wildcard that matches any one character. For example,

$ grep f.le *txt

matches "file" and "filename" but not "fooled."

[ ] Use to indicate a possible range of characters, such as the numbers 1 through 9. For example:

$ grep foo[1234]bar foo1bar foo2bar foo3bar

You can search for the “*” and “.” characters by escaping them with a “\”. So:

$ grep foo[1234\*]bar foo*bar foo1bar foo2bar foo3bar

groups Use to find out which group you or a specific user id belongs to. For example:

$ groups spw4s users staff samba

id This command is used for user identification. The syntax is

id [<user id>] [-a]

Used by itself, it returns the your current user id and the first group that you belong to.

$ id uid=23304(spw4s) gid=100(users)

If you run it with an -a flag, it will show all groups that your user id belongs to.

$ id -a uid=23304(spw4s) gid=100(users) groups=100(users),10(staff),518(samba)

You can run it with another user id to see which groups that id belongs to. E.g.,

$ id jmu2m uid=21953(jmu2m) gid=254(systems)

kill Kill a process. The syntax is:

kill [-9] <one or more PIDs>

The -9 is an optional signal which essentially tells the command to kill the process no matter what.
To run this command, you need to know the targeted process’s ID (PID). Run ps to see a list of which processes are currently running and their PIDs. For example,

$ ps PID TTY TIME CMD 2227 pts/37 0:00 emacs 2605 pts/37 0:00 emacs 21385 pts/37 0:00 ksh $ kill -9 2227 2605 $ ps PID TTY TIME CMD 21385 pts/37 0:00 ksh [1] + Killed emacs & [2] + Killed emacs &

In this example, we first run ps and see that there are two emacs processes running. We don't want these processes anymore, so we run kill on both. Notice that there is no output to indicate whether or not the command succeeded, so we finally run ps again to see that the two processes did indeed die.

Note that you can only kill your own processes.

less This lets you browse through one or more files. It is very similar to the more command, except that you can move backwards and forwards. To see a single file, enter less with the name of a file:

$ less foo.txt

Hit the space bar or the down arrow to move forward through the file and the up arrow to move backwards.
To see several files, you can enter the files names in sequence or use a regular expression to describe a pattern (such as *.txt to look at all .txt files).

$ less foo.txt bar.txt

When you get to end of the first file in the list, type :n to see the next file. At any point you can type :p to see the previous file or q to quit and get back to the command line.

ln Make links to remote files. There are two different kinds of links: hard and symbolic. A hard link is a pointer to a file which is actually located in a different directory and is indistinguishable from the orginal file. A symbolic link is an indirect pointer that only contains the file path of the original file. You can call that name to access the remote file. The syntax is

ln [-s]<file path> <link name>

The –s flag makes a symbolic link. For example:

$ ln –s /stuff/myfile.txt foobar.txt

Note that the link name foobar.txt is treated as a normal file, which may cause problems if you already have a file named foobar.txt (that is, you will lose your previous file). However, you can easily identify symbolic links when you run ls, since they have a “@” character next to their names:

$ ls foo.txt foobar.txt@ bar.txt

Use ls –l to see where the link points to:

$ ls -l foobar.txt lrwxrwxrwx 1 spw4s users 13 Jul 26 12:02 foobar.txt -> stuff/myfile.txt

lpr Use this to print a file from the command line. You may need to provide a printer name. The syntax is

lpr [-P<printer name>] <file name>

Note that there is no space between the -P and the printer name. The standard printer on jefferson is the black and white HP laser jet near the IATH conference table. Its name is av_l1, so to send a printing job there you would enter

$ lpr -Pav_l1 foobar.txt

If you do not specify a printer, the job will be sent to the default printer (which is probably av_l1).
You can check the status of print jobs from the command line with the lpq and lpstat tools. The first checks the queue status of

ls Lists the contents of the directory. There are several options available with this tool, but the more useful ones are –l and –a. The –l option displays the files in long format, meaning that it shows each file’s permissions, owner, date last modified, and byte size (please see figure 1 for an example). The –a option lists every file in the directory, including those whose name begins with a dot (those are called dot files and are normally not listed). The syntax is:

ls [-l] [-a] <file or directory name>

mkdir This will create a new directory. For example,

$ mkdir newdirectory

This creates a directory called “newdirectory” in the current directory. Note that the default permissions settings in a new directory give everyone permission to read the contents of the directory but only the owner (you) has permission to write to the directory. You can use chmod to change permissions.

more This is very similar to the less command, except that it only lets you move forward through a file. To use, enter more along with the name of the file.

$ more foo.txt

Hit the space bar to move forward through the file.

mv Use to move files and directories. For example:

$ mv foo.txt /mydirectory

This moves foo.txt from the current directory to mydirectory. You could also move an entire directory:

$ mv /mydirectory /stuff/newdirectory

Note that mydirectory will no longer exist, but that all of its files will now be in newdirectory.
Be careful when moving multiple files, since the new files will overwrite existing files of the same name. The default setting of this command on jefferson will post a warning message if you are about to overwrite a file. You can use the –f flag to override this setting.

passwd Create or change your jefferson password. To use, just type in passwd. You will be prompted for your current password and then asked to type in the new one. Please note that this will not change your Windows NT server password.
The command will check your password to see if it can be guessed or is too close to your old password, so you may want to have a couple of possibilities in mind.

You can cancel this command midway through by hitting Ctrl-q.

pico Pico is a simple text editor and is very useful for simple editing or for small text files. If you are working with large files you would be better advised to use another text editing program, such as emacs or vi. We do not recommend jove as a text editor. The syntax is

pico [<file path>]

You can type in a new or existing file name: if you type a new name or no name pico will create a new file. A new file looks something like figure 2:

Figure 2

Type in the text as you would in any basic word processing application (such as Notepad). ou can use any of the commands listed in the footer by hitting the Ctrl key (displayed here as a "^" caret character) plus the specified letter. Hit Ctrl-a to move the cursor to the beginning of the line and Ctrl-e to move to the end of the line. Use Ctrl-d to delete characters. To cut and paste, use Ctrl-k to cut a line (hold down the Ctrl key and hit "k" multiple times to cut more than one line) and Ctrl-u to paste. To save to a file without closing the window, hit Ctrl-o then type in the file name. To insert a text file into the current window, hit Ctrl-r then type the file's path. To exit, hit Ctrl-x. If you haven't saved your work, you will be asked if you want to save.

Note that there is no man page for pico, but get to the pico help screen with Ctrl-g.

ps List information about processes currently running. You will see a list of processes that you own.

$ ps PID TTY TIME CMD 20903 pts/62 0:00 emacs 20318 pts/62 0:00 ksh

This output shows that two processes are running. The PID column gives you each process’s id (PIDs can be useful for tracking and killing individual processes), the TTY column identifies the terminal where the command’s output is being displayed, the TIME column shows how long the process has been executing (if it is actively executing), and the CMD column tells you that name of the command.
There are several flags that you can use to change this list. The -f flags shows a full listing of all information about each process:

$ ps -f UID PID PPID C STIME TTY TIME CMD spw4s 20903 20318 0 10:42:05 pts/62 0:00 emacs spw4s 20318 20283 0 10:37:49 pts/62 0:00 -ksh

The UID column is the user id of whoever owns the process (that is, whoever started it). You can ignore the PPID and C columns. STIME shows when you started the process.

You can use -a to see a longer list of programs currently running. If you use it with -f, you'll get a more complete picture.

$ ps -af UID PID PPID C STIME TTY TIME CMD root 21967 670 0 0:00 <defunct> sag 16344 16147 0 Aug 20 pts/15 0:00 /bin/sh -c dtfile -noview yy8b 21594 21571 0 10:50:48 pts/9 0:02 /usr/dt/bin/dtsession patrick 25013 24998 0 11:35:23 pts/39 0:00 /bin/bash sjm8k 21952 21941 0 10:56:17 pts/64 0:00 pine jjm2f 3863 11467 0 0:42 <defunct> root 22279 20340 0 11:00:55 pts/63 0:00 -ksh mfr2v 24749 24733 0 11:31:38 pts/59 0:00 pine spw4s 20903 20318 0 10:42:05 pts/62 0:00 emacs spw4s 13069 13060 0 09:02:56 pts/34 0:01 pine root 25024 20318 0 11:35:27 pts/62 0:00 ps -af root 9022 670 0 0:00 <defunct> kat2n 15143 15058 0 Aug 20 pts/30 0:01 pine jjm2f 7589 4884 0 0:00 <defunct> kat2n 15015 1 0 Aug 20 pts/36 0:00 /usr/dt/bin/ttsession pmc 17384 16264 0 10:20:37 pts/2 0:00 pico cubukcu_f.editors pmc 15561 15543 0 09:51:27 pts/6 0:06 pine oa2m 16562 16543 0 10:03:21 pts/18 0:00 /usr/dt/bin/dtsession yy8b 21593 1 0 10:50:48 pts/9 0:00 /usr/dt/bin/ttsession jjm2f 7035 11467 0 0:45 <defunct> jjm2f 25582 11467 0 Jul 26 pts/4 0:00 jove 9-1879.s162.raw.sgml kat2n 15016 14993 0 Aug 20 pts/36 0:01 /usr/dt/bin/dtsession sag 16345 16344 0 Aug 20 pts/15 0:01 dtfile -noview sag 16147 1 0 Aug 20 pts/15 0:00 /usr/dt/bin/ttsession yy8b 22121 22120 0 0:00 <defunct> yy8b 21647 21631 0 10:51:11 pts/61 0:00 tcsh oa2m 16561 1 0 10:03:21 pts/18 0:00 /usr/dt/bin/ttsession sag 16361 16345 0 Aug 20 pts/15 0:00 dtfile -noview root 16148 16130 0 Aug 20 pts/15 0:01 /usr/dt/bin/dtsession

Finally, you can use -A or -e to see the absolutely complete list of all processes currently running. This list includes processes that are not associated with a terminal (such as daemons).

rm The rm command can be used interchangeably with the rmdir command. This removes files and directories. Usage is:

rm <file/directory name(s)>

If you are removing multiple files or a directory you will be asked to confirm each file. E.g.,

$ rm foo*txt rm: remove `foo.txt'? y rm: remove `foobar.txt'? y

Enter “y” for yes and “n” for no. This is intended to prevent accidental deletions, but it can be irritating and time-consuming if you are trying to delete several files. You can use the –f flag to remove all files without prompting.
You must have write permissions to the file(s) you are trying to remove.

sed This is an editing utility: the name is an abbreviation of "stream editor." It reads one or more text files and edits them according to your instructions. This is useful if you need to make a global change to several documents (such as a search and replace). The command looks at each line of the input files, copies it to an internal buffer (called a "pattern space"), applies the editing commands to the line (if appropriate), and prints the output to either the command line or to a file. Note that the output does not overwrite the original input files since sed is working in the pattern space.
You can give the editing instructions on the command line or in a separate script. You can tell it to search for lines with particular patterns. For example, you can look for all lines containing the word "automobile" and then replacing that word with the "car." Or to print all lines that between the words "START" and "END".

Unix in a Nutshell has a chapter devoted to sed and is reasonable place to start. If you want to start writing serious scripts you can also look at IATH's copy of sed & awk (another O'Reilly book), which also has some useful information about using regular expressions (part of pattern matching).

ssh Open a secure shell to another server. To use it, type ssh plus the name of the server. You will be asked for a password. To exit shell, type exit.

su Change user ids without having to log out. Your user id is the name you are logged in as. You might need to change to another user if you want to work with files that you don’t have permission to use. You’ll be asked for a password for the new id.

tar Copy files and directories to a single file, called a “tarfile”. (Tar originally meant “tape archive” and was used to archive files.) You use the same command to open a tarfile. If you are tarring a directory with subdirectories, the file structure will be preserved in the tarfile. Note that when you open the file it will copy the structure into the file space where the tarfile is located.
The tar command has several options, which are described in full in the man page and the Unix in a Nutshell book. it is frequently used with the zip command, which compresses the file to a more manageable size. For best results, use the following syntax to create a tarfile:

$ tar -cvf <filename>.tar <file/directory name>

This creates a file called <filename>.tar. It does not delete the original file or directory. You now have a tarfile, but it is probably rather large (especially if you tarred an entire directory). You can use zip to compress the tarfile:

$ zip <filename>.tgz <tarfile name>

The .tgz suffix indicates that this a tarred and zipped file. To unzip and untar the file, use this syntax:

$ unzip <filename>.tgz $ tar -xvf <tarfile name>

This will extract and copy the contents of the tarfile. It will retain its same naming structure. The .tgz and .tar files are not deleted, but must removed by hand.
Tarfiles are a convenient form for moving directories and large sets of files via ftp, Fetch, etc. You can open them on Windows and Mac machines with the proper applications (e.g., WinZip).

whatis The whatis command displays a one-line summary of any documented Unix command (i.e., any command that has a man page). For example,

$ whatis ls cp cp (1) - copy files

whois This is a UVa directory service for getting information about UVa users. If you enter a user id it will print out information from the UVa database. For example:

$ whois spw4s Name: Sarah P. Wells Mailid/Handle: spw4s Unix Uid: 23304 Classification: Staff Department: Rs-Inst Adv Tech Humanities Department Address: P.O. Box 400115, Alderman Library Charlottesville, VA 22904-4115 Office Phone: (434) 924-4527 Registered E-Mail Addr: spw4s@Virginia.EDU spw4s@jefferson.village.virginia.edu

If you don’t know the person’s user id you can provide part of the name:

$ whois jessee Jessee, Andrea L. (alj3e) Undergrad UVa College at Wise Jessee, Christopher D. (cj8n) Staff Rs-Inst Adv Tech Humanities Jessee, Danny Ray, jr. (drj5y) Undergrad School Of Engineering Jessee, Hazel H. (hhj8d) Faculty Cp-Hampton Rds Ctr Jessee, Sheena Lynn (slj4b) Undergrad UVa College at Wise

4.9. File naming

Windows and Mac operating systems allow a great deal of flexibility in naming files. Users are allowed to use very long filenames with characters such as “!” and “#”, and to have files without a suffix that identifies the file’s type (i.e., “.txt” or “.jpg”). While this may seem convenient, it is not a good idea and can cause you to lose data. If you move files with Fetch or FTP, the applications may balk at non-alphanumeric characters and may corrupt the file. Unix operating systems do not like file name with spaces in them (although they allow files names of up to 250 characters). Applications often don’t recognize files that don’t have the proper suffix, even if the file is in fact the proper type.

To make your life easier, please observe good practice and name your files in the following form. Use a name of less than 20 alphanumeric characters and a suffix of 3 characters that indicate the file’s type.

Note that in some cases (with CD-burning software, for example) you may need to change your filenames to fit a format of no more than 8 character name with a 3 character suffix.

If you need to work with a file with spaces in its name in Unix and you don’t want to rename it, you can enclose the file name in double quotation marks:

$ ls –l “my file about stuff.doc”

It is a VERY good idea to avoid random naming patterns, such as “n_12453_48287634.gif”. Not only is this kind of name awkward to work with, it reveals nothing about the file. You will be much better off using a descriptive name like “menu_mainheader.gif” or “sonnets_1850.xml”.

4.10. FTP

File Transfer Protocal (FTP) is a common method of transferring files between your host server and another client host server. You will probably be using it regularly to upload and download files so you should consider the various methods available. First, you open a connection to the client host (such as jefferson). Then you can use the get and put commands to move files between the two servers.

4.10.1. Command line

You can start an FTP session from a DOS or Unix command line with the ftp command. The usage is:

ftp <server name> [port number]

You be asked for a user id and password. When you have successfully connected you will see “ftp>” at the command line. It might look something like this:

$ ftp jefferson.village.virginia.edu 
Connected to jefferson.village.virginia.edu. FTP server 
(Version wu-2.6.0(1) Wed Oct 20 09:55:43 EDT 1999) ready. 
Name (jefferson.village.virginia.edu<none>): jmu2m 
331 Password required for jmu2m. Password: xxxxxx 
230 User jmu2m logged in. 
ftp>

There are several commands that you can run in an ftp session. To see them all, type help after you have started a session. Note that a session may time-out after a given period of time, in which case you need to type quit and then start a new session.

The most important commands are put and get (Figure 3):

The put command copies files from your local server onto the client host.

The get command copies files from the client host onto your local server.

Figure 3

To use either one of these command, you’ll need to know the name of the file(s) you want to put or get. You’ll also need to know whether or not the file is a binary or ascIV file. Binary files include image files and .exe files, and your session must be set to binary mode. AscIV files are text-based files, such as .txt or .pl files, and your session must be set to ascIV mode. A new session is set to ascIV mode. To change over to binary mode, type bi or binary. To go back to ascIV, type ascIV. Now you can run get or put to move your file:

 ftp> put foo.txt

You can get and put multiple files with the mput and mget commands. For example, to copy all .txt files to the client host, you would type:

ftp> mput *.txt

A session starts in the home directory of the user id you used in the client host and the current directory of your local host. Type pwd (present working directory) to see the full path of the remote directory. To see the contents of the remote directory in the client host, type ls. To see the full contents of the remote directory type dir (it’s the equivalent of ls –l). To move to a different remote directory, use cd:

ftp> cd /mydirectory/stuff

To change your local directory, use lcd instead of cd. You can also use mkdir to create a new directory on the remote host:

ftp> mkdir newdirectory

And rmdir to remove a directory:

ftp> rmdir newdirectory

To exit an ftp session, type quit.

4.10.2. Windows

There are several Windows-based FTP applications available, all of which have their own interfaces. WS_FTP comes with the Windows installation, and is reasonably acceptable (and free) so you should feel free to use it. You can download it and get documentation from ITC's web site. WS_FTP uses the same commands as the command-line version but in a graphical user interface, so if you have never used FTP before, you may want to read through the description of the command-line version, above, to become familiar with it.

4.10.3. Mac

The predominant Mac FTP application is Fetch. It also has its own documentation and user help. You can download Fetch for free and get information about using it on the ITC web site. Please note that if you configure it yourself you should set it to a secure connection. If you have any questions, please talk to an IATH staff member.

Table of Contents

1. Administrative info

2. Getting started

3. Funding

4. Technical info

1. ADMINISTRATIVE INFO

1.1. IATH Staff and hours