Julia, 21 15 bytes

x->x[1:end/2+1]

Try it online! (extra code is for printing output)

05AB1E, 3 bytes

2ä¬

Uses the CP-1252 encoding. Try it online!

Python 2, 23 bytes

I am not able to test on my phone, but this should work:

lambda s:s[:-~len(s)/2]

Fuzzy Octo Guacamole, 4 bytes

2.^/

I spent a while searching for a language in which this challenge is short, and realized I was dumb and my own language did that.

05AB1E, 5 bytes

Dg;î£

Try it online!

Explanation:

D      Duplicate
 g;î   Divide length by two and round up
    £  First b letters of a

Pyth - 4 bytes

hc2Q

Test Suite.

Cheddar, 22 18 bytes

@.head($0.len/2+1)

So simple I don't think needs explanation but I'll add one if wanted.

Try it online

WinDbg, 87 bytes

db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};r$t5=@$t0+(@$t1-@$t0)/2;eb$t5 0;da$t0

Input is passed in via an address in psuedo-register $t0. For example:

eza 2000000 "abcdedcba"       * Write string "abcdedcba" into memory at 0x02000000
r $t0 = 33554432              * Set $t0 = 0x02000000
* Edit: Something got messed up in my WinDB session, of course r $t0 = 2000000 should work
* not that crazy 33554432.

It works by replacing the right of middle char (or right-middle if the string has even length) with a null and then prints the string from the original starting memory address.

db $t0 L1;                                   * Set $p = memory-at($t0)
.for (r $t1 = @$t0; @$p; r $t1 = @$t1 + 1)   * Set $t1 = $t0 and increment until $p == 0
{
    db $t1 L1                                * Set $p = memory-at($t1)
};
r $t5 = @$t0 + (@$t1 - @$t0) / 2;            * Point $t5 to the right-middle of the string
eb $t5 0;                                    * Insert a null at $t5
da $t0                                       * Print the string

Output:

0:000> eza 2000000 "abcdeedcba"
0:000> r $t0 = 33554432
0:000> db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};r$t5=@$t0+(@$t1-@$t0)/2;eb$t5 0;da$t0
02000000  61                                               a
02000000  61                                               a
02000001  62                                               b
02000002  63                                               c
02000003  64                                               d
02000004  65                                               e
02000005  65                                               e
02000006  64                                               d
02000007  63                                               c
02000008  62                                               b
02000009  61                                               a
0200000a  00                                               .
02000000  "abcde"

Haskell, 27 bytes

take=<<succ.(`div`2).length

Pointfree version of

\x->take(div(length x)2+1)x

which is also 27 bytes.

MATL, 7 6 bytes

9LQ2/)

Try it online!

Explanation

9L       % Push array [1, 1j]
  Q      % Add 1: transforms into [2, 1+1j]
   2/    % Divide by 2: transforms into [1, 0.5+0.5j]
     )   % Apply as index into implicit input. The array [1, 0.5+0.5j] used as an index
         % is interpreted as [1:0.5+end*0.5]

Jelly, 4 bytes

œs2Ḣ

Try it online!

Explanation

œs2      Split input into 2 chunks of similar lengths. For odd-length input,
         the first chunk is the longest
   Ḣ     Keep the first chunk

V, 12 bytes

Two completely different solutions, both 12 bytes.

ò"Bx$xh|ò"bP

Try it online!

Ó./&ò
MjdGÍî

Try it online!

Java 7,57 bytes

String c(String s){return s.substring(0,s.length()/2+1);}

JavaScript (ES6), 32 26 25 bytes

1 byte saved thanks to Neil:

s=>s.slice(0,-s.length/2)

f=
  s=>s.slice(0,-s.length/2)
;
console.log(f('abcdedcba'))
console.log(f('johncenanecnhoj'))
console.log(f('ppapapp'))
console.log(f('codegolflogedoc'))

Previous solutions
26 bytes thanks to Downgoat:

s=>s.slice(0,s.length/2+1)

32 bytes:

s=>s.slice(0,(l=s.length/2)+l%2)

TI-Basic, 14 bytes

Standard function. Returns string from index 1 to index (length/2 + 1/2).

sub(Ans,1,.5+.5length(Ans

GameMaker Language, 59 bytes

a=argument0 return string_copy(a,1,ceil(string_length(a)/2)

Brachylog, 4 bytes

@2tr

Try it online!

Explanation

@2        Split in half
  t       Take the second half
   r      Reverse it

If the input has odd length, the second half generated by @2 is the one that is the longest, that is the one we should return (after reversing it).

C, 31 bytes

f(char* c){c[-~strlen(c)/2]=0;}

Usage:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}

Dyalog APL, 9 bytes

⊢↑⍨2÷⍨1+≢

⊢ the argument

↑⍨ truncated at

2÷⍨ half of

1+ one plus

≢ the length

TryAPL online!

PHP, 40 bytes

<?=substr($a=$argv[1],0,1+strlen($a)/2);

strlen($a)/2 gets cast to int, with the input always having odd length, +1 suffices to round up.

42 bytes for any length:

<?=substr($a=$argv[1],0,(1+strlen($a))/2);

for unknown length, (1+strlen)/2 gets cast to int, rounding up strlen/2.

Perl, 14 + 3 (-lF flag) = 19 17 bytes

For 5.20.0+:

perl -lF -E 'say@F[0..@F/2]'

For 5.10.0+ (19 bytes):

perl -nlaF -E 'say@F[0..@F/2]'

Ungolfed:

while (<>) {             # -n flag (implicitly sets by -F in 5.20.0+)
    chomp($_)            # -l flag
    @F = split('', $_);  # -aF flag (implicitly sets by -F in 5.20.0+)
    say(@F[0 .. (scalar(@F) / 2)]);
}

Thanx to @simbabque.

Python 2, 23 bytes

lambda x:x[:len(x)/2+1]

Actually, 7 bytes

2@l\ußH

Try it online!

Explanation:

2@l\ußH
2@l\u    len(input)//2 + 1
     ßH  first (len(input)//2 + 1) characters of input

Pyke, 4 bytes

le>_

Try it here!

l    -    len(input)
 e   -   ^//2
  >  -  input[^:]
   _ - reversed(^)

IBM/Lotus Notes Formula, 21 bytes

@Left(a;@Length(a)/2)

Computed field that takes input from an editable field a. Works because Notes rounds up when an odd number is divided by 2.

Test Cases

Retina, 24 bytes

I basically took this from another answer of mine.

^((.)*?.??)(?<-2>.)*$
$1

Try it online

Dip, 8 bytes

H{C'0ÏEI

Explanation:

           # Implicit input
 H         # Push length of input
  {        # Add 1
   C       # Divide by 2
    '      # Convert to int
     0Ï    # Get string back
       E   # Push prefixes of string
        I  # Push prefixes[a]
           # Implicit print

This could probably be much improved.

CJam, 7 bytes

r_,-2/<

Try it online!

Perl, 23 + 2 (-pl flag) = 28 25 bytes

perl -ple '$_=substr$_,0,1+y///c/2'

Ungolfed:

while (<>) {             # -p flag
    chomp($_)            # -l flag
    $_ = substr($_, 0, 1 + length($_) / 2);
    print($_, "\n")      # -pl flag
}

Thanx to @ardnew.

Befunge, 24 22 bytes

~:0`!#v_\1+
0:-2,\_@#`

Try it online!

Befunge has no string or array type so the everything is done on the stack one character at a time. The first loop (on the top line) counts the number of characters read (swapping with less than 2 elements in the stack produces an initial 0). The second (on the middle line) prints characters while counting down twice as fast. As a result only the last half of the input is printed, but LIFO so it's in the correct order.

Thanks to Brian Gradin for a better version of the first loop.