diff --git a/api/String.cpp b/api/String.cpp
index 1b6d4b28..77b8240a 100644
--- a/api/String.cpp
+++ b/api/String.cpp
@@ -166,25 +166,25 @@ void String::invalidate(void)
 	capacity = len = 0;
 }
 
-unsigned char String::reserve(unsigned int size)
+bool String::reserve(unsigned int size)
 {
 	if (buffer && capacity >= size) return 1;
 	if (changeBuffer(size)) {
 		if (len == 0) buffer[0] = 0;
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
-unsigned char String::changeBuffer(unsigned int maxStrLen)
+bool String::changeBuffer(unsigned int maxStrLen)
 {
 	char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
 	if (newbuffer) {
 		buffer = newbuffer;
 		capacity = maxStrLen;
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
 /*********************************************/
@@ -281,93 +281,93 @@ String & String::operator = (const __FlashStringHelper *pstr)
 /*  concat                                   */
 /*********************************************/
 
-unsigned char String::concat(const String &s)
+bool String::concat(const String &s)
 {
 	return concat(s.buffer, s.len);
 }
 
-unsigned char String::concat(const char *cstr, unsigned int length)
+bool String::concat(const char *cstr, unsigned int length)
 {
 	unsigned int newlen = len + length;
-	if (!cstr) return 0;
-	if (length == 0) return 1;
-	if (!reserve(newlen)) return 0;
+	if (!cstr) return false;
+	if (length == 0) return true;
+	if (!reserve(newlen)) return false;
 	memcpy(buffer + len, cstr, length);
 	len = newlen;
 	buffer[len] = '\0';
-	return 1;
+	return true;
 }
 
-unsigned char String::concat(const char *cstr)
+bool String::concat(const char *cstr)
 {
-	if (!cstr) return 0;
+	if (!cstr) return false;
 	return concat(cstr, strlen(cstr));
 }
 
-unsigned char String::concat(char c)
+bool String::concat(char c)
 {
 	return concat(&c, 1);
 }
 
-unsigned char String::concat(unsigned char num)
+bool String::concat(unsigned char num)
 {
 	char buf[1 + 3 * sizeof(unsigned char)];
 	itoa(num, buf, 10);
 	return concat(buf);
 }
 
-unsigned char String::concat(int num)
+bool String::concat(int num)
 {
 	char buf[2 + 3 * sizeof(int)];
 	itoa(num, buf, 10);
 	return concat(buf);
 }
 
-unsigned char String::concat(unsigned int num)
+bool String::concat(unsigned int num)
 {
 	char buf[1 + 3 * sizeof(unsigned int)];
 	utoa(num, buf, 10);
 	return concat(buf);
 }
 
-unsigned char String::concat(long num)
+bool String::concat(long num)
 {
 	char buf[2 + 3 * sizeof(long)];
 	ltoa(num, buf, 10);
 	return concat(buf);
 }
 
-unsigned char String::concat(unsigned long num)
+bool String::concat(unsigned long num)
 {
 	char buf[1 + 3 * sizeof(unsigned long)];
 	ultoa(num, buf, 10);
 	return concat(buf);
 }
 
-unsigned char String::concat(float num)
+bool String::concat(float num)
 {
 	char buf[20];
 	char* string = dtostrf(num, 4, 2, buf);
 	return concat(string);
 }
 
-unsigned char String::concat(double num)
+bool String::concat(double num)
 {
 	char buf[20];
 	char* string = dtostrf(num, 4, 2, buf);
 	return concat(string);
 }
 
-unsigned char String::concat(const __FlashStringHelper * str)
+bool String::concat(const __FlashStringHelper * str)
 {
-	if (!str) return 0;
+	if (!str) return false;
 	int length = strlen_P((const char *) str);
-	if (length == 0) return 1;
+	if (length == 0) return true;
 	unsigned int newlen = len + length;
-	if (!reserve(newlen)) return 0;
+	if (!reserve(newlen)) return false;
 	strcpy_P(buffer + len, (const char *) str);
 	len = newlen;
-	return 1;
+	return true;
 }
 
 /*********************************************/
@@ -475,46 +475,46 @@ int String::compareTo(const char *cstr) const
 	return strcmp(buffer, cstr);
 }
 
-unsigned char String::equals(const String &s2) const
+bool String::equals(const String &s2) const
 {
 	return (len == s2.len && compareTo(s2) == 0);
 }
 
-unsigned char String::equals(const char *cstr) const
+bool String::equals(const char *cstr) const
 {
 	if (len == 0) return (cstr == NULL || *cstr == 0);
 	if (cstr == NULL) return buffer[0] == 0;
 	return strcmp(buffer, cstr) == 0;
 }
 
-unsigned char String::equalsIgnoreCase( const String &s2 ) const
+bool String::equalsIgnoreCase( const String &s2 ) const
 {
-	if (this == &s2) return 1;
-	if (len != s2.len) return 0;
-	if (len == 0) return 1;
+	if (this == &s2) return true;
+	if (len != s2.len) return false;
+	if (len == 0) return true;
 	const char *p1 = buffer;
 	const char *p2 = s2.buffer;
 	while (*p1) {
-		if (tolower(*p1++) != tolower(*p2++)) return 0;
+		if (tolower(*p1++) != tolower(*p2++)) return false;
 	} 
-	return 1;
+	return true;
 }
 
-unsigned char String::startsWith( const String &s2 ) const
+bool String::startsWith( const String &s2 ) const
 {
-	if (len < s2.len) return 0;
+	if (len < s2.len) return false;
 	return startsWith(s2, 0);
 }
 
-unsigned char String::startsWith( const String &s2, unsigned int offset ) const
+bool String::startsWith( const String &s2, unsigned int offset ) const
 {
-	if (offset > len - s2.len || !buffer || !s2.buffer) return 0;
+	if (offset > len - s2.len || !buffer || !s2.buffer) return false;
 	return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0;
 }
 
-unsigned char String::endsWith( const String &s2 ) const
+bool String::endsWith( const String &s2 ) const
 {
-	if ( len < s2.len || !buffer || !s2.buffer) return 0;
+	if ( len < s2.len || !buffer || !s2.buffer) return false;
 	return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
 }
 
diff --git a/api/String.h b/api/String.h
index 3f34493b..9360c090 100644
--- a/api/String.h
+++ b/api/String.h
@@ -90,7 +90,7 @@ class String
 	// return true on success, false on failure (in which case, the string
 	// is left unchanged).  reserve(0), if successful, will validate an
 	// invalid string (i.e., "if (s)" will be true afterwards)
-	unsigned char reserve(unsigned int size);
+	bool reserve(unsigned int size);
 	inline unsigned int length(void) const {return len;}
 
 	// creates a copy of the assigned value.  if the value is null or
@@ -109,19 +109,19 @@ class String
 	// returns true on success, false on failure (in which case, the string
 	// is left unchanged).  if the argument is null or invalid, the
 	// concatenation is considered unsucessful.
-	unsigned char concat(const String &str);
-	unsigned char concat(const char *cstr);
-	unsigned char concat(const char *cstr, unsigned int length);
-	unsigned char concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
-	unsigned char concat(char c);
-	unsigned char concat(unsigned char num);
-	unsigned char concat(int num);
-	unsigned char concat(unsigned int num);
-	unsigned char concat(long num);
-	unsigned char concat(unsigned long num);
-	unsigned char concat(float num);
-	unsigned char concat(double num);
-	unsigned char concat(const __FlashStringHelper * str);
+	bool concat(const String &str);
+	bool concat(const char *cstr);
+	bool concat(const char *cstr, unsigned int length);
+	bool concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
+	bool concat(char c);
+	bool concat(unsigned char num);
+	bool concat(int num);
+	bool concat(unsigned int num);
+	bool concat(long num);
+	bool concat(unsigned long num);
+	bool concat(float num);
+	bool concat(double num);
+	bool concat(const __FlashStringHelper * str);
 
 	// if there's not enough memory for the concatenated value, the string
 	// will be left unchanged (but this isn't signalled in any way)
@@ -153,33 +153,33 @@ class String
 	operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; }
 	int compareTo(const String &s) const;
 	int compareTo(const char *cstr) const;
-	unsigned char equals(const String &s) const;
-	unsigned char equals(const char *cstr) const;
-
-	friend unsigned char operator == (const String &a, const String &b) { return a.equals(b); }
-	friend unsigned char operator == (const String &a, const char   *b) { return a.equals(b); }
-	friend unsigned char operator == (const char   *a, const String &b) { return b == a; }
-	friend unsigned char operator <  (const String &a, const String &b) { return a.compareTo(b) < 0; }
-	friend unsigned char operator <  (const String &a, const char   *b) { return a.compareTo(b) < 0; }
-	friend unsigned char operator <  (const char   *a, const String &b) { return b.compareTo(a) > 0; }
-
-	friend unsigned char operator != (const String &a, const String &b) { return !(a == b); }
-	friend unsigned char operator != (const String &a, const char   *b) { return !(a == b); }
-	friend unsigned char operator != (const char   *a, const String &b) { return !(a == b); }
-	friend unsigned char operator >  (const String &a, const String &b) { return b < a; }
-	friend unsigned char operator >  (const String &a, const char   *b) { return b < a; }
-	friend unsigned char operator >  (const char   *a, const String &b) { return b < a; }
-	friend unsigned char operator <= (const String &a, const String &b) { return !(b < a); }
-	friend unsigned char operator <= (const String &a, const char   *b) { return !(b < a); }
-	friend unsigned char operator <= (const char   *a, const String &b) { return !(b < a); }
-	friend unsigned char operator >= (const String &a, const String &b) { return !(a < b); }
-	friend unsigned char operator >= (const String &a, const char   *b) { return !(a < b); }
-	friend unsigned char operator >= (const char   *a, const String &b) { return !(a < b); }
-
-	unsigned char equalsIgnoreCase(const String &s) const;
-	unsigned char startsWith( const String &prefix) const;
-	unsigned char startsWith(const String &prefix, unsigned int offset) const;
-	unsigned char endsWith(const String &suffix) const;
+	bool equals(const String &s) const;
+	bool equals(const char *cstr) const;
+
+	friend bool operator == (const String &a, const String &b) { return a.equals(b); }
+	friend bool operator == (const String &a, const char   *b) { return a.equals(b); }
+	friend bool operator == (const char   *a, const String &b) { return b == a; }
+	friend bool operator <  (const String &a, const String &b) { return a.compareTo(b) < 0; }
+	friend bool operator <  (const String &a, const char   *b) { return a.compareTo(b) < 0; }
+	friend bool operator <  (const char   *a, const String &b) { return b.compareTo(a) > 0; }
+
+	friend bool operator != (const String &a, const String &b) { return !(a == b); }
+	friend bool operator != (const String &a, const char   *b) { return !(a == b); }
+	friend bool operator != (const char   *a, const String &b) { return !(a == b); }
+	friend bool operator >  (const String &a, const String &b) { return b < a; }
+	friend bool operator >  (const String &a, const char   *b) { return b < a; }
+	friend bool operator >  (const char   *a, const String &b) { return b < a; }
+	friend bool operator <= (const String &a, const String &b) { return !(b < a); }
+	friend bool operator <= (const String &a, const char   *b) { return !(b < a); }
+	friend bool operator <= (const char   *a, const String &b) { return !(b < a); }
+	friend bool operator >= (const String &a, const String &b) { return !(a < b); }
+	friend bool operator >= (const String &a, const char   *b) { return !(a < b); }
+	friend bool operator >= (const char   *a, const String &b) { return !(a < b); }
+
+	bool equalsIgnoreCase(const String &s) const;
+	bool startsWith( const String &prefix) const;
+	bool startsWith(const String &prefix, unsigned int offset) const;
+	bool endsWith(const String &suffix) const;
 
 	// character acccess
 	char charAt(unsigned int index) const;
@@ -228,7 +228,7 @@ class String
 protected:
 	void init(void);
 	void invalidate(void);
-	unsigned char changeBuffer(unsigned int maxStrLen);
+	bool changeBuffer(unsigned int maxStrLen);
 
 	// copy and move
 	String & copy(const char *cstr, unsigned int length);