MUSTAFA ILHAN'S CLASS PROJECTS AT CSU, CHICO
•
OBJECT ORIENTED PROGRAMMING PROJECTS
- Class schedule tool: Implemented an object-oriented C++ program called schedtool which generates index files
either on RAM or secondary storage that contains information about the classes, instructors, building, room
number etc. about the courses offered each semester on campus. Using these index files, the program can process
various queries, such as; basic information of the course, listing all courses taught by a particular professor, all
courses offered by a department and so on. Later, extended the schedtool program to facilitate a crude form of
advising by using the graph class in the C++ STL. Depending on a student's major, course prerequisite chart, list
of courses the student has taken, and a set of schedule files, the schedtool program has the capability to
recommend a list of courses that a student can choose from to register for. The program was developed on SunOS
5.8 (Unix) platform using GNU g++ compiler.
- Implemented a C++ object-oriented program to simulate the operation of a store. The input data for the store is
read from an external file. There are two checkers in a store that handle the customers and there's a line in the
check out area to be used by customers if the two checkers are busy. The line in the checkout area is constructed
with an unbounded queue using pointers. The store is represented as a class and the checkers, the customer array
and the queue are the data members of the class. Each customer arrives to the checkout area at a specific time and
has a specific transaction time provided in the data file. The program reports all actions taken by customers, such
as the arrival to the line/checkers, departure and so on. The store closes if all customers are checked out and time
is greater than 50. Program was developed on SunOS 5.8 (Unix) platform using GNU g++ compiler.
- Implemented a C++ object-oriented program that will check for the balance of open and close brackets against
each other in a given file to the program as an argument. This is a very simple version of a compiler, but it only
checks the open-close brackets. In order to implement the program the C++ STL vector is used to contain each
line of the program as data field and stack class to hold characters as data. The whole compiler is represented as a
class and the vector and the stack is the data members of the class. After the execution, the program reports
whether the file successfully compiles (has matching brackets) or not. Program was developed on SunOS 5.8
(Unix) platform using GNU g++ compiler.
- Implemented a C++ object-oriented program that represents a simple line editor (like Unix line editor ed) that
can run on Unix platform or a terminal emulator program like cygwin. The lines in the text file are linked to each
other using a doubly-linked list which is an ADT. The user can either edit an existing file or create a new file.
When the program runs, it prompts the user with the available command options, and the user can enter new
lines, advance the line pointer in the buffer to move back and forth between lines and display all the lines (the
whole file), delete lines and quit the editor program. Right before the program quits, it writes all the lines in the
buffer (this is the data portion of the doubly-linked list) to the external file. Program was developed on SunOS 5.8
(Unix) platform using GNU g++ compiler.
- Implemented a C++ object-oriented program that simulates a fictitious library. The data such as, the catalog
number, title, author and the status of the book is read from an external file upon the startup of the program. All
the books in the library are represented in the C++ class catalog and each book as a struct. Once the program data
is read, the user is prompted to enter a command to query the library database. The user can also check out and
return books. User is prompted to enter commands until she decides to quit the program. Program was developed
on SunOS 5.8 (Unix) platform using GNU g++ compiler.
- Java Peer to Peer Instant Chat application: Participated in a group project that developed a J2ME chat
application that can run on multiple platforms like desktop/laptop computers and mobile devices such as PDA.
The application, installed on each device, maintains a buddy list that represents other users to establish a live
page 1 of 4
chat. There is an external server called DServer that the devices can connect and ask for each buddies' IP address.
If the IP address of the buddy is found on the DServer, the device can attempt to connect the other buddy's device
directly. When a device makes a query for a buddy at the DServer, if the device's IP is not yet “registered” in the
DServer database, it is entered as a new row, or if the IP address is different than the existing one, then the IP
address of the device is updated. This way, since most IP addresses today are assigned dynamically, the latest IP
address of the device will be maintained on the DServer.
My part for the group project was to develop the DServer and the client modules on the chat devices to
make the queries for establishing the connection. I also handled the code for file I/O when the devices are turned
on and off. My part of this Java program was developed on Windows machine using Cygwin terminal emulator,
and on Unix platform using JDK javac compiler.
- Library Management System: Implemented an object-oriented Java GUI application that represents a simple
library. The application reads the data from external files that have serialized objects, or it can start from scratch.
The librarian (user) can add/remove books or add/remove patrons to the library and check in, check out books.
When the librarian decides to shut down the system for the day, all data is stored by serializing the objects to
external files. The program was developed on Windows platform using cygwin terminal emulator and compiler
was jdk 1.5 javac.
- Implemented a C++ object-oriented application called appbook. It represents an appointment book that
organizes the appointments for the user. The program reads the existing appointments from an external data file
or it can start from scratch if no file is provided on command line. Upon start of the program, it prompts the user
some commands and the user can continue processing these commands until it quits the appbook. The user can
create new appointment for a specific date and time, cancel an existing appointment or change its description or
date and time; the user can check the appointments for a specific day and so on. When the program quits it stores
all the appointments to an external file, so that the next time it can start the last version of the appbook. Program
was developed on Windows platform with cygwin terminal emulator using GNU g++ compiler.
- Implemented a C++ object-oriented application called Tunes Archive, that stores and manages CD collections
for the user. The program reads its data from an external file and upon termination writes back to the file. The
user can add new music collections, CD's; display some statistics from the collections, remove items from
collections and so on. Program was developed on Windows platform with cygwin terminal emulator using GNU
g++ compiler.
•
UNIX SYSTEMS / NETWORK PROGRAMMING PROJECTS
- Unix file transfer utility: Implemented a socket based Unix network utility called rcp, that can remotely copy
files and directories over the network from one server to another, and can process multiple requests concurrently
by using POSIX threads. Developed own network protocol to be used in network communication. The processing
occurs recursively, so if there are directory structures within a single directory, the whole directory structure is
processed from top to bottom. Program was developed using C language; and it was developed on SunOS 5.8
(Unix) platform using GNU gcc compiler.
- Fictitious Fast Food shop: Implemented a multi-threaded simulation using semaphores to synchronize the
POSIX threads that represent the customers and employee in a fast food shop. Two employee are trying to accept
and process the orders of the customers which come to a fast food shop and leave after they receive their order.
Since only 2 employee have to deal with multiple customers at the same time, -in which case, there are usually
more than 2 customers in the shop and some are waiting in line-, semaphores were utilized in order to
synchronize the simulation; that is, an employee will perform a task and after finishing it, she will move to
another task in order to satisfy all customers' needs fairly. Program was developed using C language on SunOS
page 2 of 4
5.8 (Unix) platform using GNU gcc compiler.
- Peer to peer instant chat: Implemented a client-server chat program using connectionless UDP communication.
The server UDP program runs on the host and waits for messages on a port. The client program sends messages
to that port number on host the server stub is running. No connection is established in the communication and it is
asynchronous, which means, both sides are not required to work in lock-steps. Once the client sends the first
message, the server gets to know the client and can send back messages. Program was developed using C
language on SunOS 5.8 (Unix) platform using GNU gcc compiler.
- Implemented a simplified version of the internet super-server inetd, which supports TCP services only. inetd
listens on several ports for service requests from various connections from the same host or other hosts.
Implemented also some basic services, such as; display the current users on server, generate characters, service
that outputs the date and time on the server and so on. When a request is made from client side for a service from
server, inetd listens and accepts the incoming request on the matching socket and forks a new child that will
handle the request. Program was developed using C language on SunOS 5.8 (Unix) platform using GNU gcc
compiler.
- Implemented a simple socket-based client and server program, which the server will check whether the data sent
by the client is “out of bound” data or not. The client can be executed on the same host the server is running or
from a different host. When the server starts running, it will listen on a specific port for incoming connections.
The client establishes connection with the server specifying the host name and the port. Once the connection is
established between client and server, the client sends regular and out-of-bound data that the server checks the
data and prints out the data, its byte length and whether it's OOB data. Program was developed using C language
on SunOS 5.8 (Unix) platform using GNU gcc compiler.
- Implemented a simple Unix interactive shell program called fish (Fantastically Insane Shell) which works
similar to the common Unix shells. fish is also able to execute programs in the background like ksh and reports
the user when the background process finishes execution. Program was developed using C language on SunOS
5.8 (Unix) platform using GNU gcc compiler.
- Multi-thread bridge simulator: Implemented C++ program, using POSIX threads, that simulates car traffic on a
two-lane north-south road that contains a bridge. The cars travel from north to south or vice-versa. The bridge on
the road has only one lane, which means there can only pass one car at time towards one direction. In order to
prevent accidents on the bridge, there are 2 traffic lights on both ends of the bridge that will synchronize the
traffic. The program simulates the traffic lights and the cars crossing the bridge. The cars can take random amount
of time over the bridge and there can be more than one car passing the bridge at a time, as long as they travel the
same direction, but the cars cannot pass each other. Northbound and southbound cars are specified by the user
running the program. Semaphores were used to represent the two traffic lights to synchronize the car threads.
Program was developed using C++ language and it was developed on SunOS 5.8 (Unix) platform using GNU
g++ compiler.
- Implemented a simple Unix shell program called shell that can process Unix pipelines and file redirections
besides simple Unix commands. The shell can handle up to 100 commands piped together on one command line,
and each command can handle up to 100 arguments. Program was developed using C language on SunOS 5.8
(Unix) platform using GNU gcc compiler.
- Socket based chat program: Implemented a server based two person chat program using sockets for
communication. Once the server starts running on one host, it waits for two clients to establish connection and
after the connection is established and sockets are set up, the two clients can communicate each other through the
server. That is, the server receives the message from one client and passes it to the other, and vice-versa. The chat
page 3 of 4
is asynchronous, that is the client does not need to wait for a response before sending another message to the
other client. When one client closes the connection the other client terminates too. The server waits for two other
client chat users to establish new connection. Program was developed using C++ language on SunOS 5.8 (Unix)
platform using GNU g++ compiler.
- Implemented a rudimentary version of the Unix find utility using Unix system calls. Program recursively
searches for a given target in a directory tree specified by user and reports the pathname of the target if found.
Program was developed using C++ language and it was developed on SunOS 5.8 (Unix) platform using GNU
g++ compiler.
•
OTHER PROJECTS
- RMI (Remote Method Invocation) application: Implemented a simple client-server Java RMI application that
the client remotely executes Unix commands on server side and the server sends the results back to the client.
This is an interactive Unix command line application; the server starts executing and waits for requests from
client applications. The clients might be from the same host or different hosts over the network. The server can
handle only one client at a time. The program was developed on SunOS 5.8 (Unix) platform using jdk 1.5 javac
compiler.
- Implemented a C++ program called sortalgo, that compares the execution times of the sorting algorithms like
selection, insertion, bubble, exchange sorts for a given number of elements. Program was developed on SunOS
5.8 (Unix) platform using GNU g++ compiler.
- Database Design: Designed and implemented a functional database schema modeled on a fictitious library using
Relational Database. The database was built, populated, queried and modified manually using SQL statements on
Oracle 8i database server running at instructor's office. Later in the course, created custom forms, reports and GUI
for data input/output.
Mustafa Ilhan
E-mail: milhan@ecst.csuchico.edu
page 4 of 4