[Question]
  [
On most [new-years](/questions/tagged/new-years "show questions tagged 'new-years'") challenges when it is currently not the corresponding year of the challenge, It says this in the front.
> 
> It's [current year] already, folks, go home.
> 
> 
> 
You have to output this text with the current year substituted.
---
# I/O
**Input:** None.
**Output**: `It's [current year] already, folks, go home.`
  
[Answer]
# bash + date, 40 bytes
```
date +"It's %Y already, folks, go home."
```
[Try it online!](https://tio.run/nexus/bash#@5@SWJKqoK3kWaJerKAaqZCYU5SamFKpo5CWn5NdrKOQnq@QkZ@bqqf0/z8A "Bash – TIO Nexus")
[Answer]
# C (gcc), 58 bytes
```
f(){printf("It's%s already, folks, go home.",__DATE__+6);}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~21~~ 20 bytes
Saved a byte thanks to *Erik the Outgolfer*
```
žg“It's ÿˆ§,¹Ò,‚œ€¨.
```
[Try it online!](https://tio.run/nexus/05ab1e#ASUA2v//xb5n4oCcSXQncyDDv8uGwqcswrnDkizigJrFk@KCrMKoLv// "05AB1E – TIO Nexus")
[Answer]
# TeX (44 bytes)
```
It's \the\year\ already, folks, go home.\bye
```
[Answer]
# PHP, 42 bytes
```
It's <?=date(Y)?> already, folks, go home.
```
[Answer]
# Bash, 45 characters
```
printf "It's %(%Y)T already, folks, go home."
```
Bash's built-in `printf` in version 4.2 got the `%(fmt)T` format specifier and since version 4.3 it defaults to current timestamp in absence of argument.
Sample run:
```
bash-4.3$ printf "It's %(%Y)T already, folks, go home."
It's 2017 already, folks, go home.
```
[Answer]
## Batch, 45 bytes
```
@echo It's %date:~6% already, folks, go home.
```
Batch is actually reasonably competitive for once.
[Answer]
## Mathematica, 53 bytes
```
Print["It's ",Now[[1,1]]," already, folks, go home."]
```
[Answer]
# [Python 2](https://docs.python.org/2/), 67 bytes
```
import time
print"It's",time.gmtime()[0],"already, folks, go home."
```
[Try it online!](https://tio.run/nexus/python2#@5@ZW5BfVKJQkpmbylVQlJlXouRZol6spAMS0EvPBVEamtEGsTpKiTlFqYkplToKafk52cU6Cun5Chn5QEVK//8DAA "Python 2 – TIO Nexus")
[Answer]
# x86 machine code on DOS - 62 bytes
```
00000000  b4 04 cd 1a bf 23 01 88  c8 24 0f 00 05 4f c1 e9  |.....#...$...O..|
00000010  04 75 f4 ba 1b 01 b4 09  cd 21 c3 49 74 27 73 20  |.u.......!.It's |
00000020  30 30 30 30 20 61 6c 72  65 61 64 79 2c 20 66 6f  |0000 already, fo|
00000030  6c 6b 73 2c 20 67 6f 20  68 6f 6d 65 2e 24        |lks, go home.$|
0000003e
```
Even though the input from the BIOS is in BCD (as opposed to the plain 16 bit value got from the equivalent DOS call), decoding it to ASCII turned out to be almost as long as base-10 printing a register. Oh well.
```
    org 100h
section .text
start:
    mov ah,4
    int 1ah             ; get the date from BIOS; cx now contains the year in packed BCD
    mov di,placeholder  ; put di on the last character of placeholder
lop:
    mov al,cl
    and al,0xf  ; get the low nibble of cx
    add [di],al ; add it to the digit
    dec di      ; previous character
    shr cx,4    ; next nibble
    jnz lop     ; loop as long as we have digits to unpack in cx
    mov dx,its
    mov ah,9
    int 21h     ; print the whole string
    ret
its:
    db "It's 000"
placeholder:
    db "0 already, folks, go home.$"
```
[Answer]
## Ruby, 52 bytes
```
puts"It's #{Time.now.year} already, folks, go home."
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 38 bytes
```
"It's "et0=" already, folks, go home."
```
[Try it online!](https://tio.run/nexus/cjam#@6/kWaJerKCUWmJgq6SQmFOUmphSqaOQlp@TXayjkJ6vkJGfm6qn9P8/AA "CJam – TIO Nexus")
[Answer]
# Mathematica, 58 bytes
```
"It's "<>ToString@#<>" already, folks, go home."&@@Date[]&
```
Anonymous function. Takes no input and returns a string as output. No, I'm not going to make a REPL submission, post it yourself if that one byte is so important.
[Answer]
# [Perl 6](https://perl6.org), ~~53~~ 51 bytes
```
say "It's {Date.today.year} already, folks, go home."
```
[Try it](https://tio.run/nexus/perl6#@1@cWKmg5FmiXqxQ7ZJYkqpXkp@SWKlXmZpYVKuQmFOUmphSqaOQlp@TXayjkJ6vkJGfm6qn9P8/AA "Perl 6 – TIO Nexus")
```
say "It's {now.Date.year} already, folks, go home."
```
[Try it](https://tio.run/nexus/perl6#@1@cWKmg5FmiXqxQnZdfrueSWJKqV5maWFSrkJhTlJqYUqmjkJafk12so5Cer5CRn5uqp/T/PwA "Perl 6 – TIO Nexus")
[Answer]
# TI-Basic (TI-84 Plus CE with OS 5.2+), 64 bytes
```
getDate
"It's "+toString(Ans(1))+" already, folks, go home.
```
TI-Basic is a tokenized language. Some commands (`getDate`, `toString(`, etc.), and all lowercase letters are two-bytes and everything else used here is one byte each.
Explanation:
```
getDate                                             # 3, store {Y,M,D} in Ans
"It's "+toString(Ans(1))+" already, folks, go home. # 61, implicitly return required string with Y from getDate
```
# TI-Basic (TI-84 Plus CE with OS 5.1), 108 bytes
```
{0,1→L1
getDate
Ans(1)L1→L2
LinReg(ax+b) Y1
Equ►String(Y1,Str0
sub(Str0,1,length(Str0)-3→Str0
"It's "+Str0+" already, folks, go home.
```
TI-Basic is a tokenized language. The more complicated user variables (`Y1`, `L1`, `L2`, `Str0`), some commands (`LinReg(ax+b` , `getDate`, `sub(`, `Equ►String(`, `length(`), and all lowercase letters are two-bytes and everything else used here is one byte each.
OS 5.2 added a `toString(` command, which obsolesces about half of this submission, which is based off of [this algorithm](http://tibasicdev.wikidot.com/number-to-string).
Explanation:
```
{0,1→L1                                  # 8 bytes
getDate                                  # 3 bytes, store {Y,M,D} list in Ans
Ans(1)L1→L2                              # 10 bytes, multiply L1 by the year and store in L2
LinReg(ax+b) Y1                          # 5 bytes, take a linear regression of the points specified by each pair of corresponding coordinates in L1 and L2 and store it in Y1
Equ►String(Y1,Str0                       # 8 bytes, convert Y1 to a string
sub(Str0,1,length(Str0)-3→Str0           # 18 bytes, remove the "X+0" from LinReg
"It's "+Str0+" already, folks, go home.  # 56 bytes, implicitly return the required output
```
[Answer]
# JavaScript ES6, 56 bytes
```
_=>`It's ${Date().split` `[3]} already, folks, go home.`
```
### Try it online!
```
const f = _=>`It's ${Date().split` `[3]} already, folks, go home.`
console.log(f())
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 31 bytes
```
`It's {Ki} alÎ%y, folks, go Êà.
```
[Try it online!](https://tio.run/nexus/japt#@5/gWaJerFDtnVmrkJhzuE@1UkchLT8nu1hHIT1f4XDX4QV6//8DAA "Japt – TIO Nexus")
[Answer]
## PowerShell 3.0, 44 bytes
```
"It's $(date|% y*) already, folks, go home."
```
PowerShell is competing quite well today!
[Answer]
# R, ~~62 59~~ 62 bytes
```
cat("It's",format(Sys.time(),"%Y"),"already, folks, go home.")
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~39~~ 27 bytes
```
`It's % ×ġ, ṗḊ, go λ∵.`kðt%
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgSXQncyAlIMOXxKEsIOG5l+G4iiwgZ28gzrviiLUuYGvDsHQlIiwiIiwiIl0=)
Surely golfable?
[Answer]
# C#, 58 bytes
```
()=>"It's "+DateTime.Now.Year+" already, folks, go home.";
```
Anonymous function which returns the required string.
Full program:
```
using System;
                    
public class Program
{
    public static void Main()
    {
        Func<string> f=
        ()=>"It's "+DateTime.Now.Year+" already, folks, go home.";
        
        Console.WriteLine(f());
    }
}
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 38 bytes
```
s["It's ".d3" already, folks, go home.
```
[Online interpreter.](//pyth.herokuapp.com?code=s%5B%22It%27s+%22.d3%22+already%2C+folks%2C+go+home.)
[Answer]
# [Haskell](https://www.haskell.org/), 113 bytes
```
import Data.Time.Clock
f=do t<-getCurrentTime;putStr$"It's "++(fst.span(>'-').show)t++" already, folks, go home."
```
[Try it online!](https://tio.run/nexus/haskell#FcxBDoMgEADAe1@xISZoUD7Q2oteerYf2FRQIrAE1jR9PW3Pk0x1IVFmmJFRP10wevL0Oi52XAn4NmyGpzNnE/mP13TywrkRD5YFhFKtLaxLwtje5SA7XXZ6d6yUAPTZ4PrpwZI/Sg8bwU6/XtSALsIItn4B "Haskell – TIO Nexus") Replace `f` with `main` for a full program.
The function `getCurrentTime` returns a `UTCTime` object which looks something like `"2017-04-02 10:22:29.8550527 UTC"` when converted to a string by `show`. `fst.span(>'-')` takes the leading characters while they are larger than `'-'`, that is the current year. For the next 7972 years `take 4` would work for 8 bytes less, but we want our code to work correctly for ever and ever.
As far as I see build-in functions to get the current year require a `import Data.Time.Calendar`, so extracting the year from the string should be the shortest option.
[Answer]
# JavaScript, ~~77~~ ~~71~~ ~~67~~ 63 bytes
```
alert("It's "+Date().split(' ')[3]+" already, folks, go home.")
```
Thanks to @programmer5000 for the spaces!
# JavaScript ES6 ~~66~~ 60 bytes
```
alert(`It's ${Date().split` `[3]} already, folks, go home.`)
```
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), ~~57~~ 55 bytes
```
"emoh og ,sklof ,ydaerla@ s'tI"4k,y\4*:*/"&2"*+.f7+k,@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/Xyk1Nz9DIT9dQac4Oyc/TUGnMiUxtSgn0UFEoVi9xFPJJFunMsZEy0pLX0nNSElLWy/NXDtbx@H/fwA "Befunge-98 (FBBI) – Try It Online")
Thanks to James Holderness for pointing out my mistake with the sysinfo instruction.
`"emoh og ,sklof ,ydaerla@ s'tI"` pushes the sentence to the stack where `4k,` prints the first word. `y` is the sysinfo instruction. When passed 20 (the unprintable in the string), it returns `256*256*(year-1900) + 256*month + day of month`. `\4*:*/"&2"*+.` takes just the year from the value and prints it and`f7+k,` prints the rest of the sentence.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 48 bytes
```
"It's #{Time.new.year} already, folks, go home."
```
[Try it online!](https://tio.run/nexus/golfscript#@6/kWaJerKBcHZKZm6qXl1quV5maWFSrkJhTlJqYUqmjkJafk12so5Cer5CRD1Sh9P8/AA "GolfScript – TIO Nexus")
Yes, this is string interpolation.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 42 bytes
```
'It''s '1&Z'V' already, folks, go home.'&h
```
[Try it online!](https://tio.run/nexus/matl#@6/uWaKuXqygbqgWpR6mrpCYU5SamFKpo5CWn5NdrKOQnq@QkZ@bqqeulvH//9e8fN3kxOSMVAA "MATL – TIO Nexus")
```
'It''s '                      % Push this string
1&Z'                          % Push current year
V                             % Convert to string
' already, folks, go home.'   % Push this string
&h                            % Concatenate all stack contents horizontally
                              % Implicitly display
```
[Answer]
# Python 3, ~~73~~ 68 bytes
```
import time
print(time.strftime("It's %Y already, folks, go home."))
```
Very basic answer. The "%Y" gets the current year.
*Thanks to @ovs for removing 5 bytes*
[Answer]
## IBM/Lotus Notes Formula, 54 bytes
Not exactly challenging but here we go anyway...
```
"It's "+@Text(@Year(@Now))+" already, folks, go home."
```
[Answer]
**VBScript, 53 bytes**
```
msgbox"It's "&year(now())&" already, folks, go home."
```
]