diff --git a/res/values/strings.xml b/res/values/strings.xml
index 787828a..8ebf1fc 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -165,8 +165,11 @@
     <!-- List separator for the Join Contact list: A-Z -->
     <string name="separatorJoinAggregateAll">All contacts</string>
 
-    <!-- Toast shown after two contacts have been joined by a user action -->
-    <string name="contactsJoinedMessage">Contacts joined</string>
+    <!-- Toast shown after two contacts have been joined by a user action. [CHAR LIMIT=NONE] -->
+    <string name="contactsJoinedMessage">Contacts merged</string>
+
+    <!-- Toast shown after contacts that the user has selected are deleted by a user action. [CHAR LIMIT=NONE] -->
+    <string name="contacts_deleted_toast">Contacts deleted</string>
 
     <!-- Menu item that opens the Options activity for a given contact [CHAR LIMIT=15] -->
     <string name="menu_set_ring_tone">Set ringtone</string>
diff --git a/src/com/android/contacts/ContactSaveService.java b/src/com/android/contacts/ContactSaveService.java
index cf36edf..d81867c 100644
--- a/src/com/android/contacts/ContactSaveService.java
+++ b/src/com/android/contacts/ContactSaveService.java
@@ -982,7 +982,7 @@
             final Uri contactUri = ContentUris.withAppendedId(Contacts.CONTENT_URI, contactId);
             getContentResolver().delete(contactUri, null, null);
         }
-
+        showToast(R.string.contacts_deleted_toast);
     }
 
     /**
