APL, 10↑↑3.4

Here's my revised attempt:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char (or byte*) program, running on current hardware (uses a negligible amount of memory and regular 32-bit int variables) although it will take a very long time to complete.

You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, it will have printed a number with 10 × 123456789⁴⁴ digits.

Therefore the score is 10^{10 × 12345678944} / 100³ ≈ 10¹⁰³⁵³ ≈ 10↑↑3.406161

Explanation

• ⎕D is a predefined constant string equal to '0123456789'
• n←⍎⎕D defines n to be the number represented by that string: 123456789 (which is < 2³¹ and therefore can be used as a loop control variable)
• {⍞←⎕D} will print the 10 digits to standard output, without a newline
• {⍞←⎕D}⍣n will do it n times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation n times, therefore printing the 10 digits n² times
• {⍞←n}⍣n⍣n⍣n will do it n³ times
• I could fit 44 ⍣n in there, so it prints n⁴⁴ times the string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: For the purpose of scoring, a N char long APL program that only makes use of ASCII characters and APL symbols can be considered to be N bytes long. This is because traditionally—before Unicode—APL files were saved in a specific single-byte charset which would map all the special symbols in the upper 128 values. Most interpreters can still read and write files in this charset.}

APL, 10↑↑3.4

Here's my revised attempt:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char/byte* program, running on current hardware (uses a negligible amount of memory and regular 32-bit int variables) although it will take a very long time to complete.

You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, it will have printed a number with 10 × 123456789⁴⁴ digits.

Therefore the score is 10^{10 × 12345678944} / 100³ ≈ 10¹⁰³⁵³ ≈ 10↑↑3.406161

Explanation

• ⎕D is a predefined constant string equal to '0123456789'
• n←⍎⎕D defines n to be the number represented by that string: 123456789 (which is < 2³¹ and therefore can be used as a loop control variable)
• {⍞←⎕D} will print the 10 digits to standard output, without a newline
• {⍞←⎕D}⍣n will do it n times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation n times, therefore printing the 10 digits n² times
• {⍞←n}⍣n⍣n⍣n will do it n³ times
• I could fit 44 ⍣n in there, so it prints n⁴⁴ times the string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL can be written in its own (legacy) single-byte charset that maps APL symbols to the upper 128 byte values. Therefore, for the purpose of scoring, a program of N chars that only uses ASCII characters and APL symbols can be considered to be N bytes long.}

APL

Here's my revised attempt:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char (or byte*) program, perfectly capable of running on current hardware (only uses 45 stack frames, standard output, and regular 32-bit int variables) although it could take an inordinate amout of time to complete.

You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, after a few gazillion years it will have printed a number with 10 × 123456789⁴⁴ digits.

Therefore the score is 10^{10 × 12345678944} / 100³ ≈ 10¹⁰³⁵³

Explanation

• ⎕D is a predefined constant string equal to '0123456789'
• n←⍎⎕D defines n to be the number represented by that string: 123456789 (which is < 2³¹ and therefore can be used as a loop control variable)
• {⍞←⎕D} will print the 10 digits to standard output, without a newline
• {⍞←⎕D}⍣n will do it n times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation n times, therefore printing the 10 digits n² times
• {⍞←n}⍣n⍣n⍣n will do it n³ times
• I could fit 44 ⍣n in there, so it prints n⁴⁴ times the string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: For the purpose of scoring, a N char long APL program that only makes use of ASCII characters and APL symbols can be considered to be N bytes long. This is because traditionally—before Unicode—APL files were saved in a specific single-byte charset which would map all the special symbols in the upper 128 values. Most interpreters can still read and write files in this charset.}

APL, 10↑↑3.4

Here's my revised attempt:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char (or byte*) program, running on current hardware (uses a negligible amount of memory and regular 32-bit int variables) although it will take a very long time to complete.

You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, it will have printed a number with 10 × 123456789⁴⁴ digits.

Therefore the score is 10^{10 × 12345678944} / 100³ ≈ 10¹⁰³⁵³ ≈ 10↑↑3.406161

Explanation

• ⎕D is a predefined constant string equal to '0123456789'
• n←⍎⎕D defines n to be the number represented by that string: 123456789 (which is < 2³¹ and therefore can be used as a loop control variable)
• {⍞←⎕D} will print the 10 digits to standard output, without a newline
• {⍞←⎕D}⍣n will do it n times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation n times, therefore printing the 10 digits n² times
• {⍞←n}⍣n⍣n⍣n will do it n³ times
• I could fit 44 ⍣n in there, so it prints n⁴⁴ times the string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: For the purpose of scoring, a N char long APL program that only makes use of ASCII characters and APL symbols can be considered to be N bytes long. This is because traditionally—before Unicode—APL files were saved in a specific single-byte charset which would map all the special symbols in the upper 128 values. Most interpreters can still read and write files in this charset.}

APL

Here's a lazy attempt:

{⍞←n}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←↑⍴⎕AV

99 char or byte* program, prints a number with 3 × 256⁴³ or 107507747624534602106757229467285 325349838983867263177675199476846262009816647725378282119677037141557248 digits.

Score is something like 2.56 × 10^{10750774762453460210675722946728532534983898386726317767519947 6846262009816647725378282119677037141557248} / 100³.

Explanation

• ⎕AV is a predefined array with 256 characters (it's the legacy charset of APL)
• n←↑⍴⎕AV defines n to be is its number of elements, or 256
• {⍞←n} will print this number "256" without a newline
• {⍞←n}⍣n will print it 256 times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation 256 times, therefore printing it 256^2 times
• {⍞←n}⍣n⍣n⍣n will print it 256^3 times
• I could fit 43 ⍣n in there, so it prints 256^43 times the string "256".

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: For the purpose of scoring, a N char long APL program can be considered to be N bytes long, because traditionally—before Unicode—APL files were saved with a specific single-byte charset which would map all the special symbols in the upper 128 values. Most interpreters can still read and write files in this charset.}

APL

Here's my revised attempt:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char (or byte*) program, perfectly capable of running on current hardware (only uses 45 stack frames, standard output, and regular 32-bit int variables) although it could take an inordinate amout of time to complete.

You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, after a few gazillion years it will have printed a number with 10 × 123456789⁴⁴ digits.

Therefore the score is 10^{10 × 12345678944} / 100³ ≈ 10¹⁰³⁵³

Explanation

• ⎕D is a predefined constant string equal to '0123456789'
• n←⍎⎕D defines n to be the number represented by that string: 123456789 (which is < 2³¹ and therefore can be used as a loop control variable)
• {⍞←⎕D} will print the 10 digits to standard output, without a newline
• {⍞←⎕D}⍣n will do it n times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation n times, therefore printing the 10 digits n² times
• {⍞←n}⍣n⍣n⍣n will do it n³ times
• I could fit 44 ⍣n in there, so it prints n⁴⁴ times the string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: For the purpose of scoring, a N char long APL program that only makes use of ASCII characters and APL symbols can be considered to be N bytes long. This is because traditionally—before Unicode—APL files were saved in a specific single-byte charset which would map all the special symbols in the upper 128 values. Most interpreters can still read and write files in this charset.}