This section of my portfolio comprises selected programs and documents that 
I have written in the course of my undergraduate education and internships.


Note:	Most of these zip files have been created to retain relative 
paths or folder hierarchy.  Since many folders contain files by the 
same name (like a readme.txt file), it is essential that if you unzip 
a file with more than one program, that you retain the folder hierarchy.
	For Example: 
	If you are using Norton Utilities File Manager, click the 
	"Use Stored Folders" option.  If you are using the WinZip 
	Utility, click the "Use Folder Names" option.


You have 3 different download options:

1) Download one .zip file containing the portfolio: 
   bmc_ungr_portfolio.zip
 
2) Download .zip files containing the 3 sections of my portfolio:
	
		bmc_code.zip
			- programs written in various languages

		bmc_docs.zip
			- technical documents and projects

		bmc_design.zip
			- design documents and presentations

 
If you download these files, unzip them to a directory that you 
have created for this purpose.

	The bmc_code.zip will create the directories structured as 
	follows:
		C_Code/
			BSTree_23Tree/
			CannyEdge/
			HashTables/
			HoughTransformer/
			HuffmanCode/
			MarrHildrethEdge/
			NFAtoDFA/
			OperSyst/
				data/
				given/
			Shapes/
			SysPass1/
			SysPass2/

		C++_Code/
			Atlantis/
			QuickPick/
						
		Java_Code/
			(under construction)

		Lisp_Prolog/					
				

	The bmc_docs.zip and bmc_design.zip have less directory 
	structure.  When you unzip these files they will create 
	the directories respectively:

		Bmc_Design/
		Bmc_Docs/
	
* See the Scenario 3 Description for full descriptions of the 
  contents of each directory.	

3) Download the individual programs or documents:

	Bmc_Code/
		C_Code/		
				bst_23t.zip
				canny.zip
				hashing.zip
				hough.zip
				huffman.zip	
				marrhild.zip
				nfa2dfa.zip
				opersyst.zip
				shapes.zip
				sys_pass1.zip
				sys_pass2.zip	

		C++_Code/
				atlantis_code.zip	
				quickpick_code.zip	
				quickpick.exe	

		Java_Code/
				(under construction)

		Lisp_Prolog/		
				lisp.zip
				prolog.zip
				
	Bmc_Design/
				dynamic.zip
				functional.zip
				object.zip
				seng_pres.zip

	Bmc_Docs/
				 
				atlantis_prj.zip				
				dev_plan.zip
				req_specs.zip
				vision_prj.zip
				
	
Scenario 3: Descriptions - Individual programs, documents and design:

	Again if you unzip these files choose to retain the stored 
	folders or paths option in your zip utility, they will create  
	a separate directory for each .zip file because most of them 
	contain a readme.txt file with instructions for compiling 
	and input.  A separate directory for each file avoids 
	overwriting an existing readme.txt.

C_Code/ files:	

	bst_23t.zip
		This program investigates two different tree 
		structures:  the Binary Search Tree (BST) and the 
		Two-Three Tree (TTT).

	canny.zip
		This program uses the Canny method of smoothing to 
		create the difference operator used for convolution 
		with the image.  This is the magnitude of the gradient 
		and this data is the first outputted image. Then 
		candidates for edges are detected by looking for 
		peaks in the direction of the gradient.  This data 
		is the second image that is outputted.  Then using 
		this candidate array and the first image data and 
		two threshold values, a final image is created with 
		only the candidates that are above the high threshold 
		or connected to a candidate above the high threshold.  
		The output for this program is 3 files: the magnitude 
		image, the candidate image and the final image.  This 
		is in the raw data form.  You can use a graphics 
		application like PaintShopPro to convert it to a 
		.pgm file (256 x 256).  (input files provided)
		
	hashing.zip
	   	This program investigates hash tables. Two methods 
		will be compared.
		An open hash table:   Table size is to be the largest 
		prime number less than 2000.  Collision resolution 
		will be handled by simple linked lists.  Array will 
		contain pointers to nodes and nodes will be structs 
		with integer data and a nextNode pointer. The hash 
		function will be simple, x hashes to x MOD the 
		chosen prime.  
		A closed hash table:  Array sizes chosen as above 
		with ~1000 extra slots for the overflow.  Bin size 
		should be 5 with collisions handled by circling 
		through the bin and then going to the sequential 
		overflow area. (input files provided)

	hough.zip
		This program implements the Hough Transformer for a 
		specific input.  It fits the edges in this input to 
		a linear parametric equation.  The first output is 
		the canny image that was read in is input. The second 
		output is the strongest line found in the canny 
		image.  The third output is both the second and third 
		strongest lines in the canny image. 
		(input files provided)

	huffman.zip		
		This program uses the Huffman code algorithm to 
		compress a file. 
		The encode portion creates a frequency table and a 
		huffman tree using a heap for the implementation to 
		encode a file to an intermediate file, and outputs 
		two final files - .tre and .cod: the .tre is the 
		frequency table information and the .cod is the 
		coded file converted to bits for compression.  
		The decode portion takes the two files generated by 
		encode.c:  creates a frequency table, a huffman tree 
		using a heap for the implementation, decodes the 
		.cod file to a intermediate file of chars, and then 
		decode the intermediate file; it outputs a final 
		text file which should match the original file given 
		to encode.c. (input files provided - but this should
		work on any text file)
   	
	marrhild.zip
  		This program detects the edges of an image.  It uses 
		convolution and the Marr-Hildreth method of smoothing 
		(Laplacian of a Gaussian) to create the	difference 
		operator used for the image.  This convolution is the 
		first outputted image.  Then this convolution is 
		scaled and scanned for changes from positive to 
		negative - thus detecting an edge.  This is the 
		second image that is outputted.  The output for this 
		program is 2 files: the convolution image and the 
		positive to negative image.  This is in the raw data 
		form.  You can use a graphics application like 
		PaintShopPro to convert it to a .pgm file (256 x 256). 
		(input files provided)
	
	nfa2dfa.zip
		This program implements the Powerset Construction 
		for converting an arbitrary NFA to its equivalent 
		DFA in reduced form (only reachable states).  It 
		also provides a menu to chose "regular-preserving 
		operations" to perform on these constructed DFA's.
		(input files provided)
	
	opersyst.zip
		This is the code for my Senior Operating Systems
		Project.  It consists of 6 objectives and was written 
		to integrate into an event driven simulation.  The code 
		will not compile independently, but must be run with 
		symbolic links to the UCF simulator code, thus, no 
		readme.txt file has been provided with compilation 
		instructions.

		This project implements:
		(a) the fundamental data structures of an operating 
		    system;
        	(b) the basic flow of control within an operating 
                    system;
        	(c) the mechanism of context switching and 
		    interrupt handling;
        	(d) different resource allocation and management 
             	    algorithms in multiprogrammed operating systems;
 
		This project also provided experience implementing a 
		complex program, sharpened my good programming and 
		debugging habits and improved my programming 
		communication skills. 
		(The given code with which to integrate, data files, 
		 output and specs have also been provided.)
		
	shapes.zip
		This program uses the parametric equations for a 
		super ellipsoid to create shapes in 3 dimensions.  
		It also implements rotating, tapering, bending and 
		twisting equations.  The original image and the 
		image after each process are the outputs.  These 
		are in the raw data form. You can use a graphics 
		application like PaintShopPro to convert it to a 
		.pgm file (256 x 256).

	sys_pass1.zip
		Implements pass-1 of an assembler.
		(assembly & other input files provided)

	sys_pass2.zip	
		Implements pass-1 of an assembler.	
		(assembly & other input files provided)


C++_Code/ files:

	
	atlantis_code.zip	
		This is the source code for an Object Oriented game 
		called "Crystals of Atlantis".  
		It demonstrates the design and implementation of an 
		object oriented system in C++.  Specifically the 
		system exemplifies the following Object Oriented 
		Programming (OOP) principles:
			1. Modular Design and Classes 
			2. Encapsulation and Information Hiding 
			3. Polymorphism and Function Overloading 
			4. Stream Operations 
		Full documentation for this project including code and 
		metrics is also located in the "Documents/ files:" 
		section of this portfolio
		

	quickpick_code.zip
		This is the source code for an application that 
		implements picking lottery numbers for chosen play 
		slips.  It is based on the Florida Lottery system 
		and the user will need some knowledge of the different 
		play slips available.  
		
		The object of this main executable is to provide a 
		lottery player with a program to select their lottery 
		numbers; the result is much the same as a "quick pick" 
		choice on a play slip, but more fun! The main file was 
		written as an enhancement to the midterm specifications.  

		The source code has been written in ansi C++ and uses 
		object oriented design.  Future revisions of this 
		simulation could explore inheritance from the LottoMachine
		Class. 			
		
	quickpick.exe	
		This is the executable file for the QuickPick program.
		Runs under Windows 9X-Me.	
	

Java_Code/ files:
	(under construction)

	
Lisp_Prolog/ files:

	lisp.zip
		A collection a lisp functions.
		(Download the free LISP program from my "download" 
		 link.)

	prolog.zip
		A collection a lisp functions.
		(Download the free PROLOG program from my "download"
		 link.)


Design/ files:	(I made this a separate section because these 
		documents are focused on design and presentation.) 

	dynamic.zip
		General Program Comparator Dynamic Model Design. 
		(MS PowerPoint 95/97 .ppt file)

	functional.zip
		General Program Comparator Functional Model Design. 
		(MS PowerPoint 95/97 .ppt file)

	object.zip
		General Program Comparator Object Model Design. 
		(MS PowerPoint 95/97 .ppt file)

	seng_pres.zip
		Software Engineering Final Presentation.
		(Creative MS PowerPoint 95/97 .ppt file  ~ 2.3 MB)


Documents/ files:

	The documents in this folder are technical documents from 
	my Software Engineering Project to create a General Program 
	Comparator.  This is a design for a generic program that 
	will analyze (compare) two given programs, both written in 
	Turbo Pascal programming language, to determine their 
	"degree of similarity."   Degree of similarity will be based 
	on the number of occurrences of identical instances of 
	certain pre-defined programming features appearing in a pair 
	of programs being compared.  


	atlantis_prj.zip
		Object Oriented game "Crystals of Atlantis" 
		Full project documentation 
		(C++ Senior Project - MS Word 95 .doc file)	

	dev_plan.zip
		General Program Comparator Software Development Plan 
		document. (MS Word 95 .doc file)

	req_specs.zip
		General Program Comparator Software Requirements 
		Specifications document. (MS Word 95 .doc file)

	vision_prj.zip
		Vision System for Detecting Cat Behavior
		(Senior Vision Project - MS Word 95 .doc file)