Joystick position not appearing in inspector

I am using the C# translation of the Penelope joystick script, but the public vector2 position does not appear in the inspector. I will try accessing it from another script and see if the script can read it (which is my purpose). here is the script:

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;


public class Boundary
{
		public Vector2 min = Vector2.zero;
		public Vector2 max = Vector2.zero;
}


[RequireComponent(typeof(GUITexture))]
public class Joystick : MonoBehaviour
{

		public float JoystickPositionX;
		public float JoystickPositionY;

		/* Is this joystick a TouchPad? */
		public bool touchPad = false;
		/* In case the joystick is a touchPad, should its GUI be faded when inactive? */
		public bool fadeGUI = false;
		/* Control when position is output */
		public Vector2 deadZone = Vector2.zero;
		/* Normalize output after the dead-zone? */
		public bool normalize = false;
		/* Current tap count */
		public int tapCount = -1;

		/* The touchZone of the joystick */
		public Rect touchZone;

		/* Finger last used on this joystick */
		public int lastFingerId = -1;
		/* How much time there is left for a tap to occur */
		public float tapTimeWindow;
		public Vector2 fingerDownPos;
		/*
     * Currently unused.
    public float fingerDownTime;
    */
		public float firstDeltaTime;

		/* Joystick graphic */
		private GUITexture gui;
		/* Default position / extents of the joystick graphic */
		private Rect defaultRect;
		/* Boundary for joystick graphic */
		private Boundary guiBoundary = new Boundary();
		/* Offset to apply to touch input */
		private Vector2 guiTouchOffset;
		/* Center of joystick */
		private Vector2 guiCenter;

		private bool isFingerDown
		{
				get
				{
						return (lastFingerId != -1);
				}
		}

		public int latchedFinger
		{
				set
				{
						/* If another joystick has latched this finger, then we must release it */
						if (lastFingerId == value)
						{
								Restart();
						}
				}
		}

		/* The position of the joystick on the screen ([-1, 1] in x,y) for clients to read. */
		public Vector2 JoystickPosition {
				get;
				set;
		}

		public Vector2 position
		{
				get;
				private set;
		}


		public static string joysticksTag = "joystick";
		/* A static collection of all joysticks */
		public static List<Joystick> joysticks;
		/* Has the joysticks collection been enumerated yet? */
		public static bool enumeratedJoysticks = false;
		/* Time allowed between taps */
		public static float tapTimeDelta = 0.3f;


		public void Reset()
		{
				try
				{
						gameObject.tag = joysticksTag;
				}
				catch (Exception)
				{
						Debug.LogError("The \""+joysticksTag+"\" tag has not yet been defined in the Tag Manager.");
						throw;
				}
		}


		public void Awake()
		{
				gui = GetComponent<GUITexture>();
				if (gui.texture == null)
				{
						Debug.LogError("Joystick object requires a valid texture!");
						gameObject.active = false;
						return;
				}

				if (!enumeratedJoysticks)
				{
						try
						{
								/* Collect all joysticks in the game, so we can relay finger latching messages */
								GameObject[] objs = GameObject.FindGameObjectsWithTag(joysticksTag);
								joysticks = new List<Joystick>(objs.Length);
								foreach (GameObject obj in objs)
								{
										Joystick newJoystick = obj.GetComponent<Joystick>();
										if (newJoystick == null)
										{
												throw new NullReferenceException("Joystick gameObject found without a suitable Joystick component.");
										}
										joysticks.Add(newJoystick);
								}
								enumeratedJoysticks = true;
						}
						catch (Exception exp)
						{
								Debug.LogError("Error collecting Joystick objects: "+exp.Message);
								throw;
						}
				}

				/* Store the default rect for the gui, so we can snap back to it */
				defaultRect = gui.pixelInset;

				defaultRect.x += transform.position.x * Screen.width;// + gui.pixelInset.x; // -  Screen.width * 0.5f;
				defaultRect.y += transform.position.y * Screen.height;// - Screen.height * 0.5f;

				transform.position = new Vector3(0, 0, transform.position.z);

				if (touchPad)
				{
						/* Use the rect from the gui as our touchZone */
						touchZone = defaultRect;
				}
				else
				{
						/* This is an offset for touch input to match with the top left corner of the GUI */
						guiTouchOffset.x = defaultRect.width * 0.5f;
						guiTouchOffset.y = defaultRect.height * 0.5f;

						/* Cache the center of the GUI, since it doesn't change */
						guiCenter.x = defaultRect.x + guiTouchOffset.x;
						guiCenter.y = defaultRect.y + guiTouchOffset.y;

						/* Let's build the GUI boundary, so we can clamp joystick movement */
						guiBoundary.min.x = defaultRect.x - guiTouchOffset.x;
						guiBoundary.max.x = defaultRect.x + guiTouchOffset.x;
						guiBoundary.min.y = defaultRect.y - guiTouchOffset.y;
						guiBoundary.max.y = defaultRect.y + guiTouchOffset.y;
				}

		}


		public void Enable()
		{
				enabled = true;
		}


		public void Disable()
		{
				enabled = false;
		}


		public void Restart()
		{
				/* Release the finger control and set the joystick back to the default position */
				gui.pixelInset = defaultRect;
				lastFingerId = -1;
				position = Vector2.zero;
				fingerDownPos = Vector2.zero;

				if (touchPad && fadeGUI)
				{
						gui.color = new Color(gui.color.r, gui.color.g, gui.color.b, 0.025f);
				}
		}


		public void Update()
		{

				int count = Input.touchCount;

				/* Adjust the tap time window while it still available */
				if (tapTimeWindow > 0)
				{
						tapTimeWindow -= Time.deltaTime;
				}
				else
				{
						tapCount = 0;
				}

				if (count == 0)
				{
						Restart();
				}
				else
				{
						for (int i = 0; i < count; i++)
						{
								Touch touch = Input.GetTouch(i);
								Vector2 guiTouchPos = touch.position - guiTouchOffset;

								bool shouldLatchFinger = false;
								if (touchPad && touchZone.Contains(touch.position))
								{
										shouldLatchFinger = true;
								}
								else if (gui.HitTest(touch.position))
								{
										shouldLatchFinger = true;
								}

								/* Latch the finger if this is a new touch */
								if (shouldLatchFinger && (lastFingerId == -1 || lastFingerId != touch.fingerId))
								{

										if (touchPad)
										{
												if (fadeGUI)
												{
														gui.color = new Color(gui.color.r, gui.color.g, gui.color.b, 0.15f);
												}
												lastFingerId = touch.fingerId;
												fingerDownPos = touch.position;
												/*
                         * Currently unused.
                        fingerDownTime = Time.time;
                        */
										}

										lastFingerId = touch.fingerId;

										/* Accumulate taps if it is within the time window */
										if (tapTimeWindow > 0)
										{
												tapCount++;
										}
										else
										{
												tapCount = 1;
												tapTimeWindow = tapTimeDelta;
										}

										/* Tell other joysticks we've latched this finger */
										foreach (Joystick j in joysticks)
										{
												if (j == this)
												{
														continue;
												}
												j.latchedFinger = touch.fingerId;
										}
								}

								if (lastFingerId == touch.fingerId)
								{
										/*
                        Override the tap count with what the iOS SDK reports if it is greater.
                        This is a workaround, since the iOS SDK does not currently track taps
                        for multiple touches.
                    */
										if (touch.tapCount > tapCount)
										{
												tapCount = touch.tapCount;
										}

										if (touchPad)
										{
												/* For a touchpad, let's just set the position directly based on distance from initial touchdown */
												position = new Vector2
														(
																Mathf.Clamp((touch.position.x - fingerDownPos.x) / (touchZone.width / 2), -1, 1),
																Mathf.Clamp((touch.position.y - fingerDownPos.y) / (touchZone.height / 2), -1, 1)
														);
										}
										else
										{
												/* Change the location of the joystick graphic to match where the touch is */
												gui.pixelInset = new Rect
														(
																Mathf.Clamp(guiTouchPos.x, guiBoundary.min.x, guiBoundary.max.x),
																Mathf.Clamp(guiTouchPos.y, guiBoundary.min.y, guiBoundary.max.y),
																gui.pixelInset.width,
																gui.pixelInset.height
														);
										}

										if (touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled)
										{
												Restart();
										}
								}
						}

				}

				if (!touchPad)
				{
						/* Get a value between -1 and 1 based on the joystick graphic location */
						position = new Vector2
								(
										(gui.pixelInset.x + guiTouchOffset.x - guiCenter.x) / guiTouchOffset.x,
										(gui.pixelInset.y + guiTouchOffset.y - guiCenter.y) / guiTouchOffset.y
								);
				}

				/* Adjust for dead zone */
				float absoluteX = Mathf.Abs(position.x);
				float absoluteY = Mathf.Abs(position.y);

				if (absoluteX < deadZone.x)
				{
						/* Report the joystick as being at the center if it is within the dead zone */
						position = new Vector2(0, position.y);
				}
				else if (normalize)
				{
						/* Rescale the output after taking the dead zone into account */
						position = new Vector2(Mathf.Sign(position.x) * (absoluteX - deadZone.x) / (1 - deadZone.x), position.y);
				}

				if (absoluteY < deadZone.y)
				{
						/* Report the joystick as being at the center if it is within the dead zone */
						position = new Vector2(position.x, 0);
				}
				else if (normalize)
				{
						/* Rescale the output after taking the dead zone into account */
						position = new Vector2(position.x, Mathf.Sign(position.y) * (absoluteY - deadZone.y) / (1 - deadZone.y));
				}
		}


}

Other scripts CAN access the variable position, but it is not displayed in the inspector. also, if i make the variable public in a different script, it will display it!

do you have the GUITexture that your script requires in the scene?