I was born in Costa Rica, the happiest country in the world, yes the the “Pura Vida” country!
After graduating from high school, I went to México to pursue my Computer Engineering degree which I completed in 1973.
After a year of “thinking” I decided to go back to school and finished my MS degree in Information and Computer Science at Georgia Tech in 1976.
Upon my return to Costa Rica I worked at the recently created Instituto Tecnológico de Costa Rica (ITCR). During my stay at ITCR, as founder and Director of the Computer Center (wow this sounds old...) I also contributed with the establishment of the Computer Science Department (now recognized as one of the best in the country).
In 1980 I received a Fulbright Scholarship and headed to the University of Texas-Austin, where I finished my PhD work in 1983. I then spend 3 years as a faculty member in the Department of Computer Science at the University of Kansas. In 1987 I accepted a faculty position at WFU. I have been here since, many many wonderful years!
Study of computer system mechanisms supporting program execution, with a focus on process and resource management. Topics include process control, virtual memory, concurrency, parallelism, file-based and network-based I/O, and additional coverage of system-level programming
An operating system presents common interfaces for programmers to perform various tasks such as I/O, memory management, concurrent process and threads. We will explore this interfaces and will write programs to illustrate all of this services.
Even though no particular operating system will be studied in detail, the UNIX operating system will be used as an example. UNIX was chosen because of its widespread use and it is a simple system to understand. The computer language C will be used, since most UNIX systems are written in this language so they provide a very clean interface to the services pr ovided.
Course Learning Objectives:
By the end of this course, students should be able to:
The concept of and mechanisms for controlling processes are the focus of extensive study, with additional coverage of signal handling and exceptional control flow.
The need for and general mechanisms to support virtual memory and address translation are studied, with a particular focus on paging. Mechanisms, such as translation look aside buffers and multi-level page tables, to improve the performance of paging are covered. Specific CPU architecture support for an OS implementations of paging are presented.
Concurrency and parallelism
Concurrent execution of processes is studied in-depth, with a particular focus on benefits of concurrent execution, such as improved performance on multi-CPU systems, as well problems, such as race conditions and deadlocks, that can arise from concurrent execution. Mechanisms to support correct concurrent execution, such as semaphores and monitors are presented. Threads and concurrency with threads are also introduced.
The computer language C will be used, since most UNIX systems are written in this language as it provides a very clean interface to its services.
A computer needs an operating system to manage resources and provide an interface between the hardware and the user. The operating system is a very complex software system. In this course we will examine the most important functions that make up an operating system. In particular we will discuss the following functions:
Students will select a project based on requests that been received from other departments. Each project will have a counterpart from the department requesting the development. Students will design the user interface and requirements in conjunction with the end-user counterpart. They will learn how to develop mobile Apps, based on IOS with Objective C and Swift. This will be done by them in a self study approach with the supervision of the instructor. Students will be assigned weekly readings and programming exercises and in parallel they will have weekly meetings with the end-user to analyze progress and the overall structure of the system.
There is an ever-increasing demand for speed when it comes to modern technology. There are many different approaches to achieving an increase in processing speed. One such strategy is called pipelining, in which a computational task is broken down into subcomponents called stages. Buffering is added between the stages so that once a set of inputs has made it to the second stage, a new set of inputs can be started at the first stage, and so on. This allows for multiple computations to be occurring at the same time in the pipeline, which leads to an increase in throughput. This study focuses on a floating point multiplier, a common application of a pipelined design because it offers tremendous speedups. Both a non-pipelined and a pipelined floating point multiplier were implemented in a program called LogicWorks, which is a tool for interactive circuit design. Running simulations of each of the circuits allowed for a side by side comparison of their speeds. Although the pipelined multiplier required more hardware, it offered significantly better throughput
To fully understand the conceptual principles behind operating systems it must be possible to 'see' what is happening inside the system as the execution of a task progresses. A graphic representation of information flow would give a clear picture of what is happening inside an operating system at every moment. This research presents a graphic representation of information flow inside an operating system, in particular the short term scheduler. This is done via an App developed for the iOS system.
The EZIPC library simplifies inter-process communication between concurrent processes for users. This allows users new to concurrency and inter-process communication to effectively learn about semaphores and shared memory without having to simultaneously manage the more complex system calls that these normally require. Semaphore tracing has been previously implemented to allow users to view the actions of their semaphores “post-mortem.” The goal of this project is to allow users to view, in real time, the actions of semaphores during program execution in a readable way. This involves implementing a way to suspend execution when a semaphore is used in order to allow to user to walk through the program step-by-step. This also involves designing an interface that provides the user with the most information possible at each step and presents this information in a readable way.
The University Calendar app is an attempt to make the Wake Forest University Calendar more accessible to students, faculty, staff, and the Winston-Salem community. The content is accessed through an API, and then displayed in an iPhone friendly user interface. The home screen is designed so that users can filter through the calendar content based on their specific needs. Category and date filters can be applied for this purpose. Detail views for each event make time, date, location, and description more quickly accessible.
The Wake Forest Parking mobile application provides all members of the Wake Forest community will real-time data on where they can park on-campus and how available the parking may be. By employing extensive GPS, mapping, and iOS functionality, the Wake Forest parking application provides a much needed service in a very sophisticated way.
As the population of students at our campus grows with each year the facilities that students use on a daily basis are starting to feel overcrowded. Our campus gym, the Miller Center, is no exception especially during certain hours of the day. In an attempt to lighten the frustration of students, the Cardio View iPhone application was developed. This application models a currently popular website, Laundry View, which gives students the ability to view the status of the laundry machines in each of the dorms. In a similar manner our application allows students to view the status of the cardiovascular machines at the gym, as a way to gauge how crowded the gym is prior to their arrival. We use external sensors on the equipment that broadcast data to a server. On the server we utilize a support vector machine which, based off of training data, decides if each machine is in use, as well as calculating how long it has been at that particular status. The application then downloads this data in real time, along with location based data, to create a map of the Miller Center with the machines colored based on their usage. In addition these machines are click able to show the user how many minutes they have been in use. We have many future plans to expand the project including but not limited to a web and android interface, and utilizing push notification to allow users to be notified when a machine becomes available.
The global Foreign Exchange market accounts for approximately $4 trillion in transactions daily. In recent years, this market has become dominated by high-frequency and algorithmic traders who profit from intra-day transactions and short-term price fluctuations. This paper will examine topics and strategies employed by modern currency traders, focusing particularly on the use of Statistical Arbitrage. These strategies will are implemented and tested in real time to examine the efficacy of commonly employed technical indicators and betting techniques.
The EZIPC library is used to simplify the implementation of interprocess communication in C and C++ programs written for System V Linux based machines. By reducing the number of complicated system calls and structures used needed for communication among concurrent processes, the learning curve is reduced, and students may better learn about the theories and practical applications of semaphores and shared memory blocks. However, EZIPC does not provide support for message queues, and there is no easy way to monitor the semaphores being used. This paper outlines a proposed solution, and discusses issues with implementing tracing functionality to EZIPC.
Nearly all modern operating systems used for personal computing are now based on monolithic kernels. By changing to a microkernel-based architecture, though, systems could dramatically improve reliability and security in the system at the cost of a small performance penalty. In this paper, the structure of microkernel based operating systems is described, through the kernel, driver, server, and application layers. Finally, the implementation of a microkernel server is shown, using MINIX 3 to implement a server that provides a semaphore service to user applications.