VB in Context Michael B. Spring Department of Information Science and Telecommunications University of Pittsburgh Pittsburgh, Pa Web: Voice: (412) Fax: (412)

The Value of History Unix 1980 Ethernet 1998 Wireless 1993 WWW 1994 Java C C/Basic 1999 Java Visual Basic 2002 VB.NET 1999 XML

Design Methodology and Language Capability Computer architecture constrains language design and language design constrains system design Some languages are better suited to different design methodologies Languages have evolved, in response to SAD needs –Data abstraction –Structure abstraction –Modularization –Componentization

Language Design Goals Language design goals originate with the software development process goals –Software must be reliable It must be “writable” (e.g. match to the problem) It must be readable (e.g. ability to follow logic) It must be able to deal with exceptions (e.g. trapping) –Software must be maintainable (e.g. constants) –Software must execute efficiently (e.g. automatic optimization)

Abstraction A programming language is an abstraction of the underlying processor and computer. A program is an abstraction of some problem The history of programming languages may be viewed as an effort to ever greater abstraction –Abstraction of data types –Abstraction of process structures –Abstraction of arbitrary data types –Abstraction of modules

Data Abstraction A byte is a byte is a byte –The problem of streams -- sockets –Big and little endian –Floating point variation – exponent and mantissa Structures and Unions –Type declaration –Variable declaration –Variable definition

Control Abstraction Basic computer control is provided with two simple mechanisms –Sequencing –Branching These mechanisms, in various forms are abstracted as: –Sequencing –Selection (single, double, and multiple) –Repetition (do/while, while, and for) Blocks of code are further abstracted as modules or subprograms

Selected Programming Concepts Variable scope and lifetime Weak and strong typing Early and Late Binding Recursion Multithreading Exception handling

Variables: Scope and Lifetime The scope of a variable is the range of program instructions over which a variable is known and over which it can be manipulated –Global static –Local static –Program dynamic The lifetime of a variable is the period of time over which its storage space is provided: –Static –Stack –Dynamic

Weak and strong typing Typing is the specification of the class of the allowable values of a variable. In C, typing is very weak and the contents of any particular memory location may generally be interpreted differentially –Booleans and ints –Addition of characters Weak typing generally allows implicit conversions Strong typing requires explicit cast or method based conversions

Early and Late Binding Binding refers to when the attributes (required for execution) of some object (variable or module) are set. Early binding generally means that these attributes are set at the time of compilation Late binding means that the attributes are set at time of execution

Recursion Recursion is a programming language feature that allows a module to invoke itself It is required that the algorithm have a recursion termination condition private static long factoral(long a) { if (a==1) {return 1;} else {return a*factoral(a-1);} }//factoral

Multiprocessing and Multithreading Modern OS allow for multiple processes and multiple threads within a process Processes –Share files and selected other objects –Do not share memory –Forking is the invocation mechanism Threads –Share memory and must be memory synchronized –Threads are very common in Java

Exception handling Exception handling has to do with the provision in a language for dealing with possible function failures –In C, return values of the functions are the mechanism used to handle exceptions –In Java, catch/try blocks and “exception throwing” are the mechanism General, system failures are handled by signals and signal handlers

WIMPS – A Programming Model WIMP interfaces are developed in a “sandbox” The sandbox is an event collector and dispatcher Objects within the sandbox are event generators –Objects form a hierarchy of containers and components –Objects are capable of generating different events Mouse action events Exposure events Change events Action events Code fragments are written to handle events and then registered

Common Elements of A User Interface Tookit Command Tools –Menus –Dialog boxes Selection Tools –Command buttons –Radio buttons –Check boxes –Text fields –Palettes and choosers Navigation Tools –Scroll bars –Hands –Murals/Maps Status Tools –Status bars –Cursors