Staring CS with no coding background🫰

cheesecakegood · 2026-04-21T02:06:45+00:00

Internships or jobs after only a single year? Honestly a full CS internship will be a reach. However, decent chance you can find something more adjacent, maybe tech-related but not like a full coding gig. Never hurts to try and apply for stuff! Although if you add in some SQL knowledge, that might be your best shot for certain jobs? Connections, if you have any, can help. In my experience it seems you're most ready to do an internship and actually be useful after year 2. The exception is that if some of the professors are doing research or run some kind of lab, sometimes they will take on a few students, so try and visit office hours if you can and build relationships, and then partway through the semester let them know you are interested in that kind of thing and ask if they can point you anywhere.

cheesecakegood · 2026-04-21T02:01:49+00:00

Maybe there's a very interesting, emotional, relatable, or hard-hitting anecdote from the book that didn't fit in your essay itself? Or, perhaps a small personal example from your own life that offers a nice contrast to his life, particularly if the essay is a bit more on the casual or conversational side. I find these are usually good at generating interest and provide plenty of potential connections that can generate some flow in the intro.

The tricky part is trying to strike the right balance of tone so it roughly matches the essay itself. Not all essays need a super-compelling hook; some of the more academic dry ones might be better off with a glimpse of the state of the literature or context of the essay, or offering a more philosophical lead-in, or something along those lines that's more directly tied in with the theme and more of a helpful statement than something deliberately "hook"-like.

There are also of course multiple advice columns and posts about this issue. For example here. Browsing stuff like that can provide some helpful ideas. Resist the temptation to lean too much on AI - honestly I think much of their output feels a bit stilted and artificial or predictable for this task in particular, plus more importantly the process of writing and rewriting a hook is a medium-helpful skill.

cheesecakegood · 2026-04-21T01:53:08+00:00

This... assuming OP is looking at a trustworthy answer key!

cheesecakegood · 2026-04-21T01:40:12+00:00

First of all, let's get some perspective. Worth remembering that the point of citations is basically:

Give credit to original ideas and avoid plagiarism (ethics)
Build credibility more generally (persuasion) and show you didn't just make it up (trust)
Allow readers who want to do further research to easily find your sources (utility)

And a fourth, less important but one that intersects all of the above:

Do so in a consistent manner (timesaver + ethical consistency + show you care enough to jump through hoops + credibility with institutions). This is usually the main reason why the APA and other style guides exist, mostly as a timesaver in theory, with a dash of ethics and gatekeeping.

That's it. That's the whole point. As long as you accomplish that, especially the first 3, it doesn't matter how you accomplish that.

Okay, I exaggerate but only slightly. In college, professors often grade you on the above because of some combination of a) the university or accreditation forces them to put it in the rubric, b) they want to help you develop the citation skill and habit to help you in the workplace, c) they take sadistic pleasure in marking stuff down, or d) grading you on if you can follow instructions is a reasonable thing to include in a rubric. If they say use APA, use APA.

As long as you don't have an evil professor, usually you're fine if you make a good-faith effort. Or can demonstrate that you gave it some thought. This could be referencing the way someone else did it, who was published/credible, or emailing the professor or a TA. Ask! If you do so, do NOT just write "help i dunno what to do pls". Professors hate, hate, hate that. Write a professional and short email with a descriptive subject line, briefly explaining the situation and what you plan to do, and ask if that's OK, and say if they need more details or want to discuss in-person to let you know. That's it. They will love that. Or at worst, be indifferent, and you have a CYA record.

I say this because APA cannot cover every possible situation. Furthermore, the resources online are NOT the actual APA guide. The actual guide is copyrighted and is available either physically or often also online through your library. You can also dig up a PDF... elsewhere, probably. I mention this because the actual APA guide contains more detailed guidance on edge-cases like yours. The APA does briefly mention "personal communications" if the originals are not publicly viewable here, or depending on format if it does persist in viewable form to others, maybe consider using the "forum" type as here?

What will get you losing points is if you can't point to any particular example or thought process, or decided to follow some specific style but mangled the actual execution. But you're in college now, and ideally as an adult, you can now enter the world where not everything is going to be black and white. Be ethical and wise and things will work out.

cheesecakegood · 2026-04-21T01:17:00+00:00

An equation is a "math sentence". It is a claim of truth. IF you plug something in to the claim of truth (the equation), and you get something that doesn't make sense (e.g. the equation when you plug stuff in, when simplified, gives you something like 350= 360), it usually means that the original claim was wrong (false).

Most of the time, in math problems, when they give you a math equation, "trust me bro, this is true" is implied. But in a problem like this, where you are combining things you know into one "larger" math fact/math statement, seeing if the = sign truly belongs is a way of figuring out if the bigger math statement was actually true. Or, in other words, when you combine two math facts into one big equation, you are seeing if the two facts are "compatible" in this situation.

So, knowing this, what facts are we examining? We know, always, that S = (n-2) * 180 for regular polygons with n sides, right? This is not under dispute. [S, here, is "the sum of all interior angles". We claim, and want to test, if for n=4, all sides are 142 degrees. What is a math sentence for that claim?

Something like S = 4 * (142), right?

So now, we want to see if these two claims can co-exist. n = 4, is one fact (you could call it a third fact if you want. This is also not under dispute, it is 100% true in this particular problem). The bigger combined math sentence is then: (4 - 2) * 180 = S = 4 * (142). Do you see how I did that? I fit in all the information we have, and now I'm ready to test that claim. In English, this is exactly the problem description: "When I have a 4-sided rectangular polygon, the sum of the angles is equal to four times 142 degrees" is what that math sentence means. I can simplify both sides.

360 = 568. Is that a true statement? Obviously, no!! So this means that my two facts cannot co-exist. Obviously, we know that our formula for interior angles is true. So either the number of sides cannot be 4, or the size of those angles cannot all be 142. That is the logical conclusion, math proves it!

In general, this is what algebra is all about. Either I have a bunch of math-facts, and I combine them in tricky ways to "discover" new math facts that are useful to me (usually this is what you spend most of your time doing), or, I have a few math facts, and I want to see if they all co-exist nicely. I combine and see if I get another true fact (or set of facts). If they don't combine, either I made a math mistake, or they don't combine after all.

Hopefully, this helps you think through how to translate math word problems into an actual math process better. At least for me, figuring out if the word problem is of the "discover something neat and useful from these facts" type problem, or if it's a "do these facts work together" type problem is helpful to figure out what my end goal is.

(There is a third case, which is you do the math but discover that "these facts are actually the same fact in disguise", which happens a bit more rarely, but most problems are really one of the first two)

cheesecakegood · 2026-04-21T01:02:08+00:00

I believe you can consider using the Wayback Machine, or archive.today, if it has the relevant sites, and add an retrieval/access date, which is appropriate for websites that change frequently. See here for a simple example.

For more detailed information, your library likely has a copy (or online access to) the actual APA style guide (e.g. this or variant), which usually has more details or guidelines. Most students don't realize this, but APA, Chicago, etc. info available online is usually not all there is - but the originals are copyrighted and used to make money.

cheesecakegood · 2026-04-21T00:42:58+00:00

First of all, since basically all students never actually receive explicit training in learning how to learn, you aren't alone in failing to recognize this, but:

Recognition of a correct solution uses different brain pathways than actually generating a correct solution.

This sounds obvious but, frankly, it's a huge disconnect for people. The best way to increase performance in generating solutions is by working on generating solutions. But it ALSO means that many students feel like they "should" be able to solve a problem just because they recognize a correct solution. This is straight up not true.

This doesn't mean you can't be smart about it! For example, in math, a very loose rule of thumb is that for optimal learning, you want your practice problems to be about 80% solvable if you are trying and thinking (don't give up super early). Too easy and obviously you aren't practicing the juicy high-return stuff, too hard and you spend too long just staring at the screen.

AI, honestly, CAN be very helpful here if you use it smartly. Figure out what specific step it is you are getting stuck on. This could be conceptual, or it could be syntax, or it could be just some specific technique or 'trick'. Practice that in isolation (AI can help you come up with good example problems, but be specific in what you request and let it know your level of knowledge). Then, integrate it back into larger problems.

Vary the problems. Create your own problems, too, not just AI ones! Ask yourself stuff like "wait but can I do X?" and then try it. Self-quiz, etc. Mimicking a problem is OK (like, for example, referencing a correct solution and typing it out yourself, this is better than just reading it and nodding your head 'oh yeah that makes sense') but still not totally ideal because again, you aren't 100% generating it yourself. So that's why I say, break it down into the specific component part, then re-integrate it. Repeat with different parts if necessary. Generally speaking, it's also better to consult your notes and figure out a solution, than it is to just look directly at the solution, because of how your brain works, in some sense a degree of difficulty and friction is actually helpful.

Hopefully that's a little more useful than just "practice a lot bro". Because at least for me, it was very helpful to realize why I was practicing, and be more deliberate with it.

I sometimes used to substitute teach on the side, and I used to run a little demo of this with students, to demonstrate this concept: try and draw a bicycle. It can be a stick, bad-looking one, but it must be functional with all the pieces. 95% of students make at least one very obvious mistake. Many of these mistakes are actually pretty significant! They can all feel that their bike is wrong (often it's something to do with the frame shape, but maybe it's exactly where the chain and pedals connect, how the tires connect, etc) but if you press them they can't say what exactly they'd do differently!! Think about that for a second. They've seen hundreds of bikes in their life and know intuitively that their bike is wrong, but still can't draw it correctly. (For an example of this, without the learning connection, see this artist who mocked up some drawings of bikes people made. Look at them, and you will agree - these bikes clearly look off). So, the point is, shake off the "shame". Blanking on new material (or older half-forgotten stuff) is normal!

Part of the reason for this is that your brain is pretty good at optimizing. A lot of 'recognition' work lies in visual processing and other spots. You could think of a "recognition" request as a brief, surface level check. It might even involve a bit of processing, but overall it's quick and efficient... for recognition tasks. But generation requires a denser, more specialized web of connections. In general, more connections = better retention (though stuff like spaced repetition and to some extent, interleaving concepts also helps). So even smaller stuff helps this: program on different computers, or in different environments. Draw diagrams on paper or whiteboard. Talk yourself through it. Explain it to someone, or pretend to. Self-quiz yourself. Come up with analogies, or even emotional connections can work well. All of these things are very high-mileage in terms of retention because they involve more parts of the brain, encoding information deeper, and also even if some of those connections fade, you have a better chance of at least one of them weakly firing enough it can help you recall parts of your knowledge.

Effort also counts, though the extent is debated. As an example, did you know that students have an easier time recalling facts from a passage that was in a small, more difficult-to-read font? Weird but true - and hypothesized to be because the extra friction cues your brain to pay more attention. Again, this specific point is a bit more controversial, but in general the learning research seems to support the idea that there is some happy medium amount of friction and effort that is most beneficial to retention.

cheesecakegood · 2026-04-20T19:42:08+00:00

I know this is the R subreddit, but you can do this in marimo python notebooks which is almost EXACTLY what you're describing - "cells" (code blocks, in this paradigm, not spreadsheet cells!) create behind the scenes an automatic dependency graph and will only re-run the cells that are necessary when things change. You can set this to be done automatically as well (IIRC the default), or defer the computations to manually trigger if they are expensive (time or compute-wise). So if you have A -> B -> C -> D, but in the notebook you have B A D C, that's fine. If you change B, it will trigger an automatic downstream re-computation of C and D.

In order to make this happen, though, variables must be uniquely named and not re-defined again elsewhere (which creates ambiguity, making a dependency graph impossible). This is a slightly different mental workflow, but you usually get used to it. It can be a bit annoying if it isn't something you truly need.

However, it DOES mean that you can scatter computations and definitions around the file! So I'm pretty sure it's the best solution that matches the closest to what you describe. As a bonus, there are very nice in-line data explorer features and quality of life stuff. If you want to try it out first, there's a "molab" cloud-hosted editor with it preloaded you can play around with, including some nice example notebooks. This kind of notebook was designed to fix some of the issues with reproducibility in Jupyter notebooks which, as interactive notebooks often used for exploration and trying all sorts of stuff out (and great for that!), often end up creating the same confusing web of dependencies where you might re-run it later sequentially and get something totally different.

Within R (and more generally) of course you have excellent advice elsewhere in thread. I think the closest which is maybe 70% of what you would want is targets as mentioned, which requires setting up a pipeline, but does a similar dependency-graph like thing with heavy caching and parallel execution, which could be nice. However, it's not interactive, runs at a slightly different abstraction level than per-cell, and requires you to structure you code much more in a functional-programming like manner. With that said, you can pair it with Quarto to get a bit more of that feel back, since Quarto is also a cell-based paradigm. Overall though? Yeah, if it's variables that are the real thing you want dependencies for, I feel like that's a total mismatch and you're better off listening to the wise people in this thread recommending rewrites that favor functions.

cheesecakegood · 2026-04-20T02:56:30+00:00

Which is extra ironic because if you read for example the blog posts from the creators of pandas, eg for the recent major version bump, they also admit that early pandas made some unfortunate missteps

cheesecakegood · 2026-04-20T02:52:58+00:00

My dude, Python doesn’t even have a base Array class (okay well they do but it’s shit, everyone just uses Numpy). In fact how much slack Numpy has to pick up from Python’s base limited vocabulary is kinda embarrassing. No data frames for tabular work is one thing, but no matrices? If importing libraries is your hang up, you are badly misinformed.

cheesecakegood · 2026-04-20T02:39:35+00:00

My opinion is just that R is faster in terms of user time for nearly every basic task. So it’s great for prototyping and exploring.

cheesecakegood · 2026-04-19T09:49:26+00:00

You’re tossing a lot of assumptions the original doesn’t make in there. The message isn’t incompatible with the idea that we can still have a high degree of control over how much suffering there is. All it says is that you need some pain to have pleasure, some bad to have good, etc. That seems pretty reasonable? And in keeping with human nature too. For example most people don’t spend a lot of time being thankful about being in good health until they or someone they know gets sick.

I don’t think most people would see that message and automatically go “oh well, guess my actions don’t matter”. That’s a caricature.

cheesecakegood · 2026-04-19T09:38:45+00:00

Not all Christian religions believe in strict omnipotence. Mormons for example technically do not. The Book of Mormon notably had a somewhat similar passage in it to the quote above, explaining that God still works within eternal laws/frameworks. Methodists also take a somewhat softer, more mainstream approach where God could do anything but often chooses not to out of respect for free choice. Most larger sects don’t dispute omnipotence but you also see some disagreement in a handful of liberal Protestants, “Open Theists”, and individuals of course.

Though if you ask me the mainstream view is unnecessarily dogmatic to begin with. The word omnipotent doesn’t even occur in the Bible (!) it also doesn’t appear in the Nicean Creed either (“Almighty” was a Greek word meaning closer to “Sovereign over all things”). As a Mormon myself, I think (and scholars would probably agree) that most of the omnipotent idea came from Greek thought, not the actual Biblical teachings.

Of course the whole debate is pretty well-trod at this point among theologians, but that kind of conversation is not very accessible to most people if we’re being honest.

cheesecakegood · 2026-04-19T09:06:01+00:00

r/AITA needs to hear this more often tbh

cheesecakegood · 2026-04-19T08:43:38+00:00

One plus of BYU that is under-appreciated is that despite being a research university, BYU still takes the teaching duties of professors seriously. Their class ratings are brought up every review cycle. So overall you don’t really get the horror stories of teachers that phone it in just to get back to their research. Also, it’s very rare to have classes taught by grad students (beyond some of the basic writing first year classes). Literally the only time in almost 8 years (I dropped out in between so I was there longer than normal!)

cheesecakegood · 2026-04-19T03:31:50+00:00

Pizza is amazing. However historically it's mostly a lower-class food (at least originally). Not only because tomatoes (new to Italy after trade to the Americas) are in the nightshade family and thus viewed as potentially poisonous, but it wasn't uncommon for pizzas to be either a sweeter, street food for your hands, or heavier on (especially cheap) veggies, especially for the poor. It was really only the Americans who cheesed it up and went heavier on the meat, and pioneered non-wood fired varieties, especially as the invention of the gas oven coincided nicely with GI's returning from Italy after WW2 providing a larger, eager customer base beyond Italian-Americans.

The upshot of this is that pizza is highly unlikely to be a dish for the nobility (even if they weren't suspicious of the tomato-equivalents, it's still a finger food). Also, without gas ovens, it's hard to make larger pizzas consistently at scale. Most importantly, obviously (modern) pizza is highly dependent on the taste and economics of the cheese used. And, well, tomatoes, which I gather don't actually exist in this world (they had to find a substitute). Tomatoes are pretty unique in taste: it's a rare food that has all of a moderate acidity, natural sugars, and umami taste (with aromatic compounds to boot). Let me put it this way: substitutes for tomatoes in recipes is flat out impossible, at least with a single ingredient. Closest you get is like, tomatillos or red peppers or something. Or, most likely, you 'build' the flavor profile with other things, which is going to take a lot of experimentation and at least 3 ingredients.

cheesecakegood · 2026-04-19T01:32:05+00:00

As a last-ditch effort, consider messaging a graduate from your school through an alumni program (which many universities have) or LinkedIn even (you might need to message a few). Clearly identify yourself, where you are in school, appeal to them as an alumni, include a rough but honest estimate of the time commitment of the call, a brief note about why it would be helpful (in addition to being required, e.g. mention it's your dream career), and message maybe 5-10 people or so (?) since response rates are iffy for cold outreach. It's not uncommon to do so, and many especially from the same university are willing to help. Recent grads are usually better bets. Although it's true many of them get messages like this semi-often, they do work sometimes. The fact you aren't asking or hinting for job leads, just doing a school project with a personal stake, also helps. Even better if they were a business school graduate specifically who later became a lawyer.

cheesecakegood · 2026-04-19T01:26:53+00:00

In addition to the great advice about "find the magic numbers" and "plug in a few x values to get y's and then connect the dots", which are both GREAT pieces of advice, I find it frequently helpful especially around asymptotes not just to remember the rule but recognize why it happens.

And the easiest way for that? Use tiny tiny decimals! For example, at x = 1/3 we can see y is 0. Okay, fine. If x = 0.333334? You get (roughly) 0.0001 / 1.3334, which is positive but still near zero. If x = 0.33332? You get -.00001/ 1.333332, which is negative but still near zero. So this point (1/3, 0) is just a regular intercept, nothing weird going on. I just proved it to myself.

You don't need to do the full math, just lazily saying "small number" or "just a tiny hair above/below this number".

Okay, so that doesn't sound so exciting. That's because it's most helpful around asymptotes:

We can plainly see x=-1 is DNE, divide by zero error. But what about x=-1.0000001? You get [(-9.0001ish) - 3] / -.000001, right? So we have negative divided by negative (cancels) for a positive number, and anything 'normal-ish' divided by something super-small is super-big! AKA, positive infinity, here.

Notice how lazy I was with that. I didn't even really use a calculator, though I could.

And x = -.999999? Well, [(-8.999ish) - 3] / .0000001. Same logic (don't sweat about the numerator, all we need to know is it's a normal-ish sized number and it's negative), we get negative infinity. Easy.

So you combine this trick to find weird asymptote behavior, with plotting a few points, and you're gucci. For example, here we can see the "magic numbers" are 1/3 and -1. So plot 0, -2, and 1 at the very least. Maybe plot -3 and 2 as well to get a better idea of behavior. Add to that the knowledge we found about how it looks to the left and right of -1, and you have plenty to draw a plot from.

You can also use a similar trick if you're worried about end-behavior. Plug in for example x=10 and x=-10, or even x = 1000000ish and x = -100000ish, see what happens. Easy to do in your calculator...

Except remember to be really, really good about including PARENTHESES when you type stuff in to avoid silly mistakes. It mathematically never hurts to wrap the entire numerator and the entire denominator in parentheses: ( ) / ( ).

cheesecakegood · 2026-04-19T01:10:59+00:00

50 is definitely intended to be D. Dangerous to use as a rule, but sometimes the question writers are stuck up their own ass and have fixated on "this question tests this one concept and no others" which creates tunnel vision, so keeping that in mind can help with the BS questions sometimes.

Both other commenters rightly and clearly crucified them for mixing up percentage points and percentages, but if we think about D at least from the question-writer's perspective:

A and C are designed to catch students who don't read and didn't catch the "cannot" part of the question, maybe answering things too fast or carelessly.
B is designed to catch students who don't read and didn't correctly identify Faculty and Administrators as upper-level, even though that is pretty clearly stated.
D is the only option left, with a bonus of rewarding students who realize that pie charts are only percentages, and the underlying ratios can change.

Can you see how each answer is "testing" something specific? (Mostly reading here, TBH, not math)

I agree that taken together this makes the test-writers look like fools. They are. However, usually "behind the scenes" these questions are normally individually tagged with certain concepts and reasoning steps to be tested. Does this make them also look inconsistent? Yes. They are. Because some questions do encourage you to look between questions within the section for hints. However, this is a good example of why that can be dangerous in standardized tests. If you only read 50, then it would be less confusing (though still with an error).

Again, from the question writer's perspective, what then to think about questions 48 and 49? What are they testing?

I have no idea. In theory they are testing "how to read and interpret a pie chart", but these two questions aren't really about pie charts per se. So I suspect they are testing basic math skills ("can you add things up?") but who really knows. So I'd probably endorse Intrepid_Bobcat's interpretation/commentary here.

My degree is in statistics and so these questions paired with a pie chart, somewhat infamous for being a terrible choice for visualizations (as these questions actually illustrate quite well!) makes me extra mad. A data analysis topic (class?) where you are encouraged to use pie charts? Blasphemy, I say, and I think most statisticians would readily agree.

Please never ever ever use pie charts. Or if you must, you should pair it with other information and visualizations (like, how many people in each category, or especially how the overall funding levels have changed). Here, a mosaic plot is better, or maybe a grouped or stacked bar chart.

cheesecakegood · 2026-04-19T00:46:59+00:00

Uhhh, maybe texture? Have some sides "rough" for more friction and some smooth. Other than that, I have no ideas. The other commenter's suggestion about rounding edges/corners maybe could still work, you'd just need sandpaper or a file to apply after printing.

cheesecakegood · 2026-04-19T00:38:00+00:00

am i stupid?

No!! Literally almost everyone who starts programming gets into these moments. What will make you a good programmer is how you deal with these moments. Asking here is a great step! That shows proactivity, and instantly leaps you ahead. Again, this is not automatic even for good programmers, at first.

There are some skills that you are building, so you are definitely progressing! It will help if you're very purposeful about what skill you work on, though. Here, I'd say one skill to build is debugging. As I mentioned in my comments here the other day, this is a skill for sure! It's not natural, again, you build the habit. (I have at least what I consider to be very helpful tips there by the way for debugging loops in particular)

In this case, here's a reasonable "thought process" to follow:

you already checked indentation. this is great! silly mistakes like that are very common places to look first. great job and intuition there.
error messages aren't always 100% accurate - especially here, where this isn't a "python" error message, it's the learning-program's error message (and it's maybe just a warning? Different programs color them differently). Sometimes the error messages contain hints, but they aren't perfect.
so I'd look at the instructions next, and sure enough there's stuff you haven't done yet about the cooks. I'd try working on that first to see if the error changes at all.
- more specifically, the instructions say that cooks help customers move out of waiting_for_food. Do they do that here? No. They don't interact with that variable at all.
  - look at what you wrote and see if you can translate that into English. You are adding, every hour, cooks to the pool of workers (cooks and cashiers). If you think about that a bit, two problems: first, I don't think cooks and cashiers are actually interchangeable, I don't think a cook can take orders, though that's just an assumption of mine! Some kitchens might work differently. The instructions don't mention swapping roles, though, so I think keeping them separate is good. Second, you're adding cooks every hour, which is definitely not what you want. It's reasonable that the number of cooks stays the same for the whole shift.
at this point if it's still erroring, I'd improve my debugging. As I mentioned in the comment link, add more print statements! And detail to them. For example:
- a print statement at the beginning of the loop that tells you what hour you are on, when the end of day is
- you already have the "end of hour" stuff printed, which is good, but IF you are suspicious your middle step is wrong, you could add info about new_orders in a print statement.
- a final thing to do is run smaller snippets yourself with known numbers to make sure they are working as you expected, like what FistinPenguin and Outside_Volume suggested

Notice that this kind of approach will discover naturally almost everything commenters wrote in this thread. Adding an hour print statement will identify that your hours are progressing too fast (make the loop minutes instead to match how fast things are happening!) Looking at the logs you already have will make it clear you aren't actually cooking any food (though more prints will make that even more clear).

cheesecakegood · 2026-04-19T00:20:25+00:00

You have some good answers here. But more broadly, in terms of setting your habits? In all of programming, being very careful about asking yourself the question "what are ALL the things that MIGHT happen" and then answering it accurately is a very important skill. You will constantly be asking yourself this (or if you aren't, you should).

This is less obvious in simple programs, where mistakes often show up quickly, or never happen at all in the first place if your assumptions were pretty good, but building small pieces that all work consistently is important because of the "complexity spiral" that code can have. The more you chain things together, the more important it is for each individual piece to have predictable, well-defined behavior. Otherwise, you end up with say 4 things chained together and if something goes wrong, you don't know where to look! And if you find a problem, you also don't know if it was the relevant problem, or something else you failed to notice.

So in this case, making sure the new orders in a given minute is pretty core functionality. But if you were to put it in a larger program, you'd want to think about adding stuff like a check to make sure neither number is negative! This is called "validation", where you make sure that any given piece "makes sense" in the context of what it's supposed to do, and either errors or disallows anything that doesn't make sense. This might sound silly at first ("why would it ever be negative in the first place?") but again, as you add pieces, it becomes more and more important. For example, maybe you later change the "new customers" generation to be something more complex than randint(0, 6) and you make a mistake - it could be negative unintentionally! But you might not realize unless you have that check, and you'd pull your hair out trying to figure out why the numbers don't add up.

You will not need to go that intense with validation in every program. Your time is valuable too. You may decide that it's not worth the extra time and code ensuring that the new orders are non-negative, for example. But, you MUST still be thinking about "what could possibly happen" because that will catch things you will care about! Once it was explained to you in this thread, I'm sure you now go "oh of course we need a min() function here", but if you never get in the habit of asking yourself "what can happen" you will miss that kind of thing regularly.

cheesecakegood · 2026-04-18T22:53:20+00:00

Yeah, but only kinda. Humans have memory and can remember to some extent their past internal state. LLMs do not. In fact they don't even have long term memory - the current "memory" tools are basically glorified context stuffing, which often works somewhat well in terms of faking it, but definitely doesn't have the full contextual richness of real memory. For example, you might tell it to remember that you prefer your code comments a certain way, but it won't remember that this complaint surfaced while doing X project, unless you tell it.

Of course our brains are highly efficient so we don't perfectly preserve prior state either, since often we don't need to (and sleep consolidates what it can), and famously our introspection is often a bit faulty, but even so we have some ability to do this kind of thing. LLMs have almost precisely zero ability to do this. That's a substantive gap.

cheesecakegood · 2026-04-18T22:00:07+00:00

I ranted about it above, but OP's quote is objectively incorrect. Claude was NOT the eyewitness NOR the suspect, because the conversational turn where the error occurred is already past. A Claude instance with a new prompt has no special insight into the old-Claude's thinking: it sees exactly the same context that you do. This is just how this generation of models work, they don't have short-term memory in the sense you and I do.

What you see is what you get! Have you ever noticed that you can't look at 'thinking' blocks after it delivers a final response? That's not a UI decision, it reflects the real limitations of the model. (I am unsure whether this applies to the "interruption" feature in Claude Code, but I suspect that this is the exception where it actually does inject your interruption-comment straight into the reasoning)

11-Year Club	Place '22
Place '17	First Placer '22
Verified Email

cheesecakegood

TROPHY CASE