Getting the Fastest Question Response

I always want to be sure that you get fast, courteous responses to your book-specific questions. Even though I don’t check my e-mail every day, I do check it most days of the week, so that’s the fastest way to contact me regarding issues that you have with my books. Of course, you can make the response even faster by doing a few simple things when sending your email:

  • Be sure to include the name of the book and the book edition in the message subject line.
  • Tell me which page, figure, or listing number to look at in the book.
  • Document the steps you took.
  • Provide me with the exact error message you’re seeing.
  • Tell me about your platform (operating system, the version of any software you’re using, and so on).

If you provide these basic pieces of information, I can usually answer your questions much faster—often without asking for additional information. E-mail communication can be difficult at times because it lacks that in person body language element and you can’t show me what you’re seeing on your machine. Remote diagnostics are harder than you might think.

It’s also important that you understand that I focus on book-specific questions. I’ve discussed this issue before in Sending Comments on My Books and Sending Comments and Asking Questions. The bottom line is that I want you to be happy with your book experience, but I also don’t have time to provide free consulting. Please let me know if you have any questions or concerns about contacting me at John@JohnMuellerBooks.com.

 

Sending Comments and Asking Questions

Anyone who reads my blog for very long understands that supporting my books is a big deal for me. I actively work with my readers because I realize that you have the choice of using books written by other authors. Let’s just say that my support system is one of the reasons you really do want to buy my books. My blog not only answers common questions you have, but also adds examples and other information to the information you already receive through my books, so make sure you keep you eyes peeled for additional information here as well.

The last time I discussed this topic was in 2011 in my Contact Me, Please! post. The same things apply now as they did then. I’ll answer your book-specific questions as soon as I possibly can and in as much detail as I can. However, I won’t write your school term paper for you, accept a marriage proposal, or provide free consulting (amongst other things readers have asked me to do in the past). If you’re having problems with an example or can’t find the book’s source code, please be sure to ask because I want your experience with my books to be nothing less than phenomenal.

I also encourage you to be a beta reader. You can see the posts I’ve made for several recent books. The biggest reason for me to ask readers to participate in the book building process is to ensure you get the book you want. I also want to avoid Errors in Writing. As far as I know, I’m the only technical author on the planet that invites reader comment during the writing process, but I truly feel your input is essential, so I request it in every way I can. As I get new book contracts, you’ll continue to see requests for beta readers posted on my blog.

You can always contact me at John@JohnMuellerBooks.com with any comments and questions you have. This includes both books and blog posts. Let me know about any concerns you might have and I’ll do my best to solve them. In the meantime, happy reading !

 

Sending Comments on My Books

I regularly receive a stack of e-mail about my books. Readers question everything and it makes me happy to see that they’re reviewing my books so closely. It means that I’m accomplishing my principle goal, helping you understand computers in every possible way so that you can be more productive and accomplish tasks with less effort. When I make something easier for someone and they tell me about it, the grin extends from one side of my face to another. It really makes my day.

Some readers are still asking me if it’s OK to send me comments. I definitely want to see any constructive comment that you have. Anything that helps me understand your needs better or corrects errors in my writing makes it possible for me to write better books. As I mentioned in my Contact Me, Please!, I really do want to hear from you. The main element that I need to obtain a usable comment is that it’s constructive. A comment that says, “This book really stinks!” doesn’t tell me anything. Here are some of the things you can do to create a constructive comment:

 

  • What book are you reading?
  • Which page contains the error?
  • What do you view as an error on that page?
  • How would you fix the error?
  • What sort of system are you running?
  • Are you using the correct version of the software (the same version that appears in the book)?
  • When did you encounter the problem?


The more information you provide, the easier it is for me to understand the issue and provide you with feedback. In many cases, I’ll upload the fix to my blog so that everyone can benefit from the response (so be sure you keep an eye on my blog for new entries). I work hard to ensure that my books are as error free as possible, but everyone makes mistakes. Also remember that sometimes mitigating factors, such as differences in software versions or anticipated hardware, make it appear that there is an error in the book when you’re really looking at a different in environment. Help me provide you with better books—send me comments!

There are a few things that I won’t do for you. I won’t help you pass an exam at school. Your learning experience is important to me, which means that I want you to continue your education by working through the instruction on your own. I also don’t provide free consulting. This means I won’t check the code that you created on your own for errors. I’ll help you with any book-specific question, but I draw the line at that point. Let me know if you have any input or insights on my books at John@JohnMuellerBooks.com.

 

Exploring the GrabAPicture Application (Part 9)

In the previous post, Exploring the GrabAPicture Application (Part 8), you saw how all of the GrabAPicture application settings are put together and stored on disk from a low level perspective. This post diverges from the topic of data for a while to consider the user interface that relies on the data. In this case, you discover how the command line interface for this application works. Of course, the first requirement is deciding why the application needs a command line interface. In order to support automatic desktop wallpaper changes, the application does indeed use a command line interface. You can use the command line interface to create a shortcut like the one shown here and add it to the Shortcut folder on your system.

GrabAPicture0901

Look at the Target field. The application is configured to use the /Random command line switch to display any of the configured wallpapers at random. You can configure GrabAPicture in other ways, such as selecting a specific wallpaper. As with most applications that sport a command line interface, GrabAPicture provides a full help screen. The command line interface for this application is as follows:

GrabAPicture /?

GrabAPicture /Random

GrapAPicture /Picture:<Picture URI> [/Style:Stretched | Tiled | Centered]

where:

 

  • /?: Displays the help screen.
  • /Random: Selects any of the configured wallpapers at random.
  • /Picture: Displays a specific graphic found at the specified URI.
  • /Style: Configures Windows to display the wallpaper in Stretched, Tiled, or Centered mode.

Many applications have a considerably more complex command line interface, but you’ll find that this one is more than complex enough. The command line interface resides in frmMain.vb in the Main() function. When you see the code for this part of the example your first thought will be that the code is overly complicated and you’ll never understand it, but this isn’t the case. The Main() function does have a number of decisions to make, but they really come down to a number of selections.

 

  1. If there aren’t any command line arguments, the start the GUI version of the application.
  2. If the user has entered the /? command line switch as the first argument (regardless of anything that follows), display the help screen.
  3. If the user has entered the /Picture command line argument, then process the specific picture.
    1. Obtain the specific URI as the second part of the first command line argument.
    2. Check for a /Style command line switch as a second command line argument.
    3. Obtain the specific style as the second part of the second command line argument.
    4. Display the graphic on screen.
  4. If the user has entered the /Random command line switch, determine which picture to use from the preconfigured selections.
    1. Check for a configuration file. If none exists, display an error message and exit.
    2. If the user has checked both local and remote options, make sure the configuration settings are usable, then obtain a wallpaper selection from the preconfigured choices.
    3. If the user has checked just the local option, make sure there are local wallpaper selections to use, and then obtain the wallpaper selection from the local choices.
    4. If the user has checked just the remote option, make sure there are remote wallpaper selections to use, and then obtain the wallpaper selection from the remote choices.
    5. When the user hasn’t selected either local or remote random selections, display an error message and exit.

That’s really all there is to the code—a number of choices. With that in mind, here’s the massive looking, but not all that difficult code for this part of the example (normally, I don’t present code segments this long, but this particular example requires that I show the entire segment so you can see how it works).

Shared Function Main(ByVal CmdArgs() As String) As Integer
   ' Process the command line arguments.
   If CmdArgs.Length > 0 Then
      ' Get the first argument.
      Dim CmdArg As String = CmdArgs(0)
 
      ' User is requesting help.
      If CmdArg = "/?" Then
         ' Create an output string.
         Dim Output As New StringBuilder
 
         ' Create the usage instructions.
         Output.Append("Usage:" + vbCrLf)
         Output.Append("GrabAPicture" + vbCrLf)
         Output.Append("GrabAPicture /?" + vbCrLf)
         Output.Append("GrabAPicture /Random" + vbCrLf)
         Output.Append("GrabAPicture /Picture:<Picture URI> " + _
                       "[/Style:Stretched | Centered | Tiled]" + _
                       vbCrLf + vbCrLf)
         Output.Append("When used alone, displays the configuration " + _
                       "interface" + vbCrLf)
         Output.Append("/? - Displays this help message." + vbCrLf)
         Output.Append("/Random - Displays one of the images provided as " + _
                       "random input through the configuration program." + _
                       vbCrLf)
         Output.Append("/Picture - Defines a local or Web location for a " + _
                       "picture." + vbCrLf)
         Output.Append("/Style - Determines the display style of the " + _
                       "picture. Use only with the /Picture switch." + vbCrLf)
 
         ' Display the help.
         MessageBox.Show(Output.ToString(),
                         "GrabAPicture Usage",
                         MessageBoxButtons.OK,
                         MessageBoxIcon.Information)
         Return 0
      End If
 
      ' User wants to display a particular picture.
      If CmdArg.Length > 8 Then
         If CmdArg.Substring(0, 8).ToUpper() = "/PICTURE" Then
 
            ' Wallpaper manipulation class.
            Dim Wallpaper As New WinWallpaper
 
            ' Split the string.
            Dim NewUri As Uri
            NewUri = New Uri(CmdArg.Substring(9))
 
            ' Determine whether there is a Style argument to process.
            If CmdArgs.Length > 1 Then
 
               ' Get the style argument.
               Dim StyleArg As String = CmdArgs(1)
 
               ' Change the style.
               If StyleArg.Substring(0, 6).ToUpper() = "/STYLE" Then
                  Select Case StyleArg.Substring(7).ToUpper()
                     Case "STRETCHED"
                        Wallpaper.Style = WinWallpaper.Styles.Stretched
                     Case "CENTERED"
                        Wallpaper.Style = WinWallpaper.Styles.Centered
                     Case "TILED"
                        Wallpaper.Style = WinWallpaper.Styles.Tiled
                  End Select
               End If
            End If
 
            ' Change the wallpaper.
            Wallpaper.WallpaperURI = NewUri
         End If
         Return 0
      End If
 
      If CmdArg.ToUpper() = "/RANDOM" Then
         ' Current application settings.
         Dim CurrentSettings As GrabAPictureSettings
 
         ' Number of settings to randomize.
         Dim Settings As Int32 = 0
 
         ' The selected image number.
         Dim Selection As Int32 = 0
 
         ' Contains the wallpaper location.
         Dim NewUri As Uri
 
         ' Wallpaper manipulation class.
         Dim Wallpaper As New WinWallpaper
 
         ' Initialize the stored settings.
         CurrentSettings = GrabAPictureSettings.LoadSettings()
 
         ' Verify that there are settings to use.
         If CurrentSettings Is Nothing Then
            MessageBox.Show( _
               "This application isn't configured to use random sources.")
            Return -1
         End If
 
         ' Obtain the number of settings to randomize.
         If CurrentSettings.LocalChecked And CurrentSettings.RemoteChecked Then
 
            ' Detect configuration errors.
            If CurrentSettings.LocalUris Is Nothing Or _
               CurrentSettings.RemoteUris Is Nothing Then
 
               MessageBox.Show("Application not set up to use " + _
                               "both local and remote locations.")
               Return -2
            End If
 
            ' Determine the number of settings.
            Settings = CurrentSettings.LocalUris.Length + _
               CurrentSettings.RemoteUris.Length - 1
 
            ' Randomize the settings.
            Randomize(DateTime.Now.Millisecond)
            Selection = Convert.ToInt32(Settings * Rnd())
 
            ' Obtain the style and location.
            If Selection < CurrentSettings.LocalUris.Length Then
 
               ' Choose the wallpaper style.
               Select Case CurrentSettings.LocalUris(Selection).Style
                  Case WinWallpaper.Styles.Stretched
                     Wallpaper.Style = WinWallpaper.Styles.Stretched
                  Case WinWallpaper.Styles.Centered
                     Wallpaper.Style = WinWallpaper.Styles.Centered
                  Case WinWallpaper.Styles.Tiled
                     Wallpaper.Style = WinWallpaper.Styles.Tiled
               End Select
 
               ' Create a wallpaper URI.
               NewUri = New Uri(CurrentSettings.LocalUris(Selection).Location)
            Else
               ' Subtract the local resources.
               Selection -= CurrentSettings.LocalUris.Length
 
               ' Choose the wallpaper style.
               Select Case CurrentSettings.RemoteUris(Selection).Style
                  Case WinWallpaper.Styles.Stretched
                     Wallpaper.Style = WinWallpaper.Styles.Stretched
                  Case WinWallpaper.Styles.Centered
                     Wallpaper.Style = WinWallpaper.Styles.Centered
                  Case WinWallpaper.Styles.Tiled
                     Wallpaper.Style = WinWallpaper.Styles.Tiled
               End Select
 
               ' Create a wallpaper URI.
               NewUri = New Uri(CurrentSettings.RemoteUris(Selection).Location)
            End If
 
            ' Set the wallpaper location.
            Wallpaper.WallpaperURI = NewUri
 
         ElseIf CurrentSettings.LocalChecked Then
 
            ' Detect configuration errors.
            If CurrentSettings.LocalUris Is Nothing Then
               MessageBox.Show("Application not set up " + _
                               "to use local locations.")
               Return -2
            End If
 
            ' Determine the number of settings.
            Settings = CurrentSettings.LocalUris.Length - 1
 
            ' Randomize the settings.
            Randomize(DateTime.Now.Millisecond)
            Selection = Convert.ToInt32(Settings * Rnd())
 
            ' Obtain the style and location.
            ' Choose the wallpaper style.
            Select Case CurrentSettings.LocalUris(Selection).Style
               Case WinWallpaper.Styles.Stretched
                  Wallpaper.Style = WinWallpaper.Styles.Stretched
               Case WinWallpaper.Styles.Centered
                  Wallpaper.Style = WinWallpaper.Styles.Centered
               Case WinWallpaper.Styles.Tiled
                  Wallpaper.Style = WinWallpaper.Styles.Tiled
            End Select
 
            ' Create a wallpaper URI.
            NewUri = New Uri(CurrentSettings.LocalUris(Selection).Location)
 
            ' Set the wallpaper location.
            Wallpaper.WallpaperURI = NewUri
 
         ElseIf CurrentSettings.RemoteChecked Then
 
            ' Detect configuration errors.
            If CurrentSettings.RemoteUris Is Nothing Then
               MessageBox.Show("Application not set up " + _
                               "to use remote locations.")
               Return -2
            End If
 
            ' Determine the number of settings.
            Settings = CurrentSettings.RemoteUris.Length - 1
 
            ' Randomize the settings.
            Randomize(DateTime.Now.Millisecond)
            Selection = Convert.ToInt32(Settings * Rnd())
 
            ' Obtain the style and location.
            ' Choose the wallpaper style.
            Select Case CurrentSettings.RemoteUris(Selection).Style
               Case WinWallpaper.Styles.Stretched
                  Wallpaper.Style = WinWallpaper.Styles.Stretched
               Case WinWallpaper.Styles.Centered
                  Wallpaper.Style = WinWallpaper.Styles.Centered
               Case WinWallpaper.Styles.Tiled
                  Wallpaper.Style = WinWallpaper.Styles.Tiled
            End Select
 
            ' Create a wallpaper URI.
            NewUri = New Uri(CurrentSettings.RemoteUris(Selection).Location)
 
            ' Set the wallpaper location.
            Wallpaper.WallpaperURI = NewUri
 
         Else
            MessageBox.Show("None of the random settings are selected.")
         End If
         Return 0
      End If
 
      ' Indicate an error condition for the command
      ' line switches.
      MessageBox.Show( _
         "Use the /? switch to see application usage.", _
         "GrabAPicture", _
         MessageBoxButtons.OK, _
         MessageBoxIcon.Error)
      Return -1
   Else
      ' Run the application for configuration purposes.
      Application.Run(New frmMain)
   End If
End Function

The Main() function begins by checking CmdArgs.Length, which contains the number of command line arguments passed from the command line by the user. When this value is 0, the example bypasses all of the rest of that command line processing code and calls the standard code, Application.Run(New frmMain).

Of course, you’re interested in finding out what happens when the user does provide a command line argument. The first thing you’ll normally check is the /? command line switch. In this case, all it does is create a StringBuilder object, Output, and display it to the user. Unlike most command line utilities, which display help screen at the command prompt, GrabAPicture does use a dialog box like the one shown here to display help.

GrabAPicture0902

Because Main() is a function, you need to return some sort of value that indicates success or failure. If you always return 0, then the utility isn’t very useful in a batch file. The example returns a value of 0 to indicate success. However, it uses other values to indicate errors:

 

  • -1: The application hasn’t been configured to use random sources.
  • -2: The application hasn’t been configured to use both local and/or remote random sources.

You can actually test for these errors in a batch file and then do something about it. Yes, batch files do offer limited capabilities for error trapping and even fewer options for recovery, but these outputs do provide the opportunity recover in at least some cases.

The next test is against a word, Picture, which can be in any case. Whether you use uppercase or lowercase is up to youI happen to prefer uppercase, so the next test looks for /PICTURE. The command line switch is only part of the argument though, so you must extract the switch from the URI of the image the user wants to use by calling CmdArg.Substring(0, 8).

On to the picture processing. The code begins by creating a new WinWallpaper object, Wallpaper. It then creates a Uri object, NewUri, from the second half of the first command line argument using CmdArg.Substring(9). This method skips the colon that separates /Picture from the URI of the picture.

Now, the application has to decide how to display the image. If the user doesn’t supply the /Style command line switch, the application uses whatever setting is in place. Otherwise, the application uses a Select Case block to choose the appropriate style.

Only after the application has done all of this other processing does it set the Wallpaper.WallpaperURI property value. Changing this value changes the wallpaper (see Exploring the GrabAPicture Application (Part 7) for details).

So, what happens with the /Random command line switch? The processing is more straightforward than you might think. There are four possibilities:

 

  • Both the Use Random Local Sources and Use Random Remote Sources check boxes are checked.
  • Only the Use Random Local Sources check box is checked.
  • Only the Use Random Remote Sources check box is checked.
  • Neither check box is checked.

In the last case, the program exits with an error message and an error code. All three other cases follow the same pattern.

 

  1. The application checks for the required resources.
  2. When the settings exist, the application obtains the number of available settings.
  3. The application then selects a random item from the list of available settings.
  4. The code sets the Wallpaper.Style property value.
  5. The code creates a Uri from the settings.
  6. The code sets the Wallpaper.WallpaperURI property value, which changes the wallpaper on the Desktop.

There is one final consideration for this example and you’re bound to miss it in all of that code. The user could enter a command line switch that’s pure gibberish. Users do that. In this case, you need to tell the user how to get help. This little piece of code keeps things from blowing up or frustrating the user.

' Indicate an error condition for the command
' line switches.
MessageBox.Show( _
   "Use the /? switch to see application usage.", _
   "GrabAPicture", _
   MessageBoxButtons.OK, _
   MessageBoxIcon.Error)
Return -1

This is a short course on the command line interface for the GrabAPicture application. If you have any questions about it, please contact me at John@JohnMuellerBooks.com. Next week we’ll look at the code behind the GrabAPicture frmMain controls. You can find the next post in this series at Exploring the GrabAPicture Application (Part 10).

Contact Me, Please!

I ran across an online review of one of my books the other day. The author was mainly complimentary, but said he couldn’t contact me using e-mail and found that he felt alone in using my book. He obviously had unsolved questions and felt that he had been left alone to solve them by himself. Of all of the complaints I receive about my books, not being able to contact me for help is the one that hurts worst.

I want you to be able to contact me. In fact, I check several times a day, five days a week (Monday through Friday) for reader e-mail and try my best to provide same day support. The only exception is when I’m out of the office on vacation (I’m striving to provide an automated message to let you know when I expect to return to answer your question). Even then, the first day back from vacation is spent answering reader e-mail. Your comments, questions, and general observations are incredibly important to me. Just in case you haven’t seen it in the book, my e-mail address is:

John@JohnMuellerBooks.com

If you purchase one of my books, you’ll see my e-mail address in at least two places: About the Author and the last chapter of the book as a bare minimum. I try to make it a point to mention my e-mail address five or six times in the book. In at least some cases, you’ll also find my e-mail address on the back cover.

Despite my best efforts, you may find it hard to reach me. If you can’t reach me for whatever reason, contact the publisher. Every publisher I work with has a Web site with a contact page. Normally, the publisher supports a forum in addition to an e-mail address (plus other contact methods that vary by publisher). If you contact the publisher, you can be sure that the publisher will contact me. The publisher knows it’s in its best interest to send any reader queries my way as quickly as possible.

At this point in time, I want to wipe out the “I couldn’t contact the author” complaint from the face of the earth. If you have anything to say about one of my books, don’t be afraid to contact me and say whatever is on your mind. You may be surprised to find that I care deeply about your needs and want to be sure you get the best possible use from my books.

That said, there are some people who try to take advantage of me. I won’t provide free consulting and no, I really am not a marriage prospect (I’ve been happily married for 31 years now). I truly don’t have time to debug your personal project, no matter how much it might interest me (and believe me, you readers have come up with some truly amazing projects over the years). However, if you have any question about my book, the source code, additional materials, or anything of that sort, please contact me, rather than assume I won’t treat you right.

Now, here’s an opportunity to tell me how to improve my books. If there is some other place that you’d like to see my e-mail address, tell me about it. I truly want to hear from you. Let me know where it would help to see my e-mail address so that you can contact me about my books whenever you want. I’ll be waiting to hear from you at John@JohnMuellerBooks.com.

 

Obtaining Command Line Help

Both Administering Windows Server 2008 Server Core and it’s more diminutive counterpart, Windows Command-Line Administration Instant Reference, are reference manuals that tell how to use the command line to perform specific tasks. The first book is more complete, in that it contains many uncommon commands and utilities. The second book is designed to provide more hands-on help by supplying a significant number of actual usage examples. In both cases, you get a significant amount of help about the commands. As long as you have one of these two books by your side, you’re in great shape for knowing how to use the commands at the command line. Unfortunately, the reality is that most of us don’t stuff a library full of books in our back pocket. Even with an e-Reader, such as the Kindle, you can be sure of having the device available every time you need it. So, how do you get at least some quick help when there aren’t any resources available?

The first thing to remember is that you can get at least some useful information for any command or utility by using the /? or -? command line switches (some commands and utilities are peculiar in that they require either the /? or the -? command line switch, while many will allow you to use either). For example, when you want to discover how to use the Dir command, you type Dir /? and press Enter. Here’s typical output when using the /? command line switch.

GettingHelp01

This help screen is also typical in showing what you get. Help normally includes a short description of the command, the command line syntax, and a short description of each of the command line switches. You may also see usage examples for more complex commands. In rare cases, the help screen will provide an URL for additional help.

Some commands and utilities are complex enough that they require several help screens. For example, if you type WMIC /? and press Enter, you’ll see a list of help topics, not help of the sort provided for the Dir command. Let’s say you want to know more about the CPU topic. So, now you type WMIC CPU /? and press Enter. The help looks a little more normal now, but still isn’t very complete because you need to choose a subcommand. Perhaps you want just a list of CPUs on a system, so you request information about the List subcommand by typing WMIC CPU List /? and pressing Enter. Wow, now you see a number of listing formats. This time you add a listing format by typing WMIC CPU List Brief /? and pressing Enter. It turns out that you can also discover information about command line switches used with the Brief format. The final level in this case is to type WMIC CPU List Brief /Translate /? and press Enter. The WMIC utility is unique in providing so many levels of help, but other complex commands and utilities, such as Net, do provide multilevel help.

No matter how many help screens you see, sometimes it isn’t enough to give you the help you need. That’s when you need to find your copy of my book to get additional information. Of course, a single book can do only so much—some complex commands and utilities may require still more information. Technet is a good place to start. For example, you can find an excellent article on WMIC at http://technet.microsoft.com/library/bb742610.aspx. Knowledge base articles also provide useful information, especially when it comes to issues that Microsoft has solved for a given command or utility. For example, the Knowledge Base contains an article entitled, “How to find computer serial number” that relies on WMIC. Finally, make sure you look at third party articles, such as the one entitled, “WMIC: the best command line tool you’ve never used.”

Many people complain about not being able to remember all of the commands and utilities, and this is a problem. After you use a command or utility often enough, you tend to remember it, but the memorization process can take time. Unfortunately, there isn’t any single quick method of finding every command or utility on a system. However, you should start by typing Help | More and pressing Enter. (Using the More command lets you see the information that a utility has to provide one screen at a time, rather than seeing the information scroll right past.) You’ll get a list of common commands like this one.

GettingHelp02

Not all of the commands appear on this list and none of the utilities do. Another way to obtain the information you need is to type Dir *.COM and press Enter in the \Windows\system32 directory. (You can type CD \Windows\System32 and press Enter to get to the appropriate directory.) Every directory entry you see is very likely a utility. However, many utilities are in .EXE form, so you also need to type Dir *.EXE | More and press Enter. You can eliminate files that contain more than eight letters in the filename from the list in most cases because command line utilities usually rely on the old 8.3 naming convention. Check filenames that look like they could be what you want by typing Filename /? and pressing Enter (where Filename is the name of the file you want to test). Useful command line utilities will generally display a help screen.

Now that you have a better idea of how to get command line help when you need it and where to obtain a list of useful commands and utilities, you should take some time to try it out for yourself. What techniques do you use to obtain the additional information you need at the command line? Let me know at John@JohnMuellerBooks.com.