# 2.1 Pájaros

## Objetivo

Esta construcción es simple, podría ser la primera que se construye por lo que se recomienda realizar una programación con dificultad gradual:

1. Realizarla sin interacción, sólo moviendo el motor
2. Después moviendo el motor durante un segundo
3. Cambiar el sentido de giro, primero hacia un sentido y luego que cambie
4. Interaccionar con algún objeto de Scracth
5. Interaccionar con sensor de distancia

## Construcción

Lo podemos descargar[ aquí en pdf ](http://ro-botica.com/pdf/WeDo/Dancing%20Birds.pdf)o en este enlace [Dropbox](https://www.dropbox.com/s/xb91toeoe9v2imn/PAJAROS.pdf?dl=0)

## Propuesta

Que los pájaros bailen en un sentido y luego en otro

<iframe allowfullscreen="allowfullscreen" height="314" id="bkmrk-" src="//www.youtube.com/embed/OeQmYrrp61E" width="560"></iframe>

##### Solución

  
![](data:;base64,<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" id="typepad-standard" xmlns:fb="http://www.facebook.com/2008/fbml">
<head>
	<!-- head-common -->
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
	<meta name="generator" content="http://www.typepad.com/" />
	
	<meta name="description" content="Simon Haughton shares his inspiring and creative ICT ideas." />
    <link rel="canonical" href="https://simonhaughton.typepad.com/main/" />



        <link rel="stylesheet" href="https://simonhaughton.typepad.com/main/styles.css?v=6" type="text/css" media="screen" />
        <link rel="stylesheet" href="https://static.typepad.com/.shared/themes/common/print.css" type="text/css" media="print" />

<link rel="stylesheet" href="https://static.typepad.com/.shared/css/featherlight-gallery.css">

<!-- Font Awesome -->
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.6.3/css/all.css" integrity="sha384-UHRtZLI+pbxtHCWp1t77Bi1L4ZtiqrqD80Kn4Z8NTSRyMA2Fd33n5dQ8lWUE00s/" crossorigin="anonymous">

	<link rel="alternate" type="application/atom+xml" title="Posts on 'Simon Haughton's website' (Atom)" href="https://simonhaughton.typepad.com/main/atom.xml" />
	<link rel="alternate" type="application/rss+xml" title="Posts on 'Simon Haughton's website' (RSS 1.0)" href="https://simonhaughton.typepad.com/main/index.rdf" />
	<link rel="alternate" type="application/rss+xml" title="Posts on 'Simon Haughton's website' (RSS 2.0)" href="https://simonhaughton.typepad.com/main/rss.xml" />
	<script type="text/javascript">
		var TPApp = {};
		TPApp.app_uri = "https://www.typepad.com/";
	</script>
	<script type="text/javascript" src="https://static.typepad.com/.shared/js/yui/yahoo-dom-event.js,/js/app/thumbnail-gallery-min.js,/js/app/flyouts-min.js"></script>



<!--- head google analytics -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-225723-36', 'auto', {'name': 'Typepad'}, {'allowLinker': true} );  // Separate tracker for Typepad.
ga('Typepad.require', 'linker');
ga('Typepad.linker:autoLink', ['none']);
ga('Typepad.set', 'dimension1', '6a0120a530561e970b012876745169970c');
ga('Typepad.set', 'dimension2', 'index');
ga('Typepad.send', 'pageview');
</script>



<!-- fb-opengraph.tt -->
<meta property="og:title" content="Simon Haughton's website" />
<meta property="og:site_name" content="Simon Haughton's website" />
<meta property="og:type" content="blog" />
<meta property="og:url" content="https://simonhaughton.typepad.com/main/" />
<meta property="og:description" content="" />
<meta property="fb:admins" content="" />
<meta property="fb:app_id" content="55753818692" />
<meta property="og:image" content="https://up6.typepad.com/6a0120a530561e970b01630170d665970d-220si" />



	<title>Simon Haughton's website</title>
	<link rel="openid.server" href="https://www.typepad.com/services/openid/server" />
	<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.typepad.com/services/rsd/6a0120a530561e970b012876745169970c" />
	
        
</head>


<body class="layout-two-column-left-mb">
<div id="fb-root"></div>
<script>
window.fbAsyncInit = function() {
    FB.init( { apiKey: 'a279adbe87e2b3c505e777af99a5260d', xfbml: true, version: 'v2.8' } );
};
( function() {
    var e = document.createElement( 'script' ); e.async = true;
    e.src = document.location.protocol + '//connect.facebook.net/en_US/sdk.js';
    document.getElementById( 'fb-root' ).appendChild( e );
} )();
</script>

	
	<div id="container">
	    <div id="wrapper">
		<div id="container-inner">
			
			<!-- banner -->
<div id="banner">
	<div id="banner-inner" class="pkg">
		
		<h1 id="banner-header"><a href="https://simonhaughton.typepad.com/main/" accesskey="1">Simon Haughton's website</a></h1>
		<div id="banner-screen"></div>
	</div>
	<div id="banner-bg"><a href="https://simonhaughton.typepad.com/main/" accesskey="1">Home</a></div>
</div>



			<div id="pagebody">
				<div id="pagebody-inner">
					<div id="alpha">
						<div id="alpha-inner">
							<!-- entry list sticky -->


		<h2 class="date-header">26 December 2019</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b0240a4ad6b5e200c">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2019/12/please-visit-my-new-website.html">Please visit my new website </a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>All of my content is now available on my new website:</p>
<p style="text-align: center;"><span style="font-size: 14pt;"><a href="https://sites.google.com/view/simonhaughton">https://sites.google.com/view/simonhaughton</a></span></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2019/12/please-visit-my-new-website.html">26 Dec 2019 16:10:06</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2019/12/please-visit-my-new-website.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b0240a4ad6b5e200c'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">12 October 2019</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b0240a4900316200c">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html">Internet Safety Day 2020 Assembly Slides</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p style="text-align: center;"><span class="asset  asset-generic at-xid-6a0120a530561e970b0240a4ddd0ee200b img-responsive" style="font-size: 15pt;"> <a href="https://simonhaughton.typepad.com/files/internet-safety-day-2020.pptx">Download Internet Safety Day Assembly 2020 by Simon Haughton</a></span></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html">12 Oct 2019 10:19:13</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b0240a4900316200c'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">27 January 2019</h2>
	
	<div class="entry-category-bett entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3d88656200b">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html">BETT 2019</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad392e25d200c-pi"><img alt="IMG_3006" class="asset  asset-image at-xid-6a0120a530561e970b022ad392e25d200c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad392e25d200c-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3006" /></a></p>
<p>Yesterday was my ninth visit to the annual BETT Show and I do think that I&#39;m becoming quite efficient now in navigating the stands and picking out the new products that are: manageable and cost-effective to implement in the classroom as well as having a positive impact on the curriculum and children&#39;s education. So, in no particular order, here are some of the highlights I found:</p>
<ul>
<li>the <em>Blue-Bot</em> and <em>Bee-Bot</em> now have an audio playback feature that speaks the movements that are happening (saving adults like me getting a dry throat and making it better to use independently by children) - <a href="https://www.tts-group.co.uk/Hero-BeeBot.html">https://www.tts-group.co.uk/Hero-BeeBot.html;</a></li>
</ul>
<p class="asset-video" style="text-align: center;"><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/ctRio8s5hvk?feature=oembed" width="500"></iframe></p>
<ul>
<li><em>TTS</em> have also started selling <a href="https://www.tts-group.co.uk/wildlife-garden-activity-tin/1015661.html?cgid=Primary%3AComputing_%26_ICT%3ABee-Bot_Blue-Bot_%26_Pro-Bot" rel="noopener" target="_blank">activity tins for the Bee-Bot</a>, containing: accessories, jackets and activity cards to help enhance your use of the <em>Bee-Bot</em> on the many new mats that are now available like a wildlife garden, dinosaur jungle and an amusement park;</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89642200b-pi"><img alt="IMG_3052" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89642200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89642200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3052" /></a></p>
<ul>
<li><em>Twinkl</em> have launched a free <a href="https://itunes.apple.com/gb/app/little-red-coding-club/id1434696246#?platform=ipad" rel="noopener" target="_blank">AR-based coding app</a> on the theme of Little Red Riding Hood;</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89667200b-pi"><img alt="IMG_3039" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89667200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89667200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3039" /></a></p>
<ul>
<li><em>Twinkl </em>have also started creating AR-linked books too, like <a href="https://www.twinkl.co.uk/resources/twinkl-originals">https://www.twinkl.co.uk/resources/twinkl-originals</a>;</li>
<li><em><a href="https://www.lbq.org/" rel="noopener" target="_blank">Learning By Questions</a></em> appears to be an online, multiple-choice quiz from which you can get feedback on how children perform although personally, I&#39;d rather pick the questions myself (e.g. from the&#0160;<em>Classroom Secrets</em> resources) and just create a free&#0160;<em>Google Form</em>;</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89657200b-pi"><img alt="IMG_3074" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89657200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89657200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3074" /></a></p>
<ul>
<li><em>Mission Python </em>is a book teaching you how to code via the theme of a space adventure, although look on their site, whilst it&#39;s very detailed, would need some simplification before actually presenting to children;</li>
<li><a href="https://www.bbc.com/bitesize" rel="noopener" target="_blank"><em>BBC Bitesize</em></a> has recently undergone a slight design update and archiving of old content, whilst&#0160;<a href="https://www.bbc.com/teach" rel="noopener" target="_blank"><em>BBC Teach</em></a> continues to upload curriculum video clips and live lessons.</li>
<li><a href="https://www.mightywriter.co.uk/what-is-mighty-writer.html" rel="noopener" target="_blank"><em>Mighty Writer</em></a> is a felt-based story mapping mat which looks quite fun.</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89684200b-pi"><img alt="IMG_3043" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89684200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89684200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3043" /></a></p>
<ul>
<li><em><a href="https://scottiego.com/en/edu-scottiego/how-does-it-work/" rel="noopener" target="_blank">Scottie Go</a>&#0160;</em>is an interesting collaboration between real magnetic command blocks and a programming app.</li>
<li><a href="https://gocoderz.com/educators/" rel="noopener" target="_blank"><em>CoderZ</em></a> is an online robot programming site.</li>
<li><a href="https://isandbox.co.uk/" rel="noopener" target="_blank"><em>iSandBOX</em> </a>is basically projection-mapping technology for a sand tray which would be phenomenal if your school has the money and space to put it.</li>
</ul>
<p class="asset-video" style="text-align: center;"><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/TAuQ7aun2rI?feature=oembed" width="500"></iframe></p>
<p>I had a fantastic day out and even came back with quite a nice haul of merchandise that&#39;ll I&#39;ll be distributing to my Technology Team at the end of the year!</p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html">27 Jan 2019 11:13:02</a>
		|
		<a href="https://simonhaughton.typepad.com/main/bett/">BETT</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3d88656200b'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">07 December 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3c56c5b200b">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html">Balancing Calculations - Question Generator</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>I always like making an Excel random-question generator and today I was challenged to make one for Year 6 balancing calculations.</p>
<p>If anybody wants to use it with their children, you can download it <a href="https://simonhaughton.typepad.com/files/balancing-equations-generator.xlsx">by clicking here</a>.</p>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/files/balancing-equations-generator.xlsx" style="display: inline;"><img alt="Balancing calculations" class="asset  asset-image at-xid-6a0120a530561e970b022ad37fb9a3200c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad37fb9a3200c-500wi" title="Balancing calculations" /></a></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html">7 Dec 2018 19:02:49</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3c56c5b200b'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">07 October 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3b6c0f6200b">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html">Google Sites - Staff Bulletins</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>Last week I was challenged to design an easier-to-produce method for my deputy head to produce the weekly staff bulletin, to replace the paper version (created in Word) which we&#39;ve used for many years now.</p>
<p>After asking on Twitter and doing a bit of investigating myself, I eventually opted to suggest Google Sites as a suitable alternative since it&#39;s: free, easy to design and allows for seamless embedding of Google Calendars (which we use to share: public events, staff development dates, assembly themes and much more) and linking of Google Forms (which we use for collecting feedback from lots of things within school). With these already inserted, all that now needs to be updated each week are the bullet points for news and reminders - everything else can mostly just be kept the same or updates automatically. It&#39;s emailed out to all staff so no printing is required and the fact that it contains lots of web links means that staff can now know exactly where to find them when needed.</p>
<p>Since our staff bulletin obviously contains private information, I&#39;ve tried my best to share a screenshot of it below that shows the general layout of and design as much as possible. Please let me know if you find it useful - email me (simonhaughton@ymail.com) or my deputy head (mkemp@parkfield.rochdale.sch.uk) for more details if you&#39;re interested in replicating a similar system in your school.</p>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad397267a200d-pi"><img alt="Gsite" class="asset  asset-image at-xid-6a0120a530561e970b022ad397267a200d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad397267a200d-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="Gsite" /></a></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html">7 Oct 2018 14:53:22</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3b6c0f6200b'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">12 July 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3809a81200d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html">How to Teach Primary Computing - Staff Meeting Slides</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>I was recently asked to deliver a staff meeting a nearby school sharing my methods and plans for teaching primary Computing.</p>
<p>Here&#39;s a copy of the presentation I created for it in case you find it useful in any way:</p>
<p style="text-align: center;"><span class="asset  asset-generic at-xid-6a0120a530561e970b022ad3809a75200d img-responsive" style="font-size: 15pt;"> <a href="https://simonhaughton.typepad.com/files/computing-staff-meeting-by-simon-haughton.pdf">Download Computing Staff Meeting</a></span></p>
<p style="text-align: center;"><span class="asset  asset-generic at-xid-6a0120a530561e970b022ad3809a75200d img-responsive" style="font-size: 15pt;"> <a class="asset-img-link" href="https://simonhaughton.typepad.com/files/computing-staff-meeting-by-simon-haughton.pdf"><img alt="How" class="asset  asset-image at-xid-6a0120a530561e970b022ad3a06bb3200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3a06bb3200b-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="How" /></a><br /></span></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html">12 Jul 2018 17:28:24</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3809a81200d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">09 July 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad37fccb5200d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html">Ways to Integrate Twitter into School Life</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>I visited a local school to help them set up a school Twitter account&nbsp;this morning and thought that people might find these tips I shared with them useful, based on the system I've set up and promoted at my school, Parkfield Primary:</p>
<ul>
<li>Only have one Twitter account for the whole school. Some people like their own class teacher or department accounts but this just becomes a jumble from examples I've seen, and the 'main' account just ends up with somebody having to retweet lots of things from different accounts before/so it can appear in the main feed that's embedded onto the website homepage. To restrict usage, only me and the SLT know the account password which we enter in for staff when they want to do an initial login to Twitter.</li>
<li>Offer a range of different methods for staff to tweet to increase the likelihood of them actually tweeting - let them use both school-owned tablets/lapotops as well as their own mobile phones (which they're comfortable with). Our mobile phone policy allows for this use, as long as any photos/videos are deleted at the earliest opportunity (i.e. after they've been transferred to the school server).</li>
<li>Don't be too strict about your expectations for tweets as staff will worry about getting it wrong and therefore not tweet otherwise. Praise any snapshots of learning that are shared onto Twitter as they all help to raise awareness of what's happening in the school community and improve engagement from stakeholders like parents.</li>
<li>Encourage the use of hashtags to make it easy to find groups of tweets at a later date. This can be as simple as #Y1/#Y2/#Y3 etc. along with the name of the subject the tweet is about, e.g. #Art/#Computing/#History. At my school, I created this list of hashtags which also contain a few additional ones that are useful on certain occasions, although only a few people really have the need to use them.</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad37fcceb200d-pi"><img alt="Hashtags" class="asset  asset-image at-xid-6a0120a530561e970b022ad37fcceb200d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad37fcceb200d-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="Hashtags" /></a></p>
<ul>
<li>Prompt the more confident members of staff to include @mentions in their tweets to help promote the school and improve community cohesion - e.g. mentioning places visited on trips or organisations that are involved with the school.</li>
<li>Use <a href="http://www.wordle.net/" rel="noopener noreferrer" target="_blank">http://www.wordle.net/</a> or a similar online service to create a word collage of words associated with your school (e.g. from the motto, mission statement, parent questionnaire responses or inspection report). This can then be printed out and made into a display to use as a backdrop when tweeting celebrations and awards so they look really professional.</li>
</ul>
<div align=center>
<div style="text-align: center;">
<blockquote class="twitter-tweet" data-lang="en">
<p dir="ltr" lang="en">Well done to this super speller from <a href="https://twitter.com/hashtag/Y1?src=hash&amp;ref_src=twsrc%5Etfw">#Y1</a>! 📝 <a href="https://twitter.com/hashtag/headteacheraward?src=hash&amp;ref_src=twsrc%5Etfw">#headteacheraward</a> <a href="https://t.co/sZ2kWd6x5z">pic.twitter.com/sZ2kWd6x5z</a></p>
— Parkfield Primary (@Parkfield) <a href="https://twitter.com/Parkfield/status/1012646336636817408?ref_src=twsrc%5Etfw">June 29, 2018</a></blockquote>
<p>
<script src="https://platform.twitter.com/widgets.js"></script>
</p>
</div>
</div>
<ul>
<li>On your school website, add links to Twitter searches that show tweets containing specific hashtags from your school Twitter account to make it easy for visitors to easily search for examples of specific tweets. To do this, simply go to the Twitter website, type <span style="font-family: 'courier new', courier; color: #0000bf;">ACCOUNT: #HASHTAG OR #HASHTAG</span> into the search box (putting your Twitter handle instead of 'account' and any hashtags you want - remembering to put 'OR' in capitals if needed), click 'Search', click 'Latest Tweets' and then copy/paste the generated URL. For example, <a href="https://twitter.com/search?f=tweets&amp;vertical=default&amp;q=%23Computing%20from%3AParkfield&amp;src=typd&amp;lang=en" rel="noopener noreferrer" target="_blank">this link</a> will show all the tweets from my school that include #Computing in them. Doing this provides instant evidence of work that has been produced, ordered by the most recent at the top, which is a far more efficient method of celebrating/showcasing work than creating 'Big Books' that take a long time to collate and date really fast. It also has the advantage of being able to include video clips - especially useful for music and PE lessons, for instance.</li>
<li>Train up pupils to do some tweeting themselves (e.g. G&amp;T Y6 pupils or digital leaders). At my school, I've trained up children on my Technology Team to take photos on an iPad in assemblies and then tweet them afterwards during play time, using this simple prompt sheet:</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad359ca0d200c-pi"><img alt="Promptsex" class="asset  asset-image at-xid-6a0120a530561e970b022ad359ca0d200c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad359ca0d200c-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="Promptsex" /></a></p>
<ul>
<li>If you are lucky enough to have large monitors around your school or indeed just a laptop connected to a projector in your dinner hall, consider buying some cheap online web space and creating a scrolling page showing your tweets. If you know how to write basic HTML, feel free to copy <a href="http://twitter.parkfieldprimary.com" rel="noopener noreferrer" target="_blank">this page</a> I created for my school that displays latest tweets on the left and tweets we've liked on the right (e.g. awards we want to highlight or messages from other followers praising our school).</li>
<li>Login to the Twitter account from a desktop computer using&nbsp;<a href="https://tweetdeck.twitter.com/" rel="noopener noreferrer" target="_blank">https://tweetdeck.twitter.com/</a> as this allows you to schedule tweets in advance, such as reminders.</li>
</ul>
<p><strong>&nbsp;Have you got any more ideas or tips you think others would find useful? Let me know in the comments below!</strong></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html">9 Jul 2018 19:16:43</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad37fccb5200d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">06 February 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b01bb09f0e20a970d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html">Geography Corners</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>Whilst lying in bed the other night, I came up with a fun idea for improving children&#39;s geographical knowledge of where different places are using the classic game of &#39;corners&#39;. Whenever you have a few minutes to spare - such as at the end of the day - get your children up and moving and competing against each other to see who can correctly identify different places on a map from multiple choice options, as shown in these slides which play in a random order each time. Let me know if you use them in your classroom and what your children think of this game as I&#39;m sure it could be quite easily adapted to other topics too.</p>
<p style="text-align: center;">You will need to enable macros to ensure the slides in these PowerPoints I&#39;ve made play in a random order.</p>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c94d799d970b-pi"><img alt="UK" class="asset  asset-image at-xid-6a0120a530561e970b01b7c94d799d970b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c94d799d970b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="UK" /> <span class="asset  asset-generic at-xid-6a0120a530561e970b01b7c94d79ad970b img-responsive"><a href="https://simonhaughton.typepad.com/files/geography-corners---uk.ppt">Download Geography Corners - UK</a></span></a></p>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09f0e1e3970d-pi"><img alt="Europe" class="asset  asset-image at-xid-6a0120a530561e970b01bb09f0e1e3970d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09f0e1e3970d-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="Europe" /> <span class="asset  asset-generic at-xid-6a0120a530561e970b01b8d2d7e711970c img-responsive"><a href="https://simonhaughton.typepad.com/files/geography-corners---europe.ppt">Download Geography Corners - Europe</a></span></a></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html">6 Feb 2018 19:07:34</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b01bb09f0e20a970d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">28 January 2018</h2>
	
	<div class="entry-category-bett entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b01bb09ed4020970d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html">BETT 2018</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8d9970b-pi"><img alt="IMG_3452" class="asset  asset-image at-xid-6a0120a530561e970b01b7c949f8d9970b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8d9970b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3452" /></a></p>
<p style="text-align: left;">Having been to BETT several times now and in this age of constrained school budgets, I went to this year’s show with the aim of hunting for products which were both value for money and which would actually have a real impact on children’s learning over a number of lessons - i.e. which aren’t expensive one-off gimmicks.&#0160;</p>
<p>With that being said, here is my list of stands that I visited which I spotted had interesting and potentially useful offerings:</p>
<ul>
<li>There seemed to be many stands selling mini programmable toys and games this year which all looked quite fun, such as: <a href="http://robowunderkind.com/" rel="noopener noreferrer" target="_blank"><em>Robo Wunderkind</em></a>, <a href="http://www.logiblocs.com/" rel="noopener noreferrer" target="_blank"><em>Logiblocks</em></a> and <a href="https://scottiego.com/en/scottiego/home/about-the-game/" rel="noopener noreferrer" target="_blank"><em>Scottie Go!</em></a>, with perhaps my favourite being&#0160;<a href="http://www.kamibot.com/default.php" rel="noopener noreferrer" target="_blank"><em>Kamibot</em></a> which looks like the first serious competitior to the&#0160;<em>Bee-Bot</em> but which unfortunately doesn&#39;t seem to actually be purchasable in the UK.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d44870970c-pi"><img alt="IMG_3497" class="asset  asset-image at-xid-6a0120a530561e970b01b8d2d44870970c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d44870970c-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3497" /></a></p>
<ul>
<li>The&#0160;<a href="https://eu.getcatchbox.com/products/catchbox-lite?variant=13490236100" rel="noopener noreferrer" target="_blank"><em>Catchbox</em></a> looked like a really cool cube-shaped throwable microphone but a quick look online suggests that it&#39;s very expensive.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8e3970b-pi"><img alt="IMG_3490" class="asset  asset-image at-xid-6a0120a530561e970b01b7c949f8e3970b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8e3970b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3490" /></a></p>
<ul>
<li><a href="https://uk.samlabs.com/blogs/projects" rel="noopener noreferrer" target="_blank"><em>SAM Labs</em></a> has several mini STEAM projects online which could be used in a club with children.</li>
<li><a href="https://www.yellow-door.net/ranges/apps-and-technology/" rel="noopener noreferrer" target="_blank"><em>Yellow Door</em></a> has a surprisingly large collection of apps for early years which could have potential classroom use.</li>
<li><em><a href="https://tinybop.com/" rel="noopener noreferrer" target="_blank">Tiny Bop</a>&#0160;</em>offers several child-friendly apps which offer interactive cross-sections and simulations of different things like animals and the solar system.</li>
<li><a href="http://marcothemaltabus.com/" rel="noopener noreferrer" target="_blank"><em>Marco the Malta Bus</em></a>&#0160;reading scheme is probably the most quirky titled and branded product I&#39;ve seen at BETT.</li>
<li><a href="https://www.capita-sims.co.uk/sims-primary" rel="noopener noreferrer" target="_blank"><em>SIMS Primary</em></a> has announced a new/revised version of their management system which looks to more personalised from the needs of primary schools.</li>
<li>The&#0160;<em>NSPCC</em> has <a href="https://itunes.apple.com/gb/app/playtime-with-pantosaurus/id1258635349?mt=8" rel="noopener noreferrer" target="_blank">released a new app</a> to help children learn how to stay safe.</li>
<li><a href="https://twitter.com/ICT_MrP" rel="noopener noreferrer" target="_blank">@ICT_MrP</a> was on the&#0160;<em>Cohuba</em> stand talking about ways schools can embrace social media and how schools sharing photos can have very positive outcomes which shouldn&#39;t be feared. He also talked about a very amusing twist on those annoying &#39;let&#39;s see how many RTs this photo can get&#39; tweets that classes send out - get people to instead manipulate them in as many ways as possible to make them funny.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09ed44cf970d-pi"><img alt="IMG_3501" class="asset  asset-image at-xid-6a0120a530561e970b01bb09ed44cf970d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09ed44cf970d-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3501" /></a></p>
<ul>
<li><a href="https://www.showbie.com/" rel="noopener noreferrer" target="_blank"><em>Showbie</em></a> were there promoting their excellent online classroom organisation application and kindly let me have several stylus pens to take back to school for my <a href="https://simonhaughton.typepad.com/main/2017/07/year-6-technology-team-an-end-of-year-reflection.html" rel="noopener noreferrer" target="_blank">Technology Team</a> children whom I&#39;m sure will greatly appreciate them.</li>
<li>Data Harvest were proudly showing off their <em>BETT Award</em> winner&#39;s trophy for their&#0160;<a href="http://data-harvest.co.uk/catalogue/science/primary/datalogging/primary-vu-data-logger/2305PK5" rel="noopener noreferrer" target="_blank"><em>EasySense Vu+</em></a> Bluetooth data loggers, as well as exhibiting their&#0160;<em><a href="http://data-harvest.co.uk/catalogue/science/secondary/genecon-dynamo-range/secondary-genecon/3904" rel="noopener noreferrer" target="_blank">Genecon V3</a>&#0160;</em>child-friendly handheld dynamo which is excellent value in my opinion.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d448a9970c-pi"><img alt="IMG_3488" class="asset  asset-image at-xid-6a0120a530561e970b01b8d2d448a9970c img-responsive" height="266" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d448a9970c-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3488" width="199" /></a></p>
<ul>
<li><span style="text-align: left;">Last year,&#0160;</span><em style="text-align: left;">TTS</em><span style="text-align: left;"> were giving away mini&#0160;</span><em style="text-align: left;">Bee-Bot</em><span style="text-align: left;"> compasses but I sadly only picked up one of when in hindsight I should have taken a handful as they would be great for doing an &#39;unplugged&#39; lesson on algorithms (</span><a href="https://drive.google.com/drive/folders/1BM9L1qACt6jKfc62EQvM1UJ1JSQq7x1Y" rel="noopener noreferrer" style="text-align: left;" target="_blank">see here</a><span style="text-align: left;"> for my resources which use just a picture of a&#0160;</span><em style="text-align: left;">Bee-Bot</em><span style="text-align: left;"> rather a physical one). I did learn though that they can actually be bought online </span><a href="http://www.tts-group.co.uk/bee-bot-infant-compass-10pk/1011756.html" rel="noopener noreferrer" style="text-align: left;" target="_blank">here</a><span style="text-align: left;"> in packs of 10 and are - of course - classed as a geography resource.</span></li>
<li><em>Lego Education</em> didn&#39;t have a specific stand at this year&#39;s show but have just started promoting&#0160;<em>Lego Maker Spaces</em> - see <a href="https://education.lego.com/en-us/makerspace" rel="noopener noreferrer" target="_blank">here for an explanation</a> and <a href="https://education.lego.com/en-us/middle-school/intro/c/maker-space" rel="noopener noreferrer" target="_blank">here for some activity ideas</a>. I have recently blogged about the potential use of Lego <a href="https://simonhaughton.typepad.com/main/2017/12/lego-imaginnering-in-schools.html" rel="noopener noreferrer" target="_blank">here</a>.&#0160;</li>
</ul>
<p style="text-align: center;"><span style="font-size: 14pt;"><a href="https://photos.app.goo.gl/kbKrWKCkwIeuEEWI3" rel="noopener noreferrer" target="_blank">View all my photos from the day</a></span></p>
<p>And finally, school kids were out judging BETT again and following their hashtag gives you a great insight of how children experienced BETT and what they thought of the different exhibitors this year:</p>
<p style="text-align: center;"><a class="twitter-timeline" data-widget-id="957568787217252353" href="https://twitter.com/hashtag/kidsjudgebett">#kidsjudgebett Tweets</a>
<script>// &lt;![CDATA[
// &amp;lt;![CDATA[
!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?&amp;#39;http&amp;#39;:&amp;#39;https&amp;#39;;if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+&amp;quot;://platform.twitter.com/widgets.js&amp;quot;;fjs.parentNode.insertBefore(js,fjs);}}(document,&amp;quot;script&amp;quot;,&amp;quot;twitter-wjs&amp;quot;);
// ]]&amp;gt;
// ]]&gt;</script>
</p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html">28 Jan 2018 11:08:22</a>
		|
		<a href="https://simonhaughton.typepad.com/main/bett/">BETT</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b01bb09ed4020970d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">27 December 2017</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b01bb09e32aeb970d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html">How to Improve Photography in Your School</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>Over the years at my school, I've attempted to develop and improve photography so it becomes a seamlessly integrated aspect of daily life. Some of the strategies I use are pretty obvious to me but I figured that they might not be to others, so here are sixteen of my top tips:</p>
<p><strong>1.&nbsp;</strong>Apply for a school Animoto account - they're free for educators and allow you to quickly and easily create slideshow montages of events such as trips out.&nbsp;<a href="https://animoto.com/education/classroom" rel="noopener noreferrer" target="_blank">https://animoto.com/education/classroom</a></p>
<p><strong>2.&nbsp;</strong>If you're using tablets to take your photos, place a little sticker next to the lens so you can quickly say to children where to look when posing and avoid their eyes looking in the wrong direction.</p>
<p><strong>3.&nbsp;</strong>Encourage people to take photos of small groups of children facing the camera - either directly looking at it or just having their face (as opposed to the back of their head) in it whilst they are doing a task/interaction. These are the shots you want to keep and display - photos showing the backs of children where they can't be identified are never as interesting, neither are shots that don't actually include children at all (umpteen photos of cute animals at the farm might be nice at the time but are mostly useless back in school).</p>
<p><strong>4.&nbsp;</strong>Check out what's going on in the background of a shot before you take it - whilst you're arranging children into position in the foreground, things might be happening behind them that you don't want visible in the final photo. Ask anybody walking behind to step aside for a moment or re-frame the shot to the children in the foreground are physically blocking something behind them from being shown. Also remember to check the floor as well for any unwanted items such as dropped stationary or litter which you might want to remove too.</p>
<p><strong>5.&nbsp;</strong>Take the majority of photos in landscape - these display much better on computer displays.</p>
<p><strong>6.&nbsp;</strong>Shoot the same subject from three different angles with the camera: tilted left, horizontal and tilted right. This gives you several different takes of the same thing and allows you to pick the best later on. I have a tendency to shoot mostly horizontal or tilted right which results in slideshows I create afterwards looking quite samey so I'm trying to force myself to do more left tilted shots to add a bit more variety.</p>
<p><strong>7.&nbsp;</strong>Always be ready with your camera to take photos instantly, especially on event days where you want to try and shoot as much as possible as these are the times that children will most fondly remember and want to look back on in future years. On dressing up days like World Book Day, for example, I will spend all of morning break outside on the yard shooting photos of groups of children.</p>
<p><strong>8.&nbsp;</strong>Try to take photos of children within the same year group as these can be referenced and re-used more easily in future. For example, I will often ask for a group of children in just Year 3 say to pose for a photo before I then ask for a group of just Year 4 children. Depending on the context, try to include a mix of genders in photos too.</p>
<p><strong>9.</strong>Have one DSLR camera in school that has a good optical zoom lens on it - this is especially valuable for taking photos of assemblies where I'm usually stood right at the back and the children performing are several metres away with a huge audience in between us. If you want to transfer photos to an Apple iOS device, this cable is invaluable -&nbsp;<a href="https://www.apple.com/uk/shop/product/MJYT2ZM/A/lightning-to-sd-card-camera-reader" rel="noopener noreferrer" target="_blank">https://www.apple.com/uk/shop/product/MJYT2ZM/A/lightning-to-sd-card-camera-reader</a>.</p>
<p><strong>10.&nbsp;</strong>Include digital photography skills as part of your school curriculum. In Computing lessons, I teach <a href="https://drive.google.com/drive/folders/0B4IXXL4Qnh6AUXB1NUhOX0VmRU0" rel="noopener noreferrer" target="_blank">photo editing</a>, <a href="https://drive.google.com/drive/folders/0B4IXXL4Qnh6ATWF1REZiNmd4eUU" rel="noopener noreferrer" target="_blank">perspective photography</a> and <a href="https://drive.google.com/drive/folders/0B4IXXL4Qnh6AS1hNOFZGckk2aEE" rel="noopener noreferrer" target="_blank">superimposing</a>, for instance.</p>
<p><strong>11.&nbsp;</strong>Run half-termly photo challenges where you invite people to email you photos taken outside of school which can then be compiled into a slideshow to showcase in the final week. These have been immensely popular at my school and have included topics such as: extreme reading, sports, holidays, science experiments, pumpkin carving, Lego models and Christmas tree selfies. These allow you to encourage children to develop both their photography and creative skills beyond the school gates.</p>
<p style="text-align: center;"><iframe allowfullscreen="" frameborder="0" height="243" id="vp1V8RK2" src="https://s3.amazonaws.com/embed.animoto.com/play.html?w=swf/production/vp1&amp;e=1514363652&amp;f=V8RK2t3BMB118F3hVTgZMQ&amp;d=0&amp;m=a&amp;r=360p&amp;volume=100&amp;start_res=360p&amp;i=m&amp;asset_domain=s3-p.animoto.com&amp;animoto_domain=animoto.com&amp;options=" title="Video Player" width="432"></iframe></p>
<p style="text-align: left;"><strong>12.</strong> Let some Year 6 children be responsible for taking photos of aspects of school life such as daily assemblies, attendance winners or favourite library books. I also let these children tweet the photos accompanied with a descriptive sentence typed with the aid of a writing frame like "Well done to #YearX who are this week's #attendance with XXX%!".</p>
<p style="text-align: left;"><strong>13.</strong> Create a display in a central location in school that can be used as a background for any celebration photos such as of awards or excellent work.&nbsp;</p>
<div align=center>
<blockquote class="twitter-tweet" data-lang="en">
<p dir="ltr" lang="en">Congratulations <a href="https://twitter.com/hashtag/Y1?src=hash&amp;ref_src=twsrc%5Etfw">#Y1</a> who are our <a href="https://twitter.com/hashtag/attendance?src=hash&amp;ref_src=twsrc%5Etfw">#attendance</a> <a href="https://twitter.com/hashtag/award?src=hash&amp;ref_src=twsrc%5Etfw">#award</a> winners this week with 91.1%. ⭐️🏆 <a href="https://t.co/fxEbfSFhZ1">pic.twitter.com/fxEbfSFhZ1</a></p>
— Parkfield Primary (@Parkfield) <a href="https://twitter.com/Parkfield/status/921310836702040064?ref_src=twsrc%5Etfw">October 20, 2017</a></blockquote>
<p class="asset-video">
<script src="https://platform.twitter.com/widgets.js"></script>
</p>
</div>
<p style="text-align: left;"><strong>14.</strong> Use any shared displays or screens for showcasing photos - I use the hall board during dinner times to either show slideshows playing on a loop or an automatically scrolling page of recent tweets like <a href="http://twitter.parkfieldprimary.com/" rel="noopener noreferrer" target="_blank">this</a> or <a href="http://awards.parkfieldprimary.com/" rel="noopener noreferrer" target="_blank">this</a>. This not only increases the usage of such displays but also proves the children that you are actually using, liking and keep to show off the photos which are being taken of them.</p>
<p style="text-align: left;"><strong>15.</strong> Store your photos in a central location that is accessible by all staff. We save all photos taken on in a dedicated folder on a shared network drive, with photos stored in Academic Year\Term\Event Name. Where possible, I encourage staff to name any events which are just focused on one year group with the year group name at the start of the folder name so they can easily be found later on by listing folders in alphabetical order.</p>
<p style="text-align: left;"><strong>16.</strong> <a href="https://www.cnet.com/uk/how-to/how-to-disable-live-photos-on-iphone-6s-6s-plus/" rel="noopener noreferrer" target="_blank">Turn off Live Photos</a> if shooting on any iOS device which has this feature. It's aim is to record a few seconds of video to help you recall the ambience in a setting which is great for holidays but not required when the 'ambience' is just you directing children where/when to look.</p>
<p style="text-align: center;"><strong>I hope you find these tips useful. Please write a comment below if you can think of any more!</strong></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html">27 Dec 2017 08:54:04</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b01bb09e32aeb970d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
			<div class="pager-bottom pager-entries pager content-nav">
		<div class="pager-inner">
			
			
			<span class="pager-right">
				<a href="https://simonhaughton.typepad.com/main/page/2/"><span class="pager-label">View Older Posts</span>
					<span class="chevron">&#187;</span></a>
			</span>
		</div>
	</div>
	
	



						</div>
					</div>
					<div id="beta">
						<div id="beta-inner">
						    
<div class="module-profilefollowing module">
	<div class="module-content">
		<div class="userinfo pkg">
			<div class="userinfo-userpic">
				<a href="https://profile.typepad.com/simonhaughton"><img src="https://up6.typepad.com/6a0120a530561e970b01630170d665970d-50si" alt="" width="50" height="50" class="userpic" /></a>
			</div>
			<div class="userinfo-username">
				<h3><a href="https://profile.typepad.com/simonhaughton" style="text-decoration: none;">Mr Haughton</a></h3>
				<p></p>
			</div>
		</div>
		<div class="follow-data pkg">
			<div id="user-following" class="user-following pkg">
				<div class="user-contacts user-has-contacts">
					<a rel="me" href="https://profile.typepad.com/simonhaughton/contacts" title="View all following" target="_parent"><span id="num-contacts" class="follow-num-size-l">1</span> Following</a>
				</div>
			</div>
			<div class="user-followers">
				<div class="user-num-contacts">
					<a rel="me" href="https://profile.typepad.com/simonhaughton/followers" title="View all followers" target="_parent"><span id="num-followers" class="follow-num-size-l">0</span> Followers</a>
				</div>
			</div>
			<div class="user-actions">
				<iframe src="https://www.typepad.com/services/connect/profile_module?user_id=6p0120a530561e970b&amp;follow_only=1&amp;mb=1&amp;align=center&amp;source_uri=https%3A%2F%2Fsimonhaughton.typepad.com%2Fmain%2F" width="100%" height="30" frameborder="0" scrolling="no" allowtransparency="true" id="follow-button-frame" name="follow-button-frame"></iframe>
			</div>
		</div>
	</div>
	<div class="module-list pkg">
		<div class="module-list-item"><a href="https://profile.typepad.com/typepadeverything" target="_parent"><img src="https://up3.typepad.com/6a00d83451c82369e20168ebba2aa0970c-50si" alt="The Typepad Team" title="The Typepad Team" class="userpic" /></a></div>
	</div>
</div><div class="module-search module">
    <h2 class="module-header">Search</h2>
    <div class="module-content">
        <form id="search-blog" method="get" action="https://simonhaughton.typepad.com/.services/blog/6a0120a530561e970b012876745169970c/search" class="form-search form-inline" role="search">

            <input type="search" name="filter.q" results="5" value="" />
            <input type="submit" value="Search" />
            
        </form>
    </div>
</div>
<!-- END Blog Search Module -->

<div class="module-recent-comments-mb module">
	<h2 class="module-header">Recent Comments</h2>
	<div class="module-content">
		<ul class="module-list">
			<li class="module-list-item pkg">
            	<div class="comment-avatar">
            		<img id="comment-6a0120a530561e970b01bb09e712f9970d-avatarimg" src="https://static.typepad.com/.shared/default-userpics/14-50si.gif" alt="Daniel Ekanem" width="32" height="32" />
            	</div>	
            	<div class="comment-content">
    				<div class="comment-content-excerpt"><strong>Daniel Ekanem:</strong> Simon your resources have been fantastic. Thank... <span class="separator">|</span> <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html?cid=6a0120a530561e970b01bb09e712f9970d#comment-6a0120a530561e970b01bb09e712f9970d">more »</a></div>
    				<div class="comment-content-info">On <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html">Download my FREE primary computing curriculum:</a></div> 
    	        </div>
			</li>
			<li class="module-list-item pkg">
            	<div class="comment-avatar">
            		<img id="comment-6a0120a530561e970b01bb09d6f7a9970d-avatarimg" src="https://static.typepad.com/.shared/default-userpics/18-50si.gif" alt="Yo" width="32" height="32" />
            	</div>	
            	<div class="comment-content">
    				<div class="comment-content-excerpt"><strong>Yo:</strong> I think your curriculum is inspriational..  you... <span class="separator">|</span> <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html?cid=6a0120a530561e970b01bb09d6f7a9970d#comment-6a0120a530561e970b01bb09d6f7a9970d">more »</a></div>
    				<div class="comment-content-info">On <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html">Download my FREE primary computing curriculum:</a></div> 
    	        </div>
			</li>
			<li class="module-list-item last pkg">
            	<div class="comment-avatar">
            		<img id="comment-6a0120a530561e970b01b7c90073c9970b-avatarimg" src="https://static.typepad.com/.shared/default-userpics/07-50si.gif" alt="Evelyn Wangari" width="32" height="32" />
            	</div>	
            	<div class="comment-content">
    				<div class="comment-content-excerpt"><strong>Evelyn Wangari:</strong> Your ebook is very informative. Feeling inspire... <span class="separator">|</span> <a href="https://simonhaughton.typepad.com/main/how-to-teach-outstanding-computing.html?cid=6a0120a530561e970b01b7c90073c9970b#comment-6a0120a530561e970b01b7c90073c9970b">more »</a></div>
    				<div class="comment-content-info">On <a href="https://simonhaughton.typepad.com/main/how-to-teach-outstanding-computing.html">How to teach outstanding computing</a></div> 
    	        </div>
			</li>
		</ul>
	</div>
</div>

						    
<!-- sidebar -->







						</div>
					</div>
				</div>
			</div>			
		</div>
		</div>
	</div>
	<div id="footer">
	<div id="footer-inner">
		<ul>
			<li class="footer-link-syndicate"><a href="https://simonhaughton.typepad.com/main/atom.xml">Subscribe to this blog's feed</a></li>
			<li class="footer-link-poweredby"><a href="http://www.typepad.com/">Powered by Typepad</a></li>
		</ul>
	</div>
</div>

	





     










<script type="text/javascript">
<!--
var extra_happy = Math.floor(1000000000 * Math.random());
document.write('<img src="https://www.typepad.com/t/stats?blog_id=83446835060512524&amp;user_id=&amp;page=' + escape(location.href) + '&amp;referrer=' + escape(document.referrer) + '&amp;i=' + extra_happy + '" width="1" height="1" alt="" style="position: absolute; top: 0; left: 0;" />');
// -->
</script>

<!-- Google Analytics -->
<script>
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-28020544-1', 'auto');
ga('send', 'pageview');
</script>
<!-- End Google Analytics -->



<!-- Begin disqus Tag -->

<!-- End disqus Tag -->
</body>
</html>
<!-- ph=1 -->
)

## Otras propuestas

Se acerca la mano y los pájaros dan vueltas

<iframe allowfullscreen="allowfullscreen" height="314" id="bkmrk--1" src="//www.youtube.com/embed/6AWfzHgvX3I" width="560"></iframe>

Se acerca la mano y hacen giro hacia un sentido y luego otro

<iframe allowfullscreen="allowfullscreen" height="314" id="bkmrk--2" src="//www.youtube.com/embed/gxkK-kD4_9k" width="560"></iframe>

Interacción con algún objeto de Scratch

<iframe allowfullscreen="allowfullscreen" height="314" id="bkmrk--3" src="//www.youtube.com/embed/b5oM7UWnNHM" width="560"></iframe>