A Better Planet Emacs

sachachua: How to Learn Emacs: A Hand-drawn One-pager for Beginners

Sacha Chua — Fri, 17 May 2013 19:45:00 +0000

I thought I’d draw some of the things that people often ask me about or that would help people learn Emacs (and enjoy it). You can click on the image for a larger version that you can scroll through or download. It should print all right on 8.5×11″ paper (landscape) if you want to keep it around as a reminder. Might even work at 11×17″. =)

You can find the image on Imgur and Flickr too.

Feel free to share, reuse, or modify this under the Creative Commons Attribution Licence. Enjoy!

Possibly counterintuitive point: It’s good to learn at least the basics of Vim. Despite the perception of a “Emacs vs. Vi” holy war (one of the classic battles in computer science), it makes sense to know both editors especially if you work with people who use Vi a lot. Know enough Vi to find your way around, and then learn how to customize Emacs to fit you to a tee. That way, you’ll avoid the pressure of not being able to work well with your team or your infrastructure, and you’ll have the space to explore Emacs. =) Emacs is totally awesome.

Need help with Emacs? Feel free to leave a comment or get in touch with me. I’m often in the #emacs channel on irc.freenode.net , and I also occasionally schedule time to help people one-on-one. Also, the Emacs community (mailing lists, newsgroups, IRC channel) can be wonderful, so definitely reach out to them too. =)

Meta discussion: How can I make this even better? What else would you like me to draw a guide for? I’d love to hear your thoughts! Also, thanks to dash, nicferrier, fledermaus, ijp, hypnocat, Fuco, macrobat, taylanub, axrfnu, Sebboh, thorkill, jave_, jrm, and the rest of #emacs for suggestions and feedback!

Update 2013-05-18: Check out the conversations on Hacker News and Reddit!

Read the original or check out the comments on: How to Learn Emacs: A Hand-drawn One-pager for Beginners (Sacha Chua's blog)

Irreal: Key-Chord Mode

jcs — Fri, 17 May 2013 10:52:53 +0000

One of my favorite Emacs Rocks! videos is #7, Mind Exploded, in which Sveen talks about key-chord mode. Right after I saw the video, I loaded key-chord-mode, wrote about it, and have been using it ever since. I’m mentioning it again because Eric Ritz recently posted about it.

Ritz’s post is an exhortation for Emacs users to give key-chord-mode a try. He mentions how he uses it and suggests some strategies for picking chords. You may or may not find his use cases and suggested chords compelling but you’re almost sure to find the mode itself very useful. You can see my own use cases and chords in my previous post about it and, of course, you should watch the Emacs Rocks! video for some more.

Although some Emacs users apparently are put off by the idea of key chords, I find the idea a huge win. I originally mapped jump-char-forward to 【Hyper+f】 and still maintain that mapping but after Sveen’s video I also mapped it to 【f g】, the chord he suggested. I can’t remember the last time I used 【Hyper+f】 because the chord is so much easier, faster, and natural.

Giorgos Keramidas: Powerful Regular Expressions Combined with Lisp in Emacs

keramida — Thu, 16 May 2013 16:04:58 +0000

Regular expressions are a powerful text transformation tool. Any UNIX geek will tell you that. It’s so deeply ingrained into our culture, that we even make jokes about it. Another thing that we also love is having a powerful extension language at hand, and Lisp is one of the most powerful extension languages around (and of course, we make jokes about that too).

Emacs, one of the most famous Lisp applications today, has for a while now the ability to combine both of these, to reach entirely new levels of usefulness. Combining regular expressions and Lisp can do really magical things.

An example that I recently used a few times is parsing & de-humanizing numbers in dstat output. The output of dstat includes numbers that are printed with a suffix, like ‘B’ for bytes, ‘k’ for kilobytes and ‘M’ for megabytes, e.g.:

----system---- ----total-cpu-usage---- --net/eth0- -dsk/total- sda-
     time     |usr sys idl wai hiq siq| recv  send| read  writ|util
16-05 08:36:15|  2   3  96   0   0   0|  66B  178B|   0     0 |   0
16-05 08:36:16| 42  14  37   0   0   7|  92M 1268k|   0     0 |   0
16-05 08:36:17| 45  11  36   0   0   7|  76M 1135k|   0     0 |   0
16-05 08:36:18| 27  55   8   0   0  11|  67M  754k|   0    99M|79.6
16-05 08:36:19| 29  41  16   5   0  10| 113M 2079k|4096B   63M|59.6
16-05 08:36:20| 28  48  12   4   0   8|  58M  397k|   0    95M|76.0
16-05 08:36:21| 38  37  14   1   0  10| 114M 2620k|4096B   52M|23.2
16-05 08:36:22| 37  54   0   1   0   8|  76M 1506k|8192B   76M|33.6

So if you want to graph one of the columns, it’s useful to convert all the numbers in the same unit. Bytes would be nice in this case.

Separating all columns with ‘|’ characters is a good start, so you can use e.g. a CSV-capable graphing tool, or even simple awk scripts to extract a specific column. ‘C-x r t’ can do that in Emacs, and you end up with something like this:

|     time     |cpu|cpu|cpu|cpu|cpu|cpu|eth0 |eth0 | disk| disk|sda-|
|     time     |usr|sys|idl|wai|hiq|siq| recv| send| read| writ|util|
|16-05 08:36:15|  2|  3| 96|  0|  0|  0|  66B| 178B|   0 |   0 |   0|
|16-05 08:36:16| 42| 14| 37|  0|  0|  7|  92M|1268k|   0 |   0 |   0|
|16-05 08:36:17| 45| 11| 36|  0|  0|  7|  76M|1135k|   0 |   0 |   0|
|16-05 08:36:18| 27| 55|  8|  0|  0| 11|  67M| 754k|   0 |  99M|79.6|
|16-05 08:36:19| 29| 41| 16|  5|  0| 10| 113M|2079k|4096B|  63M|59.6|
|16-05 08:36:20| 28| 48| 12|  4|  0|  8|  58M| 397k|   0 |  95M|76.0|
|16-05 08:36:21| 38| 37| 14|  1|  0| 10| 114M|2620k|4096B|  52M|23.2|
|16-05 08:36:22| 37| 54|  0|  1|  0|  8|  76M|1506k|8192B|  76M|33.6|

The leading and trailing ‘|’ characters are there so we can later use orgtbl-mode, an awesome table editing and realignment tool of Emacs. Now to the really magical step: regular expressions and lisp working together.

What we would like to do is convert text like “408B” to just “408″, text like “1268k” to the value of (1268 * 1024), and finally text like “67M” to the value of (67 * 1024 * 1024). The first part is easy:

M-x replace-regexp RET \([0-9]+\)B RET \1 RET

This should just strip the “B” suffix from byte values.

For the kilobyte and megabyte values what we would like is to be able to evaluate an arithmetic expression that involves \1. Something like “replace \1 with the value of (expression \1)“. This is possible in Emacs by prefixing the substitution pattern with \,. This instructs Emacs to evaluate the rest of the substitution pattern as a Lisp expression, and use its string representation as the “real” substitution text.

So if we match all numeric values that are suffixed by ‘k’, we can use (string-to-number \1) to convert the matching digits to an integer, multiply by 1024 and insert the resulting value by using the following substitution pattern:

\,(* 1024 (string-to-number \1))

The full Emacs command would then become:

M-x replace-regexp RET \([0-9]+\)k RET \,(* 1024 (string-to-number \1)) RET

This, and the byte suffix removal, yield now the following text in our Emacs buffer:

|     time     |cpu|cpu|cpu|cpu|cpu|cpu|eth0 |eth0 | disk| disk|sda-|
|     time     |usr|sys|idl|wai|hiq|siq| recv| send| read| writ|util|
|16-05 08:36:15|  2|  3| 96|  0|  0|  0|  66| 178|   0 |   0 |   0|
|16-05 08:36:16| 42| 14| 37|  0|  0|  7|  92M|1298432|   0 |   0 |   0|
|16-05 08:36:17| 45| 11| 36|  0|  0|  7|  76M|1162240|   0 |   0 |   0|
|16-05 08:36:18| 27| 55|  8|  0|  0| 11|  67M| 772096|   0 |  99M|79.6|
|16-05 08:36:19| 29| 41| 16|  5|  0| 10| 113M|2128896|4096|  63M|59.6|
|16-05 08:36:20| 28| 48| 12|  4|  0|  8|  58M| 406528|   0 |  95M|76.0|
|16-05 08:36:21| 38| 37| 14|  1|  0| 10| 114M|2682880|4096|  52M|23.2|
|16-05 08:36:22| 37| 54|  0|  1|  0|  8|  76M|1542144|8192|  76M|33.6|

Note: Some of the columns are indeed not aligned very well. We’ll fix that later. On to the megabyte conversion:

M-x replace-regexp RET \([0-9]+\)M RET \,(* 1024 1024 (string-to-number \1)) RET

Which produces a version that has no suffixes at all:

|     time     |cpu|cpu|cpu|cpu|cpu|cpu|eth0 |eth0 | disk| disk|sda-|
|     time     |usr|sys|idl|wai|hiq|siq| recv| send| read| writ|util|
|16-05 08:36:15|  2|  3| 96|  0|  0|  0|  66| 178|   0 |   0 |   0|
|16-05 08:36:16| 42| 14| 37|  0|  0|  7|  96468992|1298432|   0 |   0 |   0|
|16-05 08:36:17| 45| 11| 36|  0|  0|  7|  79691776|1162240|   0 |   0 |   0|
|16-05 08:36:18| 27| 55|  8|  0|  0| 11|  70254592| 772096|   0 |  103809024|79.6|
|16-05 08:36:19| 29| 41| 16|  5|  0| 10| 118489088|2128896|4096|  66060288|59.6|
|16-05 08:36:20| 28| 48| 12|  4|  0|  8|  60817408| 406528|   0 |  99614720|76.0|
|16-05 08:36:21| 38| 37| 14|  1|  0| 10| 119537664|2682880|4096|  54525952|23.2|
|16-05 08:36:22| 37| 54|  0|  1|  0|  8|  79691776|1542144|8192|  79691776|33.6|

Finally, to align everything in neat, pipe-separated columns, we enable M-x orgtbl-mode, and type “C-c C-c” with the pointer somewhere inside the transformed dstat output. The buffer now becomes something usable for pretty-much any graphing tool out there:

| time           | cpu | cpu | cpu | cpu | cpu | cpu |      eth0 |    eth0 |  disk |      disk | sda- |
| time           | usr | sys | idl | wai | hiq | siq |      recv |    send |  read |      writ | util |
| 16-05 08:36:15 |   2 |   3 |  96 |   0 |   0 |   0 |        66 |     178 |     0 |         0 |    0 |
| 16-05 08:36:16 |  42 |  14 |  37 |   0 |   0 |   7 |  96468992 | 1298432 |     0 |         0 |    0 |
| 16-05 08:36:17 |  45 |  11 |  36 |   0 |   0 |   7 |  79691776 | 1162240 |     0 |         0 |    0 |
| 16-05 08:36:18 |  27 |  55 |   8 |   0 |   0 |  11 |  70254592 |  772096 |     0 | 103809024 | 79.6 |
| 16-05 08:36:19 |  29 |  41 |  16 |   5 |   0 |  10 | 118489088 | 2128896 |  4096 |  66060288 | 59.6 |
| 16-05 08:36:20 |  28 |  48 |  12 |   4 |   0 |   8 |  60817408 |  406528 |     0 |  99614720 | 76.0 |
| 16-05 08:36:21 |  38 |  37 |  14 |   1 |   0 |  10 | 119537664 | 2682880 |  4096 |  54525952 | 23.2 |
| 16-05 08:36:22 |  37 |  54 |   0 |   1 |   0 |   8 |  79691776 | 1542144 |  8192 |  79691776 | 33.6 |

The trick of combining arbitrary Lisp expressions with regexp substitution patterns like \1, \2 … \9 is something I have found immensely useful in Emacs. Now that you know how it works, I hope you can find even more amusing use-cases for it.

Update: The Emacs manual has a few more useful examples of \, in action, as pointed out by tunixman on Twitter.

Filed under: Computers, Emacs, Free software, FreeBSD, GNU/Linux, Lisp, Open source, Programming, Software Tagged: Computers, Emacs, Free software, FreeBSD, GNU/Linux, Lisp, Open source, Programming, Software

Phil Hagelberg: in which a turtle moves things forward

Phil Hagelberg — Wed, 15 May 2013 18:09:44 +0000

Recently on the Clojure mailing list someone started an interesting thread on what motivates you as a programmer. My friend Nelson Morris responded as so:

Contributions and projects start off well, and energy might wane depending on time and life factors. Even contributing to tools used by many of the members of the community like [Leiningen] and Clojars doesn't prevent it. What helps is direct involvement by someone else.

This really resonated with me because it emphasizes that people are more important than programs. For me sharing is the thing that makes programming even worth doing in the first place. So it got me thinking about different technologies and what kind of people they're good for helping.

If you follow my writing it will be obvious that I enjoy working in Emacs and Clojure. While these are among the most powerful, flexible technologies I know of, collaborating with others on tools for Emacs and Clojure basically limits me to working with professional programmers, because both environments are very poor from a beginner's perspective. If I'm working solo or on a team of seasoned hackers, I'll definitely be most effective with Clojure. If my primary goal is to interact with the widest group of programmers possible, I would use Ruby as it's the most commonly-used language I can bring myself to use. But if I want to reach out to people who don't already spend all day thinking about functions and data structures, well that's another thing entirely.

This is particularly relevant for me personally as a father. I'm taking an active role in the education of my sons, and of course I think technical literacy must be an important part of it. But when you look at how computers used in traditional educational settings, you're much more likely to see computers programming children than children programming computers. So I've been looking for ways to foster technical skills and encourage algorithmic thinking in engaging ways that can keep the attention of my five-year-old.

In the book Mindstorms, Seymour Papert describes the shift from concrete reasoning to formal reasoning as one of the main transitions children undergo as they learn to think like adults. One of the design goals of the Logo system he created was to provide transitional concepts to bridge the gap between the two.

Children interact with Logo by giving commands to an onscreen object known as the turtle. While the turtle lives in the abstract world of geometry comprised of points and lines, children are able to identify with it since they tell it to move in ways which they can relate to—it has a heading and position, and it turns and moves forward and backwards just like they do. Because the turtle's movements on the screen are isomorphic to their own physical movements, it gives them a model to help them grasp abstract geometrical concepts though they're only used to thinking in concrete terms. And Piagetian learning—ambient, natural learning which children are so adept at doing without study—is all a matter of building models of the world.

Most people know Logo from its original triangle-turtle-centric incarnation, but in Mindstorms Papert describes Logo as more of an educational philosophy than any single program, language, or implementation. A more recent version of Logo is Scratch, a drag-and-drop visual programming environment from MIT's Media Lab targeting school children. Since my older son is an early reader he's been able to construct simple scripts (with some guidance) for the characters within Scratch, watching them interact with each other and even in some cases the outside world.

While it's been lots of fun to come up with ideas and talk through how we'd bring them to life on the screen, one of the most rewarding parts is watching his problem-solving abilities develop. Papert talks about how children are often afraid to try things for fear of failure, but Scratch teaches that debugging is a normal part of making things work. Rather than "does it work", the question becomes "how can we make it work?" This was demonstrated the other day (outside the context of Scratch) when he was putting together some Snap Circuits:

Of course the goal is not to produce "little programmers". It's primarily about developing the ability to think systematically, but it extends beyond that into getting them thinking about thinking itself. In some sense once they're in the habit of asking the right epistemological questions, the parent or teacher almost just needs to get out of the way and let them explore. At that point the process of discovering a topic with someone is much more rewarding than telling facts at them.

Irreal: Emacs Hash Tables

jcs — Wed, 15 May 2013 10:57:09 +0000

One of the most useful data structures in Computer Science is the hash table. I’ve been using them for my entire career and have implemented close to a hundred instances in several languages. That’s not as necessary these days as most modern languages—and some not so modern languages such as Lisp—have them as a built-in data type.

Happily, Elisp is one of those languages. If you’re not already familiar with the Emacs implementation of hash tables, you can get the details in the manual (of course) but Xah Lee has an excellent overview that will get you up and running quickly. There’s not much to learn and hash tables are incredibly useful when you need a fast look up data structure so give Lee’s post a look and see if they can be useful to you.

Grant Rettke: Keep track of scoping type in Emacs Lisp Buffers

Grant — Sun, 12 May 2013 22:15:58 +0000

Here is how: lexbind-mode

emacspeak: Emacspeak 38.0 (FreeDog Unleashed

T. V. Raman — Sun, 12 May 2013 15:13:09 +0000

Emacspeak 38.0—FreeDog—Unleashed!

1 Emacspeak-38.0 (FreeDog) Unleashed!

** For Immediate Release:

San Jose, Calif., (May 13, 2013) Emacspeak: Redefining Accessibility In The Era Of Cloud Computing –Zero cost of upgrades/downgrades makes priceless software affordable!

Emacspeak Inc (NASDOG: ESPK) --http://emacspeak.sf.net-- announces the immediate world-wide availability of Emacspeak 38.0 (FreeDog) –a powerful audio desktop for leveraging today's evolving data, social and service-oriented Web cloud.

1.1 Investors Note:

With several prominent tweeters expanding coverage of #emacspeak, NASDOG: ESPK has now been consistently trading over the social net at levels close to that once attained by DogCom high-fliers—and as of May 2013 is trading at levels close to that achieved by once better known stocks in the tech sector.

1.2 What Is It?

Emacspeak is a fully functional audio desktop that provides complete eyes-free access to all major 32 and 64 bit operating environments. By seamlessly blending live access to all aspects of the Internet such as Web-surfing, blogging, social computing and electronic messaging into the audio desktop, Emacspeak enables speech access to local and remote information with a consistent and well-integrated user interface. A rich suite of task-oriented tools provides efficient speech-enabled access to the evolving service-oriented social Web cloud.

1.3 Major Enhancements:

Get directions and find Places via Google Maps. ⛯
Preliminary support for Eclipse integration via Eclim. ⛅
Speech-enabled GTags (Global) for code browsing. 🌐
Updated to work with advice implementation in Emacs 24.3. 🌚
Updated Web search wizards ꩜
Updated URL templates ♅

Plus many more changes too numerous to fit in this margin ∞

1.4 Establishing Liberty, Equality And Freedom:

Never a toy system, Emacspeak is voluntarily bundled with all major Linux distributions. Though designed to be modular, distributors have freely chosen to bundle the fully integrated system without any undue pressure—a documented success for the integrated innovation embodied by Emacspeak. As the system evolves, both upgrades and downgrades continue to be available at the same zero-cost to all users. The integrity of the Emacspeak codebase is ensured by the reliable and secure Linux platform used to develop and distribute the software.

Extensive studies have shown that thanks to these features, users consider Emacspeak to be absolutely priceless. Thanks to this wide-spread user demand, the present version remains priceless as ever—it is being made available at the same zero-cost as previous releases.

At the same time, Emacspeak continues to innovate in the area of eyes-free social interaction and carries forward the well-established Open Source tradition of introducing user interface features that eventually show up in luser environments.

On this theme, when once challenged by a proponent of a crash-prone but well-marketed mousetrap with the assertion "Emacs is a system from the 70's", the creator of Emacspeak evinced surprise at the unusual candor manifest in the assertion that it would take popular idiot-proven interfaces until the year 2070 to catch up to where the Emacspeak audio desktop is today. Industry experts welcomed this refreshing breath of Courage Certainty and Clarity (CCC) at a time when users are reeling from the Fear Uncertainty and Doubt (FUD) unleashed by complex software systems backed by even more convoluted press releases.

1.5 Independent Test Results:

Independent test results have proven that unlike some modern (and not so modern) software, Emacspeak can be safely uninstalled without adversely affecting the continued performance of the computer. These same tests also revealed that once uninstalled, the user stopped functioning altogether. Speaking with Aster Labrador, the creator of Emacspeak once pointed out that these results re-emphasize the user-centric design of Emacspeak; "It is the user –and not the computer– that stops functioning when Emacspeak is uninstalled!".

1.5.1 Note from Aster,Bubbles and Tilden:

UnDoctored Videos Inc. is looking for volunteers to star in a video demonstrating such complete user failure.

1.6 Obtaining Emacspeak:

Emacspeak can be downloaded from Google Code Hosting –see http://code.google.com/p/emacspeak/ You can visit Emacspeak on the WWW at http://emacspeak.sf.net. You can subscribe to the emacspeak mailing list emacspeak@cs.vassar.edu by sending mail to the list request address emacspeak-request@cs.vassar.edu. The FreeDog release is at http://emacspeak.googlecode.com/files/emacspeak-38.0.tar.bz2. The latest development snapshot of Emacspeak is always available via Subversion from Google Code at http://emacspeak.googlecode.com/svn/trunk/

1.7 History:

Emacspeak 38.0 is the latest in a series of award-winning releases from Emacspeak Inc. Emacspeak 37.0 continues the tradition of delivering robust software as reflected by its code-name. Emacspeak 36.0 enhances the audio desktop with many new tools including full EPub support — hence the name EPubDog. Emacspeak 35.0 is all about teaching a new dog old tricks — and is aptly code-named HeadDog in honor of our new Press/Analyst contact. emacspeak-34.0 (AKA Bubbles) established a new beach-head with respect to rapid task completion in an eyes-free environment. Emacspeak-33.0 AKA StarDog brings unparalleled cloud access to the audio desktop. Emacspeak 32.0 AKA LuckyDog continues to innovate via open technologies for better access. Emacspeak 31.0 AKA TweetDog — adds tweeting to the Emacspeak desktop. Emacspeak 30.0 AKA SocialDog brings the Social Web to the audio desktop—you cant but be social if you speak! Emacspeak 29.0—AKAAbleDog—is a testament to the resilliance and innovation embodied by Open Source software—it would not exist without the thriving Emacs community that continues to ensure that Emacs remains one of the premier user environments despite perhaps also being one of the oldest. Emacspeak 28.0—AKA PuppyDog—exemplifies the rapid pace of development evinced by Open Source software. Emacspeak 27.0—AKA FastDog—is the latest in a sequence of upgrades that make previous releases obsolete and downgrades unnecessary. Emacspeak 26—AKA LeadDog—continues the tradition of introducing innovative access solutions that are unfettered by the constraints inherent in traditional adaptive technologies. Emacspeak 25 —AKA ActiveDog —re-activates open, unfettered access to online information. Emacspeak-Alive —AKA LiveDog —enlivens open, unfettered information access with a series of live updates that once again demonstrate the power and agility of open source software development. Emacspeak 23.0 – AKA Retriever—went the extra mile in fetching full access. Emacspeak 22.0 —AKA GuideDog —helps users navigate the Web more effectively than ever before. Emacspeak 21.0 —AKA PlayDog —continued the Emacspeak tradition of relying on enhanced productivity to liberate users. Emacspeak-20.0 —AKA LeapDog —continues the long established GNU/Emacs tradition of integrated innovation to create a pleasurable computing environment for eyes-free interaction. emacspeak-19.0 –AKA WorkDog– is designed to enhance user productivity at work and leisure. Emacspeak-18.0 –code named GoodDog– continued the Emacspeak tradition of enhancing user productivity and thereby reducing total cost of ownership. Emacspeak-17.0 –code named HappyDog– enhances user productivity by exploiting today's evolving WWW standards. Emacspeak-16.0 –code named CleverDog– the follow-up to SmartDog– continued the tradition of working better, faster, smarter. Emacspeak-15.0 –code named SmartDog–followed up on TopDog as the next in a continuing a series of award-winning audio desktop releases from Emacspeak Inc. Emacspeak-14.0 –code named TopDog–was the first release of this millennium. Emacspeak-13.0 –codenamed YellowLab– was the closing release of the 20th. century. Emacspeak-12.0 –code named GoldenDog– began leveraging the evolving semantic WWW to provide task-oriented speech access to Webformation. Emacspeak-11.0 –code named Aster– went the final step in making Linux a zero-cost Internet access solution for blind and visually impaired users. Emacspeak-10.0 –(AKA Emacspeak-2000) code named WonderDog– continued the tradition of award-winning software releases designed to make eyes-free computing a productive and pleasurable experience. Emacspeak-9.0 –(AKA Emacspeak 99) code named BlackLab– continued to innovate in the areas of speech interaction and interactive accessibility. Emacspeak-8.0 –(AKA Emacspeak-98++) code named BlackDog– was a major upgrade to the speech output extension to Emacs.

Emacspeak-95 (code named Illinois) was released as OpenSource on the Internet in May 1995 as the first complete speech interface to UNIX workstations. The subsequent release, Emacspeak-96 (code named Egypt) made available in May 1996 provided significant enhancements to the interface. Emacspeak-97 (Tennessee) went further in providing a true audio desktop. Emacspeak-98 integrated Internetworking into all aspects of the audio desktop to provide the first fully interactive speech-enabled WebTop.

About Emacspeak:

Originally based at Cornell (NY) http://www.cs.cornell.edu/home/raman –home to Auditory User Interfaces (AUI) on the WWW– Emacspeak is now maintained on GoogleCode --http://code.google.com/p/emacspeak —and Sourceforge —http://emacspeak.sf.net. The system is mirrored world-wide by an international network of software archives and bundled voluntarily with all major Linux distributions. On Monday, April 12, 1999, Emacspeak became part of the Smithsonian's Permanent Research Collection on Information Technology at the Smithsonian's National Museum of American History.

The Emacspeak mailing list is archived at Vassar –the home of the Emacspeak mailing list– thanks to Greg Priest-Dorman, and provides a valuable knowledge base for new users.

1.8 Press/Analyst Contact: Tilden Labrador

Going forward, Tilden acknowledges his exclusive monopoly on setting the direction of the Emacspeak Audio Desktop, and promises to exercise this freedom to innovate and her resulting power responsibly (as before) in the interest of all dogs.

**About This Release:

Windows-Free (WF) is a favorite battle-cry of The League Against Forced Fenestration (LAFF). –see http://www.usdoj.gov/atr/cases/f3800/msjudgex.htm for details on the ill-effects of Forced Fenestration.

CopyWrite )C( Aster and Hubbell Labrador. All Writes Reserved. HeadDog (DM), LiveDog (DM), GoldenDog (DM), BlackDog (DM) etc., are Registered Dogmarks of Aster, Hubbell and Tilden Labrador. All other dogs belong to their respective owners.

Joost Diepenmaat: New zeekat website design

Joost — Thu, 09 May 2013 07:52:39 +0000

This week, I re-implemented my main website. The text on the old one needed to be revised heavily (in fact I removed almost all of it except a short bio and some longer articles) and I wanted to experiment with a more colorful look. I need to revise the stylesheet a bit more to give a better experience on small screens (mobile), but so far I’m pleased with the result.

The new site html is generated completely by emacs’ org-mode project publishing functionality (the old one used a custom bunch of perl scripts generating from HTML snippets and perl POD documents). This hopefully means it’ll be easier to add and revise content, and it also provides nice syntax highlighting for any code snippets I put in my articles.

The whole switchover was pretty smooth, especially once I wrote a bit of elisp to roughly prepare conversion from POD formatting to org:

(defun pod2org (point mark) "Rougly convert region from pod syntax to org-mode" (interactive "r") (replace-regexp "C<\\([^>]+\\)>" "=\\1=" nil point mark) (replace-regexp "I<\\([^>]+\\)>" "/\\1/" nil point mark) (replace-regexp "B<\\([^>]+\\)>" "*\\1*" nil point mark) (replace-regexp "^=head1 \\(.*\\)" "* \\1" nil point mark) (replace-regexp "^=head2 \\(.*\\)" "** \\1" nil point mark) (replace-regexp "^=head3 \\(.*\\)" "*** \\1" nil point mark) (replace-regexp "^=head4 \\(.*\\)" "**** \\1" nil point mark) (replace-regexp "^=head5 \\(.*\\)" "***** \\1" nil point mark))

Very basic, but pretty useful.

Now, I’m considering replacing WordPress for this blog with org-mode too. That probably requires a bit more investigation. I want to keep at least the tags/categories feature and related rss feeds, and I’m not sure if that’s available for org at the moment.

Alex Schroeder: Distributing XP With Emacs

Alex Schroeder — Wed, 08 May 2013 13:17:38 +0000

This topic ties together two topics that probably don’t see too much overlap.

I play role-playing games of the D&D old school variety.
I use Emacs to help me do simple stuff on a daily basis.

The problem: the party of characters my players run is huge. Even if there are usually only around ten characters that are part of a single session, there are more than thirty primary and secondary characters on the status page. Given the wiki table for the status page, how can I quickly add up the correct XP and gold values? Any XP gained is shared equally amongst the characters that took part in the session but any gold gained is distributed according to each characters share. Primary characters get a full share, secondary characters get a third of a share.

I used Emacs widget mode to create a page like this:

XP total:   805          
Gold total: 7191         
[X] Schalk
[ ] Uluf
[ ] Witschik
[X] Schachtmann
[ ] Sirius
[X] Logard
[X] Arnd
[X] Tinaya
[ ] Pyrula
[ ] Pijo
[ ] Garo
[X] Zeta
[ ] Pipo
[X] Fusstritt
[ ] Thor
[ ] Jack
[ ] Gloria
[ ] Hermann
[ ] Urs
[ ] Alpha
[ ] Beta
[ ] Gamma
[ ] Boden
[ ] Basel
[ ] Bern
[X] Nuschka
[ ] Moranor
[ ] Axirios Hectaxius

[Go!]

And here’s the code to do it:

(defconst fünf-winde-regexp "^\\(|\\[\\[\\(.*?\\)\\]\\][ \t]*|[ \t]*\\(1\\|1/3\\)[ \t]*\\)|\\([ \t]*[0-9]+[ \t]*\\)|\\([ \t]*[0-9]+[ \t]*\\)"
  "Regular expression to parse the Status page.
\(let ((str (match-string 1))
      (name (match-string 2))
      (share (match-string 3))
      (xp (match-string 4))
      (gold (match-string 5)))
    ...\)")

(defvar fünf-winde-buf nil
  "Source buffer.")

(defvar fünf-winde-xp nil
  "XP share.")

(defvar fünf-winde-gold nil
  "Gold share.")

(defvar fünf-winde-party nil
  "Charakters in the party.")

(defun fünf-winde-xp-and-gold ()
  "Hand out Gold and XP."
  (interactive)
  (let ((buf (current-buffer))
	(names))
    (save-excursion
      (goto-char (point-min))
      (while (re-search-forward fünf-winde-regexp nil t)
	(setq names (cons (match-string 2) names))))
    (switch-to-buffer "*Fünf Winde*")
    (kill-all-local-variables)
    (set (make-local-variable 'fünf-winde-buf) buf)
    (make-local-variable 'fünf-winde-xp)
    (make-local-variable 'fünf-winde-gold)
    (make-local-variable 'fünf-winde-party)
    (let ((inhibit-read-only t))
      (erase-buffer))
    (remove-overlays)
    (setq fünf-winde-xp
	  (widget-create 'integer
			 :size 13
			 :format "XP total:   %v\n"
			 0))
    (setq fünf-winde-gold
	  (widget-create 'integer
			 :size 13
			 :format "Gold total: %v\n"
			 0))
    (setq fünf-winde-party
	  (apply 'widget-create 'checklist
		 (mapcar (lambda (name)
			   `(item ,name))
			 (nreverse names))))
    (widget-insert "\n")
    (widget-create 'push-button
		   :notify (lambda (&rest ignore)
			     (fünf-winde-process
			      fünf-winde-buf
			      (widget-value fünf-winde-xp)
			      (widget-value fünf-winde-gold)
			      (widget-value fünf-winde-party)))
		   "Go!")
    (widget-insert "\n")
    (use-local-map widget-keymap)
    (local-set-key (kbd "q") 'bury-buffer)
    (local-set-key (kbd "SPC") 'widget-button-press)
    (local-set-key (kbd "<left>") 'widget-backward)
    (local-set-key (kbd "<up>") 'widget-backward)
    (local-set-key (kbd "<right>") 'widget-forward)
    (local-set-key (kbd "<down>") 'widget-forward)
    (widget-setup)
    (goto-char (point-min))
    (widget-forward 1)))

(defun fünf-winde-process (buf total-xp total-gold party)
  (message "(fünf-winde-process (get-buffer \"%s\") %d %d '%S)"
	   buf total-xp total-gold party)
  (switch-to-buffer buf)
  (save-excursion
    (let ((xp-shares 0)
	  (xp-share nil)
	  (gold-shares 0)
	  (gold-share nil))
      (goto-char (point-min))
      (while (re-search-forward fünf-winde-regexp nil t)
	(let ((name (match-string 2))
	      (share (match-string 3)))
	  (when (member name party)
	    (setq gold-shares (+ gold-shares
				 (cond ((string= share "1/2") 0.5)
				       ((string= share "1/3") (/ 1.0 3))
				       (t (string-to-number share))))
		  xp-shares (1+ xp-shares)))))
      (setq gold-share (/ total-gold gold-shares)
	    xp-share (/ total-xp xp-shares))
      (goto-char (point-min))
      (while (re-search-forward fünf-winde-regexp nil t)
	(let ((str (match-string 1))
	      (name (match-string 2))
	      (share (match-string 3))
	      (xp (match-string 4))
	      (gold (match-string 5)))
	  (when (member name party)
	    (setq gold (format (concat "%9d")
			       (+  (string-to-number gold)
				   (* gold-share (cond ((string= share "1/2") 0.5)
						       ((string= share "1/3") (/ 1.0 3))
						       (t (string-to-number share))))))
		  xp (format (concat "%9d")
			     (+  (string-to-number xp)
				 xp-share)))
	    (replace-match (concat str
				   "|" xp
				   "|" gold))))))))

I’m not sure I’m spending my time wisely, but there you go. I used to have a simpler piece of code that helped me distribute XP and gold separately. The drawback was that it would ask me for every person in the table “was this character in the party? (y/n)” and that’s a lot of yes and no replies if you go through the list twice.

It’s also a stark reminder that simpler old rules doesn’t automatically mean less work for the referee. With D&D 3.5, I had a spreadsheet to compute the XP gained based on challenge rating and character level. It wasn’t something to do quickly without a book in front of me. Now the complexity of the task has been reduced, but the number of characters has exploded to compensate!

Tags: Emacs RPG Old School

Rafael: Org mode 8.0

Rafael — Sun, 05 May 2013 20:41:00 +0000

Org mode was updated recently to version 8.0, and together with many great features, an unfortunate consequence it brought is that many lovely features of org2blog/wp no longer work. There is hope for the future, but in the meantime, I will post with Emacs 24.3.1, and the org-mode that comes with it (Org-mode version 7.9.3f).

Got Emacs?: Traditional May 1st Gnus Release out

sivaram — Fri, 03 May 2013 15:44:34 +0000

A bit late in posting about it but Lars has released MaGnus 0.7 with bug fixes and some improvements. The Changelog in the link has the details

Emacs Movies: Gnus part 1

Noufal Ibrahim — Mon, 29 Apr 2013 16:18:48 +0000

I’ve picked up something this time which I’ve always wanted to study properly – Gnus. The Emacs news and email reader. This is going to be a multipart episode since Gnus is so big. I don’t know how many exactly but as of now, I’ve got a 3 part thing planned.

Also, the hiatus was unexpected. Things should be smoother now.

Other formats are available on the Archive.org page.

Comments welcome.

Summary

The gnus-select-method variable decides where to pick news from.
M-x gnus starts gnus.
g refreshes subsribed groups.
F looks for new groups.
^ takes you into the server buffer.
RET will do different things depending on where you are. On a group, it will show you articles in the group.
t toggles topics in the Groups buffer.
L shows all groups (including ones with no unread articles).
l shows only groups with no unread articles.
c catches up a group marking all articles as read.
U is used to subscribe to a group.
Information on groups and articles in cached in the .newsrc.eld file which you shouldn’t delete.
Gnus uses .gnus as a startup file.
gnus-secondary-select-methods is the variable that controls sources other than the primary one mentioned in gnus-select-method. Mail sources usually come here.
The mail-sources variable specify where the mail backends should pick data up from.
The nnmail-split-methods function can be used to split mail depending on criteria like sender etc.

Extras

The recipe used to generate the mailbox.

Alex Schroeder: Emacs Wiki Redesign

Alex Schroeder — Fri, 26 Apr 2013 12:42:35 +0000

I finally installed the new theme for Emacs Wiki. Feel free to leave comments on the Talk page. Bootstrap allows me to make all the changes at run-time, ie. add a few scripts including a script that changes the wiki’s HTML (emacs-bootstrap.js) and a new CSS file (bootstrap.css).

Since no changes to the script are necessary I can continue to provide the old theme for those that don’t feel like switching.

Tags: Emacs

Got Emacs?: GNU Emacs Contributing Guide

sivaram — Thu, 25 Apr 2013 16:42:58 +0000

If you ever wanted to contribute to Gnu Emacs development and didn't know where to start, well, worry no more. Here's the first draft of it that will be soon be on the Emacs Web pages, thanks to Xue Fuqiao.

If this encourages more people to develop on and for Emacs, it'd be worth it.

Aaron Hawley: Big Emacs reference card updated

Aaron S. Hawley — Wed, 24 Apr 2013 16:18:44 +0000

With the release of Emacs 24.3 last month and the big changes at EmacsWiki, I've posted an updated version of the giant Emacs reference card. It now contains new sections on Calendar mode, Ediff and Abbrev mode. There are also new example commands for keyboard macros, Dired Mode, Occur Mode, table.el and Calc.

There are now more than 2000 commands up from 1500. It should also be consistent with the latest version of Emacs.

It is released under a bunch of free licenses, including version 2 or later of the GNU GPL and version 1.2 or later of the GNU FDL, so people are free to share and modify it.

Bozhidar Batsov: WikEmacs lives on under new stewardship

Bozhidar Batsov — Wed, 24 Apr 2013 08:36:00 +0000

Several months passed since I stated my intent to shutdown WikEmacs. While I still consider the project a failed experiment and stand by everything I wrote in that post, I have received since lots of messages from people who were sad to see WikEmacs go. One person in particular, Jesse Johnson, was committed to seeing the project move forward and offered to take over its stewardship.

In the end I’ve decided that in spirit of the FOSS ideals I don’t have the right to take away something people like and want to use(especially given the fact that they contributed most of the content there) and handed over the domain and the data to Jesse.

WikEmacs has been running for a couple of weeks now under his management and will continue to exist for a long time. If you liked the project I guess this is a good moment to show you love and spread the word.

sachachua: Emacs chat intro

Sacha Chua — Tue, 23 Apr 2013 12:00:00 +0000

It turns out to be lots of fun to talk to other people about Emacs. You pick up all sorts of tips and interesting ideas that way.

One of the reasons why I do these chats is to help people get a sense of other people using Emacs. Now that I know John Wiegley sounds like when he’s excitedly talking about Emacs, it’s so much more fun reading his code. =) I’d love it if you told me a little bit about your story. Sharing how you got started with Emacs (what helped, what needs work) might give us ideas on how to make it easier for people to start. What was your “aha!” moment? What are the things you love, and what would you like to see improved? Walk me through your config, highlighting any quirky things you’ve done to make Emacs fit the way you work.

In addition to your story, you probably have lots of little tips that could save people time or make their Emacs lives better. No time to blog or screencast? Show us your favourite tricks in a chat, and I’ll take care of putting it up on the Net. It’s a quick way to get things out of your brain and onto the Internet. =)

If you have Emacs configuration or Lisp questions, ask away. I might be able to help, or someone listening might know the answer. We can spend some time digging into code or bouncing around ideas. I’m happy to help for free. If you come away with something incredibly useful, you can buy me a virtual mug of hot chocolate through PayPal or make a donation towards an awesome Emacs thing like EmacsWiki.org. =) It’s all cool.

I’d love to record and share our conversation so that more people can learn from it. If there are parts that you’d like blurred or not have recorded, or if you prefer to not have the conversation recorded at all, please tell me and I’ll be happy to accommodate that.

Want to talk about Emacs? Get in touch with me at sacha@sachachua.com!

Read the original or check out the comments on: Emacs chat intro (Sacha Chua's blog)

What the .emacs.d!?: my-misc.el-02

Magnar Sveen — Sun, 21 Apr 2013 00:04:27 +0000

Undo in region is one of those mind-blowing things about emacs. However, the region keeps jumping about when I use it. So I added this:

;; Keep region when undoing in region
(defadvice undo-tree-undo (around keep-region activate)
  (if (use-region-p)
      (let ((m (set-marker (make-marker) (mark)))
            (p (set-marker (make-marker) (point))))
        ad-do-it
        (goto-char p)
        (set-mark m)
        (set-marker p nil)
        (set-marker m nil))
    ad-do-it))

Now the region stays in place while I'm undoing.

Since I use undo-tree, that's what it advises, but I would guess it works the same for regular old undo too.

What the .emacs.d!?: project-defuns.el-01

Magnar Sveen — Fri, 19 Apr 2013 10:03:27 +0000

Where do you put your project specific settings?

(defmacro project-specifics (name &rest body)
  (declare (indent 1))
  `(progn
     (add-hook 'find-file-hook
               (lambda ()
                 (when (string-match-p ,name (buffer-file-name))
                   ,@body)))
     (add-hook 'dired-after-readin-hook
               (lambda ()
                 (when (string-match-p ,name (dired-current-directory))
                   ,@body)))))

(project-specifics "projects/zombietdd"
  (set (make-local-variable 'slime-js-target-url) "http://localhost:3000/")
  (ffip-local-patterns "*.js" "*.jade" "*.css" "*.json" "*.md"))

I created this macro to help me set up local vars. So in the example, any files in projects/zombietdd will see these slime-js-target-url and the find-file-in-projects patterns.

I keep these in a projects-folder to keep track of all the different settings for my projects.

Ivan Kanis: Vim Jump Cursor For Emacs

Ivan Kanis — Thu, 18 Apr 2013 00:00:00 +0000

jumpc.el implements the jump cursor feature found in vim.

A jump is added every time you insert a character on a different line.

Jumps are remembered in a jump list. With the C-o and C-i command you can go to cursor positions before older jumps, and back again. Thus you can move up and down the list.

Jumps are read and saved in the same configuration file as vim so you can switch back and forth between the two editors

It part of GNU ELPA so it's very easy to install.