[Question]
  [
# Background
This is a standard textbook example to demonstrate for loops.
This is one of the first programs I learnt when I started learning programming ~10 years ago.
# Task
You are to print this exact text:
```
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
```
# Specs
* You may have extra trailing newlines.
* You may have extra trailing spaces (U+0020) at the end of each line, including the extra trailing newlines.
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins.
  
[Answer]
# [Brainfuck](http://esolangs.org/wiki/Brainfuck), 47 bytes
```
++++++++++[->++++>+>+<<<]>++>[-<..........>>.<]
```
[Try it online!](http://brainfuck.tryitonline.net/#code=KysrKysrKysrK1stPisrKys-Kz4rPDw8XT4rKz5bLTwuLi4uLi4uLi4uPj4uPF0&input=)
```
++++++++++[->++++>+>+<<<]   set the tape to 40 10 10
>++>                        set the tape to 42 10 10
[-<..........>>.<]          come on
```
[Answer]
# C (gcc), 41 39 bytes
```
main(i){for(;++i<puts("**********"););}
```
[Answer]
## Bash + coreutils, 19 bytes
I prefer to repeat stuff in Bash using 'yes'.
```
yes **********|head
```
I saved 2 bytes by @Neil's suggestion. But when the directory where you are running this command does not only contain files starting with a '.' dot you need to enclose the stars `*` with `"`.
## Bash + coreutils, 21 bytes
```
yes "**********"|head
```
[Answer]
## Vim, ~~13~~ 8 bytes
Saved 5 bytes thanks to @Lynn
```
qqi*‚êõ9.o‚êõq9@q 
```
```
10i*‚êõY9p
```
`10i*‚êõ` insert 10 times `*`, and `Y9p` copy the line and paste it 9 times.
[Answer]
# Pyth, 6 bytes
```
VT*T\*
```
`T` is 10 in Pyth, `Vab` executes statement `b` `a` times, `\*` is the asterisk character constant, and multiplying (`*`) a string and an integer repeats that string n times. Pyth's implicit printing with `V` means 10 lines are printed.
[Answer]
## Hexagony, ~~37~~ ~~35~~ ~~34~~ 31
```
10"+}(=${";<$<1}42/.0@_=<>\;>(_
```
Expanded:
```
   1 0 " +
  } ( = $ {
 " ; < $ < 1
} 4 2 / . 0 @
 _ = < > \ ;
  > ( _ . .
   . . . .
```
[Try it online](http://hexagony.tryitonline.net/#code=MTAiK30oPSR7Ijs8JDwxfTQyLy4wQF89PD5cOz4oXw&input=)
Basically just has two for loops counting down from ten to zero, printing out an asterisk on the inner loop, and a newline on the outer loop.
### Explanation:
This program consists of three main parts: initialisation of memory, a loop which prints ten asterisks and a loop which prints a newline. The loop which prints a newline also contains the loop which prints the asterisks.
First, the code runs the totally linear memory initialisation. The code works out to be: `10"+}42`. This sets the memory of the nearby edges to look like:
```
10 \ / 10
    |
   42
```
42 is the ASCII code for the asterisk character, and the two tens will be used as our loop counters. Of note is that the memory pointer is currently pointing away from the two tens, so moving backwards will put us on one of the tens.
Next, we start the astersisk printing loop. Linearly, the code looks like: `;".._(`. This prints out an asterisk, moves the memory pointer backwards and to the left and finally decrements the value there. After one iteration, the memory would look like:
```
10 \ / 9
    |
   42
```
Then we hit the loop condition: the bottom-leftmost `>`. If the edge we just decremented is still positive we bounce around and execute a `{` to move us back onto the 42. Then we hit a `$` and return to the beginning of the printing loop, the `;`, by skipping the `<`. If the value was zero, we head into the other loop.
The outer loop begins by resetting the recently zeroed memory edge to ten (this is the `10` in the code, going southwest). Then, we print out this ten as an ASCII character, which is a newline. Next, we move onto the other memory edge and decrement it with `{(` and then execute what amounts to a bunch of noops: `=${_=`. Now, after one iteration of this loop, memory would look like:
```
 9 \ / 10
    |
   42
```
This time, the memory is facing outwards from the edge storing a nine in the above diagram. Next we execute the `<` which acts as the loop condition for the outer loop. If the value was non-zero we bounce around off of some mirrors, then begin executing meaningful instructions again after entering the top of the hexagon at the `"` moving southwest. This causes us to move backwards and to the left, onto the 42 again, but facing inwards. Then the `=` flips our direction, resetting the state properly to begin the inner loop again. If the edge was set to zero, the instruction pointer goes on a little adventure which does nothing until it exits the program.
The adventure begins by the instruction pointer venturing northeast, perilously disregarding the safety of the cardinal directions. It bravely ignores a mirror that is aligned with its diretion (`/`) and heroically leaps off of a trampoline (`$`) entirely evading the deadly trap of another, totally identical trampoline. Staring out at the emptiness of uninitialised hexagon edges, the pointer, without faltering for a moment, adds the two blank edges it faces together, setting the current edge to their sum: 0 (the edge was actually zero beforehand, but the pointer likes to believe this was pretty important). Since the edge is zero, the pointer makes a left turn at the fork in the road, walking into a mysterious forest (of hexagons). There, it finds itself disoriented, moving forwards and backwards and forwards, until it winds up at the same place in memory as it started. Thinking that the problem must be that the current edge was set to zero last time, the pointer bravely plants a `1` into the current edge. Then, the noble pointer investigates another path, one laid with... a trap! The current edge is decremented and set back to zero! The pointer, dazed by the shocking turn of events, stumbles back into the trap setting the current edge to negative one. Infuriated, the pointer attempts to return to the comparatively pleasant forest, only to notice that since the current edge is not positive, the paths have yet again shifted and the pointer finds itself walking into a cave. And by a cave, I mean the mouth of a giant hexagonal worm. Helpless, the pointer curses the sexinity with its dying breath. Also, the program ends.
[Answer]
## Emacs, ~~10~~ 8 keystrokes
`F3` `C-1` `0` `\*` `ENTER` `F4` `C-9` `F4`
### Explanation
```
F3             Starts a macro recording
C-1 0 *        Apply 10 times command '*': prints 10 asterix'
ENTER          Insert new line
F4             Stops the macro record
C-9 F4         Apply 9 times the macro
```
*Thanks to Sean for saving two keystrokes, suggesting to replace `C-u``digit` with `C-digit`.*
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
‚Äù*x‚Åµ·πÑ9¬°
```
What's going on?
```
‚Äù*x‚Åµ·πÑ9¬°  - No arguments
‚Äù*       - character literal, *
  x      - multiply (dyadic operation)
   ‚Åµ     - integer literal, 10 (we have now constructed the string '**********')
    ·πÑ    - Print & linefeed (monadic operation)
     9   - integer literal, 9
      ¬°  - Repeat n times (n is 9 as the first ·πÑ is not a repeat)
```
Test it on **[tryitonline](http://jelly.tryitonline.net/#code=4oCdKnjigbXhuYQ5wqE&input=)**
[Answer]
## PowerShell, ~~14~~ 12 bytes
```
,('*'*10)*10
```
Constructs a string of asterisks of length `10` using string multiplication. Encapsulates that in parens and feeds that into the comma-operator to construct an array. We use array multiplication to construct a 10-element array consisting of that element (i.e., a 10-element array of asterisk strings). That's left on the pipeline, and output is implicit (since the default `Write-Output` for an array is newline-separated, we get that for free -- thanks to @Joey for the clarification).
### Older, 14 bytes
```
0..9|%{'*'*10}
```
Full program. Loops from `0` to `9` through a `ForEach-Object` loop `|%{...}`. Each iteration, we use string multiplication to create a length-`10` string of `*`. Those resulting strings are left on the pipeline, and output at the end is implicit (since the default `Write-Output` for an array is newline-separated, we get that for free -- thanks to @Joey for the clarification).
[Answer]
# [V](https://github.com/DJMcMayhem/V), 7 bytes
```
10√©*10√Ñ
```
[Try it online!](http://v.tryitonline.net/#code=MTDDqSoxMMOE&input=)
About as straightforward as an answer can be.
Explanation:
```
10      "10 times:
  √©*    "insert an asterisk
    10√Ñ "make 10 copies of the current line
```
5 bytes:
```
10O¬±*
```
Explanation:
```
10O     " Insert the following on the next ten lines:
   ¬±    "   10 copies of
    *   "   an asterisk
```
This didn't work when the challenge was posted because of a bug.
[Answer]
## [Jellyfish](https://github.com/iatorm/jellyfish/blob/master/doc.md), ~~12~~ 10 bytes
*Thanks to Zgarb for saving 2 bytes.*
```
P$'*
 &;10
```
[Try it online!](http://jellyfish.tryitonline.net/#code=UCQnKgogJjsxMA&input=WzEwIDEwXQ)
### Explanation
Using more conventional notation, this program represents the following expression:
```
P( $( &;(10), '* ) )
```
`&;` takes a single value and creates a pair with two times that value, so `&;(10)` gives us `[10 10]`. Then `$` is reshape which forms a 10x10 grid of asterisks. Finally, `P` prints the array in "matrix format" which prints each string on its own line.
[Answer]
# **HTML & CSS, ~~104~~ 60 bytes**
```
p::after{content:"**********"
```
```
<p><p><p><p><p><p><p><p><p><p>
```
I'm unsure if the byte count is correct (as I'm not counting the `<style>` tags for CSS. The HTML could also be shortened if I used a HTML preprocessor, but I'm unsure if that's breaking rules
Thanks to manatwork and Business Cat.
See my [Jade entry of 36 bytes](https://codegolf.stackexchange.com/a/90231/38505)
[Answer]
# Python 2, ~~22~~ 21 bytes
```
print('*'*10+'\n')*10
```
[Answer]
# [APL](https://en.wikipedia.org/wiki/APL_(programming_language)), 9 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319)
Works on all APLs ever made.
```
10 10‚ç¥'*'
```
`10 10`‚ÄÉten rows and ten column
`‚ç¥`‚ÄÉcyclically **r**epeating
`'*'`‚ÄÉa star
[TryAPL online!](http://tryapl.org/?a=10%2010%u2374%27*%27&run)
[Answer]
# Notepad, 34 31 keystrokes
```
**********
^A^C‚Üì^V^A^C‚Üì^V^V^V^V
```
^ denotes Ctrl-<following character> keypress, ‚Üë‚Üì are up and down keys, respectively.
Props to Crypto for 3 saved keystrokes.
[Answer]
## MATLAB, 14 bytes
```
repmat('*',10)
```
[Answer]
## Java 7, 63 bytes
```
void f(){for(int i=0;i++<10;)System.out.println("**********");}
```
Just for kicks. I can't seem to find any tricks to make this shorter. Trying to add logic for a 100-loop or returning a String instead of printing just ends up worse.
[Answer]
# Ruby, 15 characters
```
puts [?**10]*10
```
Sample run:
```
bash-4.3$ ruby -e 'puts [?**10]*10'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
```
[Answer]
# [Emojicode](http://www.emojicode.org), 54 bytes
```
üèÅüçáüîÇi‚è©0 10üçáüòÄüî§**********üî§üçâüçâ
```
Explanation:
```
üèÅüçá                        üë¥ The beginning of program.
    üîÇ i ‚è© 0 10 üçá          üëµ This is called a "range".
                          It basically starts with i=0 and increments until i=10, then exits. üëµ
        üòÄ üî§**********üî§    üëµ üòÄ is printing class.
                          The üî§s make the characters they surround string literals. üëµ
    üçâ                     üë¥ End of range
üçâ                         üë¥ End of program
```
[Answer]
## 05AB1E, 7 bytes
```
TF'*T√ó,
```
**Explanation**
```
TF      # 10 times do:
  '*T√ó  # repeat asterisk 10 times
      , # print with newline
```
[Try it online](http://05ab1e.tryitonline.net/#code=VEYnKlTDlyw&input=WzEsMiwzLDQsNV0)
[Answer]
## R, 27 29 bytes
```
cat(rep('\r**********\n',10))
```
An alternate answer (34 bytes) is: `cat(rep('**********',10),sep='\n')`
[Answer]
## Brainfuck, ~~46~~ 43 bytes
```
+[[---<]+[-->]<]<<[--<<++..........-->>>.<]
```
[Try it online!](http://brainfuck.tryitonline.net/#code=K1tbLS0tPF0rWy0tPl08XTw8Wy0tPDwrKy4uLi4uLi4uLi4tLT4-Pi48XQ&input=) Requires an interpreter with a tape that is open on the left and has 8-bit cells.
The first part of this program `+[[---<]+[-->]<]` sets up the tape like so:
```
[255, 250, 245, ... 15, 10, 5, 0, 250, 240, 230, ..., 40, 30, 20, 10, 0]
                                                                      ^
```
This gives a 40 for outputting asterisks (`*`, ASCII 42), a 20 to use as a loop counter, and a 10 to use for outputting newlines.
[Answer]
# PHP, 32 bytes
```
for(;$i++<10;)echo"**********
";
```
(variant 32 bytes - was written with `echo`)
```
<?=str_repeat("**********
",10);
```
(variant 33 bytes)
```
<?=str_pad("",110,"**********
");
```
(variant 33 bytes)
```
for(;$i++<110;)echo$i%11?"*":"
";
```
(variant 35 bytes)
```
for(;$i++<10;)printf("%'*10s
",'');
```
(variant 38 bytes)
```
<?=($a=str_repeat)($a("*",10)."
",10);
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
'*'10tX"
```
[**Try it online!**](http://matl.tryitonline.net/#code=JyonMTB0WCI&input=)
```
'*'   % Push '*' (string containing an asterisk)
10t   % Push 10 twice
X"    % Repeat the string 10√ó10 times. Implicitly display
```
[Answer]
# JavaScript (ES6), 37 bytes
```
console.log(`**********
`.repeat(10))
```
A straightforward answer.
[Answer]
# Brainfuck, 74 bytes
first brainfuck submission ever, first reasonable length program, too
```
+++>>+++>>+++++++[<+<+<<+>>>>-]<[>++++++<-]<<<[->++++++++++[>>>.<<<-]>.<<]
```
```
+++>>+++>>+++++++[<+<+<<+>>>>-]<[>++++++<-] < sets tape to 10 0 10 0 42
                                           <<< moves to the first 10
            [->++++++++++[>>>.<<<-]>.<<] <
loops while the first cell of the tape is not zero:
    subtracts 1 from first cell
    sets the second cell to 10,
    loops while second cell is not zero: prints 42 cell, subtracts from second cell
    moves to third cell, prints it
```
[Answer]
# vim, 8 bytes
```
10a*<ESC>Y9p
```
`<ESC>` is 0x1b.
## Annotated
```
10a*<ESC>  # append * 10 times
Y          # copy line into default register
9p         # paste 9 times
```
[Try it online!](https://tio.run/##K/v/39AgUUs60rLg/38A "V (vim) ‚Äì Try It Online")
[Answer]
# Cheddar, ~~21~~ 20 bytes
```
print('*'*10+'
')*10
```
Yet another straightforward answer.
[Answer]
## Haskell, 29 bytes
```
putStr$[0..9]>>"**********\n"
```
`<list1> >> <list2>` makes `(length <list1>)` copies of `<list2>`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
‚Äù*x¬≥s‚Åµj‚Å∑
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCdKnjCs3PigbVq4oG3&input=)
### How it works
```
‚Äù*x¬≥s‚Åµj‚Å∑  Main link. No arguments.
‚Äù*        Yield '*'.
  x¬≥      Repeat the character 100 times.
    s‚Åµ    Split into chunks of length 10.
      j‚Å∑  Join, separating by linefeeds.
```
]