How about a middle ground between fundamentals and advanced "projects"

Can we start getting material to bridge the insane gap from fundamentals to advanced challenges? I was doing fine until they showed up and had no idea what I was doing.

Hello @designwhiz59651, welcome to the forums! DO you have any specific questions about any of the challenges? Other perhaps I should move this to course requests and suggestions?

I would say requests and suggestions. The advanced challenges are simply too much for someone who is new to Python without further instruction.

Ok, I’ll move it now. Do you have any specific questions, though?

The challenges are meant to be just that: challenging. If you’re struggling, then I would encourage you to continue with (and potentially revisit) the material on your chosen course and to do some off-platform study before doubling back to the challenge project that has you stumped.

What do I mean by “off platform study”? Could be anything like reading the Python docs, or doing kata on CodeWars to practice with the fundamentals.


Heya - thanks for your feedback. I authored these and we definitely hear this a lot. I can try to give you a little bit of context around these and also offer some advice.

I agree with you that these are much more difficult than our other content, and that’s because I don’t think teaching computational thinking is a central part of many of our lessons. A lot of our lessons focus mostly on syntax rather than teaching a way of thinking. This is something that we want to work on. I think projects try to be closer to a middle ground where we ask you to do a little bit of problem-solving on your own, and then code challenges are definitely the hardest.

We work off of Bloom’s taxonomy a lot Blooms-Taxonomy-650x366

Our lessons usually fall within the “understand” category, whereas I think our projects fall under “apply” and these code challenges fall under “analyze”. (And if you’ve reached the end of career paths, capstone projects try to get up to “create”).

We’ve also tried to make these less mandatory. These challenges used to be in lesson format, which would require you to get the solution for every challenge before moving on (In fact, I haven’t had time to port some of these into an article, so some of them are still in lesson format like this one. I would love to hear your feedback on the different formats once you get to some of the later code challenges). By making the challenges less mandatory, we’re hoping that folks feel like they can skip them and come back to them after getting some more practice.

Finally, I think these challenges are kind of cool because they’re more data-driven than some of our other content. These are genuinely ordered by difficulty - when I ported them over from the lesson I looked at how often learners were asking for the solution code for each challenge and ordered them from easiest to hardest. It would be interesting to take a look at that data again to see if it’s changed at all over the past few months.

So that’s all of the context around these, but I’m sure you’re rolling your eyes because I’m just throwing taxonomy pyramids at you but that doesn’t help your problem of still feeling like they’re way too difficult. So here’s some advice that might actually help:

  • These are tough. And on top of being tough, we haven’t really taught you this kind of thinking, so you’re going to struggle. But at the same time, I think this content is some of the most important content on our site. So one piece of advice is to use the lessons in a way that can prepare you for code challenges like this. Rather than just getting the checkmark on each lesson and moving on, use the code editor in the lessons to experiment with questions you might have. We’ll teach you the syntax that is correct, but you can do a lot more on your own. For example, if you’re working through a lesson on lists, we might teach you how to get a subset of that list using something like my_list[2:4]. Well, what happens if you do my_list[2:]? What about my_list[:4]? What about my_list[:-2]? How about my_list[4:2]? You can do small little experiments like that in your code editor rather than just doing my_list[2:4] and moving on - then when you come across a code challenge that involves getting a subset of a list, not only do you have more practice using that syntax, but you’ve also seen a few different edge cases.
  • Break the problems into pseudocode. Write down the solution in English and don’t even worry about the code. This will help develop those computational thinking skills, which are honestly more important than the syntax. For example, for the first challenge in the article that you linked, Append Sum, I might write something like “Find the last item in the list. Find the second to last item in the list. Add the two items together. Append the result to the list. Repeat 3 times. Return the list”. You now have a plan of action and can start writing code.
  • Start implementing the solution in code in parts. Don’t worry about getting the exact solution right away. Prove to yourself that you can do the building blocks of the solution. For example, in the Append Sum challenge, first prove to yourself that you can print the last item and second to last item in the list. Then prove to yourself that you can add those together by printing out that sum before even trying to add it to the list. If you feel shaky about adding an item to a list, forget about adding the sum of the last 2 items, just try adding something like "test" or 1. Prove to yourself that you can do all of the parts of the problem, and then start putting those parts together.

Hope that helps!


If I could like that post more than once, I would…