Javascript (ES6), 55 54 48 bytes

-~((n=Date().substr(13,2)*3+280)/4-9.1)/10+' '+n 

Works in Firefox 33; theoretically supports all years from 2000 to 2099. If programs that dump the result onto the console are not allowed, use this 51-byte function:

(n=Date().substr(13,2)*3+280)=>-~(n/4-9.1)/10+' '+n 

Full program, 55 bytes:

n=Date().substr(13,2)*3+280,alert(-~(n/4-9.1)/10+' '+n) 

Getting the year was quite expensive, but after using the deprecated getYear() instead of getFullYear(), all of the numbers in the equation became smaller, saving a lot of bytes. EDIT: Thanks to an eeevil trick, I skipped new and getYear() altogether. >:D

Suggestions welcome!

Pyth, 30 bytes

.R+*.075J%.d3C\d6.105 1+*3J280 

My first Pyth program!

Thanks @Jakube for some hints (I would never have thought of those!)

Python 2, 80 bytes

from datetime import* y=date.today().year%40 print int(61.55+.75*y)/10.,y*3+280 

Now rounds!

CJam, 28 bytes

et0=100%__4/(-Ad/6+S@3*280+ 

Try it online

To try years other than the current one, replace the et0= at the start with the literal value of the year.

Python 3, 134 bytes

Works well but seems a bit long

from datetime import* y=str(date.today().year) z=int(y[2:]) m=str(60+(z-int((int(y)-2005)/4))) print("%s.%s"%(m[0],m[1]),310+(z-10)*3) 

AutoIt - 60 58 56 bytes

$_=@YEAR-2e3 ClipPut(($_-Int($_/4-1))/10+6&' 3'&3*$_-20) 

The rounding eats bytes (not anymore). I have now tweaked both formulas. Some sample outputs:

7.3 325 // 2015 7.3 328 7.4 331 7.5 334 // 2018 8.4 370 // 2030 

They all seem to be accurate.

A tip: Order of execution saves bytes on parentheses. For example: (a-4)/4 = a/4-1 :-).

PowerShell, 53 45 Bytes

$n=date -f yy;.1*[int](61.45+.75*$n);280+3*$n 

Uses a similar rounding trick as muddyfish's Python 2 answer to simplify the world population calculation, since PowerShell implicitly Round()s when you cast from a [double] to an [int], rather than truncating.

For the output, we assume that "followed by some delimiter (e.g. space or comma)" can also mean "newline", so we execute one result and then the second. PowerShell implicitly writes out results, so we don't need to explicitly call any printing commands.

Mathematica, 50 bytes

n=Today["YearShort"];{.1*(61+n-Floor[n/4]),280+3n} 

Note that this is dependent on having a Wolfram Engine with Version number 10+ (released 2014) due to dependence on DateObjects.

R, 64 bytes

n=as.numeric(format(Sys.time(),"%y")) c(.1*(61+n-n%/%4),280+3*n) 

Direct port of Mathematica code, think I had a shorter solution but dependent on packages whereas this works with base R.

Java, 180 177 166 152 143 bytes

Thanks Thomas for helping a noob out :)

class D{public static void main(String[]a){int f=java.time.LocalDate.now().getYear();System.out.printf("%.1f %d\n",(3.*f-5755)/40,3*f-5720);}} 

Ungolfed version:

class D { public static void main(String[]a) { int f = java.time.LocalDate.now().getYear(); System.out.printf("%.1f %d\n",(3.*f-5755)/40,3*f-5720); } } 

Requires Java 8.

JavaScript (ES6) 52

A function returning the output as an array.

(y=(new Date).getYear())=>[(y+~(y/4)-13)/10,y*3-20] 

Just for testing purpose, the function accepts an input equals to current year - 1900 (e.g. 105 for 2015)

That's in the line of the ETHproductions' answer (the math is the math) but avoding the evil trick it is more portable in different locales. And as a function it's 1 byte shorter.

Test snippet:

f=(y=(new Date).getYear())=>[(y+~(y/4)-13)/10,y*3-20] o=[]; for(a=2000;a<2050;a++)o.push(`<td>${a}</td><td>${f(a-1900)}</td>`); document.write(`<table><tr>${o.join`</tr><tr>`}</tr></table>`)

td { text-align:right; font-family:monospace }

Desmos, 140 Bytes

I'm counting a newline to be a signal for a new equation. Folders on the link are just for organization.

Golfed, 140 Bytes

Click add slider when prompted.

a=6+.1b-.1c d=280+3b c=\sum_{n=2005}^q\left\{0=\operatorname{mod}\left(n,4\right),0\right\} b=100\left|\operatorname{floor}\left(.01q\right)-.01q\right| 

Ungolfed, 261 Bytes

p_{world}=6+\frac{l_{astdig}-l_{eap}}{10} p_{us}=310+3\left(l_{astdig}-10\right) y_{ear}=2039 l_{eap}=\sum _{n=2005}^{y_{ear}}\left\{0=\operatorname{mod}\left(n,4\right),0\right\} l_{astdig}=100\left|\operatorname{floor}\left(\frac{y_{ear}}{100}\right)-\frac{y_{ear}}{100}\right| 

Ruby, 57 bytes

y=Time.now.year%40;puts "#{6+(y-(y-5)/4)*0.1} #{3*y+280}" 

Unfortunately, Time.now.year really costs some characters.

Glava, 77 bytes

i|f=java.time.LocalDate.now().getYear();F("%.1f %d\n",(3.*f-5755)/40,3*f-5720 

A translation of my Java answer.

PHP, 45 bytes

The code:

echo(int)(($x=3*date(y)+247)/4)*.1," ",$x+33; 

Because y (the argument of date()) is an undefined constant, PHP triggers a notice (that can be muted) and converts it to a string (as we need); this PHP courtesy allows saving 2 bytes.

In order to suppress the notice, the program needs to be run using the error_reporting=0 runtime directive, like this:

$ php -d error_reporting=0 -r 'echo(int)(($x=3*date(y)+247)/4)*.1," ",$x+33;' 7.3 325 

For testing

By replacing the call to date(y) with $argv[1] (the first command line argument), the program length increases with 1 byte but it can get the year from the command line.

The expected argument is the year minus 2000; it also works for negative values (years before 2000) or values greater than 40 (after year 2040).

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 00 6.1 280 $ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 01 6.2 283 $ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 02 6.3 286 $ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 03 6.4 289 $ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 04 6.4 292 $ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 15 7.3 325 $ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 39 9.1 397 

APL, 25 23 29 bytes

{(10÷⍨⌊⍵÷4),⍵+33}⊃¯5753+3×⎕TS 

TryAPL

Yes, it's 29 bytes.