History of the South Asia Collection at the University of Pennsylvania Libraries
History of the South Asia Collection at the University of Pennsylvania LibrariesProf. Morton W. Easton, Professor of Comparative Philology (1883-1912), taught Sanskrit courses at the University of Pennsylvania. He had studied Sanskrit at Yale under W.D. Whitney (1827-1894). Upon completing his dissertation on the evolution of language, Easton was awarded the first American doctorate in Sanskrit in 1872. The University of Pennsylvania was one of the first American academic institutions to offer courses in Sanskrit; already during the 1880s, the university offered a major and a minor in Sanskrit. Easton retired in 1912 and was replaced the following year by Franklin Edgerton. After Edgerton left in 1926, W. Norman Brown was appointed in his place. Brown was responsible for the creation of the Department of South Asia Studies and expanded well beyond his own Indological interests. From 1916 to 1919, Brown had held the position of the Harrison Research Fellow at the University of Pennsylvania. He organized the American Oriental Society in 1926. By the summer of 1947 Brown's summer program, "India: A Program of Regional Studies" was being offered at Penn. In 1948, he established the Department of South Asia Regional Studies, the first area studies department in North America. Offerings continued to be expanded until a full program was available in the 1949-1950 academic year. He brought together a number of eminent scholars such as Holden Furber, Stella Kramrisch, and Ernest Bender, ensuring that the Department of South Asia Studies at Penn became, and continues as, one of the most important places in the world for serious research on South Asia in general and Sanskrit in particular. Scholars such as George Cardona, Ludo Rocher, Rosane Rocher, and Richard D. Lambert worked at Penn throughout their careers, and ensured a rich collection was developed for the libraries. W. Norman Brown was also responsible for helping to establish the well known PL 480 program which in its various permutations over the decades supplied us (and many other institutions) with literally hundreds of thousands of volumes from South Asia. During the course of the PL 480 program from 1954 to 1998, the library acquired material actively through the Library of Congress field offices (New Delhi and Islamabad), and also through various vendors in South Asia, Europe and North America. Since 2013, the South Asia Librarian also manages acquisitions from the Library of Congress Field Office in Jakarta. The Library of Congress still continues as a major vendor to supplement the activities of collecting all material including monographs, serials, film, and digital formats. Because of the history of the University of Pennsylvania Museum in the field of archaeology, the Penn Libraries also have one of the largest collection of material for archaeology in South Asia. The American Institute of Indian Studies (AIIS) was founded by W. Norman Brown, and it operated out of the Van Pelt Library till it moved to its present location in Chicago. Since 1958, the University of Pennsylvania has had a Title VI National Resource Center for South Asia (South Asia Center). In 1992, the Center for Advanced Study of India (CASI) was launched. The two centers and the Department of South Asia Studies are supplemented by faculty with interests in South Asia, in various departments and schools across campus such as Anthropology, Architecture, Comparative Literature, Economics, Education, English, History, History of Art, Political Science, Religious Studies, and Sociology.â â â â â âShared librariesA shared library or shared object is a file that is intended to be shared by executable files and further shared object files. Modules used by a program are loaded from individual shared objects into memory at load time or runtime, rather than being copied by a linker when it creates a single monolithic executable file for the program. Shared libraries can be statically linked during compile-time, meaning that references to the library modules are resolved and the modules are allocated memory when the executable file is created. But often linking of shared libraries is postponed until they are loaded.[dubious - discuss] Most modern operating systems[NB can have shared library files of the same format as the executable files. This offers two main advantages: first, it requires making only one loader for both of them, rather than two (having the single loader is considered well worth its added complexity). Secondly, it allows the executables also to be used as shared libraries, if they have a symbol table. Typical combined executable and shared library formats are ELF and Mach-O (both in Unix) and PE (Windows). In some older environments such as 16-bit Windows or MPE for the HP 3000 only stack-based data (local) was allowed in shared-library code, or other significant restrictions were placed on shared-library code. Memory sharingLibrary code may be shared in memory by multiple processes, as well as on disk. If virtual memory is used, processes would execute the same physical page of RAM that is mapped into the different address spaces of the processes. This has advantages. For instance, on the OpenStep system, applications were often only a few hundred kilobytes in size and loaded quickly; the majority of their code was located in libraries that had already been loaded for other purposes by the operating system. Programs can accomplish RAM sharing by using position-independent code, as in Unix, which leads to a complex but flexible architecture, or by using common virtual addresses, as in Windows and OS/2. These systems make sure, by various tricks like pre-mapping the address space and reserving slots for each shared library, that code has a great probability of being shared. A third alternative is single-level store, as used by the IBM System/38 and its successors. This allows position-dependent code, but places no significant restrictions on where code can be placed or how it can be shared. In some cases different versions of shared libraries can cause problems, especially when libraries of different versions have the same file name, and different applications installed on a system each require a specific version. Such a scenario is known as DLL hell, named after the Windows and OS/2 DLL file. Most modern operating systems after 2001 have clean-up methods to eliminate such situations or use application-specific "private" libraries. Dynamic linkingDynamic linking or late binding is linking performed while a program is being loaded (load time) or executed (runtime), rather than when the executable file is created. A dynamically linked library (dynamic-link library, or DLL, under Windows and OS/2; dynamic shared object, or DSO, under Unix-like systems) is a library intended for dynamic linking. Only a minimal amount of work is done by the linker when the executable file is created; it only records what library routines the program needs and the index names or numbers of the routines in the library. The majority of the work of linking is done at the time the application is loaded (load time) or during execution (runtime). Usually, the necessary linking program, called a "dynamic linker" or "linking loader", is actually part of the underlying operating system. (However, it is possible, and not exceedingly difficult, to write a program that uses dynamic linking and includes its own dynamic linker, even for an operating system that itself provides no support for dynamic linking.) Programmers originally developed dynamic linking in the Multics operating system, starting in 1964, and the MTS (Michigan Terminal System), built in the late 1960s. OptimizationsSince shared libraries on most systems do not change often, systems can compute a likely load address for each shared library on the system before it is needed and store that information in the libraries and executables. If every shared library that is loaded has undergone this process, then each will load at its predetermined address, which speeds up the process of dynamic linking. This optimization is known as prebinding in macOS and prelinking in Linux. Disadvantages of this technique include the time required to precompute these addresses every time the shared libraries change, the inability to use address space layout randomization, and the requirement of sufficient virtual address space for use (a problem that will be alleviated by the adoption of 64-bit architectures, at least for the time being). Locating libraries at runtimeLoaders for shared libraries vary widely in functionality. Some depend on the executable storing explicit paths to the libraries. Any change to the library naming or layout of the file system will cause these systems to fail. More commonly, only the name of the library (and not the path) is stored in the executable, with the operating system supplying a method to find the library on disk, based on some algorithm. If a shared library that an executable depends on is deleted, moved, or renamed, or if an incompatible version of the library is copied to a place that is earlier in the search, the executable would fail to load. This is called dependency hell, existing on many platforms. The (infamous) Windows variant is commonly known as DLL hell. This problem cannot occur if each version of each library is uniquely identified and each program references libraries only by their full unique identifiers. The "DLL hell" problems with earlier Windows versions arose from using only the names of libraries, which were not guaranteed to be unique, to resolve dynamic links in programs. (To avoid "DLL hell", later versions of Windows rely largely on options for programs to install private DLLs-essentially a partial retreat from the use of shared libraries-along with mechanisms to prevent replacement of shared system DLLs with earlier versions of them.) Microsoft WindowsMicrosoft Windows checks the registry to determine the proper place to load DLLs that implement COM objects, but for other DLLs it will check the directories in a defined order. First, Windows checks the directory where it loaded the program (private DLL); any directories set by calling the SetDllDirectory() function; the System32, System, and Windows directories; then the current working directory; and finally the directories specified by the PATH environment variable. Applications written for the .NET Framework framework (since 2002), also check the Global Assembly Cache as the primary store of shared dll files to remove the issue of DLL hell. OpenStepOpenStep used a more flexible system, collecting a list of libraries from a number of known locations (similar to the PATH concept) when the system first starts. Moving libraries around causes no problems at all, although users incur a time cost when first starting the system. Unix-like systemsMost Unix-like systems have a "search path" specifying file-system directories in which to look for dynamic libraries. Some systems specify the default path in a configuration file, others hard-code it into the dynamic loader. Some executable file formats can specify additional directories in which to search for libraries for a particular program. This can usually be overridden with an environment variable, although it is disabled for setuid and setgid programs, so that a user can not force such a program to run arbitrary code with root permissions. Developers of libraries are encouraged to place their dynamic libraries in places in the default search path. On the downside, this can make installation of new libraries problematic, and these "known" locations quickly become home to an increasing number of library files, making management more complex. Dynamic loadingDynamic loading, a subset of dynamic linking, involves a dynamically linked library loading and unloading at runtime on request. Such a request may be made implicitly or explicitly. Implicit requests are made when a compiler or static linker adds library references that include file paths or simply file names. Explicit requests are made when applications make direct calls to an operating system's API. Most operating systems that support dynamically linked libraries also support dynamically loading such libraries via a run-time linker API. For instance, Microsoft Windows uses the API functions LoadLibrary, LoadLibraryEx, FreeLibrary and GetProcAddress with Microsoft Dynamic Link Libraries; POSIX-based systems, including most UNIX and UNIX-like systems, use dlopen, dlclose and dlsym. Some development systems automate this process.