10
$\begingroup$

As is often the case, there is usually more than one way to approach a problem or task.

Currently, my students use what they were taught in the lessons (which is expected). When they stumble upon a problem (e.g. a project that has parts that they are unsure how to approach) they very often get stuck. This is because they haven't been taught some specific thing that is related.

I want the students to be more independent in their learning, and to look for that other approach on their own. How can I structure a lesson that would foster independence and give the students the ability to look for a new approach when needed?

The students' level is somewhat advanced high school level.

$\endgroup$
  • $\begingroup$ It's really broad as it is, but to try and narrow it you could specify what you want out of a language. You've said "Name a new language I can teach." You should make it more "What is a language that will help kids with xyz" $\endgroup$ – thesecretmaster May 27 '17 at 12:11
  • 2
    $\begingroup$ Newer is not always better. $\endgroup$ – beroal May 27 '17 at 14:46
  • $\begingroup$ @beroal my mistake. I didn't make it clear what kind of new I'm talking about $\endgroup$ – ItamarG3 May 27 '17 at 16:22
  • 2
    $\begingroup$ @thesecretmaster not sure I understand the issue you're referring to. I'm not looking for any specific language. I'm trying to teach students to learn things (techniques, algorithms etc.) on their own. $\endgroup$ – ItamarG3 May 27 '17 at 17:39
  • $\begingroup$ So "How can I teach my students to teach themselves?" That's still a very broad question. $\endgroup$ – thesecretmaster May 27 '17 at 17:41
8
$\begingroup$

I think there's a few different skills students need for independence, and they require quite different teaching approaches. Independence is the end result but you can't teach it directly.

  • Confidence. They need to think it's possible to try out a new toolset and make something. Guiding them prescriptively through a variety of different new tools is a good way to do this, as with @BrDaHa's answer. i.e. Don't teach independence as such but show through example that different and new approaches are possible and not too difficult. Once they've achieved several different projects, even tiny ones, with different technologies they'll be more confident to explore different options rather than use the same thing every time.

  • Abstract understanding. The hard bit of programming is thinking about problems and solutions in the right way. Once you know conceptually what you want to do it's much less scary to go find a tool to implement that well, and that conceptual understanding will help guide you through using a new tool. Teaching CS generally addresses this, plus a specific focus on systems design.

  • Ability to learn something they don't already know. Reading documentation, using stack overflow, reading blog posts and books. Students need to learn each of these, they're different skills, and they're often not taught well or at all in CS courses. When you can do these things then approaching a new tech is fun rather than daunting.

  • Appreciate there's different tools for different jobs. You need to demonstrate, or better have them experience, that some technologies are great for some things and not others. So they know there's worthwhile in exploring different tech. On the one hand, when you have a hammer everything looks like a nail. Conversely though, it's often a lot faster to use a tool you know than learn a whole new one for a small job, even if that tool is 'better'. Negotiating that trade off is an important part of general software development. Part of the fun of being a developer.

$\endgroup$
  • $\begingroup$ The "abstract understanding" part seems to be what makes programming different from many other fields. I have seen many articles debating the idea: "You can't teach abstraction". In my opinion, this is the main unsolved issue in computer science instruction. I certainly have no clue how to do it. $\endgroup$ – user737 Jun 18 '17 at 16:47
4
$\begingroup$

The best "win" I've had with this is drawing on tables. I gave challenges to my Y12s (about a dozen students). While talking through the problems I was annotating ideas, flowcharting, tracing etc on the tables beside them with a board marker.

Now when I give them a problem they grab a table from the centre of the room and start drawing out ideas. And because they're 'winning' with what they're doing they start going above and beyond.

$\endgroup$
  • $\begingroup$ So you've taught them to think in a project oriented way? Cool. $\endgroup$ – ItamarG3 Jun 6 '17 at 17:20
  • $\begingroup$ I don't see the obvious 'win' connection which you're suggesting. $\endgroup$ – Sean Houlihane Jun 6 '17 at 17:26
  • 1
    $\begingroup$ They are planning better, and so producing better, working solutions. This is a win. The win for me is they are making the decision to plan themselves rather than just jumping on a computer and starting coding. $\endgroup$ – Oli Howson Jun 6 '17 at 18:03
3
$\begingroup$

I think it's hugely beneficial to create projects that require use of a certain language or technology, or in other words, don't leave students to their own devices to solve a problem. As a student, I found that learning Java and then moving to "weird" languages like Ocaml really expands how you think of how to solve a problem. Knowing JavaScript is pretty much a requirement in web development. Learning Python can expose students to beautiful, concise ways of solving problems, and opens the door to a lot of machine learning libraries.

I can't count how many times I've read about some technology, dismissed it, then was forced to use it somewhere, and came out thinking, "Huh, that's pretty cool"

$\endgroup$
  • 2
    $\begingroup$ So you're saying I simply shouldn't try to teach them to be independent in what they learn? $\endgroup$ – ItamarG3 May 27 '17 at 18:08
  • 2
    $\begingroup$ Downvoters: at least explain why you're downvoting. It's not helpful without an explanation $\endgroup$ – BrDaHa May 27 '17 at 19:01
  • 2
    $\begingroup$ @Itamar Green I don't think it's that so much as students may be averse to finding a new technology without seeing a project they can build with it. They can still be independent in a sense, but should be compelled to be independent by virtue of some motivating factor so as to not be dismissive of that which could be challenging, confusing, and/or seemingly irrelevant at first glance. For example, requiring students to use BeautifulSoup for webscraping in Python may lead to seeing its value more than having them find their own library to explore in Python. Too much freedom in the latter. $\endgroup$ – Peter May 27 '17 at 19:03
  • 3
    $\begingroup$ Precisely. Too much freedom can be paralyzing. Especially for newer/younger programmers, freedom with helpful guidelines/boundaries/constraints is more freeing. $\endgroup$ – Peter May 27 '17 at 19:35
  • 1
    $\begingroup$ @Peter a lot has been written lately about "the paradox of choice" and that having no guidelines or way forward is stressful and unhelpful. Lots of pension plans fail because well-meaning people provide so many options that people never choose. When I signed up for the ACA a few years ago, there were about 10 insurers, and one had over 40 plans in just one of the 4 tiers. This is not choice, it is torment. Many graduates have no idea what to do next. "The world is at your feet" feels more like, "I am drowning!" $\endgroup$ – user737 Jun 18 '17 at 16:58
3
$\begingroup$

There is an argument for facilitated and directed learning to encourage independence. Students should be allowed to discuss problems and options with their peers in order to make judgements; evidence shows that adults tend to interfere with that process. Ensure activities are hands on and try pairing students.

This may be of interested to help structure a critical thinking approach - Search Kivunjas article Using Dear Bono's Six Thinking Hats Model to Teach Critical Thinking and Problem Solving Essential for Success in the 21st Century Economy.

$\endgroup$
  • $\begingroup$ I see what you're saying, but I'm not quite sure how pairing students would aid them in being more independent. Could you please clarify that? $\endgroup$ – ItamarG3 May 28 '17 at 7:43
  • 1
    $\begingroup$ Its about being able to discuss ideas with someone and obtain direction. Sometimes they may have a direction without having to discuss it (but that would assume having the knowledge in the first place). Being able to discuss affirm amongst themselves they are heading in the right direction, and being able to describe what they are doing aids learning. $\endgroup$ – JTC May 28 '17 at 7:54
  • $\begingroup$ And, pair programming is common too. $\endgroup$ – user737 Jun 18 '17 at 17:00
3
$\begingroup$

I don't think there are shortcuts here—the students just need more foundational knowledge before they can be independent. It takes significant expertise to be able to transfer knowledge to new contexts [ref]. Novices have shallow knowledge that is closely tied to shallow features.

As an expert, you have insight into meaningful patterns in your area of expertise. You have also seen many, many different problems and cases that you can relate to current problem-solving. Your knowledge is organized in terms of its applicability to new problems [ref]. It seems so straightforward from your perspective!

But think about the challenges facing novices. To them, the problem looks different than anything they've seen because they don't recognize the generalities. Do they even know what words to Google?

I agree with other posters that confidence is necessary. Knowing good resources to use (e.g. user-friendly documentation) also helps. But most important is foundational knowledge. Teach your students well, with many examples, and as they learn more they will begin to seek out knowledge on their own.

$\endgroup$
0
$\begingroup$

Early in the process, you should emphasize using and applying documentation. Once the students begin to gain this skill, they can explore APIs and libraries that interest them.

$\endgroup$
  • $\begingroup$ Yes, although they need to have enough conceptual understanding to be able to make sense of the documentation. $\endgroup$ – nova Jul 19 '17 at 15:50
  • $\begingroup$ When we introduce Java strings, we open the docs and start learning how to use the method descriptions. We do a similar thing in a Python or JavaScript class. $\endgroup$ – ncmathsadist Jul 19 '17 at 21:05

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.