Eliciting & Concept Checking

Posted 2023-04-17

参考技术A If I can tell you something about this three-month training in the U.K. Please remember one word ---eliciting!!!

启发和引导式教学by Theresa

Eliciting---a range of techniques which enables the teacher to get learners to provide information rather than giving it to them （mostly by using questions rather than statements).

通过一系列教学手段让学生提供信息而非直接将信息告知学生。

看这张图片，作为教师，能从哪方面入手引导学生。（小组合作，头脑风暴）例如：

Vocabulary词汇——天气/服装

Structure结构—— There be /be doing

Information about a topic 话题信息——人物关系/户外活动

引导式教学的好处诸多，如激活学生自身已有信息，在已有信息的基础上进一步提高拓展；紧紧抓住学生课堂注意力；教师能够更好的把握课堂节奏，了解学生掌握程度等等。

启发式教学的注意事项

1.经常使用引导式教学方法

2.启发引导要建立在学生已有知识的基础上

3.采用肢体语言和简短评价来回应学生的每个答案

4.问题设置不易过难

5.采用苏格拉底式的问答法引导学生的新发现，并培养其批判性思维

6.鼓励学生相互之间引导，不完全依赖教师。

这种方法会形成一个良性循环：

教师引导—学生回答—教师给予学生肯定—学生受到鼓舞继续参与课堂—教师继续引导

但事物的两面性决定了这种方法也有一定的弊端，例如能力强的同学会占据教师的注意力并总是争取课堂表现的机会，致使稍弱的学生长期滞后以至消极懈怠。慢慢变成了恶性循环：

教师引导—能力强的学生快速反应—教师提问这些学生—学生受到鼓舞更加积极参与—教师继续引导。

为了避免这类现象的频繁发生，我们可以采取以下措施，来试图打破这样一种循环：

1.教师点名学生回答问题，让不同层次的学生都能参与。

2.提问前，给学生思考问题的时间。

3.在点名前，让学生先进行小组讨论。

4.教师刻意兼顾全体学生，把握好课堂节奏，而非只按照能力强的学生的步伐。

5.在课堂节奏对于某些能力强的学生而言略慢时，可以引导这些学生帮助同组成员，促使他们保持注意力的集中。

之前教授们就一直强调课堂上放松鼓励的氛围有多重要，那么鼓励学生参与，让学生在课堂上觉得舒服，我们可以怎样做呢？

除了上文提到的点名，小组合作和思考时间之外，有两点值得一提：

1.多鼓励，少纠正。多用“差不多，再试试”等方式鼓励学生继续思考，而不是“错了，谁知道正确答案？”这种否定式用语会中断学生的思考。

2.当学生自愿发言，就某一话题发表看法时，尽量不去纠正其错误。因为有时信心的建立比答案的正确更重要。

关于elicit的更多资源，可以参考以上reference。

Elicit是教学活动的第一步，你可能想着，引导的最后，应该是给出正确答案了吧，其实在大多数情况下，教师根本不必给出正确答案，你肯定要问，那我们怎么确定学生是否真的掌握，这个时候我们就要借助concept checking questions---概念检查问题 (by Ailsa)

课堂导入部分，Ailsa让学生两人一组，先感受一下通过创设情景让对方猜句子的过程。然后她再举例说明： A friend asked me what happened to me last night. And I said what do you mean by last night? She said there was a party and everyone was there but you. And what would I say?

同学们给出的答案是：if I had known about the party, I would have gone.为了确保学生理解过去完成式的语法含义，她给出一系列CCQs:

Did I know about the party?

How do I feel ?

Did I want to go?

When was the party?

通过回答这些问题，学生们可以更好理解这句话，老师也可以通过学生是否给出正确答案来判断学生理解程度。这是针对语法概念检测的例子。接下来是词汇教学中的应用。

给出度假和汽车的图片，elicit学生说出租车的单词—hire ，为了检测学生对这个单词的掌握程度，可以设置以下CCQs:

Does it belong to you?(理解单词基本含义，是租用，不是拥有own）

Can you keep it for ever?（理解租用短期性 short term）

Is it free?（表明需要付费payment is involved ）

Tell me some things that you can hire.(学会应用这个词汇how they can relate to other things)

进行到这一步，一般情况下，很多人会问一句

Do you understand? 但是这句话是否真正有意义，得到的学生的回应是否真实有效都值得推敲。若当堂不能解决这个问题，而仅仅通过课后作业检测往往又丧失了时效性。

在课堂上，我们可以采用以下措施

1. Examples/models 让学生应用举例

2. Activities/exercises 设计活动

3. Translations /dictation翻译或听写

4. Timelines 学生画时间轴 用于时态语法教学

5. Visuals 图片检测 比如sensible 给出两张图片对比，那种行为更理智

6. Create other context 创设情景 Can you think another typical situation that we can use this grammar or vocabulary

7. TPR -Total physical response 肢体语言表达正确与否

概念检测问题要简洁明了，达到检验学生对目标语言的理解，语言结构的掌握和语言使用的正确语境。

上图展示了三个实例和四个练习，请你也来试试，欢迎留言探讨！

multiset

multiset

#ifndef __SGI_STL_INTERNAL_MULTISET_H
#define __SGI_STL_INTERNAL_MULTISET_H

#include <concept_checks.h>

__STL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1174
#pragma set woff 1375
#endif

// Forward declaration of operators < and ==, needed for friend declaration.

template <class _Key, class _Compare __STL_DEPENDENT_DEFAULT_TMPL(less<_Key>),
          class _Alloc = __STL_DEFAULT_ALLOCATOR(_Key) >
class multiset;

template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x, 
                       const multiset<_Key,_Compare,_Alloc>& __y);

template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x, 
                      const multiset<_Key,_Compare,_Alloc>& __y);

template <class _Key, class _Compare, class _Alloc>
class multiset {
  // requirements:
  
  __STL_CLASS_REQUIRES(_Key, _Assignable);
  __STL_CLASS_BINARY_FUNCTION_CHECK(_Compare, bool, _Key, _Key);

public:

  // typedefs:

  //@ 以下的定义与set相同
  typedef _Key     key_type;
  typedef _Key     value_type;
  typedef _Compare key_compare;
  typedef _Compare value_compare;
private:
	//@ 底层机制是采用RB-Tree
  typedef _Rb_tree<key_type, value_type, 
                  _Identity<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;  // red-black tree representing multiset
public:
  typedef typename _Rep_type::const_pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::const_reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::const_iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;

  // allocation/deallocation
  multiset() : _M_t(_Compare(), allocator_type()) {}
  explicit multiset(const _Compare& __comp,
                    const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) {}

#ifdef __STL_MEMBER_TEMPLATES

  //@ multiset的插入操作采用的是底层RB-Tree的insert_equal()而非insert_unique()
  template <class _InputIterator>
  multiset(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_equal(__first, __last); }

  template <class _InputIterator>
  multiset(_InputIterator __first, _InputIterator __last,
           const _Compare& __comp,
           const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }

#else

  multiset(const value_type* __first, const value_type* __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_equal(__first, __last); }

  multiset(const value_type* __first, const value_type* __last,
           const _Compare& __comp,
           const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }

  multiset(const_iterator __first, const_iterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_equal(__first, __last); }

  multiset(const_iterator __first, const_iterator __last,
           const _Compare& __comp,
           const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
   
#endif /* __STL_MEMBER_TEMPLATES */

  multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
  multiset<_Key,_Compare,_Alloc>&
  operator=(const multiset<_Key,_Compare,_Alloc>& __x) {
    _M_t = __x._M_t;//@ 调用了底层红黑树的operator=操作函数 
    return *this;
  }

  allocator_type get_allocator() const { return _M_t.get_allocator(); }
  
  //@ ...
  
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#pragma reset woff 1375
#endif

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_MULTISET_H */

迭代器

  iterator begin() const { return _M_t.begin(); }
  iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() const { return _M_t.rbegin(); } 
  reverse_iterator rend() const { return _M_t.rend(); }

观察器

  //@ 返回用于key比较的函数,调用RB-Tree的key_comp()
  key_compare key_comp() const { return _M_t.key_comp(); }
   //@ 由于multiset的性质, value和key使用同一个比较函数
  value_compare value_comp() const { return _M_t.key_comp(); }

容量

  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }

修改器

//@ 这里调用的swap()函数是专属于RB-Tree的swap()，并不是STL的swap()算法
  void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }

  // insert/erase
  //@ 插入数据节点
  iterator insert(const value_type& __x) { 
    return _M_t.insert_equal(__x);
  }
  //@ 在指定位置插入节点
  iterator insert(iterator __position, const value_type& __x) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    return _M_t.insert_equal((_Rep_iterator&)__position, __x);
  }

#ifdef __STL_MEMBER_TEMPLATES  
  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_equal(__first, __last);
  }
#else
  void insert(const value_type* __first, const value_type* __last) {
    _M_t.insert_equal(__first, __last);
  }
  void insert(const_iterator __first, const_iterator __last) {
    _M_t.insert_equal(__first, __last);
  }
#endif /* __STL_MEMBER_TEMPLATES */
  //@ 擦除指定位置的元素
  void erase(iterator __position) { 
    typedef typename _Rep_type::iterator _Rep_iterator;
    _M_t.erase((_Rep_iterator&)__position); 
  }
  //@ 擦除元素值为x的节点
  size_type erase(const key_type& __x) { 
    return _M_t.erase(__x); 
  }
  //@ 擦除指定区间的节点
  void erase(iterator __first, iterator __last) { 
    typedef typename _Rep_type::iterator _Rep_iterator;
    _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last); 
  }
  //@ 清除multiset
  void clear() { _M_t.clear(); }

查找

  //@ 查找元素值为x的节点
  iterator find(const key_type& __x) const { return _M_t.find(__x); }
  //@ 返回指定元素的个数
  size_type count(const key_type& __x) const { return _M_t.count(__x); }
  
  //@ 返回指向首个不小于给定键的元素的迭代器
  iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  
  //@ 返回指向首个大于给定键的元素的迭代器
  iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x); 
  }
  
  //@ 返回匹配特定键的元素范围
  pair<iterator,iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }

操作符

  //@ 以下是操作符的重载

#ifdef __STL_TEMPLATE_FRIENDS
  template <class _K1, class _C1, class _A1>
  friend bool operator== (const multiset<_K1,_C1,_A1>&,
                          const multiset<_K1,_C1,_A1>&);
  template <class _K1, class _C1, class _A1>
  friend bool operator< (const multiset<_K1,_C1,_A1>&,
                         const multiset<_K1,_C1,_A1>&);
#else /* __STL_TEMPLATE_FRIENDS */
  friend bool __STD_QUALIFIER
  operator== __STL_NULL_TMPL_ARGS (const multiset&, const multiset&);
  friend bool __STD_QUALIFIER
  operator< __STL_NULL_TMPL_ARGS (const multiset&, const multiset&);
#endif /* __STL_TEMPLATE_FRIENDS */
};

template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x, 
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x, 
                      const multiset<_Key,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class _Key, class _Compare, class _Alloc>
inline bool operator!=(const multiset<_Key,_Compare,_Alloc>& __x, 
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator>(const multiset<_Key,_Compare,_Alloc>& __x, 
                      const multiset<_Key,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator<=(const multiset<_Key,_Compare,_Alloc>& __x, 
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator>=(const multiset<_Key,_Compare,_Alloc>& __x, 
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Compare, class _Alloc>
inline void swap(multiset<_Key,_Compare,_Alloc>& __x, 
                 multiset<_Key,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

总结

• multiset 的特性及其用法和 set 完全相同，唯一的区别就是 multiset 允许键值key重复
• multiset 的插入操作采用的是底层 RB-Tree 的 insert_equal() 而非 insert_unique()。