I spent last Saturday up at the Microsoft offices in Times Square observing a TEALS training session. My fried Nathaniel Granor, Teals Regional Manager in the east has invited me a number of times and this time I was able to make it.

If you don't know, TEALS is a program that takes volunteers in the tech industry and places them in classrooms. Unlike other programs, the TEALS volunteers work with the teachers while the kids learn some CS. The idea is that the teacher will learn about CS from the volunteer and the volunteer will learn something about teaching.

It's not the same as having a strong, knowledgeable CS teacher in the classroom but until we get there, TEALS is doing great work giving kids something that they need and otherwise wouldn't get.

At one point, Nathaniel started to talk to the volunteers about lesson plans emphasizing the fact that TEALS would provide all the lesson materials and the plans so these new to teaching tech volunteers wouldn't have to make curricular decisions.

The lesson plan form was pretty traditional and pretty formulaic:

• warm up
• hook
• instruction
• practice
• Assessment

Very similar to what I was shown back in the day during my two day "teaching boot camp" that kicked off my career ¹ and very appropriate as an effective and efficient way to prepare these volunteers for their first days.

This got me thinking about my lesson planning over the years.

When I started, I was teaching math but I wasn't really a math guy - I was CS all the way. I had to remember the math from high school, learn the new topics, and figure out how to teach it.

I had a very supportive department but they were busy with their own classes and this was pre internet. Fortunately, the NYC DOE published lesson plan books. They were basically bound volumes of xerox copies of hand written and typed lesson plans provided by experienced teachers.

I spent many hours copying them, studying them, and then later tweaking them.

They were a life saver back then. How was the teaching? OK. Not great. I got the material to the kids but I was nothing special. This is where I started to form my bias against the scripted teaching that's being pushed down today.

As I developed my chops, I started to design my own experiences for my classes and things improved. By the time I was done teaching math - maybe 4 years in, I was just scratching the surface of being a math teacher.

One year in, I started teaching CS along with math at Seward Park. When I was bumped to Stuy, I went back to math for a year and a half and then it was all CS all the time.

For CS, we didn't have lesson plan books so I had to craft everything from scratch. It was a lot of work but the results were much better.

At first, I would actually write out lesson plans a la math lesson plans. A "do now," "instructional objectives," "applications," "Homework," etc. The only thing I never formally wrote out was a "medial summary."

Over time, my lessons got better but my lesson plans looked worse and worse.

There were times a lesson plan might look something like this:

OK, not exactly but as I developed at my craft, I didn't need a laid out script to follow line for line rather, just a set of little reminders and maybe some printed out code. If we were going to develop a complicated algorithm or derivation, though, I would still write out all the steps.

This doesn't mean that as my career progressed I planned any less. It might appear that I'm winging it but even if little to nothing is written down, there is a plan and there's always a lot of pre work before class begins.

Now, to bring this back to TEALS.

It's interesting how what's good in one context is not so much in another.

What TEALS is doing is great - they've got to get a lot of technologists in to classrooms quickly but once there, they'll be with real, hopefully experienced teachers. What they're doing gets them ready to go. It's a starting point, not an end.

On the other hand, when I see scripted curriculum being sold as the special sauce, be it in CS teacher "training," Teach for America summer prep or in the name of charter school uniformity, I run the other way.

Let's prepare curricular materials for important programs like TEALS and for beginning teachers just starting out but let's not confuse a scripted lesson that can be delivered by one and all to be anything close to the work of a master educator and craftsman.

This video is all about using incremental search to navigate through your emacs buffers.

You can use the default incremental searchb, bound to C-s for isearch-forward C-r to search backwards (reverse).

They work really well as is but I prefer using Swiper. The video demos both and the Swiper home page has loads of details.

Part of the Swiper package includes ivy and counsel which I use instead of ido.

The video also mentions lorem-ipsum mode for generating text quickly and describe-mode in the help system.

Here's the code we added for swiper:

;; it looks like counsel is a requirement for swiper
(use-package counsel
  :ensure t
  )

(use-package swiper
  :ensure try
  :config
  (progn
    (ivy-mode 1)
    (setq ivy-use-virtual-buffers t)
    (global-set-key "\C-s" 'swiper)
    (global-set-key (kbd "C-c C-r") 'ivy-resume)
    (global-set-key (kbd "<f6>") 'ivy-resume)
    (global-set-key (kbd "M-x") 'counsel-M-x)
    (global-set-key (kbd "C-x C-f") 'counsel-find-file)
    (global-set-key (kbd "<f1> f") 'counsel-describe-function)
    (global-set-key (kbd "<f1> v") 'counsel-describe-variable)
    (global-set-key (kbd "<f1> l") 'counsel-load-library)
    (global-set-key (kbd "<f2> i") 'counsel-info-lookup-symbol)
    (global-set-key (kbd "<f2> u") 'counsel-unicode-char)
    (global-set-key (kbd "C-c g") 'counsel-git)
    (global-set-key (kbd "C-c j") 'counsel-git-grep)
    (global-set-key (kbd "C-c k") 'counsel-ag)
    (global-set-key (kbd "C-x l") 'counsel-locate)
    (global-set-key (kbd "C-S-o") 'counsel-rhythmbox)
    (define-key read-expression-map (kbd "C-r") 'counsel-expression-history)
    ))

and we commented out the ido stuff:

;; using swiper so ido no longer needed
;;(setq ido-enable-flex-matching t)
;;(setq ido-everywhere t)
;;(ido-mode 1)

If you want to see a nice video specifically on swiper by the author, here it is:

Relevant links:

• Swiper: https://github.com/abo-abo/swiper
• The Swiper Manual: http://oremacs.com/swiper/
• Video series overview page:
  • http://cestlaz.github.io/stories/emacs
• Code for this video:
  • https://github.com/zamansky/using-emacs/tree/lesson-6-swiper
• Complete code built up over all videos:
  • https://github.com/zamansky/using-emacs/tree/master

Sorry for the delay in getting this next video / post up. I spent the last part of last week at The Personal Democracy Forum 2016 which is really an exceptional conference.

I posted a bit about it in my last post and plan to write some more on it, but for now, more Emacs.

This video concerns using windows. By using buffers and windows and the basics you got from the tutorial, you shouldn't have to ever leave emacs.

From here, we'll be able to start going over effective Emacs and then using it for things like development or document creation.

Some of the key window bindings:

You also have frames which use C-x 5 as the prefix, so C-x 5 2 creats a new frame and C-x 5 1 closes the other frames.

Remember, you can always use the help system, in particular C-x k to describe a key and C-x f to describe a function.

C-x o can be a little clunky so some people like to use windmove which lets you move between windows by holding the shift key and with the arrows. To set that up, you can add this to your init.el

(windmove-default-keybindings)

I prefer using ace-window mode which still uses C-x o:

; add this to init.el
(use-package ace-window
  :ensure t
  :init
  (progn
    (global-set-key [remap other-window] 'ace-window)
    (custom-set-faces
     '(aw-leading-char-face
       ((t (:inherit ace-jump-face-foreground :height 3.0))))) 
    ))

The other mode I mention in the video is winner mode:

(winner-mode 1)

Which will allow you to use C-c left or right to move through past window configurations.

Relevant links:

• Ace window mode: https://github.com/abo-abo/ace-window
• Video series overview page:
  • http://cestlaz.github.io/stories/emacs
• Code for this video:
  • https://github.com/zamansky/using-emacs/tree/lesson-5-windows
• Complete code built up over all videos:
  • https://github.com/zamansky/using-emacs/tree/master

Many people think of Emacs as an editor. I like to think of it as an Elisp interpreter where you live code documents.

In some ways, it's like those new fangled interactive programming environments where you type in code and the updates are reflected instantly.

In this video, I try to explain the way I think about Emacs and why it's so cool.

The only change we made to our configuration was adding:

(tool-bar-mode -1)  

Which gets rid of the tool bar at the top.

Next time, we start talking about efficiently using Emacs.

Relevant links:

• Video series overview page:
  • http://cestlaz.github.io/stories/emacs
• Code for this video:
  • https://github.com/zamansky/using-emacs/tree/lesson-3-elisp
• Complete code built up over all videos:
  • https://github.com/zamansky/using-emacs/tree/master

Now that we're past the intro material, we'll start looking at emacs features one at a time. This will let you focus on using the one feature we're covering, fit it into your work flow, and really get comfortable with it.

This time we'll dive into using Emacs effectively with buffers.

Watch the video and then make a real effort to use buffers over the next few emacs sessions. Before you know it, they'll be a natural part of your work flow.

The idea of incrementally learning a tool this way seems to be called developing micro-habits and I first read about the idea from Sacha Chua who is an amazing member of the emacs community.

When seeing beginners, I'll frequently observe this work flow:

• Open a terminal
• Load emacs on a file
• Edit the file
• Save and quit emacs
• Try to compile and run the program (since usually this is in a programming class)
• repeat

If the beginner needs to see multiple files at once, they fire up multiple separate emacs.

All of this causes me physical pain.

In emacs, your editor can load several buffers at once, each associated with a separate file. You can quickly switch between them, search across them, and more. The video will get you started.

The video also mentions ido mode. To set up ido mode, add the following code to your init.el:

(setq ido-enable-flex-matching t)
(setq ido-everywhere t)
(ido-mode 1)

And here's a great little write up on it by Mickey Petersen:

https://www.masteringemacs.org/article/introduction-to-ido-mode

As I mentioned in the video, I actually use another mode for completions (swiper), which I'll cover in a future video and another popular option is helm which we'll also cover.

For buffers, the keys to remember are:

To use ibuffer, which is more powerful than list-buffers you can add either:

(defalias 'list-buffers 'ibuffer) ; make ibuffer default

Or if you want to open ibuffer in another Window:

(defalias 'list-buffers 'ibuffer-other-window) ; make ibuffer default

Here are a couple of useful links on ibuffer and buffer switching:

• http://ergoemacs.org/emacs/emacs_buffer_switching.html
• https://mytechrants.wordpress.com/2010/03/25/emacs-tip-of-the-day-start-using-ibuffer-asap/

Finally, if you like a tab bar, you can add the following to your init.el:

(use-package tabbar
  :ensure t
  :config (tabbar-mode 1)
)

There's also a package tabbar-ruler which is supposed to make the tabbar look nicer but since I don't use the tabbar at all, I haven't checked it out.

Hope this gets you using emacs more effectively.

Stay tuned for our next video on window management.

Relevant links:

• Video series overview page:
  • http://cestlaz.github.io/stories/emacs
• Code for this video:
  • https://github.com/zamansky/using-emacs/tree/lesson-4-buffers
• Complete code built up over all videos:
  • https://github.com/zamansky/using-emacs/tree/master

This video is a brief introduction to org-mode, a mode I use for all sorts of things.

We'll dive into org-mode later in the series. Right now I just want you to see the basics since we'll be using org-mode for any notes that are written up during this series.

Actually, all my blog posts are written in org-mode.

Here are the important lines to add to your Emacs init.el file to get the nice looking bullets when in org-mode:

(use-package org-bullets
  :ensure t
  :config
  (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))

About a month ago, Emacs user Harry Schwartz gave a nice overview talk on org-mode. If you want to get a better idea as to all the things you can do with it, check it out: https://www.youtube.com/watch?v=SzA2YODtgK4

Next time, we'll look at a little Elisp. After that, we'll dive in to using Emacs effectively and efficiently.

Relevant links:

• Video series overview page:
  • http://cestlaz.github.io/stories/emacs
• Code for this video:
  • https://github.com/zamansky/using-emacs/tree/lesson-2-org
• Complete code built up over all videos:
  • https://github.com/zamansky/using-emacs/tree/master
• Packages
  • org-bullets