Index: kernel/arch/abs32le/include/arch/asm.h
===================================================================
--- kernel/arch/abs32le/include/arch/asm.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/arch/abs32le/include/arch/asm.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -192,5 +192,5 @@
 	/*
 	 * On real hardware this returns the address of the bottom
-	 * of the current CPU stack. The the_t structure is stored
+	 * of the current CPU stack. The current_t structure is stored
 	 * on the bottom of stack and this is used to identify the
 	 * current CPU, current task, current thread and current
Index: kernel/generic/include/arch.h
===================================================================
--- kernel/generic/include/arch.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/arch.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -40,10 +40,9 @@
 
 /*
- * THE is not an abbreviation, but the English definite article written in
- * capital letters. It means the current pointer to something, e.g. thread,
- * processor or address space. Kind reader of this comment shall appreciate
- * the wit of constructs like THE->thread and similar.
+ * The context pointer. The current_t structure holds pointers to various parts
+ * of the current execution context, like running task, thread, address space,
+ * etc.
  */
-#define THE  ((the_t * )(get_stack_base()))
+#define CURRENT  ((current_t * )(get_stack_base()))
 
 #define MAGIC                UINT32_C(0xfacefeed)
@@ -53,5 +52,5 @@
 #define DEFAULT_CONTAINER  0
 #define CONTAINER \
-	((THE->task) ? (THE->task->container) : (DEFAULT_CONTAINER))
+	((CURRENT->task) ? (CURRENT->task->container) : (DEFAULT_CONTAINER))
 
 /* Fwd decl. to avoid include hell. */
@@ -76,5 +75,5 @@
 	struct as *as;         /**< Current address space. */
 	uint32_t magic;        /**< Magic value */
-} the_t;
+} current_t;
 
 typedef struct {
@@ -96,6 +95,6 @@
 #define ARCH_OP(op)	ARCH_STRUCT_OP(arch_ops, op)
 
-extern void the_initialize(the_t *);
-extern void the_copy(the_t *, the_t *);
+extern void current_initialize(current_t *);
+extern void current_copy(current_t *, current_t *);
 
 extern void calibrate_delay_loop(void);
Index: kernel/generic/include/cpu.h
===================================================================
--- kernel/generic/include/cpu.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/cpu.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -45,5 +45,5 @@
 #include <arch.h>
 
-#define CPU                  THE->cpu
+#define CPU                  CURRENT->cpu
 
 /** CPU structure.
Index: kernel/generic/include/mm/as.h
===================================================================
--- kernel/generic/include/mm/as.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/mm/as.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -50,5 +50,5 @@
 #include <lib/refcount.h>
 
-#define AS                   THE->as
+#define AS                   CURRENT->as
 
 /**
Index: kernel/generic/include/preemption.h
===================================================================
--- kernel/generic/include/preemption.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/preemption.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -41,5 +41,5 @@
 
 #define PREEMPTION_INC         (1 << 0)
-#define PREEMPTION_DISABLED    (PREEMPTION_INC <= THE->preemption)
+#define PREEMPTION_DISABLED    (PREEMPTION_INC <= CURRENT->preemption)
 #define PREEMPTION_ENABLED     (!PREEMPTION_DISABLED)
 
@@ -47,5 +47,5 @@
 #define preemption_disable() \
 	do { \
-		THE->preemption += PREEMPTION_INC; \
+		CURRENT->preemption += PREEMPTION_INC; \
 		compiler_barrier(); \
 	} while (0)
@@ -56,5 +56,5 @@
 		assert(PREEMPTION_DISABLED); \
 		compiler_barrier(); \
-		THE->preemption -= PREEMPTION_INC; \
+		CURRENT->preemption -= PREEMPTION_INC; \
 	} while (0)
 
Index: kernel/generic/include/proc/task.h
===================================================================
--- kernel/generic/include/proc/task.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/proc/task.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -63,5 +63,5 @@
 #include <cap/cap.h>
 
-#define TASK                 THE->task
+#define TASK                 CURRENT->task
 
 struct thread;
Index: kernel/generic/include/proc/thread.h
===================================================================
--- kernel/generic/include/proc/thread.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/proc/thread.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -52,5 +52,5 @@
 #include <arch.h>
 
-#define THREAD              THE->thread
+#define THREAD              CURRENT->thread
 
 #define THREAD_NAME_BUFLEN  20
Index: kernel/generic/include/synch/rcu.h
===================================================================
--- kernel/generic/include/synch/rcu.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/synch/rcu.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -132,5 +132,5 @@
 static inline void rcu_read_lock(void)
 {
-	THE->rcu_nesting += RCU_CNT_INC;
+	CURRENT->rcu_nesting += RCU_CNT_INC;
 	compiler_barrier();
 }
@@ -140,7 +140,7 @@
 {
 	compiler_barrier();
-	THE->rcu_nesting -= RCU_CNT_INC;
-
-	if (RCU_WAS_PREEMPTED == THE->rcu_nesting) {
+	CURRENT->rcu_nesting -= RCU_CNT_INC;
+
+	if (RCU_WAS_PREEMPTED == CURRENT->rcu_nesting) {
 		_rcu_preempted_unlock();
 	}
Index: kernel/generic/include/time/timeout.h
===================================================================
--- kernel/generic/include/time/timeout.h	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/include/time/timeout.h	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -45,5 +45,5 @@
 	IRQ_SPINLOCK_DECLARE(lock);
 
-	/** Link to the list of active timeouts on THE->cpu */
+	/** Link to the list of active timeouts on CURRENT->cpu */
 	link_t link;
 	/** Timeout will be activated in this amount of clock() ticks. */
Index: kernel/generic/src/debug/panic.c
===================================================================
--- kernel/generic/src/debug/panic.c	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/src/debug/panic.c	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -94,15 +94,15 @@
 	printf("\n");
 
-	printf("THE=%p: ", THE);
-	if (THE != NULL) {
+	printf("CURRENT=%p: ", CURRENT);
+	if (CURRENT != NULL) {
 		printf("pe=%" PRIuPTR " thread=%p task=%p cpu=%p as=%p"
-		    " magic=%#" PRIx32 "\n", THE->preemption,
-		    THE->thread, THE->task, THE->cpu, THE->as, THE->magic);
+		    " magic=%#" PRIx32 "\n", CURRENT->preemption,
+		    CURRENT->thread, CURRENT->task, CURRENT->cpu, CURRENT->as, CURRENT->magic);
 
-		if (THE->thread != NULL)
-			printf("thread=\"%s\"\n", THE->thread->name);
+		if (CURRENT->thread != NULL)
+			printf("thread=\"%s\"\n", CURRENT->thread->name);
 
-		if (THE->task != NULL)
-			printf("task=\"%s\"\n", THE->task->name);
+		if (CURRENT->task != NULL)
+			printf("task=\"%s\"\n", CURRENT->task->name);
 	} else
 		printf("invalid\n");
Index: kernel/generic/src/main/main.c
===================================================================
--- kernel/generic/src/main/main.c	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/src/main/main.c	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -213,5 +213,5 @@
 {
 	/* Keep this the first thing. */
-	the_initialize(THE);
+	current_initialize(CURRENT);
 
 	version_print();
@@ -342,7 +342,7 @@
 
 	/*
-	 * The THE structure is well defined because ctx.sp is used as stack.
-	 */
-	the_initialize(THE);
+	 * The CURRENT structure is well defined because ctx.sp is used as stack.
+	 */
+	current_initialize(CURRENT);
 
 	ARCH_OP(pre_mm_init);
@@ -356,5 +356,5 @@
 	ARCH_OP(post_cpu_init);
 
-	the_copy(THE, (the_t *) CPU->stack);
+	current_copy(CURRENT, (current_t *) CPU->stack);
 
 	/*
Index: kernel/generic/src/proc/scheduler.c
===================================================================
--- kernel/generic/src/proc/scheduler.c	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/src/proc/scheduler.c	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -363,10 +363,10 @@
 
 	/*
-	 * Through the 'THE' structure, we keep track of THREAD, TASK, CPU, AS
-	 * and preemption counter. At this point THE could be coming either
+	 * Through the 'CURRENT' structure, we keep track of THREAD, TASK, CPU, AS
+	 * and preemption counter. At this point CURRENT could be coming either
 	 * from THREAD's or CPU's stack.
 	 *
 	 */
-	the_copy(THE, (the_t *) CPU->stack);
+	current_copy(CURRENT, (current_t *) CPU->stack);
 
 	/*
@@ -548,5 +548,5 @@
 	 * thread's stack.
 	 */
-	the_copy(THE, (the_t *) THREAD->kstack);
+	current_copy(CURRENT, (current_t *) THREAD->kstack);
 
 	context_restore(&THREAD->saved_context);
Index: kernel/generic/src/proc/the.c
===================================================================
--- kernel/generic/src/proc/the.c	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/src/proc/the.c	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -33,8 +33,8 @@
 /**
  * @file
- * @brief THE structure functions.
+ * @brief CURRENT structure functions.
  *
- * This file contains functions to manage the THE structure.
- * The THE structure exists at the base address of every kernel
+ * This file contains functions to manage the CURRENT structure.
+ * The CURRENT structure exists at the base address of every kernel
  * stack and carries information about current settings
  * (e.g. current CPU, current thread, task and address space
@@ -45,12 +45,12 @@
 #include <assert.h>
 
-/** Initialize THE structure
+/** Initialize CURRENT structure
  *
- * Initialize THE structure passed as argument.
+ * Initialize CURRENT structure passed as argument.
  *
- * @param the THE structure to be initialized.
+ * @param the CURRENT structure to be initialized.
  *
  */
-void the_initialize(the_t *the)
+void current_initialize(current_t *the)
 {
 	the->preemption = 0;
@@ -65,13 +65,13 @@
 }
 
-/** Copy THE structure
+/** Copy CURRENT structure
  *
- * Copy the source THE structure to the destination THE structure.
+ * Copy the source CURRENT structure to the destination CURRENT structure.
  *
- * @param src The source THE structure.
- * @param dst The destination THE structure.
+ * @param src The source CURRENT structure.
+ * @param dst The destination CURRENT structure.
  *
  */
-NO_TRACE void the_copy(the_t *src, the_t *dst)
+NO_TRACE void current_copy(current_t *src, current_t *dst)
 {
 	assert(src->magic == MAGIC);
Index: kernel/generic/src/proc/thread.c
===================================================================
--- kernel/generic/src/proc/thread.c	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/src/proc/thread.c	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -356,5 +356,5 @@
 	    (uintptr_t) thread->kstack, STACK_SIZE);
 
-	the_initialize((the_t *) thread->kstack);
+	current_initialize((current_t *) thread->kstack);
 
 	ipl_t ipl = interrupts_disable();
Index: kernel/generic/src/synch/rcu.c
===================================================================
--- kernel/generic/src/synch/rcu.c	(revision 482f968b8b53156bb4454e6c369c1e92dc426ea9)
+++ kernel/generic/src/synch/rcu.c	(revision 91a8f837283629418f6b227ac9232dd63901abf2)
@@ -1026,5 +1026,5 @@
 	cpu_mask_t *reader_cpus = (cpu_mask_t *)arg;
 
-	bool locked = RCU_CNT_INC <= THE->rcu_nesting;
+	bool locked = RCU_CNT_INC <= CURRENT->rcu_nesting;
 	/* smp_call machinery makes the most current _rcu_cur_gp visible. */
 	bool passed_qs = (CPU->rcu.last_seen_gp == _rcu_cur_gp);
@@ -1054,5 +1054,5 @@
 	 * with a local copy.
 	 */
-	size_t nesting_cnt = local_atomic_exchange(&THE->rcu_nesting, 0);
+	size_t nesting_cnt = local_atomic_exchange(&CURRENT->rcu_nesting, 0);
 
 	/*
@@ -1113,5 +1113,5 @@
 
 	/* Load the thread's saved nesting count from before it was preempted. */
-	THE->rcu_nesting = THREAD->rcu.nesting_cnt;
+	CURRENT->rcu_nesting = THREAD->rcu.nesting_cnt;
 }
 
@@ -1123,5 +1123,5 @@
 void rcu_thread_exiting(void)
 {
-	assert(THE->rcu_nesting == 0);
+	assert(CURRENT->rcu_nesting == 0);
 
 	/*
@@ -1145,5 +1145,5 @@
 bool rcu_read_locked(void)
 {
-	return RCU_CNT_INC <= THE->rcu_nesting;
+	return RCU_CNT_INC <= CURRENT->rcu_nesting;
 }
 
@@ -1151,7 +1151,7 @@
 void _rcu_preempted_unlock(void)
 {
-	assert(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
-
-	size_t prev = local_atomic_exchange(&THE->rcu_nesting, 0);
+	assert(0 == CURRENT->rcu_nesting || RCU_WAS_PREEMPTED == CURRENT->rcu_nesting);
+
+	size_t prev = local_atomic_exchange(&CURRENT->rcu_nesting, 0);
 	if (prev == RCU_WAS_PREEMPTED) {
 		/*
