Journal Quotes

Lines from the Journal, read back in class. No names.

Lines from the Journal worth keeping, in the words they were written in. Some get read back in class. Nobody is named, here or there. Each heading is the prompt that was asked.

Monday’s close asked for the three lines of sumTo’s loop that are about i. Today the same three sit in one header: for (int i = 1; i <= n; i++). Which of the three runs once, which runs before every round, and which runs after every round? And the loop in section 8 of last Monday’s page, the one that breaks from the middle: written as a for, one part of its header would be empty, not true, which? (Class 22, 11/11)

int i = 1 runs once i <= n runs before every loop i++ runs after every loop the third section would be omitted because it normally increments a value so the loop doesn’t go forever but if you have a break you don’t need to increment the value

int i = 1 runs first, i <= n runs for every round, and i++ runs after every round. the middle would be empty

Nine wrote the close. Eight had the three parts: once, before every round, after every round. On the second question, one of the six who tried named the middle; the others named the first part, the third, or “after the loop”. The other seven, in the order they came in:

The first i runs once, and the latter two run multiple times. I think the part with int k = 1; or int square = 1; would be written as empty rather than filled in or true.

int i = 1; runs once i <= n; runs before every round since it is the Evaluation we check i++ runs after to increment and continue the loop the int i = 1 would be empty since were running infinitely until we break it. or maybe the evaluation.

int i = 1; runs once. i <= n; runs before every round. i++ runs after every round. The line that is not true is after the loop.

once: i = 1; before every round: i <= n; after every round: i++;

“int i = 1” runs once, “i <= n” runs before every round, and “i++” runs after every round

int 1 runs once I <= n is every round i++ is after each round

Int i = 1 runs once; i <= n runs before everu round ; i++ runs after every round; not sure

Section 4’s program has a for inside a for: r from 1 to 3, c from 1 to 4, and count = count + 1 in the inner body. What does IO.println(count) print, and how did you count it? (Class 22, 11/11)

It prints 12. The first ‘for’ has the nested ‘for’ repeat itself 3 times, and the nested ‘for’ adds 1 to ‘count’ 4 times, which means that 1 is being added to ‘count’ 12 times

I think count prints as 3 because r will be 3 before c is 4.

Share your exam-prep approach: my most effective exam-prep technique is …, I think it works particularly well because …, one exam-prep technique that does not work for me is … (Class 22, 11/11)

My most effective exam-prep technique is basically just testing myself (whether on flash cards or otherwise) on my own to help me remember for the actual exam. I think it works particularly well because I first have to make the questions so I have to look back through the information to help me do that then I have to later access my memory to help me answer those questions plus if it’s easy I didn’t do it right I gotta make harder questions it should challenge me. One exam-prep technique that does not work for me is rereading and rereading info it just doesn’t help it stick in the long run like sure I’ll remember it tomorrow (short term) but I won’t remember it for the next year or so (long term)

To prepare for the progress exam, my most effective technique is to redo past in class work and assignments that I struggled with. Least effective technique was just rereading my work, I feel like I have a much better understanding when I actually redo and rethink through each problem as opposed to just reading it.

My most effective exam-prep technique is … I like to try and redo problems, or go back and do the optional work to make sure i have the concepts in my head properly. One exam-prep technique that does not work for me is … just looking at my code. memorization doesn’t always help, since I’m not working with the concepts

Nine wrote the opener. Four named redoing old problems or testing themselves as the best technique, three named looking over the assignments, one the readings with the assignments understood as they are done, and one not studying at all. Four named rereading as the one that does not work, three named not studying. The other six, in the order they came in:

My most effective exam-prep technique is reviewing the assignments codes and how they work. I think it works particularly well because the questions on the progress exam are typically similar to some on the assignments. One exam-prep technique that does not work for me is forgetting to study… because it does not refresh my memory at all. Also, rereading the book does not help because it is a lot to look over.

my most effect exam prep is playing Minecraft for 6 hours before the exam and not studying. I think this works because I have done this for every other progress exam and got an A on both of them. One exam prep technique that doesn’t work for me is reviewing the classes content it just makes me nervous for the exam and I end up doing worse.

My most effective exam-prep technique is looking over the assignments. I think it works particularly well because of how well I remember to do things by doing things over and over and struggling until it works out. Looking over the assignments reminds me of the struggles. One exam-prep technique that does not work for me is forgetting about it until I walk into class and [a classmate] tells me we have an exam.

My most effective exam-prep technique is reviewing the readings for each week, making sure that I understand the assignments when I do them, and when there was a practice exam, working through those problems. I think this works well because it makes sure that I review what is most likely to be on the exam and it makes sure that I understand everything that happens in the assignments instead of trying to understand it the night before the exam. One that I think may fail is ignoring the readings and practice test and not doing the assignments properly.

My most effective exam-prep technique is to look at previous code or create new code and redo it, or even write it down to use as a reference point in the exam. I think it works particularly well because I am new to coding and my memory isn’t always the best. I feel like we move on from certain subjects very quick sometimes and so things never really stick with me all that much, and I only have so much time to practice outside of class and assignments. Having a reference point similar enough to what we are working on in the exam helps me a lot.

My most effective exam-prep technique is taking notes down from previous assignments. I think it works particularly well because it may point you in the right direction to what you need to dop on the test. One exam-prep technique that does not work for me is looking at previous assignment 10 minutes before the test, and not having notes.

sumTo’s loop has three lines about i: where i starts, the question that stops the loop, and the line that moves i on. Copy the three lines out, in that order. Then: which of the three was missing from the loop in section 6 of Wednesday’s page, the one that never stopped? (Class 21, 11/09)

int i = 0; while(i < n){} i = i + 1;

The line that moves i ahead (or, the one that updates todo in section 6’s case) is the one that is missing and that makes the loop never end

I wasn’t able to get sumTo done in class Wednesday. my assumption is the i += 1

Three wrote the close. The third named the other line:

int sum = 0; int i = 1; while (i <= n) { sum = sum + i; i = i + 1; } The line where i<= n is not there

On Wednesday, three endings were written for the evaluation of totalFrom(101, Lst.of(4, 10, 20)): (a) return return return return 135; (b) return totalFrom(135, Empty) -> 135 (c) return totalFrom(135, Link(null)) -> 135. Which of (b) and (c) writes the empty list the way Lst.java spells it? And in (a), what does each of the four returns hand back? (Class 21, 11/09)

b writes it the correct way each return returns 135, so it would be 135 135 135 135

c 1st hands back: return return return 135; the 2nd hands back: return return 135; the 3rd hands back: return 135; the 4th hands back: 135;

Of (b) and (c), I think that (b) is closest to how Lst.java says it. (a) would have been the last entry, after totalFrom finished calling itself and got a single integer to return; the return would return what comes after it, eventually getting to return 135.

(b), Empty: four of the seven who answered. (c), Link(null): three. The rest of what was written:

c return(return(return(return(135)))) return(return(return(135))) return(return(135)) return(135) -> 135

b writes it the way java spells it for a they all hand back the next return and the last one hands back the number

  1. writes it the way Java spells it.
  2. returns each rest from todo until it is a value

the c does the total with a digit added onto it

Didn’t get a chance to answer before class discussion.

Section 1 of today’s page shows the first four steps of evaluating totalFrom(101, Lst.of(4, 10, 20)) by hand. Finish the evaluation: write the remaining steps the same way, down to the number it gives back. (Class 20, 11/04)

All seven entries reach 135. The endings differ, and the ending is where the empty list has to be written down.

return return return return switch (Lst.Empty()){
    case Lst.Empty() -> 135;
    case Lst.Link(var u, var rest) -> totalFrom(135 + u, rest);
};
->
return return return return 135;
return totalFrom(135, Empty))
->
totalFrom(135, Empty)
->
since it's empty it'll return 135
return totalFrom(115 + 20, Link(null)) -> return totalFrom(135, Link(null)
->
totalFrom(135,Link(null))
->
return switch (Link(null)) {
 case Lst.Empty() -> 135;
 case Lst.Link(var u, var rest) ->totalFrom(135 + u, rest); };
->
return 135;

The four given steps and the middle of each trace are left out; the endings are as written.

return totalFrom(115 + 20, Link(Empty))
return totalFrom(135, Link(Empty))
->
return switch(Link(Empty)){
      case Lst.Empty() -> 135;
      case Lst.Link(var u, var rest) -> totalFrom(135 + u, rest);
};
135
return totalFrom(135, Empty))
->
totalFrom(135, empty))
->
return switch (empty) {
    case Lst.Empty() -> 135;
    case Lst.Link(var u, var rest) -> totalFrom(135 + u, rest);
};
->
return 135
->
135
switch(Link 20)
case Lst.Empty() -> 135;
    case Lst.Link(var u, var rest) -> totalFrom(135 + u, rest);
return totalFrom(135 + u, rest)
case Lst.Empty() -> 135;
    case Lst.Link(var u, var rest) -> totalFrom(135 + u, rest);
return 135;

The totalFrom will add 101 + 4, leading it to being 105. It well then add the 10, and then an additional 10, putting it at 125. The last 10 will be added, meaning the final part is totalFrom(135, Link(empty)).

You now have outlined two ways: Wednesday’s one line with Lst.filter and an arrow, and today’s switch with two cases and a call on rest. Which of the two would you rather be handed by somebody else, and why? Is that the same one you would rather write? (Class 19, 11/02)

I would rather be handed a switch because I find it easier to see what is happening to the list. I would rather write it with an arrow, as it is shorter and simpler to format without Lst.Link and <>.

I’d probably like the filter, as all I needed was a list that was filtered, there’s a method that already does that, so it’s faster than making a new one. But if I wanted to see exactly how it works, I would want the switch cases. I would write it with the filter and arrows, why reinvent the wheel.

I would rather be handed the today’s switch. I feel like this is easier to read and understand than the one from wednesdays class. However, I would rather write the one from wednesday’s class because it is shorter to write.

I would rather be handed somebody’s one line because it is shorter and easier to read. I would also rather write the one line because it is shorter.

I would rather be handed filter because it is much easier to use and would also rathe code filter because I don’t know how it works

I much prefer the way we did it on Wednesday. It is much simpler and less to type.

I would rather the switch cases that we did today because I think it is easier for me to read. It is the same I would rather write aswell.

honestly I find both to be fairly straight forward and understandable so I can’t really pick one I like both of them

Wednesday’s Units.java had two lines processing lists: line 3 filtered units, and line 4 mapped units. Did line 3 change units? Say how you know. (Class 19, 11/02)

no because you could still print units and it’ll be (4, 10, 20)

Line 3 did not change the original ‘units’ as the filter method does not modify the list given to it and instead creates a new one.

It did not (a Lst never changes; filter gives back a new one): the two lines above, and

Line 3 did not change units it is applying a number determined by which unit is being entered, not changing it.

It did, four of eight:

Yes, it changed units because it removed 4 because it was less than 10

yes, because line 4 ran on a filtered version of the list

yes, it filtered the list to only show a list that contains numbers greater than or equal to 10.

it multiplied unit * 6, so yes

Methods vs. lambdas in Java, attempt 2 (Class 19, 11/02)

Two differences are that methods are named so that they can be used in many places without needing to rewrite the entire function, and that methods clearly define what they take and return while lambda functions do not

a difference between a lambda and a function is the lambdas doesn’t work outside of itself, or you can’t call it and you don’t need to define a return typer like int or void

lambdas are much smaller & can fit in one line. a method can do more statements in a readable way.

Today Lst.filter(u -> u >= 10, units) did what week 3’s filter(lam(u): u >= 10 end, units) did. Which parts of lam(u): u >= 10 end does the arrow keep, and which does it leave out? How about Java’s -> vs a Java method? (Class 18, 10/28)

it keeps how you state u, then what you want to filter with u, but leaves out the “end” and “lam”

Java’s lambda functions compared to the methods keep the idea of inputting something (today, a list) and returning something else based on what was given.

What the arrow keeps of lam(u): u >= 10 end (The u and the body; it drops lam and end, and the word keep collided with filter’s for some.)

it keeps the definition of a variable the same both just use u but it is different because pyre needs to have an end

It keeps out the lam or calling something and the end, and keeps the u.

For the first question it keeps most things but leaves out lam()

the arrow keeps the variable, and being able to work with the variable, and defining what is used(with units) It leaves out the end.

-> leaves out syntax compared to the other.

The Java lam and Pyret lam are very similar in function, only differing in appearance, such as Java having an arrow and not directly using the “lam” itself, as well as Java not having an end in it.

The arrow keeps the part of the lambda function that was applying the following function to each item in the list following before it and keeping only those items where the function came out as true.

The arrow keeps all u where u >= 10 in the list.

Java’s -> against a Java method (Nobody reached what is true of it: no name, no declared types, no return, written where it is used, and handed to filter as a value, where a method has to be called by someone.)

A method can use whatever type is defined in it, but a lam can’t

I think javas lam is better because its simple and requires less code, and is easier to read.

It is different than a method because it will eliminate some of the input units and return them as a list, while a method will just return the integer values

As for the second I genuinely don’t know

In week 3 you wrote filter(lam(u): u >= 10 end, [list: 4, 10, 20]). Today’s page, section 2, has it in Java. What do its two IO.println lines print? (Class 18, 10/28)

I think that line 3 will print a list with the numbers 10, 20 from the original list. Line 4 will probably print a list with the numbers 24, 60, 120 after applying u * 6 to the original list, assuming that the previous line’s Lst.filter did not change the original list.

Repeating things the way row3/grid3 or checker2/checker4/checker8 did is powerful but doesn’t scale very well. What tools could be used to create 67 green squares side by side? Something we haven’t seen in Java but have in Pyret. (Class 17, 10/26)

To put 67 green squares side by side you can use the fold expression.

The best options would be something akin to lists, that allow multiple things, including images, to be listed next to each other.

Today grid3(i) put nine copies of the picture i in a square, by calling row3 three times. If i is 40 wide instead of 30, what has to change in grid3, and why? (Class 17, 10/26)

my code for grid3 I don’t believe has to change. […] the img would just be larger

the checks because the expected result will be different

The book’s program puts each Rectangle at an x and a y; Img.beside puts one picture after another. Which number does the book make you work out that Img.beside works out for you? How do you think it does that? (Class 16, 10/21)

The book makes you work out where the rectangles go with coordinates. I think it does that by automatically putting the starting coordinate at the end of the previous one.

The book makes you work out and input the coordinates of the rectangles yourself to place them beside one another; Img.beside finds the coordinates for you using the width of the first rectangle.

When would you make a new type an enum, and when a record? (Class 15, 10/19)

Enum or record, in your words

you would make an enum when you need a fixed set of values, and a record when you need to store a data bundle

You would make an enum when you are storing multiple items of one category under one name (ex. all listings in the enum Day are day names, or all in the enum Month are months). You would make a record when you are storing two items of different categories that are tied together under one name

You would make an enum if you want a constant that doesn’t change, you have 7 days and only 7, so you make them a enum. While a Stripe could be anything, so you make it a record […] the Stripe could be “red” or “green” depending on what you want, same with it’s height. but it will always have those 2 parameters

The line to set right: an enum for texts, a record for numbers?

Enums are best used for functions that require strings for its options, like days or months as an example. Records are better for functions that require integers like height, width, and length.

Two new Stripe("red", 10)s: == says false and .equals says true. What does == ask, and what does .equals ask about a record? (Class 15, 10/19)

“==” asks if the two are the same thing(like the same address on the heap) while .equals asks if record’s the contents are the same.

== looks at the same addresses

.equals looks at each individual piece of the record

The line to set right: == for numbers, .equals for texts?

“==” Can only be used for an integer, while .equals can only be used for a string. If you try to use “==” on a string it will not go through and vice versa for using .equals on an integer.

Wednesday’s passing was (count > 0) && (total / count >= 70). What goes wrong if the two sides are swapped, and for which input? (Class 15, 10/19)

if the sides are swapped java will read total/count first so if count is zero then it will error

The line to set right: does the order inside && matter?

I’m honestly I’m struggling to figure out what would go wrong because doesn’t it being an and stop it if either of them are false either way

A6’s isWeekend took the day as a text; today’s takes a Day. What mistake can a caller make with the text one that Java stops with the Day one, and when does Java stop it? (Class 14, 10/14)

The enum, in your words

When using a string, a caller can make a mistake in using a case not expected by the method (ex. using SAT instead of Sat) and the compiler will not give an error, isWeekend would just return false even if SAT is a weekend. When using an enumerator, if a caller uses a case not expected, the compiler will give a compile error and the program will not run.

It stops mistypes or incorrect capitalization, and it stops it before it runs.

You can make a typo in the string like “sat” instead of “Sat”, and it’ll fail at runtime, while Day.sat will still fail, it’ll fail at compile time, and in the IDE it’ll underline it letting you know “Hey, this thing should be Day.SAT, fix me!!”

The opener: which side is Pyret’s if km <= 2: 5 else: 11 end on, and Java’s km <= 2 ? 5 : 11?

Pyret’s is a statement because it outputs a number. Java’s is an expression because it does not return anything or change any variables.

The enum

a caller might make a mistake with capitalization which would cause java to error because it can’t find what the caller is trying to refer to.

it keeps the caller from putting in a value that is not a day

The Day one won’t run if there are misspellings.

Day will create a compile time error as opposed to a run time error because if the day is not typed exactly like it is in enum, java will not compile.

When you use the enum “Day” there is just as little room for error, but the enum function makes it easier to catch this mistake as Java will prompt you to fix it before you run.

The opener: which side is Pyret’s if km <= 2: 5 else: 11 end on, and Java’s km <= 2 ? 5 : 11? (Both are expressions.)

Pyret - Expression because it returns a value. Java - Expression because it returns a value

if km <= 2: 5 else: 11 is an expression. km <= 2 ? 5 : 11 is a statement

Pyrets is a statement because it has if and end. Java’s is an expression because it doesn’t have return

I believe Pyrets is a statement, as it uses the if else, while Java is an expression, as it’s using operators to evaluate (ternary I believe)

They are both statements. They both change the state of the program and set up the rules for the expressions and functions.

Does your midterm grade reflect your progress, and what do grades mean to you? (Class 14, 10/14)

I like to try to get good grades, but if they slip a grade level, I tend not to get to bent out of shape because if it.

Tangible consequences of grades are your ability to show quality work to an employer.

What does return do that the 5 on its own did not? And in your own words: what makes something an expression, and what makes something a statement? (Class 13, 10/07)

Expression against statement, in your words

a statement changes the state of a program, a expression does the math

An expression evalutes the value while a statement evalutes that action.

What return does

5 on its own does nothing so you need return.

Return 5 tells it to put out 5, if you just put 5, it won’t know what to do with it.

return specifies that the object after it is what should be output by the method.

return signals when the function is supposed to end and also give what is there based on the type specified in the function name

Return allows Java to know what it must give back when you run your code, and works as a way to end your statement.

returns tells java that the values or objects in the line will be output of the function

Return ends the method and returns the specified type of the method.

5 alone was just saying something while the return 5 was telling the system to give the answer five back if the conditions are met.

return tells the program to set 5 to the answer.

it made it statement

Expression against statement

A statement is something that tells the programing what to do, but an expression is just equals something.

statement is anything that changes the code, like returning something, and expressions is something in the code that just evaluates to something. Anything that evaluates is the expression part, and a statements “states” what happened in the code.

A statement is when you use an operator that essentially tells the program to do something on an object like return tells it to make whatever it is returning the answer and an expression is for mathematics like 2 + 2 where it is using an operator without needing an object that is given in the input.

An expression is comparing thing while a statement is saying what something is.

Expressions are code that help guide statements, which are commands.

An expression is something that does not immediately return to code, a statement is something that returns

An expression is when math or logic is being done without any output besides a boolean. A statement is when an object other than a boolean is output.

On Wednesday reverse changed the builder at its address. Today, what does nextInt change, and where in the drawing? (Class 12, 10/05)

The heap, or somewhere else?

nextInt changes the integer in the heap that tells what integer is next to be output from the generator, which is in the right column of the drawing

nextInt does not change an object inside the heap, it instead changes a primitive variable on the stack

In the heap

next int changes the next result of the seed and it is stored in the heap

The heap. the nextInt draws from the seed inside of the heap, either from a defined seed or a random one

nextInt changes the heap for the address. For instance, if you do it for seed 42 once, you get 1 value in the heap, but the next time you do it, the heap will also have the following pseudorandom integer, since the seed value makes the sequential integers predetermined.

nextInt changes the position in the seed.

nextInt updates the seed so the next call can yield a different number. This happens in the heap inside the Random memory’s block. The generated integer is returned to the stack.

The number in the heap again

I think nextInt changes the position that the number generator is at in the heap.

nextInt() changes the address of the heap, getting the number that is next up in the line, and replacing it in the heap.

It changes the heap to output a new number.

Somewhere else, or no column named

It changes the integer to the next number in line.

nextInt changes the integer address to the next integer in the random seed

Int converts numbers/values into integers, and changes the objects within the code, rather than the heap.

What it gives back, rather than what it changes

The nextInt returns an integer from a range given, first number is included while the second is left out.

Today reverse changed a string builder, and Monday toLowerCase did not change a string. Say what happened to the directory/heap structure in each (Class 11, 9/30)

The directory or the heap?

toLowerCase did not change a string because it manipulates it while reverse goes into the directory and changes it.

In the directory, changing a string builder makes two of the same number (1008 and 1008) and it changes both when you change one. With a string, it makes two separate numbers (1008 and 1009) in the directory/heap that get changed separately, reverse also can’t be used on a string normally.

The heap

Stringbuilder changed the same heap item, while the toLowerCase made a new heap. The directory stayed same with the builder, pointing to the same heap, but the String created new heap with the directory.

.reverse changes the heap. .toLowerCase adds another directory address and a new heap entry for it.

with strings we make a new heap address every time but with stringbuilder we change it in the heap

Today, reverse changed the string builder at its heap address as StringBuilders store heap addresses and not an object like a named string contains characters, and it did not create any new information in the heap. Monday, toLowerCase took a string from the directory that existed in the heap, but it did not affect the information at the original address and instead created a new entry at a new address for the new information.

Previously, we were creating new heap addresses, but now with StringBuilder, we are able to change heap addresses entirely. P.S. not changing heap address, changing the text within the heap address

The directory

String builders can edit previously stored directory values

Reverse is allowed to change the string builder, but toLowerCase cannot change strings. Nothing happened in the directory/heap for toLowerCase. Reverse flips what is at the address for what is being changed and creates a new directory spot for it.

The builder and the text

The StringBuilder function allowed for the molding and manipulation of strings that was not able to be done without it as it did not make any major alterations that would mess up the code.

Reverse is registered in the builder to modify string while to lower Case was not registered in the builder to do so.

the StringBuilder is able to change the string where earlier the strings were immutable.

One thing that doesn’t work, one that does, one you would change — and how (Class 10, 9/28)

Pair work

One thing that does not work for this course is one partner typing and the other saying what to type because sometimes the person saying what to type doesn’t know what to put and sometimes the typer does their own thing.

I think the working with a partner in class is excellent because it makes me have to think through what I’m doing and articulate it to someone else who is typing and it allows me to hear a sometimes different solution to how I would do things.

Check.is

one thing that I think does not work is the check.is because you can just check it with a system.out.println(); statement and it takes less typing and you can see what mistakes you made. … I would just remove the check.is statements total.

I also don’t like the check.is part of the course because if you want a carrer in coding your not going to have that and you need to be able to see if something doesn’t work on the screen not just from a check passing or failing. But I can live with doing it.

Pair work

I don’t think the partner work is good. I think it would be better for people to work on things themselves and have partners to help figure things out not one doing the work and one doing the thinking. That just seems counter productive to me.

the one person types one person talks strategy doesn’t work for me. I learn better when I’m doing the work alongside someone and learning from their example and working it out with them, rather than entirely relying on them to help or having to do all the thinking myself. I’m newer to programming so some things are very unfamiliar or don’t stick immediately for me.

one thing that doesnt work: the format of doing work with a partner, for me at least it is difficult having to pilot someone who might think and work entirely different from me and vice versa.

One thing that doesn’t work great, at least for me, is doing work with a partner every class. I know it is a great way to learn and discuss, however I feel as if we spend a bit too much time on it. Maybe once a week instead of twice could be better. It sometimes feels like we push the lecture part of class a bit quick to get to the partner work.

I also enjoy the partners, as I can explain a thought process of the code out loud when stuck, rubber ducky style.

I like working with partners and I think it helps both people understand what they’re learning and helps them both do better on in class assignments.

I do like working code in class with a partner. It makes it more memorable, and being able to ask questions about problems in real time is great. Practice makes perfect.

The cooperation groupwork in classes is wonderful, it helps share ideas, thought processes and build over gaps in knowledge

the working with a partner system really works well

one thing that does is getting to work in pairs.

Pyret, then Java

switching from Pyret to Java was like jumping of a cliff like I was just starting to get used to Pyret then we went to Java perhaps teaching Java and Pyret could be a bit more intertwined

I personally had confusion with the jump from pyret to java, perhaps the jump could’ve been made earlier, or been more gradual, I feel like we had started to sink into pyret when we had swapped over.

Something I think does work well in this course is using Pyret before actually getting into Java to get people used to some parts before the switch. I think the part of this class that could be done better is part of how that switch goes, it is a bit too sudden. I think what could be done to make the switch from Pyret to Java a bit less confusing is introducing a little bit of Java gradually as a smaller part when doing the Pyret part of the course.

One thing that doesn’t work well in this course is some parts of Pyret. … One thing that I would change is defining concepts in Java first instead of in Pyret terms and then in Java terms.

What works

One thing that definitely does work in this course is that we always pick up from where we were last class. No jumping ahead, and no one is expected to learn a great deal of content on their own besides reading, which we discuss.

one thing that does work is how we pick up from the last class every time and there being no jumps in material.

I enjoy the 2 quiz attempts, I enjoy speaking in front of the class to explain your code(as it shows that you understand what you wrote)

One thing that does work is having two quizzes on the reading, as it highlights and fixes whatever was missed during the most important parts of the reading.

one thing that dose work is the progress exams giving access to a coding environment because most code is built from trial and error.

I think the examples at the help and having others present their work helps everyone out.

One thing that works for this course is the assignments because they are able to be completed after the readings and class time so they are a good practice.

I like that we go in depth with programming during class to get some practice in, it really helps with the assignments

the class schedule and process works well, the in-class time is effective, and allows for students to get help and to work at their own pace, and the assignments and quizzes very properly test for textual knowledge.

What to change

I would say to just have available solutions to the in class assignments open up after class, rather than waiting until the postmortom of the first assignment to see how I organize and work through my code compares to the solution.

One thing that I feel does not work is to give a few more examples of how to format code, I feel like the textbook doesn’t always do a good job of showing absolutely everything in one place, the information is there, but it is sometimes hard to understand from just reading it over before practicing with the material.

I would maybe like it if as the class is going on through the partner classwork we could as a class go over certain sections just as like a buffer as to where we are supposed to be at.

One thing that doesn’t work is not enough explanation … I would like more explanations like video that can help us or something.

I am not a fan of using discord for communication. It isn’t horrible, but it is just different from how my other classes operate.

i think i would change the way deadlines work

What does the dot do, in your own words? (Class 9, 9/23)

The dot reads what comes before it and then based off that, it knows what to do with what comes after.

The dot applies an action to something. In Check.is and IO.println, it takes the action from Check and IO and applies it to what comes in parentheses after it. For “#”.repeat, it applies it to the # before the dot.

The first is the rule. The second found the split the rule hides: for Check and IO the action goes to what is in the parentheses, and for "#" it goes to the text before the dot. Monday’s reading is about that difference, and has a name for it.

Examples in main instead of a where: block: one thing better, one thing worse (Class 9, 9/23)

One thing that was worse was that it was more difficult to determine which tests go with which method, where with Pyret it was contained within the function.

That is the cost of moving the examples into main, stated exactly, and it is the design recipe’s own point about keeping examples beside the function they describe.

Which differences between Pyret and Java are consequential, and which are only spelling? (Class 8, 9/21)

placing all calls in a println line instead of calling them by themselves.

That is the whole difference between Pyret’s REPL and a Java program, said better than the page said it: Pyret shows you every value, and Java shows nothing unless you ask.

in pyret i feel like the codes whent with the wording so function is fun but in java function is initial.

A real hole, found in one sentence. fun is a herald: it announces a function and says nothing else. Java has no herald. The first word of a Java function is the type of its answer — int stripeWidth(int u) reads gives back an int — and that is the only announcement you get.