diff --git a/util/call.go b/util/call.go
index 55004d7..ab55bc5 100644
--- a/util/call.go
+++ b/util/call.go
@@ -36,10 +36,10 @@
 	}
 	for i, arg := range args {
 		sign := argSigns[i]
-		jVal, ok := jValue(env, arg, sign)
-		if !ok {
+		jVal, err := jValue(env, arg, sign)
+		if err != nil {
 			freeFunc()
-			return nil, nil, fmt.Errorf("couldn't get Java value for argument #%d [%#v] of expected type %v", i, arg, sign)
+			return nil, nil, fmt.Errorf("couldn't get Java value for argument #%d [%#v] of expected type %v: %v", i, arg, sign, err)
 		}
 		C.setJValueArrayElement(jArr, C.int(i), jVal)
 	}
diff --git a/util/jni_wrapper.c b/util/jni_wrapper.c
index 054a94c..0be09ba 100644
--- a/util/jni_wrapper.c
+++ b/util/jni_wrapper.c
@@ -182,6 +182,10 @@
   return (*env)->ExceptionClear(env);
 }
 
+void ExceptionDescribe(JNIEnv* env) {
+  return (*env)->ExceptionDescribe(env);
+}
+
 jint AttachCurrentThread(JavaVM* jvm, JNIEnv** env, void* args) {
   return (*jvm)->AttachCurrentThread(jvm, (void**) env, args);
 }
diff --git a/util/jni_wrapper.h b/util/jni_wrapper.h
index ef66a03..941013d 100644
--- a/util/jni_wrapper.h
+++ b/util/jni_wrapper.h
@@ -129,6 +129,10 @@
 // Clears any exception that is currently being thrown.
 void ExceptionClear(JNIEnv* env);
 
+// Prints an exception and a backtrace of the stack to a system error-reporting
+// channel, such as stderr.
+void ExceptionDescribe(JNIEnv* env);
+
 // Attaches the current thread to a Java VM.
 jint AttachCurrentThread(JavaVM* jvm, JNIEnv** env, void* args);
 
diff --git a/util/util.go b/util/util.go
index 70ae2f4..264c7eb 100644
--- a/util/util.go
+++ b/util/util.go
@@ -151,25 +151,25 @@
 }
 
 // JThrowV throws a new Java VException corresponding to the given error.
-func JThrowV(env Env, err error) {
-	if err == nil {
+func JThrowV(env Env, native error) {
+	if native == nil {
 		log.Printf("Couldn't throw exception: nil error")
 		return
 	}
-	obj, e := JVomCopy(env, err, jVExceptionClass)
-	if e != nil {
-		log.Printf("Couldn't throw exception %q: %v", err, e)
+	obj, err := JVomCopy(env, native, jVExceptionClass)
+	if err != nil {
+		log.Printf("Couldn't throw exception %#v: %v", native, err)
 		return
 	}
 	C.Throw(env.value(), C.jthrowable(obj.value()))
 }
 
 // JVException returns the Java VException given the Go error.
-func JVException(env Env, err error) (Object, error) {
-	if err == nil {
+func JVException(env Env, native error) (Object, error) {
+	if native == nil {
 		return NullObject, nil
 	}
-	return JVomCopy(env, err, jVExceptionClass)
+	return JVomCopy(env, native, jVExceptionClass)
 }
 
 // JExceptionMsg returns the exception message as a Go error, if an exception
@@ -179,6 +179,7 @@
 	if jException.IsNull() { // no exception
 		return nil
 	}
+	C.ExceptionDescribe(env.value())
 	C.ExceptionClear(env.value())
 	return GoError(env, jException)
 }
diff --git a/util/value.go b/util/value.go
index f9819ec..a68d1d4 100644
--- a/util/value.go
+++ b/util/value.go
@@ -7,6 +7,7 @@
 package util
 
 import (
+	"fmt"
 	"reflect"
 	"time"
 )
@@ -54,7 +55,7 @@
 var errJValue = C.jObjectValue(nil)
 
 // jValue converts a Go value into a Java value with the given sign.
-func jValue(env Env, v interface{}, sign Sign) (C.jvalue, bool) {
+func jValue(env Env, v interface{}, sign Sign) (C.jvalue, error) {
 	switch sign {
 	case BoolSign:
 		return jBoolValue(v)
@@ -87,153 +88,153 @@
 	}
 }
 
-func jBoolValue(v interface{}) (C.jvalue, bool) {
+func jBoolValue(v interface{}) (C.jvalue, error) {
 	val, ok := v.(bool)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't bool", v)
 	}
 	jBool := C.jboolean(C.JNI_FALSE)
 	if val {
 		jBool = C.jboolean(C.JNI_TRUE)
 	}
-	return C.jBoolValue(jBool), true
+	return C.jBoolValue(jBool), nil
 }
 
-func jByteValue(v interface{}) (C.jvalue, bool) {
+func jByteValue(v interface{}) (C.jvalue, error) {
 	val, ok := intValue(v)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't byte", v)
 	}
-	return C.jByteValue(C.jbyte(val)), true
+	return C.jByteValue(C.jbyte(val)), nil
 }
 
-func jCharValue(v interface{}) (C.jvalue, bool) {
+func jCharValue(v interface{}) (C.jvalue, error) {
 	val, ok := intValue(v)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't char", v)
 	}
-	return C.jCharValue(C.jchar(val)), true
+	return C.jCharValue(C.jchar(val)), nil
 }
 
-func jShortValue(v interface{}) (C.jvalue, bool) {
+func jShortValue(v interface{}) (C.jvalue, error) {
 	val, ok := intValue(v)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't short", v)
 	}
-	return C.jShortValue(C.jshort(val)), true
+	return C.jShortValue(C.jshort(val)), nil
 }
 
-func jIntValue(v interface{}) (C.jvalue, bool) {
+func jIntValue(v interface{}) (C.jvalue, error) {
 	val, ok := intValue(v)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't int", v)
 	}
-	return C.jIntValue(C.jint(val)), true
+	return C.jIntValue(C.jint(val)), nil
 }
 
-func jLongValue(v interface{}) (C.jvalue, bool) {
+func jLongValue(v interface{}) (C.jvalue, error) {
 	val, ok := intValue(v)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't long", v)
 	}
-	return C.jLongValue(C.jlong(val)), true
+	return C.jLongValue(C.jlong(val)), nil
 }
 
-func jStringValue(env Env, v interface{}) (C.jvalue, bool) {
+func jStringValue(env Env, v interface{}) (C.jvalue, error) {
 	str, ok := v.(string)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't string", v)
 	}
 	return jObjectValue(JString(env, str))
 }
 
-func jDateTimeValue(env Env, v interface{}) (C.jvalue, bool) {
+func jDateTimeValue(env Env, v interface{}) (C.jvalue, error) {
 	t, ok := v.(time.Time)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't time.Time", v)
 	}
 	jTime, err := JTime(env, t)
 	if err != nil {
-		return errJValue, false
+		return errJValue, err
 	}
 	return jObjectValue(jTime)
 }
 
-func jDurationValue(env Env, v interface{}) (C.jvalue, bool) {
+func jDurationValue(env Env, v interface{}) (C.jvalue, error) {
 	d, ok := v.(time.Duration)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't time.Duration", v)
 	}
 	jDuration, err := JDuration(env, d)
 	if err != nil {
-		return errJValue, false
+		return errJValue, err
 	}
 	return jObjectValue(jDuration)
 }
 
-func jVExceptionValue(env Env, v interface{}) (C.jvalue, bool) {
+func jVExceptionValue(env Env, v interface{}) (C.jvalue, error) {
 	if v == nil {
-		return C.jObjectValue(nil), true
+		return C.jObjectValue(nil), nil
 	}
-	err, ok := v.(error)
+	native, ok := v.(error)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't error", v)
 	}
-	jVException, err := JVException(env, err)
+	jVException, err := JVException(env, native)
 	if err != nil {
-		return errJValue, false
+		return errJValue, err
 	}
 	return jObjectValue(jVException)
 }
 
-func jByteArrayValue(env Env, v interface{}) (C.jvalue, bool) {
+func jByteArrayValue(env Env, v interface{}) (C.jvalue, error) {
 	arr, ok := v.([]byte)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't []byte", v)
 	}
 	jArr, err := JByteArray(env, arr)
 	if err != nil {
-		return errJValue, false
+		return errJValue, err
 	}
 	return jObjectValue(jArr)
 }
 
-func jStringArrayValue(env Env, v interface{}) (C.jvalue, bool) {
+func jStringArrayValue(env Env, v interface{}) (C.jvalue, error) {
 	arr, ok := v.([]string)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't []string", v)
 	}
 	jArr, err := JStringArray(env, arr)
 	if err != nil {
-		return errJValue, false
+		return errJValue, err
 	}
 	return jObjectValue(jArr)
 }
 
-func jByteArrayArrayValue(env Env, v interface{}) (C.jvalue, bool) {
+func jByteArrayArrayValue(env Env, v interface{}) (C.jvalue, error) {
 	arr, ok := v.([][]byte)
 	if !ok {
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't [][]byte", v)
 	}
 	jArr, err := JByteArrayArray(env, arr)
 	if err != nil {
-		return errJValue, false
+		return errJValue, err
 	}
 	return jObjectValue(jArr)
 }
 
-func jObjectValue(v interface{}) (C.jvalue, bool) {
+func jObjectValue(v interface{}) (C.jvalue, error) {
 	rv := reflect.ValueOf(v)
 	if !rv.IsValid() { // nil value
-		return C.jObjectValue(nil), true
+		return C.jObjectValue(nil), nil
 	}
 	switch val := v.(type) {
 	case Object:
-		return C.jObjectValue(val.value()), true
+		return C.jObjectValue(val.value()), nil
 	case Class:
-		return C.jObjectValue(C.jobject(val.value())), true
+		return C.jObjectValue(C.jobject(val.value())), nil
 	default:
-		return errJValue, false
+		return errJValue, fmt.Errorf("%#v isn't Object or Class", v)
 	}
 }