[Question]
  [
This is my first golf contest.
**What you need to do**
Build me, in the shortest amount of bytes possible, my AC remote control system. My room is too cold right now, and I'm missing my remote.
Now, I don't want you literally building it or anything, just golf this:
A slow increment of temperature, starting at 40 degrees, and ending at exactly 72. The increment time must always be 500 millis per increment. It can wait another 500ms at the end. I would prefer it to stop however. The increment itself must go up by two each time, like my remote.
You should not clear the screen. You should have newlines.
**What should happen**
Example output (everything in parentheses shouldn't be outputted).
```
40
(wait 500 millis)
42
(wait 500 millis)
44
(..repeat until 72..)
72
(stop or wait 500ms)
```
**Keep in mind**
This is my first golf, so I apologize if this is too hard to golf. :(
Best of luck, golfers!
  
[Answer]
# Minecraft 1.9.0+, ~~204~~ 162 bytes + ~~58~~ ~~36~~ ~~28~~ ~~24~~ 20 blocks = ~~262~~ ~~240~~ ~~232~~ ~~186~~ 182 blytes
This solution is golfed down, and it can't be seen whole in one, or even two screenshots. Uses two glitches and abuses another two features of the game
[![RUN! MINECRAFT WILL KILL YOU!](https://i.stack.imgur.com/kPgVk.jpg)](https://i.stack.imgur.com/kPgVk.jpg)
This solution uses the same principles as the one below, just a 4 blocks more compact design.
* Abuses the fact that Chain command blocks (green blocks) can't be powered by redstone, only by a singal from a impulse command block (orange).
* Abuses the fact pistons take 0.30 seconds to extend completely, and redstone needs only 0.10s to register a signal.
* Also abuses a twofold glitch to set the timer (TNT) off: the redstone next to the timer (TNT) gets not only powered, but also thinks the TNT is another redstone and powers it.
* On top of all these abuses, the signal shortener (thing under the TNT) is one-use, after it gets powered it changes shape, allowing to pass signal *through* it to the "incrementer" (topmost orange block)
A bit of explanation on the functionality of it's different parts can be seen in older solutions (but best in the one just below). You can also **Try it Offline!** (simplified solution incrementing by 4, works only in 1.11+) **by running [this command](http://pastebin.com/L8R5j3TL) in a command block**.
---
### Old solution, Minecraft 1.9.0+, 186 blytes:
[![MINECRAFT ABUSE](https://i.stack.imgur.com/XCwBQ.png)](https://i.stack.imgur.com/XCwBQ.png)
Since TNT normally explode after 3.0s in Minecraft, this one has to be placed by a command (`/setblock`) with a specified fuse. Also uses a more compact design to remove redundant command block (containing 42 bytes) and redstone against the older versions. I'm sure this can't get any lower...
### Older solution, Minecraft 1.9.0+, 232 blytes:
Oops, I found out these older solutions increment by 4...
[![golfcraft](https://i.stack.imgur.com/DcLTx.png)](https://i.stack.imgur.com/DcLTx.png)
Uses the 1.9 command block chain feature (green block thing) to save blocks. Also uses a more compact signal shortener then in the older solutions
### Even older solution, Minecraft 1.7.0+, 240 blytes:
[![the soulless monster](https://i.stack.imgur.com/rU2DN.jpg)](https://i.stack.imgur.com/rU2DN.jpg)
Uses a more compact timer (TNT) then the first solution (below).
### Oldest solution, Minecraft 1.7.0+, 262 blytes:
[![the old monster](https://i.stack.imgur.com/CQRMd.png)](https://i.stack.imgur.com/CQRMd.png)
---
This is so long because of the way Minecraft handles variables:
* To define a variable (int): `scoreboard objectives add <variable> dummy`
* To set a value to a variable (each entity including players has it's own variable value): `scoreboard players set <entity> <variable> <value>`
	+ `*` can be used as `<entity>` to select all entities and save bytes.
	+ only defined variables may be used
	+ the value of the variable must be set to a number, not a variable
* To increment var1 by var2: `scoreboard players operation <entity> var1 += <entity> var2`
	+ `<entity>` must be a single entity, eg. `@p`, not `*`
---
Screenshots are of my own, dual licenced under [WTFPL](http://www.wtfpl.net/) and what licence SE decides to use today (currently `cc by-sa 3.0 with attribution required`) :-)
[Answer]
# Bash + linux utilities, 19
```
seq 40 2 72|pv -qlL2
```
`seq` generates the numerical output. `pv` ratelimits it to 2 lines/sec.
[Answer]
# Vim, ~~24~~, 23 bytes/keystrokes
```
i40<esc>qq:sl500m
Yp2<C-a>q15@q
```
*One byte saved thanks to @Kritixi Lithos!*
Written from my phone, tested in mobile vim (which is apparently a real thing).
Here's a gif of it running:
[![enter image description here](https://i.stack.imgur.com/yJJYh.gif)](https://i.stack.imgur.com/yJJYh.gif)
And here is a command-by-command explanation:
```
i40<esc>            " Insert '40' into the buffer
        qq          " Start recording into register 'q'
          :sl500m   " Sleep form 500 ms
Y                   " Yank this line
 p                  " and paste it on a newline
  2<C-a>            " Increment this line twice
        q           " Stop recording
         15@q       " Callback register 'q' 15 times
```
[Answer]
# JavaScript (ES6), 52 bytes
```
f=(i=40)=>console.log(i)|i-72&&setTimeout(f,500,i+2)
f()
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~13~~ 12 bytes
```
40µṄœS.+2µ⁴¡
```
[Try it online!](https://tio.run/nexus/bash#088vKNHPSs3JqYSQCqmleQrq/00MDm19uLPl6ORgPW2jQ1sfNW45tPC/ukKNQnlGZk6qQlFqYoq1Qko@F2dBUWZeSZqCumqxFQgZmOgZpsWUqBbH5KkrqGikJJakKqhrq3ooqPoqqAbrqfqpayqoBLkG@ERypeTnpf4HAA "Bash – TIO Nexus") The Jelly program is wrapped in a Bash script to prefix each line of output by a timestamp.
### How it works
```
40µṄœS.+2µ⁴¡  Main link. No arguments.
40             Set the return value to 40.
  µ      µ⁴¡  Execute the chain between the two µ 16 times.
   Ṅ           Print the return value, followed by a linefeed.
      .        Yield 0.5.
    œS         Sleep for 0.5 seconds. Yield the previous result.
       +2      Add 2.
```
After the last iteration, the final value of **72** is printed implicitly and the program exits.
[Answer]
# [Perl 6](http://perl6.org/), 30 bytes
```
for 20..36 {sleep .5;say 2*$_}
```
Sorry that it looks like un-golfed code, I don't see a way to make it shorter...
The version that stops right after the last number, would be 37 bytes:
```
for 20..36 {sleep .5 if $++;say 2*$_}
```
[Answer]
# Pyth - 12 bytes
Very simple, uses a for loop from 0-17.
```
V17+40yN.d.5
```
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 20 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
{⎕DL.5⊣⎕←⍵}¨38+2×⍳17
```
`{` the anonymous function
 `⎕DL` delay...
 `.5⊣` half (a second) rather than the value of
 `⎕←` print (with newline)
 `⍵` the argument
`}¨` applied to each of
`38+` thirty eight plus
`2×` twice
`⍳17` the integers from 1 to 17
[Answer]
# TI-Basic (CE or CSE only), 16 bytes
```
:For(A,40,72
:Pause A,.5
:End
```
Note that many commands are single byte tokens.
[Answer]
# C compiled with Clang 3.8.1 on Linux, ~~62~~ ~~59~~ 58 bytes
*2 bytes saved thanks to @ranisalt*
```
s=38;main(){for(;s<74;printf("%d\n",s+=2))usleep(500000);}
```
**59 bytes**
```
s=38;main(){for(;s<73;printf("%d\n",s+=2+usleep(500000)));}
```
**62 Bytes**
```
s=38;main(){for(;s!=72;){printf("%d\n",s+=2);usleep(500000);}}
s=38                # Initializes a global (int) variable, this is only possible in C, in other languages from the C family variables must have an explicit type.
main()              # Is the main entry point, again as before, in case a type isn't specified C defaults to int
printf("%d\n",s+=2) # printf outputs to stdout based on the pattern defined in the first parameter 
                    # %d is a placeholder for an int variable
                    # \n appends a newline to stdout
                    # The second parameter increments the s variable and afterwards it goes in the placeholder's spot.
usleep(500000)      # This function is Linux specific, it takes an int as parameter, it represents how much time the app needs to sleep in microseconds
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 14 bytes
```
17:E38+".5Y.@D
```
Try it in [MATL Online!](https://matl.io/?code=17%3AE38%2B%22.5Y.%40D&inputs=&version=19.7.0) You may need to reload the page if it doesn't initially work.
### Explanation
```
17:     % Push array [1 2 ... 17]
E       % Multiply by 2, element-wise
38+     % Add 38, element-wise. This gives [40 42 ... 72]
"       % For each k in that array
  .5Y.  %   Pause 0.5 seconds
  @D    %   Push k and display
        % End (implicit)
```
---
## Old version (before spec change), clearing the screen
```
17:E38+"5&Xx@D
```
Try it in [MATL Online!](https://matl.io/?code=17%3AE38%2B%225%26Xx%40D&inputs=&version=19.7.0)
[Answer]
# Mathematica, 34 bytes
```
Pause[Print@#;.5]&/@Range[40,72,2]
```
Full program. Takes no input and outputs to STDOUT.
[Answer]
## R, 49 bytes
```
x=38;while(x<72){Sys.sleep(.5);x=x+2;cat(x,"\n")}
```
Very trivial solution but it does the trick.
[Answer]
# [Perl 6](http://perl6.org), 27 bytes
```
sleep .say/2 for 40,42...72
```
`say` returns `True`, which is coerced to a numeric `1` when divided by `2`.
Unicode shenanigans can get it down to 23 characters:
```
sleep .say/2 for ㊵,㊷…72
```
But that's 29 UTF-8-encoded bytes.
[Answer]
# Python 2, ~~57 56~~ 55 Bytes
```
import time
a=40
while a<73:print a;time.sleep(.5);a+=2
```
EDIT:
-1 Byte thanks to Mega Man
-1 Byte thanks to Flp.Tkc
[Answer]
## Ruby, 33 bytes
```
(40).step(72,2){|n|p n;sleep 0.5}
```
[Answer]
# C#, 95 bytes
```
()=>{for(int i=40;i<73;i+=2){System.Console.WriteLine(i);System.Threading.Thread.Sleep(500);}};
```
It is a simple for loop, it waits an extra 500ms at the end.
[Answer]
## [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 21 bytes
```
[44,72,4|?a┘'sleep 1.
```
QBIC starts a FOR-loop, running from 44 to 72 and incrementing the counter by 4 on every loop. It then sleeps for 1 second. QBasic doesn't have a more finegrained control foor `sleep`, so I've added a `.` to simulate giving `.5` as an argument.
[Answer]
# Kotlin, 47 bytes
I guess it was not said in the problem statement that solutions should actually contain increment by two, so the `40+2*i` is legal here.
If written as a regular Kotlin source with `main`:
```
fun main(args:Array<String>){(0..16).map{println(40+2*it);Thread.sleep(500)}}
```
(77 bytes)
**UPD**: In Kotlin 1.3, `args:Array<String>` can be removed, so it's 18 bytes less.
And in Kotlin Script, the whole program would be
```
(0..16).map{println(40+2*it);Thread.sleep(500)}
```
(47 bytes)
[Answer]
# Ruby 31 bytes
```
20.upto(36){|n|p n*2
sleep 0.5}
```
[Try it online!](https://tio.run/##FczBCsIgAAbgcz7Ff5i4FYlt1aHOQYeKqFOwi0PHBsOJOiKyZ7eC7/w10nfJTc0LSw2WSsEnG8a82hbvaKKFmZfED1pbCL75JIaIZ9cPGk5LtYcaycy63oQWjPrdn1jzVVsH6mvDkOVKhl@8oEfQM@id0wsrkN0O19ODqNHo9AU "Bash – TIO Nexus")
[Answer]
## Haskell, 67 bytes
```
import System.Posix.Unistd
mapM((>>usleep 500000).print)[40,42..70]
```
If you want to go with ghc only, you can save a few bytes by importing `GHC.Conc` and using `threadDelay` instead of `usleep`. 
[Answer]
# php, 38 bytes
```
for(;35>$t+=2;usleep(5e5))echo$t+38,_;
```
uses underscore as delimiter. Run with `-nr`.
[Answer]
## Clojure, 54 bytes
```
(doseq[t(range 32 73 2)](println t)(Thread/sleep 500))
```
Third lisp ftw. Just iterates over the range, printing and sleeping each iteration. Sleeps at the end. 
Ungolfed:
```
(doseq [t (range 32 73 2)]
    (println t)
    (Thread/sleep 500)))
```
## A version that doesn't sleep at the end, 66 bytes
```
(doseq[t(range 32 73 2)](println t)(if(< t 72)(Thread/sleep 500)))
```
Note, these are full programs since the instructions don't specify. Add a byte to each if a function is required. 
[Answer]
## Racket 46 bytes
```
(for((i(range 40 73 2)))(println i)(sleep .5))
```
Ungolfed: 
```
(define (f)
  (for ((i (range 40 73 2)))
    (println i)
    (sleep .5)))
```
Command to run: `(f)`
[Answer]
# Octave, ~~38~~ 35 bytes
*Saved 3 bytes thanks to @LuisMendo by changing `endfor` to `end`*
```
for i=20:36;disp(2*i);sleep(.5);end
```
[Try it online!](https://octave-online.net/#cmd=for%20i%3D20%3A36%3Bdisp(2*i)%3Bsleep(.5)%3Bend)
I am new to Octave, so this solution still might be golfed further. Any tips are welcome!
### Ungolfed
```
for i=20:36
  disp(2*i)
  sleep(.5)
end
```
[Answer]
# Python 2, ~~57~~ 58 Bytes
**Edit**
Counted as 57 bytes on my handy but TIO says 58 now that I'm back on my own machine so that's my final offer. Interestingly enough TIO doesn't seem to respect the timeout and just waits and then prints out the whole list in one go. Works on QPython for Android and Python 2 on my Ubuntu box so that's good enough for me.
```
import time
for x in range(40,74,2):print x;time.sleep(.5)
```
[Try it online!](https://tio.run/nexus/python2#@5@ZW5BfVKJQkpmbypWWX6RQoZCZp1CUmJeeqmFioGNuomOkaVVQlJlXolBhDVKkV5yTmlqgoWeq@f8/AA "Python 2 – TIO Nexus")
Would be ~~58~~ 59 in Python 3 so doesn't beat @sonrad10 anyway.
[Answer]
# R, ~~44~~ 42 bytes
Straightforward for-loop, there's likely a golfier way. (Also, crossed-out 44 is still regular 44...)
```
for(i in 20:36*2)cat(i,"\n",Sys.sleep(.5))
```
[Answer]
# F#, 60 bytes
`async{for i in 40..2..72 do printfn"%d"i;do!Async.Sleep 500}`
This is an async expression, in order to run it pass it into `Async.Start` or `Async.RunSynchronously`.
[Answer]
# [Noodel](https://tkellehe.github.io/noodel/), noncompeting 10 bytes
Cannot compete because *Noodel* was born after the challenge was created:(
```
40Ḷ16ñ++ḍh
```
[Try it:)](https://tkellehe.github.io/noodel/editor.html?code=40%E1%B8%B616%C3%B1%2B%2B%E1%B8%8Dh&input=&run=true)
### How it works
```
40         # Creates the literal number 40 and places it into the pipe.
  Ḷ16      # Loop the following code 16 times.
     ñ     # Print what is in the front of the pipe with a new line.
      ++   # Increment what is in the pipe by two.
        ḍh # Delay for a half a second (500ms).
```
---
There is not a version of *Noodel* that supports the syntax used in this answer. Here is a version that is correct:
```
kȥḶ16ñ⁺2ḍh
```
```
<div id="noodel" code="kȥḶ16ñ⁺2ḍh" input="" cols="10" rows="17"></div>
<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>
```
[Answer]
# Windows Batch - ~~65 62~~ 61 bytes
*btw this is my first PPCG answer*
```
@for /l %%p in (40,2,72)do @echo %%p&@ping 1.1 -n 1 -w 10>nul
```
This exits when the degree reaches 72.
---
# ~~76~~ 75 bytes - Does not sleep at end
```
@for /l %%p in (40,2,72)do @echo %%p&if %%p lss 72 @ping 1.1 -n 1 -w 10>nul
```
---
]