Basics of programming

• variables (generally, of different types: integer, floating point, character; arrays; structures)
• control statements: if/then/else
• loops: for, while
• libraries for common tasks
• support for reading and writing data in various formats (ASCII / FITS / custom)

• compiled languages: source code needs to be explicitly translated into machine code, generally in two steps: compilation and linking
  • machine language
  • basic languages: C, Fortran
  • more advanced languages (often "object-oriented"): C++, many others
• "interactive" languages
  • provide interactive programming as well as the ability to run existing programs
  • can be (but are not always) less computationally efficient than compiled programs
  • generally provide more extensive libraries, e.g. for plotting
  • astronomy possibilities:
    • Python, with matplotlib for plotting
    • IDL, with Astronomy Users Library
    • MATLAB
    • SuperMongo
    • gnuplot
• in astronomy, Python is undoubtedly the most ``up and coming"; also, freely available; also, widely used outside of astronomy/academics
• languages evolve and change! Understand the principles and be open-minded!

• Programming may be one of the more important skills you develop in the graduate program!
  • Think about coming out of NMSU with a programming portfolio!
• Assume that everything you write has an error in it (it usually does!): consider how you can test things!
• less is more (to a point) - don't repeat work, make the tool better and reusable
  • If your code has blocks that are very similar to each other, you can probably make it more efficient
  • Use functions/subroutines
• Think before you program: outline what needs to be included and consider how it can be made more modular
• all software should be written as if someone else will use it: document and share
• style, e.g. PEP8 guidelines, e.g., white space, indentation rules, ...
• Make your program readable. Use white space judiciously, recognizing tradeoff between separating program blocks and increasing length of code. Modular code is generally easier to read and digest.
• comments: every program must be commmented! Include an overview comment at the top and clarification comments throughout the code as needed. Don't need to comment what is apparent from reading the code if the code is straightforward. Separate comment statements are usually preferable to ``end-of-line" comments.
• Avoid hard-wired directories: consider use of environment variables to specify root directories
• Avoid hard-wired constants, file lengths
• Don't be too reluctant to rewrite code! Be self-critical.
• With "interactive" languages, experiment "interactively", but produce all final output using saved programs, so it is repeatable
• Show your code to others!
• Most astronomers think they are good programmers; most programmers would probably disagree, see, e.g., here , realize what you don't know, and learn it as appropriate
  • what astronomers can bring to the table: knowledge of analysis techniques, coming up with creative approaches/solutions to problems
• my experience as a programmer

Language basics:

• See table of basic syntax for C, Fortran, Python, IDL

Compiling a file:

• Compile and link single file program:
  • C: cc file (if default C extension .c is used, don't need to specify)
  • FORTRAN: f95 file (if default Fortran extension .f is used, don't need to specify)
• Multi-file programs:
  • compile individual program file modules: cc -c file
  • creates object (.o) files
  • multiple object files can be saved in a library archive (.a) file
  • link objects: cc -o output file1.o file2.o lib1.a

Unix Makefiles:

• simplifies task of compiling/linking programs, especially those that use many files/modules.
• Only recompiles files that have been modified.
• Can be generally useful for any Unix tasks that perform same functions on a number of different files
• A simple example
• See the GNU documentation
• standard for distribution of packages: often you download a package, unpack it, and enter: make to compile the whole thing, make install to install the final executables to some location in your PATH
• Explicit commands, variable filenames, rules.

  prog:
  	f95 -c prog.f b.f c.d
  	f95 -o prog prog.o b.o c.o
  

• Standard targets: install, objs, etc.
• Standard rules.
• Defining rules, e.g. Latex into PDF, etc

Simple examples:

• Create a simple "hello, class" code in C: sample C source
• Create a makefile that compiles this code and run it: Makefile
• Here is a code that outputs the number of bytes occupied by different types: typeSize
• Modify the program following the instructions at the top of the source code.
• See about plotting the output using idl, python, or gnuplot. Don't know how? Next section!