More Practice Badges#
Note
these are listed by the date they were posted
More practice exercises are a chance to try new dimensions of the concepts that we cover in class.
Note
Activities will appear here once the semester begins
2023-09-07#
Activities:
Review the notes after I post them.
Fill in the first two columns of your KWL chart (on a branch for this badge).
review git and github vocabulary be sure to edit a file and make an issue or PR (include link in your badge PR)
Post an introduction to your classmates on our discussion forum
2023-09-12#
Activities:
review notes after they are posted, both rendered and the raw markdown versions. Include links to both views in your badge PR comment.
read Chapter 1, “Decoding your confusion while coding” in The Programmer’s Brain add a file called brain.md to your kwl repo that summarizes your thoughts on the chapter and how, if at all, it changes how you think about debugging and learning to program.
map out your computing knowledge and add it to your kwl chart repo in a file called prior-knowledge-map.md. Use mermaid syntax, to draw your map. GitHub can render it for you including while you work using the preview button.
Read more about version control in general and add a “version control” row to your KWL chart with all 3 columns filled in.
2023-09-14#
Activities:
Any steps in a badge marked lab are steps that we are going to focus in on during lab time. Remember the goal of lab is to help you complete the work, not add additional work. The lab checkout will include some other tasks and then we will encourage you to work on this badge while we are there to help. Lab checkouts are checked only for completion though, not correctness, so steps of activities that we want you to really think about and revise if incorrect will be in a practice or review badge.
Read the notes. If you have any questions, post an issue on the course website repo.
Using your terminal, download your KWL repo. Include the command used in your badge PR.
Try using setting up git using your favorite IDE or GitHub Desktop. Make a file gitoffline.md and include some notes of how it went. Was it hard? easy? what did you figure out or get stuck on? Is the terminology consistent or does it use different terms?
lab Explore the difference between git add and git commit: try committing and pushing without adding, then add and push without committing. Describe what happens in each case in a file called gitcommit_tips.md. Compare what happens based on what you can see on GitHub and what you can see with git status. Write a scenario with examples of how a person might make mistakes with git add and commit and what to look for to get unstuck.
2023-09-19#
Activities:
Create a merge conflict in your github in class repo and resolve it using your favorite IDE, then create one and resolve it on GitHub in browser(this requires the merge conflict to occur on a PR). Describe how you created it, show the files, and describe how your IDE helps or does not help in ide_merge_conflict.md. Give advice for when you think someone should resolve a merge conflict in GitHub vs using an IDE. (if you do not regulary use an, IDE, try VSCode)
Learn about GitHub forks and more about git branches(you can also use other resources)
add
branches-forks.mdto your KWL repo and describe how branches work, what a fork is, and how they relate to one another. If you use other resources, include them in your file as markdown links.
2023-09-21#
Activities:
badge steps marked lab are steps that you will be encouraged to use lab time to work on.
Update your KWL chart with any learned items.
Get set up so that you can pull from the introcompsyss/fall2023 repo and push to your own fork of the class website by cloning the main repo, then forking it and adding your fork as an additional remote. Append the commands used and the contents of your
fall2023/.git/configto a terminalpractice.md (hint:historyoutputs recent commands and redirects can work with any command, not only echo). Based on what you know so far about forks and branches, what advantage does this setup provide? (answer in theterminal_practice.md)lab Organize the provided messy folder (details will be provided in lab time). Commit and push the changes. Clone that repo locally.
For extra practice, re/organize a folder on your computer ( good candidate may be desktop or downloads folder), using only a terminal to make new directories, move files, check what’s inside them, etc. Answer reflection questions in a new file, terminal_organization_adv.md in your kwl repo. Tip: Start with a file explorer open, but then try to close it, and use only command line tools to explore and make your choices. If you get stuck, look up additional commands to do acomplish your goals.
Find your team’s repository. It will have a name like
fa23-team#where#is a number 1-4. Join the discussion on that repo about naming your team. Link to your comment directly in your PR for this badge (use the 3 dots menu to get the comment specific URL).
# Terminal File moving reflection
1. How was this activity overall Did this get easier toward the end?
2. How was it different working on your own computer compared to the Codespace from?
3. Did you have to look up how to do anything we had not done in class?
4. When do you think that using the terminal will be better than using your GUI file explorer?
5. What questions/challenges/ reflections do you have after this?
6. Append all of the commands you used in lab below. (not from your local computer's history, from the codespace history)
2023-09-26#
Activities:
Find a resource/reference that helps explain a topic related to the course that you want to review. Make sure that your contribution does not overlap with one that another member is going to post by viewing other issues before you post your issue. Create an issue for your planned item.
Clone your group repo.
Work offline to add your contribution and then open a PR. Your reference review should help a classmate decide if that reference material will help them understand better or not. It should summarize the material and it’s strengths/weaknesses.
Complete a peer review of a class mate’s PR. Use inline comments for any minor corrections, provide a summary, and either approve or request changes.
learn about options for how git can display commit history. Try out a few different options. Choose two, write them both to a file,
gitlog-compare.md. Using a text editor, wrap each log with three backticks to make them “code blocks” and then add text to the file describing a use case where that format in particular would be helpful.
2023-09-28#
Activities:
Review the notes, jupyterbook docs, and experiment with the
jupyter-bookCLI to determine what files are required to makejupyter-book buildrun. Make your kwl repo into a jupyter book. Set it so that the_builddirectory is not under version control.Learn about the documentation ecosystem in another language that you know using at least one official source and additional sources as you find helpful. In
docs.mdinclude a summary of your findings and compare and contrast it to jupyter book/sphinx. Include a bibtex based bibliography of the sources you used. You can use this generator for informal sources and google scholar for formal sources.
2023-10-03#
Activities:
Read about different workflows in git and add responses to the below in a workflows.md in your kwl repo. Two good places to read from are Git Book and the atlassian Docs
Update your kwl chart with what you have learned or new questions in the want to know column
Find the hash of the blob object that contains the content of your gitislike.md file and put that in the comment of your badge PR for this badge.
## Workflow Reflection
1. Why is it important that git can be used with different workflows?
1. Which workflow do you think you would like to work with best and why?
1. Describe a scenario that might make it better for the whole team to use a workflow other than the one you prefer.
2023-10-05#
Activities:
Add to your software.md a section about if that project does or does not adhere to the unix philosophy and why. You can see what badge it was previously assigned in and the instructions on the KWL file list.
create methods.md and answer the following:
- which of the three methods for studying a system do you use most often when debugging?
- which do you use when you are trying to understand something new?
- do you think the ones you use most often are consistently effective? why or why not? When do they work or not work?
- what are you most interested in trying that might be different?
2023-10-12#
Activities:
Read more details about git internals to review what we did in class in greater detail. Make a file gitplumbingdetail.md and create a visualization that is compatible with version control (eg can be viewed in plain text and compared line by line, such as table or mermaid graph) that shows the relationship between at least three porcelain commands and their corresponding plumbing commands.
Create gitislike.md and explain main git operations we have seen (add, commit, push) in your own words in a way that will either help you remember or how you would explain it to someone else at a high level. This might be analogies or explanations using other programming concepts or concepts from a hobby.
Contribute to your group repo and review a classmate’s contribution. Include a link to your contribution and review in your badge PR comment using markdown link syntax. Your contribution can be a short how to with a code excerpt or a resource. (view the raw version of this issue page for the git internals link above for an example)
2023-10-17#
Activities:
Read about the Learn more about the SHA-1 collision attach
Learn more about how git is working on changing from SHA-1 to SHA-256 and answer the transition questions below gittransition.md
find 2 more real world examples of using other number systems (either different bases or different symbols and bases) that are current. Describe them in numbers.md
Calculate the maximum number of git objects that a repo can have without needing to use more than the minimum number of characters to refer to any object and include that number in gitcounts_scenarios.md with a title
# Git counts. Describe 3 scenarios that would get you to that number of objects in terms of what types of objects would exist. For example, what is the maximum number of commits you could have without exceeding that number, how many files could you have? How could you get to that number of objects in the fewest number of commits? What might be a typical way to get there? Assume normal git use with porcelain commands, not atypical cases with plubming commands. If you get stuck, outline what you know and then request a review.
gittransition#
## transition questions
1. Why make the switch?
2. What impact will the switch have on how git works?
3. Which developers will have the most work to do because of the switch?
2023-10-19#
Activities:
Use your github-inclass repo to create a scenario where you can fix a problem using a git command from the patching or debugging section of the docs. Create a log of what you did using the history or git log into a file gitstory.md. If you have a project in another class or another badge in this class that causes you to use one in a real scenario, that can count. If not, for example, you could create a “bug” and then use bisect to find it.
Create tagtypes.md with the template below. Include an experiment that shows which if either type of tag creates a new git object. There are two types, try creating one of each a lightwight tag (provide only the tag name- what we did in class) and an annotated (provide a name and a message with
-m). Determine many of the tags in the course website are annotated vs lightweight using what you learned about how tags are represented andgit cat-fileto see which is which.
# Tags
<!-- short defintion/description in your own words of what a tag is and what it is for -->
## Comparing tag types
<!-- include your experiment terminal history and interpretation -->
## Inspecting tags
Course website tags by type:
- annoted:
- lightweight:
2023-10-24#
Activities:
Update your KWL Chart learned column with what you’ve learned
Write a bash script that you can run in your group repo to generate a file with a list of all of your PRs and PR reviews (you may go in and assign yourself to these PRs to make this easier). Save the script as groupcontributions.sh and its output as group_contributions-YYYY-MM-DD.md in your KWL repo.
2023-10-31#
Activities:
File permissions are represented numerically often in octal, by transforming the permissions for each level (owner, group, all) as binary into a number. Add octal.md to your KWL repo and answer the following. Try to think through it on your own, but you may look up the answers, as long as you link to (or ideally cite using jupyterbook citations) a high quality source.
1. Describe how to transform the permissions [`r--`, `rw-`, `rwx`] to octal, by treating each set as three bits. 1. Transform the permission we changed our script to `rwxr-xr-x` to octal. 1. Which of the following would prevent a file from being edited by other people 777 or 755 and why?
Answer the following in hpc.md of your KWL repo: (to think about how the design of the system we used in class impacts programming and connect it to other ideas taught in CS)
1. What kinds of things would your code need to do if you were going to run it on an HPC system? 1. What sbatch options seem the most helpful? 1. How might you go about setting the time limits for a script? How could you estimate how long a script will take?
2023-11-02#
Activities:
create a new ssh key and configure it to your GitHub account
Install gcc locally and practice using it. Repeat steps we did in class on your computer and then change the order of parameters; try skipping steps to produce errors, etc. Export the list of variations you tried and summarize what you learned as a list of tips and reminders on what the parameters do/why/when you would need them (or not) in gcctips.md. (to reinforce what we learned)
Write two short programs that do the same thing in different ways and compile them both to assembly (eg using a for vs while loop to sum numbers up to a number). Check the assembly to see if they produce the same thing or if it’s different. Save your code (in code blocks) and notes about your findings in assemblycompare.md
2023-11-07#
Activities:
On Seawulf, modfiy main.c from class to accept the integer as a command line argument instead of via input while running the program. See this tutorial for an example.
5. Write a bash script demo_test.sh that runs your compiled program for each integer from 10 to 30 (syntax for a range is {start..end} so this would be {10..30})
6. Write an sbatch script, batchrun.sh to run your script on a compute node and save the output to a file. The sbatch script should compile and link the program and then call the script. see the options
7. use scp to download your modified main, script files, and output to your local computer and include them in your kwl repo.
2023-11-14#
Activities:
Run and examine how rect.hack and max.hack in the
nand2tetris/projects/05/folder work. Make notes and answer the questions below in assemblyexplore.md.
1. What does rect.hack do?
2. What did you learn trying to figure out how it works?
3. Explain how max.hack works in detail.
4. Write code in a high level language that would compile into this program. Try writing multiple different versions.
5. What does this max.hack assume has happened that it doesn't include in its body?
2023-11-16#
Activities:
While we saw many types of gates today, but we actually could get all of the operations needed using only NAND gates. Work out how to use NAND gates to implement a half adder and describe it in nandhalf.md
In addertypes.md compare ripple adders and lookahead adders.
1. Give a synopsis of each adder type 1. Compare them in terms of time (assume that each gate requires one unite of time) 1. Compare them in terms of space/cost by counting the total number of gates required.
Add bitwise.md to your kwl and write the bitwise operations required for the following transformations (replace the
(_)with a bitwise operator (&, |, ^, >>, <<, ~)):4 (_) 128 12493 (_) -12494 127 (_) 15 7 (_) 56 4 (_) -5 45 (_) 37 = 37 45 (_) 37 = 45 3 (_) 5 = 7 6 (_) 8 = 0 10 (_) 5 = 15
2023-11-21#
Activities:
Write a C program to compare values as doubles and as float (single precision/32bit) to see that this comparison issue is related to the IEEE standard and is not language specific. Make notes and comparison around its behavior and include the program in a code cell in cdouble.md
In floatexpt.md design an experiment using the
fractions.Fractionclass in Python that shows helps illustrate why.1*3 == .3evaluates toFalsebut.1*4 ==.4evaluates toTrue. Your file must include both code and interpretation of the results.
2023-11-28#
Activities:
Pick a component that is in the more detailed von Neumann (other than the ALU) and contribute an explanation of what it is to your group repo. Coordinate with your team so that each contribution is a different component by creating an issue stating what you will work on before contributing. Link to your PR in the group repo in your badge PR. All contributions should include a description of the component- what it does and how it is built- and it’s predecessors. All must include sources as markdown links.
review a classmate’s PR providing feedback and either approving or requesting changes
Work with your group mates to ensure both your PR and the one you reviewed get approved and merged.
Read about systems abstractions in CACM and answer reflection questions below in systemsabstractions.md based on the systems abstraction reading:
1. What are your overall thoughts on this article? (include how much is neew vs familar, easy vs hard to understand, etc)
2. How has you undertanding of these changed during this course.
3. Do you think you understand this article more now than you would have at the beginning of the semester
4. Write 3 questions and their answers that could be a quiz to see if someone understood or had misconceptions about the abstractions in this article.
2023-11-30#
Activities:
this is integrative-2
Create
in_five_years.mdand answer the following two questions: What do you think you will remember from this class in five years? What parts of this course’s content do you think will change the most in five years?Reflect on how this course impacts programming/debugging skills in
skillup.md. You can write this as how you think your own skill has improved or as if you are convincing another student to take this class. Touch on at least three topics.Submit a PR with either advice to future students on how to succeed in the course or on why a student should take this course. Each of those is linked to where you should add your advice.
2023-12-05#
Activities:
Update your KWL chart.
Simulate a more computationally intensive program using the
sleepfunction in C and compare the time of a threaded vs single threaded (ie serial, no intentional threading) version of the program. Include your two programs and the bash script to show how you tested it with notes on the performance in threaded.md (to better illustrate the impact of the threads)Learn about the system libraries in two languages (one can be C or Python, one must be something else). Find the name(s) of the library or libraries. In systeminteraction.md summarize what types of support are shared or different? What does that tell you about the language?
Research examples of programs using multi-threading besides splitting up a single calculation for time reasons, include three examples in whymultithread.md.
2023-12-07#
Activities:
Describe a type of project where it would be worth it for you to learn a language you have never used before in newlanguage.md This should be based in what types of features for the language your project would require and/or what would contribute to the long term health of the project.
Learn about one of the following languages that you have not used before: R, Julia, Clojure, Zig, Go, erlang, Elixir or another language you are curious about that appeared in the Developer survey. For example you might be interest in the top paying languages. Use the official documentation. Answer the following questions in languagelearning.md:
1. What is this language designed for? 2. What Programming paradigm(s) does it support? 3. Give at least 1 example of a programming language that experience in would make it easy to learn this language and explain why. 4. Give at least 1 example of a programming language that experience in would make it hard to learn this language and explain why. 5. What is its most unique feature(s)?
Explore badge option#
Actually try out one of the langauges above in a new repo created from this asssignment.
Setup the devcontainer to provide the compiler/interpreter for the language of your choice. See features
Add top extensions related to the language to the devcontainer.
Add gitignore file for that language
Write a hello world type program in the language and make sure it runs.
Use the official documentation to figure out a common task in the language. You may use GitHub Co-pilot to write the code.
Answer the questions in the README of the template repo.