Credits

Purpose

This website contains all the resources to learn the principles of computer programming using C#. It is used in the delivery of CSCI 1301 - Principles of Computer Programming I and CSCI 1302 - Principles of Computer Programming II in the Bachelor of Science in Computer Science at Augusta University, and contains practical guides and additional resources for students and instructors.

Authors

At the time of writing, this resource is actively maintained Clément Aubert. Additional contributions, by (under)graduate course assistants and other contributors, are tracked by version control.

Some of the material originated from discussion, handouts and contributions by Clément Aubert, Aubrey Bryant, Michael Dowell, Richard DeFrancisco, Onyeka Ezenwoye, Leszek Gasieniec, Reza Rahaeimehr, Neea Rusch, Edward Tremel and Paul York.

Additionally, the School of Computer & Cyber Sciences’s past and present academic advisors, Laura Austin, Denise Coleman, Markus Bacha, and Wennie Squires, and communications & marketing specialist, Haley Bourne, improved the Academic Life notes through their suggestions and references.

Supports

The first source of support is the constant stream of feedback we receive from students and users: thank you.

This project has been monetarily supported by an Affordable Learning Georgia Transformation Grants (Proposal 571) and a Continuous Improvement Grant (M260).

This project also received the support of Augusta University’s School of Computer and Cyber Sciences and Center for Instructional Innovation.

Tools

We strive to prioritize open-source software when possible, and occasionally contribute to them.

Software

This website uses different technologies.

• The markdown source code is converted to (a slightly different) md, pdf, odt and docx formats thanks to pandoc and pandoc-include (among other lua filters).
• The pdf format is compiled using XeLaTeX.
• The source code is highlighted thanks to Pygments.
• The website is powered by quartz.

More details on the tools we use and how this resource is made can be found in dev. guide.

Fonts

We use the URW Gothic and Hack (inspired by the DejaVu font) fonts. Those fonts have been specially selected for their legibility and lower impact on environment.

Services

The source code and the website are graciously hosted and built by github.

Licence

This work is under Creative Commons Attribution 4.0 International. Concretely, this means that you are free to:

• Save, print, copy and redistribute the entirety of the resources presented here,
• Modify them as you see fit,

as long as you give proper credit and keep the same licence.

Please refer to our licence file for the detail of this licence.

Contributing

How can I contribute?

If you are a student

We would like to hear your thoughts on this resource to understand how to make it better for you and your fellow students. If you encounter a mistake, run into an issue while using the resource, or find it missing something important, you can contribute by providing feedback in one of the following ways:

• talk to your instructor about the issue
• talk to your section’s UCA about the issue
• leave feedback on this website on the page where you notice the issue
• Open an issue
• print the resource and identify the issue, then hand it to your instructor or UCA

If you have suggestions on how to make it better, we encourage you to share those ideas too.

If you are an instructor

You will need to have a Github account. Next contact any of the authors of this resource over email, provide your Github username, and request an invitation to be added to the instructors team.

If you are a UCA

You will need to have a Github account. Next ask your course section instructor to invite you to the 1301 UCAs team. Your instructor needs your Github username to send you the invitation.

If you are an outside collaborator

When you have identified a mistake in this resource and want to notify the authors, leave feedback on this website on the page where you notice the issue or open an issue explaining the issue.

If you want to make edits yourself, you can fork the source code, make edits, then open a pull request for us to review.

Next steps for editors

If you are looking to edit this resource and making your first contribution, read through the dev. guide. It explains:

• how to locate different resources
• how to edit the resources
• how to label content

Following the dev. guide will help to ensure your edits meet the expected quality guidelines and can be integrated into the existing resource with ease.

Dev. Guide

This guide explains how this resource is organized, how it is built and deployed, and how to maintain this resource. It is intended to be comprehensive, but should most likely be read only after having read our contributing and UCA guides.

Resources Organization Overview

Folders and Files

The source code repository’s main branch is organized as follows:

The source/ folder contains the following:

Building and Deploying

The content is built and deployed in two phases:

• Running make all in the source/ folder will create a content/ folder at root level containing:
  • one .md file per .md file in the source/ folder (in the same location: source/labs/If.md is compiled to content/labs/If.md), resulting from pandoc’s conversion,
  • one .pdf, .odt and .docx file per .md file (with the exception of the index.md files) in the source/ folder (in the same location: source/labs/If.md is compiled to content/labs/If.pdf), resulting from pandoc’s conversion,
  • some files from the img/, slides/ and vid/ folders, copied selectively (for example, only the .jpeg, .png, .pdf, .svg and .gif files are copied from the img/ folder),
  • the .woff and .woff2 files copied from the fonts/ folders,
  • a code/projects/ folder containing, for each Program.cs file contained in a source/code/projects/x/y, a x.zip archive containing a C# project including Program.cs along with some (optional) class file,
  • a web-order.ts file, compiled from the source/order file, that fixes the order used by the website in the menu,
  • a book.html, a book.pdf, a book.html and a book.docx file resulting from pandoc’s conversion of the .md files contained in the SOURCE_BOOK’s makefile variable (containing all the .md files in the source/docs/ and source/lectures/, in the order fixed by the order file).
• Then, using the files in the generated content/ folder, a website is built using quartz and deployed to https://princomp.github.io/. This is achieved mainly thanks to the .github/workflows/build_and_deploy.yaml file and github’s actions.

Tools, Briefly

This resource is mainly developed and powered using

• git
• pandoc
• make
• python
• quartz,
• github’s actions.

But note that knowing git and markdown are enough to contribute on-line through the github repository.

While most of those tools are standard (with the exception of quartz, but it relies itself on the standard Node and npm technologies), we acknowledge that

1. It is challenging to understand that many different technologies,
2. We should strive to welcome contributions from collaborators not familiar with them,
3. Our set-up is unique in some respects.

This guide tries to alleviate some challenges resulting from this overall unique and diverse resource organization. For more details about our tools, please refer to the Installing dependencies and Repository Maintenance sections.

Locating Resources

To obtain the latest version of this resource, you can either

• visit the accompanying website princomp.github.io,
• download the latest version of the built resource,
• clone our repository.

This resource is an extension of csci-1301.github.io/, please refer to their user guide for more information about it.

Editing Resources

If you are new to this project, first read through Contributing Guidelines to learn how you can contribute to the improvement of this resource, and if applicable, how to join a contributing team.

Best practices for all forms of content

Inclusivity

Follow the IT Inclusive Language Guide from the University of Washington:

use gender-neutral terms; avoid ableist language; focus on people not disabilities or circumstances; avoid generalizations about people, regions, cultures and countries; and avoid slang, idioms, metaphors and other words with layers of meaning and a negative history.

Typically, we recommend using

• “unethical hacker” instead of “black hat”,
• “main” instead of “master”,
• “blank space” instead of “white space”,
• “display on the screen” instead of “printing”, -etc.

In doubt, please start by referring to this list of problematic words and phrases.

Structure for accessibility

• All resources are titled
  • title each markdown document by having one (and only one) title at top level (that is, using #),
  • use subtitles when appropriate,
  • title all images with a descriptive title and add an alt-tag,
  • title all code blocks in labs and lecture notes.
• All resources are labelled when applicable, see content labelling for more details

Resources to assess accessibility:

• Affordable Learning Georgia’s guide
• Specific Review Standards from the QM Higher Education Rubric
• UWG Accessibility Services’s guide
• Penn State’s recommendations for alternative text and complex images.
  
• WebAim Color Contrast Checker
• WebAIM (Web Accessibility In Mind)

Markdown

Text documents are written using standard markdown syntax. More precisely,

• in the markdown+emoji format, that is, in pandoc’s markdown, using the emoji extension),
• using the pandoc-include filter,
• and a custom filter that sets all the code blocks, or all the code block and inline code’s syntax highlighting to C# by default.

Because of the way the markdown is processed, please refrain from using the “ and ” characters: pandoc will automatically convert " into language-appropriate quotes for us.

Images

• Images belong in source/img/ directory.
• Explain the image in written form.
• Title each image, this will create a URL for the image and enables linking to it.
• Always include a descriptive alt tag for accessibility.
• Do not rely on everyone seeing colors the same way.
• Prefer scalable vector images.
• When referring to images in markdown, use path from root, see example below

Syntax example. The quoted text is the alt tag and in parentheses is path to file

!["image of visual studio IDE"](./img/vs_ide.jpg){ width=80% }

The { width=80% } attribute is optional.

Images generated by LaTeX

Some images are generated by LaTeX: the .tex file is what is used to generate the .pdf file, and then pdf2svg converts the .pdf into a .svg file. The .svg files are used in the .html, .odt and .docx documents, while the .pdf is used in the .pdf documents. The resulting images are added to the repository so that there is no need to re-compile them every time, or to set-up LaTeX and latexmk on each system.

UML class diagrams

The UML class diagrams are created using Mermaid and located in source/uml. To create a new class diagram, say for a Documentation class, follow those steps:

1. Create a Documentation.txt file in source/uml that follows the syntax for class diagrams (note that there is no need to add classDiagram at the beginning, it will be done automatically),
2. Run (from the source/ folder) make uml/Documentation.md,
3. Integrate the resulting drawing, properly captioned and with a link to your Documentation.txt file (for visually impaired readers, or to facilitate automatic processing) using !include uml/Documentation.md.

Source code

• Source code programs belong in source/code/ directory.
• The code included in this directory should either be:
  • Placed in the snippets/ sub-folder, and be a complete program.
  • Placed in the projects/<solution>/<project>/ sub-folder, and contains a Program.cs file:
    • Go to source/code/projets/,
    • Create a subdirectory with the name of the solution you would like to use,
    • Create a subdirectory with the name of the project you would like to use,
    • Create a file called Program.cs in

    source/code/projects/<solution>/<project>/Program.cs

    • If you want to add additional classes, add them in code/projects/<solution>/<project>/<Class>.cs files.
    Do not add solution (sln) or project (csproj) files: they will be created automatically using the project and solution’s name you specified (and a makefile rule similar to this one), if multiple classes are present they will all be linked, and the resulting archive will be hosted at content/code/projects/<solution>.zip.
• Source code that is faulty, partial, or does not terminate can be included in markdown as inline code block.

Code snippets can be included in markdown documents using pandoc-include filter:

    ```text
    !include code/sample.cs
    ```

Note that for an unknown reason, no special characters (such as _) should be used in the filenames.

• Title each source code block included in markdown, this will create a URL for the code block and enables linking to it.
• code blocks are by default annotated as csharp
  • syntax highlighting is applied automatically at build time based on the code block language
  • to use a language other than C#, specify the language locally in the specific code block:

    ```text
    This will be treated as plain text without highlighting
    ```
    

• only include code in text form such that it can be copy-pasted for reuse
• make sure to include blank lines before and after code blocks, since the absence of these can cause the code block to display incorrectly.

Tidying Source code

CSharpier is used to tidy the source code and make it uniform. Use

make tidy

to tidy all the source code present in the source/code/ folders. The configuration file is at source/code/csharpierrc.yaml.

Creating new lectures

Lecture notes belong to the source/lectures/ directory.

To create a new lecture, for instance on exception handling:

1. Create a directory corresponding to the theme if it does not exist already (say, exceptions), under source/lectures/ directory

   • Follow the existing pattern for naming convention which is lowercase and separation by underscores.

   • At the root of this folder, create an index.md file (so, at source/lectures/exceptions/index.md) containing

     ---
     title: Desired Title for Theme
     ---

     so that your theme will be labeled “Desired Title for Theme” on the website’s menu (see content labelling on how to further label it).

2. Under the directory corresponding to your theme, create a file named after the lecture’s title (e.g., exception-handling.md) in lowercase. Write lecture notes in this file using markdown.

3. Edit the source/order file and insert where appropriate

   • ./lectures/exception/ (if you created a folder called exception),
   • ./lectures/exception/exception-handling.md (which must be between ./lectures/exception/ and the next ./lectures/xyz/ folder).

   This last step will insure that your lecture is 1. included in the book, 2. sorted correctly on the website’s menu (the default ordering is alphabetical).

If the lecture does not appear, here are the steps for troubleshooting the issue:

1. Check that after committing changes, the automated build has completed successfully, by checking the workflows,
2. The newly created lecture is under the subdirectory you picked in the source/lectures/ directory,
3. The .md file exists,
4. Hard refresh the browser page if viewing the resources website

Known issues: When concatenating files pandoc may or may not include empty spaces between individual files. This may cause the subsequent lecture title to not appear in the generated book. For this reason, each lecture file should end with a newline.

Creating new labs

The process is very close to the process to create a new lecture, with the following exceptions:

• All lab resources are located under source/labs/ directory, at root level (there is no “theme” sub-folder).
• You do not need to edit the source/order file, since labs are not included in the book nor sorted on the website.

Additionally, remember to:

1. Choose a short and unique name that describes the lab (say, StringMethods.md)
   • follow the existing convention for naming,
   • do not number labs or make assumptions about numbering because another instructor may not follow the exact same lab order,
   • make the lab standalone to support alternative ordering (avoid assumptions about what was done “last time”),
   • do not make assumptions about student using specific OS, include instructions for all supported options (Windows, MacOS, Linux),
   • do not make assumptions about student using Visual Studio, refer to IDE instead.
2. (optional) You can add a downloadable project (use a link of the form [the Rectangle project](./code/projects/Rectangle.zip)) or include snippets of code by following our instructions to add source code.

Using this established build system generates labs that are cross-platform (Windows, MacOS, Linux) and work on different IDEs (this process is documented in the corresponding repository). Do not attempt to create labs locally as that approach does not have the same cross-platform guarantee.

Content Labelling

Technically

Quartz support a powerful tagging system which should be leveraged. Markdown files can contain at their very top a YAML metadata block containing, e.g.

---
tags:
- Resource
---

to “tag” this resource with “Resource” so that it will appears in the tag listing. To include multiple tags, simply make a list:

---
tags:
- Resource
- Guide
---

Conceptually

We will follow the guidance provided on this page:

• Use as Few Tags as Possible
• Limit Yourself to a Self-Defined Set of Tags
• Tags Within Your Set Must Not Overlap
• By Convention, Tags Are in Plural
• Tags Lower Case
• Tags Are Single Words
• Keep Tags on a General Level
• Omit Tags That Are Obvious
• Use One Tag Language
• Explain Your Tags

Styling and Templating

Templating files are under source/templates/ directory. Templates directory contain layout files that are applied by pandoc when resources are built: note that the website’s style uses a completely different mechanism.

For maintainability reasons it is preferable to apply templates during build time. This strategy makes it easy to edit templates later and apply those changes across all resources. Avoid applying templating to individual resource files whenever possible.

Currently templates directory contains the following:

• docx/ - contains template used to produce .docx files (this template is not used yet, for size issues).
• filters/ - contains pandoc filters for annotating code blocks, configured to default to C#, which then allows applying syntax highlighting to all code block.
• html/ - contains template used to produce only the book.html file (to edit the style of the website, refer to editing website)
• latex - contains templates used to produce .pdf files,
• docx/ - contains template used to produce .odt files.

Updating docx template

Note that this template is not used yet, for (among other) size issues.

To edit this template, start by obtaining the default template file:

pandoc -o custom-reference.docx --print-default-data-file reference.docx

Then, open reference.docx, and, following loosely this tutorial, do:

• Click pretty much anywhere, and right-click on the highlighted style (displayed if you are under “Home”, you may need to scroll down the styles),
• Change the font for everything but the source code,
• Click on the “Block code”, then right-click on the highlighted style, and select the font for the source code,
• The font for “Verbatim Char” was also changed, but I am not sure if this has an impact,
• Make sure the fonts are embedded,
• Save and close the document.

This was inspired by this post but does not seem to work properly.

Updating odt template

First, output the default template file:

pandoc -o custom-reference.odt --print-default-data-file reference.odt

Then, open reference.odt, and, following loosely this tutorial, do:

• Click on View, then Styles.
• Right-click on “Preformatted Text”, click on “Modify…”, and then select the desired font family for source code.
• In the dialog or sidebar which opens make sure the button in the top panel marked with ¶ is highlighted (it is very subtle).
• In the menu at the bottom of the dialog/sidebar choose Applied Styles. Only “Default Paragraph Style” and “Footer” should appear.
• Right-click on “Default Paragraph Style”, click on “Modify…”, and then select the desired font family for the rest of the text.
• Then, highlight the A next to ¶.
• Right-click on “Source_Text”, click on “Modify…”, and then select the desired font family for source code.
• Click on File, then Properties, then on the Font tab, click on “Embed fonts in the document”.
• Save and close the document.

Building locally

It is generally not necessary to build this resource locally unless the intent is to preview templating changes or to make changes to build scripts. For the purposes of editing content, it is sufficient to make edits to markdown files and commit those changes.

Installing dependencies

To find the current list of dependencies needed to build this resource, refer to the build and deploy script install section. The exact installation steps vary depending on your local operating system.

In general the following dependencies are needed:

• pandoc
• texlive
• make and other standard unix utilities (such as sed or wget, all included in the Windows Subsystem for Linux),
• python 3.+
• packages and filters: Pygments, pandoc-include, texlive-xetex, texlive-latex-extra, lmodern, librsvg2-bin
• symbola font

For this later, note that starting with version 11, the licence is too restrictive for non-personal use. As a consequence, users are asked to make sure they do not use a version greater than v.10.24, which is “free for any use” and archived on-line (curious users can also refer to the related webpage). Note that installing this dependency using a unix-like package manager will result in installing a version of the font that is free to use in any context.

You can make sure you are currently using the latest version of panflute by running

pip install -U panflute

This is needed if running a recent version of pandoc (as of pandoc 3.1.6.1 at least).

Running the build

Testing the installation

After installing all dependencies, from the source/ folder, run:

make

to display a list of useful rules.

It is recommended to first run a command building simple documents or copying files to test your installation, such as

make ../content/docs/about/credits.md
make ../content/docs/about/credits.pdf
make ../content/docs/about/credits.odt
make ../content/docs/about/credits.docx
make ../content/code/projects/Rectangle.zip
make ../content/web-order.ts
make ../content/img/create_project_monodevelop.png
make ../content/fonts/hack/hack-italic-subset.woff

If this was successful, you can compile the resources needed for the website using

make build-light

Building all resources

You can run

make -l 2.5 -j$(nproc --ignore=2) all

to create and populate the content/ folder at root level with all the resources compiled. Note that this command limits the number of jobs in parallel and the number of CPU used (using this trick), but that tweaking those values may be needed to find the sweet spot on your own machine.

If you want to speed-up the compilation time, you can run

make fetch

which will fetch the latest build output, extract it and populate the content/ folder using its content. Due to make’s unique feature only the files whose source was edited will be re-created when executing make all the next time, hence saving a lot of time. However, please not that files moved or deleted will still be present in the build.

Website

Editing the website

The website https://princomp.github.io/ is built from the .md files contained in the content/ folder using a dedicated branch of quartz. To edit the layout, style, or other features such as the footer, please start by checking out the quartz branch (using git checkout quartz), and then

• Refer to quartz’s website, repository and general community,
• Knowing that multiple edits already tweaked its style.

A couple of indications about the edits made to quartz:

• The favicon at quartz/static/, and have been generated using https://realfavicongenerator.net/.
• The order in the menu is constructed using the content/web-order.ts file, itself generated from the source/order file in the main branch: refer to the makefile (again, in the main branch) for explanations on how this file is created, to the quartz documentation for the main inspiration, and to the quartz.layout.ts and sortFn.ts files for the concrete implementation. If you change the order, setting

useSavedState: true, // To debug the explorer, change to "false" (this way, the menu is not cached / permanent), 

to false in the quartz/components/Explorer.tsx file may help in refreshing the menu more easily.

• Other files edited or created include:

  • The files

    quartz/components/AlternativeFormats.tsx
    quartz/components/styles/alternativeFormats.scss

    list alternative formats at the top of the page,

  • The files

    quartz/components/Comments.tsx
    quartz/components/scripts/darkmode.inline.ts
    quartz/components/Footer.tsx
    quartz/components/styles/listPage.scss

    customize the footer and add a link to our repository feedback (while following the selected style),

  • quartz/styles/base.scss loads a different set of fonts,

  • The files

    quartz/components/Explorer.tsx
    quartz.layout.ts

    tweak the menu and layout,

  • quartz.config.ts sets meta-data about the website,

  • quartz/components/pages/404.tsx customizes the 404 error message,

  • quartz/plugins/emitters/assets.ts emits the .md files (they are not available by default),

  • quartz/components/index.ts ties it all together.

Refer to Generate the git patch for instruction on how to generate a patch containing all the edits performed to our local copy of quartz.

Deploying locally the website

Follow closely those steps:

• Build the resource locally (note that running make build-light is enough to deploy the website).

• Move to the quartz branch by running

  git checkout quartz 

  Note that the content/ folder is still here, but that the source is absent from this branch: only files related to quartz are committed in this branch.

• Rename the content/index.md file (this is due to an annoying bug) by running

mv content/index.md content/index_b.md

• Follow quartz’s instructions:

  • If you don’t have at least Node v18.14 and npm v9.3.1, install node and npm (npm is probably installed automatically when you install node),
  • Run the following commands at root level (do not enter the quartz/ folder):

  npm i
  npx quartz create

  for this last command, select

  │ ● Empty Quartz

  then,

  │ ● Treat links as shortest path ((default))

  • If the previous command succeeded, run

  mv content/index_b.md content/index.md

  to restore our index file, then

  npx quartz build --serve

  to start the server. Then, navigate to localhost:8080/ to see the website deployed locally.

Updating quartz

Our local copy of quartz, in the quartz branch, is “frozen” in the sense that it corresponds to the development of quartz at a point of time. It is possible to

1. Save the edits made to our local copy (as a git patch),
2. Pull the current version of quartz in a different branch (called quartz-update),
3. Apply our edits to this updated version of quartz,
4. Replace the quartz branch with the quartz-update branch to deploy the updated version of quartz with our edits.

This process is not without risks and requires to be able to deploy locally the website to test it before deploying it. The following guide was inspired by this discussion.

Generate the git patch

The first step is to save as a git patch all the edits that have been made on our local copy of quartz since it was last updated.

• Make sure you are

  1. At root level in your repository’s copy,
  2. In the quartz branch,
  3. That your branch is up-to-date.

  by running a command such as

  pwd && git checkout quartz && git pull

• Locate the commit (short) id of the last commit performed by quartz maintainer. A way of achieving this is to look for “PCP” in the commit messages, using

  git rev-parse --short :/PCP

  and then to look for the commit id of the commit that came before it. For instance, if the previous command returns 847e3356, then the command

  git rev-parse --short 847e3356^1

  will return information about the commit that came before that last commit: we will assume its (short) id is 3b74453f in the following.

  Visual inspection using github’s interface or a program such as gitk can facilitate this process. Note that removing the --short option will give the long version of the id, which may be harder to compare.

• Use the (short) id previously obtained to generate a patch containing all the changes made since that commit:

  git diff-index 3b74453f --binary > pcp_quartz_patch

  The --binary option insures that any file created will be included in the patch: as a result, this file can be heavy.

• Make sure this pcp_quartz_patch file is located at the root level in your repository’s copy but do not commit it to the repository.

Clone the latest version of quartz

Execute the following commands:

git remote add quartz https://github.com/jackyzha0/quartz.git
git fetch quartz
git checkout -b quartz-update quartz/v4

where quartz-update is the name we use for our branch, and quartz/v4 is the name of the branch in the quartz repository we want to copy.

Apply the git patch

There are two ways of applying the patch. First, make sure you are in the quartz-update branch by executing

git rev-parse --abbrev-ref HEAD

Then follows the first method if possible.

Using apply

First, check if the pcp_quartz_patch patch is applicable, by executing

git apply --ignore-space-change --ignore-whitespace --check --reject pcp_quartz_patch

Some sections of the patch may be rejected: make sure you take note of which file will need to be merged by hand. Then, apply the patch, using

git apply --ignore-space-change --ignore-whitespace --reject pcp_quartz_patch

Then look for the .rej files: they will contain the edited version of a file that you will need to merge manually with the updated version of the same file from quartz’s update.

Using patch

If git apply gave an error starting with

Checking patch quartz.layout.ts...
error: while searching for:

then, instead, do

patch -p1 < pcp_quartz_patch

And look for the .rej files as described above. Note that using this technique requires to copy the binary files by hand. Indeed, you should receive warning messages like

File quartz/static/android-chrome-192x192.png: git binary diffs are not supported.

and those files will have to be copied by hand from another branch, and / or re-added to the repository.

Testing

Once you are done manually merging, test your updated version by deploying locally the website and making sure that quartz does not return any error. If everything looks ok, add all the new files and commit the edits using a message containing the “PCP” string (to facilitate future generation of git patch), and push, using for example:

• First, use bash git add --all -n . to list all the files you are about to add: make sure you are not adding files from the content/ folder, for instance. If everything looks fine, proceed to the next step.

• Then, actually add the files, commit, and push, using:

  git add --all
  git commit -a -m "Applying previous PCP patch."
  git push origin quartz-update

Update the branch

If you were able to fix all the conflicts and to check that the website could still be deployed locally, then overwrite the quartz branch with the quartz-update branch, by executing:

# Make sure your working tree is in a clean state
git status

# Check out the branch you want to change, e.g. some-branch
git checkout quartz

# Reset that branch to some other branch/commit, e.g. target-branch
git reset --hard quartz-update

If the deployment was successful and everything seems to be working, you can delete the quartz-update branch, locally then remotely, by executing

git branch -D quartz-update
git push -d origin quartz-update

Repository Maintenance

This repository uses following tools and technologies:

• git - version control
• Github - to make source code available on the web
• markdown, LaTeX - for writing the resources
• pandoc - for converting documents to various output formats
• make - for specifying how to build this resource
• github actions - to automatically build the resource
• github pages - to serve the accompanying website
• additional packages for specific tasks: texlive, Pygments, pandoc filters, lua filter, etc.
• fonts-symbola - to produce the emoji and other symbols in the pdf document.
• utteranc.es - for feedback through website
• csharpier - to tidy the C# source code

Build outputs

The resource material is organized into specific directories inside the source/ folder. These resources are then compiled into templated documents in various formats using pandoc. The makefile explains the exact steps applied to each type of resource.

Github actions

This resource is built automatically every time changes concerning files in the source/ folder are committed to the main branch of the repository. This is configured to run on Github actions. The workflow that is automatically triggered has two jobs: one to build the resource, and one to deploy it.

Currently Github actions offers unlimited free build minutes for public repositories (and 2000 min/mo. for private repositories, should we ever need them), which hopefully continues in perpetuity (if it does not there are other alternative services). Going with one specific CI service over another is simply a matter of preference.

Following a successful build, the build script will automatically deploy the generated resources to an accompanying website hosted on github pages.

Fetch and No Fetch Versions

There is a second workflow that is identical to the first one with one important exception: to speed up compilation, build_and_deploy.yaml uses make fetch to speed up compilation time by re-downloading the latest build output, and then compiling only the required files. This can sometimes complicate the propagation of changes, typically if a template is modified (as this does not triggers a re-compilation of the files using it currently) or if a file is renamed (as the previous version will not be deleted).

The build_and_deploy_no_fetch.yaml can be triggered manually to force a “fresh” remote compilation.

Creating releases

Currently a github action is setup to do the following: whenever a new commit is made to the main branch, the action will build the resource and add the generated resources as a pre-release and tag them as “latest”. If a subsequent commit occurs it will overwrite the previous latest files and become the new latest version. This cycle continues until maintainers are ready to make a versioned release (or “package”).

Making a versioned release is done as follows:

1. Go to repository releases
2. Choose latest, which contains the files of the latest build
3. Edit this release, giving it a semantic name and a version, such as v1.0.0. Name and version can be the same. (cf. semantic versioning)
4. Enter release notes to explain what changed since last release
5. Uncheck “This is a pre-release”
6. Check “Set as the latest release”
7. Update release

Following these steps will generate a new, versioned release. The versioned releases will be manually uploaded to and archived on galileo.

Once this is done, remember to create the next pre-release:

1. Go to the repository releases.
2. Click on “Draft a new release”.
3. Pick the tag “Latest”.
4. Click on “Generate release notes”
5. Check “This is a pre-release”
6. Click on “Publish release”

Maintaining repository feedback

Resource users can submit feedback about the resource through various means, one of which is leaving comments on the website. This feature is enabled by utteranc.es, using repositories hosted by the princomp github organization.

To manage user feedback over time, a semester-specific repository is created for issues only. This must be a public repository and located under the same organization as the resources repository. utteranc.es widget is configured to point to this repository. After a semester is over, this feedback repository will be archived, and a new one created for the next semester. This will simultaneously archive all older issues and reset the feedback across website pages.

Migrating feedback repository

The steps for migrating feedback target repository are as follows:

1. Create a new public repository under princomp github organization. Follow the established naming convention (feedback-<fall|spring|summer>-<YYYY>), and leave all the options except for visibility (which needs to be set to public) by default.

2. Go to repository Issues (make sure issues is enabled in repository settings).

3. Create a new label whose label name is comment (to match widget configuration as indicated in quartz/components/Footer.tsx, in the quartz branch).

4. Go to Organization Settings > Installed GitHub Apps.

5. Choose “utterances” > “configure”

6. Under “Repository access” > “Only select repositories”

   • Select the repository created in step 1.
   • Remove the previous semester feedback repository.
   • Save.

7. In princomp/princomp.github.io/ repository, in the quartz branch, open quartz/components/Footer.tsx

8. Update utteranc.es widget code to point to the new feedback repository created in step 1.

   <script data-external="1"
           src="https://utteranc.es/client.js"
           repo="princomp/{REPOSITORY_NAME}"
           label="comment" …>
   </script>

9. Commit change to quartz/components/Footer.tsx

10. Make sure the feedback works after migration. If it does not, retrace your steps.

11. Archive the earlier feedback repository in its settings.

Maintaining Instructors / G/UCA rights

This is handled by the csci-1301 github organization and documented at https://csci-1301.github.io/user_guide.html#maintaining-instructors-guca-rights.

How to get Help

This page lists resources for Augusta University students to receive help with their course of studies, in general, for students of the School of Computer and Cyber Sciences, and for this course in particular.

In General

Many resources are available to help you be a successful student:

• If you are food insecure, you are not alone, and the Open Paws Food Pantry will help you.
• For tutoring resources, consult the Academic Success Center (or “ASC”). It can help you, among other things, in the areas of time management, test preparation and study strategies.
• Student Counseling & Psychological Services (or “SCAPS”) is here to assist students with a variety of personal, developmental, and mental health concerns.
• The Writing Center can help you with any written, oral, or multimedia project.
• To get help with technologies, refer to our Instructional Technology Support correspondent Sienna Sewell.
• The Department of Multicultural Student Engagement (MSE) aims to provide education, training, and programming to foster awareness of diversity and inclusion among Augusta University students. Their Multicultural Mentorship Program and African American Male Initiative are excellent resources to receive additional help.

For Students of the School of Computer and Cyber Sciences

School of Computer and Cyber Sciences Tutoring Center

The School has a tutoring center that can be reached:

• On discord,
• During their tutoring hours (hours posted on the door and on discord), in University Hall 129.

ACM Club

The Augusta University chapter of the A.C.M is one of the university’s best resources for Computer Science, Information Technology and Cyber Security students. It provides a platform to network with other students in similar majors, presenting countless opportunities to not only expand the people you know, but also a fantastic place to learn and ask questions. To learn more, you can sign up for the newsletter, or attend one of the subgroup meetings (meeting times and locations are listed on the website).

Other Club Activities

The Augusta University Game Design Club and Girls Who Code College Loop “will be continuing activities in full force this year”. Notifications for upcoming activities will be shared in class alongside school-wide emails.

How to Ask a Question?

It may seems silly, but asking a question “the right way” may not always be easy.

1. Once you’ve identified your issue, try again from scratch to see if you missed a point.
2. Go over the instructions, and look in our resources for some meaningful keywords.
3. Think about how you can describe your issue, what is the shortest route to reproduce it.
4. If you are still facing difficulties, be detailed and clear about what you think went wrong: if the question is related to computers, specify which operating system, what you have tried, the exact nature of the error message, etc. Screenshots are not always the right way to convey your question: try to be descriptive, and explain what you tried. If you want to refer to a particular lab or lecture, open the corresponding page, look for the closest title, hover over it, and you should see a “§” symbol appears: click on it, you can now share that link so that your interlocutor knows precisely what you are talking about!

And, remember: your instructor(s) knows that you are a student and here to learn, so you should never feel intimidated or assume that everyone knows better than you: many students struggle in this class at times, and you could actually do them all a favor by asking your instructor(s) to go over a particular dimension that they may have overlooked or explained poorly!

Commenting Using a Github Account

On this website, if you look below, you will see a box where you can comment. This will require that you create a Github account, which is free and may serve multiple purpose if you intend to study, use, or contribute to open-source projects. The comment can use the markdown syntax (exactly like this resource!), which is also used on websites like stackoverflow and extremely popular!

Choosing Your Major

Which degree is best for you?

Most universities offer both a Computer Science degree and an Information Technology degree, and some universities even offer a Management Information Systems degree. Here at Augusta Unversity, we have all three options for you:

• Computer Science (CS / CSCI),
• Information Technology (IT / AIST),
• and Cybersecurity (CYBR),

along with two unique diploma,

• Cybersecurity Engineering,
• and Cyber Operations.

While all of these degrees are high-quality and should place students on a fast-track towards a successful career, students always ask the same question, “Which degree is best for me?” The answer to this question depends on the student, their career goals, and a variety of other factors.

Students even ask more specific questions:

• Which degree will give me the highest salary?
• Which degree is easiest?
• Which degree is hardest?
• Which degree has the most job opportunities?

These are all great questions! But before answering them, it is more important to have a basic understanding of the degree options.

The following links detail these three degrees and explain the benefits of each:

• Difference Between a Computer Science & Information Technology Degree
• Computer Science vs Information Systems/Technology
• Degrees that Pay You Back (from Wall Street Journal)

Additionally, Augusta University has more information on its advising page. To answer the first question (“Which degree will give me the highest salary?”), you can use Georgia Degrees Pay

Summary

Computer scientists design and develop computer programs, software, and applications. IT and IS professionals then use, configure, and troubleshoot those programs, software, and applications.

So it really depends on what you want to do. Do you want to be on the front end, designing the software and applications? Do you prefer to use and troubleshoot them? One of the websites gave the analogy of a home: computer scientists build the home, set up home, install the lighting, plumbing, etc., and then the IT/IS professionals come and live in the home to use it, test it, and troubleshoot it.

So which degree is “best”?

Perhaps you can now see how this question is not fair or at least not clear. If we ask which degree is more difficult, the students will immediately exclaim, “Computer Science is the most challenging!” Therefore, one can perhaps argue that the Computer Science degree is the most rigorous (challenging) and will likely provide the student with more opportunities in their career. And the salary statistics support this argument, as CS students, on average, have a higher salary than their IT and IS colleagues.

That said, is Computer Science better? Yes, and no. It depends on you! It depends on your goals. It depends on how hard you want to work. For some, “better” means more money and more career opportunities. For others, “better” means easier studies and less math! So again, which degree is “best”? There is no short answer. As mentioned above, all three degrees provide the tools you need to hopefully have a great career. Perhaps the question is best worded as, “Which Degree is Best for me?” And of course, only you can answer this question!

Course Assistants

What Is an Undergraduate Course Assistant?

In this course, an Undergraduate Course Assistant (UCA) is generally present in addition to your instructor. A UCA is a student, generally in the School of Cyber and Computer Sciences, who successfully passed CSCI 1301 and that is hired by the School to assist other students.

Their duties generally include:

• Helping the students during the labs,
  • To set-up their computers,
  • To find the right resources,
  • To understand their IDE’s error messages,
  • To investigate bugs with them,
  • etc.
• Helping the students outside of the lab (through email, teams, or office hours), for similar tasks as in lab, but also to get ready for an exam or a quiz,
• Reporting to the instructors any issue, mistake or confusion they noticed,
• Suggesting improvements to the resources shared with the students.

Their duties can not include:

• Understanding for you¹,
• Helping you or even commenting on graded material before it was graded,
• Grading students’ work,
• Helping you with other classes,
• Helping you becoming a self-regulated learner and work on your schedule².

How Do I Become One?

A UCA is hired by the School upon recommendation of instructors, after discussion with our Academic Program Coordinator, and possibly our Director of Undergraduate Studies.

A UCA must:

• Be a student, that is, currently enrolled in courses, or, if during the Summer, being enrolled in courses for the next Fall semester,
• Pass our Human Resources background check,
• Have an interest in tutoring,
• Clearly understand the limits and boundaries to the help they can provide to students.

Additionally, if a student wants to help with this particular class, then the student must have successfully passed CSCI 1301 with a grade of B or higher

A UCA will:

• Be able to work up to 25 hours per week (an average of 10 hours per week is typical, but needs to be discussed with the instructor), paid $12.50 per hour, without other benefits,
• Be adequately trained to use our platforms and edit our resources,
• Be able to work on Campus and discuss their schedule with their referent instructor,
• Develop a stronger bond with the instructors, facilitating possible future reference or research projects.

So, in short: talk to any CSCI 1301 instructor if you feel like becoming a UCA.

I Am a UCA, What Should I Do Now?

Congratulations! You should now read more about your position in the UCA starting guide!

What Is the Difference With a GRA?

Graduate Course Assistants (GRA) hold a bachelor and are generally PhD or Master student. Their duties generally overlap with those of the instructors and those of the UCAs, as they are the first point of contact of UCAs, design projects, organize the schedule of the tutoring center and of the labs.

What Is the Difference With a URA?

Undegraduate Research Assistants (or “URAs”) share many similarities with UCAs:

• They both are students employed by the University,
• They both have a maximum of 25 hours/week,
• Their pay rates are the same,
• They both work under the direction of a Faculty member.

However, their focus is on working on research instead of being focused on teaching. The difference is sometimes tenuous, but URAs positions are generally given in priority to “advanced” students (that is, close to graduation), to use their gained knowledge to push further the limits of human knowledge!

It is not possible to cumulate an URA and an UCA position, but obtaining an UCA position is in general an excellent stepping stone to obtain a URA position, if you wish to do so: by proving that you are reliable, serious, agreeable to work with, you will maximize your chances of having a Faculty member notice you and offer you to work on their research with them.

UCA starting guide

Congratulations on your new position! This page briefly explain what is expected from you as an Undergraduate Course Assistant (UCA).

The Three Rules

There are three important rules for you:

1. This is a job.

   Meaning that you have a contract that you should have read and understood, and that you need to carefully clock in and out to receive the pay you deserve. Briefly reviewing the information listed here, and in particular those slides can help you in making sure that you understand all aspects of your position. Do not forget that you are first and foremost a student, and that your main goal here is to graduate.

2. You are here to help students, not to solve their problems.

   Please, review what you should and should not do on this section. It is difficult to strike the right balance when helping a student, but a good rule of thumb is that you should not do anything yourself, just explain and give hints so that they can solve the problem they are facing. You are here to help students understand how to solve a problem, not to solve it for them.

3. Don’t hesitate to ask.

   That’s it. You are not alone to deal with difficult situations (cheating, rude behavior, student abusing your time, etc.), and it is normal if you are sometimes unsure of the best course of action. The instructors are happy to train you and help you solve problems that may arise.

In general, UCAs should prioritize giving clear and concise explanations and hints, as to avoid confusion while also helping them better understand the problem-solving process. This means that when you encounter a problem that you are not able to solve, it’s important to ask a colleague who is available for help and try to understand their approach. This way, the student can receive assistance more quickly and will be less likely to get confused during the troubleshooting process. By emphasizing the importance of understanding and working through the problem, rather than just providing a solution, tutors can help students develop the skills they need to become more independent problem-solvers.

On top of supporting students and helping the instructor, you are also encouraged to work on the improvement of those resources. Your contribution may range from spell-checking to pointing inconsistencies, from clarifying statements to re-organizing exercises. Thanks to git and pull requests, you do not need to worry (too much) about introducing mistakes or blunders: the changes you suggest will always be reviewed by instructors before being merged in our master document. We discuss below how you can edit our resources.

Editing the Resources

You need three things to start editing our resources:

• A github account & an invitation,
• Some working knowledge of markdown,
• Some working knowledge of github’s interface.

Follow the instructions in our “Contributing Guidelines” for the first step.

For a quick syntax guide in Markdown, the best resource is this website and its 10 minutes tutorial. We list some best practices, and would appreciate if you could follow them.

For github’s interface, please refer to the following guide (where the screenshots where taken for the csci-1301.github.io website, but remains relevant).

GitHub is separated into many “repositories”:

• The princomp.github.io contains most of the resources that will be used (so it will be where you will navigate to the most),
• The uca-resources--YYYY is a private repository where material useful to UCAs but not accessible to students (such as project solution, listings, etc.) will be shared,
• The feedback--YYYY and similarly named repositories contains feedback submitted by students/users.

Under the Code section (next to Issues, Pull Requests, Actions, etc.), you will find various folders containing documents for the website. Typically, if there is some error or mistake in the lecture notes, so that will be where you will navigate to the most. The way the resources are organized is explained here.

For this example, I just clicked on the first chapter, “General Concepts”.

On this page, you can see the edit history of that specific document you clicked on. In the corner above the document and below the edit history, there is a pencil icon that will put you into editing mode for that document.

On this page, you will see the document formatted as markdown with two sections at the top of the document: Edit file and Preview. If you have Edit file selected, then you will see the “code” version of the document whereas if you click on the Preview button, you will see the document in its “final” form, or how the website users should see it, without the “code”. To edit, make sure you have Edit file selected.

Once you have made the edits you wanted, you need to “commit” them; just like how you may write a paper, you need to submit it to the professor for them to see it. At the bottom of the page, there is a header box and a description box for you to describe what you did so others will know the changes you did (you do not need to go into every detail; just describe it generally, like “I fixed grammatical issues” or “Fixed code error”). As a UCA, you do not have write access to the princomp.github.io repository, so submitting a change will write it to a new branch in your fork <your name>/princomp.github.io, so you can send a pull request. Given the new protocol by Github, after making the neccessary edits, click the “Propose Changes” button located at the bottom. On this page and the next, there will be a “Create pull request” button, by clicking on this you will start a pull request. After you have successfully created a new branch for your commit and started a pull request, your edits will be checked by others so as to catch any mistake(s) you may have introduced before your pull request is merged into the base branch.

Note that if you are making edits inside the repository for UCAs, uca-resources-<semester>-YYYY, you do have write access so there will instead be two buttons: Commit directly to main branch and Create a new branch for this commit and start a pull request

• Commit directly to main branch submits your edits directly into the document.

• Create a new branch for this commit and start a pull request creates a “pull request” (which can be found in the Pull Requests tab at the top of the page) which essentially notifies others “you edited this document and you want them to check it”. Others can check the changes you make, improve them, change them, and can submit them for you.

You can Create a new branch for this commit and start a pull request so others can double check your edits: it can act as a safety net, so your colleagues will be able to catch any mistake(s) you may have introduced!

Computer Requirements

In Short

Anything less than 5 years old running Microsoft Windows, macOs or a Linux operating system is probably fine. Second hand and custom built are fine, but you will in all likelihood needs a portable computer (as opposed to a desktop computer) to present your work and work on projects.

In Terms of Hardware

Desktop, Laptop, or something else?

A laptop is generally recommended (to take notes in class, make presentations, work on projects at School, …) but technically possessing only a desktop should be ok (and will be more comfortable to use, in all likeliness). Tablets and other “small” handled devices (such as Netbooks, Chromebooks or Mini PCs) are not recommended and will in all likelihood prove challenging to use for some classes.

Specifications

GPU and other special equipment are not required, but recent USB-C connectors will be useful.

As An Example

Dr. Aubert uses a Dell Latitude 5480/5488 from 2017 (but in no way endorses it) with

• 4 cores @ 2.40 GHz CPU,
• 8GB of ram,
• 238 GB of hard drive,

and of courses wishes that it was a bit more responsive at times, but can conduct otherwise all his professional activities.

In Terms of Operating System

We will briefly consider four “families” of operating systems:

• Microsoft Windows (Windows 10, Windows 11, etc.)
• macOS (macOS Ventura, macOS Sonoma, etc.)
• Linux operating systems (Ubuntu, Debian, Gentoo, etc.)
• Operating systems that uses their web browsers as their principal user interface (essentially, ChromeOS).

Note we do not discuss Android or iOS since they are primarily mobile operating systems, and not easily suited for the development workload in our curriculum.

In Short

Anything but ChromeOS is (probably) fine.

Expanded

• If you are (planning on) using Visual Studio as your IDE, then windows is your best choice of operating system.
• If you need to use macOS for whatever reason, then you will probably be able to accommodate all the requirements, but it may require some tweaking at times.
• Using Linux-based operating systems are a great way to learn how to tinker with your computer (you have full control!), but will sometimes require you to be creative to meet courses expectations.
• Virtual machines allow you to simulate (almost) any operating system using (almost) any operating system, and is required for some courses. Using virtual machines means, essentially, that your choice of operating system does not matter at all.
• Remember that multi-boots (that is, installing multiple operating systems side-by-side) is an option.

Virtual Machines

Virtual machines allow you to simulate (almost) any operating system using (almost) any operating system: this means that, for instance, you can load the Windows 11 operating system from your computer running Debian 12.5, or the Debian 12.5 operating system from macOS 14.

Note that CSCI 4532 - Hardware and Embedded Systems and CSCI 4531 - Malware Analysis and Reverse Engineering require you to run virtual machines. If you are planning on taking one of those classes, make sure your computer can run virtual machines!

You can find on this page some indications on how to run a virtual machine on your computer, and you can check on-line the recommended specifications for Hyper-V, VirtualBox, kvm, vmware. Note that, as a student, you can obtain a free licence for Windows.

Where to Buy?

That is really up to you, but remember that, as a student (or employee), you are allowed to

• Some discounts,
• A free licence for Windows.

Second-hand computers or even custom-built computers are probably fine, but requires more skills (such as how to factory-reset a computer and / or how to (re)install an operating system) and inspections on your end.

Is There Anything Else I Should Know?

• A well taken-care of computer can easily last 5 years, but laptops are harder to upgrade and preserve in good shape than desktops.
• Ergonomics is important: you will most likely spend many hours on your computer, so make sure your workstation is well organized.
• A programmer is first and foremost a typist: make sure you develop good habits and learn to type correctly. Exploring ergonomics keyboard layouts and ergonomics mice can save you later from carpal tunnel syndrome, arthritis, and other repetitive strain injuries.

Installing Software

Generalities on Installing Software

You probably already installed software in your life, be it VLC, Microsoft Teams, or Whatsapp. However, depending on whether you installed it on a phone, a tablet, a computer, and depending on the operating systems (Android, Windows 10, iOS, Ubuntu, etc.) your experience may have varied drastically.

Between the Play store, the command-line interface, homebrew and the act of downloading software using your browser and then installing it using the navigator, there can be a lot of differences, but in all those circumstances you should keep security in mind. In addition to making sure that you are downloading the software from a trusted source, you should also be vigilant about the information the software will be able to access about e.g., your private life.

As data can be lost or corrupted upon downloading, many platforms now use checksums to verify the integrity of the software you downloaded before installing it. This is an excellent practice that can also be performed “by hand”, as explained for instance for the database manager MySQL: the main idea is that the probability of the signature matching a tampered-with file is extremely low, and that as long as you are downloading the signature and the software from two different sources, you are considerably reducing the attack surface.

Executing Code Found on-line

As you progress in this class, you will be asked more and more to download and execute code hosted in our repository. How can you tell that you can trust this code?

We have not implemented checksum-matching (yet!), but you can trust this code as it was coded by your instructors, and hosted on a platform using two-factor authentication where every action is tracked using versioning. Concretely, this means that only somebody who manages to steal your instructor’s credentials and their phone, and thwart all the other instructors’ vigilance, would be able to host malicious code on our platform: while we certainly imagine that this is theoretically possible, we hope that you will agree that the probability is low enough for you to trust the code on this site.

As often, security is not absolute, but aims at providing reasonable confidence. Executing “blindly” code found on-line, on the other hand, gives you a good chance of facing unpleasant surprises: while there certainly is a lot of useful, good code on websites like stackoverflowyour instructor probably uses such websites, by the way!, copying-and-pasting it without understanding its purpose or general structure is almost guaranteed to, at best, not execute properly, at worst, make your system unstable or insecure.

Accessing an IDE

An IDE, for “Integrated development environment”, is the software or service you will be using to write, compile, execute and debug your code. There are many available IDEs, and some can accommodate multiple different programming languages.

For C#, there are many different possibilities: some are cross-platforms (meaning you can use them on macOS, Windows or Linux), some are provided free of charge, some have not been updated in a long time. Three natural choices are Visual Studio, MonoDevelop and Rider. While the last two are accessible on every operating systems, Visual Studio is available only for Windows, and in a slightly different version for macOS.

To access one or the other, you will need either

• a computer with the right to install software on it,
• to access one of the computers in the computer lab, or
• a computer with internet access.

The third solution is a backup plan, as instead you will access a very minimal version of an IDE to test small snippets of code. You should not rely on it for the duration of this course.

Installing an IDE On Your Own Computer

This part gathers some references for you to install Visual Studio, MonoDevelop and Rider on your own computer, regardless of your operating system. It is strongly encouraged that you do so, especially if you want to continue in a CS/IT/Cyber degree, but is not mandatory³.

The instructions are detailed, but there are plenty of ways this can go wrong: make sure you have read and followed those instructions carefully before asking for help!

Installing Visual Studio On Your Own Computer

Note that we are not installing “Visual Studio Code”, but simply “Visual Studio”.

For Windows

1. Visit Azure Dev Tools for Teaching.

2. Log in using your Augusta University credentials.

3. Select “Download software”.

4. Look for Visual Studio. The path is Education → Software → Visual Studio Enterprise 2019/2022. You can search “Services” for the “Education” group and then click “Software” if the education group is not immediately displayed. It should look like the following:

   

   Normally, the following direct link should get you to the right page: https://portal.azure.com/?Microsoft_Azure_Education_correlationId=8ee63052-dc32-46f7-a109-e26793622dbf#view/Microsoft_Azure_Education/EducationMenuBlade/~/software. Type “Visual Studio Enterprise” in the search bar and you should find what you are looking for:

   

5. Download and install Visual Studio (leave all the options on their default settings).

   Before clicking install, make sure to check “.NET Desktop Development”

   If you are installing Visual Studio 2019, click the dropdown for .NET Desktop Development and check “.NET SDK (out of support)”. You do not have to do this for Visual Studio 2022

   

6. Enter the product key you obtained previously, following the instructions in the documentation. Normally, clicking on “View key” on the screen pictured in the fourth step above should give you access to a key, that you simply need to copy-and-paste in the menu you can access on Visual Studio by clicking on “Select File” → “Account Settings” → “License with a Product Key”.

For Mac

Download a version of Visual Studio at https://visualstudio.microsoft.com/vs/mac/. It differs a bit from the Windows version, but that should not impact your experience in this class. The only Visual Studio feature we rely on is the ability to create “Console Apps with C#”, which is equally available in both the Windows and Mac versions.

Installing MonoDevelop On Your Own Computer

Unfortunately, MonoDevelop offers pre-packaged release only for linux distributions

• If you are using linux (e.g. Ubuntu, Debian, etc.), then please head out to MonoDevelop’s download page.
• If you are using MacOS, you can have a look at the compilation instructions, but it is very likely that you will find them impossible to understand.
• If you are using Windows, you can have a look at the compilation instructions, but it is very likely that you will find them impossible to understand.

Installing Rider On Your Own Computer

You can download Rider from their website, for any operating system. Note that, as a student, you can obtain a licence for free: simply fill out this form, making sure you use your @augusta.edu email account, and you should receive a free licence instantaneously!

Note that Jetbrains offers to use a SHA-256 checksum (for instance, for the linux version) for you to check that your download has not been tampered with. In any case, you can consult their detailed instructions to install and execute Rider on any operating system.

Installing a Code Editor On Your Own Computer

IDE in general performs the operation of setting up the compiler for you, but if you are willing to try to do it yourself, you can then access a larger offering of editors. Indeed, an alternative to installing an IDE is to install a C# compiler on one hand, and a code editor on the other hand (which is just a text editor with some completion or visualization related to the programming language you are using).

Among other code editors suited for C# code, we can mention:

• RosalynPad,
• Geany,
• LinqPad.

We give below some indications on how to set-up Geany.

Installing Geany On Your Own Computer

Note:

This method will only allow you edit and compile individual .cs files, and will not compile C# Solution Projects. To set-up Geany so that you can compile projects, could start by reading this exchange (which is about projects in Linux, but applies equally well to projects in C#) or this one.

You can download Geany from their website, for any operating system. To use Geany as a text editor for C#, we must download the Mono C# compiler from their website. Make sure to download the most recent version to assure your compiler has the most up-to-date version of “.NET”.

Once you installed Mono, locate the “csc.bat”, “csc.exe” or “csc” file in Mono’s “bin” folder and copy the file path. This path can be of the form

C:\Program Files (x86)\Mono\bin\csc.bat

on windows, or

/usr/bin/csc

on Unix systems.

Now open a .cs file using Geany. Click the arrow next to the “Build” Button and click “Set Build Commands” from the dropdown menu.

In the “Set Build Commands” window, erase the entry next to the “Compile” button and paste the file path to the “csc.bat” in quotation marks. After the file path, create a single space followed by “%f” with the quotaion marks. All in all, you should have something of the form

"C:\Program Files (x86)\Mono\bin\csc.bat" "%f"

in the “Command” field of the “Compile” line.

Confirm the change by clicking OK and now you will be able to compile, build, and execute standalone .cs files.

Installing Anything Anywhere

If the IDE you would like to adopt is not available for your operating system, you can use a Virtual Machine manager to execute a linux-based distribution or a Windows image on top of your operating system.

For this, and regardless of your current operating system, you will need a Virtual Machine manager.

1. There are many (free) options to chose from, let us mention
   1. Virtual Box (for Windows, Linux and Mac),
   2. QEMU (for Windows, Linux and Mac),
   3. Hyper-V (for Windows),
2. Download a version of “Microsoft Operating Systems” from Azure Dev Tools for Teaching, or a linux-based distribution (typically, ubuntu has a good reputation of being accessible and user-friendly).
3. Install and execute your version of Windows or Linux from your virtual machine, and follow the corresponding instructions to install the IDE you are interested in.

Note that it is illegal to execute macOS in a virtual environment that is not hosted on a mac computer, which drastically reduces the interest for you to consider this option.

Accessing One of the Computers in a Computer Lab

Please refer to this page from AU’s Information Technology to know where the computer labs are located. Visual Studio should be pre-installed on every computer.

Compiling Code On-Line

As a backup or only to test snippets of code, you can compile C# code online. Multiple online platforms exist, such as:

• https://www.browxy.com/
• https://www.tutorialspoint.com/compile_csharp_online.php
• https://www.onlinegdb.com/online_csharp_compiler
• https://www.jdoodle.com/compile-c-sharp-online/
• https://dotnetfiddle.net/
• https://www.w3schools.com/CS/trycs.php?filename=demo_helloworld

Note that none of them are endorsed by the school and that they can pose security and privacy challenges: never enter any sensitive information and do not rely on them too heavily. However, they can be a good support if you would like to test a short snippet of code but do not have access at the moment to a computer with an IDE installed.

(Un)Zipping Archives

This short note explains how to

• Unzip files,
• Zip folders,
• Locate your project

for the three main operating systems (Windows, Linux and macOS).

Unzipping Files

Windows

Navigate your file explorer and navigate to your Downloads folder (or wherever you downloaded the file). From there, look for the file you downloaded, right-click, and select “Extract All…”. When the “Extract Compressed (Zipped) Folder” window opens, click the “Extract” button.

Linux

This guide is assuming you have Zip/Unzip installed on your Linux distribution. If this is not the case, first follow this install guide.

Using the graphical interface

Normally, a simple right click and choose “Extract” or “Open with Ark” should do it.

Using the Command-Line

Navigate to your command-line interface and execute the following command (as a normal user, as indicated by $):

$ unzip [FileName].zip

where “[FileName].zip” is the name of the zip file.

macOS

Simply double-click on the zip file to unzip it onto your desktop.

Zipping Files

Windows

Navigate to your file explorer and go to where your solution is stored on your system, the default file path being:

C:\Users\[UserName]\source\repos

where “[UserName]” is your Windows username (on school computers, this should be your AU username). Right click the folder you want to zip, go down the list to the “Send to” option, and then click on the “Compressed (Zipped) Folder” option. This should then create a new zip file.

Linux

Using the graphical interface

Normally, a simple right click and choose “Compress” should do it.

Using the Command-Line

Navigate to your command-line interface and execute the following command (as a normal user, as indicated by $):

$ zip -r [ZipFileName].zip [FileName]

where “[ZipFileName].zip” is the name you want for the zip file, and “[FileName]” for the folder you want to zip.

macOS

Navigate to your file explorer and go to where your solution is stored on your system, the default file path being:

[UserName]\source\repos

where “[UserName]” is your Mac username. Right-click on the folder that you want to zip up and click on the “Compress the Folder” option.

But Where Is My Project?

By default, it should be stored in a folder located in

C:\Users\[UserName]\source\repos

for Windows users,

[UserName]\source\repos

for macOS users,

/home/[UserName]/Projects

for Linux users.

When in doubt, open your project in the IDE, right-click on the solution, and look for an option called “Open in File Explorer” or “Open Containing Folder”:

Keyboard Shortcuts

Foreword

This document contains useful keyboard shortcuts for different operating systems and IDEs. We use the following symbols:

The sections labeled with the star symbol (“*”) work generally everywhere, beyond your IDE.

More advanced shortcuts may be available to your particular IDE:

• For Visual Studio for Windows, refer to the documentation,
• For Visual Studio for MacOS, refer to the documentation
• For Rider, refer to the documentation,
• For MonoDevelop, you can refer to this cheatsheet or directly access the key binding panel.

Useful Shortcuts

Build solution

Exit any program*

Redo*

Run/execute program

Save*

Save All*

Undo*

Comment Code Selection

Uncomment Code Selection

Datatypes in C

Value Types

Numeric

Signed Integer

Unsigned Integer

Floating-point Numbers

Logical

Character

Literals

Compatibility

This table is to be read as

✓ means that those values or variables from the datatypes in the row and column can be “operated together” (meaning, you can for instance multiply them), ✘ means that those values or variables from the datatypes in the row and column cannot be “operated together” (meaning, you cannot for instance multiply them).

Result Type of Operations

This table is to be read as

Values or variables from the datatypes in the row and column can be “operated together” and will produce the datatype indicated in the cell, or cannot be “operated together” if the value in the cell is “illegal”.

References

• https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/types-and-variables
• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/integral-types-table
• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/floating-point-types-table
• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/value-types-table
• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/implicit-numeric-conversions-table
• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/explicit-numeric-conversions-table

Computers and Programming

Principles of Computer Programming

• Computer hardware changes frequently - from room-filling machines with punch cards and tapes to modern laptops and tablets - and will continue doing so.
• With these changes, the capabilities of computers increase rapidly (storage, speed, graphics, etc.)
• Computer programming languages also change
  • Better programming language theory leads to new programming techniques
  • Improved programming language implementations
  • New languages are created, old ones updated
• There are hundreds of programming languages, why?
  • Different tools for different jobs
    • Some languages are better suited for certain jobs
    • For example, Python is best for scripting, Javascript is best for web pages, MySQL is best for databases, etc.
  • Personal preference and popularity
• This class is about “principles” of computer programming
  • Common principles behind all languages will not change, even though hardware and languages do
  • How to organize and structure data
  • How to express logical conditions and relations
  • How to solve problems with programs

Programming Language Concepts

We begin by discussing three categories of languages manipulated by computers. We will be studying and writing programs in high-level languages, but understanding their differences and relationships to other languages⁴ is of importance to become familiar with them.

• Machine language
  • Computers are made of electronic circuits
    • Circuits are components connected by wires
    • Some wires carry data - e.g. numbers
    • Some carry control signals - e.g. do an add or a subtract operation
  • Instructions are settings on these control signals
    • A setting is represented as a 0 or 1
    • A machine language instruction is a group of settings - For example: 1000100111011000
  • Most CPUs use one of two languages: x86 or ARM
• Assembly language
  • Easier way for humans to write machine-language instructions
  • Instead of 1s and 0s, it uses letters and “words” to represent an instruction.
    • Example x86 instruction:

    MOV BX, AX

    which makes a copy of data stored in a component called AX and places it in one called BX
  • Assembler: Translates assembly language instructions to machine language instructions
    • For example: MOV BX, AX translates into 1000100111011000
    • One assembly instruction = one machine-language instruction
    • x86 assembly produces x86 machine code
  • Computers can only execute the machine code
• High-level language
  • Hundreds including C#, C++, Java, Python, etc.
  • Most programs are written in a high-level language since:
    • More human-readable than assembly language
    • High-level concepts such as processing a collection of items are easier to write and understand
    • Takes less code since each statement might be translated into several assembly instructions
  • Compiler: Translates high-level language to machine code
    • Finds “spelling” errors but not problem-solving errors
    • Incorporates code libraries – commonly used pieces of code previously written such as Math.Sqrt(9)
    • Optimizes high-level instructions – your code may look very different after it has been optimized
    • Compiler is specific to both the source language and the target computer
  • Compile high-level instructions into machine code then execute since computers can only execute machine code

A more subtle difference exists between high-level languages. Some (like C) are compiled (as we discussed above), some (like Python) are interpreted, and some (like C#) are in an in-between called managed.

• Compiled vs. Interpreted languages
  • Not all high-level languages use a compiler - some use an interpreter
  • Interpreter: Lets a computer “execute” high-level code by translating one statement at a time to machine code
  • Advantage: Less waiting time before you can execute the program (no separate “compile” step)
  • Disadvantage: Program executes slower since you wait for the high-level statements to be translated then the program is executed
• Managed high-level languages (like C#)
  • Combine features of compiled and interpreted languages
  • Compiler translates high-level statements to intermediate language instructions, not machine code
    • Intermediate language: Looks like assembly language, but not specific to any CPU
  • run-time executes by interpreting the intermediate language instructions - translates one at a time to machine code
    • Faster since translation is partially done already (by compiler), only a simple “last step” is done when executing the program
  • Advantages of managed languages:
    • In a “non-managed” language, a compiled program only works on one OS + CPU combination (platform) because it is machine code
    • Managed-language programs can be reused on a different platform without recompiling - intermediate language is not machine code and not CPU-specific
    • Still need to write an intermediate language interpreter for each platform (so it produces the right machine code), but, for a non-managed language, you must write a compiler for each platform
    • Writing a compiler is more complicated and more work than writing an interpreter thus an interpreter is a quicker (and cheaper) way to put your language on different platforms
    • Intermediate-language interpreter is much faster than a high-level language interpreter, so programs execute faster than an “interpreted language” like Python
  • This still executes slower than a non-managed language (due to the interpreter), so performance-minded programmers use non-managed compiled languages (e.g. for video games)

Software Concepts

• Flow of execution in a program
  • Program receives input from some source, e.g. keyboard, mouse, data in files
  • Program uses input to make decisions
  • Program produces output for the outside world to see, e.g. by displaying images on screen, writing text to console, or saving data in files
• Program interfaces
  • GUI or Graphical User Interface: Input is from clicking mouse in visual elements on screen (buttons, menus, etc.), output is by drawing onto the screen
  • CLI or Command Line Interface: Input is from text typed into “command prompt” or “terminal window,” output is text printed at same terminal window
  • This class will use CLI because it is simple, portable, easy to work with – no need to learn how to draw images, just read and write text

Programming Concepts

Programming workflow

The workflow of the programmer will differ a bit depending on if the program is written in a compiled or an intprepreted programming language. From the distance, both looks like what is pictured in the the flowchart demonstrating roles and tasks of a programmer, beta tester and user in the creation of programs, but some differences remain:

• Compiled language workflow
  • Writing down specifications
  • Creating the source code
  • Running the compiler
  • Reading the compiler’s output, warning and error messages
  • Fixing compile errors, if necessary
  • Executing and testing the program
  • Debugging the program, if necessary
• Interpreted language workflow
  • Writing down specifications
  • Creating the source code
  • Executing the program in the interpreter
  • Reading the interpreter’s output, determining if there is a syntax (language) error or the program finished executing
  • Editing the program to fix syntax errors
  • Testing the program (once it can execute with no errors)
  • Debugging the program, if necessary

Interpreted languages have

• Advantages: Fewer steps between writing and executing, can be a faster cycle
• Disadvantages: All errors happen when you execute the program, no distinction between syntax errors (compile errors) and logic errors (bugs in executing program)

(Integrated) Development Environment

Programmers can either use a collection of tools to write, compile, debug and execute a program, or use an “all-in-one” solution called an Integrated Development Environment (IDE).

• The “Unix philosophy” states that a program should do only one task, and do it properly. For programmers, this means that
  • One program will be needed to edit the source code, a text editor (it can be Geany, notepad, kwrite, emacs, sublime text, vi, etc.),
  • One program will be needed to compile the source code, a compiler (for C#, it will be either mono or Roslyn,
  • Other programs may be needed to debug, execute, or organize larger projects, such as makefile or MKBundle.

IDE “bundle” all of those functionality into a single interface, to ease the workflow of the programmer. This means sometimes that programmers have fewer control over their tools, but that it is easier to get started.

• Integrated Development Environment (IDE)
  • Combines a text editor, compiler, file browser, debugger, and other tools
  • Helps you organize a programming project
  • Helps you write, compile, and test code in one place

In particular, Visual Studio is an IDE, and it uses its own vocabulary:

• Solution: An entire software project, including source code, metadata, input data files, etc.
• “Build solution”: Compile all of your code
• “Start without debugging”: Execute the compiled code
• Solution location: The folder (on your computer’s file system) that contains the solution, meaning all your code and the information needed to compile and execute it

C# Fundamentals

Introduction to the C# Language

• C# is a managed language (as discussed previously)
  • Write in a high-level language, compile to intermediate language, run intermediate language in interpreter
  • Intermediate language is called CIL (Common Intermediate Language)
  • Interpreter is called .NET run-time
  • Standard library is called .NET Framework, comes with the compiler and run-time
• It is widespread and popular
  • It is “programming language of the year 2023” in the very well-respected TIOBE Index.
  • It was the first in the list of “3 Future Programming Languages You Should Learn Between 2022 and 2030”, because of the growing popularity of Unity.
  • 7th most “desired / admired” language on StackOverflow
  • .NET is the first most used “other” library/framework
  • More insights on its evolution can be found in this blog post.

The Object-Oriented Paradigm

• C# is called an “object-oriented” language
  • Programming languages have different paradigms: philosophies for organizing code, expressing ideas
  • Object-oriented is one such paradigm, C# uses it
  • Meaning of object-oriented: Program mostly consists of objects, which are reusable modules of code
  • Each object contains some data (attributes) and some functions related to that data (methods)
• Object-oriented terms
  • Class: A blueprint or template for an object. Code that defines what kind of data the object will contain and what operations (functions) you will be able to do with that data
  • Object: A single instance of a class, containing running code with specific values for the data. Each object is a separate “copy” based on the template given by the class.
    Analogy: A class is like a floorplan while an object is the house build from the floorplan. Plus, you can make as many houses as you would like from a single floorplan.
  • Attribute: A piece of data stored in an object.
    Example: A House class has a spot for a color property while an house object has a color (e.g. “Green”).
  • Method: A function that modifies an object. This code is part of the class, but when it is executed, it modifies only a specific object and not the class.
    Example: A House class with a method to change the house color. Using this method changes the color a single house object but does not change the House class or the color on any other house objects.
• Examples:
  • A Car Class
    • Attributes: Color, engine status (on/off), gear position
    • Methods: Press gas or brake pedal, turn key on/off, shift transmission
  • A Car Object
    Example: A Porsche911 object that is Red, Engine On, and in 1st gear
  • An “Audio File” Class represents a song being played in a music player
    • Attributes: Sound wave data, current playback position, target speaker device
    • Methods: Play, pause, stop, fast-forward, rewind
  • An Audio File Object
    Example: A NeverGonnaGiveYouUp object that is “rolled wave data”, 0:00, speaker01

First Program

It is customary to start the study of a programming language with a “Hello World” program, that simply displays “Hello World”. It is a simple way of seeing a first, simple example of the basic structure of a program. Here’s a simple “hello world” program in the C# language:

Hello World

/* I'm a multi-line comment,
 * I can span over multiple lines!
 */
using System;

class Program
{
  static void Main()
  {
    Console.WriteLine("Hello, world!"); // I'm an in-line comment.
  }
}

Features of this program:

• A multi-line comment: everything between the /* and */ is considered a comment, i.e. text for humans to read. It will be ignored by the C# compiler and has no effect on the program.

• A using statement: This imports code definitions from the System namespace, which is part of the .NET Framework (the standard library).

  • In C#, code is organized into namespaces, which group related classes together
  • If you want to use code from a different namespace, you need a using statement to “import” that namespace
  • All the standard library code is in different namespaces from the code you will be writing, so you’ll need using statements to access it

• A class declaration⁵

  • Syntax:

   class [name of class]
   {
         [body of the class]
   }

  • All code between opening { and closing } is the body of the class named by the class [name of class] statement

• A method declaration

  • A collection of instructions with a name
  • Can be used by typing its name
  • A method is similar to a paragraph, in that it can contain multiple statements, and a class is similar to a chapter, in that it can have multiple methods within its body.
  • A C# program requires a method called Main, and, in our example, is followed by empty parentheses (we will get to those later, but they are required)
  • Just like the class declaration, the body of the method beings with { and ends with }

• A statement inside the body of the method:

  Console.WriteLine("Hello, world!"); // I'm an in-line comment.

  • This is the part of the program that actually “does something”: It displays a line of text to the console:

    

  • This statement contains a class name (Console), followed by a method name (WriteLine). It calls the WriteLine method in the Console class.

  • The argument to the WriteLine method is the text “Hello, world!”, which is in parentheses after the name of the method. This is the text that gets printed in the console: The WriteLine method (which is in the standard library) takes an argument and prints it to the console.

  • Note that the argument to WriteLine is inside double-quotes. This means it is a string, i.e. textual data, not a piece of C# code. The quotes are required in order to distinguish between text and code.

  • A statement must end in a semicolon (the class header and method header are not statements)

• An in-line comment: All the text from the // to the end of the line is considered a comment, and is ignored by the C# compiler.

Rules of C# Syntax

• Each statement must end in a semicolon (;), except for some statements that we will study in the future that contains opening { and closing }, that do not end in a ;.
  • Note that class and method declarations, as well as comments, are not statements and hence do not need to ends with a ;. Typically, a method contains some statements, but it is not a statement.
• All words are case-sensitive
  • A class named Program is not the same as one named program
  • A method named writeline is not the same as one named WriteLine
• Braces and parentheses must always be matched
  • Once you start a class or method definition with {, you must end it with }
• Blank space has almost no meaning
  • Blank spaces refer to spaces (sometimes denoted “ ”, “␣” or “⌴”), tabs (which consists in 4 spaces), and new lines (sometimes denoted “↵”, “↩︎”, “←” or “⏎”)
  • There must be at least 1 space between words
  • Other than that, spaces and new lines are just to help humans read the code
  • Spaces are counted exactly if they are inside string data, e.g. "Hello world!" is different from "Hello world!"
  • Otherwise, entire program could be written on one line⁶; it would have the same meaning
• All C# applications must have a Main method
  • Name must match exactly, otherwise .NET run-time will get confused
  • This is the first code to execute when the application starts – any other code (in methods) will only execute when its method is called

Conventions of C# Programs

• Conventions: Not enforced by the compiler/language, but expected by humans
  • Program will still work if you break them, but other programmers will be confused
• Indentation
  • After a class or method declaration (header), put the opening { on a new line underneath it
  • Then indent the next line by 4 spaces, and all other lines “inside” the class or method body
  • De-indent by 4 spaces at end of method body, so ending } aligns vertically with opening {
  • Method definition inside class definition: Indent body of method by another 4 spaces
  • In general, any code between { and } should be indented by 4 spaces relative to the { and }
• Code files
  • C# code is stored in files that end with the extension “.cs”
  • Each “.cs” file contains exactly one class
  • The name of the file is the same as the name of the class (Program.cs contains class Program)

Note that some of those conventions are actually rules in different programming languages (typically, the last two regarding code files are mandatory rules in java).

Reserved Words and Identifiers

• Reserved words: Keywords in the C# language
  • Note they have a distinct color in the code sample and in your IDE
  • Built-in commands/features of the language
  • Can only be used for one specific purpose; meaning cannot be changed
  • Examples:
    • using
    • class
    • public
    • private
    • namespace
    • this
    • if
    • else
    • for
    • while
    • do
    • return
  • There is no need to memorize the whole list of keywords, as we will only introduce the ones we need on a “per need” basis.
• Identifiers: Human-chosen names
  • Names for classes (Rectangle, ClassRoom, etc.), variables (age, name, etc.), methods (ComputeArea, GetLength, etc), namespaces, etc.
  • Some have already been chosen for the standard library (e.g. system, Console, WriteLine, Main), but they are still identifiers, not keywords
  • Rules for identifiers:
    • Must not be a reserved word
    • Must contain only letters (lower case, from a to z, or upper case, from A to Z), numbers (made of digits from 0 to 9), and underscore (_). But they cannot contain spaces.
    • Must not begin with a number
    • Are case sensitive
    • Must be unique (you cannot re-use the same identifier twice in the same scope – a concept we will discuss later)
  • Conventions for identifiers
    • Should be descriptive, e.g. “AudioFile” or “userInput” not “a” or “x”
    • Should be easy for humans to read and type
    • If name is multiple words, use CamelCase (or its variation Pascal case) to distinguish words, e.g. myHeightInMeters or distanceFromEarthToMoon.
    • Class and method names should start with capitals, e.g. “class AudioFile”
    • Variable names should start with lowercase letters, then capitalize subsequent words, e.g. “myFavoriteNumber”

Write and WriteLine

• The WriteLine method

  • We saw this in the “Hello World” program: Console.WriteLine("Hello World!"); results in “Hello World!” being displayed in the terminal

  • In general, Console.WriteLine("text"); will display the text but not the “’s in the terminal, then start a new line

  • This means a second Console.WriteLine will display its text on the next line of the terminal. For example, this program:

    using System;
    
    class Welcome
    {
      static void Main()
      {
        Console.WriteLine("Hello");
        Console.WriteLine("World!");
      }
    }

    will display the following output in the terminal:

    Hello
    World!

• Methods with multiple statements

  • Note that our two-line example has a Main method with multiple statements
  • In C#, each statement must end in a semicolon
  • Class and method declarations are not statements
  • Each line of code in your .cs file is not necessarily a statement
  • A single invocation/call of the WriteLine method is a statement

• The Write method

  • Console.WriteLine("text") prints the text, then starts a new line in the terminal – it effectively “hits enter” after printing the text

  • Console.Write("text") just prints the text, without starting a new line. It’s like typing the text without hitting “enter” afterwards.

  • Even though two Console.Write calls are two statements, and appear on two lines, they will result in the text being printed on just one line. For example, this program:

    using System;
    
    class Welcome
    {
      static void Main()
      {
        Console.Write("Hello");
        Console.Write("World!");
      }
    }

    will display the following output in the terminal:

    HelloWorld!

  • Note that there is no space between “Hello” and “World!” because we did not type one in the argument to Console.Write

• Combining Write and WriteLine

  • We can use both WriteLine and Write in the same program

  • After a call to Write, the “cursor” is on the same line after the printed text; after a call to WriteLine the “cursor” is at the beginning of the next line

  • This program:

    using System;
    
    class Welcome
    {
      static void Main()
      {
        Console.Write("Hello ");
        Console.WriteLine("World!");
        Console.Write("Welcome to ");
        Console.WriteLine("CSCI 1301!");
      }
    }

    will display the following output in the terminal:

    Hello world!
    Welcome to CSCI 1301!

Escape Sequences

• Explicitly writing a new line

  • So far we’ve used WriteLine when we want to create a new line in the output

  • The escape sequence \n can also be used to create a new line – it represents the “newline character,” which is what gets printed when you type “enter”

  • This program will produce the same output as our two-line “Hello World” example, with each word on its own line:

    using System;
    
    class Welcome
    {
      static void Main()
      {
        Console.Write("Hello\nWorld!\n");
      }
    }

• Escape sequences in detail

  • An escape sequence uses “normal” letters to represent “special”, hard-to-type characters

  • \n represents the newline character, i.e. the result of pressing “enter”

  • \t represents the tab character, which is a single extra-wide space (you usually get it by pressing the “tab” key)

  • \" represents a double-quote character that will get printed on the screen, rather than ending the text string in the C# code.

    • Without this, you couldn’t write a sentence with quotation marks in a Console.WriteLine, because the C# compiler would assume the quotation marks meant the string was ending

    • This program will not compile because in quotes is not valid C# code, and the compiler thinks it is not part of the string:

      //  Incorrect Code
      class Welcome
      {
          static void Main()
          {
              Console.WriteLine("This is "in quotes"");
              // This is parsed as if the string was "This is "
              // followed by in quotes, which is not valid C#,
              // followed by the empty string "".
          }
      }

    • This program will display the sentence including the quotation marks:

      using System;
      
      class Welcome
      {
        static void Main()
        {
          Console.WriteLine("This is \"in quotes\"");
        }
      }

  • Note that all escape sequences begin with a backslash character (\), called the “escape character”

  • General format is \[key letter] – the letter after the backslash is like a “keyword” indicating which special character to display. You can refer to the full list on microsoft documentation.

  • If you want to put an actual backslash in your string, you need the escape sequence \\, which prints a single backslash

    • This will result in a compile error because \U is not a valid escape sequence:

      Console.WriteLine("Go to C:\Users\Edward");

    • This will display the path correctly:

      Console.WriteLine("Go to C:\\Users\\Edward");

Datatypes and Variables

Datatype Basics

• Recall the basic structure of a program
  • Program receives input from some source, uses input to make decisions, produces output for the outside world to see
  • In other words, the program reads some data, manipulates data, and writes out new data
  • In C#, data is stored in objects during the program’s execution, and manipulated using the methods of those objects
• This data has types
  • Numbers (the number 2) are different from text (the word “two”)
  • Text data is called “strings” because each letter is a character and a word is a string of characters
  • Within “numeric data,” there are different types of numbers
    • Natural numbers (ℕ): 0, 1, 2, …
    • Integers (ℤ): … -2, -1, 0, 1, 2, …
    • Real numbers (ℝ): 0.5, 1.333333…, -1.4, etc.
• Basic Datatypes in C#
  • C# uses keywords to name the types of data
  • Text data:
    • string: a string of characters, like "Hello world!"
    • char: a single character, like 'e' or 't'
  • Numeric data:
    • int: An integer, as defined previously
    • uint: An unsigned integer, in other words, a natural number (positive integers only)
    • float: A “floating-point” number, which is a real number with a fractional part, such as 3.85
    • double: A floating-point number with “double precision” – also a real number, but capable of storing more significant figures
    • decimal: An “exact decimal” number – also a real number, but has fewer rounding errors than float and double (we will explore the difference later) ⁷

Literals and Variables

Literals and their types

• A literal is a data value written in the code
• A form of “input” provided by the programmer rather than the user; its value is fixed throughout the program’s execution
• Literal data must have a type, indicated by syntax:
  • string literal: text in double quotes, like "hello"
  • char literal: a character in single quotes, like 'a'
  • int literal: a number without a decimal point, with or without a minus sign (e.g. 52)
  • long literal: just like an int literal but with the suffix l or L, e.g. 4L
  • double literal: a number with a decimal point, with or without a minus sign (e.g. -4.5)
  • float literal: just like a double literal but with the suffix f or F (for “float”), e.g. 4.5f
  • decimal literal: just like a double literal but with the suffix m or M(for “deciMal”), e.g. 6.01m

Variables overview

• Variables store data that can vary (change) during the program’s execution

• They have a type, just like literals, and also a name

• You can use literals to write data that gets stored in variables

• Sample program with variables:

  using System;
  
  class MyFirstVariables
  {
    static void Main()
    {
      // Declaration
      int myAge;
      string myName;
      // Assignment
      myAge = 29;
      myName = "Edward";
      // Displaying
      Console.WriteLine(
        $"My name is {myName} and I am {myAge} years old."
      );
    }
  }

  This program shows three major operations you can do with variables.

  • First it declares two variables, an int-type variable named “myAge” and a string-type variable named “myName”
  • Then, it assigns values to each of those variables, using literals of the same type. myAge is assigned the value 29, using the int literal 29, and myName is assigned the value “Edward”, using the string literal "Edward"
  • Finally, it displays the current value of each variable by using the Console.WriteLine method and string interpolation, in which the values of variables are inserted into a string by writing their names with some special syntax (a $ character at the beginning of the string, and braces around the variable names)

Variable Operations

Declaration

• This is when you specify the name of a variable and its type
• The syntax is the type keyword, a space, the name of the variable, then a semi-colon.
• Examples: int myAge;, string myName;, double winChance;.
• A variable name is an identifier, so it should follow the rules and conventions
  • Can only contain letters and numbers
  • Must be unique among all variable, method, and class names
  • Should use CamelCase if it contains multiple words
• Note that the variable’s type is not part of its name: two variables cannot have the same name even if they are different types
• Multiple variables can be declared in the same statement: string myFirstName, myLastName; would declare two strings called respectively myFirstName and myLastName

Assignment

• The act of changing the value of a variable
• Uses the symbol =, which is the assignment operator, not a statement of equality – it does not mean “equals”
• Direction of assignment is right to left: the variable goes on the left side of the = symbol, and its new value goes on the right
• Syntax: variable_name = value;
• Example: myAge = 29;
• Value must match the type of the variable. If myAge was declared as an int-type variable, you cannot write myAge = "29"; because "29" is a string

Initialization (Declaration + Assignment)

• Initialization statement combines declaration and assignment in one single statement (it is just a shortcut, a.k.a. some “syntactical sugar”, and not something new)
• Creates a new variable and also gives it an initial value
• The syntax is the datatype of the variable, the name of the variable, the = sign, the value we want to store, and a semi-colon
• Example: string myName = "Edward";
• Can only be used once per variable, since you can only declare a variable once

Assignment Details

• Assignment replaces the “old” value of the variable with a “new” one; it is how variables vary

  • If you initialize a variable with int myAge = 29; and then write myAge = 30;, the variable myAge now stores the value 30

• You can assign a variable to another variable: just write a variable name on both sides of the = operator

  • This will take a “snapshot” of the current value of the variable on the right side, and store it into the variable on the left side

  • For example, in this code:

    int a = 12;
    int b = a;
    a = -5;

    the variable b gets the value 12, because that’s the value that a had when the statement int b = a was executed. Even though a was then changed to -5 afterward, b is still 12.

Displaying

• Only text (strings) can be displayed in the console
• When we want to print a mixture of text and variables with Console.WriteLine, we need to convert all of them to a string
• String interpolation: a mechanism for converting a variable’s value to a string and inserting it into the main string
  • Syntax: $"text {variable} text" – begin with a $ symbol, then put variable’s name inside brackets within the string
  • Example: $"I am {myAge} years old"
  • When this line of code is executed, it reads the variable’s current value, converts it to a string (29 becomes "29"), and inserts it into the surrounding string
  • Displayed: I am 29 years old
• If the argument to Console.WriteLine is the name of a variable, it will automatically convert that variable to a string before displaying it
• For example, Console.WriteLine(myAge); will display “29” in the console, as if we had written Console.WriteLine($"{myAge}");
• When string interpolation converts a variable to a string, it must call a “string conversion” method supplied with the data type (int, double, etc.). All built-in C# datatypes come with string conversion methods, but when you write your own data types (classes), you’ll need to write your own string conversions – string interpolation will not magically “know” how to convert MyClass variables to strings

On a final note, observe that you can write statements mixing multiple declarations and assignments, as in int myAge = 10, yourAge, ageDifference; that declares three variables of type int and set the value of the first one. It is generally recommended to separate those instructions in different statements as you begin, to ease debugging and have a better understanding of the “atomic steps” your program should perform.

Format Specifiers

• Formats for displaying numbers

  • There are lots of possible ways to display a number, especially a fraction (how many decimal places to use?)

  • String interpolation has a default way to format numbers, but it might not always be the best

  • For example, consider this program:

    decimal price = 19.99m;
    decimal discount = 0.25m;
    decimal salePrice = price – discount * price;
    Console.WriteLine($"{price} with a discount of " +
        $"{discount} is {salePrice}");

    It will display this output:

    19.99 with a discount of 0.25 is 14.9925

    But this isn’t the best way to display prices and discounts. Obviously, the prices should have dollar signs, but also, it does not make sense to show a price with fractional cents (14.9925) – it should be rounded to two decimal places. You might also prefer to display the discount as 25% instead of 0.25, since people usually think of discounts as percentages.

• Improving interpolation with format specifiers

  • You can change how numbers are displayed by adding a format specifier to a variable’s name in string interpolation

  • Format specifier: A special letter indicating how a numeric value should be converted to a string

  • General format is {[variable]:[format specifier]}, e.g. {numVar:N}

  • Common format specifiers:

    Format specifier	Description
    N or n	Adds a thousands separator, displays 2 decimal places (by default)
    E or e	Uses scientific notation, displays 6 decimal places (by default)
    C or c	Formats as currency: Adds a currency symbol, adds thousands separator, displays 2 decimal places (by default)
    P or p	Formats as percentage with 2 decimal places (by default)

  • Example usage with our “discount” program:

    decimal price = 19.99m;
    decimal discount = 0.25m;
    decimal salePrice = price – discount * price;
    Console.WriteLine($"{price:C} with a discount of " +
        $"{discount:P} is {salePrice:C}");

    will display

    $19.99 with a discount of 25.00% is $14.99

• Format specifiers with custom rounding
  • Each format specifier uses a default number of decimal places, but you can change this with a precision specifier
  • Precision specifier: A number added after a format specifier indicating how many digits past the decimal point to display
  • Format is {[variable]:[format specifier][precision specifier]}, e.g. {numVar:N3}. Note there is no space or other symbol between the format specifier and the precision specifier, and the number can be more than one digit ({numVar:N12} is valid)
  • Examples:

    • Given the declarations

      double bigNumber = 1537963.666;
      decimal discount = 0.1337m;

      Statement	Display
      Console.WriteLine($"{bigNumber:N}");	1,537,963.67
      Console.WriteLine($"{bigNumber:N3}");	1,537,963.666
      Console.WriteLine($"{bigNumber:N1}");	1,537,963.7
      Console.WriteLine($"{discount:P1}");	13.4%
      Console.WriteLine($"{discount:P4}");	13.3700%
      Console.WriteLine($"{bigNumber:E}");	1.537964E+006
      Console.WriteLine($"{bigNumber:E2}");	1.54E+006

Variables in Memory

• A variable names a memory location
• Data is stored in memory (RAM), so a variable “stores data” by storing it in memory
• Declaring a variable reserves a memory location (address) and gives it a name
• Assigning to a variable stores data to the memory location (address) named by that variable

Sizes of Numeric Datatypes

• Numeric datatypes have different sizes
• Amount of memory used/reserved by each variable depends on the variable’s type
• Amount of memory needed for an integer data type depends on the size of the number
  • int uses 4 bytes of memory, can store numbers in the range [−2³¹, 2³¹ − 1]
  • long uses 8 bytes of memory can store numbers in the range [−2⁶³, 2⁶³ − 1]
  • short uses 2 bytes of memory, can store numbers in the range [−2¹⁵, 2¹⁵ − 1]
  • sbyte uses only 1 bytes of memory, can store numbers in the range [−128, 127]
• Unsigned versions of the integer types use the same amount of memory, but can store larger positive numbers
  • byte uses 1 byte of memory, can store numbers in the range [0, 255]
  • ushort uses 2 bytes of memory, can store numbers in the range [0, 2¹⁶ − 1]
  • uint uses 4 bytes of memory, can store numbers in the range [0, 2³² − 1]
  • ulong uses 8 bytes of memory, can store numbers in the range [0, 2⁶⁴ − 1]
  • This is because in a signed integer, one bit (digit) of the binary number is needed to represent the sign (+ or -). This means the actual number stored must be 1 bit smaller than the size of the memory (e.g. 31 bits out of the 32 bits in 4 bytes). In an unsigned integer, there is no “sign bit”, so all the bits can be used for the number.
• Amount of memory needed for a floating-point data type depends on the precision (significant figures) of the number
  • float uses 4 bytes of memory, can store positive or negative numbers in a range of approximately [10⁻⁴⁵, 10³⁸], with 7 significant figures of precision
  • double uses 8 bytes of memory, and has both a wider range (10⁻³²⁴ to 10³⁰⁸) and more significant figures (15 or 16)
  • decimal uses 16 bytes of memory, and has 28 or 29 significant figures of precision, but it actually has the smallest range (10⁻²⁸ to 10²⁸) because it stores decimal fractions exactly
• Difference between binary fractions and decimal fractions
  • float and double store their data as binary (base 2) fractions, where each digit represents a power of 2
    • The binary number 101.01 represents 4 + 1 + 1/4, or 5.25 in base 10
  • More specifically, they use binary scientific notation: A mantissa (a binary integer), followed by an exponent assumed to be a power of 2, which is applied to the mantissa
    • 10101e-10 means a mantissa of 10101 (i.e. 21 in base 10) with an exponent of -10 (i.e. 2⁻² in base 10), which also produces the value 101.01 or 5.25 in base 10
  • Binary fractions cannot represent all base-10 fractions, because they can only represent fractions that are negative powers of 2. 1/10 is not a negative power of 2 and cannot be represented as a sum of 1/16, 1/32, 1/64, etc.
  • This means some base-10 fractions will get “rounded” to the nearest finite binary fraction, and this will cause errors when they are used in arithmetic
  • On the other hand, decimal stores data as a base-10 fraction, using base-10 scientific notation
  • This is slower for the computer to calculate with (since computers work only in binary) but has no “rounding errors” with fractions that include 0.1
  • Use decimal when working with money (since money uses a lot of 0.1 and 0.01 fractions), double when working with non-money fractions

Summary of numeric data types and sizes:

Value and Reference types

• Value and reference types are different ways of storing data in memory

• Variables name memory locations, but the data that gets stored at the named location is different for each type

• For a value type variable, the named memory location stores the exact data value held by the variable (just what you’d expect)

• Value types: all the numeric types (int, float, double, decimal, etc.), char, and bool

• For a reference type variable, the named memory location stores a reference to the data, not the data itself

  • The contents of the memory location named by the variable are the address of another memory location
  • The other memory location is where the variable’s data is stored
  • To get to the data, the computer first reads the location named by the variable, then uses that information (the memory address) to find and read the other memory location where the data is stored

• Reference types: string, object, and all objects you create from your own classes

• Assignment works differently for reference types

  • Assignment always copies the value in the variable’s named memory location - but in the case of a reference type that’s just a memory address, not the data

  • Assigning one reference-type variable to another copies the memory address, so now both variables “refer to” the same data

  • Example:

    string word = "Hello";
    string word2 = word;

    Both word and word2 contain the same memory address, pointing to the same memory location, which contains the string “Hello”. There is only one copy of the string “Hello”; word2 does not get its own copy.

Operators

Arithmetic Operators

Variables can be used to do math. All the usual arithmetic operations are available in C#:

Note: the “remainder” or “modulo” operator represents the remainder after doing integer division between its two operands.
For example, 44 % 7 = 2 because 44/7 = 6 when rounded down, then do 7*6 to get 42 and 44 - 42 = 2.

Arithmetic and variables

• The result of an arithmetic expression (like those shown in the table) is a numeric value

  • For example, the C# expression 3 * 4 has the value 12, which is int data

• A numeric value can be assigned to a variable of the same type, just like a literal: int myVar = 3 * 4; initializes the variable myVar to contain the value 12

• A numeric-type variable can be used in an arithmetic expression

• When a variable is used in an arithmetic expression, its current value is read, and the math is done on that value

• Example:

  int a = 4;
  int b = a + 5;
  a = b * 2;

  • To execute the second line of the code, the computer will first evaluate the expression on the right side of the = sign. It reads the value of the variable a, which is 4, and then computes the result of 4 + 5, which is 9. Then, it assigns this value to the variable b (remember assignment goes right to left).
  • To execute the third line of code, the computer first evaluates the expression on the right side of the = sign, which means reading the value of b to use in the arithmetic operation. b contains 9, so the expression is 9 * 2, which evaluates to 18. Then it assigns the value 18 to the variable a, which now contains 18 instead of 4.

• A variable can appear on both sides of the = sign, like this:

  int myVar = 4;
  myVar = myVar * 2;

  This looks like a paradox because myVar is assigned to itself, but it has a clear meaning because assignment is evaluated right to left. When executing the second line of code, the computer evaluates the right side of the = before doing the assignment. So it first reads the current (“old”) value of myVar, which is 4, and computes 4 * 2 to get the value 8. Then, it assigns the new value to myVar, overwriting its old value.

Compound assignment operators

• The pattern of “compute an expression with a variable, then assign the result to that variable” is common, so there are shortcuts for doing it
• The compound assignment operators change the value of a variable by adding, subtracting, etc. from its current value, equivalent to an assignment statement that has the value on both sides:

Increment and Decrement Operators

Increment and decrement basics

• In C#, we have already seen multiple ways to add 1 to a numeric variable:

int myVar = 1;
myVar = myVar + 1;
myVar += 1

These two lines of code have the same effect; the += operator is “shorthand” for “add and assign”

• The increment operator, ++, is an even shorter way to add 1 to a variable. It can be used in two ways:

myVar++;
++myVar;

• Writing ++ after the name of the variable is called a postfix increment, while writing ++ before the name of the variable is called a prefix increment. They both have the same effect on the variable: its value increases by 1.

• Similarly, there are multiple ways to subtract 1 from a numeric variable:

int myVar = 10;
myVar = myVar - 1;
myVar -= 1;

• The decrement operator, --, is a shortcut for subtracting 1 from a variable, and is used just like the increment operator:

myVar--;
--myVar;

• To summarize, the increment and decrement operators both have a prefix and postfix version:

Difference between prefix and postfix

• The prefix and postfix versions of the increment and decrement operators both have the same effect on the variable: Its value increases or decreases by 1

• The difference between prefix and postfix is whether the “old” or “new” value of the variable is returned by the expression

• With postfix increment/decrement, the operator returns the value of the variable, then increases/decreases it by 1

• This means the value of the increment/decrement expression is the old value of the variable, before it was incremented/decremented

• Consider this example:

int a = 1;
Console.WriteLine(a++);
Console.WriteLine(a--);

• The expression a++ returns the current value of a, which is 1, to be used in Console.WriteLine. Then it increments a by 1, giving it a new value of 2. Thus, the first Console.WriteLine displays “1” on the screen.

• The expression a-- returns the current value of a, which is 2, to be used in Console.WriteLine, and then decrements a by 1. Thus, the second Console.WriteLine displays “2” on the screen.

• With prefix increment/decrement, the operator increases/decreases the value of the variable by 1, then returns its value

• This means the value of the increment/decrement expression is the new value of the variable, after the increment/decrement

• Consider the same code, but with prefix instead of postfix operators:

int a = 1;
Console.WriteLine(++a);
Console.WriteLine(--a);

• The expression ++a increments a by 1, then returns the value of a for use in Console.WriteLine. Thus, the first Console.WriteLine displays “2” on the screen.

• The expression --a decrements a by 1, then returns the value of a for use in Console.WriteLine. Thus, the second Console.WriteLine displays “1” on the screen.

Using increment/decrement in expressions

• The ++ and -- operators have higher precedence than the other math operators, so if you use them in an expression they will get executed first

• The “result” of the operator, i.e. the value that will be used in the rest of the math expression, depends on whether it is the prefix or postfix increment/decrement operator: The prefix operator returns the variable’s new value, while the postfix operator returns the variable’s old value

• Consider these examples:

int a = 1;
int b = a++;
int c = ++a * 2 + 4;
int d = a-- + 1;

• The variable b gets the value 1, because a++ returns the “old” value of a (1) and then increments a to 2

• In the expression ++a * 2 + 4, the operator ++a executes first, and it returns the new value of a, which is 3. Then the multiplication executes (3 * 2, which is 6), then the addition (6 + 4, which is 10). Thus c gets the value 10.

• In thee expression a-- + 1, the operator a-- executes first, and it returns the old value of a, which is 3 (even though a is now 2). Then the addition executes, so d gets the value 4.

Arithmetic on Mixed Data Types

• The math operators (+, -, *, /) are defined separately for each data type: There is an int version of + that adds ints, a float version of + that adds floats, etc.
• Each operator expects to get two values of the same type on each side, and produces a result of that same type. For example, 2.25 + 3.25 uses the double version of +, which adds the two double values to produce a double-type result, 5.5.
• Most operators have the same effect regardless of their type, except for /
• The int/short/long version of / does integer division, which returns only the quotient and drops the remainder: In the statement int result = 21 / 5;, the variable result gets the value 4, because 21 ÷ 5 is 4 with a remainder of 1. If you want the fractional part, you need to use the floating-point version (for float, double, and decimal): double fracDiv = 21.0 / 5.0; will initialize fracDiv to 4.2.

Implicit conversions in math

• If the two operands/arguments to a math operator are not the same type, they must become the same type – one must be converted
• C# will first try implicit conversion to “promote” a less-precise or smaller value to a more precise, larger type
• Example: with the expression double fracDiv = 21 / 2.4;
  • Operand types are int and double
  • int is smaller/less-precise than double
  • 21 gets implicitly converted to 21.0, a double value
  • Now the operands are both double type, so the double version of the / operator gets executed
  • The result is 8.75, a double value, which gets assigned to the variable fracDiv
• Implicit conversion also happens in assignment statements, which happen after the math expression is computed
• Example: with the expression double fraction = 21 / 5;
  • Operand types are int and int
  • Since they match, the int version of / gets executed
  • The result is 4, an int value
  • Now this value is assigned to the variable fraction, which is double type
  • The int value is implicitly converted to the double value 4.0, and fraction is assigned the value 4.0

Explicit conversions in math

• If the operands are int type, the int version of / will get called, even if you assign the result to a double

• You can “force” floating-point division by explicitly converting one operand to double or float

• Example:

  int numCookies = 21;
  int numPeople = 6;
  double share = (double) numCookies / numPeople;

  Without the cast, share would get the value 3.0 because numCookies and numPeople are both int type (just like the fraction example above). With the cast, numCookies is converted to the value 21.0 (a double), which means the operands are no longer the same type. This will cause numPeople to be implicitly converted to double in order to make them match, and the double version of / will get called to evaluate 21.0 / 6.0. The result is 3.5, so share gets assigned 3.5.

• You might also need a cast to ensure the operands are the same type, if implicit conversion does not work

• Example:

  decimal price = 3.89;
  double shares = 47.75;
  decimal total = price * (decimal) shares;

  In this code, double cannot be implicitly converted to decimal, and decimal cannot be implicitly converted to double, so the multiplication price * shares would produce a compile error. We need an explicit cast to decimal to make both operands the same type (decimal).

Order of Operations

• Math operations in C# follow PEMDAS from math class: Parentheses, Exponents, Multiplication, Division, Addition, Subtraction
  • Multiplication/division are evaluated together, as are addition/subtraction
  • Expressions are evaluated left-to-right
  • Example: int x = 4 = 10 * 3 - 21 / 2 - (3 + 3);
    • Parentheses: (3 + 3) is evaluated, returns 6
    • Multiplication/Division: 10 * 3 is evaluated to produce 30, then 21 / 2 is evaluated to produce 10 (left-to-right)
    • Addition/Subtraction: 4 + 30 - 10 - 6 is evaluated, result is 18
• Cast operator is higher priority than all binary operators
  • Example: double share = (double) numCookies / numPeople;
    • Cast operator is evaluated first, converts numCookies to a double
    • Division is evaluated next, but operand types do not match
    • numPeople is implicitly converted to double to make operand types match
    • Then division is evaluated, result is 21.0 / 6.0 = 3.5
• Parentheses always increase priority, even with casts

  • An expression in parentheses gets evaluated before the cast “next to” it

  • Example:

    int a = 5, b = 4;
    double result = (double) (a / b);

    The expression in parentheses gets evaluated first, then the result has the (double) cast applied to it. That means a / b is evaluated to produce 1, since a and b are both int type, and then that result is cast to a double, producing 1.0.

Conversions

We now discuss implicit and explicit conversions between datatypes: how C# can (or not!) convert a value from one datatype to another, and how we can “force” this conversion if C# does not do it automatically.

Assignments from different types

• The “proper” way to initialize a variable is to assign it a literal of the same type:

int myAge = 29;
double myHeight = 1.77;
float radius = 2.3f;

Note that 1.77 is a double literal, while 2.3f is a float literal

• If the literal is not the same type as the variable, you will sometimes get an error – for example, float radius = 2.3 will result in a compile error – but sometimes, it appears to work fine: for example float radius = 2; compiles and executes without error even though 2 is an int value.

• In fact, the value being assigned to the variable must be the same type as the variable, but some types can be implicitly converted to others

Implicit conversions

• Implicit conversion allows variables to be assigned from literals of the “wrong” type: the literal value is first implicitly converted to the right type

• In the statement float radius = 2;, the int value 2 is implicitly converted to an equivalent float value, 2.0f. Then the computer assigns 2.0f to the radius variable.

• Implicit conversion also allows variables to be assigned from other variables that have a different type:

int length = 2;
float radius = length;

When the computer executes the second line of this code, it reads the variable length to get an int value 2. It then implicitly converts that value to 2.0f, and then assigns 2.0f to the float-type variable radius.

• Implicit conversion only works between some data types: a value will only be implicitly converted if it is “safe” to do so without losing data

• Summary of possible implicit conversions:

• In general, a data type can only be implicitly converted to one with a larger range of possible values

• Since an int can store any integer between −2³¹ and 2³¹ − 1, but a float can store any integer between −3.4 × 10³⁸ and 3.4 × 10³⁸ (as well as fractional values), it is always safe to store an int value in a float

• You cannot implicitly convert a float to an int because an int stores fewer values than a float – it cannot store fractions – so converting a float to an int will lose data

• Note that all integer data types can be implicitly converted to float or double

• Each integer data type can be implicitly converted to a larger integer type: short → int → long

• Unsigned integer data types can be implicitly converted to a larger signed integer type, but not the same signed integer type: uint → long, but not uint → int

• This is because of the “sign bit”: a uint can store larger values than an int because it does not use a sign bit, so converting a large uint to an int might lose data

Explicit conversions

• Any conversion that is “unsafe” because it might lose data will not happen automatically: you get a compile error if you assign a double variable to a float variable

• If you want to do an unsafe conversion anyway, you must perform an explicit conversion with the cast operator

• Cast operator syntax: ([type name]) [variable or value] – the cast is “right-associative”, so it applies to the variable to the right of the type name

• Example: (float) 2.8 or (int) radius

• Explicit conversions are often used when you (the programmer) know the conversion is actually “safe” – data will not actually be lost

• For example, in this code, we know that 2.886 is within the range of a float, so it is safe to convert it to a float:

float radius = (float) 2.886;

The variable radius will be assigned the value 2.886f.

• For example, in this code, we know that 2.0 is safe to convert to an int because it has no fractional part:

double length = 2.0;
int height = (int) length;

The variable height will be assigned the value 2.

• Explicit conversions only work if there exists code to perform the conversion, usually in the standard library. The cast operator isn’t “magic” – it just calls a method that is defined to convert one type of data (e.g. double) to another (e.g. int).

• All the C# numeric types have explicit conversions to each other defined

• string does not have explicit conversions defined, so you cannot write int myAge = (int) "29";

• If the explicit conversion is truly unsafe (will lose data), data is lost in a specific way

• Casting from floating-point (e.g. double) types to integer types: fractional part of number is truncated (ignored/dropped)

• In int length = (int) 2.886;, the value 2.886 is truncated to 2 by the cast to int, so the variable length gets the value 2.

• Casting from more-precise to less-precise floating point type: number is rounded to nearest value that fits in less-precise type:

decimal myDecimal = 123456789.999999918m;
double myDouble = (double) myDecimal;
float myFloat = (float) myDouble;

In this code, myDouble gets the value 123456789.99999993, while myFloat gets the value 123456790.0f, as the original decimal value is rounded to fit types with fewer significant figures of precision.

• Casting from a larger integer to a smaller integer: the most significant bits are truncated – remember that numbers are stored in binary format

• This can cause weird results, since the least-significant bits of a number in binary do not correspond to the least significant digits of the equivalent base-10 number

• Casting from another floating point type to decimal: Either value is stored precisely (no rounding), or program crashes with System.OverflowException if value is larger than decimal’s maximum value:

decimal fromSmall = (decimal) 42.76875;
double bigDouble = 2.65e35;
decimal fromBig = (decimal) bigDouble;

In this code, fromSmall will get the value 42.76875m, but the program will crash when attempting to cast bigDouble to a decimal because 2.65 × 10³⁵ is larger than decimal’s maximum value of 7.9 × 10²⁸

• decimal is more precise than the other two floating-point types (thus does not need to round), but has a smaller range (only 10²⁸, vs. 10³⁰⁸)

Summary of implicit and explicit conversions for the numeric datatypes:

Refer to the “Result Type of Operations” chart from the cheatsheet for more detail.

Inputs and Outputs

Reading Input from the User

• Input and output in CLI
  • Our programs use a command-line interface, where input and output come from text printed in a “terminal” or “console”
  • We’ve already seen that Console.WriteLine prints text from your program on the screen to provide output to the user
  • The equivalent method for reading input is Console.ReadLine(), which waits for the user to type some text in the console and then returns it to your program
  • In general, the Console class represents the command-line interface
• Using Console.ReadLine()

  • Example usage:

    using System;
    
    class PersonalizedWelcomeMessage
    {
      static void Main()
      {
        string firstName;
        Console.WriteLine("Enter your first name:");
        firstName = Console.ReadLine();
        Console.WriteLine($"Welcome, {firstName}!");
      }
    }

    This program first declares a string variable named firstName. On the second line, it uses Console.WriteLine to display a message (instructions for the user). On the third line, it calls the Console.ReadLine() method, and assigns its return value (result) to the firstName variable. This means the program waits for the user to type some text and press “Enter”, and then stores that text in firstName. Finally, the program uses string interpolation in Console.WriteLine to display a message including the contents of the firstName variable.

  • Console.ReadLine is the “inverse” of Console.WriteLine, and the way you use it is also the “inverse”

  • While Console.WriteLine takes an argument, which is the text you want to display on the screen, Console.ReadLine() takes no arguments because it does not need any input from your program – it will always do the same thing

  • Console.WriteLine has no “return value” - it does not give any output back to your program, and the only effect of calling it is that text is displayed on the screen

  • Console.ReadLine() does have a return value, specifically a string. This means you can use the result of this method to assign a string variable, just like you can use the result of an arithmetic expression to assign a numeric variable.

  • The string that Console.ReadLine() returns is one line of text typed in the console. When you call it, the computer will wait for the user to type some text and then press “Enter”, and everything the user typed before pressing “Enter” gets returned from Console.ReadLine()

Parsing user input

• Console.ReadLine() always returns the same type of data, a string, regardless of what the user enters

  • If you ask the user to enter a number, ReadLine will output that number as a string
  • For example, if you ask the user to enter his/her age, and the user enters 21, Console.ReadLine() will return the string "21"

• If we want to do any kind of arithmetic with a number provided by the user, we will need to convert that string to a numeric type like int or double. Remember that casting cannot be used to convert numeric data to or from string data.

• When converting numeric data to string data, we use string interpolation:

  int myAge = 29;
  //This does not work:
  //string strAge = (string) myAge;
  string strAge = $"{myAge}";

• In the other direction, we use a method called Parse to convert strings to numbers:

  string strAge = "29";
  //This does not work:
  //int myAge = (int) strAge;
  int myAge = int.Parse(strAge);

• The int.Parse method takes a string as an argument, and returns an int containing the numeric value written in that string

• Each built-in numeric type has its own Parse method

  • int.Parse("42") returns the value 42
  • long.Parse("42") returns the value 42L
  • double.Parse("3.65") returns the value 3.65
  • float.Parse("3.65") returns the value 3.65f
  • decimal.Parse("3.65") returns the value 3.65m

• The Parse methods are useful for converting user input to useable data. For example, this is how to get the user’s age as an int:

  Console.WriteLine("Enter your age:");
  string ageString = Console.ReadLine();
  int age = int.Parse(ageString);

More detail on the Parse methods

• Console.WriteLine is a method that takes input from your program, in the form of an argument, but does not return any output. Meanwhile, Console.ReadLine is a method that does not have any arguments, but it returns output to your program (the user’s string).

• int.Parse is a method that both takes input (the string argument) and returns output (the converted int value)

• When executing a statement such as

  int answer = int.Parse("42");

  the computer must evaluate the expression on the right side of the = operator before it can do the assignment. This means it calls the int.Parse method with the string "42" as input. The method’s code then executes, converting "42" to an integer, and it returns a result, the int value 42. This value can now be assigned to the variable answer.

• Since the return value of a Parse method is a numeric type, it can be used in arithmetic expressions just like a numeric-type variable or literal. For example, in this statement:

  double result = double.Parse("3.65") * 4;

  To evaluate the expression on the right side of the = operator, the computer must first call the method double.Parse with the input "3.65". Then the method’s return value, 3.65, is used the math operation as if it was written 3.65 * 4. So the computer implicitly converts 4 to a double value, performs the multiplication on doubles, and gets the resulting value 14.6, which it assigns to the variable result.

• Another example of using the result of Parse to do math:

  Console.WriteLine("Please enter the year.");
  string userInput = Console.ReadLine();
  int curYear = int.Parse(userInput);
  Console.WriteLine($"Next year it will be {curYear + 1}");

  Note that in order to do arithmetic with the user’s input (i.e. add 1), it must be a numeric type (i.e. int), not a string. This is why we often call a Parse method on the data returned by Console.ReadLine().

• The previous example can be made shorter and simpler by combining the Parse and ReadLine methods in one statement. Specifically, you can write:

  int curYear = int.Parse(Console.ReadLine());

  In this statement, the return value (output) of one method is used as the argument (input) to another method. When the computer executes the statement, it starts by evaluating the int.Parse(...) method call, but it cannot actually execute the Parse method yet because its argument is an expression, not a variable or value. In order to determine what value to send to the Parse method as input, it must first evaluate the Console.ReadLine() method call. Since this method has no arguments, the computer can immediately start executing it; the ReadLine method waits for the user to type a line of text, then returns that text as a string value. This return value can now be used as the argument to int.Parse, and the computer starts executing int.Parse with the user-provided string as input. When the Parse method returns an int value, this value becomes the value of the entire expression int.Parse(Console.ReadLine()), and the computer assigns it to the variable curYear.

• Notice that by placing the call to ReadLine inside the argument to Parse, we have eliminated the variable userInput entirely. The string returned by ReadLine does not need to be stored anywhere (i.e. in a variable); it only needs to exist long enough to be sent to the Parse method as input.

Correct input formatting

• The Parse methods assume that the string they are given as an argument (i.e. the user input) actually contains a valid number. But the user may not follow directions, and invalid input can cause a variety of errors.
• If the string does not contain a number at all – e.g. int badIdea = int.Parse("Hello"); – the program will fail with the error System.FormatException
• If the string contains a number with a decimal point, but the Parse method is for an integer datatype, the program will also fail with System.FormatException. For example, int fromFraction = int.Parse("52.5"); will cause this error. This will happen even if the number in the string ends in “.0” (meaning it has no fractional part), such as int wholeNumber = int.Parse("45.0");.
• If the string has extraneous text before or after the number, such as "$18.95" or 1999!, the program will fail with the error System.FormatException
• If the string contains a number that cannot fit in the desired datatype (due to overflow or underflow), the behavior depends on the datatype:
  • For the integer types (int and long), the program will fail with the error System.OverflowException. For example, int.Parse("3000000000") will cause this error because 3000000000 is larger than 2³¹ − 1 (the maximum value an int can store).
  • For the floating-point types (float and double), no error will be produced. Instead, the result will be the same as if an overflow or underflow had occurred during normal program execution: an overflow will produce the value Infinity, and an underflow will produce the value 0. For example, float tooSmall = float.Parse("1.5e-55"); will assign tooSmall the value 0, while double tooBig = double.Parse("1.8e310"); will assign tooBig the value double.Infinity.
• Acceptable string formats vary slightly between the numeric types, due to the different ranges of values they can contain
  • int.Parse and long.Parse will accept strings in the format ([ws])([sign])[digits]([ws]), where [ws] represents empty spaces and groups in parentheses are optional. This means that a string with leading or trailing spaces will not cause an error, unlike a string with other extraneous text around the number.
  • decimal.Parse will accept strings in the format ([ws])([sign])([digits],)[digits](.[digits])([ws]). Note that you can optionally include commas between groups of digits, and the decimal point is also optional. This means a string like "18,999" is valid for decimal.Parse but not for int.Parse.
  • float.Parse and double.Parse will accept strings in the format ([ws])([sign])([digits],)[digits](.[digits])(e[sign][digits])([ws]). As with decimal, you can include commas between groups of digits. In addition, you can write the string in scientific notation with the letter “e” or “E” followed by an exponent, such as "-9.44e15".

Output with Variables

Converting from numbers to strings

• As we saw in a previous lecture (Datatypes and Variables), the Console.WriteLine method needs a string as its argument

• If the variable you want to display is not a string, you might think you could cast it to a string, but that will not work – there is no explicit conversion from string to numeric types

  • This code:

    double fraction = (double) 47 / 6;
    string text = (string) fraction;

    will produce a compile error

• You can convert numeric data to a string using string interpolation, which we’ve used before in Console.WriteLine statements:

  int x = 47, y = 6;
  double fraction = (double) x / y;
  string text = $"{x} divided by {y} is {fraction}";

  After executing this code, text will contain “47 divided by 6 is 7.8333333”

• String interpolation can convert any expression to a string, not just a single variable. For example, you can write:

  Console.WriteLine($"{x} divided by {y} is {(double) x / y}");
  Console.WriteLine($"{x} plus 7 is {x + 7}");

  This will display the following output:

  47 divided by 6 is 7.8333333
  47 plus 7 is 54

  Note that writing a math expression inside a string interpolation statement does not change the values of any variables. After executing this code, x is still 47, and y is still 6.

The ToString() method

• String interpolation does not “magically know” how to convert numbers to strings – it delegates the task to the numbers themselves

• This works because all data types in C# are objects, even the built-in ones like int and double

  • Since they are objects, they can have methods

• All objects in C# are guaranteed to have a method named ToString(), whose return value (result) is a string

• Meaning of ToString() method: “Convert this object to a string, and return that string”

• This means you can call the ToString() method on any variable to convert it to a string, like this:

  int num = 42;
  double fraction = 33.5;
  string intText = num.ToString();
  string fracText = fraction.ToString();

  After executing this code, intText will contain the string “42”, and fracText will contain the string “33.5”

• String interpolation calls ToString() on each variable or expression within braces, asking it to convert itself to a string

  • In other words, these three statements are all the same:

    Console.WriteLine($"num is {num}");
    Console.WriteLine($"num is {intText}");
    Console.WriteLine($"num is {num.ToString()}");

    Putting num within the braces is the same as calling ToString() on it.

String Concatenation

• Now that we’ve seen ToString(), we can introduce another operator: the concatenation operator
• Concatenation basics

  • Remember, the + operator is defined separately for each data type. The “double + double” operator is different from the “int + int” operator.

  • If the operand types are string (i.e. string + string), the + operator performs concatenation, not addition

  • You can concatenate string literals or string variables:

    string greeting = "Hi there, " + "John";
    string name = "Paul";
    string greeting2 = "Hi there, " + name;

    After executing this code, greeting will contain “Hi there, John” and greeting2 will contain “Hi there, Paul”

• Concatenation with mixed types

  • Just like with the other operators, both operands (both sides of the +) must be the same type

  • If one operand is a string and the other is not a string, the ToString() method will automatically be called to convert it to a string

  • Example: In this code:

    int bananas = 42;
    string text = "Bananas: " + bananas;

    The + operator has a string operand and an int operand, so the int will be converted to a string. This means the computer will call bananas.ToString(), which returns the string “42”. Then the string + string operator is called with the operands “Bananas:” and “42”, which concatenates them into “Bananas: 42”.

Output with concatenation

• We now have two different ways to construct a string for Console.WriteLine: Interpolation and concatenation

• Concatenating a string with a variable will automatically call its ToString() method, just like interpolation will. These two WriteLine calls are equivalent:

  int num = 42;
  Console.WriteLine($"num is {num}");
  Console.WriteLine("num is " + num);

• It’s usually easier to use interpolation, since when you have many variables the + signs start to add up. Compare the length of these two equivalent lines of code:

  Console.WriteLine($"The variables are {a}, {b}, {c}, {d}, and {e}");
  Console.WriteLine("The variables are " + a + ", " + b + ", " + c + ", " + d + ", and " + e);

• Be careful when using concatenation with numeric variables: the meaning of + depends on the types of its two operands

  • If both operands are numbers, the + operator does addition

  • If both operands are strings, the + operator does concatenation

  • If one argument is a string, the other argument will be converted to a string using ToString()

  • Expressions in C# are always evaluated left-to-right, just like arithmetic

  • Therefore, in this code:

    int var1 = 6, var2 = 7;
    Console.WriteLine(var1 + var2 + " is the result");
    Console.WriteLine("The result is " + var1 + var2);

    The first WriteLine will display “13 is the result”, because var1 and var2 are both ints, so the first + operator performs addition on two ints (the resulting number,13, is then converted to a string for the second + operator). However, the second WriteLine will display “The result is 67”, because both + operators perform concatenation: The first one concatenates a string with var1 to produce a string, and then the second one concatenates this string with var2

  • If you want to combine addition and concatenation in the same line of code, use parentheses to make the order and grouping of operations explicit. For example:

    int var1 = 6, var2 = 7;
    Console.WriteLine((var1 + var2) + " is the result");
    Console.WriteLine("The result is " + (var1 + var2));

    In this code, the parentheses ensure that var1 + var2 is always interpreted as addition.

Introduction

Class and Object Basics

• Classes vs. Objects
  • A class is a specification, blueprint, or template for an object; it is the code that describes what data the object stores and what it can do
  • An object is a single instance of a class, created using its “template.” It is executing code, with specific values stored in each variable
  • To instantiate an object is to create a new object from a class
• Object design basics
  • Objects have attributes: data stored in the object. This data is different in each instance, although the type of data is defined in the class.
  • Objects have methods: functions that use or modify the object’s data. The code for these functions is defined in the class, but it is executed on (and modifies) a specific object
• Encapsulation: An important principle in class/object design
  • Attribute data is stored in instance variables, a special kind of variable
  • Called “instance” because each instance, i.e. object, has its own copy of them
  • Encapsulation means instance variables (attributes) are “hidden” inside an object: other code cannot access them directly
    • Only the object’s own methods can access the instance variables
    • Other code must “ask permission” from the object in order to read or write the variables

Writing Our First Class

• Designing the class
  • Our first class will be used to represent rectangles; each instance (object) will represent one rectangle
  • Attributes of a rectangle:
    • Length
    • Width
  • Methods that will use the rectangle’s attributes
    • Get length
    • Get width
    • Set length
    • Set width
    • Compute the rectangle’s area
  • Note that the first four are a specific type of method called “getters” and “setters” because they allow other code to read (get) or write (set) the rectangle’s instance variables while respecting encapsulation

The Rectangle class:

class Rectangle
{
  private int length;
  private int width;

  public void SetLength(int lengthParameter)
  {
    length = lengthParameter;
  }

  public int GetLength()
  {
    return length;
  }

  public void SetWidth(int widthParameter)
  {
    width = widthParameter;
  }

  public int GetWidth()
  {
    return width;
  }

  public int ComputeArea()
  {
    return length * width;
  }
}

Let’s look at each part of this code in order.

• Attributes
  • Each attribute (length and width) is stored in an instance variable
  • Instance variables are declared similarly to “regular” variables, but with one additional feature: the access modifier
  • Syntax: [access modifier] [type] [variable name]
  • The access modifier can have several values, the most common of which are public and private. (There are other access modifiers, such as protected and internal, but in this class we will only be using public and private).
  • An access modifier of private is what enforces encapsulation: when you use this access modifier, it means the instance variable cannot be accessed by any code outside the Rectangle class
  • The C# compiler will give you an error if you write code that attempts to use a private instance variable anywhere other than a method of that variable’s class
• SetLength method, an example of a “setter” method
  • This method will allow code outside the Rectangle class to modify a Rectangle object’s “length” attribute
  • Note that the header of this method has an access modifier, just like the instance variable
  • In this case the access modifier is public because we want to allow other code to call the SetLength method
  • Syntax of a method declaration: [access modifier] [return type] [method name]([parameters])
  • This method has one parameter, named lengthParameter, whose type is int. This means the method must be called with one argument that is int type.
    • Similar to how Console.WriteLine must be called with one argument that is string type – the Console.WriteLine declaration has one parameter that is string type.
    • Note that it is declared just like a variable, with a type and a name
  • A parameter works like a variable: it has a type and a value, and you can use it in expressions and assignment
  • When you call a method with a particular argument, like 15, the parameter is assigned this value, so within the method’s code you can assume the parameter value is “the argument to this method”
  • The body of the SetLength method has one statement, which assigns the instance variable length to the value contained in the parameter lengthParameter. In other words, whatever argument SetLength is called with will get assigned to length
  • This is why it is called a “setter”: SetLength(15) will set length to 15.
• GetLength method, an example of a “getter” method
  • This method will allow code outside the Rectangle class to read the current value of a Rectangle object’s “length” attribute
  • The return type of this method is int, which means that the value it returns to the calling code is an int value
  • Recall that Console.ReadLine() returns a string value to the caller, which is why you can write string userInput = Console.ReadLine(). The GetLength method will do the same thing, only with an int instead of a string
  • This method has no parameters, so you do not provide any arguments when calling it. “Getter” methods never have parameters, since their purpose is to “get” (read) a value, not change anything
  • The body of GetLength has one statement, which uses a new keyword: return. This keyword declares what will be returned by the method, i.e. what particular value will be given to the caller to use in an expression.
  • In a “getter” method, the value we return is the instance variable that corresponds to the attribute named in the method. GetLength returns the length instance variable.
• SetWidth method
  • This is another “setter” method, so it looks very similar to SetLength
  • It takes one parameter (widthParameter) and assigns it to the width instance variable
  • Note that the return type of both setters is void. The return type void means “this method does not return a value.” Console.WriteLine is an example of a void method we’ve used already.
  • Since the return type is void, there is no return statement in this method
• GetWidth method
  • This is the “getter” method for the width attribute
  • It looks very similar to GetLength, except the instance variable in the return statement is width rather than length
• The ComputeArea method
  • This is not a getter or setter: its goal is not to read or write a single instance variable
  • The goal of this method is to compute and return the rectangle’s area
  • Since the area of the rectangle will be an int (it is the product of two ints), we declare the return type of the method to be int
  • This method has no parameters, because it does not need any arguments. Its only “input” is the instance variables, and it will always do the same thing every time you call it.
  • The body of the method has a return statement with an expression, rather than a single variable
  • When you write return [expression], the expression will be evaluated first, then the resulting value will be used by the return command
  • In this case, the expression length * width will be evaluated, which computes the area of the rectangle. Since both length and width are ints, the int version of the * operator executes, and it produces an int result. This resulting int is what the method returns.