text:
Is it Christmas?
Challenge
Given that Christmas is:

December
Month 12
Day 25

Every year, determine today's date, and whether or not today is Christmas.
If it is Christmas, you must print "It's Christmas". If it is not Christmas, you must somehow wait until Christmas and then print "It's Christmas".
Example
From this Stack Overflow Question
import time
while time.strftime("%b, %d", time.localtime()) != "Dec, 25":
    time.sleep(60)
print "It's Christmas"

Python in 115 Characters
Rules
Here are the rules:

Assume that the computer's clock is always right.
Your code must be able to be started at any time.
Your code must print "It's Christmas" on Christmas.
Looping is certainly not necessary, but once started your code should not stop until it has printed.
Shortest code wins.

I thought the input is in Julian date before I read this post

Unix, 39 bytes
echo{,} "It\'s christmas"|at -t12252359

With help from Dennis, thanks for that.

This violates »Looping is certainly not necessary, but once started your code should not stop until it has printed.«, though.

I don't understand your critique. Do you claim this is looping? That it stops before printing?

Using echo{,} "It\'s Christmas"|at -t12252359, this is shorter than the accepted answer. (The backslash is required by the way.)

@Dennis: Nice use of brace expansion.

PowerShell, 45 46 chars
for(;(date).date-ne'12/25'){}"It's Christmas"

It's certainly not very power-efficient, so a laptop battery might die before Christmas (reason to wish for a new one, maybe). But not sleeping is definitely shorter.
This is also locale-agnostic. And thanks to Jaykul for a nice trick in reducing this further.
Abusing the rules a bit, 45 chars
for(){"It's Christmas"*((date)-like'12/25*')}

This will print empty lines until it's Christmas, upon which it will print “It's Christmas”.
It ...

... can be started at any time.
... prints “It's Christmas” on Christmas. Several times. The whole day long. (The rules didn't say anything about how often it may be printed.)
... does not print “It's Christmas” on not-Christmas (although it prints an empty line in that case; can be rectified by sacrificing another character, but then this gains nothing over the more sane solution above).
... does not ever stop (not even after it has printed “It's Christmas” but definitely not before).

for(;(date).date-ne"12/25"){}"It's Christmas"  # 45 chars

Jaykul: Thanks ... that's something I never would have thought to be working.

The "abusive" script could also use -match, and do without the wildcard, for no gain/loss in characters.

You can remove the abuse now, it's unneeded.

@EriktheGolfer: How so? It still offers an interesting alternative approach, even though it's not shorter.

Perl + Unix, 40 chars
1until`date`=~/c 25/;say"It's Christmas"

This is the same as J B's Perl solution, except that I save a few chars by using the external date command instead of Perl's localtime.

PostScript, 90
(%Calendar%)currentdevparams begin{Month 12 eq Day 25 eq and{exit}if}loop(It's Christmas)=

Don't run on a printer, it doesn't print a page, and it will only DoS your printer until Christmas day.  Then again, getting your printer back would be a nice present.

Don't forget to tape a sign to the printer saying: DO NOT KILL JOB UNTIL CHRISTMAS!

I guess most printers won't even have a working hardware clock as that's an optional feature. Very nice, though :)

Mathematica, 47
While[Date[][[2;;3]]!={12,25}];"It's Christmas"

I was surprised that Mathematica doesn't have a built-in for Xmas.

Perl, 44 45
perl -E'1until localtime=~/c 25/;say"It's Christmas"'

Wouldn't GMT time be sufficient? (3 characters off ;-)

1until localtime=~/c 25/; would save you one char. :)

I thought I'd already tried that and it failed, but it turns out I actually forgot -E at the time.  Thanks!

No problem.  (Ps. I just posted a version of your solution using backticks instead of localtime below.  Feel free to steal it if you like, but I felt the extra dependency justified a separate answer.)

Naaaw, shame's on me for not thinking of it again. The separate answer is perfectly justified IMO (and upvoted).

Perl, 45
{localtime=~/c 25/&&die"It's Christmas";redo}

Perl, 44
using ternary operator (Thanks to Ilmari Karonen).
{localtime=~/c 25/?say"It's Christmas":redo}

? : instead of && ; would save you one char too.  (And I'd use say instead of die for prettier output.)

@Ilmari Karonen: thanks. But by using say instead of die, the script never finish.

It will, if you use the ternary operator.

@Ilmari Karonen: yes, of course. May be i'm too tired !!!

Javascript, 51 chars
It's a CPU killer:
while(!/c 25/.test(Date()));alert("It's Christmas")

R (47)
while(!grepl("c 25",date())){};"It's Christmas"

while(!grepl("c 25",date()))0;"It's Christmas" is 1 byte shorter.

I wanted to do this without parsing strings. Subsequently, there's a lot of magic numbers in my code.
I did some approximation to account for leap years. No one said that it had to print it out right on 00:00:00, Dec. 25!
Perl, 80 69 57 characters
{(time-30931200)%31557600<86399?die"It's Christmas":redo}

Edited for more concise looping!

Python, 66 68
import time
while'c 25'not in time.ctime():1
print"It's Christmas"

That 1 at the end of the second line looks quite suspicious to me. :P

@Trimsty:  The 1 provides a body for the while-loop.  It's basically a busy wait until December 25.  It has the similar effect to while 1:if'c 25'in time.asctime():break.

Ah, okay, thanks for clearing that up.

I think time.ctime() would do.

@gnibbler:  Indeed it would.  Nice catch.

TI-BASIC, 42 38
Repeat 769=sum(getDate²,2
End
"It's Christmas

Expects the date format to be YYYY/MM/DD.
getDate creates a three-element list {year,month,day}; only on Christmas is month^2 + day^2 equal to 769.
23 bytes are used for the string because lowercase letters are two bytes each, except for i which is displayed as the imaginary unit token.

(pdf)eTeX - 180 chars only December 1-25.
\lccode`m`~\let\e\expandafter\def~{\ifdim900pt<\pdfelapsedtime
sp\pdfresettimer\else\e~\fi}\lowercase\e{\e\scantokens\e
{\romannumeral\numexpr (25 - \day)*96000}}It's Christmas!\bye

TeX only has a way to access the date when the program starts, and the time elapsed since the start, capped at 32768 seconds, so I need to compute the number of seconds to wait, and for each second do a loop which waits for the elapsed time to reach 1s and reset the time. (Precisely, I'm doing blocks of 900 seconds.)
Working for any month requires more work: 355 chars.
\lccode`m=`~\let\o\or\let\y\year\let\n\numexpr\let\e\expandafter
\def\b#1{\ifnum#1=\n(#1/4)*4\relax+1\fi}\def~{\ifdim
900pt<\pdfelapsedtime sp\pdfresettimer\else\e~\fi}\lowercase
\e{\e\scantokens\e{\romannumeral\n(25-\day+\ifcase\month\o334\b\y
\o303\b\y\o275\o244\o214\o183\o153\o122\o91\o61\o30\o0\ifnum25<\day
365\b{\n\y+1}\fi\fi)*96000}}It's Christmas!\bye

Batch file, 68 chars
:l
@date/t|findstr/c:"-12-25">nul&&echo It's Christmas&&exit
@goto l

Not usable interactively, as it kills the session. Solving that would require 5 more characters.
Also locale-sensitive. This works on my locale which uses ISO 8601 date format.
But hey, it's a batch file (by most not even regarded as a programming language). And shorter than Javascript (and on par with Python).

Groovy, 55
while(!new Date()==~/.*c 25.*/);
println"It's Christmas"

Think it works, but still waiting for output.

If Groovy's regexps are anything like in most other languages, those .* are entirely unnecessary.  (Ps. You can test it by waiting for Dec 5 instead of 25.)

Ilmari, Groovy is a JVM language and Java's regexes are anchored by default.

Ilmari, I'd check but my program is still running

Ruby, 53
until Time.now.to_s=~/c 25/
end
puts"It's Christmas!"

MySQL, 180 chars
Because what are you using your database engine for, anyway?
DELIMITER $$
CREATE FUNCTION c() RETURNS CHAR(14) BEGIN a: LOOP IF DAY(NOW())=25 && MONTH(NOW())=12 THEN RETURN 'It\'s Christmas'; END IF; END LOOP a; END$$
DELIMITER ;
SELECT c();

Not very competitive lengthwise, but hey, it's doable!

Try DELIMITER /, RETURNS TEXT and CURDATE()LIKE'%12-25'; and try to remove some whitespace.

PHP, 40 bytes
<?while(date(dm)-1225);?>It´s Christmas;

Loop until 25th of December; then exit to plain mode and print.
Run with default settings (don´t display notices).

8086 machine code, 33 bytes
00000000  b4 2a cd 21 81 fa 19 0c  75 f6 b4 09 ba 12 01 cd  |.*.!....u.......|
00000010  21 c3 49 74 27 73 20 43  68 72 69 73 74 6d 61 73  |!.It's Christmas|
00000020  24                                                |$|
00000021

Forth (gforth), 84 bytes
: f begin time&date drop 12 = 0<> swap 25 = 0<> and until s" It's Christmas!" type ;

Try it online!
Yet another stack language. Somehow not the longest answer.
The time&date word is very convenient here.
A stack overflow happens since time&date values are left on stack every iteration.

Javascript, 93 89 78 77 chars
function x(){Date().match("c 25")?alert("It's Christmas"):setTimeout(x,1)}x()

@Joey Thanks! I forgot about that.

Another non-blocking version: setInterval('/c 25/.test(Date())&&alert("It\'s Christmas")',9) at 61 chars ... the only drawback is that it will alert() all day on Christmas.

Why setInterval to 1? setInveral to 1000*60*60*24 and it both won't make the process suffer and will notify only once on christmas.

D, 130
import std.datetime,std.stdio;
main(){
do{
auto t = Clock.currTime();
}while(t.month!=12||t.day!=25);
writeln("It's Christmas");
}

You can probably save two characters in the assignment. And a few more by reducing the number of lines.

I can also save some by using t.month^12|t.day^25 (if I get my priorities right)

Q, 63 chars
system"t 1000";.z.ts:{$["12.25"~-5#-3!.z.d;1"It's Christmas";]}

will work for christmas day on every year

SQL*Plus + PL/SQL - 100
EXEC LOOP EXIT WHEN TO_CHAR(SYSDATE,'DDMM')='2512';END LOOP;DBMS_OUTPUT.put_line('It''s Christmas');

Assuming SERVEROUTPUT ON
Shorter then the MySql solution (eat that, MySql!)
Too late for last year, but in time for this year
Tried DBMS_OUTPUT.put instead of DBMS_OUTPUT.put_line but that doesn't print anything.

C# (126)
using System;class P{static void Main(){while(DateTime.Now.Date.ToString("Md")!="1225");Console.WriteLine("It's Christmas");}}

Nicer for your battery:
C# (163)
using s=System;class P{static void Main(){s.Threading.Thread.Sleep(s.DateTime.ParseExact("1225","Md",null)-s.DateTime.Now);s.Console.WriteLine("It's Christmas");}}

edit
The second ("nicer for your battery") version does have a bit of an issue dec. 26th to dec. 31st I just thought of :P
Both versions can probably be shortened a bit more.

SmileBASIC, 49 47 bytes
DTREAD OUT,M,D?"It's Christmas"*(M/D==.48)EXEC.

month/day will be 0.48 on December 25th.

Japt, 27 bytes
Ks f"c 25" ?`It's CËItµs`:P

To test against today's date : Replace c 25 with this month's last letter (shorthand) + space + day of the month. Feb 02 == b 02
Try it online!

VBA, 58 Bytes
Anonymous VBE immediates window function that takes no input and runs until it's Christmas day, at which time it outputs It's Christmas to the VBE immediates window.

While Left(Now,5)<>"12/25":DoEvents:Wend:?"It's Christmas"

05AB1E, 28 21 bytes
[že25Qžf12Q&#}”It'sŒÎ

Try it online!
Noncompeting, I suppose(Beats the other non-competing answer, ha).
My first 05AB1E answer.
-7 bytes from ovs.
Explanation
[že25Qžf12Q&#”It'sŒÎ
[                            start an infinite loop
 že                          push current day
   25                        25
     Q                       are they equal?
      žf                     push current month
        12                   12
          Q                  are they equal?
           &                 logical and
            #                break if both conditions are true
             ”It'sŒÎ         push "It's Christmas"
                             implicit output

This will not output It's Christmas is the execution is started on Christmas, since "It's Christmas is part of the loop and won't get executed if # breaks on the first iteration. This can be fixed by closing the loop after # with }.

And with the help of Kevin's tip on compression, the string literal can be shortened to ”It'sŒÎ.

@Shaggy It loops infinitely and breaks on christmas. When it breaks, it prints the value. I think it's correct.

Sorry, @Razetime, missed the infinite loop at the start :\

Thunno 2, 23 bytes
(kNkM,¿⁺P¿Q)’It's ñẈmas

Try it online!
Explanation
(kNkM,¿⁺P¿Q)’It's ñẈmas  '# Full program
(          )              # Loop until this returns false:
 kNkM,                    #   Push [current month, current day]
      ¿⁺P¿Q               #   Not equal to [12, 25]
            ’It's ñẈmas  '# Push "It's Christmas"
                          # Implicit output

bash-n-date: 69 chars:
sleep $(($(date -d"12/25" +%s)-$(date +%s))) && echo "It's X-Ray    "

But it will fail on Dec. 26th to Dec. 31th.

Q (60)
 system"t 1000";.z.ts:{if[.z.d~2012.12.25;1"It’s Christmas"]}

If it is not Christmas, you must somehow wait until Christmas and then print "It's Christmas".

My apologies, corrected to check every second if it's Christmas...so this will print "It's Christmas" 86,400 times every 25th December. Obviously you can alter this by increasing the timer, which is in milliseconds.

PHP - 49 Characters
I got this quite short, so yeah.
<?while(date("dm")!="2512");echo"It's Christmas";

EDIT: Whoops, I printed something else than It's Christmas x3

J, 54
'It''s Christmas'[(-^:(3 :'-.12 25-:1 2{6!:0''''')^:_)1

Rebol (53 chars)
wait difference 25-Dec-14 now
print "It's Christmas"

Of course the above will only wait till Xmas 2014 :)
Here's a version that will wait for next Xmas day:
next-xmas: does [
    d: now
    make date! reduce [25 12 either all [d/month = 12 d/day > 25][d/year + 1][d/year]]
]

wait difference next-xmas now
print "It's Christmas"

Befunge-98 (36 chars)
Requires a Unicode-capable interpreter (' is used for a literal 65536 and 'ఙ for 3097):
aa+y'%'ఙ-!#v_
s Christmas"<@,kd"It'

Explanation:

Use y with an argument of 20 to get the date field (aa+y)
Mask off the month & day portion by reducing mod-65536 ('%)
Subtract 3097 (= month * 256 + day) ('ఙ-)
If zero, print the string (abuses edge wrapping)
Otherwise repeat

Since default code-golf scoring is now in bytes, this should be at least 39 due to the multibyte characters.

Factor + calendar.holidays.us math.unicode, 54 bytes
[ now dup christmas-day ≠ ] loop [I It's ChristmasI]

Attempt This Online!

Groovy - 88
new Timer().schedule({print"It's Christmas"}as TimerTask,Date.parse("yyddMM","112512"))

Is all that whitespace necessary?

@Joey no, it was for the sake of readability.

Does it work every year? Don't think so.


text:
Print a Christmas Tree
The Challenge
Print a nice Christmas tree with it's own star at the top using the shortest code possible. The tree star is an asterisk (*) and the tree body is made out of 0 The tree must be 10 rows high. Every row should be properly indented in the way that the previous row are centered over the next one. Any given row must have 2 more 0s than the previous, except for the first one that is the star and the second, which has only one 0. The result is something like this:
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Tie break for resizable height trees without software changes (except changing height parameter)
Please, paste the resulting tree of your code too!

Leaderboard

var QUESTION_ID=4114,OVERRIDE_USER=73772;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Not exactly a duplicate but there's this one on SO: Code Golf Christmas Edition: How to print out a Christmas tree of height N

Golfscript, 27 characters
" "9*"*"9,{n\.4$>\.+)"0"*}%

The resulting tree looks like this:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

A version which uses the height parameter only once is one character longer:
9." "*"*"@,{n\.4$>\.+)"0"*}%

Reading the height from stdin (with input "10" to generate the example tree) takes the same amount of characters (28):
~,)" "*"*"@{n\.4$>\.+)"0"*}%

I know this doesn't comply with the spec, but I thought I'd try to add some diversity to the trees here by imitating this classic ASCII art Christmas scene by Joan G. Stark.
I didn't try to reproduce the whole picture — that would've been a bit too much — but just the tree, for which I present this 138-byte Perl program:
$_=join$/,qw'11| 8\2_2/ 9(\o/) 5---2/1\2--- 10>*<',map(11-$_.A.AA x$_,2..11),'9\|H|/';s/\d+/$"x$&/eg,s/A/substr">>>@*O<<<",rand 9,1/eg,say

And, of course, here's a sample of the output:
           |
        \  _  /
         (\o/)
     ---  / \  ---
          >*<
         >O><@
        <><<>><
       @><><>@<<
      @<O><*@*>>O
     OO@@*O<<<*<OO
    ><<>@><<>@<><><
   >><O<>>><@*>>><<O
  *<>*<><<>@><O*>><*<
 O><><<@<*>><O*@>O><>*
O<><<><@O>>*O*OO<><<>O>
         \|H|/

Try it online!
The code uses the Perl 5.10+ say feature, and so needs to be run with the -M5.010 (or -E) command line switch.  (Actually, just replacing the say at the end with print would avoid that, at the cost of two more bytes and the loss of the newline after the last line of output.)
Note that the bulk of the tree is randomly generated, so the placement of the ornaments will vary between runs.  The angel, the stand and the top row of the tree are fixed, though.

To keep this popular answer from being summarily deleted under a policy instituted after it was posted, here's a token spec-compliant solution as well (45 bytes, also Perl 5):
$_=$"x10 ."*";say,s/ 0/00/,s/\*?$/0/ while/ /

Try it online!
Like the program above, this one also needs to be run on Perl 5.10+ with the -M5.010 switch to enable the say feature.  Obviously (this being a kolmogorov-complexity challenge) it produces the exact same boring output as all the other compliant entries, which I won't bother repeating here.  (It's also trivially resizable by changing the number 10 to any other other value.)

Great! Not by the spec but I think the judges special award is for you! :)

this kicks the specs' proverbial behind, +2 if I could.

Sorry, but per the rules, answers that don't meet the spec must be deleted.

I'm deleting this post in compliance with our policy about answers not meeting the challenge specification.

Could you please move the valid answer to the top and add a header?

GolfScript (33 chars)
Fixed-height version:
;8:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

Or for exactly the same length
;8:^' '*.'*'+n@'0'+^{.n\(;'00'+}*

The tree looks remarkably similar to everyone else's:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Version which takes height from stdin:
~((:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

The start of the previous line is one of the better smilies I've made in a "useful" GolfScript program.

Shell script, 44 characters
printf %9c\\n \* 0|sed ':x
p;s/ 0/000/;tx
d'

Prints this tree:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Maple, 30 / 37 chars
Inspired by Mr.Wizard's Mathematica entry, I present this 30-char Maple 12 command:
<`*`,('cat(0$2*i+1)'$i=0..8)>;

Output:
                              [        *        ]
                              [                 ]
                              [        0        ]
                              [                 ]
                              [       000       ]
                              [                 ]
                              [      00000      ]
                              [                 ]
                              [     0000000     ]
                              [                 ]
                              [    000000000    ]
                              [                 ]
                              [   00000000000   ]
                              [                 ]
                              [  0000000000000  ]
                              [                 ]
                              [ 000000000000000 ]
                              [                 ]
                              [00000000000000000]

I can also get rid of the brackets at the cost of seven more chars:
`*`;for i in$0..8 do;cat(0$2*i+1);od;

Output omitted — it looks just like above, only without the brackets.  Unfortunately, I don't know any way to keep Maple from inserting blank lines between the output rows in text mode.  It looks better in classic worksheet mode.  I guess I could include a screenshot...

(The screenshot shows an earlier 44-char version of the command, but I'm too lazy to retake it.  The output is still the same.)
Oh, and yes, the size is fully adjustable: just replace the 8 with n-2 for an n-row tree.  With the first solution, going above 25 rows (or 10 in the GUI) requires also setting interface(rtablesize = n), though.
(Ps. I thought I'd managed to beat GolfScript with the latest version, but alas...)

Ruby, 46 characters
puts" "*8+?*;9.times{|i|puts"%8s0"%(v=?0*i)+v}

In order to change the height you would have to change both 8s and of course also the 9.
The output of the program is as follows:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Edit: Inexcusably I omitted the output in the first submission.

You forgot to post the output. :)

Perl, 42 chars
say$"x9,"*";say$"x(9-$_),"00"x$_,0for 0..8

Output:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

The height of the tree can be changed between 1 and 11 rows by replacing the 8 at the end with values from -1 to 9.  Going above 11 rows requires also increasing the two 9s earlier in the code, which control how far from the left side of the screen the tree is indented.

This one have 11 rows :P Minor changes I guess

@Averroes: Yeah, I first assumed it was supposed to be 10 rows plus the star, but then I actually counted the rows in the sample output and fixed it.

Groovy, 65
(p={c,r->println' '*(9-r)+(c*(r*2-1))})'*',1;(1..9).each{p'0',it}

Surprisingly, the tree looks like this:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

The 'post the tree output' part is for bringing some Christmas spirit to this site :P

Also, yours have 11 rows too!

I can fix that by adjusting the height parameter(s)!

Python 3: 62 characters
print(' '*9+'*',*('\n'+' '*(9-i)+'0'*(i*2+1)for i in range(9)))

Output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Note that this essentially beats @Ante's answer by 11 characters, because that answer, when converted to Python 3, uses 73 characters.
Change each 9 to another value for a different height.

I think you can also lose the space before for.

@badp Thanks—changed from 63 to 62!

PowerShell, 41
" "*8+"*";0..8|%{" "*(8-$_)+"0"+"0"*$_*2}

Unsurprisingly, outputs the same tree as everyone else's :-p
If you parametrize that 8, it will yield up to the size of your console, in, say, 48 characters:
" "*($w=8)+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

Or, as a full-blown script which takes an argument, 53 characters:
param($w)" "*$w+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

Called, it looks like:
PS>: Get-Tree.ps1 8
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Prolog: 183 or 186
r(0,_,L,L).
r(N,C,L,[C|T]):-N>0,M is N-1,r(M,C,L,T).
y(S,T,C):-r(T,C,[10],X),r(S,32,X,Y),atom_codes(A,Y),write(A).
x(A,B):-A>0,y(A,B,48),C is A-1,D is B+2,x(C,D).
x(N):-y(N,1,42),x(N,1).

Prints:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
false.

Could be squeezed further for certain interpreters (e.g. using tab/1 on SWI)
Invoke with x(N).  Where N is the number of rows in the actual tree (excluding star).  Giving it a fixed height would bring it down to 183

Python, 59
print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)

Nice work—this demonstrates that though the answer by @Ante gets longer in Python 3, my Python 3 answer is shorter in Python 2 (print not a function).

C
This is Wade Tandy's C version but modified a little bit:
           ;
          int
         main(
        ){int i
       =-1,j=0,c
      =10;while(j
     ++<c){printf(
    " ");}{;printf(
   "*");}while(++i<c
  ){for(j=-2;++j<c-i;
 )printf(" ");for(j=0;
++j<2*i;){printf("0");}
          ;;;
        printf(
         "\n")
          ;}}

PostScript (with parameterised height), 114 characters
/h 9 def/b{{( )=print}repeat}def
h -1 0{dup h eq{dup b(*)=}if dup b h sub neg 2 mul 1 add{(0)=print}repeat()=}for

Output:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

What, you wanted it to print out?

Applesoft BASIC, 143 chars
Since this question reminds me of a homework assignment I had back in high school (when they were teaching on an Apple //e):
1INPUTH:X=(H*2)-2:C=(X/2):S$="*":O=0:GOSUB2:S$="0":FORO=0TOX-2STEP2:GOSUB2:NEXT:END
2FORS=0TOC-(O/2):?" ";:NEXT:FORI=0TOO:?S$;:NEXT:?"":RETURN

I used the JavaScript Applesoft BASIC found here: http://www.calormen.com/applesoft/
OUTPUT:
?10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Prolog: 127 characters
p:-write('        *'),h(1).
h(L):-(L<10,nl,w(L,-8),h(L+1));!.
w(L,N):-(N<9,N<L,(L>abs(N)->write('0');write(' ')),w(L,N+1));!.

Output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true

Used Prolog because I was not able to beat the Groovy record without looking at his code :(.

Mathematica, 50
MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]

PHP, 106 characters
7 fewer than the previous:
<?php echo str_pad(' ',9)."*\n";for($i=0;$i<9;$i++){echo str_pad("",9-$i).str_pad("",($i*2)+1,"0")."\n";}

enable short tags and save yourself 3 chars, or use the <?= and save another 5 from the "echo ".

I know I'm 8 months late, but http://codegolf.stackexchange.com/a/6783/4967 :)

JavaScript (Rhino: 108, Node: 114, Webkit Dev Console: 119, jQuery Plugin: 132)

Rhino is the shortest (at 108 characters) because (a) its print function has a short name and (b) it'll let you assign built-in functions into a shorter variable name. So:
h=10,p=print,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}

Node.js comes in a close second (at 114 chars) because its print function console.log has a longer name, but it'll let us assign that to a short variable as well:
h=10,p=console.log,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}

However, the Webkit Dev Console (and probably Firebug, too) thinks p=console.log is a bit too sneaky (when you try to call p(), it'll complain at you). So, we have to lengthen things out to 119 characters:
h=10,m='0',a=Array(h-1),s=a.join(' ');with(console){log(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();log(a.join(' ')+m);}}

(Interestingly, with only saves us a character).
Finally... a jQuery plugin (still tweetable at 132 characters!):
$.fn.xms=function(h){var m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$(this).css({textAlign:'center'}).html(l.join('\n
'));}

And you can invoke it on the footer of this very page: $('#footer').xms(3)
Of course, it doesn't have to be a plugin... since we'd probably have to use a JavaScript console to add it to a page and invoke it, we could've just done a snippet of jQuery:
h=10,m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$('#footer').css({textAlign:'center'}).html(l.join('\n
'));

which weighs in at a more competitive 116 characters -- in fact, it beats out the other dev console implementation. But, then again, using jQuery and/or the browser's layout engine might be considered cheating. :)

Python, 70 characters
Not so short, but recursive solution :-)
def a(s):
 print s
 if s<"0":a(s[1:]+"00")
print" "*8+"*"
a(" "*8+"0")

Change 8's to set height.

Javascript, 119 characters
Outputs to firebug console
i=h=9;a=new Array(h);a[0]=a.join(' ');b=a.join('000');a[0]+='*';while(i)a[i--]=b.substr(i,h+i);console.log(a.join('\n'))

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

This is 120 characters actually.

C, 67
I know this is long over, but it's my first attempt at code golf, and I think I've got a pretty nice C solution.
Interestingly, I came up with this independently of @Patrick's very similar solution.
And yes, I won't win any ties with my hardcoded values ;)  I'm quite pleased, anyway.
i;main(){for(;i<10;++i)printf("%*s%0*c\n",i?9-i:8,"",i*2,i?32:42);}

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Press any key to continue . . .

LOLCODE, 527 bytes
CAN HAS STDIO?
HAI 1.2
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 8
    VISIBLE " "!
IM OUTTA YR LOOP
VISIBLE "*"
I HAS A SPACES
SPACES R 8
I HAS A ZEROS
ZEROS R 1
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 9
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN SPACES
        VISIBLE " "!
    IM OUTTA YR LOOP
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN ZEROS
        VISIBLE "0"!
    IM OUTTA YR LOOP
    VISIBLE ""
    SPACES R DIFF OF SPACES AN 1
    ZEROS R SUM OF ZEROS AN 2
IM OUTTA YR LOOP
KTHXBYE

Try it online!
Output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

This is [tag:code-golf], so please add the byte count of your submission to the header.

Oracle
select lpad('*', 11) from dual
union all
select rpad(' ', 10 - level) || rpad(' ', level * 2, '0') from dual
connect by level <= 9;

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

10 rows selected.

C, 77
i;main(c){printf("%*c\n",c,42);while(i<c)printf("%*s%0*d\n",c-i,"",i++*2+1,0);}

Before reading the printf spec more carefully, I had this cute little number down to 138 chars:
#define x sprintf(b,
#define y printf(b,
i;main(c){char b[9]="%%%dc\n",*t="%%%ds%%0%dd\n";x b,c);y 42);while(i<c)x t,c-i,i++*2+1),y "",0);}

Java, 192 (198 with param)
class V{public static void main(String[]a){int c=10,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}
Prints the requested tree:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

For variable height, slightly longer:
class W{public static void main(String[]a){int c=a.length,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}
Length of command line argument list determines height (e. g. java W a a a a a will give height 5).
(This is basically the Java version of Wade Tandy's C solution.)

I know this was posted a while ago :), but here are two things I see: 1. you can use an interface instead of a class in java 8 2. to save two characters, while (++i < c) { -> for (s += "*";++i < c;s = "") {, and remove the s += "*"; and the s = "";

Scala, 74 bytes
val h=10;println(" "*h+"*");for(i<-0 to h-2)println(" "*(h-i)+"0"*(i*2+1))

h - height of the tree
Output
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

PHP 113
Figured i'd chime in with a php version:
113 chars (adjust $h to change the height, the number of lines includes the star):
$h=10;for($n=0;$n<$h;$n++){$i=$n>0?$n:1;$c=$n<1?"*":"0";echo str_repeat(" ",$h-$i).str_repeat($c,($i*2)-1)."\n";}

I tried to make it short, not readable and we already knew php can't compete on conciseness so this isn't going to win anything, still a fun little puzzle tho.
output is as spec:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Hardcoding a litlle bit more, 103 chars, (you can't see the spaces in the first echo inside this comment)
$n=0;echo"        *\n";for($i=9;$i>0;$i--,print str_repeat(' ',$i).str_repeat('0',$n+9-$i)."\n",$n++);

your hardcoded first line would go out of balance if you change the height of the tree tho :-(

Vim, 18 bytes
17i0<esc>qqYPxr q8@qa*

Try it online in the backwards-compatible V interpreter!
Although this is a very similar approach as my V answer, this one is not non-competing since vim is crazy old. :)
Explanation:
17i0<esc>               " Insert 17 '0's
         qq     q       " Start recording into register 'q'
           YP           " Duplicate this line upwards
             x          " Delete one character
              r         " Replace this character with a space
                 8@q    " Playback macro 'q' 8 times
                    a*  " Append an asterisk

C, 80
i=9,k=10,j;main(F){while(i)putchar(++j<i?32:j<k?48-F*6:(i-=!F,k+=!F,F=j=0,10));}

Initialize k to the tree height, i to k-1. F is first line flag. Given no argument, then F should be 1 upon entry.
A slightly longer(81) version where f is non first line flag:
i=9,k=10,j,f;main(){while(i)putchar(++j<i?32:j<k?42+f*6:(i-=f,k+=f,f=1,j=0,10));}

Lua: 83, 89 or 97
A fixed-height 10-layer tree can be done in 83
a=string.rep
for i=0,9 do
print(i<1 and a(" ",8).."*" or a(" ",9-i)..a(0,i+i-1))end

Providing a height parameter takes it to 89
h=9
a=string.rep
for i=0,h do
print(i<1 and a(" ",h-1).."*" or a(" ",h-i)..a(0,i+i-1))end

Changing the first line to h=io.read() takes it up to 97, but allows the program to read the height from stdio.
Prints:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Note that the value of h is the size of the tree itself, excluding the star.

Java, 141
class t{public static void main(String a[]){char s[]=new char[21];s[9]='*';for(int i=0; i<10;System.out.println(s),s[9+i]=s[9-i]='0',i++);}}

Using a char array ..

Whitespace, 2155 bytes
Program (replace S,T,L with Space,Tab,Linefeed characters respectively):
SSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSTSTSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTSTSLTLSSSSSTSSSSSLTLSSSSSTSSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSSSSTTSSSSLTLSSLLL

or download the whitespace-only program text-file christmas_tree.ws.
Output:
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

This program simply outputs the 164 successive characters that make up the ten rows of the tree (averaging just over 13 program characters per output character). No doubt there's a much shorter Whitespace program that uses some logic to generate the blocks of repeated tree characters.

T-SQL, 151 142 bytes
declare @ int
set @=10;with t as(select space(@-1)+'*'z,1 i
union all
select space(@-i)+replicate('0',i*2-1),i+1 from t)
select top(@)z from t

The height of the tree can be adjusted (just change the value of the @h variable)
The query uses a Recursive CTE.
Test link: http://sqlfiddle.com/#!3/d41d8/1695 (from the "Run SQL" dropdown button, select "Plaintext Output")
If run from the SQL Management Studio select "Results to Text" and use this query, as SSMS displays the data left aligned:
declare @h int
set @h=10;with t as(select space(@h-1)+'*'as z,1 as i
union all
select space(@h-i)+replicate('0',i*2-1),i+1 from t)
select top(@h)z from t

Sample SQL Server Management Studio output:
z
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

EDIT: Saved 9 chars thanks to BradC!

Nice technique with the recursive CTE. You can save a few bytes by using @ as the variable instead of @h, and by dropping the AS column keywords on z and i (although you'll still need it for table t). Also, in SQL 2008 and later you can set the value as part of the declare: declare @ int=10

@BradC Wow, thanks!
I don' t know how I forgot about that as, but the @ var name - I didn't think that was possible. :)

Java, 177 Chars
import java.util.Arrays;class C{public static void main(String[]a){
char[]r=new char[17];r[8]='*';int c=10;while(c-->0){if(c<9)Arrays.fill(r,c,17-c,'0');System.out.println(r);}}}

(Line break after main(...){ only for better readability.)
Uses API method Arrays.fill() to reduce number of while loops.
Prints this tree:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Java, 230 characters
My own take.
class p{public static void main(String[]a){new p().m();}void m(){int h=0;x(20,1,"*");while(h<9)x(20-h,2*h+++1,"0");}void x(int s,int f,String c){for(;s>0;s--)d(" ");while(f-->0)d(c);d("\n");}void d(String s){System.out.print(s);}}

And the output:
                *
                0
               000
              00000
             0000000
            000000000
           00000000000
          0000000000000
         000000000000000
        00000000000000000

The code indented:
class p {
public static void main(String[] a) {
    new p().m();
}

void m() {
    int h = 0;
    x(20, 1, "*");
    while (h < 9)
        x(20 - h, 2 * h++ + 1, "0");
}

void x(int s, int f, String c) {
    for (; s > 0; s--)
        d(" ");
    while (f-- > 0)
        d(c);
    d("\n");
}

void d(String s) {
    System.out.print(s);
}
}

Adding parameters for height should take only a few more characters, but I am very far way of winning :P

Haskell, 83 chars
r=replicate
main=mapM_ putStrLn$(r 8' '++"*"):map(\x->r(9-x)' '++r(x*2-1)'0')[1..9]

...not as short as I thought it might be.

Java, 147 chars (or 153)
class V{public static void main(String[]a){int c=10,i=-1,j;while(++i<c){for(j=0;++j<c+i;)System.out.print(j>c+i-2?i<1?"*\n":"\n":j<c-i?" ":"0");}}}
I based this on Daniel Schneller's solution, although I changed a lot. In line with Daniels solution, this one can be parameterized as well, where the number of command line parameters represents the height of the tree:
class V{public static void main(String[]a){int c=a.length,i=-1,j;while(++i<c){for(j=0;++j<c+i;)System.out.print(j>c+i-2?i<1?"*\n":"\n":j<c-i?" ":"0");}}}
Output (how surprising :):
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

PHP, 136 Characters

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

;)

Now make the size adjustable. :)

Well, I can't make this size adjustable, but I could write meta-programs which can generate PHP programs like these of arbitrary size ;).

C#, 181 Characters
using System;
class T{static void Main(string[]a){
int h=int.Parse(a[0])-2,i=0;
Console.WriteLine("*".PadLeft(h+1));
while(i<=h)
Console.WriteLine(new string('O',i++*2+1).PadLeft(h+i));
}}

Output:
        *
        O
       OOO
      OOOOO
     OOOOOOO
    OOOOOOOOO
   OOOOOOOOOOO
  OOOOOOOOOOOOO
 OOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOO

The Main method does not need a string[] input parameter. It can be declared as: static void Main()

@m0sa It's used to pick up the height from the command line arguments. You can of course make it shorter by hardcoding the height.

Hmm, looks like my BF answer at least beats something...

Haskell, 73 characters
main=mapM_ putStrLn$"        *":take 9(iterate((++"00").tail)"        0")

And the output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Python, 64
Yet another python answer.
def f(i,c='0'):print' '*(9-i)+c*(i*2+1)
f(0,'*')
map(f,range(9))

PHP, 109 characters
for($i=10,$j=1,$k=0;$i;$i--,$j+=2,$k=2)echo str_pad(str_repeat($j<2?'*':0,$j-$k),$i+$j-(!$k?1:2),' ',0)."\n";

Not the shortest code possible, but easily resizable with changing only the value of $i.

F#, 167 bytes
let r n s=String.replicate n s
let rec x h i=
 let w=r i" "
 match h with|0->w+"*\n"|1->(x(h-1)i)+w+"0\n"|z->(x(h-1)(i+1))+w+(r(z+z-1)"0")+"\n"
printfn "%s"(x 8 0)

Java, 155 127
enum t{_;{for(char c=42,i=9,j;--i<0;c=48){j=i;String b="";while(--j>0)b+=" ";while(++j<(10-i)*2)b+=c;System.out.println(b);}}}

and a tree
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Ruby, 51 bytes
puts' '*8+'*';9.times{|a|puts' '*(8-a)+'0'*(a*2+1)}

Output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Alas, there's already a shorter Ruby solution.

with sed:
$ echo $'\n\n\n\n\n\n\n\n\n'|sed -e '1{ s/^/        */;h;}' -e '2,${x;/ 0/s//000/;/\*/s//0/;h;}'

Output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

VALA, 181
void main(string[] argv){int i,h=int.parse(argv[1]);stdout.printf(string.nfill(h-1,' ')+"*\n");for(i=0;i<h;i++)stdout.printf(string.nfill(h-i-1,' ')+string.nfill(2*i+1,'0')+"\n");}

The result :
[damien@caturday ~]$ ./christmas_tree 5
    *
    0
   000
  00000
 0000000
000000000

Scala, 73 bytes
var(h,c)=(10,"*");0+:(0 to h-2)map{i=>println(" "*(h-i)+c*(i*2+1));c="0"}

Output
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Welcome to Programming Puzzles and Code Golf. This is a very well golfed answer (+1), however it could benefit from a code breakdown and explanation.

V, 13 bytes
17é0òÄlxx>òr*

Try it online!
It's fun to beat the accepted answer by a huge margin. :D
Explanation:
17é0            " Insert 17 '0's
    ò     ò     " Recursively:
     Ä          "   Copy this line upwards
      l         "   Move one char to the right
       xx       "   Delete two characters
         >      "   Indent this line
           r*   " Replace the last character with an asterisk

Powershell, 38 bytes
' '*8+'*'
8..0|%{' '*$_+'0'*(17-2*$_)}

Output:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Powershell with parameter, 49 bytes
param($h)' '*$h+'*'
$h..0|%{' '*$_+'0'*(17-2*$_)}

BATCH, 96 90 83 73 71 bytes
Fixed height=10:
@set[=          0
@echo%[:0=*%
:0
@echo%[%
@set[=%[:~1%00
@goto:0%[:~1%

Saved 6 bytes by replacing \r\n line terminators with \n (still works)
P.S I'm new to golf, so I'm not sure if pause is required. Removed @pause, saved 7 bytes.
2020/4/30 - Abused token delimiters [, golfed 2 bytes.

I would say you do not need \n@pause, since it does not change your program's output.

@JonathanFrech thanks, it's removed

Charcoal, fixed height: 10 8 bytes
↓*Ｇ↙→→⁹0

-2 bytes thanks to @Neil.
Try it online (verbose) or try it online (pure).
Explanation:
Print the "*", and move the cursor down:
Print(:Down, "*");
↓*

Draw a polygon in the shape of a triangle, with the initial arm as size 9 and using the character "0" as filler:
Polygon(:DownRight, :Left, :Left, 9, "0");
Ｇ↙→→⁹0

Variable height through input: 14 9 bytes:
↓*Ｇ↘←←⊖θ0

-5 bytes thanks to @Neil.
Try it online (verbose) or try it online (pure).
Explanation:
Print the "*", and move the cursor down:
Print(:Down, "*");
↓*

Draw a polygon in the shape of a triangle, with the initial arm as size input-1 and using the character "0" as filler:
Polygon(:DownRight, :Left, :Left, Decremented(q), "0");
Ｇ↘←←⊖θ0

By reversing the order of drawing, you get ↓*Ｇ↙→→⁹0 for 8 bytes.

@Neil Thanks! And the same golfs 3 bytes in the variable answer, + 2 more because the input can be done implicitly for integers as well now. (This wasn't the case prior, was it? I can remember it wasn't when I posted my first Charcoal answer a few years back.)

As far as I can remember, I think Decremented has always cast from string to number first.

I think you forgot to update Ｇ↗↘←⊖θ0Ｍ⊖θ↑* to your latest linked code in your explanation?

@Neil Oops, thanks for noticing.

Notepad++, 27 keystrokes
0000<Ctrl-A><Ctrl-D><Ctrl-A><Ctrl-D><Home>0<Ctrl-Shift-R><Ctrl-D><Backsp><Space>
→<Ctrl-Shift-R><Ctrl-Shift-P><Ctrl-Shift-P><Ctrl-Shift-P><Ctrl-Shift-P>
<Ctrl-Shift-P><Ctrl-Shift-P><Ctrl-Shift-P><Ctrl-D><Backsp>*

(Newlines included only for readability.)
Explanation
We'll build the tree from the bottom up:
The setup
Starting with four 0s, we CtrlA CtrlD (select all, duplicate) twice to get sixteen 0s. We need seventeen 0s on the bottom row, so we go Home and add another one. The cursor is now positioned right after the first 0 on the line.
The macro
CtrlShiftR starts recording a macro, which we'll use to generate each line from the one below it:

CtrlD duplicates the line, leaving the cursor on the upper of the two copies
Since the cursor is just after the first 0 on the line, Del Backsp Space removes two 0s and prepends a space
Finally, → moves one character rightward, so that we are once again right after the first 0 on the line

A second CtrlShiftR ends the macro, and then CtrlShiftP seven times calls the macro repeatedly to generate the rest of the body of the tree.
The finishing touch
For the star, we need only duplicate the top row with CtrlD, remove the 0 with Backsp, and replace it with a *.
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Rockstar, 72 bytes
say " "*8+"*"
X's0
while 9-X
let Y be 8-X
say " "*Y+0+"0"*X*2
let X be+1

Try it here (Code will need to be pasted in)

Jelly, 17 16 bytes
⁶ẋ8⁾*¶9µ>þa⁶UŒBY

Try it online!
This is my first time golfing in Jelly; I'm sure this could be golfed further. Advice welcome. :^)
Explanation
⁶                 Space character
 ẋ8               Repeated 8 times
                  Since this niladic chain doesn't connect to anything, just output it
   ⁾*¶            Two-character string containing * and newline
                  Since this niladic chain doesn't connect to anything, just output it
      9µ          Apply the following monadic chain to a starting value of 9:
        >þ        Make a 9x9 table, where each entry is 1 if the column number is
                  greater than the row number, 0 if not
          a⁶      Logical AND with space (replaces the 1's with spaces)
            U     Reverse each row
             ŒB   Bounce, mirroring each row to the right
               Y  Join with newlines

Vyxal, 18 bytes
9\*꘍₀(,9n-\0n›*꘍øm

Try it Online!
Fairly well golfed.
9                  # 9
 \*                # '*'
   ꘍               # ' ' * 9 + '*'
    ₀(             # 10 times
      ,            # output
       9n-         # 9 - (iteration number)
          \0       # String '0'
            n›     # iteration number + 1
              *    # That many 0s
               ꘍   # (9 - (iteration number)) spaces + 0s
                øm # Palindromised

Tree:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Python 2, 49 bytes
n=-1
exec"print' '*(8-n/2%n),n*'0'or'*';n+=2;"*10

Try it online!
Python 3, 47 bytes
n=-1
while n<19:print(f"{n*'0'or'*':^19}");n+=2

Try it online!

Vyxal C, 9 bytes
17~∷\0*×p

Try it Online!
17~       # the range 1..17 filtered by
   ∷      # is odd
    \0*   # "0" repeated n times for n in those odd nums
       ×p # with an asterisk prepended
          # C flag joins by newlines and centers output

Python, 79 chars
s,h=1,10;print " "*(h-s/2)+"*"
for x in range(h):print " "*(h-s/2)+"0"*s;s=s+2

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000
 0000000000000000000

R, 68 characters
s=sprintf;cat(s('%10s','*'),s('% *s%0*d',9:1,'',1:9*2-1,0),sep='\n')

And here's a parameterized version:
n=12 # Tree height (without star)
s=sprintf;cat(s('%*s',n+1,'*'),s('% *s%0*d',n:1,'',1:n*2-1,0),sep='\n')

Old version, 85 characters
cat('         *\n         0\n');cat(sprintf('% *d%0*d',9:2,0,seq(2,16,2),0),sep='\n')

I know, not the prettiest - R is not that great at formatting output using compact code.

C 145
Takes its heigh param from argc, so set the number of rows by setting the number of arguments:
#define x printf
int main(int c){int i=-1,j=0;while(j++<c)x(" ");x("*");while(++i<c){for(j=-2;++j<c-i;)x(" ");for(j=0;++j<2*i;)x("0");x("\n");}}

To generate the ten line spec output, you call:
christmastree 1 2 3 4 5 6 7 8 9

Or if you'd prefer to hardcode the height, change c in this version:
#define x printf
int main(){int i=-1,j=0,c=10;while(j++<c)x(" ");x("*");while(++i<c){for(j=-2;++j<c-i;)x(" ");for(j=0;++j<2*i;)x("0");x("\n");}}

R, 89 chars
A fixed-height 10-layer tree can be done in 89 characters:
cat(rep("",9),"*\n");for(i in 1:10)cat(rep(" ",10-i),rep("0",seq(1,20,2)[i]),"\n",sep="")

Providing a height parameter takes it to 97:
h=10;cat(rep("",h-1),"*\n");for (i in 1:h)cat(rep(" ",h-i),rep("0",seq(1,2*h,2)[i]),"\n",sep="")

Output:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

PHP-275 Chars
Count is not including any whitespace, resizable by changing function parameter number:
function Tenenbaum($n)
{
$r="
";
$x=2;
$v=" ";
$z="0";
$l=str_repeat($v,$n);
echo "$l*$r".$l."0$r";

for($i=1;$i<=$n;$i++)
{
$s=$n-3;
$p=str_repeat($v,$s);
$q=str_repeat($z,5);
echo str_repeat($v,$n-$i).str_repeat($z,$i+$x).$r;

if($i==$n)
{
echo "$p$q$r$p$q$r$p$q";
}
$x+=1;
}
}

Tenenbaum(20);

Output:
                    *
                    0
                   000
                  00000
                 0000000
                000000000
               00000000000
              0000000000000
             000000000000000
            00000000000000000
           0000000000000000000
          000000000000000000000
         00000000000000000000000
        0000000000000000000000000
       000000000000000000000000000
      00000000000000000000000000000
     0000000000000000000000000000000
    000000000000000000000000000000000
   00000000000000000000000000000000000
  0000000000000000000000000000000000000
 000000000000000000000000000000000000000
00000000000000000000000000000000000000000
                 00000
                 00000
                 00000

CSV, 133 bytes
Thought I would Cheat Just a little on this one for a few laughs :)
        0,
       000,
      00000,
     0000000,
    000000000,
   00000000000,
  0000000000000,
 000000000000000,
00000000000000000

PHP - 75
<?=($p='          ').'*
';for($s=' 0';$p=substr($p,1);$s.='00')echo"$p$s
";

For variable heights of 12 or below, modify the hard-coded padding in the above. (Code gets smaller the lower the height)
For variable heights of 13 or more use the following, height param is the second argument to str_pad. (Code starts at 77 bytes and doesn't grow as fast as the version with static padding)
<?=($p=str_pad('',13)).'*
';for($s=' 0';$p=substr($p,1);$s.='00')echo"$p$s
";

Output of php -d short_open_tag=1 tree.php
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Common Lisp - 100 [nonblank] chars
No Common Lisp solutions? =) Here's mine:
(or
   (format t "~17:@<*~>~%")
   (format t "~{~17:@<~{0~*~}~>~%~}"
      (loop for x upto 8 collect
         (make-list (1+ (* 2 x))))))

result:
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

for higher trees just replace "8" with (height - 2) and "17" with 1+2x(height-2). Here's a 14 rows tree:
CL-USER> (or
          (format t "~25:@<*~>~%")
          (format t "~{~25:@<~{0~*~}~>~%~}"
                  (loop for x upto 12 collect
                       (make-list (1+ (* 2 x))))))
            *
            0
           000
          00000
         0000000
        000000000
       00000000000
      0000000000000
     000000000000000
    00000000000000000
   0000000000000000000
  000000000000000000000
 00000000000000000000000
0000000000000000000000000

VimScript: 92 characters
I am working at learning Vim and it occurred to me that it could be a neat platform for code golfing. I don't know how to script in Vim that well yet, so any optimization suggestions are appreciated. Note: ^[ does not mean a literal caret next to a literal bracket, but is Vim's way of displaying a literal ESC character in the text.
norm8a ^[a*^[9o^[17a0^[ka ^[15a0^[k2a ^[13a0^[k3a ^[11a0^[k4a ^[9a0^[k5a ^[7a0^[k6a ^[5a0^[k7a ^[3a0^[k8a ^[a0

Here is the output. One of the unique things about this answer is that the output is created in a buffer in Vim (use a :new buffer). The brackets indicate the final cursor location, which ended up where it did for optimization reasons but I think that is cool:
        *
       [0]
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Updated: 71 characters
Using mapping to reduce number of characters:
map b a0^[k
map c a ^[
norm8ca*^[9o^[17bc15b2c13b3c11b4c9b5c7b6c5b7c3b8ca0

Updated: 69 characters
Use punctuation instead of letters for the mapped characters in order to save two space characters.
map- a0^[k
map. a ^[
norm8.a*^[9o^[17-.15-2.13-3.11-4.9-5.7-6.5-7.3-8.a0

Updated: 66 characters
Use nn ("normal, no remap") for map to save 2 letters. Also swap final a0 for -. Note that this results in the cursor resting on the star in the final output rather than on the tip-top of the tree right below the star.
nn- a0^[k
nn. a ^[
norm8.a*^[9o^[17-.15-2.13-3.11-4.9-5.7-6.5-7.3-8.-

Updated: 63 characters
Moving/substituting a few more things allows yet another reduction (ignore the , -> . change):
nn- a0^[O^[
nn, a ^[
norm17-,15-2,13-3,11-4,9-5,7-6,5-7,3-8,-8,a*

C#, Fixed height, 136 chars
class P{static void Main(){for(int i=0;i<10;i++)System.Console.WriteLine((i>0?new string('0',(i-1)*2+1):"*").PadLeft(10+(i>0?i-1:0)));}}

Formatted:
class P
{
    static void Main()
    {
        for (int i = 0; i < 10; i++)
            System.Console.WriteLine((i > 0 ? new string('0', (i - 1) * 2 + 1) : "*").PadLeft(10 + (i > 0 ? i - 1 : 0)));
    }
}

Output when run:
         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Variable height: 165 chars
Use commandline parameter to specify height
class P{static void Main(string[]a){int h=int.Parse(a[0]);for(int i=0;i<h;i++)System.Console.WriteLine((i>0?new string('0',(i-1)*2+1):"*").PadLeft(h+(i>0?i-1:0)));}}

Formatted:
class P
{
    static void Main(string[] a)
    {
        int h = int.Parse(a[0]);
        for (int i = 0; i < h; i++)
            System.Console.WriteLine((i > 0 ? new string('0', (i - 1) * 2 + 1) : "*").PadLeft(h + (i > 0 ? i - 1 : 0)));
    }
}

Output for foo.exe 15:
              *
              0
             000
            00000
           0000000
          000000000
         00000000000
        0000000000000
       000000000000000
      00000000000000000
     0000000000000000000
    000000000000000000000
   00000000000000000000000
  0000000000000000000000000
 000000000000000000000000000

Haskell
tree x=unlines $ (insert 1 '*'):[insert o '0'|o<-[1,3..r]]
    where insert n c=let sur = replicate ((r-n) `div` 2) ' ' in sur++(replicate n c)++sur
          r=2*x+1

Here is the output:
λ <*Main>: putStr $ tree 10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000
 0000000000000000000
000000000000000000000

JavaScript, 108 bytes 92 bytes
    i=9,n=Array(i).join(' '),s='0',a=[n+'*'];while(i--)a.push(n.substr(0,i)+s),s+='00';console.log(a.join('\n'))
edited:
i=10,n=' '.repeat(i-1),s='0',t=n+'x';for(;i--;s+='00')t+='\n'+n.substr(0,i)+s;console.log(t)

ungolfed:
i=10,n=' '.repeat(i-1),s='0',t=n+'x';

for(;i--;s+='00')t+='\n'+n.substr(0,i)+s;

console.log(t);

Welcome to PPCG! Nice first post!

Welcome to PPCG! n='<9 spaces>' will save you a few bytes over your current setup. You can also save a few bytes by switching to a for loop, like so: for(;i--;s+='00')a.push(n.substr(0,i)+s); You can also read through the Tips for golfing in JavaScript thread for more ways to golf, if you'd like.

@ETHproductions that's very good tips, thanks

JavaScript, 71 bytes
for(i=z='10';i--;z+='00')console.log('        *'.slice(0,i)+z.slice(3))

This challenge seemed to be suffering from a distinct lack of super-short JavaScript answers, so I thought I'd try to make up for that. This is the shortest ES5 solution I have found thus far.
Test snippet

for(i=z='10';i--;z+='00')console.log('        *'.slice(0,i)+z.slice(3))

Brainf*ck, 163 bytes
This could be golfed further, but this is my first serious attempt at golfing in general, so oh well...
++++++++++[->+>+>+<<<]>>>++++++[->>++>+++<<<]>>.<<<-[>>>.<<+<-]>>>>------.++++++>+<<<<+.-[-[-<+>>+<]<[->+<]>>>..<[->.<]>>>[->+>+<<]>[-<+>]>[-<<<.>>>]<<++<<<<<<.>>]

Output:
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

jQuery, 160 152 143 bytes
Well, I recognize that it's late, and that it didn't beat the other jQuery entries, but it's been a LONG time since I've done any javascript, so here goes:
$.fn.x=function(h){for(var i=1,o=" ".repeat(h-2)+"*\n";i++<h;)o+=(i==h?"0".repeat(i+(i-3)):" ".repeat(h-i)+"0".repeat(i+(i-3)))+"\n";return o};

Can be run from your browser's javascript console with $().x(10), and accepts any height parameter. Keep in mind, Chrome's console puts a quotation mark at the beginning and end of console output, so that makes the * appear out of place, but it's not.

Kotlin, 113 bytes
{(0..9).map{print(' ')}
println('*')
(0..9).map{(it..9).map{print(' ')}
(0..it-1).map{print("00")}
println('0')}}

Beautified
{
    (0..9).map { print(' ') }
    println('*')
    (0..9).map {
        (it..9).map { print(' ') }
        (0..it-1).map { print("00") }
        println('0')
    }
}

Test
var f:()->Unit =
{(0..9).map{print(' ')}
println('*')
(0..9).map{(it..9).map{print(' ')}
(0..it-1).map{print("00")}
println('0')}}

fun main(args: Array<String>) {
    f()
}

TIO
TryItOnline

uBASIC, 63 bytes
0?Tab(9);"*":ForI=0To8:?Tab(9-I);:ForJ=0To2*I:?0;:NextJ:?:NextI

Try it online!

MY-BASIC, 95 bytes
S="         *"
Print S;
For I=0 To 8
Print Left(S,9-I)d
For J=0 To 2*I
Print 0
Next
Print;
Next

Try it online!

AWK, 71 bytes
{for(;$1--;)printf"%"$1-(a==0)"s%0"2*++F-3(a?"d":"s")"\n","",a++?0:"*"}

Try it online!
It seems like some simplification should be possible, but I can't find it.
NOTE: The TIO link has a few extra bytes to allow printing multiple trees.
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

APL (Dyalog Classic), 25 bytes
' *0'[(⊣⌿⍪+⍨)(⊖,~)∘.≤⍨⍳⎕]

Try it online!
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

it's resizable:
                   *
                   0
                  000
                 00000
                0000000
               000000000
              00000000000
             0000000000000
            000000000000000
           00000000000000000
          0000000000000000000
         000000000000000000000
        00000000000000000000000
       0000000000000000000000000
      000000000000000000000000000
     00000000000000000000000000000
    0000000000000000000000000000000
   000000000000000000000000000000000
  00000000000000000000000000000000000
 0000000000000000000000000000000000000
000000000000000000000000000000000000000

Java (OpenJDK 8), 165 bytes
I saw some possible changes in the existing Java answer and thought I'd add my answer. (trims off 65 bytes, so I'm pretty proud tbh)
interface p{static void main(String[]a){String s="        ",o=s+"*";for(int i=0;i<9;i++){o+="\n"+s.substring(i);for(int j=0;j<=2*i;j++)o+=0;}System.out.println(o);}}

Try it online!

PHP, 69 bytes
while($i<10)printf("%".(8+$i+!$i)."s
",$i++?str_pad(0,$i*2-3,0):'*');

Run with php -nr '' or try it online.

Resizable version, 76+1 bytes (run as pipe with -nR):
while($i<$argn)printf("%".($argn+$i+!$i)."s
",$i++?str_pad(0,$i*2-3,0):'*');

Kotlin, 108 bytes
A few years late, but I was searching for something else and it was in my search results. Accepts a input for the rows. Fixing it to 10 rows saves 6 bytes (code below).
{n:Int->(0..n).map{if(it<1)" ".repeat(n)+"*"
else " ".repeat(n-it+1)+"0".repeat(it*2-1)}.joinToString("\n")}

Try it online!
Output:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000
 0000000000000000000

Hardcoded with 10:

{(0..10).map{if(it<1)" ".repeat(10)+"*"
else " ".repeat(11-it)+"0".repeat(it*2-1)}.joinToString("\n")}

You can to save some bytes: {n:Int->(-1..n).map{if(it<0)"".padEnd(n)+"*" else "".padEnd(n-it)+"0".repeat(it*2+1)}.joinToString("\n")}

Erlang (escript), 134 bytes
The tree is resizable.
r(-1,_)->"";r(X,Y)->lists:duplicate(X," ")++lists:duplicate(Y,"0")++"\n"++r(X-1,Y+2).
t(X)->lists:duplicate(X-1," ")++"*\n"++r(X-1,1).

Try it online!

05AB1E, fixed height: 11 bytes
¾17ÅÉ×'*š.c

Try it online.
Variable height through input: 12 11 bytes:
Î·ÍÅÉ×'*š.c

Try it online.
Explanation:
¾             # Push 0 (push the counter_variable, which is 0 by default)
 17ÅÉ         # Push a list of the positive odd numbers <= 17: [1,3,5,7,9,11,13,15,17]
     ×        # Repeat the 0 that many times as string:
              #  ["0", "000", "00000", ..., "00000000000000000"]
      '*š    '# Prepend a "*": ["*", "0", "000", "00000", ..., "00000000000000000"]
         .c   # Centralize each line by padding with leading spaces
              # (which also implicitly joins a list by newlines at the same time)
              # (after which it is output implicitly as result)

Î             # Push 0 and the input-integer
 ·            # Double the input
  Í           # Decrease it by 2
   ÅÉ×'*š.c  '# Same as above

C, 128
h=10;y,w,i,j;main(){for(y=-1;y<h;y++){w=1+max(y,0)*2;i=((h*2)-w)/2;for(j=0;j<i+w;j+1)printf(j<i?" ":y+1?"0":"*");printf("\n");}}

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

h is the tree's height without the star.

Japt -R, 12 11 bytes
AÇçT êÃh* û

Test it
AÇçT êÃh* û     :(Remove A to input the height instead)
A               :10
 Ç              :Map the range [0,A) (or [0,input))
  ç             :  Repeat
   T            :    0
     ê          :  Palindromise
      Ã         :End map
       h*       :Replace the first element with "*"
          û     :Centre pad with spaces to the length of the longest
                :Implicit output joined with newlines

///, 57 bytes
/i/         /i*/> /
i0\/ \\0\/a\\a\/\/a\\a\/000\/>//>//>i

Try it online!
Normally I would have another replacement for the escaped "/" in the loop bit, but it happens to be the same length without so why not.
Change the number of spaces in the first line, after the /i/. Technically, there is one less space that the 'size' but size 0, 1 etc aren't defined so I don't think it matters.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Smple way to get min & max

You will take a set of input numbers, and output the minimum and maximum of the set. You can either write two programs, with 1 program doing each function, or one combined program.
Here's an example in Perl, 50 and 42 bytes (92 total):
Max:
sub mx {return ( reverse sort {$a <=> $b} @_ )[0]}

Min:
sub mn {return ( sort {$a <=> $b} @_ )[0]}

And a single program, 96:
sub mxmn {return ( reverse sort {$a <=> $b} @_ )[0] if shift; return ( sort {$a <=> $b} @_ )[0]}

Here's some more test cases.
Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 4310; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });

  });

  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/ b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Welcome to code-golf. Please specify on what kind of input it should run (see faq on how to ask questions here). You also have to decide on what you wan't: "simplest way", "code-golf" or "fastest-code"? I suspect they contradict each other.

@Howard Thanks for telling me. See my post I revised it.

Your example has holes in it. If passed ( 100, 12 ) it will see 100 as min and 12 as max

Also, the definition of 'simplest' is highly subjective.

@Zaid that's weird, I don't see why its doing it

@linuxrules94 : sort will sort ASCII-betically by default. That's why 100 comes before 12, since 0 lt 2 == 1

-1 because of: 1) language-specific, 2) overly broad (min or max? strings? sweet and simple despite the code-golf tag?); 3) a bit misinformed (Perl has min and max)

@Jb Oh it does never saw that, sorry

-1 boring. In Golfscript it's $0= and $-1=.

It's a one-liner in many languages - not challenging. Prepare your next question in the chat or on meta, where you get hints before going public. I vote to close.

-1 boring. It's >./ and <./ in J

Perl, 28 char
This sub provides an array that contains the min in the first member and the max in the second member:
sub a{@_=sort@_;(shift,pop)}

Perl, 34 char (27 inside the sub)
According to comments, in fact the above doesn't work for array length less than 2, here a new attempt that works even for zero length array and array that contains only numerics:
sub a{@_&&(sort{$a<=>$b}@_)[0,-1]}

whoa, its 28 char and does min and max and is easy to read? amazing! great job!

Are you sure that this works e.g. if you provide a single number (and not a list)?

Make it shorter and handle the degenerate case: replace (shift,pop) with a slice: @_[0,-1]

And then get rid of temporaries: sub a{(sort@_)[0,-1]} is 21 characters long.

I like this one because you used a language not dedicated to code golf

Doesn't work. It thinks ten is smaller than two.

This answer appears to have the same problem as the example in the question. sort sorts ASCII-betically (to use Zaid's terminology).  Even though 10 > 2, the first character 1 is less than 2, so 10 get sorted as the smallest number.

If it doesn't have to be Perl and you just want the simplicity of Scheme instead of just shaving off characters (I don't care about long variable names (symbols in Scheme)), here's my Scheme for this (pun intended):
Of course we could cheat and use the fonctions (min a b c d ...) and (max a b c ...).
Don't mind the long variable names, they were chosen to be descriptive:
(define (min . args) (extremum < args))
(define (max . args) (extremum > args))

(define-syntax extremum
  (syntax-rules ()
    [(_ op . args)
     (if (null? args)
         (error "Read The Fucking Code!")
         (reduce (lambda (a b) (if (op a b) a b))
           (car rest) (cdr rest)))]
    [else (error "Read The Fucking Code!")]))

But if you want less code (fold is sort of like reduce):
(define (min . args) (e < args)) (define (max . args) (e > args))
(define-syntax e
  (syntax-rules ()
    [(_ o . r) (fold (lambda (a b) (if (o a b) a b)) (car r) (cdr r))]))

Perl does have min and max subs.
use List::Util qw( min max );
my $min = min @values;
my $max = max @values;

A common module has a minmax function which finds both at once faster than they can be found individually (which is far more important than compactness of code).
use List::MoreUtils qw( minmax );
my ($min, $max) = minmax @values;

I only did this as a contest you don't need to use perl but anyway I decided to end it

If all numbers are non-negative, this works:
sub max{\@s[@_];$#s}

a.k.a. Thelen's Device. I prefer to write it as \@_[@_];$#_, but only because it's more obscure that way.

Japt -g, 1 byte Min
n

Try it online!

Japt -g, 2 bytes Max
n<

Try it online!

Total: 3 bytes

Both programs pretty much just evaluate the input & sort it. Min takes the first item of the sorted list, and Max takes the last item of the sorted list.
GolfScript, 4 bytes Min
~$0=

Try it online!
GolfScript, 5 bytes Max
~$-1=

Try it online!
Total: 9 bytes

I don't think Perl is very golfy for such a problem.
Here are two alternatives for numerical lists only:

20 chars (inside sub)
sub min{(sort{$a<=>$b}@_)[0]}
sub max{(sort{$b<=>$a}@_)[0]}

30 chars (inside sub)
sub min{$r=pop;$r=$_<$r?$_:$r for@_;$r}
sub max{$r=pop;$r=$_>$r?$_:$r for@_;$r}

Wow amazing only 20 characters! "the greatest thing since sliced bread!" as they would say

or the greatest thing since [soda] pop (pun intended)

you may rename the subs to n & x or mx & mn

or use a different language

Io, 28 + 28 = 56
I found the magical pure-arithmetic max/min functions! (You guys definitely have a better formula than be, so feel free to mention a better one!)
Io, 28 bytes
The max function;
method(x,y,(x+y+(x-y)abs)/2)

Try it online!
Io, 28 bytes
Min function
method(x,y,(x+y-(x-y)abs)/2)

Try it online!
Explanation for both programs
In order to find a purely-arithmetic max-min function, I started to think of averages. Let's take 3 and 4 as examples.
(3+4)/2 = 3.5

We can see that the distance towards both sides are equal:
3 - 3.5 = -0.5
4 - 3.5 = 0.5

We do the difference and take the absolute value, to get the distance that we need to add / subtract towards the average. 0.5 in this case.
Then, we find the average again. If we're finding the max, we add it by the distance, otherwise we subtract the value by the distance:
3.5 + 0.5 = 4
3.5 - 0.5 = 3

Our current expression is:
x + y   | x - y     |
----- ± | ----- - x |
  2     |   2       |

Actually, the rightmost x can also be y, but we chose x for the simplicity of simplification.
x + y   | x - y   2x  |
----- ± | ----- - --- |
  2     |   2      2  |

=

x + y   | x - y - 2x |
----- ± | ---------- |
  2     |     2      |

=

x + y   | x - y |
----- ± ---------
  2         2

And then, the formula becomes the current formula:

x + y ± | x - y |
-----------------
       2
```

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
ASCII animated snow scene
Write the shortest program to turn any piece of ASCII art into an animated snow scene that begins to form from the falling snow (non-golfed JavaScript example last updated 2011-12-19).
Input specification:
Your program must accept arbitrary combinations of spaces, asterisks, and newlines. The input will contain at most 23 lines and 80 characters per line. There will be no empty lines, yet lines may consist of only whitespace. A single trailing newline will be included and must be ignored.
Output:
Output ASCII characters (spaces, asterisks) and control codes (carriage returns, linefeeds, ANSI escape codes, etc.) for your operating system's text console or terminal emulator until the user manually terminates the program. You may assume the terminal window is 80x24 characters if your operating system allows that setting.
Rules:

The animation must be smooth and fast (15 fps preferred).
Snow density must be between 5% and 15%.
No more than one screen of snow may scroll per second. (That means no more than 24 lines of new snow may be added in any one second time period.)
The snow must not display any obvious pattern as it enters the top of the screen; it must look random.
The program must fill all rows of the screen with snow as quickly as possible when it starts; initial filling of the screen's individual rows must not be obvious to the viewer.
The lower left corner of the input ASCII art must be at the lower left corner of the screen (Figure 1 for further clarification).
The area inside or under the ASCII art must not be permanently filled with asterisks. However, asterisks may (but are not required to) scroll through this area.
Snow must not accumulate at the bottom of the screen or on top of existing snow except as shown in the input.
Lower spaces must be filled before upper ones, as filling spaces in the opposite order makes the Christmas tree animation look very different from my original code's output. (added 2011-12-20)

Happy holidays!
Figure 1: labeled areas of an 80x24 screen
---------------------------New snow added on this line--------------------------
                                                                             |
                                                                             |
----------------------------------------------------------+                  |
                                                    ****  |                  |
    Snow MUST fall  Snow MAY fall ---------------->  **** |                  |
    through this    through these          ****      **** |  Snow MUST fall  |
    area.           areas of a              ****     **** |  through this    |
                    completed   \--------->  ****     ****|  area.           |
        ASCII art   scene.    \     ***        ****   ****|                  |
          area         \       \   *******      ****  ****|                  |
                        \       \    ********     ***  ***|  (ALL CAPS terms |
      (located in        \       \-->   *********  ***    |  have standard   |
       lower left         \     *******     ******  MAY   |     RFC 2119     |
       corner of           \    *************  **   fall  |    meanings.)    |
       screen)              \        ***********    here  |                  |
                         *** +--->          ****  ***     |                  |
                         *** | ****************   ***     |                  |
  | Snow MUST fall       *** | ****************   ***     |                  |
  | through this         *** +--->                ***     |                  |
  | area.                *** | ****************   ***     |                  |
--+---------------------+*** +--->                ***+----+------------------+--
  |   Snow MUST NOT     |****************************|      Snow MUST NOT    |
  V  accumulate here.   |****************************|     accumulate here.  V

Example inputs
Code Golf Banner
 ******   *******  ********  ********     ******    *******  **       ********
**    ** **     ** **     ** **          **    **  **     ** **       **
**       **     ** **     ** **          **        **     ** **       **
**       **     ** **     ** ******      **   **** **     ** **       ******
**       **     ** **     ** **          **    **  **     ** **       **
**    ** **     ** **     ** **          **    **  **     ** **       **
 ******   *******  ********  ********     ******    *******  ******** **

Stack Overflow Logo
                                                    ****
                                                     ****
                                           ****      ****
                                            ****     ****
                                             ****     ****
                                    ***        ****   ****
                                   *******      ****  ****
                                     ********     ***  ***
                                        *********  ***
                                *******     ******
                                *************  **
                                     ***********
                         ***                ****  ***
                         ***   ****************   ***
                         ***   ****************   ***
                         ***                      ***
                         ***   ****************   ***
                         ***                      ***
                         ****************************
                         ****************************

Christmas Trees
                                        *
                                       ***                           *
                *                     *****                         ***
               ***                   *******           *           *****
              *****                 *********         ***            *
                *                  ***********       *****
                       *          *************     *******
        *             ***        ***************       *               *
       ***           *****      *****************                     ***
      *****         *******    *******************                   *****
     *******           *      *********************                 *******
    *********                           *                          *********
        *                                                              *

The third christmas tree is broken.

Nice challenge! I think the rules should be enumerated for easier reference, and I don't understand the third and sixth rule...

@hallvabo I have clarified those two rules, the latter by adding a labeled figure.

Clarification request: is the newline included in the 80-char maximum line length, or is it max 80 chars plus newline?  (I assumed the latter, but some submissions seem to have assumed the former.)

@IlmariKaronen The latter.

Perl, 196 / 239 chars
chomp(@p=(@f=($"x80)x24,<>)[-24..-1]);{@s=(join("",map rand>.1?$":"*",1..80),@s);if(@s>23){$t=$f[$_],print$_?$/:"\e[H",($f[$_]|=$s[$_]&$p[$_])|($s[$_]&=~$t^$f[$_])for 0..23;select"","","",.1}redo}

This solution differs from your JS example in that the pattern is filled from top down rather than from bottom up, but I assume that's OK since you didn't say anything about it in the rules.
A trivial 1-char reduction can be obtained by replacing \e with a literal ESC character, but that makes the code much harder to read and edit.

Update: I did manage to come up with a version that fills the pattern from bottom up, and doesn't allow snow to fall through the filled parts of the pattern, as in the example JS implementation, at the cost of 43 extra chars:
chomp(@p=(@q=@f=($"x80)x24,<>)[-24..-1]);{@s=(join("",map rand>.1?$":"*",1..80),@s);if(@s>23){my$q;$q[-1-$_]=($q|=$p[-$_]&~$f[-$_])for@a=0..23;print$_?$/:"\e[H",($f[$_]|=$s[$_]&$p[$_]&~$q[$_])|($s[$_]&=~$f[$_])for@a;select"","","",.1}redo}

Replacing ($s[$_]&=~$f[$_]) with just $s[$_] would save 11 chars by letting falling snow pass through the filled parts of the pattern (which matches the spec, but not the example implementation).

OK, since I still seem to be leading the race after a week, I guess I should explain how my solution works to encourage more competition.  (Note: This explanation is for the 196-char top-down filling version.  I may amend it to include the other version later.)
First of all, the one big trick my solution is based on is that, due to the way ASCII character codes are arranged, the 1-bits in the ASCII code for a space just happen to be a subset of those in the code for an asterisk.
Thus, the following expressions are true: " " & "*" eq " " and " " | "*" eq "*".  This is what lets me use bitwise string operations for combining the static and moving parts of the scene without having to loop over individual characters.
So, with that out of the way, let's go over the code.  Here's a de-golfed version of it:
chomp(@p = (@f = ($" x 80) x 24, <ARGV>)[-24..-1]);
{
    @s = (join('', map((rand > 0.1 ? $" : '*'), 1..80)), @s);
    if (@s > 23) {
        foreach (0 .. 23) {
            $t = $f[$_];
            print( $_ ? $/ : "\e[H" );
            print( ($f[$_] |= $s[$_] & $p[$_]) | ($s[$_] &= ~$t ^ $f[$_]) );
        }
        select '', '', '', 0.1;
    }
    redo;
}

The first line sets up the arrays @f (for "fixed") and @p (for "pattern").  @f will form the fixed part of the display, and starts out containing nothing but spaces, while @p, which is not shown directly, contains the input pattern; as the animation proceeds, we'll add more and more asterisks to @f until it eventually looks just like @p.
Specifically, @f = ($" x 80) x 23 sets @f to 24 strings of 80 spaces each.  ($" is a special Perl variable whose default value just happens to be a space.)  We then take this list, append the input lines to it using the readline operator <>, take the last 24 lines of this combined list and assign it to @p: this is a compact way to pad @p with blank lines so that the pattern appears where it should.  Finally, we chomp the input lines in @p to remove any trailing newlines so that they won't cause problems later.
Now, let's look at the main loop.  It turns out that {...;redo} is a shorter way to write an infinite loop than while(1){...} or even for(;;){...}, especially if we get to omit the semicolon before redo because it immediately follows an if block.
The first line of the main loop introduces the array @s (for "snow", of course), to which it prepends a random 80-character string of 90% spaces and 10% asterisks on every iteration.  (To save a few chars, I never actually pop extra lines off the end of the @s array, so it keeps getting longer and longer.  Eventually that will grind the program to a halt as the array gets too long to fit in memory, but that will take much longer than most people would ever watch this animation for.  Adding a pop@s; statement before the select would fix that at the cost of seven chars.)
The rest of the main loop is wrapped in an if block, so that it only runs once the @s array contains at least 24 lines.  This is a simple way to comply with the spec, which requires the whole display to be filled with falling snow from the start, and also simplifies the bitwise operations a bit.
Next comes a foreach loop, which in the golfed version is actually a single statement with a for 0..23 modifier.  Since the content of the loop probably needs some explanation, I'm going to unpack it a bit more below:
foreach (0 .. 23) {
    print $_ ? $/ : "\e[H";     # move cursor top left before first line, else print newline
    $t = $f[$_];                # save the previous fixed snowflakes
    $f[$_] |= $s[$_] & $p[$_];  # snowflakes that hit the pattern become fixed
    $s[$_] &= ~$t ^ $f[$_];     # ...and are removed from the moving part
    print $f[$_] | $s[$_];      # print both moving and fixed snowflakes ORed together
}

First of all, $_ is the default loop counter variable in Perl unless another variable is specified.  Here it runs from 0 to 23, i.e. over the 24 lines in the display frame.  $foo[$_] denotes the element indexed by $_ in the array @foo.
On the first line of the de-golfed loop, we print either a newline (conveniently obtained from the $/ special variable) or, when $_ equals 0, the string "\e[H", where \e denotes an ESC character.  This is an ANSI terminal control code that moves the cursor to the top left corner of the screen.  Technically, we could omit that if we assumed a specific screen size, but I kept it in this version since it means I don't have to resize my terminal to run the animation.
On the $t = $f[$_] line, we just save the current value of $f[$_] in a "temporary" variable (hence $t) before potentially changing it in the next line, where $s[$_] & $p[$_] gives the intersection (bitwise AND) of the falling snow and the input pattern, and the |= operator ORs that into the fixed output line $f[$_].
On the line below that, $t ^ $f[$_] gives the bitwise XOR of the previous and current values of $f[$_], i.e. a list of the bits we changed in the previous line, if any, and negating either of the input strings with ~ negates the output.  Thus, what we get is a bitmask with all bits set to 1 except those that we just added to $f[$_] on the previous line.  ANDing that bitmask onto $s[$_] removes those bits from it; in effect, this means that when a falling snowflake fills in a hole in the fixed pattern, it gets removed from the falling snow array.
Finally, print $f[$_] | $s[$_] (which in the golfed version is implemented by just ORing the two previous lines together) just prints the union (bitwise OR) of the fixed and moving snowflakes on the current line.
One more thing left to explain is the select '', '', '', 0.1 below the inner loop.  This is just a klugy way to sleep 0.1 seconds in Perl; for some silly historical reason, the standard Perl sleep command has one-second resolution, and importing a better sleep from the Time::HiRes module takes more chars than abusing 4-arg select.

There seems to be a slight bug: the 24th line is not used, and the bottom line of the ASCII art is the 23rd line. And it really should fill lower spaces before it fills upper ones, although I did not originally specify that.

@PleaseStand: I changed the code to use all 24 lines (and incidentally got rid of the say), at the cost of 2 extra chars.  I don't think I can change the fill order very easily, though; my implementation is rather fundamentally tied to it.

Great explanation! I wish I could up-vote this entry again.

@PleaseStand: I actually did manage to make a bottom-up filling version, which now looks pretty much the same as your JS example; it's a bit longer than the top-down one, but still shorter than the other entries so far.

HTML and JavaScript, 436 chars
Prepend it to the input:
<body onload="for(a=[],b=[],c=document.body.firstChild,e=c[H='innerHTML'].split(N='\n'),f=e.length-1,g=24,h=g-f;f--;)for(X=80;X--;)b[80*(h+f)+X]='*'==e[f][X];for(setInterval(F='for(y=24;y--;)for(x=80;x--;)if(a[w=80*y+x]){d=1;if(b[w])for(d=0,z=y+1;24>z;++z)b[s=80*z+x]&&!a[s]&&(d=1);d&&(a[w]=0,a[w+80]=1)}for(x=80;x--;).1>Math.random(i=0)&&(a[x]=1);for(t=\'\';1920>i;++i)t+=\'* \'[+!a[i]],79==i%80&&(t+=N);c[H]=t',67);g--;)eval(F)"><pre>

See it run for each example: code golf, Stack Overflow logo, Christmas trees. Internet Explorer users need to run version 9 and set the "Document Mode" to "IE9 standards" (using the F12 developer tools) for this submission to correctly work.

All 3 seem to be broken? http://www.pasteall.org/pic/show.php?id=66297

Python, 299 chars
This should conform to the rules, assuming the newline is included in the 80 char limit.
import random,sys,time
C=1920
v=_,x=' *'
a=['']*C
f=lambda n:[random.choice(e*9+x)for e in _*n]
for e in sys.stdin:a+="%-80s"%e
a=a[-C:]
s=f(C)
while 1:
 z=0;t=''
 for e in s:
    t+=v[x<a[z]or e>_]
    if(e>_<a[z])>(x in a[z+80::80]):a[z]='+'
    t+=z%80/79*'\n';z+=1
 print t;s=f(80)+s[:-80];time.sleep(.1)

Your output gets screwy if the input has any lines that are exactly 80 chars (plus newline) long.  I've asked PleaseStand to clarify whether that's OK.

This is because I include a newline at the end of each 80-char wide line. The description is ambiguous here, since it specifies that newlines must be included, but also that one may assume the terminal is 80 chars wide (in which case one may omit the newlines and depend on automatic wrapping).

I think the actual problem is that you don't strip off the newlines before padding the input lines to 80 chars, so that an 80-chars-plus-newline input ends up actually appending 81 chars to a and so messes up the indexing.  I just tried it, and it looks like replacing %e with %e.rstrip() on line 6 fixes the problem.  (Of course, there may well be a shorter fix; I'm no good at Python golf.)

If you want to support 81 char lines, just change the numbers, and it works out just fine. As long as you stay under 100 chars per line, it won't change the char count :-)

If I change your code to use 81-char lines, it won't run correctly on an 80-column terminal, now will it?  You're producing 80-column output just fine, it's just that you're not accepting 80-column input correctly.  Try it: create an input file with a couple of lines with 80 asterisks on each and see what happens.  It shouldn't be that hard: my solution handles it just fine.

Java, 625 chars
import java.io.*;import java.util.*;class s extends TimerTask {int _c,_k;char _i[],_o[];boolean _b[];public s(String f) throws IOException {_i=new char[23*80];_o=new char[80];_b=new boolean [23*80];BufferedReader br = new BufferedReader(new FileReader(f));while (br.read(_i,_c++*80,80)!=-1);} public void run(){_k=--_k<0?_c:_k;for(int i=0;i<80;_b[_k*80+i]=Math.random()>0.9?true:false,i++);for(int m=0;m<_c;m++){for(int n=0;n<80;_o[n]=_b[(_k+m)%_c*80+n]?'*':_i[m*80+n],n++);System.out.println(_o);}}public static void main(String[] a) throws IOException{Timer timer=new Timer();timer.scheduleAtFixedRate(new s(a[0]),0,500);}}

A simple solution in Java.

Nice, but I don't think you're complying with the spec.  In particular, you show the whole pattern from the beginning -- it doesn't "form from the falling snow" as in the sample demo.  (Admittedly, this could be explained better in the question.  You really need to watch the demo to understand what it should do.)  Also, your framerate is too slow, you don't start with a snow-filled screen, you seem to be assuming an input format different from the examples given, and you really ought to reset the cursor position between frames (printing "\033[H" should do it).