use strict;
use warnings;

$|++;

my %acro = (
    HTML   => "Hypertext Markup Language",
    ICBM   => "Intercontinental Ballistic Missile",
    EEPROM => "Electronically-erasable programmable read only memory",
    SCUBA  => "Self Contained Underwater Breathing Aparatus",
    FAQ    => "Frequently Asked Questions",
    LCARS  => "Library Computer And Retrieval System",
    NASA   => "National Aeronautical and Space Administration",
);

INPUT: {
    print "Please enter an acronym: ";
    chomp( $_ = <STDIN> );
    $_ = uc or redo INPUT;

    last INPUT if /^Q/;

    unless (exists $acro{$_})
    {
        print "I don't know what '$_' means.\n";
        redo INPUT;
    }

    print "$_ ($acro{$_})\n";
    redo INPUT;
}
[download]

Some explanations:

1. Always begin programs with the top two lines. It's easier to have the compiler do the bookkeeping for you.
2. The $|++ is to disable output buffering. (q.v. Suffering from Buffering for more info.)
3. Then, I set up the lookup table for the acronyms.
4. Now, here's the goofy thing. You'll notice I'm using a named block and using last and redo. (I can't use next cause I'm not in a loop, but redo does something similar.) Sometimes, a certain construct makes a given algorithm easier to express for a given person. I like using named blocks and redo to handle keyboard input. Others like while-loops, goto, and all sorts of other ideas. I like named blocks.
5. Now, I assign to $_, which has the fancy name of "local topic". This is the default variable for many functions, including regexes.
6. I want to compare case-insensitively, so I uc the string. (uc defaults to using $_.) Now, if there is nothing, uc will return the empty string. This allows me to use logic short-circuits to redo the loop if nothing was entered. (Try it!)
7. I allow for a quit scenario by stopping if anything that begins with 'Q' or 'q' is entered. (You might want to change this to allow acronyms that begin with 'Q'.)
8. I use the exists function to have the hash do the lookup for me (instead of me coding a for loop). This also has the benefit of keeping my hash clean. If it doesn't exist, print a message and redo the block.
9. If it does exist, print the acronym and definition, then redo the block.

If you have any questions, please don't hesitate to ask!

I like this style, but the one thing that would drive me crazy using a program like this is that I wouldn't have any idea of how to exit. While I don't like cumbersome prompts like "Enter an acronym, upper or lower case, or enter something that starts with Q (also upper or lower case) to quit:" perhaps some indication of how to get out would be beneficial?

I know this is probably a moot point for a script like this, but I spend too much time in programs with really bad UIs to ignore it...

use strict;
use warnings;
use diagnostics;
[download]

This will do several things. You mentioned that you're (paraphrasing) "so new you don't know what you don't know..."

'use strict;' will force you to learn what it is you don't know; how to use lexical variables and scoping instead of package globals. It will also protect you from the pitfalls of unwittingly using soft references (symbolic refs -- something to leave alone for a good long while). And strictures will protect you from misspelling variable names.

'use warnings;' will cause Perl to warn you when you do things that turn out to often be indicitave of a common mistake. For example, using a variable only once, trying to rely on the value of a variable that never received a value, etc. You've already got warnings with the -w switch on the shebang line, but you get better control with the pragma instead of the commandline switch.

'use diagnostics;' will force Perl to become more verbose by explaining what its warnings and error messages mean, in greater detail.

If you do that, you will suddenly find yourself needing to revamp the script a little. Feel free to ask questions if you need an explanation of the outcome.

chomp($in = <STDIN>);
if (exists $acro{$in}) {
   print "$in is the acronym for $acro{$in}\n";
} else {
   print "Sorry, unknown acronym"; 
}
[download]

In my opinion (and all things are always subject to debate):

• You use last and other tools to exit loops when your loop structure could be made simpler to eliminate this hopping around. Code feels a bit goto-ish. Consider subroutines if you want extra clarity.
• Need to use 'my' to declare variables with scope rather than globally. Definitely enable 'use strict' and 'use warnings'. There are numerous reasons for this, which the books can explain in great detail.
• Program should probably process STDIN and output to STDOUT given the problem description, rather than being an interactive tool
• Stylistic, but no need to single quote items on the left side of '=>'
• If you want to clear a variable, use 'undef $var' instead of sending it the size of an empty array with '$var=()'. If you write good code, you'll rarely need to clear a variable, scoping means you don't need globals. Globals are usually a sign of a design flaw.
• Check for exit should probably read /yes|y/i instead of using what looks to be character classes... again, pick up Learning Perl or Programming Perl -- preferably both, as they cover this in depth
• No reason to assign a string to $final if you can just print a message...again, this is a sign your loop logic needs to be refactored

These are just a bunch of random comments, but you were asking for them, so I thought I would share. As you grow as a Perl programmer you will learn new tweaks and stuff, and your code will grow more elegant and easy to understand. Enjoy the process, as Perl is a really fun language and allows for some neat constructs. Don't be worried that people are pointing out ways you can improve, this monastery is an incredible resource. Most of all, realize Perl is fun!

I think most people would read this as suggesting that it should accept arbitrary text with the acronyms embedded, and modify them in place, not just do a straight lookup.

Under this interpretation, CombatSquirrel's solution is the only correct one in the thread.

Here's a related solution using the -p flag:

#!perl -p

s/($regex)/$1 ($acronyms{$1})/g;

BEGIN {
  %acronyms = (
    'HTML'    => "Hypertext Markup Language",
    'ICBM'    => "Intercontinental Ballistic Missile",
    'EEPROM'  => "Electronically-erasable programmable read only memor
+y",
    'SCUBA'   => "Self Contained Underwater Breathing Aparatus",
    'FAQ'     => "Frequently Asked Questions",
    'LCARS'   => "Library Computer And Retrieval System",
    'NASA'    => "National Aeronautical and Space Administration"
  );
  
  $regex = join '|', map quotemeta, 
        sort { length($b) <=> length($a) } keys %acronyms;
}
[download]

A quick note to bluethundr to explain whats going on here.

Perhaps the biggest difference between your program and CombatSquirrel's and simonm's is that they do not prompt for input, but instead read it from stdin. A program that prompts for input can only be used in one way. A program that reads text from stdin, does some work (expands acronyms) and writes out to stdout is useful on the unix command line. It can be used just like any other unix tool, and in combination with any of them.

See The Art of Unix programming, or any good unix book. Its not more work to learn the unix way along with the perl way - its less!

qq

In this case I often use an alternate method, especially if there are lots of accronyms in the list: I scan the text for things that look like accronyms, and see if they exist in the hash:

#!/usr/bin/perl -w
use strict; 

my %acro = (
    HTML   => "Hypertext Markup Language",
    ICBM   => "Intercontinental Ballistic Missile",
    EEPROM => "Electronically-erasable programmable read only memory",
    SCUBA  => "Self Contained Underwater Breathing Aparatus",
    FAQ    => "Frequently Asked Questions",
    LCARS  => "Library Computer And Retrieval System",
    NASA   => "National Aeronautical and Space Administration",
);

my $text=<<TEXT;
Here is a text that includes LOTS of accronyms like HTML, 
ICBM, SCUBA etc. Maybe this should be a FAQ.
TEXT

# substitute all accronymns in the text
$text=~ s{([A-Z0-9]+)}                 # find all upper-case words (st
+ored in $1)
         { $acro{$1}                   # is it in %acro?
                    ? "$1 ($acro{$1})" # yes, expand it
                    : $1               # no, leave it as is
         }gex;                         # g means to do it as many time
+s as possible
                                       # e means to execute the code i
+n the replacement part
                                       # x allows multi-line regexp an
+d comments

print $text;
[download]

Note that if accronyms can include lower case letters, you will need to change the matching regexp to include them.

Hey man. Thanks for your input. Sure, that's (partly) what I'm looking for. But the thing is I'm so new to perl that I literally "don't know what it is I don't know". honestly! Could you possibly, or rather would you care to be more specific about my "misconceptions about the operation of perl"? But I appreciate the confirmation that I was in headed in the right general direction. So, if you don't want to write a book about my "misconceptions" I can certainly understand.

At any rate, THANKS!

The short answer is that you'd do well to pick up one of the well known and well written books like merlyn's Learning Perl. I'll see if I can follow up with some specifics later.

#!/usr/bin/perl -w

use strict;
my $in = (); # usr input
my $exit = 'n'; # done yet?

my %acro = (
    'HTML' => "Hypertext Markup Language",
    'ICBM' => "Intercontinental Ballistic Missile",
    'EEPROM' => "Electronically-erasable programmable read only memory
+",
    'SCUBA' => "Self Contained Underwater Breathing Aparatus",
    'FAQ' => "Frequently Asked Questions",
    'LCARS' => "Library Computer And Retrieval System",
    'NASA' => "National Aeronautical and Space Administration" 
             );

# I personally don't like empty conditions on
# while loops.  This changed the logic a bit, so
# I changed the exit prompt as well.
while ($exit !~ /^y/i) {
    print "\nPlease enter an acronym: ";
    chomp($in = <STDIN>);
    print "\n";

    # I'm lazy, and don't want to worry about entering
    # uppercase acronyms.  The uc() changes input to
    # uppercase automagically.  Also, this approach
    # doesn't loop over every key every time.  That's
    # what a hash is best for -- so you don't have to loop
    # over everything.
    if (exists $acro{uc($in)})
    {
        # No need to assign to a temp variable, btw.
        print "$in is the acronym for ", $acro{uc($in)}, " \n\n";
    }
    else
    {
        # I also echo input so if the user mistyped the acronym they
        # may see the error.
        print "Sorry. But $in is not an acronym that I recognize!\n";
    }

    print "\nFinished? ";
    # Your original script didn't have any way to input $exit, so
    # it went into an infinite loop (I am guessing that was a
    # transcription error)
    chomp($exit = <STDIN>);
}
[download]

Ask if any of this doesn't make sense.

#!perl

use strict;
use warnings;

my %acronyms = (
   'HTML'    => "Hypertext Markup Language",
   'ICBM'    => "Intercontinental Ballistic Missile",
   'EEPROM'  => "Electronically-erasable programmable read only memory
+",
   'SCUBA'   => "Self Contained Underwater Breathing Aparatus",
   'FAQ'     => "Frequently Asked Questions",
   'LCARS'   => "Library Computer And Retrieval System",
   'NASA'    => "National Aeronautical and Space Administration"
);

my $regex;
{
   my $temp = join '|', map quotemeta, keys %acronyms;
   $regex = qr/($temp)/o;
}

while (<>) {
   s/$regex/$1 ($acronyms{$1})/g;
   print;
}
[download]

That is a useless use of /o.

Ah, that's what I was going to say!

So here's something a little different:

local $" = ';';
system qq( sed '@{[ map "s/\\<$_\\>/$_ ($acronyms{$_})/g", keys %acron
+yms ]}' );
[download]

Of course, if the acronym list is long, the above will smack into the command line length limit; in that case, it's easy enough to write a sed script file.

and a useless use of $1 ;)

Guys...I just have to say this. I am silently amazed. This thread is more than I was hoping for and truly a wonderful thing. The monk's site, in my thus far brief experience, proves to exemplify the finest aspects of the net. Which in my mind is that of allowing people to form their own communities and then to take that potential and leverage it to one's own personal growth and benefit. Amazing.

I have to say that a good deal of what was written was a bit beyond my ken. That is a good thing. It gives me something to strive for. But a good amount was also clearly discernible to my beginner's mind. I found an amazing amount of insight that I could only find amongst monks' wisdom that was, nevertheless, within my beginner's grasp.

I wish that I could address each of you individually. But that of course is impossible, especially given the fact that I'm typing this while the boss isn't looking! ;D

But in the meantime I just wanted to express my gratitude and say that I will STUDY what you all have written, weigh what I believe to be the pro's and cons of this exhilerating discussion and take the vast majority of your suggestions into consideration; especially the reading suggestions!

But right now for example, though I do have some experience with C && C++ - a thing which I find makes this journey a bit easier - I am still only, for example JUST learning about how to create functions in Perl and got a handle on basic regexing only a few weeks ago (among a great many other things that I don't yet know!). So this process may take some time. That's okay. I'm a patient fellow. One virtue to balance out a great multitude of vice! I'm going to take the next year or so to improve my beginner's status, but I'm quite sure I'll enjoy writing Perl forever. Or at least until the inevitable forward ho' march of progress forcess us to adopt more advanced technology!

But when I have more time I will try to address the individual questions I may have as a result of this (formidble!) thread. Until that can happen, I just wanted to say...

DA MONKS ROCK!!!