Please enable JavaScript.

Coggle requires JavaScript to display documents.

Teaching to Code (Lesson Planning (Pedagogical Content Knowledge (What is…

- - - - Program Structures
        
        building blocks of code
        
        chunking
      - Pragmatics
        
        Specifications
        
        Development
        
        Testing
        
        Debugging
        
        Communication
      - Orientation
        
        End goals
        
        Areas of application
        
        Benefits of programming
      - Notation
        
        semantics
        
        grammar
        
        syntax
      - Cognitive load
        
        Lower for experts when solving the same problem
        
        Chunking
        
        Allows experts to think through things more quickly
        
        Can teach common patterns through examples
        
        Experts reason using higher level pattern than novices
        
        :newspaper: Problem Solving and the Development of Abstract Categories in Programming Languages
        
        subconscious pruning
        
        chess players do not consider more moves than non-expert chess players, but “zoom in” on potentially good moves
        (De Groot (1946, 1978))
        
        Informed by existing domain knowledge
        
        Knowledge of the contexts and/or situations in which
        it is or will be useful
        
        parallel thinking
        
        experts work from findings to a hypothesis using a breadth first
        novice reasoning is characterised as backwards and depth first
        
        efficient access
        
        Knowledge is linked to related knowledge (like HDD cache)
        
        Stronger neural pathways
        
        :newspaper:Epistemology or Pedagogy, That Is
        the Question
        
        :newspaper: On the nature of programmer expertise
        
        Three types of load
        
        Intrinsic load (prerequisite load, remnant of previous learning)
        
        Germane load (what is being taught) - Desirable
        
        Extraneous load (undesirable extra load not related to target learning)
        
        Made worse by
        
        inquiry based learning
        
        requires simultaneous acquisition of factual content and problem solving strategies
        
        Novices lack mental structures required to make good use of inquiry based learning
        
        :newspaper: Why Minimal Guidance During Instruction Does Not
        Work
        
        Writing code from scratch
        
        Improved by
        
        Worked Examples
        
        Parsons problems
        
        Live coding
        
        Tracing
        
        PRIMM
        
        :newspaper:Instructional Design of a Programming Course ⎯ A Learning Theoretic Approach
      - The Notional Machine
        
        Behaviour of the machine
        
        Relation to physical machine
        
        Mental models
    - - process of building
        
        Three stages
        
        Fill in complexities and special cases later
        
        Manuals fill in gaps in knowledge
        
        start from existing models of similar domain
        
        build model that is useful rather than accurate
        
        tutorials build mental models
        
        Analogies
        
        Should not be too close to actual domain
        
        Increases opportunities for deeper conceptual links
        
        Reduces misconceptions from gaps in analogy
        
        Start from knowledge they already have, not from knowledge you have (see also: expert blind spot)
      - danger of incorrect models
        
        Too many facts can reinforce bad models
        
        Test by regular formative assessment
        
        Should be quick to administer
        
        Should be unambiguous (self-marking)
        
        Have diagnostic value - test misconceptions - plausible distractors
        
        options for format
        
        Multiple choice
        
        Parsons problems
        
        matching problems
        
        🔗 Further examples
        
        use regularly (10-15 mins)
        
        Use to inform lesson planning (tdt)
        
        Can use peer instruction for deeper reflection
        
        "It ain't what you don't know that gets you into trouble. It's what you know for sure that just ain't so"
        Mark Twain
        
        Fix by reasoning through examples that draw attention to contradictions
        
        Avoid by presenting common misconceptions to students
        
        Seek out concept inventories
        
        :link: example misconceptions
      - Are a required structure for facts to be useful
        
        Facts alone are not useful and can be harmful
        
        The facts experts see as underlying their models may not be the ones useful to learners
        
        Expert blind spot: "the tendancy of experts to organise explanation according to the subject's deep principles rather than being guided by what their learners already know"
        
        :newspaper: Expert Blind Spot: When Content Knowledge Eclipses Pedagogical Content Knowledge
      - Test mental models
        
        Can be tested better through diagnosis and debugging than creation of new code
        
        Present code with opportunities for diagnosing misconceptions
      - Characteristics of robust models
        
        no-function-in-structure principle:
        
        E.g. the rules that describe how a switch in an electric circuit works must not refer to the function of the whole circuit
        
        The rules that specify the behaviour of a system component are context free.
        
        locality principle.
        
        E.g. the rules that describe a switch in a circuit must not depend on the internal state of any other component in the circuit
        
        the rules that specify the behaviour of a system component are represented only in terms of the internal aspects of the component and its connections to other components
        
        weak causality principle:
        
        E.g. what happens next to a component in a circuit must be attributable to some local cause not by reasoning about other components.
        
        the rules of the mental model attribute each event in the system to a direct cause.
        
        :newspaper: Visual Program Simulation in Introductory Programming Education
        :link: Summary
    - - Activities
        
        general principals
        
        Differentiation
        
        pitfalls
        
        Expertise Reversal Effect
        
        :newspaper: The Expertise Reversal Effect
        
        applies to
        
        4 more items...
        
        strategies
        
        Flexible Pace Learning
        
        Student can complete activities in their own time
        
        Extension activities for those that finish quickly
        
        Collaborative learning
        
        Higher achievers have a platform to vocalize their ideas
        
        Lower ability students can learn from their peers
        
        progressive tasks
        
        Tasks that gradually get harder over time
        
        Faster workers will be slowed by the more challenging exercises
        
        Variable outcomes
        
        Open ended questions allow answers matching the learners level of understanding
        
        PRIMM
        
        Predict – given a working program, what do you think it will do?
        
        Run – run it and test your prediction
        
        Investigate (Explain) – What does each line of code mean? What are the steps this code follows? Why has the person who wrote this code chosen to do it this way?
        
        Modify – edit the program to make it do different things
        
        Make/Create/Design – design a new program that uses the same ideas but that solves a new problem.
        
        provide context for learning (authentic tasks)
        
        should encourage collaboration
        
        consider cognitive load
        
        activity types
        
        Worked examples
        
        Transition to faded examples
        
        Transition between worked examples and generative problem solving
        
        Reduce cognitive load by focusing on small parts of the problem
        
        Aid in dividing problems into sub-chunks
        
        Delivery
        
        Examples should be interleaved with matching problems (see formative assessment). Don't block exercises together!
        
        sub-goals should be identifiable or marked (aid breaking into blocks)
        
        There is value in working through incorrect solutions (perhaps more with intermediate level learners)
        
        Progressive reveal can allow easier digesting and show non-linear process in which experts writing code
        
        Can take the form of live coding
        
        Effective when multiple similar examples are used (aids generalisation)
        
        Only meaningful when combined with self-explanation
        
        Filling in the motivations for choosing steps
        
        Generalising patterns from the specific example
        
        Can be encouraged
        
        structural manipulations
        
        3 more items...
        
        training
        
        2 more items...
        
        Follow up questions / prompting
        
        Builds knowledge contextualisation
        
        Types of self explanation
        
        Elaborating on individual examples (deriving principals)
        
        Comparing examples (generalisation)
        
        anticipative reasoning (predict and test)
        
        :newspaper: Worked-out examples: instructional explanations support learning by self explanations
        
        :newspaper: Learning from Examples: Instructional Principles from the Worked Examples Research
        
        :newspaper:Applying Science of Learning in Education (p118)
        
        benefits
        
        Concentrates on application of strategy and alleviates cost of finding strategy
        
        Prevents expending effort on and reinforcement of poor methods of finding strategies (focusing on superficial aspects of questions, copy and adapt etc)
        
        breaks problems into manageable chunks
        
        Live Coding
        
        benefits
        
        Allows responses to what-if questions
        
        Lateral knowledge transfer (how to use editor etc)
        
        Slows down teaching (easier to take in)
        
        Makes teacher more aware of size of content
        
        Learners get to see mistakes and their corrections
        
        Easier to watch than static slides - more compelling
        
        Get students to make predictions
        
        Ask students for next steps
        
        Talk through everything you do
        
        Mirror the learners' environment (IDE etc)
        
        Perhaps start from skeleton code to reduce extraneous cognitive load
        
        :rolled_up_newspaper: Marc J. Rubin. The effectiveness of live-coding to teach introductory programming.
        
        Examples
        
        Should bear some resemblance to real code (authentic)
        
        Should solve problems learners can relate to
        
        Should be in an easy to understand domain (less extraneous load)
        
        Should be superficially different to each other - focus attention on deep structure
        
        Should be easily broken down into steps for explanation and live coding
        
        Don't be afraid to use long examples if they can be broken down into parts
        
        Don't be afraid to include syntax not previously seen (comprehensible input)
        
        :newspaper: Worked Examples in Computer Science
        
        parsons problems
        
        focuses on control flow
        
        reduces syntax load
        
        :link:Example of load of syntax
        
        :newspaper:Parson's programming puzzles: A fun and effective learning tool for first programming courses
        
        exposure to good code
        
        Debugging
        
        Good debuggers are good programmers, but not vice versa
        
        Makes classes easier to manage (they debug themselves)
        
        Trains reading of code
        
        Should teach reading and interpreting error messages
        
        Use tracing, including tracing variable values
        
        Draw flow charts of code
        
        :newspaper:Learning by Taking Apart: Deconstructing Code by Reading, Tracing, and Debugging
        
        Pair Programming
        
        use traditional driver+navigator model
        
        switch roles regularly
        
        a form of peer instruction
        
        :newspaper: The Case for Pair Programming in the Computer Science Classroom
        
        faded examples
        
        Consider unplugged activities
        
        :link: examples
        
        :link: tips
      - Comprehensible Input
      - Cognitive Apprenticeship
        
        Apprenticeship aspects
        
        Modelling
        
        model expert performance
        
        show internal cognitive processes
        
        show tacit knowledge
        
        transfer motivations and emotions
        
        Scaffolding
        
        Support given to carry out tasks
        
        Ranges from doing almost everything to giving small hints
        
        Fading
        
        The gradual reduction of scaffolding over time
        
        Increasing responsibility of apprentice
        
        Coaching
        
        Overseeing the process of learning
        
        Giving continual feedback
        
        Choosing appropriate tasks
        
        Proving encouragement
        
        :newspaper: Situated learning in the workplace
        
        Creating apprenticeship tasks
        
        Identify the process of a task
        
        Make the process visible to students
        
        Situate abstract tasks in authentic contexts
        
        Vary the diversity of tasks
        
        Make clear the common aspects
        
        :newspaper: Instructional Design of a Programming
        Course ⎯ A Learning Theoretic Approach
    - - Learning Objectives
        
        Should be measurable and verifiable - acceptance criteria
        
        Use clear verbs e.g. Fink's Taxonomy
        
        Foundational Knowledge
        remember, understand, identify, recall, describe, explain
        
        Application
        use, solve, calculate, create, write, design
        
        Integration
        connect, relate, compare, contrast, evaluate, identify issues
        
        Human Dimension
        come to see themselves as, understand others in terms of, decide to become
        
        Caring
        get excited about, be ready to, value, want to learn more about
        
        Learning How to Learn
        identify source of information for, frame useful questions about
        
        :newspaper:Creating Significant Learning Experiences
        
        Each a single sentence describing what a student will be able to do after the lesson
      - procedural
        
        program comprehension
        
        program generation
      - technical
        
        data
        
        instructions
        
        syntax
      - modularity
        
        primitive expressions
        
        means of combination
        
        means of abstraction
  - - - Design tests first
      - Enforce testable content
      - Tests are small units
      - Many small tests. Few big tests
      - Fix failing tests before moving on
      - Don't teach if the tests already pass
    - - Characterise different personas
      - What do they find hard?
      - What do they know already?
      - What do they want to learn?
    - - Describe a single unit of learning
      - Make clear the motivations
      - Verifiable acceptance criteria
      - Clear statement of what is required
    - - Re-evaluate personas and stories in response to new data
      - Maintain focus on delivering benefit to learners over following a pre-set plan
      - Release small units of knowledge regularly and evaluate their impact.
      - Monitor progress always
    - - Build demonstrable capability early
      - 5 real capabilities is better than being half way to having 10 capabilities
      - Explain, demonstrate, guide, reproduce, consolidate etc make a vertical slice of teaching
- - - - Diagrams
        
        Different types of diagrams
        
        Concept Maps
        
        Can be used to reinforce model building aspects of lesson content
        
        Are a skill to learn above the understanding itself
        
        Can be drawn as an assessment
        
        Shops concepts and their relations
        
        Useful to represent mental models
        
        Value of diagrams
        
        Can be used to "pin ideas to" for later reference
        
        Improve satisfaction
        
        Can improve performance, but only with instructive graphics
        
        Creating good diagrams
        
        Highlight most critical material - standard design principals
        
        Captions/text should be as close as possible to graphical material
        
        Should be presented, gradually, in parallel to spoken content
        
        Broken into easy to digest chunks
        
        Audio is better than text when accompanying graphics (but not for non-native speakers)
- - - - Ask questions about how things work and why
      - make connections between ideas. Compare and contrast
      - relate ideas to your own experiences or memories
      - check for misconceptions in your elaborations
    - - Write or sketch everything you know about a topic
      - Take practice tests
      - Check accuracy against notes
    - - practice small amounts spread over many days
      - review previous content with exponential back-off
      - review information that you have forgotten
    - - Find words and visuals to explain concepts
      - Come up with your own different ways to represent ideas
    - - switch between ideas when studying
      - go over topics in different orders
      - make links between ideas as you switch between them
    - - Find examples to show abstract ideas
      - Make links between the examples and the ideas